00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
#include <config.h>
00036
00037
#include "folderstorage.h"
00038
#include "kmfolder.h"
00039
00040
#include "kmfolderimap.h"
00041
#include "undostack.h"
00042
#include "kmmsgdict.h"
00043
#include "kmfoldermgr.h"
00044
#include "kmkernel.h"
00045
#include "kmcommands.h"
00046
#include "listjob.h"
00047
using KMail::ListJob;
00048
#include "kmailicalifaceimpl.h"
00049
00050
#include <klocale.h>
00051
#include <kconfig.h>
00052
#include <kdebug.h>
00053
00054
#include <qfile.h>
00055
#include <qregexp.h>
00056
00057
#include <mimelib/mimepp.h>
00058
#include <errno.h>
00059
00060
00061
00062 FolderStorage::FolderStorage(
KMFolder* folder,
const char* aName )
00063 :
QObject( folder, aName ), mFolder( folder )
00064 {
00065 mOpenCount = 0;
00066 mQuiet = 0;
00067 mChanged = FALSE;
00068
mAutoCreateIndex= TRUE;
00069 folder->setType(
"plain" );
00070 mAcctList = 0;
00071
mDirty = FALSE;
00072
mUnreadMsgs = -1;
00073
mGuessedUnreadMsgs = -1;
00074 mTotalMsgs = -1;
00075
needsCompact = FALSE;
00076 mConvertToUtf8 = FALSE;
00077
mCompactable = TRUE;
00078 mNoContent = FALSE;
00079 mNoChildren = FALSE;
00080
mRDict = 0;
00081 mDirtyTimer =
new QTimer(
this);
00082 connect(mDirtyTimer, SIGNAL(timeout()),
00083
this, SLOT(
updateIndex()));
00084 mHasChildren = HasNoChildren;
00085
mContentsType = KMail::ContentsTypeMail;
00086 }
00087
00088
00089 FolderStorage::~FolderStorage()
00090 {
00091
delete mAcctList;
00092 mJobList.setAutoDelete(
true );
00093 QObject::disconnect( SIGNAL(destroyed(
QObject*)),
this, 0 );
00094 mJobList.clear();
00095 KMMsgDict::deleteRentry(mRDict);
00096 }
00097
00098
00099
00100 QString FolderStorage::dotEscape(
const QString& aStr)
00101 {
00102
if (aStr[0] !=
'.')
return aStr;
00103
return aStr.left(aStr.find(
QRegExp(
"[^\\.]"))) + aStr;
00104 }
00105
00106 void FolderStorage::addJob( FolderJob* job )
const
00107
{
00108 QObject::connect( job, SIGNAL(destroyed(
QObject*)),
00109 SLOT(removeJob(
QObject*)) );
00110
mJobList.append( job );
00111 }
00112
00113
void FolderStorage::removeJob(
QObject* job )
00114 {
00115 mJobList.remove( static_cast<FolderJob*>( job ) );
00116 }
00117
00118
00119
00120 QString FolderStorage::location()
const
00121
{
00122
QString sLocation(const_cast<FolderStorage*>(
this)->folder()->path());
00123
00124
if (!sLocation.isEmpty()) sLocation +=
'/';
00125 sLocation +=
dotEscape(
fileName());
00126
00127
return sLocation;
00128 }
00129
00130 QString FolderStorage::fileName()
const
00131
{
00132
return mFolder->name();
00133 }
00134
00135
00136
00137
00138 void FolderStorage::setAutoCreateIndex(
bool autoIndex)
00139 {
00140
mAutoCreateIndex = autoIndex;
00141 }
00142
00143
00144 void FolderStorage::setDirty(
bool f)
00145 {
00146
mDirty = f;
00147
if (
mDirty &&
mAutoCreateIndex)
00148 mDirtyTimer->changeInterval( mDirtyTimerInterval );
00149
else
00150 mDirtyTimer->stop();
00151 }
00152
00153
00154 void FolderStorage::markNewAsUnread()
00155 {
00156 KMMsgBase* msgBase;
00157
int i;
00158
00159
for (i=0; i<
count(); ++i)
00160 {
00161
if (!(msgBase =
getMsgBase(i)))
continue;
00162
if (msgBase->isNew())
00163 {
00164 msgBase->setStatus(KMMsgStatusUnread);
00165 msgBase->setDirty(TRUE);
00166 }
00167 }
00168 }
00169
00170 void FolderStorage::markUnreadAsRead()
00171 {
00172 KMMsgBase* msgBase;
00173
SerNumList serNums;
00174
00175
for (
int i=
count()-1; i>=0; --i)
00176 {
00177 msgBase =
getMsgBase(i);
00178 assert(msgBase);
00179
if (msgBase->isNew() || msgBase->isUnread())
00180 {
00181 serNums.append( msgBase->getMsgSerNum() );
00182 }
00183 }
00184
if (serNums.empty())
00185
return;
00186
00187 KMCommand *command =
new KMSetStatusCommand( KMMsgStatusRead, serNums );
00188 command->start();
00189 }
00190
00191
00192 void FolderStorage::quiet(
bool beQuiet)
00193 {
00194
if (beQuiet)
00195 mQuiet++;
00196
else {
00197 mQuiet--;
00198
if (mQuiet <= 0)
00199 {
00200 mQuiet = 0;
00201
if (mChanged)
00202 emit
changed();
00203 mChanged = FALSE;
00204 }
00205 }
00206 }
00207
00208
00209
00210
00211
00213
int operator<( KMMsgBase & m1, KMMsgBase & m2 )
00214 {
00215
return (m1.date() < m2.date());
00216 }
00217
00219
int operator==( KMMsgBase & m1, KMMsgBase & m2 )
00220 {
00221
return (m1.date() == m2.date());
00222 }
00223
00224
00225
00226 int FolderStorage::expungeOldMsg(
int days)
00227 {
00228
int i, msgnb=0;
00229 time_t msgTime, maxTime;
00230
const KMMsgBase* mb;
00231
QValueList<int> rmvMsgList;
00232
00233 maxTime = time(0) - days * 3600 * 24;
00234
00235
for (i=
count()-1; i>=0; i--) {
00236 mb =
getMsgBase(i);
00237 assert(mb);
00238 msgTime = mb->date();
00239
00240
if (msgTime < maxTime) {
00241
00242
removeMsg( i );
00243 msgnb++;
00244 }
00245 }
00246
return msgnb;
00247 }
00248
00249
00250 void FolderStorage::emitMsgAddedSignals(
int idx)
00251 {
00252 Q_UINT32 serNum = kmkernel->msgDict()->getMsgSerNum( folder() , idx );
00253
if (!mQuiet) {
00254 emit
msgAdded(idx);
00255 }
else {
00256 mChanged=
true;
00257 }
00258 emit
msgAdded( folder(), serNum );
00259 }
00260
00261
00262 bool FolderStorage::canAddMsgNow(KMMessage* aMsg,
int* aIndex_ret)
00263 {
00264
if (aIndex_ret) *aIndex_ret = -1;
00265
KMFolder *msgParent = aMsg->parent();
00266
00267
00268
if (aMsg->transferInProgress() && msgParent)
00269
return false;
00270
if (!aMsg->isComplete() && msgParent && msgParent->
folderType() == KMFolderTypeImap)
00271 {
00272 FolderJob *job = msgParent->
createJob(aMsg);
00273 connect(job, SIGNAL(messageRetrieved(KMMessage*)),
00274 SLOT(
reallyAddMsg(KMMessage*)));
00275 job->start();
00276 aMsg->setTransferInProgress(TRUE);
00277
return FALSE;
00278 }
00279
return TRUE;
00280 }
00281
00282
00283
00284 void FolderStorage::reallyAddMsg(KMMessage* aMsg)
00285 {
00286
if (!aMsg)
00287
return;
00288 aMsg->setTransferInProgress(FALSE);
00289
KMFolder *aFolder = aMsg->parent();
00290
int index;
00291 ulong serNum = aMsg->getMsgSerNum();
00292
bool undo = aMsg->enableUndo();
00293
addMsg(aMsg, &index);
00294
if (index < 0)
return;
00295
unGetMsg(index);
00296
if (undo)
00297 {
00298 kmkernel->undoStack()->pushSingleAction( serNum, aFolder, folder() );
00299 }
00300 }
00301
00302
00303
00304 void FolderStorage::reallyAddCopyOfMsg(KMMessage* aMsg)
00305 {
00306 aMsg->setParent( 0 );
00307 aMsg->setTransferInProgress(
false );
00308
addMsg( aMsg );
00309
unGetMsg(
count() - 1 );
00310 }
00311
00312
int FolderStorage::find(
const KMMessage * msg )
const {
00313
return find( &msg->toMsgBase() );
00314 }
00315
00316
00317
void FolderStorage::removeMsg(
const QPtrList<KMMsgBase>& msgList,
bool imapQuiet)
00318 {
00319
for(
QPtrListIterator<KMMsgBase> it( msgList ); *it; ++it )
00320 {
00321
int idx =
find(it.current());
00322 assert( idx != -1);
00323
removeMsg(idx, imapQuiet);
00324 }
00325 }
00326
00327
00328
void FolderStorage::removeMsg(
const QPtrList<KMMessage>& msgList,
bool imapQuiet)
00329 {
00330
for(
QPtrListIterator<KMMessage> it( msgList ); *it; ++it )
00331 {
00332
int idx =
find(it.current());
00333 assert( idx != -1);
00334
removeMsg(idx, imapQuiet);
00335 }
00336 }
00337
00338
00339 void FolderStorage::removeMsg(
int idx,
bool)
00340 {
00341
00342
if(idx < 0)
00343 {
00344 kdDebug(5006) <<
"FolderStorage::removeMsg() : idx < 0\n" << endl;
00345
return;
00346 }
00347
00348 KMMsgBase* mb =
getMsgBase(idx);
00349
00350 Q_UINT32 serNum = kmkernel->msgDict()->getMsgSerNum( folder(), idx );
00351
if (serNum != 0)
00352 emit
msgRemoved( folder(), serNum );
00353 mb = takeIndexEntry( idx );
00354
00355
setDirty(
true );
00356
needsCompact=
true;
00357
00358
if (mb->isUnread() || mb->isNew() ||
00359 (folder() == kmkernel->outboxFolder())) {
00360 --
mUnreadMsgs;
00361 emit
numUnreadMsgsChanged( folder() );
00362 }
00363 --mTotalMsgs;
00364
00365
QString msgIdMD5 = mb->msgIdMD5();
00366
QString strippedSubjMD5 = mb->strippedSubjectMD5();
00367
if (strippedSubjMD5.isEmpty()) {
00368 mb->initStrippedSubjectMD5();
00369 strippedSubjMD5 = mb->strippedSubjectMD5();
00370 }
00371 emit
msgRemoved(idx, msgIdMD5, strippedSubjMD5);
00372 emit
msgRemoved( folder() );
00373 }
00374
00375
00376
00377 KMMessage*
FolderStorage::take(
int idx)
00378 {
00379 KMMsgBase* mb;
00380 KMMessage* msg;
00381
00382 assert(idx>=0 && idx<=
count());
00383
00384 mb =
getMsgBase(idx);
00385
if (!mb)
return 0;
00386
if (!mb->isMessage())
readMsg(idx);
00387 Q_UINT32 serNum = kmkernel->msgDict()->getMsgSerNum( folder(), idx );
00388 emit
msgRemoved( folder(), serNum );
00389
00390 msg = (KMMessage*)takeIndexEntry(idx);
00391
00392
if (msg->isUnread() || msg->isNew() ||
00393 ( folder() == kmkernel->outboxFolder() )) {
00394 --
mUnreadMsgs;
00395 emit
numUnreadMsgsChanged( folder() );
00396 }
00397 --mTotalMsgs;
00398 msg->setParent(0);
00399
setDirty(
true );
00400
needsCompact=
true;
00401
QString msgIdMD5 = msg->msgIdMD5();
00402
QString strippedSubjMD5 = msg->strippedSubjectMD5();
00403
if (strippedSubjMD5.isEmpty()) {
00404 msg->initStrippedSubjectMD5();
00405 strippedSubjMD5 = msg->strippedSubjectMD5();
00406 }
00407 emit
msgRemoved(idx, msgIdMD5, strippedSubjMD5);
00408 emit
msgRemoved( folder() );
00409
00410
return msg;
00411 }
00412
00413
void FolderStorage::take(
QPtrList<KMMessage> msgList)
00414 {
00415
for ( KMMessage* msg = msgList.first(); msg; msg = msgList.next() )
00416 {
00417
if (msg->parent())
00418 {
00419
int idx = msg->parent()->find(msg);
00420 assert( idx != -1);
00421
FolderStorage::take(idx);
00422 }
00423 }
00424 }
00425
00426
00427
00428 KMMessage*
FolderStorage::getMsg(
int idx)
00429 {
00430 KMMsgBase* mb;
00431
00432
if(!(idx >= 0 && idx <=
count()))
00433
return 0;
00434
00435 mb =
getMsgBase(idx);
00436
if (!mb)
return 0;
00437
00438
#if 0
00439
if (mb->isMessage())
return ((KMMessage*)mb);
00440
return readMsg(idx);
00441
#else
00442
KMMessage *msg = 0;
00443
bool undo = mb->enableUndo();
00444
if (mb->isMessage()) {
00445 msg = ((KMMessage*)mb);
00446 }
else {
00447
QString mbSubject = mb->subject();
00448 msg =
readMsg(idx);
00449
00450
if (
mCompactable && (!msg || (msg->subject().isEmpty() != mbSubject.isEmpty()))) {
00451 kdDebug(5006) <<
"Error: " <<
location() <<
00452
" Index file is inconsistent with folder file. This should never happen." << endl;
00453
mCompactable = FALSE;
00454
writeConfig();
00455 }
00456 }
00457 msg->setEnableUndo(undo);
00458
00459
if (msg->getMsgSerNum() == 0) {
00460 msg->setMsgSerNum(kmkernel->msgDict()->insert(0, msg, idx));
00461 kdDebug(5006) <<
"Serial number generated for message in folder "
00462 <<
label() << endl;
00463 }
00464 msg->setComplete(
true );
00465
return msg;
00466
#endif
00467
00468
00469 }
00470
00471
00472
00473 KMMsgInfo*
FolderStorage::unGetMsg(
int idx)
00474 {
00475 KMMsgBase* mb;
00476
00477
if(!(idx >= 0 && idx <=
count()))
00478
return 0;
00479
00480 mb =
getMsgBase(idx);
00481
if (!mb)
return 0;
00482
00483
00484
if (mb->isMessage()) {
00485
00486
00487 KMMessage *msg = static_cast<KMMessage*>(mb);
00488
if ( msg->transferInProgress() )
return 0;
00489
ignoreJobsForMessage( msg );
00490
return setIndexEntry( idx, msg );
00491 }
00492
00493
return 0;
00494 }
00495
00496
00497
00498 bool FolderStorage::isMessage(
int idx)
00499 {
00500 KMMsgBase* mb;
00501
if (!(idx >= 0 && idx <=
count()))
return FALSE;
00502 mb =
getMsgBase(idx);
00503
return (mb && mb->isMessage());
00504 }
00505
00506
00507 FolderJob*
FolderStorage::createJob( KMMessage *msg, FolderJob::JobType jt,
00508
KMFolder *folder,
QString partSpecifier,
00509
const AttachmentStrategy *as )
const
00510
{
00511 FolderJob * job =
doCreateJob( msg, jt, folder, partSpecifier, as );
00512
if ( job )
00513
addJob( job );
00514
return job;
00515 }
00516
00517
00518 FolderJob*
FolderStorage::createJob(
QPtrList<KMMessage>& msgList,
const QString& sets,
00519 FolderJob::JobType jt,
KMFolder *folder )
const
00520
{
00521 FolderJob * job =
doCreateJob( msgList, sets, jt, folder );
00522
if ( job )
00523
addJob( job );
00524
return job;
00525 }
00526
00527
00528 int FolderStorage::moveMsg(KMMessage* aMsg,
int* aIndex_ret)
00529 {
00530 assert(aMsg != 0);
00531
KMFolder* msgParent = aMsg->parent();
00532
00533
if (msgParent)
00534 msgParent->
open();
00535
00536
open();
00537
int rc =
addMsg(aMsg, aIndex_ret);
00538
close();
00539
00540
if (msgParent)
00541 msgParent->
close();
00542
00543
return rc;
00544 }
00545
00546
00547
int FolderStorage::moveMsg(
QPtrList<KMMessage> msglist,
int* aIndex_ret)
00548 {
00549 KMMessage* aMsg = msglist.first();
00550 assert(aMsg != 0);
00551
KMFolder* msgParent = aMsg->parent();
00552
00553
if (msgParent)
00554 msgParent->
open();
00555
00556
open();
00557
00558
int rc = static_cast<KMFolderImap*>(
this)->addMsg(msglist, aIndex_ret);
00559
close();
00560
00561
if (msgParent)
00562 msgParent->
close();
00563
00564
return rc;
00565 }
00566
00567
00568
00569 int FolderStorage::rename(
const QString& newName,
KMFolderDir *newParent)
00570 {
00571
QString oldLoc, oldIndexLoc, oldIdsLoc, newLoc, newIndexLoc, newIdsLoc;
00572
QString oldSubDirLoc, newSubDirLoc;
00573
QString oldName;
00574
int rc=0, openCount=mOpenCount;
00575
KMFolderDir *oldParent;
00576
00577 assert(!newName.isEmpty());
00578
00579 oldLoc =
location();
00580 oldIndexLoc =
indexLocation();
00581 oldSubDirLoc = folder()->
subdirLocation();
00582
if (kmkernel->msgDict())
00583 oldIdsLoc = kmkernel->msgDict()->getFolderIdsLocation( folder() );
00584
QString oldConfigString =
"Folder-" + folder()->
idString();
00585
00586
close(TRUE);
00587
00588 oldName = folder()->
fileName();
00589 oldParent = folder()->parent();
00590
if (newParent)
00591 folder()->setParent( newParent );
00592
00593 folder()->setName(newName);
00594 newLoc =
location();
00595 newIndexLoc =
indexLocation();
00596 newSubDirLoc = folder()->
subdirLocation();
00597
if (kmkernel->msgDict())
00598 newIdsLoc = kmkernel->msgDict()->getFolderIdsLocation( folder() );
00599
00600
if (::rename(QFile::encodeName(oldLoc), QFile::encodeName(newLoc))) {
00601 folder()->setName(oldName);
00602 folder()->setParent(oldParent);
00603 rc = errno;
00604 }
00605
else {
00606
00607
if (!oldIndexLoc.isEmpty()) {
00608 ::rename(QFile::encodeName(oldIndexLoc), QFile::encodeName(newIndexLoc));
00609 ::rename(QFile::encodeName(oldIndexLoc) +
".sorted",
00610 QFile::encodeName(newIndexLoc) +
".sorted");
00611 }
00612
00613
00614
if (!oldIdsLoc.isEmpty())
00615 ::rename(QFile::encodeName(oldIdsLoc), QFile::encodeName(newIdsLoc));
00616
00617
00618
KMFolderDir* child = 0;
00619
if( folder() )
00620 child = folder()->
child();
00621
00622
if (!::rename(QFile::encodeName(oldSubDirLoc), QFile::encodeName(newSubDirLoc) )) {
00623
00624
00625
00626
if( child && ( oldName != newName ) ) {
00627 child->setName(
"." + QFile::encodeName(newName) +
".directory" );
00628 }
00629 }
00630
00631
00632
00633
if (newParent) {
00634
if (oldParent->findRef( folder() ) != -1)
00635 oldParent->take();
00636 newParent->inSort( folder() );
00637
if ( child ) {
00638
if ( child->parent()->findRef( child ) != -1 )
00639 child->parent()->take();
00640 newParent->inSort( child );
00641 child->setParent( newParent );
00642 }
00643 }
00644 }
00645
00646
if (openCount > 0)
00647 {
00648
open();
00649 mOpenCount = openCount;
00650 }
00651
writeConfig();
00652
00653
00654 KMKernel::config()->deleteGroup( oldConfigString );
00655
00656 emit
nameChanged();
00657
return rc;
00658 }
00659
00660
00661
00662 void FolderStorage::remove()
00663 {
00664 assert(!folder()->name().isEmpty());
00665
00666 clearIndex(
true,
true);
00667
close(TRUE);
00668
00669
if (kmkernel->msgDict()) kmkernel->msgDict()->removeFolderIds( folder() );
00670 unlink(QFile::encodeName(
indexLocation()) +
".sorted");
00671 unlink(QFile::encodeName(
indexLocation()));
00672
00673
int rc =
removeContents();
00674
00675
needsCompact =
false;
00676
00677
00678 KConfig* config = KMKernel::config();
00679 config->deleteGroup(
"Folder-" + folder()->idString() );
00680
00681 emit
removed(folder(), (rc ?
false :
true));
00682 }
00683
00684
00685
00686 int FolderStorage::expunge()
00687 {
00688
int openCount = mOpenCount;
00689
00690 assert(!folder()->name().isEmpty());
00691
00692 clearIndex(
true,
true);
00693
close(TRUE);
00694
00695 kmkernel->msgDict()->removeFolderIds( folder() );
00696
if (
mAutoCreateIndex)
00697 truncateIndex();
00698
else unlink(QFile::encodeName(
indexLocation()));
00699
00700
int rc =
expungeContents();
00701
if (rc)
return rc;
00702
00703
mDirty = FALSE;
00704
needsCompact =
false;
00705
00706
if (openCount > 0)
00707 {
00708
open();
00709 mOpenCount = openCount;
00710 }
00711
00712
mUnreadMsgs = 0;
00713 mTotalMsgs = 0;
00714 emit
numUnreadMsgsChanged( folder() );
00715
if (
mAutoCreateIndex)
00716
writeConfig();
00717 emit
changed();
00718 emit
expunged();
00719
00720
return 0;
00721 }
00722
00723
00724
00725 const char*
FolderStorage::type()
const
00726
{
00727
if (mAcctList)
return "In";
00728
return folder()->KMFolderNode::type();
00729 }
00730
00731
00732
00733 QString FolderStorage::label()
const
00734
{
00735
return folder()->
label();
00736 }
00737
00738 int FolderStorage::count(
bool cache)
const
00739
{
00740
if (cache && mTotalMsgs != -1)
00741
return mTotalMsgs;
00742
else
00743
return -1;
00744 }
00745
00746
00747 int FolderStorage::countUnread()
00748 {
00749
if (
mGuessedUnreadMsgs > -1)
00750
return mGuessedUnreadMsgs;
00751
if (
mUnreadMsgs > -1)
00752
return mUnreadMsgs;
00753
00754
readConfig();
00755
00756
if (
mUnreadMsgs > -1)
00757
return mUnreadMsgs;
00758
00759
open();
00760
int unread =
mUnreadMsgs;
00761
close();
00762
return (unread > 0) ? unread : 0;
00763 }
00764
00765
00766 void FolderStorage::msgStatusChanged(
const KMMsgStatus oldStatus,
00767
const KMMsgStatus newStatus,
int idx)
00768 {
00769
int oldUnread = 0;
00770
int newUnread = 0;
00771
00772
if (oldStatus & KMMsgStatusUnread || oldStatus & KMMsgStatusNew ||
00773 (folder() == kmkernel->outboxFolder()))
00774 oldUnread = 1;
00775
if (newStatus & KMMsgStatusUnread || newStatus & KMMsgStatusNew ||
00776 (folder() == kmkernel->outboxFolder()))
00777 newUnread = 1;
00778
int deltaUnread = newUnread - oldUnread;
00779
00780 mDirtyTimer->changeInterval(mDirtyTimerInterval);
00781
if (deltaUnread != 0) {
00782
if (
mUnreadMsgs < 0)
mUnreadMsgs = 0;
00783
mUnreadMsgs += deltaUnread;
00784
if ( !mQuiet )
00785 emit
numUnreadMsgsChanged( folder() );
00786
else
00787 mChanged =
true;
00788 Q_UINT32 serNum = kmkernel->msgDict()->getMsgSerNum(folder(), idx);
00789 emit
msgChanged( folder(), serNum, deltaUnread );
00790 }
00791 }
00792
00793
00794 void FolderStorage::headerOfMsgChanged(
const KMMsgBase* aMsg,
int idx)
00795 {
00796
if (idx < 0)
00797 idx = aMsg->parent()->find( aMsg );
00798
if (idx >= 0 && !mQuiet)
00799 emit
msgHeaderChanged(folder(), idx);
00800
else
00801 mChanged =
true;
00802 }
00803
00804
00805 void FolderStorage::readConfig()
00806 {
00807
00808 KConfig* config = KMKernel::config();
00809 KConfigGroupSaver saver(config,
"Folder-" + folder()->idString());
00810
if (
mUnreadMsgs == -1)
00811
mUnreadMsgs = config->readNumEntry(
"UnreadMsgs", -1);
00812
if (mTotalMsgs == -1)
00813 mTotalMsgs = config->readNumEntry(
"TotalMsgs", -1);
00814
mCompactable = config->readBoolEntry(
"Compactable", TRUE);
00815
00816
int type = config->readNumEntry(
"ContentsType", 0 );
00817
if ( type < 0 || type > KMail::ContentsTypeLast ) type = 0;
00818
setContentsType( static_cast<KMail::FolderContentsType>( type ) );
00819 mContentsTypeChanged =
false;
00820
00821
if( folder() ) folder()->
readConfig( config );
00822 }
00823
00824
00825 void FolderStorage::writeConfig()
00826 {
00827 KConfig* config = KMKernel::config();
00828 KConfigGroupSaver saver(config,
"Folder-" + folder()->idString());
00829 config->writeEntry(
"UnreadMsgs",
mGuessedUnreadMsgs == -1 ?
mUnreadMsgs : -1);
00830 config->writeEntry(
"TotalMsgs", mTotalMsgs);
00831 config->writeEntry(
"Compactable",
mCompactable);
00832 config->writeEntry(
"ContentsType",
mContentsType);
00833
00834
00835
if( folder() ) folder()->
writeConfig( config );
00836 }
00837
00838
00839 void FolderStorage::correctUnreadMsgsCount()
00840 {
00841
open();
00842
close();
00843 emit
numUnreadMsgsChanged( folder() );
00844 }
00845
00846
00847 void FolderStorage::fillMsgDict(KMMsgDict *dict)
00848 {
00849 fillDictFromIndex(dict);
00850 }
00851
00852
00853 int FolderStorage::writeMsgDict(KMMsgDict *dict)
00854 {
00855
int ret = 0;
00856
if (!dict)
00857 dict = kmkernel->msgDict();
00858
if (dict)
00859 ret = dict->writeFolderIds(folder());
00860
return ret;
00861 }
00862
00863
00864 int FolderStorage::touchMsgDict()
00865 {
00866
int ret = 0;
00867 KMMsgDict *dict = kmkernel->msgDict();
00868
if (dict)
00869 ret = dict->touchFolderIds(folder());
00870
return ret;
00871 }
00872
00873
00874 int FolderStorage::appendtoMsgDict(
int idx)
00875 {
00876
int ret = 0;
00877 KMMsgDict *dict = kmkernel->msgDict();
00878
if (dict) {
00879
if (
count() == 1) {
00880 ret = dict->writeFolderIds(folder());
00881 }
else {
00882 ret = dict->appendtoFolderIds(folder(), idx);
00883 }
00884 }
00885
return ret;
00886 }
00887
00888
00889 void FolderStorage::setStatus(
int idx, KMMsgStatus status,
bool toggle)
00890 {
00891 KMMsgBase *msg =
getMsgBase(idx);
00892
if ( msg ) {
00893
if (toggle)
00894 msg->toggleStatus(status, idx);
00895
else
00896 msg->setStatus(status, idx);
00897 }
00898 }
00899
00900 void FolderStorage::setRDict(KMMsgDictREntry *rentry) {
00901
if (rentry ==
mRDict)
00902
return;
00903 KMMsgDict::deleteRentry(
mRDict);
00904
mRDict = rentry;
00905 }
00906
00907
00908 void FolderStorage::setStatus(
QValueList<int>& ids, KMMsgStatus status,
bool toggle)
00909 {
00910
for (
QValueList<int>::Iterator it = ids.begin(); it != ids.end(); ++it )
00911 {
00912
FolderStorage::setStatus(*it, status, toggle);
00913 }
00914 }
00915
00916 void FolderStorage::ignoreJobsForMessage( KMMessage *msg )
00917 {
00918
if ( !msg || msg->transferInProgress() )
00919
return;
00920
00921
QPtrListIterator<FolderJob> it(
mJobList );
00922
while ( it.current() )
00923 {
00924
00925
00926
00927
if ( it.current()->msgList().first() == msg )
00928 {
00929 FolderJob* job = it.current();
00930
mJobList.remove( job );
00931
delete job;
00932 }
else
00933 ++it;
00934 }
00935 }
00936
00937
00938
void FolderStorage::removeJobs()
00939 {
00940 mJobList.setAutoDelete(
true );
00941 mJobList.clear();
00942 mJobList.setAutoDelete(
false );
00943 }
00944
00945
00946 size_t
FolderStorage::crlf2lf(
char* str,
const size_t strLen )
00947 {
00948
if ( !str || strLen == 0 )
return 0;
00949
00950
const char* source = str;
00951
const char* sourceEnd = source + strLen;
00952
00953
00954
for ( ; source < sourceEnd - 1; ++source ) {
00955
if ( *source ==
'\r' && *( source + 1 ) ==
'\n' )
00956
break;
00957 }
00958
00959
if ( source == sourceEnd - 1 ) {
00960
00961
return strLen;
00962 }
00963
00964
00965
char* target = const_cast<char*>( source );
00966 ++source;
00967
for ( ; source < sourceEnd; ++source ) {
00968
if ( *source !=
'\r' || *( source + 1 ) !=
'\n' )
00969 *target++ = *source;
00970 }
00971 *target =
'\0';
00972
return target - str;
00973 }
00974
00975
00976 void FolderStorage::updateChildrenState()
00977 {
00978
if ( folder() && folder()->
child() )
00979 {
00980
if ( kmkernel->folderMgr()->folderCount( folder()->child() ) > 0 )
00981
setHasChildren( HasChildren );
00982
else
00983
setHasChildren( HasNoChildren );
00984 }
00985 }
00986
00987
00988 void FolderStorage::setNoChildren(
bool aNoChildren )
00989 {
00990 mNoChildren = aNoChildren;
00991
if ( aNoChildren )
00992
setHasChildren( HasNoChildren );
00993 }
00994
00995
00996 void FolderStorage::setContentsType( KMail::FolderContentsType type )
00997 {
00998
if ( type !=
mContentsType ) {
00999
mContentsType = type;
01000
01001
01002
01003
01004
writeConfig();
01005 kmkernel->iCalIface().folderContentsTypeChanged( folder(), type );
01006 }
01007 }
01008
01009
#include "folderstorage.moc"