kmheaders.h

#ifndef __KMHEADERS
#define __KMHEADERS
 
#include "kmime_util.h"
#include "headeritem.h"
using KMail::SortCacheItem;
using KMail::HeaderItem;
 
#include <tdelistview.h>
#include <kfoldertree.h> // for KPaintInfo
#include <kmmsgbase.h>   // for KMMsgStatus
 
#include <tqwidget.h>
#include <tqstrlist.h>
#include <tqmemarray.h>
#include <tqmap.h>
#include <tqdragobject.h>
#include <tqdict.h>
#include <tqguardedptr.h>
 
class KMFolder;
class KMMessage;
class KMMsgBase;
class KMCommand;
class KMMainWidget;
class TDEPopupMenu;
class TQPalette;
class TQPixmap;
class TQIconSet;
class TQDateTime;
 
typedef TQPtrList<KMMsgBase> KMMessageList;
typedef TQValueList<TQ_UINT32> SerNumList;
typedef TQMap<int,KMFolder*> KMMenuToFolder;
enum NestingPolicy { AlwaysOpen = 0, DefaultOpen, DefaultClosed, OpenUnread };
 
 
#define KMAIL_SORT_VERSION 1012
#define KMAIL_SORT_FILE(x) x->indexLocation() + ".sorted"
#define KMAIL_SORT_HEADER "## KMail Sort V%04d\n\t"
#define KMAIL_MAGIC_HEADER_OFFSET 21 //strlen(KMAIL_SORT_HEADER)
#define KMAIL_MAX_KEY_LEN 16384
#define KMAIL_RESERVED 3
 
class KMHeaders : public TDEListView
{
  TQ_OBJECT
  
 
  friend class ::KMail::HeaderItem; // For easy access to the pixmaps
 
public:
  KMHeaders(KMMainWidget *owner, TQWidget *parent=0, const char *name=0);
  virtual ~KMHeaders();
 
  virtual void setFolder(KMFolder *, bool forceJumpToUnread = false);
 
  KMFolder* folder(void) { return mFolder; }
 
  void refreshNestedState(void);
 
  virtual void setCurrentMsg(int msgId);
 
  TQPtrList<TQListViewItem> currentThread() const;
 
  virtual void setThreadStatus(KMMsgStatus status, bool toggle=false);
 
  /* Set message status to read if it is new, or unread */
  virtual void setMsgRead(int msgId);
 
  virtual void setMsgStatus(KMMsgStatus status, bool toggle=false);
  virtual void deleteMsg();
  virtual void applyFiltersOnMsg();
  virtual void undo();
  virtual bool canUndo() const;
  virtual HeaderItem * prepareMove( int *contentX, int *contentY );
  virtual void finalizeMove( HeaderItem *item, int contentX, int contentY );
 
  virtual void moveMsgToFolder( KMFolder* destination,
                                bool askForConfirmation=true );
 
  virtual void copyMsgToFolder(KMFolder* destination,
                               KMMessage* aMsg = 0);
 
  virtual void clearSelectableAndAboutToBeDeleted(TQ_UINT32 serNum);
  virtual KMMessageList* selectedMsgs(bool toBeDeleted = false);
 
  TQValueList<int> selectedItems();
 
  TQValueList<TQ_UINT32> selectedSernums();
 
  TQValueList<TQ_UINT32> selectedVisibleSernums();
 
  int indexOfGetMsg (void) const { return getMsgIndex; }
 
  KMMainWidget* owner(void) const { return mOwner; }
 
  const KPaintInfo *paintInfo(void) const { return &mPaintInfo; }
 
  virtual void readConfig(void);
 
  virtual void readColorConfig(void);
 
  void restoreColumnLayout( TDEConfig *config, const TQString &group );
 
  virtual KMMessage* currentMsg();
  virtual HeaderItem* currentHeaderItem();
  virtual int currentItemIndex();
  virtual void setCurrentItemByIndex( int msgIdx );
  void setCurrentItemBySerialNum( unsigned long serialNum );
  virtual int topItemIndex();
  virtual void setTopItemByIndex( int aMsgIdx );
  virtual void setNestedOverride( bool override );
  virtual void setSubjectThreading( bool subjThreading );
  virtual void setOpen ( TQListViewItem *, bool );
 
  NestingPolicy getNestingPolicy() const { return nestingPolicy; }
  bool isThreaded() const {
    return mNested != mNestedOverride; // xor
  }
 
  virtual int findUnread(bool findNext, int startAt=-1, bool onlyNew = false, bool acceptCurrent = false);
 
  void highlightMessage(TQListViewItem*, bool markitread);
  void highlightCurrentThread();
 
  static TQString fancyDate( time_t otime );
 
  bool noRepaint;
 
  // filter events for popup
  bool eventFilter ( TQObject *o, TQEvent *e );
 
  const KMMsgBase * getMsgBaseForItem( const TQListViewItem *item ) const;
 
  // accessors
  TQFont newFont() const { return mNewFont; }
  TQFont unreadFont() const { return mUnreadFont; }
  TQFont importantFont() const { return mImportantFont; }
  TQFont todoFont() const { return mTodoFont; }
  TQFont dateFont() const { return mDateFont; }
 
  void setCopiedMessages( const TQValueList<TQ_UINT32> &msgs, bool move );
 
  bool isMessageCut( TQ_UINT32 serNum ) const;
 
  virtual void writeConfig(void);
 
signals:
  void selected(KMMessage *);
  void activated(KMMessage *);
  void maybeDeleting();
  void messageListUpdated();
 
  void msgAddedToListView( TQListViewItem* );
 
public slots:
  void selectMessage(TQListViewItem*);
  void highlightMessage(TQListViewItem*);
  void slotRMB();
  void msgHeaderChanged(KMFolder *folder, int msgId);
  void msgChanged();
  void folderCleared();
  void folderClosed();
  void msgAdded(int);
  void msgRemoved( int, TQString );
  void nextMessage();
  void selectNextMessage();
  void prevMessage();
  void selectPrevMessage();
  bool nextUnreadMessage(bool acceptCurrent = false);
  bool prevUnreadMessage();
  void incCurrentMessage();
  void decCurrentMessage();
  void selectCurrentMessage();
  void slotNoDrag();
  void resetCurrentTime();
 
  void reset();
 
  void slotExpandOrCollapseThread( bool expand );
  void slotExpandOrCollapseAllThreads( bool expand );
 
  virtual void ensureCurrentItemVisible();
 
  virtual void setSelected(TQListViewItem *item, bool selected);
 
  void setSelectedByIndex(TQValueList<int> items, bool selected);
 
  void slotToggleColumn(int id, int mode = -1);
 
  void setFolderInfoStatus();
 
protected:
  static TQPixmap *pixNew, *pixUns, *pixDel, *pixRead, *pixRep, *pixSent,
    *pixQueued, *pixFwd, *pixFlag, *pixWatched, *pixIgnored, *pixSpam, *pixHam,
    *pixFullySigned, *pixPartiallySigned, *pixUndefinedSigned,
    *pixFullyEncrypted, *pixPartiallyEncrypted, *pixUndefinedEncrypted,
    *pixFiller, *pixEncryptionProblematic,
    *pixSignatureProblematic, *pixAttachment, *pixInvitation,
    *pixReadFwd, *pixReadReplied, *pixReadFwdReplied, *pixTodo;
 
  virtual bool event(TQEvent *e);
 
  virtual void paintEmptyArea( TQPainter * p, const TQRect & rect );
 
  void makeHeaderVisible();
 
  void findUnreadAux( HeaderItem*&, bool &, bool, bool );
 
  virtual int firstSelectedMsg() const;
 
  virtual void readFolderConfig(void);
 
  virtual void writeFolderConfig(void);
 
  virtual void contentsMousePressEvent(TQMouseEvent*);
  virtual void contentsMouseReleaseEvent(TQMouseEvent* e);
  virtual void keyPressEvent( TQKeyEvent * e );
 
  virtual void setSorting( int column, bool ascending = true);
 
  void contentsMouseMoveEvent( TQMouseEvent *e );
 
  void styleChange( TQStyle& oldStyle );
 
  void setStyleDependantFrameWidth();
 
protected slots:
  virtual void moveSelectedToFolder( int menuId );
  virtual void copySelectedToFolder( int menuId );
  virtual int slotFilterMsg( KMMessage * );
  void dirtySortOrder(int);
  void rightButtonPressed( TQListViewItem *, const TQPoint &, int );
 
private slots:
  void slotMoveCompleted( KMCommand * );
 
  void copyMessages();
  void cutMessages();
  void pasteMessages();
 
  void updateActions();
 
private:
  virtual void updateMessageList( bool set_selection=false,
      bool forceJumpToUnread = false );
 
  TQGuardedPtr<KMFolder> mFolder;
  KMMainWidget* mOwner;
  int mTopItem;
  int mCurrentItem;
  unsigned long mCurrentItemSerNum;
  TQMemArray<HeaderItem*> mItems;
 
  // ===== threading and sorting ==========
  bool mNested, mNestedOverride, mSubjThreading;
  NestingPolicy nestingPolicy;
  int mSortCol;
  bool mSortDescending;
  bool mIgnoreSortOrderChanges;
 
  struct {
      uint ascending : 1;
      uint dirty : 1;
      short column;
      uint fakeSort : 1;
      uint removed : 1;
  } mSortInfo;
 
 
  TQDict< SortCacheItem > mSortCacheItems;
  TQDict< TQPtrList< SortCacheItem > > mSubjectLists;
  TQPtrList<HeaderItem> mImperfectlyThreadedList;
 
  void printSubjectThreadingTree( );
  void printThreadingTree( );
  void buildThreadingTree( TQMemArray<SortCacheItem *> sortCache );
  void buildSubjectThreadingTree( TQMemArray<SortCacheItem *> sortCache );
  SortCacheItem* findParent(SortCacheItem *item);
  SortCacheItem* findParentBySubject(SortCacheItem *item);
  SortCacheItem* mRoot; // used to represent the list view itself while threading
 
  void appendItemToSortFile(HeaderItem *);
  bool writeSortOrder();
  bool readSortOrder( bool set_selection = false,
      bool forceJumpToUnread = false );
 
  int getMsgIndex;
  bool getMsgMulti;
  HeaderItem* getMsgItem;
  KMMessageList mSelMsgBaseList;
  HeaderItem* mPrevCurrent;
 
  KPaintInfo mPaintInfo;
 
  TQFont mNewFont, mUnreadFont, mImportantFont, mDateFont,mTodoFont;
 
  static TQIconSet *up, *down;
  KMMenuToFolder mMenuToFolder;
 
  bool mMousePressed;
  TQPoint mPressPos;
 
  KMime::DateFormatter mDate;
  bool mReaderWindowActive;
 
  TDEPopupMenu* mPopup;
 
  // copied messages
  TQValueList<TQ_UINT32> mCopiedMessages;
  bool mMoveMessages;
}; // class
#endif