1 files changed, 279 insertions, 0 deletions
diff --git a/kmail/messagecomposer.h b/kmail/messagecomposer.h
new file mode 100644
index 000000000..7d908bfac
--- /dev/null
+++ b/kmail/messagecomposer.h
@@ -0,0 +1,279 @@
+/*
+ *  messagecomposer.cpp
+ *
+ *  Copyright (c) 2004 Bo Thorsen <bo@sonofthor.dk>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ *  In addition, as a special exception, the copyright holders give
+ *  permission to link the code of this program with any edition of
+ *  the Qt library by Trolltech AS, Norway (or with modified versions
+ *  of Qt that use the same license as Qt), and distribute linked
+ *  combinations including the two.  You must obey the GNU General
+ *  Public License in all respects for all of the code used other than
+ *  Qt.  If you modify this file, you may extend this exception to
+ *  your version of the file, but you are not obligated to do so.  If
+ *  you do not wish to do so, delete this exception statement from
+ *  your version.
+ */
+
+#ifndef MESSAGECOMPOSER_H
+#define MESSAGECOMPOSER_H
+
+#include "kmmsgpart.h"
+#include "keyresolver.h"
+
+#include <qobject.h>
+#include <qvaluevector.h>
+
+#include <mimelib/mediatyp.h>
+#include <kleo/cryptobackend.h>
+#include <kpgp.h>
+
+#include <vector>
+
+class KMMessage;
+class KMComposeWin;
+
+class MessageComposerJob;
+class EncryptMessageJob;
+class SetLastMessageAsUnencryptedVersionOfLastButOne;
+
+namespace Kleo {
+  class KeyResolver;
+}
+
+namespace GpgME {
+  class Key;
+}
+
+namespace KPIM {
+  class Identity;
+}
+
+class MessageComposer : public QObject {
+  Q_OBJECT
+  friend class ::MessageComposerJob;
+  friend class ::EncryptMessageJob;
+  friend class ::SetLastMessageAsUnencryptedVersionOfLastButOne;
+
+public:
+  class KeyResolver;
+
+  MessageComposer( KMComposeWin* win, const char* name=0 );
+  ~MessageComposer();
+
+  /**
+   * Applies the user changes to the message object of the composer
+   * and signs/encrypts the message if activated. Returns FALSE in
+   * case of an error (e.g. if PGP encryption fails).
+   * If backgroundMode is true then no functions which might require
+   * user interaction (like signing/encrypting) are performed
+   */
+  void applyChanges( bool disableCrypto );
+
+  QString originalBCC() const { return mBcc; }
+
+  void setDisableBreaking( bool b ) { mDisableBreaking = b; }
+
+  const QValueVector<KMMessage*> & composedMessageList() const {
+    return mMessageList;
+  }
+
+  bool isPerformingSignOperation() const { return mPerformingSignOperation; }
+signals:
+  void done( bool );
+
+private:
+  void readFromComposeWin();
+
+  void adjustCryptFlags();
+
+  bool encryptWithChiasmus( const Kleo::CryptoBackend::Protocol * chiasmus,
+                            const QByteArray& body,
+                            QByteArray& resultData );
+  void chiasmusEncryptAllAttachments();
+  void composeChiasmusMessage( KMMessage& theMessage, Kleo::CryptoMessageFormat format );
+
+  // This is the composeMessage method
+  void composeMessage();
+  // And these two are the parts that should be run after job completions
+  void createUnencryptedMessageVersion();
+
+  /**
+   * Internal helper function called from applyChanges(void) to allow
+   * processing several messages (encrypted or unencrypted) based on
+   * the same composer content.
+   * That's useful for storing decrypted versions of messages which
+   * were sent in encrypted form.                  (khz, 2002/06/24)
+   */
+  void composeMessage( KMMessage& theMessage,
+                       bool doSign, bool doEncrypt,
+		       Kleo::CryptoMessageFormat format );
+  void continueComposeMessage( KMMessage& theMessage, bool doSign,
+                               bool doEncrypt,
+			       Kleo::CryptoMessageFormat format );
+
+  /**
+   * Called by composeMessage for inline-openpgp messages
+   */
+  void composeInlineOpenPGPMessage( KMMessage& theMessage,
+                                    bool doSign, bool doEncrypt );
+
+  /**
+   * Get message ready for sending or saving.
+   * This must be done _before_ signing and/or encrypting it.
+   */
+  QByteArray breakLinesAndApplyCodec();
+
+  /**
+   * Create a plain text version of a marked up mail for use as the plain
+   * part in a multipart/alternative mail.
+   */
+  QCString plainTextFromMarkup( const QString& markupText );
+
+  /**
+   * Get signature for a message (into mMessage).
+   * To build nice S/MIME objects signing and encoding must be separated.
+   */
+  void pgpSignedMsg( const QByteArray& cText, Kleo::CryptoMessageFormat f );
+  /**
+   * Get encrypted message.
+   * To build nice S/MIME objects signing and encrypting must be separate.
+   */
+  Kpgp::Result pgpEncryptedMsg( QByteArray& rEncryptedBody,
+                                const QByteArray& cText,
+                                const std::vector<GpgME::Key> & encryptionKeys,
+				Kleo::CryptoMessageFormat f );
+
+  /**
+   * Get signed & encrypted message.
+   * To build nice S/MIME objects signing and encrypting must be separate.
+   */
+  Kpgp::Result pgpSignedAndEncryptedMsg( QByteArray& rEncryptedBody,
+					 const QByteArray& cText,
+					 const std::vector<GpgME::Key> & signingKeys,
+					 const std::vector<GpgME::Key> & encryptionKeys,
+					 Kleo::CryptoMessageFormat f );
+
+  /**
+   * Check for expiry of various certificates.
+   */
+  bool checkForEncryptCertificateExpiry( const QString& recipient,
+                                         const QCString& certFingerprint );
+
+  /**
+   * Build a MIME object (or a flat text resp.) based upon
+   * structuring information returned by a crypto plugin that was
+   * called via pgpSignedMsg() (or pgpEncryptedMsg(), resp.).
+   *
+   * NOTE: The c string representation of the MIME object (or the
+   *       flat text, resp.) is returned in resultingPart, so just
+   *       use this string as body text of the surrounding MIME object.
+   *       This string *is* encoded according to contentTEncClear
+   *       and thus should be ready for being sent via SMTP.
+   */
+  bool processStructuringInfo( const QString bugURL,
+                               const QString contentDescriptionClear,
+                               const QCString contentTypeClear,
+                               const QCString contentSubtypeClear,
+                               const QCString contentDispClear,
+                               const QCString contentTEncClear,
+                               const QByteArray& bodytext,
+                               const QString contentDescriptionCiph,
+                               const QByteArray& ciphertext,
+                               KMMessagePart& resultingPart,
+			       bool signing, Kleo::CryptoMessageFormat format );
+
+  void encryptMessage( KMMessage* msg, const Kleo::KeyResolver::SplitInfo & si,
+                       bool doSign, bool doEncrypt,
+                       KMMessagePart newBodyPart,
+		       Kleo::CryptoMessageFormat format );
+
+  void addBodyAndAttachments( KMMessage* msg, const Kleo::KeyResolver::SplitInfo & si,
+                              bool doSign, bool doEncrypt,
+                              const KMMessagePart& ourFineBodyPart,
+                              Kleo::CryptoMessageFormat format );
+
+private slots:
+  void slotDoNextJob();
+
+private:
+  void doNextJob();
+  void emitDone( bool ok );
+
+  int encryptionPossible( const QStringList & recipients, bool openPGP );
+  bool determineWhetherToSign( bool doSignCompletely );
+  bool determineWhetherToEncrypt( bool doEncryptCompletely );
+  void markAllAttachmentsForSigning( bool sign );
+  void markAllAttachmentsForEncryption( bool enc );
+
+  KMComposeWin* mComposeWin;
+  MessageComposerJob * mCurrentJob;
+  KMMessage* mReferenceMessage;
+  QValueVector<KMMessage*> mMessageList;
+
+  Kleo::KeyResolver * mKeyResolver;
+
+  QCString mSignCertFingerprint;
+
+  struct Attachment {
+    Attachment( KMMessagePart * p=0, bool s=false, bool e=false )
+      : part( p ), sign( s ), encrypt( e ) {}
+    KMMessagePart * part;
+    bool sign;
+    bool encrypt;
+  };
+  QValueVector<Attachment> mAttachments;
+
+  QString mPGPSigningKey, mSMIMESigningKey;
+  bool mUseOpportunisticEncryption;
+  bool mSignBody, mEncryptBody;
+  bool mSigningRequested, mEncryptionRequested;
+  bool mDoSign, mDoEncrypt;
+  unsigned int mAllowedCryptoMessageFormats;
+  bool mDisableCrypto;
+  bool mDisableBreaking;
+  QString mBcc;
+  QStringList mTo, mCc, mBccList;
+  bool mDebugComposerCrypto;
+  bool mAutoCharset;
+  QCString mCharset;
+  bool mIsRichText;
+  uint mIdentityUid;
+  bool mRc; // Set this to false, if something fails during the processes
+  bool mHoldJobs; // Don't run the next job yet
+
+  QByteArray mText; // textual representation of the message text, encoded
+  unsigned int mLineBreakColumn; // used for line breaking
+
+  // These are the variables of the big composeMessage(X,Y,Z) message
+  KMMessagePart* mNewBodyPart;
+  QByteArray mSignature;
+
+  QByteArray mEncodedBody; // Only needed if signing and/or encrypting
+  bool mEarlyAddAttachments, mAllAttachmentsAreInBody;
+  KMMessagePart mOldBodyPart;
+  int mPreviousBoundaryLevel;
+
+  // The boundary is saved for later addition into mp/a body
+  DwString  mSaveBoundary;
+  QCString mMultipartMixedBoundary;
+
+  QValueList<MessageComposerJob*> mJobs;
+  bool mEncryptWithChiasmus;
+  bool mPerformingSignOperation;
+};
+
+#endif /* MESSAGECOMPOSER_H */