kmcomposewin.h

/*
 * KMComposeWin Header File
 * Author: Markus Wuebben <markus.wuebben@kde.org>
 */
#ifndef __KMComposeWin
#define __KMComposeWin
 
#ifndef KDE_USE_FINAL
# ifndef REALLY_WANT_KMCOMPOSEWIN_H
#  error Do not include kmcomposewin.h anymore. Include composer.h instead.
# endif
#endif
 
#include "composer.h"
#include "messagesender.h"
 
#include <set>
 
#include <tqlabel.h>
#include <tqlistview.h>
 
#include <tqcheckbox.h>
#include <tqpushbutton.h>
#include <tqclipboard.h>
#include <tqpalette.h>
#include <tqfont.h>
#include <tqptrlist.h>
#include <tqvaluevector.h>
#include <tqsplitter.h>
 
#include <tdeio/job.h>
#include <tdeglobalsettings.h>
#include <keditcl.h>
#include <ktempdir.h>
 
#include "mailcomposerIface.h"
#include "accountmanager.h"
 
#include <libtdepim/addresseelineedit.h>
#include <mimelib/mediatyp.h>
 
#include <kleo/enum.h>
 
class TQCloseEvent;
class TQComboBox;
class TQFrame;
class TQGridLayout;
class TQListView;
class TQPopupMenu;
class TQPushButton;
class TQCString;
class TDECompletion;
class KMEdit;
class KMComposeWin;
class KMFolderComboBox;
class KMFolder;
class KMMessage;
class KMMessagePart;
class TDEProcess;
class KDirWatch;
class TDESelectAction;
class TDEFontAction;
class TDEFontSizeAction;
class TDESelectAction;
class KStatusBar;
class TDEAction;
class TDEToggleAction;
class KTempFile;
class TDEToolBar;
class TDEToggleAction;
class TDESelectColorAction;
class KURL;
class TDERecentFilesAction;
class SpellingFilter;
class MessageComposer;
class RecipientsEditor;
class KMLineEdit;
class KMLineEditSpell;
class KMAtmListViewItem;
class SnippetWidget;
 
namespace KPIM {
  class IdentityCombo;
  class Identity;
}
 
namespace KMail {
  class AttachmentListView;
  class DictionaryComboBox;
  class EditorWatcher;
}
 
namespace GpgME {
  class Error;
}
 
//-----------------------------------------------------------------------------
class KMComposeWin : public KMail::Composer, public MailComposerIface
{
  TQ_OBJECT
  
  friend class ::KMEdit;
  friend class ::MessageComposer;
 
private: // mailserviceimpl, kmkernel, kmcommands, callback, kmmainwidget
  KMComposeWin( KMMessage* msg=0, uint identity=0 );
  ~KMComposeWin();
public:
  static Composer * create( KMMessage * msg = 0, uint identity = 0 );
 
  MailComposerIface * asMailComposerIFace() { return this; }
  const MailComposerIface * asMailComposerIFace() const { return this; }
 
public: // mailserviceimpl
  void send(int how);
  void addAttachmentsAndSend(const KURL::List &urls, const TQString &comment, int how);
  void addAttachment(KURL url,TQString comment);
  void addAttachment(const TQString &name,
                    const TQCString &cte,
                    const TQByteArray &data,
                    const TQCString &type,
                    const TQCString &subType,
                    const TQCString &paramAttr,
                    const TQString &paramValue,
                    const TQCString &contDisp);
public: // kmcommand
  void setBody (TQString body);
 
private:
  virtual bool event(TQEvent *e);
 
  void readColorConfig();
 
   void writeConfig(void);
 
   void verifyWordWrapLengthIsAdequate(const TQString&);
 
public: // kmkernel, kmcommands, callback
   void setMsg(KMMessage* newMsg, bool mayAutoSign=true,
           bool allowDecryption=false, bool isModified=false);
 
   void disableWordWrap();
 
  void disableRecipientNumberCheck();
 
  void disableForgottenAttachmentsCheck();
 
  void ignoreStickyFields();
 
   bool isComposing() const { return mComposer != 0; }
 
private: // kmedit
   KMMessage* msg() const { return mMsg; }
 
public: // kmkernel
  void setAutoSaveFilename( const TQString & filename );
 
private:
  bool isModified() const;
 
  void setModified( bool modified );
 
public: // kmkernel, callback
   inline void setAutoDelete(bool f) { mAutoDeleteMsg = f; }
 
  void setAutoDeleteWindow( bool f );
 
public: // kmcommand
   void setFolder(KMFolder* aFolder) { mFolder = aFolder; }
public: // kmkernel, kmcommand, mailserviceimpl
   void setCharset(const TQCString& aCharset, bool forceDefault = false);
 
public: // kmcommand
   void setReplyFocus( bool hasMessage = true );
 
   void setFocusToSubject();
 
private:
   bool inlineSigningEncryptionSelected();
 
   static TQString prettyMimeType( const TQString& type );
    TQString quotePrefixName() const;
 
private: // kmedit:
  KMLineEditSpell *sujectLineWidget() const { return mEdtSubject;}
  void setSubjectTextWasSpellChecked( bool _spell ) {
    mSubjectTextWasSpellChecked = _spell;
  }
  bool subjectTextWasSpellChecked() const { return mSubjectTextWasSpellChecked; }
 
  void paste( TQClipboard::Mode mode );
 
public: // callback
  void setSigningAndEncryptionDisabled( bool v )
  {
    mSigningAndEncryptionExplicitlyDisabled = v;
  }
 
private slots:
  void polish();
  void slotPrint();
  void slotAttachFile();
  void slotInsertRecentFile(const KURL&);
  void slotAttachedFile(const KURL&);
public slots: // kmkernel, callback
  void slotSendNow();
private slots:
  void slotSendNowVia( int item );
  void slotSendLater();
  void slotSendLaterVia( int item );
 
  void getTransportMenu();
 
  void slotSaveDraft();
  void slotSaveTemplate();
  void slotNewComposer();
  void slotNewMailReader();
  void slotClose();
  void slotHelp();
 
  void slotFind();
  void slotSearchAgain();
  void slotReplace();
  void slotUndo();
  void slotRedo();
  void slotCut();
  void slotCopy();
  void slotPasteClipboard();
  void slotPasteClipboardAsQuotation();
  void slotPasteClipboardAsAttachment();
  void slotAddQuotes();
  void slotRemoveQuotes();
  void slotAttachPNGImageData(const TQByteArray &image);
 
  void slotMarkAll();
 
  void slotFolderRemoved(KMFolder*);
 
  void slotEditDone( KMail::EditorWatcher* watcher );
 
public slots: // kmkernel
  void slotSetAlwaysSend( bool bAlwaysSend );
private slots:
  void slotUpdateFont();
 
  void slotAddrBook();
  void slotInsertFile();
 
  void slotSetCharset();
  void slotSpellcheck();
  void slotSpellcheckConfig();
  void slotSubjectTextSpellChecked();
 
  void slotSelectCryptoModule( bool init = false );
 
  void slotStatusMessage(const TQString &message);
  void slotEditToolbars();
  void slotUpdateToolbars();
  void slotEditKeys();
  void readConfig( bool reload = false );
  void slotUpdWinTitle(const TQString& );
 
  void slotEncryptToggled(bool);
 
  void slotSignToggled(bool);
 
public slots: // kmkernel, callback
  void slotWordWrapToggled(bool);
 
private slots:
  void slotAppendSignature();
 
  void slotPrependSignature();
 
  void slotInsertSignatureAtCursor();
 
  void slotInsertMyPublicKey();
 
  void slotInsertPublicKey();
 
  void slotUpdateAttachActions();
 
  void slotAttachPopupMenu(TQListViewItem *, const TQPoint &, int);
 
  int currentAttachmentNum();
 
  void slotAttachOpen();
  void slotAttachView();
  void slotAttachRemove();
  void slotAttachSave();
  void slotAttachProperties();
  void slotAttachOpenWith();
  void slotAttachEdit();
  void slotAttachEditWith();
  void slotAttachmentDragStarted();
 
  void slotAddrBookTo();
  void slotAddrBookFrom();
  void slotAddrBookReplyTo();
 
  void slotCleanSpace();
 
  void slotToggleMarkup();
  void toggleMarkup(bool markup);
  void htmlToolBarVisibilityChanged( bool visible );
 
//  void slotSpellConfigure();
  void slotSpellcheckDone(int result);
  void slotSpellcheckDoneClearStatus();
 
public slots: // kmkernel
  void autoSaveMessage();
 
private slots:
  void updateCursorPosition();
 
  void slotView();
 
  void slotIdentityChanged(uint);
 
  void slotAttachFileData(TDEIO::Job *, const TQByteArray &);
  void slotAttachFileResult(TDEIO::Job *);
 
  void slotListAction(const TQString &);
  void slotFontAction(const TQString &);
  void slotSizeAction(int);
  void slotAlignLeft();
  void slotAlignCenter();
  void slotAlignRight();
  void slotTextBold();
  void slotTextItalic();
  void slotTextUnder();
  void slotFormatReset();
  void slotTextColor();
  void fontChanged( const TQFont & );
  void alignmentChanged( int );
 
public: // kmkernel, attachmentlistview
  bool addAttach(const KURL url);
 
public: // kmcommand
  void addAttach(const KMMessagePart* msgPart);
 
private:
  const KPIM::Identity & identity() const;
  uint identityUid() const;
  Kleo::CryptoMessageFormat cryptoMessageFormat() const;
  bool encryptToSelf() const;
 
signals:
  void applyChangesDone( bool );
  void attachmentAdded( const KURL&, bool success );
 
private:
  void applyChanges( bool dontSignNorEncrypt, bool dontDisable=false );
 
  void rethinkFields(bool fromslot=false);
 
  TQWidget *connectFocusMoving( TQWidget *prev, TQWidget *next );
 
  void rethinkHeaderLine( int aValue, int aMask, int& aRow,
                          TQLabel* aLbl,
                          TQLineEdit* aEdt, TQPushButton* aBtn = 0,
                          const TQString &toolTip = TQString(),
                          const TQString &whatsThis = TQString() );
 
  void rethinkHeaderLine( int value, int mask, int& row,
                          TQLabel* lbl, TQComboBox* cbx, TQCheckBox *chk );
 
  bool checkRecipientNumber() const;
 
 
  bool checkTransport() const;
 
  void setupActions();
  void setupStatusBar();
  void setupEditor();
 
 
  TQString subject() const;
  TQString to() const;
  TQString cc() const;
  TQString bcc() const;
  TQString from() const;
  TQString replyTo() const;
 
  void setFcc( const TQString &idString );
 
  virtual bool queryClose ();
  virtual bool queryExit ();
 
  void openAttach( int index, bool with );
 
  void viewAttach( int index );
 
  void editAttach( int index, bool openWith );
 
   void removeAttach(const TQString &url);
   void removeAttach(int idx);
 
   void msgPartToItem(const KMMessagePart* msgPart, KMAtmListViewItem *lvi,
        bool loadDefaults = true );
 
  void addrBookSelInto();
 
  void addrBookSelIntoOld();
  void addrBookSelIntoNew();
 
private:
  void setEncryption( bool encrypt, bool setByUser = false );
 
  void setSigning( bool sign, bool setByUser = false );
 
  bool userForgotAttachment();
 
  bool encryptFlagOfAttachment(int idx);
 
  bool signFlagOfAttachment(int idx);
 
 
  static void decryptOrStripOffCleartextSignature( TQCString& );
 
  bool saveDraftOrTemplate( const TQString &folderName, KMMessage *msg );
 
  enum SaveIn { None, Drafts, Templates };
  void doSend( KMail::MessageSender::SendMethod method=KMail::MessageSender::SendDefault,
               KMComposeWin::SaveIn saveIn = KMComposeWin::None );
 
  int autoSaveInterval() const;
 
  void initAutoSave();
 
  void updateAutoSave();
 
  void cleanupAutoSave();
 
  static bool validateAddresses( TQWidget * parent, const TQString & addresses );
 
  void setTransport( const TQString & transport );
 
  enum SignaturePlacement { Append, Prepend, AtCursor };
 
  void insertSignature( SignaturePlacement placement = Append );
private slots:
    void compressAttach(int idx);
    void uncompressAttach(int idx);
    void editorFocusChanged(bool gained);
    void recipientEditorSizeHintChanged();
    void setMaximumHeaderSize();
 
private:
  TQWidget   *mMainWidget;
  TQComboBox *mTransport;
  KMail::DictionaryComboBox *mDictionaryCombo;
  KPIM::IdentityCombo    *mIdentity;
  KMFolderComboBox *mFcc;
  KMLineEdit *mEdtFrom, *mEdtReplyTo, *mEdtTo, *mEdtCc, *mEdtBcc;
  KMLineEditSpell *mEdtSubject;
  TQLabel    *mLblIdentity, *mLblTransport, *mLblFcc;
  TQLabel    *mLblFrom, *mLblReplyTo, *mLblTo, *mLblCc, *mLblBcc, *mLblSubject;
  TQLabel    *mDictionaryLabel;
  TQCheckBox *mBtnIdentity, *mBtnDictionary, *mBtnTransport, *mBtnFcc;
  TQPushButton *mBtnTo, *mBtnCc, *mBtnBcc, /* *mBtnFrom, */ *mBtnReplyTo;
  bool mSpellCheckInProgress;
  bool mDone;
  bool mAtmModified;
  TQListViewItem *mAtmSelectNew;
 
  KMEdit* mEditor;
  TQGridLayout* mGrid;
  KMMessage *mMsg;
  TQValueVector<KMMessage*> mComposedMessages;
  KMail::AttachmentListView* mAtmListView;
  int mAtmColEncrypt;
  int mAtmColSign;
  int mAtmColCompress;
  int mAtmEncryptColWidth;
  int mAtmSignColWidth;
  int mAtmCompressColWidth;
  TQPtrList<TQListViewItem> mAtmItemList;
  TQPtrList<KMMessagePart> mAtmList;
  TQPopupMenu *mAttachMenu;
  int mOpenId, mOpenWithId, mViewId, mRemoveId, mSaveAsId, mPropertiesId, mEditId, mEditWithId;
  bool mAutoDeleteMsg;
  bool mSigningAndEncryptionExplicitlyDisabled;
  bool mLastSignActionState, mLastEncryptActionState;
  bool mLastIdentityHasSigningKey, mLastIdentityHasEncryptionKey;
  KMFolder *mFolder;
  long mShowHeaders;
  bool mConfirmSend;
  bool mDisableBreaking; // Move
  int mNumHeaders;
  bool mUseHTMLEditor;
  bool mHtmlMarkup;
  TQFont mBodyFont, mFixedFont;
  TQPtrList<KTempFile> mAtmTempList;
  TQPalette mPalette;
  uint mId;
  TQString mOldSigText;
 
  TDEAction *mAttachPK, *mAttachMPK,
          *mAttachRemoveAction, *mAttachSaveAction, *mAttachPropertiesAction,
          *mPasteQuotation, *mAddQuoteChars, *mRemQuoteChars;
  TDERecentFilesAction *mRecentAction;
 
  TDEAction *mAppendSignatureAction, *mPrependSignatureAction, *mInsertSignatureAction;
 
  TDEToggleAction *mSignAction, *mEncryptAction, *mRequestMDNAction;
  TDEToggleAction *mUrgentAction, *mAllFieldsAction, *mFromAction;
  TDEToggleAction *mReplyToAction, *mToAction, *mCcAction, *mBccAction;
  TDEToggleAction *mSubjectAction;
  TDEToggleAction *mIdentityAction, *mTransportAction, *mFccAction;
  TDEToggleAction *mWordWrapAction, *mFixedFontAction, *mAutoSpellCheckingAction;
  TDEToggleAction *mDictionaryAction, *mSnippetAction;
 
  TDESelectAction *listAction;
  TDEFontAction *fontAction;
  TDEFontSizeAction *fontSizeAction;
  TDEToggleAction *alignLeftAction, *alignCenterAction, *alignRightAction;
  TDEToggleAction *textBoldAction, *textItalicAction, *textUnderAction;
  TDEToggleAction *plainTextAction, *markupAction;
  TDEAction *actionFormatColor, *actionFormatReset;
  TDEAction *mHtmlToolbar;
 
  TDESelectAction *mEncodingAction;
  TDESelectAction *mCryptoModuleAction;
 
  TQCString mCharset;
  TQCString mDefCharset;
  TQStringList mCharsets;
  bool mAutoCharset;
 
  bool mAlwaysSend;
 
  TQStringList mFolderNames;
  TQValueList<TQGuardedPtr<KMFolder> > mFolderList;
  TQMap<TDEIO::Job*, KURL> mAttachJobs;
  KURL::List mAttachFilesPending;
  int mAttachFilesSend;
 
private:
  // helper method for slotInsert(My)PublicKey()
  void startPublicKeyExport();
  bool canSignEncryptAttachments() const {
    return cryptoMessageFormat() != Kleo::InlineOpenPGPFormat;
  }
 
  bool mSubjectTextWasSpellChecked;
 
  TQString addQuotesToText( const TQString &inputText );
  TQString removeQuotesFromText( const TQString &inputText );
  // helper method for rethinkFields
  int calcColumnWidth(int which, long allShowing, int width);
 
private slots:
  void slotCompletionModeChanged( TDEGlobalSettings::Completion );
  void slotConfigChanged();
 
  void slotComposerDone( bool );
 
  void slotContinueDoSend( bool );
  void slotContinuePrint( bool );
  void slotContinueAutoSave();
 
  void slotEncryptChiasmusToggled( bool );
 
  void slotPublicKeyExportResult( const GpgME::Error & err, const TQByteArray & keydata );
 
  void slotAutoSpellCheckingToggled(bool);
 
  void slotUpdateSignatureActions();
 
  void slotUpdateSignatureAndEncrypionStateIndicators();
private:
  TQColor mForeColor,mBackColor;
  TQFont mSaveFont;
  TQSplitter *mHeadersToEditorSplitter;
  TQWidget* mHeadersArea;
  TQSplitter *mSplitter;
  TQSplitter *mSnippetSplitter;
  struct atmLoadData
  {
    KURL url;
    TQByteArray data;
    bool insert;
    TQCString encoding;
  };
  TQMap<TDEIO::Job *, atmLoadData> mMapAtmLoadData;
 
  // These are for passing on methods over the applyChanges calls
  KMail::MessageSender::SendMethod mSendMethod;
  KMComposeWin::SaveIn mSaveIn;
 
  TDEToggleAction *mEncryptChiasmusAction;
  bool mEncryptWithChiasmus;
 
  // This is the temporary object that constructs the message out of the
  // window
  MessageComposer* mComposer;
 
  // Temp var for slotPrint:
  bool mMessageWasModified;
 
  // Temp var for slotInsert(My)PublicKey():
  TQString mFingerprint;
 
  // Temp ptr for saving image from clipboard
  KTempDir *mTempDir;
 
  bool mClassicalRecipients;
 
  RecipientsEditor *mRecipientsEditor;
  int mLabelWidth;
 
  TQTimer *mAutoSaveTimer;
  TQString mAutoSaveFilename;
  int mLastAutoSaveErrno; // holds the errno of the last try to autosave
 
  TQPopupMenu *mActNowMenu;
  TQPopupMenu *mActLaterMenu;
 
  TQMap<KMail::EditorWatcher*, KMMessagePart*> mEditorMap;
  TQMap<KMail::EditorWatcher*, KTempFile*> mEditorTempFiles;
 
  TQLabel *mSignatureStateIndicator;
  TQLabel *mEncryptionStateIndicator;
 
  SnippetWidget *mSnippetWidget;
  std::set<KTempDir*> mTempDirs;
 
  bool mPreserveUserCursorPosition;
 
  bool mPreventFccOverwrite;
  bool mCheckForRecipients;
  bool mCheckForForgottenAttachments;
  bool mIgnoreStickyFields;
};
 
#endif