Skip to main content :: ::

KDE PIM API Reference

:: Skip to Link Menu

/ API Reference / kmail

kmail kmheaders.cpp Go to the documentation of this file. // -*- mode: C++; c-file-style: "gnu" -*- // kmheaders.cpp #include <config.h> #include "kmheaders.h" #include "headeritem.h" using KMail::HeaderItem; #include "kcursorsaver.h" #include "kmcommands.h" #include "kmmainwidget.h" #include "kmfiltermgr.h" #include "undostack.h" #include "kmmsgdict.h" #include "kmdebug.h" #include "kmfoldertree.h" #include "folderjob.h" using KMail::FolderJob; #include "actionscheduler.h" using KMail::ActionScheduler; #include "messagecopyhelper.h" using KMail::MessageCopyHelper; #include "broadcaststatus.h" using KPIM::BroadcastStatus; #include "progressmanager.h" using KPIM::ProgressManager; using KPIM::ProgressItem; #include <maillistdrag.h> #include "globalsettings.h" using namespace KPIM; #include "messageactions.h" #include <kapplication.h> #include <kaccelmanager.h> #include <kglobalsettings.h> #include <kmessagebox.h> #include <kiconloader.h> #include <kpopupmenu.h> #include <kimageio.h> #include <kconfig.h> #include <klocale.h> #include <kdebug.h> #include <qbuffer.h> #include <qeventloop.h> #include <qfile.h> #include <qheader.h> #include <qptrstack.h> #include <qptrqueue.h> #include <qpainter.h> #include <qtextcodec.h> #include <qstyle.h> #include <qlistview.h> #include <mimelib/enum.h> #include <mimelib/field.h> #include <mimelib/mimepp.h> #include <stdlib.h> #include <errno.h> #include "textsource.h" QPixmap* KMHeaders::pixNew = 0; QPixmap* KMHeaders::pixUns = 0; QPixmap* KMHeaders::pixDel = 0; QPixmap* KMHeaders::pixRead = 0; QPixmap* KMHeaders::pixRep = 0; QPixmap* KMHeaders::pixQueued = 0; QPixmap* KMHeaders::pixTodo = 0; QPixmap* KMHeaders::pixSent = 0; QPixmap* KMHeaders::pixFwd = 0; QPixmap* KMHeaders::pixFlag = 0; QPixmap* KMHeaders::pixWatched = 0; QPixmap* KMHeaders::pixIgnored = 0; QPixmap* KMHeaders::pixSpam = 0; QPixmap* KMHeaders::pixHam = 0; QPixmap* KMHeaders::pixFullySigned = 0; QPixmap* KMHeaders::pixPartiallySigned = 0; QPixmap* KMHeaders::pixUndefinedSigned = 0; QPixmap* KMHeaders::pixFullyEncrypted = 0; QPixmap* KMHeaders::pixPartiallyEncrypted = 0; QPixmap* KMHeaders::pixUndefinedEncrypted = 0; QPixmap* KMHeaders::pixEncryptionProblematic = 0; QPixmap* KMHeaders::pixSignatureProblematic = 0; QPixmap* KMHeaders::pixAttachment = 0; QPixmap* KMHeaders::pixReadFwd = 0; QPixmap* KMHeaders::pixReadReplied = 0; QPixmap* KMHeaders::pixReadFwdReplied = 0; //----------------------------------------------------------------------------- KMHeaders::KMHeaders(KMMainWidget *aOwner, QWidget *parent, const char *name) : KListView(parent, name) { static bool pixmapsLoaded = false; //qInitImageIO(); KImageIO::registerFormats(); mOwner = aOwner; mFolder = 0; noRepaint = false; getMsgIndex = -1; mTopItem = 0; setSelectionMode( QListView::Extended ); setAllColumnsShowFocus( true ); mNested = false; nestingPolicy = OpenUnread; mNestedOverride = false; mSubjThreading = true; mMousePressed = false; mSortInfo.dirty = true; mSortInfo.fakeSort = 0; mSortInfo.removed = 0; mSortInfo.column = 0; mSortCol = 2; // 2 == date mSortDescending = false; mSortInfo.ascending = false; mReaderWindowActive = false; mRoot = new SortCacheItem; mRoot->setId(-666); //mark of the root! setStyleDependantFrameWidth(); // popup-menu header()->setClickEnabled(true); header()->installEventFilter(this); mPopup = new KPopupMenu(this); mPopup->insertTitle(i18n("View Columns")); mPopup->setCheckable(true); mPopup->insertItem(i18n("Status"), KPaintInfo::COL_STATUS); mPopup->insertItem(i18n("Important"), KPaintInfo::COL_IMPORTANT); mPopup->insertItem(i18n("Action Item"), KPaintInfo::COL_TODO); mPopup->insertItem(i18n("Attachment"), KPaintInfo::COL_ATTACHMENT); mPopup->insertItem(i18n("Spam/Ham"), KPaintInfo::COL_SPAM_HAM); mPopup->insertItem(i18n("Watched/Ignored"), KPaintInfo::COL_WATCHED_IGNORED); mPopup->insertItem(i18n("Signature"), KPaintInfo::COL_SIGNED); mPopup->insertItem(i18n("Encryption"), KPaintInfo::COL_CRYPTO); mPopup->insertItem(i18n("Size"), KPaintInfo::COL_SIZE); mPopup->insertItem(i18n("Receiver"), KPaintInfo::COL_RECEIVER); connect(mPopup, SIGNAL(activated(int)), this, SLOT(slotToggleColumn(int))); setShowSortIndicator(true); setFocusPolicy( WheelFocus ); if (!pixmapsLoaded) { pixmapsLoaded = true; pixNew = new QPixmap( UserIcon( "kmmsgnew" ) ); pixUns = new QPixmap( UserIcon( "kmmsgunseen" ) ); pixDel = new QPixmap( UserIcon( "kmmsgdel" ) ); pixRead = new QPixmap( UserIcon( "kmmsgread" ) ); pixRep = new QPixmap( UserIcon( "kmmsgreplied" ) ); pixQueued = new QPixmap( UserIcon( "kmmsgqueued" ) ); pixTodo = new QPixmap( UserIcon( "kmmsgtodo" ) ); pixSent = new QPixmap( UserIcon( "kmmsgsent" ) ); pixFwd = new QPixmap( UserIcon( "kmmsgforwarded" ) ); pixFlag = new QPixmap( UserIcon( "kmmsgflag" ) ); pixWatched = new QPixmap( UserIcon( "kmmsgwatched" ) ); pixIgnored = new QPixmap( UserIcon( "kmmsgignored" ) ); pixSpam = new QPixmap( UserIcon( "kmmsgspam" ) ); pixHam = new QPixmap( UserIcon( "kmmsgham" ) ); pixFullySigned = new QPixmap( UserIcon( "kmmsgfullysigned" ) ); pixPartiallySigned = new QPixmap( UserIcon( "kmmsgpartiallysigned" ) ); pixUndefinedSigned = new QPixmap( UserIcon( "kmmsgundefinedsigned" ) ); pixFullyEncrypted = new QPixmap( UserIcon( "kmmsgfullyencrypted" ) ); pixPartiallyEncrypted = new QPixmap( UserIcon( "kmmsgpartiallyencrypted" ) ); pixUndefinedEncrypted = new QPixmap( UserIcon( "kmmsgundefinedencrypted" ) ); pixEncryptionProblematic = new QPixmap( UserIcon( "kmmsgencryptionproblematic" ) ); pixSignatureProblematic = new QPixmap( UserIcon( "kmmsgsignatureproblematic" ) ); pixAttachment = new QPixmap( UserIcon( "kmmsgattachment" ) ); pixReadFwd = new QPixmap( UserIcon( "kmmsgread_fwd" ) ); pixReadReplied = new QPixmap( UserIcon( "kmmsgread_replied" ) ); pixReadFwdReplied = new QPixmap( UserIcon( "kmmsgread_fwd_replied" ) ); } header()->setStretchEnabled( false ); header()->setResizeEnabled( false ); mPaintInfo.subCol = addColumn( i18n("Subject"), 310 ); mPaintInfo.senderCol = addColumn( i18n("Sender"), 170 ); mPaintInfo.dateCol = addColumn( i18n("Date"), 170 ); mPaintInfo.sizeCol = addColumn( i18n("Size"), 0 ); mPaintInfo.receiverCol = addColumn( i18n("Receiver"), 0 ); mPaintInfo.statusCol = addColumn( *pixNew , "", 0 ); mPaintInfo.importantCol = addColumn( *pixFlag , "", 0 ); mPaintInfo.todoCol = addColumn( *pixTodo , "", 0 ); mPaintInfo.attachmentCol = addColumn( *pixAttachment , "", 0 ); mPaintInfo.spamHamCol = addColumn( *pixSpam , "", 0 ); mPaintInfo.watchedIgnoredCol = addColumn( *pixWatched , "", 0 ); mPaintInfo.signedCol = addColumn( *pixFullySigned , "", 0 ); mPaintInfo.cryptoCol = addColumn( *pixFullyEncrypted, "", 0 ); setResizeMode( QListView::NoColumn ); // only the non-optional columns shall be resizeable header()->setResizeEnabled( true, mPaintInfo.subCol ); header()->setResizeEnabled( true, mPaintInfo.senderCol ); header()->setResizeEnabled( true, mPaintInfo.dateCol ); connect( this, SIGNAL( contextMenuRequested( QListViewItem*, const QPoint &, int )), this, SLOT( rightButtonPressed( QListViewItem*, const QPoint &, int ))); connect(this, SIGNAL(doubleClicked(QListViewItem*)), this,SLOT(selectMessage(QListViewItem*))); connect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); resetCurrentTime(); mSubjectLists.setAutoDelete( true ); mMoveMessages = false; connect( this, SIGNAL(selectionChanged()), SLOT(updateActions()) ); } //----------------------------------------------------------------------------- KMHeaders::~KMHeaders () { if (mFolder) { writeFolderConfig(); writeSortOrder(); mFolder->close("kmheaders"); } writeConfig(); delete mRoot; } //----------------------------------------------------------------------------- bool KMHeaders::eventFilter ( QObject *o, QEvent *e ) { if ( e->type() == QEvent::MouseButtonPress && static_cast<QMouseEvent*>(e)->button() == RightButton && o->isA("QHeader") ) { // if we currently only show one of either sender/receiver column // modify the popup text in the way, that it displays the text of the other of the two if ( mPaintInfo.showReceiver ) mPopup->changeItem(KPaintInfo::COL_RECEIVER, i18n("Receiver")); else if ( mFolder && (mFolder->whoField().lower() == "to") ) mPopup->changeItem(KPaintInfo::COL_RECEIVER, i18n("Sender")); else mPopup->changeItem(KPaintInfo::COL_RECEIVER, i18n("Receiver")); mPopup->popup( static_cast<QMouseEvent*>(e)->globalPos() ); return true; } return KListView::eventFilter(o, e); } //----------------------------------------------------------------------------- void KMHeaders::slotToggleColumn(int id, int mode) { bool *show = 0; int *col = 0; int width = 0; int moveToCol = -1; switch ( static_cast<KPaintInfo::ColumnIds>(id) ) { case KPaintInfo::COL_SIZE: { show = &mPaintInfo.showSize; col = &mPaintInfo.sizeCol; width = 80; break; } case KPaintInfo::COL_ATTACHMENT: { show = &mPaintInfo.showAttachment; col = &mPaintInfo.attachmentCol; width = pixAttachment->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_IMPORTANT: { show = &mPaintInfo.showImportant; col = &mPaintInfo.importantCol; width = pixFlag->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_TODO: { show = &mPaintInfo.showTodo; col = &mPaintInfo.todoCol; width = pixTodo->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_SPAM_HAM: { show = &mPaintInfo.showSpamHam; col = &mPaintInfo.spamHamCol; width = pixSpam->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_WATCHED_IGNORED: { show = &mPaintInfo.showWatchedIgnored; col = &mPaintInfo.watchedIgnoredCol; width = pixWatched->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_STATUS: { show = &mPaintInfo.showStatus; col = &mPaintInfo.statusCol; width = pixNew->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_SIGNED: { show = &mPaintInfo.showSigned; col = &mPaintInfo.signedCol; width = pixFullySigned->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_CRYPTO: { show = &mPaintInfo.showCrypto; col = &mPaintInfo.cryptoCol; width = pixFullyEncrypted->width() + 8; if ( *col == header()->mapToIndex( *col ) ) moveToCol = 0; break; } case KPaintInfo::COL_RECEIVER: { show = &mPaintInfo.showReceiver; col = &mPaintInfo.receiverCol; width = 170; break; } case KPaintInfo::COL_SCORE: ; // only used by KNode // don't use default, so that the compiler tells us you forgot to code here for a new column } assert(show); if (mode == -1) *show = !*show; else *show = mode; mPopup->setItemChecked(id, *show); if (*show) { header()->setResizeEnabled(true, *col); setColumnWidth(*col, width); if ( moveToCol >= 0 ) header()->moveSection( *col, moveToCol ); } else { header()->setResizeEnabled(false, *col); header()->setStretchEnabled(false, *col); hideColumn(*col); } // if we change the visibility of the receiver column, // the sender column has to show either the sender or the receiver if ( static_cast<KPaintInfo::ColumnIds>(id) == KPaintInfo::COL_RECEIVER ) { QString colText = i18n( "Sender" ); if ( mFolder && (mFolder->whoField().lower() == "to") && !mPaintInfo.showReceiver) colText = i18n( "Receiver" ); setColumnText( mPaintInfo.senderCol, colText ); } if (mode == -1) writeConfig(); } //----------------------------------------------------------------------------- // Support for backing pixmap void KMHeaders::paintEmptyArea( QPainter * p, const QRect & rect ) { if (mPaintInfo.pixmapOn) p->drawTiledPixmap( rect.left(), rect.top(), rect.width(), rect.height(), mPaintInfo.pixmap, rect.left() + contentsX(), rect.top() + contentsY() ); else p->fillRect( rect, colorGroup().base() ); } bool KMHeaders::event(QEvent *e) { bool result = KListView::event(e); if (e->type() == QEvent::ApplicationPaletteChange) { readColorConfig(); } return result; } //----------------------------------------------------------------------------- void KMHeaders::readColorConfig (void) { KConfig* config = KMKernel::config(); // Custom/System colors KConfigGroupSaver saver(config, "Reader"); QColor c1=QColor(kapp->palette().active().text()); QColor c2=QColor("red"); QColor c3=QColor("blue"); QColor c4=QColor(kapp->palette().active().base()); QColor c5=QColor(0,0x7F,0); QColor c6=QColor(0,0x98,0); QColor c7=KGlobalSettings::alternateBackgroundColor(); if (!config->readBoolEntry("defaultColors",true)) { mPaintInfo.colFore = config->readColorEntry("ForegroundColor",&c1); mPaintInfo.colBack = config->readColorEntry("BackgroundColor",&c4); QPalette newPal = kapp->palette(); newPal.setColor( QColorGroup::Base, mPaintInfo.colBack ); newPal.setColor( QColorGroup::Text, mPaintInfo.colFore ); setPalette( newPal ); mPaintInfo.colNew = config->readColorEntry("NewMessage",&c2); mPaintInfo.colUnread = config->readColorEntry("UnreadMessage",&c3); mPaintInfo.colFlag = config->readColorEntry("FlagMessage",&c5); mPaintInfo.colTodo = config->readColorEntry("TodoMessage",&c6); c7 = config->readColorEntry("AltBackgroundColor",&c7); } else { mPaintInfo.colFore = c1; mPaintInfo.colBack = c4; QPalette newPal = kapp->palette(); newPal.setColor( QColorGroup::Base, c4 ); newPal.setColor( QColorGroup::Text, c1 ); setPalette( newPal ); mPaintInfo.colNew = c2; mPaintInfo.colUnread = c3; mPaintInfo.colFlag = c5; mPaintInfo.colTodo = c6; } setAlternateBackground(c7); } //----------------------------------------------------------------------------- void KMHeaders::readConfig (void) { KConfig* config = KMKernel::config(); // Backing pixmap support { // area for config group "Pixmaps" KConfigGroupSaver saver(config, "Pixmaps"); QString pixmapFile = config->readEntry("Headers"); mPaintInfo.pixmapOn = false; if (!pixmapFile.isEmpty()) { mPaintInfo.pixmapOn = true; mPaintInfo.pixmap = QPixmap( pixmapFile ); } } { // area for config group "General" KConfigGroupSaver saver(config, "General"); bool show = config->readBoolEntry("showMessageSize"); slotToggleColumn(KPaintInfo::COL_SIZE, show); show = config->readBoolEntry("showAttachmentColumn"); slotToggleColumn(KPaintInfo::COL_ATTACHMENT, show); show = config->readBoolEntry("showImportantColumn"); slotToggleColumn(KPaintInfo::COL_IMPORTANT, show); show = config->readBoolEntry("showTodoColumn"); slotToggleColumn(KPaintInfo::COL_TODO, show); show = config->readBoolEntry("showSpamHamColumn"); slotToggleColumn(KPaintInfo::COL_SPAM_HAM, show); show = config->readBoolEntry("showWatchedIgnoredColumn"); slotToggleColumn(KPaintInfo::COL_WATCHED_IGNORED, show); show = config->readBoolEntry("showStatusColumn"); slotToggleColumn(KPaintInfo::COL_STATUS, show); show = config->readBoolEntry("showSignedColumn"); slotToggleColumn(KPaintInfo::COL_SIGNED, show); show = config->readBoolEntry("showCryptoColumn"); slotToggleColumn(KPaintInfo::COL_CRYPTO, show); show = config->readBoolEntry("showReceiverColumn"); slotToggleColumn(KPaintInfo::COL_RECEIVER, show); mPaintInfo.showCryptoIcons = config->readBoolEntry( "showCryptoIcons", false ); mPaintInfo.showAttachmentIcon = config->readBoolEntry( "showAttachmentIcon", true ); KMime::DateFormatter::FormatType t = (KMime::DateFormatter::FormatType) config->readNumEntry("dateFormat", KMime::DateFormatter::Fancy ) ; mDate.setCustomFormat( config->readEntry("customDateFormat") ); mDate.setFormat( t ); } readColorConfig(); // Custom/System fonts { // area for config group "General" KConfigGroupSaver saver(config, "Fonts"); if (!(config->readBoolEntry("defaultFonts",true))) { QFont listFont( KGlobalSettings::generalFont() ); listFont = config->readFontEntry( "list-font", &listFont ); setFont( listFont ); mNewFont = config->readFontEntry( "list-new-font", &listFont ); mUnreadFont = config->readFontEntry( "list-unread-font", &listFont ); mImportantFont = config->readFontEntry( "list-important-font", &listFont ); mTodoFont = config->readFontEntry( "list-todo-font", &listFont ); mDateFont = KGlobalSettings::fixedFont(); mDateFont = config->readFontEntry( "list-date-font", &mDateFont ); } else { mNewFont= mUnreadFont = mImportantFont = mDateFont = mTodoFont = KGlobalSettings::generalFont(); setFont( mDateFont ); } } // Behavior { KConfigGroupSaver saver(config, "Geometry"); mReaderWindowActive = config->readEntry( "readerWindowMode", "below" ) != "hide"; } } //----------------------------------------------------------------------------- void KMHeaders::reset() { int top = topItemIndex(); int id = currentItemIndex(); noRepaint = true; clear(); QString colText = i18n( "Sender" ); if ( mFolder && (mFolder->whoField().lower() == "to") && !mPaintInfo.showReceiver) colText = i18n( "Receiver" ); setColumnText( mPaintInfo.senderCol, colText ); noRepaint = false; mItems.resize(0); updateMessageList(); setCurrentMsg(id); setTopItemByIndex(top); ensureCurrentItemVisible(); } //----------------------------------------------------------------------------- void KMHeaders::refreshNestedState(void) { bool oldState = isThreaded(); NestingPolicy oldNestPolicy = nestingPolicy; KConfig* config = KMKernel::config(); KConfigGroupSaver saver(config, "Geometry"); mNested = config->readBoolEntry( "nestedMessages", false ); nestingPolicy = (NestingPolicy)config->readNumEntry( "nestingPolicy", OpenUnread ); if ((nestingPolicy != oldNestPolicy) || (oldState != isThreaded())) { setRootIsDecorated( nestingPolicy != AlwaysOpen && isThreaded() ); reset(); } } //----------------------------------------------------------------------------- void KMHeaders::readFolderConfig (void) { if (!mFolder) return; KConfig* config = KMKernel::config(); KConfigGroupSaver saver(config, "Folder-" + mFolder->idString()); mNestedOverride = config->readBoolEntry( "threadMessagesOverride", false ); mSortCol = config->readNumEntry("SortColumn", mSortCol+1 /* inited to date column */); mSortDescending = (mSortCol < 0); mSortCol = abs(mSortCol) - 1; mTopItem = config->readNumEntry("Top", 0); mCurrentItem = config->readNumEntry("Current", 0); mCurrentItemSerNum = config->readNumEntry("CurrentSerialNum", 0); mPaintInfo.orderOfArrival = config->readBoolEntry( "OrderOfArrival", true ); mPaintInfo.status = config->readBoolEntry( "Status", false ); { //area for config group "Geometry" KConfigGroupSaver saver(config, "Geometry"); mNested = config->readBoolEntry( "nestedMessages", false ); nestingPolicy = (NestingPolicy)config->readNumEntry( "nestingPolicy", OpenUnread ); } setRootIsDecorated( nestingPolicy != AlwaysOpen && isThreaded() ); mSubjThreading = config->readBoolEntry( "threadMessagesBySubject", true ); } //----------------------------------------------------------------------------- void KMHeaders::writeFolderConfig (void) { if (!mFolder) return; KConfig* config = KMKernel::config(); int mSortColAdj = mSortCol + 1; KConfigGroupSaver saver(config, "Folder-" + mFolder->idString()); config->writeEntry("SortColumn", (mSortDescending ? -mSortColAdj : mSortColAdj)); config->writeEntry("Top", topItemIndex()); config->writeEntry("Current", currentItemIndex()); HeaderItem* current = currentHeaderItem(); ulong sernum = 0; if ( current && mFolder->getMsgBase( current->msgId() ) ) sernum = mFolder->getMsgBase( current->msgId() )->getMsgSerNum(); config->writeEntry("CurrentSerialNum", sernum); config->writeEntry("OrderOfArrival", mPaintInfo.orderOfArrival); config->writeEntry("Status", mPaintInfo.status); } //----------------------------------------------------------------------------- void KMHeaders::writeConfig (void) { KConfig* config = KMKernel::config(); saveLayout(config, "Header-Geometry"); KConfigGroupSaver saver(config, "General"); config->writeEntry("showMessageSize" , mPaintInfo.showSize); config->writeEntry("showAttachmentColumn" , mPaintInfo.showAttachment); config->writeEntry("showImportantColumn" , mPaintInfo.showImportant); config->writeEntry("showTodoColumn" , mPaintInfo.showTodo); config->writeEntry("showSpamHamColumn" , mPaintInfo.showSpamHam); config->writeEntry("showWatchedIgnoredColumn", mPaintInfo.showWatchedIgnored); config->writeEntry("showStatusColumn" , mPaintInfo.showStatus); config->writeEntry("showSignedColumn" , mPaintInfo.showSigned); config->writeEntry("showCryptoColumn" , mPaintInfo.showCrypto); config->writeEntry("showReceiverColumn" , mPaintInfo.showReceiver); } //----------------------------------------------------------------------------- void KMHeaders::setFolder( KMFolder *aFolder, bool forceJumpToUnread ) { CREATE_TIMER(set_folder); START_TIMER(set_folder); int id; QString str; mSortInfo.fakeSort = 0; if ( mFolder && static_cast<KMFolder*>(mFolder) == aFolder ) { int top = topItemIndex(); id = currentItemIndex(); writeFolderConfig(); readFolderConfig(); updateMessageList(); // do not change the selection setCurrentMsg(id); setTopItemByIndex(top); } else { if (mFolder) { // WABA: Make sure that no KMReaderWin is still using a msg // from this folder, since it's msg's are about to be deleted. highlightMessage(0, false); disconnect(mFolder, SIGNAL(numUnreadMsgsChanged(KMFolder*)), this, SLOT(setFolderInfoStatus())); mFolder->markNewAsUnread(); writeFolderConfig(); disconnect(mFolder, SIGNAL(msgHeaderChanged(KMFolder*,int)), this, SLOT(msgHeaderChanged(KMFolder*,int))); disconnect(mFolder, SIGNAL(msgAdded(int)), this, SLOT(msgAdded(int))); disconnect(mFolder, SIGNAL( msgRemoved( int, QString ) ), this, SLOT( msgRemoved( int, QString ) ) ); disconnect(mFolder, SIGNAL(changed()), this, SLOT(msgChanged())); disconnect(mFolder, SIGNAL(cleared()), this, SLOT(folderCleared())); disconnect(mFolder, SIGNAL(expunged( KMFolder* )), this, SLOT(folderCleared())); disconnect(mFolder, SIGNAL(closed()), this, SLOT(folderClosed())); disconnect( mFolder, SIGNAL( statusMsg( const QString& ) ), BroadcastStatus::instance(), SLOT( setStatusMsg( const QString& ) ) ); disconnect(mFolder, SIGNAL(viewConfigChanged()), this, SLOT(reset())); writeSortOrder(); mFolder->close("kmheaders"); // System folders remain open but we also should write the index from // time to time if (mFolder->dirty()) mFolder->writeIndex(); } mSortInfo.removed = 0; mFolder = aFolder; mSortInfo.dirty = true; mOwner->useAction()->setEnabled( mFolder ? ( kmkernel->folderIsTemplates( mFolder ) ) : false ); mOwner->messageActions()->replyListAction()->setEnabled( mFolder ? mFolder->isMailingListEnabled() : false ); if ( mFolder ) { connect(mFolder, SIGNAL(msgHeaderChanged(KMFolder*,int)), this, SLOT(msgHeaderChanged(KMFolder*,int))); connect(mFolder, SIGNAL(msgAdded(int)), this, SLOT(msgAdded(int))); connect(mFolder, SIGNAL(msgRemoved(int,QString)), this, SLOT(msgRemoved(int,QString))); connect(mFolder, SIGNAL(changed()), this, SLOT(msgChanged())); connect(mFolder, SIGNAL(cleared()), this, SLOT(folderCleared())); connect(mFolder, SIGNAL(expunged( KMFolder* )), this, SLOT(folderCleared())); connect(mFolder, SIGNAL(closed()), this, SLOT(folderClosed())); connect(mFolder, SIGNAL(statusMsg(const QString&)), BroadcastStatus::instance(), SLOT( setStatusMsg( const QString& ) ) ); connect(mFolder, SIGNAL(numUnreadMsgsChanged(KMFolder*)), this, SLOT(setFolderInfoStatus())); connect(mFolder, SIGNAL(viewConfigChanged()), this, SLOT(reset())); // Not very nice, but if we go from nested to non-nested // in the folderConfig below then we need to do this otherwise // updateMessageList would do something unspeakable if (isThreaded()) { noRepaint = true; clear(); noRepaint = false; mItems.resize( 0 ); } readFolderConfig(); CREATE_TIMER(kmfolder_open); START_TIMER(kmfolder_open); mFolder->open("kmheaders"); END_TIMER(kmfolder_open); SHOW_TIMER(kmfolder_open); if (isThreaded()) { noRepaint = true; clear(); noRepaint = false; mItems.resize( 0 ); } } CREATE_TIMER(updateMsg); START_TIMER(updateMsg); updateMessageList(true, forceJumpToUnread); END_TIMER(updateMsg); SHOW_TIMER(updateMsg); makeHeaderVisible(); setFolderInfoStatus(); QString colText = i18n( "Sender" ); if (mFolder && (mFolder->whoField().lower() == "to") && !mPaintInfo.showReceiver) colText = i18n("Receiver"); setColumnText( mPaintInfo.senderCol, colText); colText = i18n( "Date" ); if (mPaintInfo.orderOfArrival) colText = i18n( "Order of Arrival" ); setColumnText( mPaintInfo.dateCol, colText); colText = i18n( "Subject" ); if (mPaintInfo.status) colText = colText + i18n( " (Status)" ); setColumnText( mPaintInfo.subCol, colText); } updateActions(); END_TIMER(set_folder); SHOW_TIMER(set_folder); } //----------------------------------------------------------------------------- void KMHeaders::msgChanged() { if (mFolder->count() == 0) { // Folder cleared mItems.resize(0); clear(); return; } int i = topItemIndex(); int cur = currentItemIndex(); if (!isUpdatesEnabled()) return; QString msgIdMD5; QListViewItem *item = currentItem(); HeaderItem *hi = dynamic_cast<HeaderItem*>(item); if (item && hi) { // get the msgIdMD5 to compare it later KMMsgBase *mb = mFolder->getMsgBase(hi->msgId()); if (mb) msgIdMD5 = mb->msgIdMD5(); } // if (!isUpdatesEnabled()) return; // prevent IMAP messages from scrolling to top disconnect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); // remember all selected messages QValueList<int> curItems = selectedItems(); updateMessageList(); // do not change the selection // restore the old state, but move up when there are unread message just out of view HeaderItem *topOfList = mItems[i]; item = firstChild(); QListViewItem *unreadItem = 0; while(item && item != topOfList) { KMMsgBase *msg = mFolder->getMsgBase( static_cast<HeaderItem*>(item)->msgId() ); if ( msg->isUnread() || msg->isNew() ) { if ( !unreadItem ) unreadItem = item; } else unreadItem = 0; item = item->itemBelow(); } if(unreadItem == 0) unreadItem = topOfList; setContentsPos( 0, itemPos( unreadItem )); setCurrentMsg( cur ); setSelectedByIndex( curItems, true ); connect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); // if the current message has changed then emit // the selected signal to force an update // Normally the serial number of the message would be // used to do this, but because we don't yet have // guaranteed serial numbers for IMAP messages fall back // to using the MD5 checksum of the msgId. item = currentItem(); hi = dynamic_cast<HeaderItem*>(item); if (item && hi) { KMMsgBase *mb = mFolder->getMsgBase(hi->msgId()); if (mb) { if (msgIdMD5.isEmpty() || (msgIdMD5 != mb->msgIdMD5())) emit selected(mFolder->getMsg(hi->msgId())); } else { emit selected(0); } } else emit selected(0); } //----------------------------------------------------------------------------- void KMHeaders::msgAdded(int id) { HeaderItem* hi = 0; if (!isUpdatesEnabled()) return; CREATE_TIMER(msgAdded); START_TIMER(msgAdded); assert( mFolder->getMsgBase( id ) ); // otherwise using count() is wrong /* Create a new SortCacheItem to be used for threading. */ SortCacheItem *sci = new SortCacheItem; sci->setId(id); if (isThreaded()) { // make sure the id and subject dicts grow, if necessary if (mSortCacheItems.count() == (uint)mFolder->count() || mSortCacheItems.count() == 0) { kdDebug (5006) << "KMHeaders::msgAdded - Resizing id and subject trees of " << mFolder->label() << ": before=" << mSortCacheItems.count() << " ,after=" << (mFolder->count()*2) << endl; mSortCacheItems.resize(mFolder->count()*2); mSubjectLists.resize(mFolder->count()*2); } QString msgId = mFolder->getMsgBase(id)->msgIdMD5(); if (msgId.isNull()) msgId = ""; QString replyToId = mFolder->getMsgBase(id)->replyToIdMD5(); SortCacheItem *parent = findParent( sci ); if (!parent && mSubjThreading) { parent = findParentBySubject( sci ); if (parent && sci->isImperfectlyThreaded()) { // The parent we found could be by subject, in which case it is // possible, that it would be preferrable to thread it below us, // not the other way around. Check that. This is not only // cosmetic, as getting this wrong leads to circular threading. if (msgId == mFolder->getMsgBase(parent->item()->msgId())->replyToIdMD5() || msgId == mFolder->getMsgBase(parent->item()->msgId())->replyToAuxIdMD5()) parent = NULL; } } if (parent && mFolder->getMsgBase(parent->id())->isWatched()) mFolder->getMsgBase(id)->setStatus( KMMsgStatusWatched ); else if (parent && mFolder->getMsgBase(parent->id())->isIgnored()) mFolder->getMsgBase(id)->setStatus( KMMsgStatusIgnored ); if (parent) hi = new HeaderItem( parent->item(), id ); else hi = new HeaderItem( this, id ); // o/` ... my buddy and me .. o/` hi->setSortCacheItem(sci); sci->setItem(hi); // Update and resize the id trees. mItems.resize( mFolder->count() ); mItems[id] = hi; if ( !msgId.isEmpty() ) mSortCacheItems.replace(msgId, sci); /* Add to the list of potential parents for subject threading. But only if * we are top level. */ if (mSubjThreading && parent) { QString subjMD5 = mFolder->getMsgBase(id)->strippedSubjectMD5(); if (subjMD5.isEmpty()) { mFolder->getMsgBase(id)->initStrippedSubjectMD5(); subjMD5 = mFolder->getMsgBase(id)->strippedSubjectMD5(); } if( !subjMD5.isEmpty()) { if ( !mSubjectLists.find(subjMD5) ) mSubjectLists.insert(subjMD5, new QPtrList<SortCacheItem>()); // insertion sort by date. See buildThreadTrees for details. int p=0; for (QPtrListIterator<SortCacheItem> it(*mSubjectLists[subjMD5]); it.current(); ++it) { KMMsgBase *mb = mFolder->getMsgBase((*it)->id()); if ( mb->date() < mFolder->getMsgBase(id)->date()) break; p++; } mSubjectLists[subjMD5]->insert( p, sci); sci->setSubjectThreadingList( mSubjectLists[subjMD5] ); } } // The message we just added might be a better parent for one of the as of // yet imperfectly threaded messages. Let's find out. /* In case the current item is taken during reparenting, prevent qlistview * from selecting some unrelated item as a result of take() emitting * currentChanged. */ disconnect( this, SIGNAL(currentChanged(QListViewItem*)), this, SLOT(highlightMessage(QListViewItem*))); if ( !msgId.isEmpty() ) { QPtrListIterator<HeaderItem> it(mImperfectlyThreadedList); HeaderItem *cur; while ( (cur = it.current()) ) { ++it; int tryMe = cur->msgId(); // Check, whether our message is the replyToId or replyToAuxId of // this one. If so, thread it below our message, unless it is already // correctly threaded by replyToId. bool perfectParent = true; KMMsgBase *otherMsg = mFolder->getMsgBase(tryMe); if ( !otherMsg ) { kdDebug(5006) << "otherMsg is NULL !!! tryMe: " << tryMe << endl; continue; } QString otherId = otherMsg->replyToIdMD5(); if (msgId != otherId) { if (msgId != otherMsg->replyToAuxIdMD5()) continue; else { if (!otherId.isEmpty() && mSortCacheItems.find(otherId)) continue; else // Thread below us by aux id, but keep on the list of // imperfectly threaded messages. perfectParent = false; } } QListViewItem *newParent = mItems[id]; QListViewItem *msg = mItems[tryMe]; if (msg->parent()) msg->parent()->takeItem(msg); else takeItem(msg); newParent->insertItem(msg); HeaderItem *hi = static_cast<HeaderItem*>( newParent ); hi->sortCacheItem()->addSortedChild( cur->sortCacheItem() ); makeHeaderVisible(); if (perfectParent) { mImperfectlyThreadedList.removeRef (mItems[tryMe]); // The item was imperfectly thread before, now it's parent // is there. Update the .sorted file accordingly. QString sortFile = KMAIL_SORT_FILE(mFolder); FILE *sortStream = fopen(QFile::encodeName(sortFile), "r+"); if (sortStream) { mItems[tryMe]->sortCacheItem()->updateSortFile( sortStream, mFolder ); fclose (sortStream); } } } } // Add ourselves only now, to avoid circularity above. if (hi && hi->sortCacheItem()->isImperfectlyThreaded()) mImperfectlyThreadedList.append(hi); } else { // non-threaded case hi = new HeaderItem( this, id ); mItems.resize( mFolder->count() ); mItems[id] = hi; // o/` ... my buddy and me .. o/` hi->setSortCacheItem(sci); sci->setItem(hi); } if (mSortInfo.fakeSort) { QObject::disconnect(header(), SIGNAL(clicked(int)), this, SLOT(dirtySortOrder(int))); KListView::setSorting(mSortCol, !mSortDescending ); mSortInfo.fakeSort = 0; } appendItemToSortFile(hi); //inserted into sorted list msgHeaderChanged(mFolder,id); if ((childCount() == 1) && hi) { setSelected( hi, true ); setCurrentItem( firstChild() ); setSelectionAnchor( currentItem() ); highlightMessage( currentItem() ); } /* restore signal */ connect( this, SIGNAL(currentChanged(QListViewItem*)), this, SLOT(highlightMessage(QListViewItem*))); emit msgAddedToListView( hi ); END_TIMER(msgAdded); SHOW_TIMER(msgAdded); } //----------------------------------------------------------------------------- void KMHeaders::msgRemoved(int id, QString msgId ) { if (!isUpdatesEnabled()) return; if ((id < 0) || (id >= (int)mItems.size())) return; /* * qlistview has its own ideas about what to select as the next * item once this one is removed. Sine we have already selected * something in prepare/finalizeMove that's counter productive */ disconnect( this, SIGNAL(currentChanged(QListViewItem*)), this, SLOT(highlightMessage(QListViewItem*))); HeaderItem *removedItem = mItems[id]; if (!removedItem) return; HeaderItem *curItem = currentHeaderItem(); for (int i = id; i < (int)mItems.size() - 1; ++i) { mItems[i] = mItems[i+1]; mItems[i]->setMsgId( i ); mItems[i]->sortCacheItem()->setId( i ); } mItems.resize( mItems.size() - 1 ); if (isThreaded() && mFolder->count()) { if ( !msgId.isEmpty() && mSortCacheItems[msgId] ) { if (mSortCacheItems[msgId] == removedItem->sortCacheItem()) mSortCacheItems.remove(msgId); } // Remove the message from the list of potential parents for threading by // subject. if ( mSubjThreading && removedItem->sortCacheItem()->subjectThreadingList() ) removedItem->sortCacheItem()->subjectThreadingList()->removeRef( removedItem->sortCacheItem() ); // Reparent children of item. QListViewItem *myParent = removedItem; QListViewItem *myChild = myParent->firstChild(); QListViewItem *threadRoot = myParent; while (threadRoot->parent()) threadRoot = threadRoot->parent(); QString key = static_cast<HeaderItem*>(threadRoot)->key(mSortCol, !mSortDescending); QPtrList<QListViewItem> childList; while (myChild) { HeaderItem *item = static_cast<HeaderItem*>(myChild); // Just keep the item at top level, if it will be deleted anyhow if ( !item->aboutToBeDeleted() ) { childList.append(myChild); } myChild = myChild->nextSibling(); if ( item->aboutToBeDeleted() ) { myParent->takeItem( item ); insertItem( item ); mRoot->addSortedChild( item->sortCacheItem() ); } item->setTempKey( key + item->key( mSortCol, !mSortDescending )); if (mSortInfo.fakeSort) { QObject::disconnect(header(), SIGNAL(clicked(int)), this, SLOT(dirtySortOrder(int))); KListView::setSorting(mSortCol, !mSortDescending ); mSortInfo.fakeSort = 0; } } for (QPtrListIterator<QListViewItem> it(childList); it.current() ; ++it ) { QListViewItem *lvi = *it; HeaderItem *item = static_cast<HeaderItem*>(lvi); SortCacheItem *sci = item->sortCacheItem(); SortCacheItem *parent = findParent( sci ); if ( !parent && mSubjThreading ) parent = findParentBySubject( sci ); Q_ASSERT( !parent || parent->item() != removedItem ); myParent->takeItem(lvi); if ( parent && parent->item() != item && parent->item() != removedItem ) { parent->item()->insertItem(lvi); parent->addSortedChild( sci ); } else { insertItem(lvi); mRoot->addSortedChild( sci ); } if ((!parent || sci->isImperfectlyThreaded()) && !mImperfectlyThreadedList.containsRef(item)) mImperfectlyThreadedList.append(item); if (parent && !sci->isImperfectlyThreaded() && mImperfectlyThreadedList.containsRef(item)) mImperfectlyThreadedList.removeRef(item); } } // Make sure our data structures are cleared. if (!mFolder->count()) folderCleared(); mImperfectlyThreadedList.removeRef( removedItem ); #ifdef DEBUG // This should never happen, in this case the folders are inconsistent. while ( mImperfectlyThreadedList.findRef( removedItem ) != -1 ) { mImperfectlyThreadedList.remove(); kdDebug(5006) << "Remove doubled item from mImperfectlyThreadedList: " << removedItem << endl; } #endif delete removedItem; // we might have rethreaded it, in which case its current state will be lost if ( curItem ) { if ( curItem != removedItem ) { setCurrentItem( curItem ); setSelectionAnchor( currentItem() ); } else { // We've removed the current item, which means it was removed from // something other than a user move or copy, which would have selected // the next logical mail. This can happen when the mail is deleted by // a filter, or some other behind the scenes action. Select something // sensible, then, and make sure the reader window is cleared. emit maybeDeleting(); int contentX, contentY; HeaderItem *nextItem = prepareMove( &contentX, &contentY ); finalizeMove( nextItem, contentX, contentY ); } } /* restore signal */ connect( this, SIGNAL(currentChanged(QListViewItem*)), this, SLOT(highlightMessage(QListViewItem*))); } //----------------------------------------------------------------------------- void KMHeaders::msgHeaderChanged(KMFolder*, int msgId) { if (msgId<0 || msgId >= (int)mItems.size() || !isUpdatesEnabled()) return; HeaderItem *item = mItems[msgId]; if (item) { item->irefresh(); item->repaint(); } } //----------------------------------------------------------------------------- void KMHeaders::setMsgStatus (KMMsgStatus status, bool toggle) { // kdDebug() << k_funcinfo << endl; SerNumList serNums = selectedVisibleSernums(); if (serNums.empty()) return; KMCommand *command = new KMSetStatusCommand( status, serNums, toggle ); command->start(); } QPtrList<QListViewItem> KMHeaders::currentThread() const { if (!mFolder) return QPtrList<QListViewItem>(); // starting with the current item... QListViewItem *curItem = currentItem(); if (!curItem) return QPtrList<QListViewItem>(); // ...find the top-level item: QListViewItem *topOfThread = curItem; while ( topOfThread->parent() ) topOfThread = topOfThread->parent(); // collect the items in this thread: QPtrList<QListViewItem> list; QListViewItem *topOfNextThread = topOfThread->nextSibling(); for ( QListViewItemIterator it( topOfThread ) ; it.current() && it.current() != topOfNextThread ; ++it ) list.append( it.current() ); return list; } void KMHeaders::setThreadStatus(KMMsgStatus status, bool toggle) { QPtrList<QListViewItem> curThread; if (mFolder) { QPtrList<QListViewItem> topOfThreads; // for each selected item... for (QListViewItem *item = firstChild(); item; item = item->itemBelow()) if (item->isSelected() ) { // ...find the top-level item: QListViewItem *top = item; while ( top->parent() ) top = top->parent(); if (!topOfThreads.contains(top)) { topOfThreads.append(top); } } // for each thread found... for ( QPtrListIterator<QListViewItem> it( topOfThreads ) ; it.current() ; ++ it ) { QListViewItem *top = *it; // collect the items in this thread: QListViewItem *topOfNextThread = top->nextSibling(); for ( QListViewItemIterator it( top ) ; it.current() && it.current() != topOfNextThread ; ++it ) curThread.append( it.current() ); } } QPtrListIterator<QListViewItem> it( curThread ); SerNumList serNums; for ( it.toFirst() ; it.current() ; ++it ) { int id = static_cast<HeaderItem*>(*it)->msgId(); KMMsgBase *msgBase = mFolder->getMsgBase( id ); serNums.append( msgBase->getMsgSerNum() ); } if (serNums.empty()) return; KMCommand *command = new KMSetStatusCommand( status, serNums, toggle ); command->start(); } //----------------------------------------------------------------------------- int KMHeaders::slotFilterMsg(KMMessage *msg) { if ( !msg ) return 2; // messageRetrieve(0) is always possible msg->setTransferInProgress(false); int filterResult = kmkernel->filterMgr()->process(msg,KMFilterMgr::Explicit); if (filterResult == 2) { // something went horribly wrong (out of space?) kmkernel->emergencyExit( i18n("Unable to process messages: " ) + QString::fromLocal8Bit(strerror(errno))); return 2; } if (msg->parent()) { // unGet this msg int idx = -1; KMFolder * p = 0; KMMsgDict::instance()->getLocation( msg, &p, &idx ); assert( p == msg->parent() ); assert( idx >= 0 ); p->unGetMsg( idx ); } return filterResult; } void KMHeaders::slotExpandOrCollapseThread( bool expand ) { if ( !isThreaded() ) return; // find top-level parent of currentItem(). QListViewItem *item = currentItem(); if ( !item ) return; clearSelection(); item->setSelected( true ); while ( item->parent() ) item = item->parent(); HeaderItem * hdrItem = static_cast<HeaderItem*>(item); hdrItem->setOpenRecursive( expand ); if ( !expand ) // collapse can hide the current item: setCurrentMsg( hdrItem->msgId() ); ensureItemVisible( currentItem() ); } void KMHeaders::slotExpandOrCollapseAllThreads( bool expand ) { if ( !isThreaded() ) return; QListViewItem * item = currentItem(); if( item ) { clearSelection(); item->setSelected( true ); } for ( QListViewItem *item = firstChild() ; item ; item = item->nextSibling() ) static_cast<HeaderItem*>(item)->setOpenRecursive( expand ); if ( !expand ) { // collapse can hide the current item: QListViewItem * item = currentItem(); if( item ) { while ( item->parent() ) item = item->parent(); setCurrentMsg( static_cast<HeaderItem*>(item)->msgId() ); } } ensureItemVisible( currentItem() ); } //----------------------------------------------------------------------------- void KMHeaders::setStyleDependantFrameWidth() { // set the width of the frame to a reasonable value for the current GUI style int frameWidth; if( style().isA("KeramikStyle") ) frameWidth = style().pixelMetric( QStyle::PM_DefaultFrameWidth ) - 1; else frameWidth = style().pixelMetric( QStyle::PM_DefaultFrameWidth ); if ( frameWidth < 0 ) frameWidth = 0; if ( frameWidth != lineWidth() ) setLineWidth( frameWidth ); } //----------------------------------------------------------------------------- void KMHeaders::styleChange( QStyle& oldStyle ) { setStyleDependantFrameWidth(); KListView::styleChange( oldStyle ); } //----------------------------------------------------------------------------- void KMHeaders::setFolderInfoStatus () { if ( !mFolder ) return; QString str; const int unread = mFolder->countUnread(); if ( static_cast<KMFolder*>(mFolder) == kmkernel->outboxFolder() ) str = unread ? i18n( "1 unsent", "%n unsent", unread ) : i18n( "0 unsent" ); else str = unread ? i18n( "1 unread", "%n unread", unread ) : i18n( "0 unread" ); const int count = mFolder->count(); str = count ? i18n( "1 message, %1.", "%n messages, %1.", count ).arg( str ) : i18n( "0 messages" ); // no need for "0 unread" to be added here if ( mFolder->isReadOnly() ) str = i18n("%1 = n messages, m unread.", "%1 Folder is read-only.").arg( str ); BroadcastStatus::instance()->setStatusMsg(str); } //----------------------------------------------------------------------------- void KMHeaders::applyFiltersOnMsg() { if (ActionScheduler::isEnabled() || kmkernel->filterMgr()->atLeastOneOnlineImapFolderTarget()) { // uses action scheduler KMFilterMgr::FilterSet set = KMFilterMgr::Explicit; QValueList<KMFilter*> filters = kmkernel->filterMgr()->filters(); ActionScheduler *scheduler = new ActionScheduler( set, filters, this ); scheduler->setAutoDestruct( true ); int contentX, contentY; HeaderItem *nextItem = prepareMove( &contentX, &contentY ); QPtrList<KMMsgBase> msgList = *selectedMsgs(true); finalizeMove( nextItem, contentX, contentY ); for (KMMsgBase *msg = msgList.first(); msg; msg = msgList.next()) scheduler->execFilters( msg ); } else { int contentX, contentY; HeaderItem *nextItem = prepareMove( &contentX, &contentY ); //prevent issues with stale message pointers by using serial numbers instead QValueList<unsigned long> serNums = KMMsgDict::serNumList( *selectedMsgs() ); if ( serNums.isEmpty() ) return; finalizeMove( nextItem, contentX, contentY ); CREATE_TIMER(filter); START_TIMER(filter); KCursorSaver busy( KBusyPtr::busy() ); int msgCount = 0; int msgCountToFilter = serNums.count(); ProgressItem* progressItem = ProgressManager::createProgressItem( "filter"+ProgressManager::getUniqueID(), i18n( "Filtering messages" ) ); progressItem->setTotalItems( msgCountToFilter ); for ( QValueList<unsigned long>::ConstIterator it = serNums.constBegin(); it != serNums.constEnd(); ++it ) { msgCount++; if ( msgCountToFilter - msgCount < 10 || !( msgCount % 20 ) || msgCount <= 10 ) { progressItem->updateProgress(); QString statusMsg = i18n("Filtering message %1 of %2"); statusMsg = statusMsg.arg( msgCount ).arg( msgCountToFilter ); KPIM::BroadcastStatus::instance()->setStatusMsg( statusMsg ); KApplication::kApplication()->eventLoop()->processEvents( QEventLoop::ExcludeUserInput, 50 ); } KMFolder *folder = 0; int idx; KMMsgDict::instance()->getLocation( *it, &folder, &idx ); KMMessage *msg = 0; if (folder) msg = folder->getMsg(idx); if (msg) { if (msg->transferInProgress()) continue; msg->setTransferInProgress(true); if (!msg->isComplete()) { FolderJob *job = mFolder->createJob(msg); connect(job, SIGNAL(messageRetrieved(KMMessage*)), this, SLOT(slotFilterMsg(KMMessage*))); job->start(); } else { if (slotFilterMsg(msg) == 2) break; } } else { kdDebug (5006) << "####### KMHeaders::applyFiltersOnMsg -" " A message went missing during filtering " << endl; } progressItem->incCompletedItems(); } progressItem->setComplete(); progressItem = 0; END_TIMER(filter); SHOW_TIMER(filter); } } //----------------------------------------------------------------------------- void KMHeaders::setMsgRead (int msgId) { KMMsgBase *msgBase = mFolder->getMsgBase( msgId ); if (!msgBase) return; SerNumList serNums; if (msgBase->isNew() || msgBase->isUnread()) { serNums.append( msgBase->getMsgSerNum() ); } KMCommand *command = new KMSetStatusCommand( KMMsgStatusRead, serNums ); command->start(); } //----------------------------------------------------------------------------- void KMHeaders::deleteMsg () { //make sure we have an associated folder (root of folder tree does not). if (!mFolder) return; int contentX, contentY; HeaderItem *nextItem = prepareMove( &contentX, &contentY ); KMMessageList msgList = *selectedMsgs(true); finalizeMove( nextItem, contentX, contentY ); KMCommand *command = new KMDeleteMsgCommand( mFolder, msgList ); connect( command, SIGNAL( completed( KMCommand * ) ), this, SLOT( slotMoveCompleted( KMCommand * ) ) ); command->start(); BroadcastStatus::instance()->setStatusMsg(""); // triggerUpdate(); } //----------------------------------------------------------------------------- void KMHeaders::moveSelectedToFolder( int menuId ) { if (mMenuToFolder[menuId]) moveMsgToFolder( mMenuToFolder[menuId] ); } //----------------------------------------------------------------------------- HeaderItem* KMHeaders::prepareMove( int *contentX, int *contentY ) { HeaderItem *ret = 0; emit maybeDeleting(); disconnect( this, SIGNAL(currentChanged(QListViewItem*)), this, SLOT(highlightMessage(QListViewItem*))); QListViewItem *curItem; HeaderItem *item; curItem = currentItem(); while (curItem && curItem->isSelected() && curItem->itemBelow()) curItem = curItem->itemBelow(); while (curItem && curItem->isSelected() && curItem->itemAbove()) curItem = curItem->itemAbove(); item = static_cast<HeaderItem*>(curItem); *contentX = contentsX(); *contentY = contentsY(); if (item && !item->isSelected()) ret = item; return ret; } //----------------------------------------------------------------------------- void KMHeaders::finalizeMove( HeaderItem *item, int contentX, int contentY ) { emit selected( 0 ); clearSelection(); if ( item ) { setCurrentItem( item ); setSelected( item, true ); setSelectionAnchor( currentItem() ); mPrevCurrent = 0; highlightMessage( item, false); } setContentsPos( contentX, contentY ); makeHeaderVisible(); connect( this, SIGNAL(currentChanged(QListViewItem*)), this, SLOT(highlightMessage(QListViewItem*))); } //----------------------------------------------------------------------------- void KMHeaders::moveMsgToFolder ( KMFolder* destFolder, bool askForConfirmation ) { if ( destFolder == mFolder ) return; // Catch the noop case if ( mFolder->isReadOnly() ) return; KMMessageList msgList = *selectedMsgs(); if ( msgList.isEmpty() ) return; if ( !destFolder && askForConfirmation && // messages shall be deleted KMessageBox::warningContinueCancel(this, i18n("<qt>Do you really want to delete the selected message?<br>" "Once deleted, it cannot be restored.</qt>", "<qt>Do you really want to delete the %n selected messages?<br>" "Once deleted, they cannot be restored.</qt>", msgList.count() ), msgList.count()>1 ? i18n("Delete Messages") : i18n("Delete Message"), KStdGuiItem::del(), "NoConfirmDelete") == KMessageBox::Cancel ) return; // user canceled the action // remember the message to select afterwards int contentX, contentY; HeaderItem *nextItem = prepareMove( &contentX, &contentY ); msgList = *selectedMsgs(true); finalizeMove( nextItem, contentX, contentY ); KMCommand *command = new KMMoveCommand( destFolder, msgList ); connect( command, SIGNAL( completed( KMCommand * ) ), this, SLOT( slotMoveCompleted( KMCommand * ) ) ); command->start(); } void KMHeaders::slotMoveCompleted( KMCommand *command ) { kdDebug(5006) << k_funcinfo << command->result() << endl; bool deleted = static_cast<KMMoveCommand *>( command )->destFolder() == 0; if ( command->result() == KMCommand::OK ) { // make sure the current item is shown makeHeaderVisible(); BroadcastStatus::instance()->setStatusMsg( deleted ? i18n("Messages deleted successfully.") : i18n("Messages moved successfully") ); } else { /* The move failed or the user canceled it; reset the state of all * messages involved and repaint. * * Note: This potentially resets too many items if there is more than one * move going on. Oh well, I suppose no animals will be harmed. * */ for (QListViewItemIterator it(this); it.current(); it++) { HeaderItem *item = static_cast<HeaderItem*>(it.current()); if ( item->aboutToBeDeleted() ) { item->setAboutToBeDeleted ( false ); item->setSelectable ( true ); KMMsgBase *msgBase = mFolder->getMsgBase(item->msgId()); if ( msgBase->isMessage() ) { KMMessage *msg = static_cast<KMMessage *>(msgBase); if ( msg ) msg->setTransferInProgress( false, true ); } } } triggerUpdate(); if ( command->result() == KMCommand::Failed ) BroadcastStatus::instance()->setStatusMsg( deleted ? i18n("Deleting messages failed.") : i18n("Moving messages failed.") ); else BroadcastStatus::instance()->setStatusMsg( deleted ? i18n("Deleting messages canceled.") : i18n("Moving messages canceled.") ); } mOwner->updateMessageActions(); } bool KMHeaders::canUndo() const { return ( kmkernel->undoStack()->size() > 0 ); } //----------------------------------------------------------------------------- void KMHeaders::undo() { kmkernel->undoStack()->undo(); } //----------------------------------------------------------------------------- void KMHeaders::copySelectedToFolder(int menuId ) { if (mMenuToFolder[menuId]) copyMsgToFolder( mMenuToFolder[menuId] ); } //----------------------------------------------------------------------------- void KMHeaders::copyMsgToFolder(KMFolder* destFolder, KMMessage* aMsg) { if ( !destFolder ) return; KMCommand * command = 0; if (aMsg) command = new KMCopyCommand( destFolder, aMsg ); else { KMMessageList msgList = *selectedMsgs(); command = new KMCopyCommand( destFolder, msgList ); } command->start(); } //----------------------------------------------------------------------------- void KMHeaders::setCurrentMsg(int cur) { if (!mFolder) return; if (cur >= mFolder->count()) cur = mFolder->count() - 1; if ((cur >= 0) && (cur < (int)mItems.size())) { clearSelection(); setCurrentItem( mItems[cur] ); setSelected( mItems[cur], true ); setSelectionAnchor( currentItem() ); } makeHeaderVisible(); setFolderInfoStatus(); } //----------------------------------------------------------------------------- void KMHeaders::setSelected( QListViewItem *item, bool selected ) { if ( !item ) return; if ( item->isVisible() ) KListView::setSelected( item, selected ); // If the item is the parent of a closed thread recursively select // children . if ( isThreaded() && !item->isOpen() && item->firstChild() ) { QListViewItem *nextRoot = item->itemBelow(); QListViewItemIterator it( item->firstChild() ); for( ; (*it) != nextRoot; ++it ) { if ( (*it)->isVisible() ) (*it)->setSelected( selected ); } } } void KMHeaders::setSelectedByIndex( QValueList<int> items, bool selected ) { for ( QValueList<int>::Iterator it = items.begin(); it != items.end(); ++it ) { if ( ((*it) >= 0) && ((*it) < (int)mItems.size()) ) { setSelected( mItems[(*it)], selected ); } } } void KMHeaders::clearSelectableAndAboutToBeDeleted( Q_UINT32 serNum ) { // fugly, but I see no way around it for (QListViewItemIterator it(this); it.current(); it++) { HeaderItem *item = static_cast<HeaderItem*>(it.current()); if ( item->aboutToBeDeleted() ) { KMMsgBase *msgBase = mFolder->getMsgBase( item->msgId() ); if ( serNum == msgBase->getMsgSerNum() ) { item->setAboutToBeDeleted ( false ); item->setSelectable ( true ); } } } triggerUpdate(); } //----------------------------------------------------------------------------- KMMessageList* KMHeaders::selectedMsgs(bool toBeDeleted) { mSelMsgBaseList.clear(); for (QListViewItemIterator it(this); it.current(); it++) { if ( it.current()->isSelected() && it.current()->isVisible() ) { HeaderItem *item = static_cast<HeaderItem*>(it.current()); if ( !item->aboutToBeDeleted() ) { // we are already working on this one if (toBeDeleted) { // make sure the item is not uselessly rethreaded and not selectable item->setAboutToBeDeleted ( true ); item->setSelectable ( false ); } KMMsgBase *msgBase = mFolder->getMsgBase(item->msgId()); mSelMsgBaseList.append(msgBase); } } } return &mSelMsgBaseList; } //----------------------------------------------------------------------------- QValueList<int> KMHeaders::selectedItems() { QValueList<int> items; for ( QListViewItemIterator it(this); it.current(); it++ ) { if ( it.current()->isSelected() && it.current()->isVisible() ) { HeaderItem* item = static_cast<HeaderItem*>( it.current() ); items.append( item->msgId() ); } } return items; } //----------------------------------------------------------------------------- int KMHeaders::firstSelectedMsg() const { int selectedMsg = -1; QListViewItem *item; for (item = firstChild(); item; item = item->itemBelow()) if (item->isSelected()) { selectedMsg = (static_cast<HeaderItem*>(item))->msgId(); break; } return selectedMsg; } //----------------------------------------------------------------------------- void KMHeaders::nextMessage() { QListViewItem *lvi = currentItem(); if (lvi && lvi->itemBelow()) { clearSelection(); setSelected( lvi, false ); selectNextMessage(); setSelectionAnchor( currentItem() ); ensureCurrentItemVisible(); } } void KMHeaders::selectNextMessage() { KMMessage *cm = currentMsg(); if ( cm && cm->isBeingParsed() ) return; QListViewItem *lvi = currentItem(); if( lvi ) { QListViewItem *below = lvi->itemBelow(); QListViewItem *temp = lvi; if (lvi && below ) { while (temp) { temp->firstChild(); temp = temp->parent(); } lvi->repaint(); /* test to see if we need to unselect messages on back track */ (below->isSelected() ? setSelected(lvi, false) : setSelected(below, true)); setCurrentItem(below); makeHeaderVisible(); setFolderInfoStatus(); } } } //----------------------------------------------------------------------------- void KMHeaders::prevMessage() { QListViewItem *lvi = currentItem(); if (lvi && lvi->itemAbove()) { clearSelection(); setSelected( lvi, false ); selectPrevMessage(); setSelectionAnchor( currentItem() ); ensureCurrentItemVisible(); } } void KMHeaders::selectPrevMessage() { KMMessage *cm = currentMsg(); if ( cm && cm->isBeingParsed() ) return; QListViewItem *lvi = currentItem(); if( lvi ) { QListViewItem *above = lvi->itemAbove(); QListViewItem *temp = lvi; if (lvi && above) { while (temp) { temp->firstChild(); temp = temp->parent(); } lvi->repaint(); /* test to see if we need to unselect messages on back track */ (above->isSelected() ? setSelected(lvi, false) : setSelected(above, true)); setCurrentItem(above); makeHeaderVisible(); setFolderInfoStatus(); } } } void KMHeaders::incCurrentMessage() { KMMessage *cm = currentMsg(); if ( cm && cm->isBeingParsed() ) return; QListViewItem *lvi = currentItem(); if ( lvi && lvi->itemBelow() ) { disconnect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); setCurrentItem( lvi->itemBelow() ); ensureCurrentItemVisible(); setFocus(); connect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); } } void KMHeaders::decCurrentMessage() { KMMessage *cm = currentMsg(); if ( cm && cm->isBeingParsed() ) return; QListViewItem *lvi = currentItem(); if ( lvi && lvi->itemAbove() ) { disconnect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); setCurrentItem( lvi->itemAbove() ); ensureCurrentItemVisible(); setFocus(); connect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); } } void KMHeaders::selectCurrentMessage() { setCurrentMsg( currentItemIndex() ); highlightMessage( currentItem() ); } //----------------------------------------------------------------------------- void KMHeaders::findUnreadAux( HeaderItem*& item, bool & foundUnreadMessage, bool onlyNew, bool aDirNext ) { KMMsgBase* msgBase = 0; HeaderItem *lastUnread = 0; /* itemAbove() is _slow_ */ if (aDirNext) { while (item) { msgBase = mFolder->getMsgBase(item->msgId()); if (!msgBase) continue; if (msgBase->isUnread() || msgBase->isNew()) foundUnreadMessage = true; if (!onlyNew && (msgBase->isUnread() || msgBase->isNew())) break; if (onlyNew && msgBase->isNew()) break; item = static_cast<HeaderItem*>(item->itemBelow()); } } else { HeaderItem *newItem = static_cast<HeaderItem*>(firstChild()); while (newItem) { msgBase = mFolder->getMsgBase(newItem->msgId()); if (!msgBase) continue; if (msgBase->isUnread() || msgBase->isNew()) foundUnreadMessage = true; if (!onlyNew && (msgBase->isUnread() || msgBase->isNew()) || onlyNew && msgBase->isNew()) lastUnread = newItem; if (newItem == item) break; newItem = static_cast<HeaderItem*>(newItem->itemBelow()); } item = lastUnread; } } //----------------------------------------------------------------------------- int KMHeaders::findUnread(bool aDirNext, int aStartAt, bool onlyNew, bool acceptCurrent) { HeaderItem *item, *pitem; bool foundUnreadMessage = false; if (!mFolder) return -1; if (mFolder->count() <= 0) return -1; if ((aStartAt >= 0) && (aStartAt < (int)mItems.size())) item = mItems[aStartAt]; else { item = currentHeaderItem(); if (!item) { if (aDirNext) item = static_cast<HeaderItem*>(firstChild()); else item = static_cast<HeaderItem*>(lastChild()); } if (!item) return -1; if ( !acceptCurrent ) if (aDirNext) item = static_cast<HeaderItem*>(item->itemBelow()); else item = static_cast<HeaderItem*>(item->itemAbove()); } pitem = item; findUnreadAux( item, foundUnreadMessage, onlyNew, aDirNext ); // We have found an unread item, but it is not necessary the // first unread item. // // Find the ancestor of the unread item closest to the // root and recursively sort all of that ancestors children. if (item) { QListViewItem *next = item; while (next->parent()) next = next->parent(); next = static_cast<HeaderItem*>(next)->firstChildNonConst(); while (next && (next != item)) if (static_cast<HeaderItem*>(next)->firstChildNonConst()) next = next->firstChild(); else if (next->nextSibling()) next = next->nextSibling(); else { while (next && (next != item)) { next = next->parent(); if (next == item) break; if (next && next->nextSibling()) { next = next->nextSibling(); break; } } } } item = pitem; findUnreadAux( item, foundUnreadMessage, onlyNew, aDirNext ); if (item) return item->msgId(); // A kludge to try to keep the number of unread messages in sync int unread = mFolder->countUnread(); if (((unread == 0) && foundUnreadMessage) || ((unread > 0) && !foundUnreadMessage)) { mFolder->correctUnreadMsgsCount(); } return -1; } //----------------------------------------------------------------------------- bool KMHeaders::nextUnreadMessage(bool acceptCurrent) { if ( !mFolder || !mFolder->countUnread() ) return false; int i = findUnread(true, -1, false, acceptCurrent); if ( i < 0 && GlobalSettings::self()->loopOnGotoUnread() != GlobalSettings::EnumLoopOnGotoUnread::DontLoop ) { HeaderItem * first = static_cast<HeaderItem*>(firstChild()); if ( first ) i = findUnread(true, first->msgId(), false, acceptCurrent); // from top } if ( i < 0 ) return false; setCurrentMsg(i); ensureCurrentItemVisible(); return true; } void KMHeaders::ensureCurrentItemVisible() { int i = currentItemIndex(); if ((i >= 0) && (i < (int)mItems.size())) center( contentsX(), itemPos(mItems[i]), 0, 9.0 ); } //----------------------------------------------------------------------------- bool KMHeaders::prevUnreadMessage() { if ( !mFolder || !mFolder->countUnread() ) return false; int i = findUnread(false); if ( i < 0 && GlobalSettings::self()->loopOnGotoUnread() != GlobalSettings::EnumLoopOnGotoUnread::DontLoop ) { HeaderItem * last = static_cast<HeaderItem*>(lastItem()); if ( last ) i = findUnread(false, last->msgId() ); // from bottom } if ( i < 0 ) return false; setCurrentMsg(i); ensureCurrentItemVisible(); return true; } //----------------------------------------------------------------------------- void KMHeaders::slotNoDrag() { // This causes Kolab issue 1569 (encrypted mails sometimes not dragable) // This was introduced in r73594 to fix interference between dnd and // pinentry, which is no longer reproducable now. However, since the // original problem was probably a race and might reappear, let's keep // this workaround in for now and just disable it. // mMousePressed = false; } //----------------------------------------------------------------------------- void KMHeaders::makeHeaderVisible() { if (currentItem()) ensureItemVisible( currentItem() ); } //----------------------------------------------------------------------------- void KMHeaders::highlightMessage(QListViewItem* lvi, bool markitread) { // shouldnt happen but will crash if it does if (lvi && !lvi->isSelectable()) return; HeaderItem *item = static_cast<HeaderItem*>(lvi); if (lvi != mPrevCurrent) { if (mPrevCurrent && mFolder) { KMMessage *prevMsg = mFolder->getMsg(mPrevCurrent->msgId()); if (prevMsg && mReaderWindowActive) { mFolder->ignoreJobsForMessage(prevMsg); if (!prevMsg->transferInProgress()) mFolder->unGetMsg(mPrevCurrent->msgId()); } } mPrevCurrent = item; } if (!item) { emit selected( 0 ); return; } int idx = item->msgId(); KMMessage *msg = mFolder->getMsg(idx); if (mReaderWindowActive && !msg) { emit selected( 0 ); mPrevCurrent = 0; return; } BroadcastStatus::instance()->setStatusMsg(""); if (markitread && idx >= 0) setMsgRead(idx); mItems[idx]->irefresh(); mItems[idx]->repaint(); emit selected( msg ); setFolderInfoStatus(); } void KMHeaders::highlightCurrentThread() { QPtrList<QListViewItem> curThread = currentThread(); QPtrListIterator<QListViewItem> it( curThread ); for ( it.toFirst() ; it.current() ; ++it ) { QListViewItem *lvi = *it; lvi->setSelected( true ); lvi->repaint(); } } void KMHeaders::resetCurrentTime() { mDate.reset(); // only reset exactly during minute switch QTimer::singleShot( ( 60-QTime::currentTime().second() ) * 1000, this, SLOT( resetCurrentTime() ) ); } //----------------------------------------------------------------------------- void KMHeaders::selectMessage(QListViewItem* lvi) { HeaderItem *item = static_cast<HeaderItem*>(lvi); if (!item) return; int idx = item->msgId(); KMMessage *msg = mFolder->getMsg(idx); if (msg && !msg->transferInProgress()) { emit activated(mFolder->getMsg(idx)); } // if (kmkernel->folderIsDraftOrOutbox(mFolder)) // setOpen(lvi, !lvi->isOpen()); } //----------------------------------------------------------------------------- void KMHeaders::updateMessageList( bool set_selection, bool forceJumpToUnread ) { mPrevCurrent = 0; noRepaint = true; clear(); mItems.resize(0); // will contain deleted pointers noRepaint = false; KListView::setSorting( mSortCol, !mSortDescending ); if (!mFolder) { repaint(); return; } readSortOrder( set_selection, forceJumpToUnread ); emit messageListUpdated(); } //----------------------------------------------------------------------------- // KMail Header list selection/navigation description // // If the selection state changes the reader window is updated to show the // current item. // // (The selection state of a message or messages can be changed by pressing // space, or normal/shift/cntrl clicking). // // The following keyboard events are supported when the messages headers list // has focus, Ctrl+Key_Down, Ctrl+Key_Up, Ctrl+Key_Home, Ctrl+Key_End, // Ctrl+Key_Next, Ctrl+Key_Prior, these events change the current item but do // not change the selection state. // // Exception: When shift selecting either with mouse or key press the reader // window is updated regardless of whether of not the selection has changed. void KMHeaders::keyPressEvent( QKeyEvent * e ) { bool cntrl = (e->state() & ControlButton ); bool shft = (e->state() & ShiftButton ); QListViewItem *cur = currentItem(); if (!e || !firstChild()) return; // If no current item, make some first item current when a key is pressed if (!cur) { setCurrentItem( firstChild() ); setSelectionAnchor( currentItem() ); return; } // Handle space key press if (cur->isSelectable() && e->ascii() == ' ' ) { setSelected( cur, !cur->isSelected() ); highlightMessage( cur, false); return; } if (cntrl) { if (!shft) disconnect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); switch (e->key()) { case Key_Down: case Key_Up: case Key_Home: case Key_End: case Key_Next: case Key_Prior: case Key_Escape: KListView::keyPressEvent( e ); } if (!shft) connect(this,SIGNAL(currentChanged(QListViewItem*)), this,SLOT(highlightMessage(QListViewItem*))); } } //----------------------------------------------------------------------------- // Handle RMB press, show pop up menu void KMHeaders::rightButtonPressed( QListViewItem *lvi, const QPoint &, int ) { if (!lvi) return; if (!(lvi->isSelected())) { clearSelection(); } setSelected( lvi, true ); slotRMB(); } //----------------------------------------------------------------------------- void KMHeaders::contentsMousePressEvent(QMouseEvent* e) { mPressPos = e->pos(); QListViewItem *lvi = itemAt( contentsToViewport( e->pos() )); bool wasSelected = false; bool rootDecoClicked = false; if (lvi) { wasSelected = lvi->isSelected(); rootDecoClicked = ( mPressPos.x() <= header()->cellPos( header()->mapToActual( 0 ) ) + treeStepSize() * ( lvi->depth() + ( rootIsDecorated() ? 1 : 0 ) ) + itemMargin() ) && ( mPressPos.x() >= header()->cellPos( header()->mapToActual( 0 ) ) ); if ( rootDecoClicked ) { // Check if our item is the parent of a closed thread and if so, if the root // decoration of the item was clicked (i.e. the +/- sign) which would expand // the thread. In that case, deselect all children, so opening the thread // doesn't cause a flicker. if ( !lvi->isOpen() && lvi->firstChild() ) { QListViewItem *nextRoot = lvi->itemBelow(); QListViewItemIterator it( lvi->firstChild() ); for( ; (*it) != nextRoot; ++it ) (*it)->setSelected( false ); } } } // let klistview do it's thing, expanding/collapsing, selection/deselection KListView::contentsMousePressEvent(e); /* QListView's shift-select selects also invisible items. Until that is fixed, we have to deselect hidden items here manually, so the quick search doesn't mess things up. */ if ( e->state() & ShiftButton ) { QListViewItemIterator it( this, QListViewItemIterator::Invisible ); while ( it.current() ) { it.current()->setSelected( false ); ++it; } } if ( rootDecoClicked ) { // select the thread's children after closing if the parent is selected if ( lvi && !lvi->isOpen() && lvi->isSelected() ) setSelected( lvi, true ); } if ( lvi && !rootDecoClicked ) { if ( lvi != currentItem() ) highlightMessage( lvi ); /* Explicitely set selection state. This is necessary because we want to * also select all children of closed threads when the parent is selected. */ // unless ctrl mask, set selected if it isn't already if ( !( e->state() & ControlButton ) && !wasSelected ) setSelected( lvi, true ); // if ctrl mask, toggle selection if ( e->state() & ControlButton ) setSelected( lvi, !wasSelected ); if ((e->button() == LeftButton) ) mMousePressed = true; } // check if we are on a status column and toggle it if ( lvi && e->button() == LeftButton && !( e->state() & (ShiftButton | ControlButton | AltButton | MetaButton) ) ) { bool flagsToggleable = GlobalSettings::self()->allowLocalFlags() || !(mFolder ? mFolder->isReadOnly() : true); int section = header()->sectionAt( e->pos().x() ); HeaderItem *item = static_cast<HeaderItem*>( lvi ); KMMsgBase *msg = mFolder->getMsgBase(item->msgId()); if ( section == mPaintInfo.flagCol && flagsToggleable ) { setMsgStatus( KMMsgStatusFlag, true ); } else if ( section == mPaintInfo.importantCol && flagsToggleable ) { setMsgStatus( KMMsgStatusFlag, true ); } else if ( section == mPaintInfo.todoCol && flagsToggleable ) { setMsgStatus( KMMsgStatusTodo, true ); } else if ( section == mPaintInfo.watchedIgnoredCol && flagsToggleable ) { if ( msg->isWatched() || msg->isIgnored() ) setMsgStatus( KMMsgStatusIgnored, true ); else setMsgStatus( KMMsgStatusWatched, true ); } else if ( section == mPaintInfo.statusCol ) { if ( msg->isUnread() || msg->isNew() ) setMsgStatus( KMMsgStatusRead ); else setMsgStatus( KMMsgStatusUnread ); } } } //----------------------------------------------------------------------------- void KMHeaders::contentsMouseReleaseEvent(QMouseEvent* e) { if (e->button() != RightButton) KListView::contentsMouseReleaseEvent(e); mMousePressed = false; } //----------------------------------------------------------------------------- void KMHeaders::contentsMouseMoveEvent( QMouseEvent* e ) { if (mMousePressed && (e->pos() - mPressPos).manhattanLength() > KGlobalSettings::dndEventDelay()) { mMousePressed = false; QListViewItem *item = itemAt( contentsToViewport(mPressPos) ); if ( item ) { MailList mailList; unsigned int count = 0; for( QListViewItemIterator it(this); it.current(); it++ ) if( it.current()->isSelected() ) { HeaderItem *item = static_cast<HeaderItem*>(it.current()); KMMsgBase *msg = mFolder->getMsgBase(item->msgId()); // FIXME: msg can be null here which crashes. I think it's a race // because it's very hard to reproduce. (GS) MailSummary mailSummary( msg->getMsgSerNum(), msg->msgIdMD5(), msg->subject(), msg->fromStrip(), msg->toStrip(), msg->date() ); mailList.append( mailSummary ); ++count; } MailListDrag *d = new MailListDrag( mailList, viewport(), new KMTextSource ); // Set pixmap QPixmap pixmap; if( count == 1 ) pixmap = QPixmap( DesktopIcon("message", KIcon::SizeSmall) ); else pixmap = QPixmap( DesktopIcon("kmultiple", KIcon::SizeSmall) ); // Calculate hotspot (as in Konqueror) if( !pixmap.isNull() ) { QPoint hotspot( pixmap.width() / 2, pixmap.height() / 2 ); d->setPixmap( pixmap, hotspot ); } if ( mFolder->isReadOnly() ) d->dragCopy(); else d->drag(); } } } void KMHeaders::highlightMessage(QListViewItem* i) { highlightMessage( i, false ); } //----------------------------------------------------------------------------- void KMHeaders::slotRMB() { if (!topLevelWidget()) return; // safe bet mOwner->updateMessageActions(); // check if the user clicked into a status column and only show the respective menues QListViewItem *item = itemAt( viewport()->mapFromGlobal( QCursor::pos() ) ); if ( item ) { int section = header()->sectionAt( viewportToContents( viewport()->mapFromGlobal( QCursor::pos() ) ).x() ); if ( section == mPaintInfo.flagCol || section == mPaintInfo.importantCol || section == mPaintInfo.todoCol || section == mPaintInfo.statusCol ) { mOwner->statusMenu()->popup( QCursor::pos() ); return; } if ( section == mPaintInfo.watchedIgnoredCol ) { mOwner->threadStatusMenu()->popup( QCursor::pos() ); return; } } QPopupMenu *menu = new QPopupMenu(this); mMenuToFolder.clear(); mOwner->updateMessageMenu(); bool out_folder = kmkernel->folderIsDraftOrOutbox( mFolder ); bool tem_folder = kmkernel->folderIsTemplates( mFolder ); if ( tem_folder ) { mOwner->useAction()->plug( menu ); } else { // show most used actions if( !mFolder->isSent() ) { mOwner->messageActions()->replyMenu()->plug( menu ); } mOwner->forwardMenu()->plug( menu ); if( mOwner->sendAgainAction()->isEnabled() ) { mOwner->sendAgainAction()->plug( menu ); } else { mOwner->editAction()->plug( menu ); } } menu->insertSeparator(); QPopupMenu *msgCopyMenu = new QPopupMenu(menu); mOwner->folderTree()->folderToPopupMenu( KMFolderTree::CopyMessage, this, &mMenuToFolder, msgCopyMenu ); menu->insertItem(i18n("&Copy To"), msgCopyMenu); if ( mFolder->isReadOnly() ) { int id = menu->insertItem( i18n("&Move To") ); menu->setItemEnabled( id, false ); } else { QPopupMenu *msgMoveMenu = new QPopupMenu(menu); mOwner->folderTree()->folderToPopupMenu( KMFolderTree::MoveMessage, this, &mMenuToFolder, msgMoveMenu ); menu->insertItem(i18n("&Move To"), msgMoveMenu); } menu->insertSeparator(); mOwner->statusMenu()->plug( menu ); // Mark Message menu if ( mOwner->threadStatusMenu()->isEnabled() ) { mOwner->threadStatusMenu()->plug( menu ); // Mark Thread menu } if ( !out_folder && !tem_folder ) { menu->insertSeparator(); mOwner->filterMenu()->plug( menu ); // Create Filter menu mOwner->action( "apply_filter_actions" )->plug( menu ); } menu->insertSeparator(); mOwner->printAction()->plug(menu); mOwner->saveAsAction()->plug(menu); mOwner->saveAttachmentsAction()->plug(menu); menu->insertSeparator(); if ( mFolder->isTrash() ) { mOwner->deleteAction()->plug(menu); if ( mOwner->trashThreadAction()->isEnabled() ) mOwner->deleteThreadAction()->plug(menu); } else { mOwner->trashAction()->plug(menu); if ( mOwner->trashThreadAction()->isEnabled() ) mOwner->trashThreadAction()->plug(menu); } menu->insertSeparator(); mOwner->messageActions()->createTodoAction()->plug( menu ); KAcceleratorManager::manage(menu); kmkernel->setContextMenuShown( true ); menu->exec(QCursor::pos(), 0); kmkernel->setContextMenuShown( false ); delete menu; } //----------------------------------------------------------------------------- KMMessage* KMHeaders::currentMsg() { HeaderItem *hi = currentHeaderItem(); if (!hi) return 0; else return mFolder->getMsg(hi->msgId()); } //----------------------------------------------------------------------------- HeaderItem* KMHeaders::currentHeaderItem() { return static_cast<HeaderItem*>(currentItem()); } //----------------------------------------------------------------------------- int KMHeaders::currentItemIndex() { HeaderItem* item = currentHeaderItem(); if (item) return item->msgId(); else return -1; } //----------------------------------------------------------------------------- void KMHeaders::setCurrentItemByIndex(int msgIdx) { if (!mFolder->isOpened()) setFolder(mFolder); if ((msgIdx >= 0) && (msgIdx < (int)mItems.size())) { clearSelection(); bool unchanged = (currentItem() == mItems[msgIdx]); setCurrentItem( mItems[msgIdx] ); setSelected( mItems[msgIdx], true ); setSelectionAnchor( currentItem() ); if (unchanged) highlightMessage( mItems[msgIdx], false); makeHeaderVisible(); } } //----------------------------------------------------------------------------- int KMHeaders::topItemIndex() { HeaderItem *item = static_cast<HeaderItem*>( itemAt( QPoint( 1, 1 ) ) ); if ( item ) return item->msgId(); else return -1; } //----------------------------------------------------------------------------- void KMHeaders::setTopItemByIndex( int aMsgIdx) { if ( aMsgIdx < 0 || static_cast<unsigned int>( aMsgIdx ) >= mItems.size() ) return; const QListViewItem * const item = mItems[aMsgIdx]; if ( item ) setContentsPos( 0, itemPos( item ) ); } //----------------------------------------------------------------------------- void KMHeaders::setNestedOverride( bool override ) { mSortInfo.dirty = true; mNestedOverride = override; setRootIsDecorated( nestingPolicy != AlwaysOpen && isThreaded() ); QString sortFile = mFolder->indexLocation() + ".sorted"; unlink(QFile::encodeName(sortFile)); reset(); } //----------------------------------------------------------------------------- void KMHeaders::setSubjectThreading( bool aSubjThreading ) { mSortInfo.dirty = true; mSubjThreading = aSubjThreading; QString sortFile = mFolder->indexLocation() + ".sorted"; unlink(QFile::encodeName(sortFile)); reset(); } //----------------------------------------------------------------------------- void KMHeaders::setOpen( QListViewItem *item, bool open ) { if ((nestingPolicy != AlwaysOpen)|| open) ((HeaderItem*)item)->setOpenRecursive( open ); } //----------------------------------------------------------------------------- const KMMsgBase* KMHeaders::getMsgBaseForItem( const QListViewItem *item ) const { const HeaderItem *hi = static_cast<const HeaderItem *> ( item ); return mFolder->getMsgBase( hi->msgId() ); } //----------------------------------------------------------------------------- void KMHeaders::setSorting( int column, bool ascending ) { if (column != -1) { // carsten: really needed? // if (column != mSortCol) // setColumnText( mSortCol, QIconSet( QPixmap()), columnText( mSortCol )); if(mSortInfo.dirty || column != mSortInfo.column || ascending != mSortInfo.ascending) { //dirtied QObject::disconnect(header(), SIGNAL(clicked(int)), this, SLOT(dirtySortOrder(int))); mSortInfo.dirty = true; } assert(column >= 0); mSortCol = column; mSortDescending = !ascending; if (!ascending && (column == mPaintInfo.dateCol)) mPaintInfo.orderOfArrival = !mPaintInfo.orderOfArrival; if (!ascending && (column == mPaintInfo.subCol)) mPaintInfo.status = !mPaintInfo.status; QString colText = i18n( "Date" ); if (mPaintInfo.orderOfArrival) colText = i18n( "Order of Arrival" ); setColumnText( mPaintInfo.dateCol, colText); colText = i18n( "Subject" ); if (mPaintInfo.status) colText = colText + i18n( " (Status)" ); setColumnText( mPaintInfo.subCol, colText); } KListView::setSorting( column, ascending ); ensureCurrentItemVisible(); // Make sure the config and .sorted file are updated, otherwise stale info // is read on new imap mail. ( folder->folderComplete() -> readSortOrder() ). if ( mFolder ) { writeFolderConfig(); writeSortOrder(); } } //Flatten the list and write it to disk static void internalWriteItem(FILE *sortStream, KMFolder *folder, int msgid, int parent_id, QString key, bool update_discover=true) { unsigned long msgSerNum; unsigned long parentSerNum; msgSerNum = KMMsgDict::instance()->getMsgSerNum( folder, msgid ); if (parent_id >= 0) parentSerNum = KMMsgDict::instance()->getMsgSerNum( folder, parent_id ) + KMAIL_RESERVED; else parentSerNum = (unsigned long)(parent_id + KMAIL_RESERVED); fwrite(&msgSerNum, sizeof(msgSerNum), 1, sortStream); fwrite(&parentSerNum, sizeof(parentSerNum), 1, sortStream); Q_INT32 len = key.length() * sizeof(QChar); fwrite(&len, sizeof(len), 1, sortStream); if (len) fwrite(key.unicode(), QMIN(len, KMAIL_MAX_KEY_LEN), 1, sortStream); if (update_discover) { //update the discovered change count Q_INT32 discovered_count = 0; fseek(sortStream, KMAIL_MAGIC_HEADER_OFFSET + 20, SEEK_SET); fread(&discovered_count, sizeof(discovered_count), 1, sortStream); discovered_count++; fseek(sortStream, KMAIL_MAGIC_HEADER_OFFSET + 20, SEEK_SET); fwrite(&discovered_count, sizeof(discovered_count), 1, sortStream); } } void KMHeaders::folderCleared() { mSortCacheItems.clear(); //autoDelete is true mSubjectLists.clear(); mImperfectlyThreadedList.clear(); mPrevCurrent = 0; emit selected(0); } void KMHeaders::folderClosed() { mFolder->open( "kmheaders" ); folderCleared(); } bool KMHeaders::writeSortOrder() { QString sortFile = KMAIL_SORT_FILE(mFolder); if (!mSortInfo.dirty) { struct stat stat_tmp; if(stat(QFile::encodeName(sortFile), &stat_tmp) == -1) { mSortInfo.dirty = true; } } if (mSortInfo.dirty) { if (!mFolder->count()) { // Folder is empty now, remove the sort file. unlink(QFile::encodeName(sortFile)); return true; } QString tempName = sortFile + ".temp"; unlink(QFile::encodeName(tempName)); FILE *sortStream = fopen(QFile::encodeName(tempName), "w"); if (!sortStream) return false; mSortInfo.ascending = !mSortDescending; mSortInfo.dirty = false; mSortInfo.column = mSortCol; fprintf(sortStream, KMAIL_SORT_HEADER, KMAIL_SORT_VERSION); //magic header information Q_INT32 byteOrder = 0x12345678; Q_INT32 column = mSortCol; Q_INT32 ascending= !mSortDescending; Q_INT32 threaded = isThreaded(); Q_INT32 appended=0; Q_INT32 discovered_count = 0; Q_INT32 sorted_count=0; fwrite(&byteOrder, sizeof(byteOrder), 1, sortStream); fwrite(&column, sizeof(column), 1, sortStream); fwrite(&ascending, sizeof(ascending), 1, sortStream); fwrite(&threaded, sizeof(threaded), 1, sortStream); fwrite(&appended, sizeof(appended), 1, sortStream); fwrite(&discovered_count, sizeof(discovered_count), 1, sortStream); fwrite(&sorted_count, sizeof(sorted_count), 1, sortStream); QPtrStack<HeaderItem> items; { QPtrStack<QListViewItem> s; for (QListViewItem * i = firstChild(); i; ) { items.push((HeaderItem *)i); if ( i->firstChild() ) { s.push( i ); i = i->firstChild(); } else if( i->nextSibling()) { i = i->nextSibling(); } else { for(i=0; !i && s.count(); i = s.pop()->nextSibling()) ; } } } KMMsgBase *kmb; while(HeaderItem *i = items.pop()) { int parent_id = -1; //no parent, top level if (threaded) { kmb = mFolder->getMsgBase( i->msgId() ); assert(kmb); // I have seen 0L come out of this, called from // KMHeaders::setFolder(0xgoodpointer, false); // I see this crash too. after rebuilding a broken index on a dimap folder. always QString replymd5 = kmb->replyToIdMD5(); QString replyToAuxId = kmb->replyToAuxIdMD5(); SortCacheItem *p = NULL; if(!replymd5.isEmpty()) p = mSortCacheItems[replymd5]; if (p) parent_id = p->id(); // We now have either found a parent, or set it to -1, which means that // it will be reevaluated when a message is added, for example. If there // is no replyToId and no replyToAuxId and the message is not prefixed, // this message is top level, and will always be, so no need to // reevaluate it. if (replymd5.isEmpty() && replyToAuxId.isEmpty() && !kmb->subjectIsPrefixed() ) parent_id = -2; // FIXME also mark messages with -1 as -2 a certain amount of time after // their arrival, since it becomes very unlikely that a new parent for // them will show up. (Ingo suggests a month.) -till } internalWriteItem(sortStream, mFolder, i->msgId(), parent_id, i->key(mSortCol, !mSortDescending), false); //double check for magic headers sorted_count++; } //magic header twice, case they've changed fseek(sortStream, KMAIL_MAGIC_HEADER_OFFSET, SEEK_SET); fwrite(&byteOrder, sizeof(byteOrder), 1, sortStream); fwrite(&column, sizeof(column), 1, sortStream); fwrite(&ascending, sizeof(ascending), 1, sortStream); fwrite(&threaded, sizeof(threaded), 1, sortStream); fwrite(&appended, sizeof(appended), 1, sortStream); fwrite(&discovered_count, sizeof(discovered_count), 1, sortStream); fwrite(&sorted_count, sizeof(sorted_count), 1, sortStream); if (sortStream && ferror(sortStream)) { fclose(sortStream); unlink(QFile::encodeName(sortFile)); kdWarning(5006) << "Error: Failure modifying " << sortFile << " (No space left on device?)" << endl; kdWarning(5006) << __FILE__ << ":" << __LINE__ << endl; kmkernel->emergencyExit( i18n("Failure modifying %1\n(No space left on device?)").arg( sortFile )); } fclose(sortStream); ::rename(QFile::encodeName(tempName), QFile::encodeName(sortFile)); } return true; } void KMHeaders::appendItemToSortFile(HeaderItem *khi) { QString sortFile = KMAIL_SORT_FILE(mFolder); if(FILE *sortStream = fopen(QFile::encodeName(sortFile), "r+")) { int parent_id = -1; //no parent, top level if (isThreaded()) { SortCacheItem *sci = khi->sortCacheItem(); KMMsgBase *kmb = mFolder->getMsgBase( khi->msgId() ); if(sci->parent() && !sci->isImperfectlyThreaded()) parent_id = sci->parent()->id(); else if(kmb->replyToIdMD5().isEmpty() && kmb->replyToAuxIdMD5().isEmpty() && !kmb->subjectIsPrefixed()) parent_id = -2; } internalWriteItem(sortStream, mFolder, khi->msgId(), parent_id, khi->key(mSortCol, !mSortDescending), false); //update the appended flag FIXME obsolete? Q_INT32 appended = 1; fseek(sortStream, KMAIL_MAGIC_HEADER_OFFSET + 16, SEEK_SET); fwrite(&appended, sizeof(appended), 1, sortStream); fseek(sortStream, KMAIL_MAGIC_HEADER_OFFSET + 16, SEEK_SET); if (sortStream && ferror(sortStream)) { fclose(sortStream); unlink(QFile::encodeName(sortFile)); kdWarning(5006) << "Error: Failure modifying " << sortFile << " (No space left on device?)" << endl; kdWarning(5006) << __FILE__ << ":" << __LINE__ << endl; kmkernel->emergencyExit( i18n("Failure modifying %1\n(No space left on device?)").arg( sortFile )); } fclose(sortStream); } else { mSortInfo.dirty = true; } } void KMHeaders::dirtySortOrder(int column) { mSortInfo.dirty = true; QObject::disconnect(header(), SIGNAL(clicked(int)), this, SLOT(dirtySortOrder(int))); setSorting(column, mSortInfo.column == column ? !mSortInfo.ascending : true); } // ----------------- void SortCacheItem::updateSortFile( FILE *sortStream, KMFolder *folder, bool waiting_for_parent, bool update_discover) { if(mSortOffset == -1) { fseek(sortStream, 0, SEEK_END); mSortOffset = ftell(sortStream); } else { fseek(sortStream, mSortOffset, SEEK_SET); } int parent_id = -1; if(!waiting_for_parent) { if(mParent && !isImperfectlyThreaded()) parent_id = mParent->id(); } internalWriteItem(sortStream, folder, mId, parent_id, mKey, update_discover); } static bool compare_ascending = false; static bool compare_toplevel = true; static int compare_SortCacheItem(const void *s1, const void *s2) { if ( !s1 || !s2 ) return 0; SortCacheItem **b1 = (SortCacheItem **)s1; SortCacheItem **b2 = (SortCacheItem **)s2; int ret = (*b1)->key().compare((*b2)->key()); if(compare_ascending || !compare_toplevel) ret = -ret; return ret; } // Debugging helpers void KMHeaders::printSubjectThreadingTree() { QDictIterator< QPtrList< SortCacheItem > > it ( mSubjectLists ); kdDebug(5006) << "SubjectThreading tree: " << endl; for( ; it.current(); ++it ) { QPtrList<SortCacheItem> list = *( it.current() ); QPtrListIterator<SortCacheItem> it2( list ) ; kdDebug(5006) << "Subject MD5: " << it.currentKey() << " list: " << endl; for( ; it2.current(); ++it2 ) { SortCacheItem *sci = it2.current(); kdDebug(5006) << " item:" << sci << " sci id: " << sci->id() << endl; } } kdDebug(5006) << endl; } void KMHeaders::printThreadingTree() { kdDebug(5006) << "Threading tree: " << endl; QDictIterator<SortCacheItem> it( mSortCacheItems ); kdDebug(5006) << endl; for( ; it.current(); ++it ) { SortCacheItem *sci = it.current(); kdDebug(5006) << "MsgId MD5: " << it.currentKey() << " message id: " << sci->id() << endl; } for (int i = 0; i < (int)mItems.size(); ++i) { HeaderItem *item = mItems[i]; int parentCacheId = item->sortCacheItem()->parent()?item->sortCacheItem()->parent()->id():0; kdDebug( 5006 ) << "SortCacheItem: " << item->sortCacheItem()->id() << " parent: " << parentCacheId << endl; kdDebug( 5006 ) << "Item: " << item << " sortCache: " << item->sortCacheItem() << " parent: " << item->sortCacheItem()->parent() << endl; } kdDebug(5006) << endl; } // ------------------------------------- void KMHeaders::buildThreadingTree( QMemArray<SortCacheItem *> sortCache ) { mSortCacheItems.clear(); mSortCacheItems.resize( mFolder->count() * 2 ); // build a dict of all message id's for(int x = 0; x < mFolder->count(); x++) { KMMsgBase *mi = mFolder->getMsgBase(x); QString md5 = mi->msgIdMD5(); if(!md5.isEmpty()) mSortCacheItems.replace(md5, sortCache[x]); } } void KMHeaders::buildSubjectThreadingTree( QMemArray<SortCacheItem *> sortCache ) { mSubjectLists.clear(); // autoDelete is true mSubjectLists.resize( mFolder->count() * 2 ); for(int x = 0; x < mFolder->count(); x++) { // Only a lot items that are now toplevel if ( sortCache[x]->parent() && sortCache[x]->parent()->id() != -666 ) continue; KMMsgBase *mi = mFolder->getMsgBase(x); QString subjMD5 = mi->strippedSubjectMD5(); if (subjMD5.isEmpty()) { mFolder->getMsgBase(x)->initStrippedSubjectMD5(); subjMD5 = mFolder->getMsgBase(x)->strippedSubjectMD5(); } if( subjMD5.isEmpty() ) continue; /* For each subject, keep a list of items with that subject * (stripped of prefixes) sorted by date. */ if (!mSubjectLists.find(subjMD5)) mSubjectLists.insert(subjMD5, new QPtrList<SortCacheItem>()); /* Insertion sort by date. These lists are expected to be very small. * Also, since the messages are roughly ordered by date in the store, * they should mostly be prepended at the very start, so insertion is * cheap. */ int p=0; for (QPtrListIterator<SortCacheItem> it(*mSubjectLists[subjMD5]); it.current(); ++it) { KMMsgBase *mb = mFolder->getMsgBase((*it)->id()); if ( mb->date() < mi->date()) break; p++; } mSubjectLists[subjMD5]->insert( p, sortCache[x]); sortCache[x]->setSubjectThreadingList( mSubjectLists[subjMD5] ); } } SortCacheItem* KMHeaders::findParent(SortCacheItem *item) { SortCacheItem *parent = NULL; if (!item) return parent; KMMsgBase *msg = mFolder->getMsgBase(item->id()); QString replyToIdMD5 = msg->replyToIdMD5(); item->setImperfectlyThreaded(true); /* First, try if the message our Reply-To header points to * is available to thread below. */ if(!replyToIdMD5.isEmpty()) { parent = mSortCacheItems[replyToIdMD5]; if (parent) item->setImperfectlyThreaded(false); } if (!parent) { // If we dont have a replyToId, or if we have one and the // corresponding message is not in this folder, as happens // if you keep your outgoing messages in an OUTBOX, for // example, try the list of references, because the second // to last will likely be in this folder. replyToAuxIdMD5 // contains the second to last one. QString ref = msg->replyToAuxIdMD5(); if (!ref.isEmpty()) parent = mSortCacheItems[ref]; } return parent; } SortCacheItem* KMHeaders::findParentBySubject(SortCacheItem *item) { SortCacheItem *parent = NULL; if (!item) return parent; KMMsgBase *msg = mFolder->getMsgBase(item->id()); // Let's try by subject, but only if the subject is prefixed. // This is necessary to make for example cvs commit mailing lists // work as expected without having to turn threading off alltogether. if (!msg->subjectIsPrefixed()) return parent; QString replyToIdMD5 = msg->replyToIdMD5(); QString subjMD5 = msg->strippedSubjectMD5(); if (!subjMD5.isEmpty() && mSubjectLists[subjMD5]) { /* Iterate over the list of potential parents with the same * subject, and take the closest one by date. */ for (QPtrListIterator<SortCacheItem> it2(*mSubjectLists[subjMD5]); it2.current(); ++it2) { KMMsgBase *mb = mFolder->getMsgBase((*it2)->id()); if ( !mb ) return parent; // make sure it's not ourselves if ( item == (*it2) ) continue; int delta = msg->date() - mb->date(); // delta == 0 is not allowed, to avoid circular threading // with duplicates. if (delta > 0 ) { // Don't use parents more than 6 weeks older than us. if (delta < 3628899) parent = (*it2); break; } } } return parent; } bool KMHeaders::readSortOrder( bool set_selection, bool forceJumpToUnread ) { if (!mFolder->isOpened()) mFolder->open("kmheaders"); //all cases Q_INT32 column, ascending, threaded, discovered_count, sorted_count, appended; Q_INT32 deleted_count = 0; bool unread_exists = false; bool jumpToUnread = (GlobalSettings::self()->actionEnterFolder() == GlobalSettings::EnumActionEnterFolder::SelectFirstUnreadNew) || forceJumpToUnread; QMemArray<SortCacheItem *> sortCache(mFolder->count()); bool error = false; //threaded cases QPtrList<SortCacheItem> unparented; mImperfectlyThreadedList.clear(); //cleanup mItems.fill( 0, mFolder->count() ); sortCache.fill( 0 ); mRoot->clearChildren(); QString sortFile = KMAIL_SORT_FILE(mFolder); FILE *sortStream = fopen(QFile::encodeName(sortFile), "r+"); mSortInfo.fakeSort = 0; if(sortStream) { mSortInfo.fakeSort = 1; int version = 0; if (fscanf(sortStream, KMAIL_SORT_HEADER, &version) != 1) version = -1; if(version == KMAIL_SORT_VERSION) { Q_INT32 byteOrder = 0; fread(&byteOrder, sizeof(byteOrder), 1, sortStream); if (byteOrder == 0x12345678) { fread(&column, sizeof(column), 1, sortStream); fread(&ascending, sizeof(ascending), 1, sortStream); fread(&threaded, sizeof(threaded), 1, sortStream); fread(&appended, sizeof(appended), 1, sortStream); fread(&discovered_count, sizeof(discovered_count), 1, sortStream); fread(&sorted_count, sizeof(sorted_count), 1, sortStream); //Hackyness to work around qlistview problems KListView::setSorting(-1); header()->setSortIndicator(column, ascending); QObject::connect(header(), SIGNAL(clicked(int)), this, SLOT(dirtySortOrder(int))); //setup mSortInfo here now, as above may change it mSortInfo.dirty = false; mSortInfo.column = (short)column; mSortInfo.ascending = (compare_ascending = ascending); SortCacheItem *item; unsigned long serNum, parentSerNum; int id, len, parent, x; QChar *tmp_qchar = 0; int tmp_qchar_len = 0; const int mFolderCount = mFolder->count(); QString key; CREATE_TIMER(parse); START_TIMER(parse); for(x = 0; !feof(sortStream) && !error; x++) { off_t offset = ftell(sortStream); KMFolder *folder; //parse if(!fread(&serNum, sizeof(serNum), 1, sortStream) || //short read means to end !fread(&parentSerNum, sizeof(parentSerNum), 1, sortStream) || !fread(&len, sizeof(len), 1, sortStream)) { break; } if ((len < 0) || (len > KMAIL_MAX_KEY_LEN)) { kdDebug(5006) << "Whoa.2! len " << len << " " << __FILE__ << ":" << __LINE__ << endl; error = true; continue; } if(len) { if(len > tmp_qchar_len) { tmp_qchar = (QChar *)realloc(tmp_qchar, len); tmp_qchar_len = len; } if(!fread(tmp_qchar, len, 1, sortStream)) break; key = QString(tmp_qchar, len / 2); } else { key = QString(""); //yuck } KMMsgDict::instance()->getLocation(serNum, &folder, &id); if (folder != mFolder) { ++deleted_count; continue; } if (parentSerNum < KMAIL_RESERVED) { parent = (int)parentSerNum - KMAIL_RESERVED; } else { KMMsgDict::instance()->getLocation(parentSerNum - KMAIL_RESERVED, &folder, &parent); if (folder != mFolder) parent = -1; } if ((id < 0) || (id >= mFolderCount) || (parent < -2) || (parent >= mFolderCount)) { // sanity checking kdDebug(5006) << "Whoa.1! " << __FILE__ << ":" << __LINE__ << endl; error = true; continue; } if ((item=sortCache[id])) { if (item->id() != -1) { kdDebug(5006) << "Whoa.3! " << __FILE__ << ":" << __LINE__ << endl; error = true; continue; } item->setKey(key); item->setId(id); item->setOffset(offset); } else { item = sortCache[id] = new SortCacheItem(id, key, offset); } if (threaded && parent != -2) { if(parent == -1) { unparented.append(item); mRoot->addUnsortedChild(item); } else { if( ! sortCache[parent] ) { sortCache[parent] = new SortCacheItem; } sortCache[parent]->addUnsortedChild(item); } } else { if(x < sorted_count ) mRoot->addSortedChild(item); else { mRoot->addUnsortedChild(item); } } } if (error || (x != sorted_count + discovered_count)) {// sanity check kdDebug(5006) << endl << "Whoa: x " << x << ", sorted_count " << sorted_count << ", discovered_count " << discovered_count << ", count " << mFolder->count() << endl << endl; fclose(sortStream); sortStream = 0; } if(tmp_qchar) free(tmp_qchar); END_TIMER(parse); SHOW_TIMER(parse); } else { fclose(sortStream); sortStream = 0; } } else { fclose(sortStream); sortStream = 0; } } if (!sortStream) { mSortInfo.dirty = true; mSortInfo.column = column = mSortCol; mSortInfo.ascending = ascending = !mSortDescending; threaded = (isThreaded()); sorted_count = discovered_count = appended = 0; KListView::setSorting( mSortCol, !mSortDescending ); } //fill in empty holes if((sorted_count + discovered_count - deleted_count) < mFolder->count()) { CREATE_TIMER(holes); START_TIMER(holes); KMMsgBase *msg = 0; for(int x = 0; x < mFolder->count(); x++) { if((!sortCache[x] || (sortCache[x]->id() < 0)) && (msg=mFolder->getMsgBase(x))) { int sortOrder = column; if (mPaintInfo.orderOfArrival) sortOrder |= (1 << 6); if (mPaintInfo.status) sortOrder |= (1 << 5); sortCache[x] = new SortCacheItem( x, HeaderItem::generate_key( this, msg, &mPaintInfo, sortOrder )); if(threaded) unparented.append(sortCache[x]); else mRoot->addUnsortedChild(sortCache[x]); if(sortStream) sortCache[x]->updateSortFile(sortStream, mFolder, true, true); discovered_count++; appended = 1; } } END_TIMER(holes); SHOW_TIMER(holes); } // Make sure we've placed everything in parent/child relationship. All // messages with a parent id of -1 in the sort file are reevaluated here. if (threaded) buildThreadingTree( sortCache ); QPtrList<SortCacheItem> toBeSubjThreaded; if (threaded && !unparented.isEmpty()) { CREATE_TIMER(reparent); START_TIMER(reparent); for(QPtrListIterator<SortCacheItem> it(unparented); it.current(); ++it) { SortCacheItem *item = (*it); SortCacheItem *parent = findParent( item ); // If we have a parent, make sure it's not ourselves if ( parent && (parent != (*it)) ) { parent->addUnsortedChild((*it)); if(sortStream) (*it)->updateSortFile(sortStream, mFolder); } else { // if we will attempt subject threading, add to the list, // otherwise to the root with them if (mSubjThreading) toBeSubjThreaded.append((*it)); else mRoot->addUnsortedChild((*it)); } } if (mSubjThreading) { buildSubjectThreadingTree( sortCache ); for(QPtrListIterator<SortCacheItem> it(toBeSubjThreaded); it.current(); ++it) { SortCacheItem *item = (*it); SortCacheItem *parent = findParentBySubject( item ); if ( parent ) { parent->addUnsortedChild((*it)); if(sortStream) (*it)->updateSortFile(sortStream, mFolder); } else { //oh well we tried, to the root with you! mRoot->addUnsortedChild((*it)); } } } END_TIMER(reparent); SHOW_TIMER(reparent); } //create headeritems CREATE_TIMER(header_creation); START_TIMER(header_creation); HeaderItem *khi; SortCacheItem *i, *new_kci; QPtrQueue<SortCacheItem> s; s.enqueue(mRoot); compare_toplevel = true; do { i = s.dequeue(); const QPtrList<SortCacheItem> *sorted = i->sortedChildren(); int unsorted_count, unsorted_off=0; SortCacheItem **unsorted = i->unsortedChildren(unsorted_count); if(unsorted) qsort(unsorted, unsorted_count, sizeof(SortCacheItem *), //sort compare_SortCacheItem); /* The sorted list now contains all sorted children of this item, while * the (aptly named) unsorted array contains all as of yet unsorted * ones. It has just been qsorted, so it is in itself sorted. These two * sorted lists are now merged into one. */ for(QPtrListIterator<SortCacheItem> it(*sorted); (unsorted && unsorted_off < unsorted_count) || it.current(); ) { /* As long as we have something in the sorted list and there is nothing unsorted left, use the item from the sorted list. Also if we are sorting descendingly and the sorted item is supposed to be sorted before the unsorted one do so. In the ascending case we invert the logic for non top level items. */ if( it.current() && ( !unsorted || unsorted_off >= unsorted_count || ( ( !ascending || (ascending && !compare_toplevel) ) && (*it)->key() < unsorted[unsorted_off]->key() ) || ( ascending && (*it)->key() >= unsorted[unsorted_off]->key() ) ) ) { new_kci = (*it); ++it; } else { /* Otherwise use the next item of the unsorted list */ new_kci = unsorted[unsorted_off++]; } if(new_kci->item() || new_kci->parent() != i) //could happen if you reparent continue; if(threaded && i->item()) { // If the parent is watched or ignored, propagate that to it's // children if (mFolder->getMsgBase(i->id())->isWatched()) mFolder->getMsgBase(new_kci->id())->setStatus(KMMsgStatusWatched); if (mFolder->getMsgBase(i->id())->isIgnored()) mFolder->getMsgBase(new_kci->id())->setStatus(KMMsgStatusIgnored); khi = new HeaderItem(i->item(), new_kci->id(), new_kci->key()); } else { khi = new HeaderItem(this, new_kci->id(), new_kci->key()); } new_kci->setItem(mItems[new_kci->id()] = khi); if(new_kci->hasChildren()) s.enqueue(new_kci); // we always jump to new messages, but we only jump to // unread messages if we are told to do so if ( ( mFolder->getMsgBase(new_kci->id())->isNew() && GlobalSettings::self()->actionEnterFolder() == GlobalSettings::EnumActionEnterFolder::SelectFirstNew ) || ( ( mFolder->getMsgBase(new_kci->id())->isNew() || mFolder->getMsgBase(new_kci->id())->isUnread() ) && jumpToUnread ) ) { unread_exists = true; } } // If we are sorting by date and ascending the top level items are sorted // ascending and the threads themselves are sorted descending. One wants // to have new threads on top but the threads themselves top down. if (mSortCol == paintInfo()->dateCol) compare_toplevel = false; } while(!s.isEmpty()); for(int x = 0; x < mFolder->count(); x++) { //cleanup if (!sortCache[x]) { // not yet there? continue; } if (!sortCache[x]->item()) { // we missed a message, how did that happen ? kdDebug(5006) << "KMHeaders::readSortOrder - msg could not be threaded. " << endl << "Please talk to your threading counselor asap. " << endl; khi = new HeaderItem(this, sortCache[x]->id(), sortCache[x]->key()); sortCache[x]->setItem(mItems[sortCache[x]->id()] = khi); } // Add all imperfectly threaded items to a list, so they can be // reevaluated when a new message arrives which might be a better parent. // Important for messages arriving out of order. if (threaded && sortCache[x]->isImperfectlyThreaded()) { mImperfectlyThreadedList.append(sortCache[x]->item()); } // Set the reverse mapping HeaderItem -> SortCacheItem. Needed for // keeping the data structures up to date on removal, for example. sortCache[x]->item()->setSortCacheItem(sortCache[x]); } if (getNestingPolicy()<2) for (HeaderItem *khi=static_cast<HeaderItem*>(firstChild()); khi!=0;khi=static_cast<HeaderItem*>(khi->nextSibling())) khi->setOpen(true); END_TIMER(header_creation); SHOW_TIMER(header_creation); if(sortStream) { //update the .sorted file now // heuristic for when it's time to rewrite the .sorted file if( discovered_count * discovered_count > sorted_count - deleted_count ) { mSortInfo.dirty = true; } else { //update the appended flag appended = 0; fseek(sortStream, KMAIL_MAGIC_HEADER_OFFSET + 16, SEEK_SET); fwrite(&appended, sizeof(appended), 1, sortStream); } } //show a message CREATE_TIMER(selection); START_TIMER(selection); if(set_selection) { int first_unread = -1; if (unread_exists) { HeaderItem *item = static_cast<HeaderItem*>(firstChild()); while (item) { if ( ( mFolder->getMsgBase(item->msgId())->isNew() && GlobalSettings::self()->actionEnterFolder() == GlobalSettings::EnumActionEnterFolder::SelectFirstNew ) || ( ( mFolder->getMsgBase(item->msgId())->isNew() || mFolder->getMsgBase(item->msgId())->isUnread() ) && jumpToUnread ) ) { first_unread = item->msgId(); break; } item = static_cast<HeaderItem*>(item->itemBelow()); } } if(first_unread == -1 ) { setTopItemByIndex(mTopItem); if ( mCurrentItem >= 0 ) setCurrentItemByIndex( mCurrentItem ); else if ( mCurrentItemSerNum > 0 ) setCurrentItemBySerialNum( mCurrentItemSerNum ); else setCurrentItemByIndex( 0 ); } else { setCurrentItemByIndex(first_unread); makeHeaderVisible(); center( contentsX(), itemPos(mItems[first_unread]), 0, 9.0 ); } } else { // only reset the selection if we have no current item if (mCurrentItem <= 0) { setTopItemByIndex(mTopItem); setCurrentItemByIndex(0); } } END_TIMER(selection); SHOW_TIMER(selection); if (error || (sortStream && ferror(sortStream))) { if ( sortStream ) fclose(sortStream); unlink(QFile::encodeName(sortFile)); kdWarning(5006) << "Error: Failure modifying " << sortFile << " (No space left on device?)" << endl; kdWarning(5006) << __FILE__ << ":" << __LINE__ << endl; return true; } if(sortStream) fclose(sortStream); return true; } //----------------------------------------------------------------------------- void KMHeaders::setCurrentItemBySerialNum( unsigned long serialNum ) { // Linear search == slow. Don't overuse this method. // It's currently only used for finding the current item again // after expiry deleted mails (so the index got invalidated). for (int i = 0; i < (int)mItems.size() - 1; ++i) { KMMsgBase *mMsgBase = mFolder->getMsgBase( i ); if ( mMsgBase->getMsgSerNum() == serialNum ) { bool unchanged = (currentItem() == mItems[i]); setCurrentItem( mItems[i] ); setSelected( mItems[i], true ); setSelectionAnchor( currentItem() ); if ( unchanged ) highlightMessage( currentItem(), false ); ensureCurrentItemVisible(); return; } } // Not found. Maybe we should select the last item instead? kdDebug(5006) << "KMHeaders::setCurrentItem item with serial number " << serialNum << " NOT FOUND" << endl; } void KMHeaders::copyMessages() { mCopiedMessages.clear(); KMMessageList* list = selectedMsgs(); for ( uint i = 0; i < list->count(); ++ i ) mCopiedMessages << list->at( i )->getMsgSerNum(); mMoveMessages = false; updateActions(); triggerUpdate(); } void KMHeaders::cutMessages() { mCopiedMessages.clear(); KMMessageList* list = selectedMsgs(); for ( uint i = 0; i < list->count(); ++ i ) mCopiedMessages << list->at( i )->getMsgSerNum(); mMoveMessages = true; updateActions(); triggerUpdate(); } void KMHeaders::pasteMessages() { new MessageCopyHelper( mCopiedMessages, folder(), mMoveMessages, this ); if ( mMoveMessages ) { mCopiedMessages.clear(); updateActions(); } } void KMHeaders::updateActions() { KAction *copy = owner()->action( "copy_messages" ); KAction *cut = owner()->action( "cut_messages" ); KAction *paste = owner()->action( "paste_messages" ); if ( selectedItems().isEmpty() ) { copy->setEnabled( false ); cut->setEnabled( false ); } else { copy->setEnabled( true ); if ( folder() && folder()->isReadOnly() ) cut->setEnabled( false ); else cut->setEnabled( true ); } if ( mCopiedMessages.isEmpty() || !folder() || folder()->isReadOnly() ) paste->setEnabled( false ); else paste->setEnabled( true ); } void KMHeaders::setCopiedMessages(const QValueList< Q_UINT32 > & msgs, bool move) { mCopiedMessages = msgs; mMoveMessages = move; updateActions(); } bool KMHeaders::isMessageCut(Q_UINT32 serNum) const { return mMoveMessages && mCopiedMessages.contains( serNum ); } QValueList< Q_UINT32 > KMHeaders::selectedSernums() { QValueList<Q_UINT32> list; for ( QListViewItemIterator it(this); it.current(); it++ ) { if ( it.current()->isSelected() && it.current()->isVisible() ) { HeaderItem* item = static_cast<HeaderItem*>( it.current() ); KMMsgBase *msgBase = mFolder->getMsgBase( item->msgId() ); list.append( msgBase->getMsgSerNum() ); } } return list; } QValueList< Q_UINT32 > KMHeaders::selectedVisibleSernums() { QValueList<Q_UINT32> list; QListViewItemIterator it(this, QListViewItemIterator::Selected|QListViewItemIterator::Visible); while( it.current() ) { if ( it.current()->isSelected() && it.current()->isVisible() ) { if ( it.current()->parent() && ( !it.current()->parent()->isOpen() ) ) { // the item's parent is closed, don't traverse any more of this subtree QListViewItem * lastAncestorWithSiblings = it.current()->parent(); // travel towards the root until we find an ancestor with siblings while ( ( lastAncestorWithSiblings->depth() > 0 ) && !lastAncestorWithSiblings->nextSibling() ) lastAncestorWithSiblings = lastAncestorWithSiblings->parent(); // move the iterator to that ancestor's next sibling it = QListViewItemIterator( lastAncestorWithSiblings->nextSibling() ); continue; } HeaderItem *item = static_cast<HeaderItem*>(it.current()); KMMsgBase *msgBase = mFolder->getMsgBase( item->msgId() ); list.append( msgBase->getMsgSerNum() ); } ++it; } return list; } #include "kmheaders.moc" kmail Skip menu "kmail" Main Page Namespace List Class Hierarchy Alphabetical List Class List File List Namespace Members Class Members Related Pages API Reference Skip menu "API Reference"   doc kioslaves kmail konsolekalendar kpilot libemailfunctions libkcal Generated for API Reference by doxygen 1.5.9 This website is maintained by Adriaan de Groot and Allen Winter. KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal