kmail Library API Documentation

kmacctcachedimap.cpp

00001 
00021 #ifdef HAVE_CONFIG_H
00022 #include <config.h>
00023 #endif
00024 
00025 #include "kmacctcachedimap.h"
00026 using KMail::SieveConfig;
00027 
00028 #include "imapprogressdialog.h"
00029 using KMail::IMAPProgressDialog;
00030 
00031 #include "kmbroadcaststatus.h"
00032 #include "kmfoldertree.h"
00033 #include "kmfoldermgr.h"
00034 #include "kmfiltermgr.h"
00035 #include "kmfoldercachedimap.h"
00036 #include "kmmainwin.h"
00037 #include "kmkernel.h"
00038 
00039 #include <kio/passdlg.h>
00040 #include <kio/scheduler.h>
00041 #include <kio/slave.h>
00042 #include <kmessagebox.h>
00043 #include <kdebug.h>
00044 #include <kstandarddirs.h>
00045 #include <kapplication.h>
00046 #include <kconfig.h>
00047 
00048 
00049 KMAcctCachedImap::KMAcctCachedImap( KMAcctMgr* aOwner,
00050                     const QString& aAccountName )
00051   : KMail::ImapAccountBase( aOwner, aAccountName ), mFolder( 0 ),
00052     mProgressDialogEnabled( true ), mSyncActive( false )
00053 {
00054   // Never EVER set this for the cached IMAP account
00055   mAutoExpunge = false;
00056 
00057   connect(KMBroadcastStatus::instance(), SIGNAL(signalAbortRequested()),
00058           this, SLOT(slotAbortRequested()));
00059   connect(&mIdleTimer, SIGNAL(timeout()), SLOT(slotIdleTimeout()));
00060 }
00061 
00062 
00063 //-----------------------------------------------------------------------------
00064 KMAcctCachedImap::~KMAcctCachedImap()
00065 {
00066   killAllJobs( true );
00067   delete mProgressDlg;
00068 }
00069 
00070 
00071 //-----------------------------------------------------------------------------
00072 QString KMAcctCachedImap::type() const
00073 {
00074   return "cachedimap";
00075 }
00076 
00077 void KMAcctCachedImap::init() {
00078   ImapAccountBase::init();
00079 
00080   setProgressDialogEnabled( true );
00081 }
00082 
00083 //-----------------------------------------------------------------------------
00084 void KMAcctCachedImap::pseudoAssign( const KMAccount * a ) {
00085   mIdleTimer.stop();
00086   killAllJobs( true );
00087   if (mFolder)
00088   {
00089     mFolder->setContentState(KMFolderCachedImap::imapNoInformation);
00090     mFolder->setSubfolderState(KMFolderCachedImap::imapNoInformation);
00091   }
00092 
00093   setProgressDialogEnabled(static_cast<const KMAcctCachedImap*>(a)->isProgressDialogEnabled());
00094 
00095   ImapAccountBase::pseudoAssign( a );
00096 }
00097 
00098 void KMAcctCachedImap::setPrefixHook() {
00099   if ( mFolder ) mFolder->setImapPath( prefix() );
00100 }
00101 
00102 //-----------------------------------------------------------------------------
00103 void KMAcctCachedImap::setImapFolder(KMFolderCachedImap *aFolder)
00104 {
00105   mFolder = aFolder;
00106   mFolder->setImapPath(mPrefix);
00107   mFolder->setAccount( this );
00108 }
00109 
00110 
00111 //-----------------------------------------------------------------------------
00112 void KMAcctCachedImap::setAutoExpunge( bool /*aAutoExpunge*/ )
00113 {
00114   // Never EVER set this for the cached IMAP account
00115   mAutoExpunge = false;
00116 }
00117 
00118 //-----------------------------------------------------------------------------
00119 void KMAcctCachedImap::slotSlaveError(KIO::Slave *aSlave, int errorCode,
00120   const QString &errorMsg)
00121 {
00122   if (aSlave != mSlave) return;
00123   if (errorCode == KIO::ERR_SLAVE_DIED) slaveDied();
00124   if (errorCode == KIO::ERR_COULD_NOT_LOGIN) mAskAgain = TRUE;
00125 
00126   // Note: HEAD has a killAllJobs() call here
00127 
00128   // check if we still display an error
00129   if ( !mErrorDialogIsActive )
00130   {
00131     mErrorDialogIsActive = true;
00132     KMessageBox::messageBox(kapp->activeWindow(), KMessageBox::Error,
00133           KIO::buildErrorString(errorCode, errorMsg),
00134           i18n("Error"));
00135     mErrorDialogIsActive = false;
00136   } else
00137     kdDebug(5006) << "suppressing error:" << errorMsg << endl;
00138 
00139   mSyncActive = false;
00140 }
00141 
00142 
00143 //-----------------------------------------------------------------------------
00144 void KMAcctCachedImap::displayProgress()
00145 {
00146   if (mProgressEnabled == mapJobData.isEmpty())
00147   {
00148     mProgressEnabled = !mapJobData.isEmpty();
00149     KMBroadcastStatus::instance()->setStatusProgressEnable( "I" + mName,
00150       mProgressEnabled );
00151     if (!mProgressEnabled) kmkernel->filterMgr()->deref(true);
00152   }
00153   mIdle = FALSE;
00154   if( mapJobData.isEmpty() )
00155     mIdleTimer.start(0);
00156   else
00157     mIdleTimer.stop();
00158   int total = 0, done = 0;
00159   // This is a loop, but it seems that we can currently have only one job at a time in this map.
00160   for (QMap<KIO::Job*, jobData>::Iterator it = mapJobData.begin();
00161     it != mapJobData.end(); ++it)
00162   {
00163     total += (*it).total; // always ==1 (in kmfoldercachedimap.cpp)
00164     if( (*it).parent )
00165       done += static_cast<KMFolderCachedImap*>((*it).parent)->progress();
00166     else
00167       done += (*it).done;
00168   }
00169   if (total == 0) // can't happen
00170   {
00171     mTotal = 0;
00172     return;
00173   }
00174   //if (total > mTotal) mTotal = total;
00175   //done += mTotal - total;
00176   KMBroadcastStatus::instance()->setStatusProgressPercent( "I" + mName,
00177      done / total );
00178      //  100*done / mTotal );
00179 }
00180 
00181 
00182 //-----------------------------------------------------------------------------
00183 void KMAcctCachedImap::slotIdleTimeout()
00184 {
00185   if (/*mIdle*/true) // STEFFEN: Hacked this to always disconnect
00186   {
00187     if (mSlave) KIO::Scheduler::disconnectSlave(mSlave);
00188     mSlave = NULL;
00189     mIdleTimer.stop();
00190   } else {
00191     if (mSlave)
00192     {
00193       QByteArray packedArgs;
00194       QDataStream stream( packedArgs, IO_WriteOnly);
00195 
00196       stream << (int) 'N';
00197 
00198       KIO::SimpleJob *job = KIO::special(getUrl(), packedArgs, FALSE);
00199       KIO::Scheduler::assignJobToSlave(mSlave, job);
00200       connect(job, SIGNAL(result(KIO::Job *)),
00201         this, SLOT(slotSimpleResult(KIO::Job *)));
00202     }
00203     else mIdleTimer.stop();
00204   }
00205 }
00206 
00207 
00208 //-----------------------------------------------------------------------------
00209 void KMAcctCachedImap::slotAbortRequested()
00210 {
00211   killAllJobs();
00212 }
00213 
00214 
00215 //-----------------------------------------------------------------------------
00216 void KMAcctCachedImap::killAllJobs( bool disconnectSlave )
00217 {
00218   QMap<KIO::Job*, jobData>::Iterator it = mapJobData.begin();
00219   for (it = mapJobData.begin(); it != mapJobData.end(); ++it)
00220     if ((*it).parent)
00221     {
00222       KMFolderCachedImap *fld = static_cast<KMFolderCachedImap*>((*it).parent);
00223       fld->resetSyncState();
00224       fld->setContentState(KMFolderCachedImap::imapNoInformation);
00225       fld->setSubfolderState(KMFolderCachedImap::imapNoInformation);
00226       fld->sendFolderComplete(FALSE);
00227     }
00228   if (mSlave && mapJobData.begin() != mapJobData.end())
00229   {
00230     mSlave->kill();
00231     mSlave = 0;
00232   }
00233   mapJobData.clear();
00234 
00235   // Clear the joblist. Make SURE to stop the job emitting "finished"
00236   for( QPtrListIterator<CachedImapJob> it( mJobList ); it.current(); ++it )
00237     it.current()->setPassiveDestructor( true );
00238   mJobList.setAutoDelete(true);
00239   mJobList.clear();
00240   mJobList.setAutoDelete(false);
00241   displayProgress();
00242 
00243   if ( disconnectSlave && slave() ) {
00244     KIO::Scheduler::disconnectSlave( slave() );
00245     mSlave = 0;
00246   }
00247 
00248   // Finally allow new syncs to proceed
00249   mSyncActive = false;
00250 }
00251 
00252 
00253 //-----------------------------------------------------------------------------
00254 void KMAcctCachedImap::killJobsForItem(KMFolderTreeItem * fti)
00255 {
00256   QMap<KIO::Job *, jobData>::Iterator it = mapJobData.begin();
00257   while (it != mapJobData.end())
00258   {
00259     if (it.data().parent == fti->folder())
00260     {
00261       killAllJobs();
00262       break;
00263     }
00264     else ++it;
00265   }
00266 }
00267 
00268 
00269 //-----------------------------------------------------------------------------
00270 void KMAcctCachedImap::slotSimpleResult(KIO::Job * job)
00271 {
00272   JobIterator it = findJob( job );
00273   bool quiet = false;
00274   if (it != mapJobData.end())
00275   {
00276     quiet = (*it).quiet;
00277     removeJob(it);
00278   }
00279   if (job->error())
00280   {
00281     if (!quiet) slotSlaveError(mSlave, job->error(),
00282         job->errorText() );
00283     if (job->error() == KIO::ERR_SLAVE_DIED) slaveDied();
00284     mSyncActive = false;
00285   }
00286   displayProgress();
00287 }
00288 
00289 
00290 //-----------------------------------------------------------------------------
00291 void KMAcctCachedImap::processNewMail( KMFolderCachedImap* folder,
00292                        bool interactive )
00293 {
00294   // This should never be set for a cached IMAP account
00295   mAutoExpunge = false;
00296 
00297   // Guard against parallel runs
00298   if( mSyncActive ) {
00299     kdDebug(5006) << "Already processing new mail, won't start again\n";
00300     return;
00301   }
00302   mSyncActive = true;
00303 
00304   emit newMailsProcessed(-1);
00305   if( interactive && isProgressDialogEnabled() ) {
00306     imapProgressDialog()->clear();
00307     imapProgressDialog()->show();
00308     imapProgressDialog()->raise();
00309   }
00310 
00311   folder->setAccount(this);
00312   connect(folder, SIGNAL(folderComplete(KMFolderCachedImap*, bool)),
00313       this, SLOT(postProcessNewMail(KMFolderCachedImap*, bool)));
00314   folder->serverSync( interactive && isProgressDialogEnabled() );
00315   checkDone(false, 0);
00316 }
00317 
00318 void KMAcctCachedImap::postProcessNewMail( KMFolderCachedImap* folder, bool )
00319 {
00320   mSyncActive = false;
00321   setCheckingMail( false );
00322   emit finishedCheck(false);
00323   disconnect(folder, SIGNAL(folderComplete(KMFolderCachedImap*, bool)),
00324       this, SLOT(postProcessNewMail(KMFolderCachedImap*, bool)));
00325   //postProcessNewMail(static_cast<KMFolder*>(folder));
00326 }
00327 
00328 //
00329 //
00330 // read/write config
00331 //
00332 //
00333 
00334 void KMAcctCachedImap::readConfig( /*const*/ KConfig/*Base*/ & config ) {
00335   ImapAccountBase::readConfig( config );
00336   setProgressDialogEnabled( config.readBoolEntry( "progressdialog", true ) );
00337 }
00338 
00339 void KMAcctCachedImap::writeConfig( KConfig/*Base*/ & config ) /*const*/ {
00340   ImapAccountBase::writeConfig( config );
00341   config.writeEntry( "progressdialog", isProgressDialogEnabled() );
00342 }
00343 
00344 void KMAcctCachedImap::invalidateIMAPFolders()
00345 {
00346   invalidateIMAPFolders( mFolder );
00347 }
00348 
00349 void KMAcctCachedImap::invalidateIMAPFolders( KMFolderCachedImap* folder )
00350 {
00351   folder->setAccount(this);
00352 
00353   QStringList strList;
00354   QValueList<QGuardedPtr<KMFolder> > folderList;
00355   kmkernel->dimapFolderMgr()->createFolderList( &strList, &folderList,
00356                         folder->child(), QString::null,
00357                         false );
00358   QValueList<QGuardedPtr<KMFolder> >::Iterator it;
00359   mCountRemainChecks = 0;
00360   mCountLastUnread = 0;
00361 
00362   if( folderList.count() > 0 )
00363     for( it = folderList.begin(); it != folderList.end(); ++it ) {
00364       KMFolder *folder = *it;
00365       if( folder && folder->folderType() == KMFolderTypeCachedImap ) {
00366     KMFolderCachedImap *cfolder = static_cast<KMFolderCachedImap*>(folder);
00367     // This invalidates the folder completely
00368     cfolder->setUidValidity("INVALID");
00369     cfolder->writeUidCache();
00370       }
00371     }
00372   folder->setUidValidity("INVALID");
00373   folder->writeUidCache();
00374 
00375   processNewMail(false);
00376 }
00377 
00378 //-----------------------------------------------------------------------------
00379 void KMAcctCachedImap::listDirectory(QString path, bool onlySubscribed,
00380     bool secondStep, KMFolder* parent, bool reset)
00381 {
00382   ImapAccountBase::listDirectory( path, onlySubscribed, secondStep, parent, reset );
00383 }
00384 
00385 //-----------------------------------------------------------------------------
00386 void KMAcctCachedImap::listDirectory()
00387 {
00388   mFolder->listDirectory();
00389 }
00390 
00391 IMAPProgressDialog* KMAcctCachedImap::imapProgressDialog() const
00392 {
00393   if( !mProgressDlg ) {
00394     mProgressDlg = new IMAPProgressDialog( KMKernel::self()->mainWin() );
00395   }
00396   return mProgressDlg;
00397 }
00398 
00399 #include "kmacctcachedimap.moc"
KDE Logo
This file is part of the documentation for kmail Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat May 1 11:37:19 2004 by doxygen 1.2.15 written by Dimitri van Heesch, © 1997-2003