00001
00002
00003
00004
00005
#include <config.h>
00006
00007
#include "kmfolder.h"
00008
#include "kmfolderdir.h"
00009
#include "kmfoldermbox.h"
00010
#include "folderstorage.h"
00011
#include "kmfoldercachedimap.h"
00012
#include "kmfoldersearch.h"
00013
#include "kmfolderimap.h"
00014
#include "kmfoldermgr.h"
00015
#include <libkpimidentities/identitymanager.h>
00016
#include <libkpimidentities/identity.h>
00017
#include "expirejob.h"
00018
#include "compactionjob.h"
00019
#include "kmfoldertree.h"
00020
00021
#include <errno.h>
00022
00023
#include <kdebug.h>
00024
#include <klocale.h>
00025
#include <kmessagebox.h>
00026
#include <qfile.h>
00027
00028
00029 KMFolder::KMFolder(
KMFolderDir* aParent,
const QString& aFolderName,
00030 KMFolderType aFolderType )
00031 : KMFolderNode( aParent, aFolderName ), mStorage(0),
00032 mParent( aParent ), mChild( 0 ),
00033 mIsSystemFolder( false ),
00034 mExpireMessages( false ), mUnreadExpireAge( 28 ),
00035 mReadExpireAge( 14 ), mUnreadExpireUnits( expireNever ),
00036 mReadExpireUnits( expireNever ),
00037 mExpireAction( ExpireDelete ),
00038 mUseCustomIcons( false ), mMailingListEnabled( false )
00039 {
00040
if( aFolderType == KMFolderTypeCachedImap )
00041 mStorage =
new KMFolderCachedImap(
this, aFolderName.latin1() );
00042
else if( aFolderType == KMFolderTypeImap )
00043 mStorage =
new KMFolderImap(
this, aFolderName.latin1() );
00044
else if( aFolderType == KMFolderTypeMaildir )
00045 mStorage =
new KMFolderMaildir(
this, aFolderName.latin1() );
00046
else if( aFolderType == KMFolderTypeSearch )
00047 mStorage =
new KMFolderSearch(
this, aFolderName.latin1() );
00048
else
00049 mStorage =
new KMFolderMbox(
this, aFolderName.latin1() );
00050
00051
if ( aParent ) {
00052 connect( mStorage, SIGNAL(
msgAdded(
KMFolder*, Q_UINT32 ) ),
00053 aParent->
manager(), SIGNAL(
msgAdded(
KMFolder*, Q_UINT32 ) ) );
00054 connect( mStorage, SIGNAL(
msgRemoved(
KMFolder*, Q_UINT32 ) ),
00055 parent()->manager(), SIGNAL(
msgRemoved(
KMFolder*, Q_UINT32 ) ) );
00056 connect(
this, SIGNAL(
msgChanged(
KMFolder*, Q_UINT32,
int ) ),
00057 parent()->manager(), SIGNAL(
msgChanged(
KMFolder*, Q_UINT32,
int ) ) );
00058 connect(
this, SIGNAL(
msgHeaderChanged(
KMFolder*,
int ) ),
00059 parent()->manager(), SIGNAL(
msgHeaderChanged(
KMFolder*,
int ) ) );
00060 }
00061
00062
00063 connect( mStorage, SIGNAL(
changed() ), SIGNAL(
changed() ) );
00064 connect( mStorage, SIGNAL(
cleared() ), SIGNAL(
cleared() ) );
00065 connect( mStorage, SIGNAL(
expunged() ), SIGNAL(
expunged() ) );
00066 connect( mStorage, SIGNAL(
nameChanged() ), SIGNAL(
nameChanged() ) );
00067 connect( mStorage, SIGNAL(
msgRemoved(
KMFolder*, Q_UINT32 ) ),
00068 SIGNAL(
msgRemoved(
KMFolder*, Q_UINT32 ) ) );
00069 connect( mStorage, SIGNAL(
msgRemoved(
int,
QString,
QString ) ),
00070 SIGNAL(
msgRemoved(
int,
QString,
QString ) ) );
00071 connect( mStorage, SIGNAL(
msgRemoved(
KMFolder* ) ),
00072 SIGNAL(
msgRemoved(
KMFolder* ) ) );
00073 connect( mStorage, SIGNAL(
msgAdded(
int ) ), SIGNAL(
msgAdded(
int ) ) );
00074 connect( mStorage, SIGNAL(
msgAdded(
KMFolder*, Q_UINT32 ) ),
00075 SIGNAL(
msgAdded(
KMFolder*, Q_UINT32 ) ) );
00076 connect( mStorage, SIGNAL(
msgChanged(
KMFolder*, Q_UINT32 ,
int ) ),
00077 SIGNAL(
msgChanged(
KMFolder*, Q_UINT32 ,
int ) ) );
00078 connect( mStorage, SIGNAL(
msgHeaderChanged(
KMFolder*,
int ) ),
00079 SIGNAL(
msgHeaderChanged(
KMFolder*,
int ) ) );
00080 connect( mStorage, SIGNAL(
statusMsg(
const QString& ) ),
00081 SIGNAL(
statusMsg(
const QString& ) ) );
00082 connect( mStorage, SIGNAL(
numUnreadMsgsChanged(
KMFolder* ) ),
00083 SIGNAL(
numUnreadMsgsChanged(
KMFolder* ) ) );
00084 connect( mStorage, SIGNAL(
removed(
KMFolder*,
bool ) ),
00085 SIGNAL(
removed(
KMFolder*,
bool ) ) );
00086
00087
00088 mStorage->
readConfig();
00089
00090
if ( mId == 0 && aParent )
00091 mId = aParent->
manager()->createId();
00092 }
00093
00094 KMFolder::~KMFolder()
00095 {
00096
delete mStorage;
00097 }
00098
00099 void KMFolder::readConfig( KConfig* config )
00100 {
00101
if ( !config->readEntry(
"SystemLabel").isEmpty() )
00102 mSystemLabel = config->readEntry(
"SystemLabel");
00103 mExpireMessages = config->readBoolEntry(
"ExpireMessages",
false);
00104 mReadExpireAge = config->readNumEntry(
"ReadExpireAge", 3);
00105 mReadExpireUnits = (ExpireUnits)config->readNumEntry(
"ReadExpireUnits", expireMonths);
00106 mUnreadExpireAge = config->readNumEntry(
"UnreadExpireAge", 12);
00107 mUnreadExpireUnits = (ExpireUnits)config->readNumEntry(
"UnreadExpireUnits", expireNever);
00108 mExpireAction = config->readEntry(
"ExpireAction",
"Delete") ==
"Move" ? ExpireMove : ExpireDelete;
00109 mExpireToFolderId = config->readEntry(
"ExpireToFolder");
00110
00111 mUseCustomIcons = config->readBoolEntry(
"UseCustomIcons",
false );
00112 mNormalIconPath = config->readEntry(
"NormalIconPath" );
00113 mUnreadIconPath = config->readEntry(
"UnreadIconPath" );
00114
00115 mMailingListEnabled = config->readBoolEntry(
"MailingListEnabled");
00116 mMailingList.readConfig( config );
00117
00118 mIdentity = config->readUnsignedNumEntry(
"Identity",0);
00119
00120 setUserWhoField( config->readEntry(
"WhoField"),
false );
00121 uint savedId = config->readUnsignedNumEntry(
"Id", 0);
00122
00123
if ( savedId != 0 && mId == 0 )
00124 mId = savedId;
00125 mPutRepliesInSameFolder = config->readBoolEntry(
"PutRepliesInSameFolder",
false );
00126 mIgnoreNewMail = config->readBoolEntry(
"IgnoreNewMail",
false );
00127
00128
if ( mUseCustomIcons )
00129 emit
iconsChanged();
00130 }
00131
00132 void KMFolder::writeConfig( KConfig* config )
const
00133
{
00134 config->writeEntry(
"SystemLabel", mSystemLabel);
00135 config->writeEntry(
"ExpireMessages", mExpireMessages);
00136 config->writeEntry(
"ReadExpireAge", mReadExpireAge);
00137 config->writeEntry(
"ReadExpireUnits", mReadExpireUnits);
00138 config->writeEntry(
"UnreadExpireAge", mUnreadExpireAge);
00139 config->writeEntry(
"UnreadExpireUnits", mUnreadExpireUnits);
00140 config->writeEntry(
"ExpireAction", mExpireAction == ExpireDelete ?
"Delete" :
"Move");
00141 config->writeEntry(
"ExpireToFolder", mExpireToFolderId);
00142
00143 config->writeEntry(
"UseCustomIcons", mUseCustomIcons);
00144 config->writeEntry(
"NormalIconPath", mNormalIconPath);
00145 config->writeEntry(
"UnreadIconPath", mUnreadIconPath);
00146
00147 config->writeEntry(
"MailingListEnabled", mMailingListEnabled);
00148 mMailingList.writeConfig( config );
00149
00150 config->writeEntry(
"Identity", mIdentity);
00151
00152 config->writeEntry(
"WhoField", mUserWhoField);
00153 config->writeEntry(
"Id", mId);
00154 config->writeEntry(
"PutRepliesInSameFolder", mPutRepliesInSameFolder );
00155 config->writeEntry(
"IgnoreNewMail", mIgnoreNewMail );
00156 }
00157
00158 KMFolderType
KMFolder::folderType()
const
00159
{
00160
return mStorage ? mStorage->
folderType() : KMFolderTypeUnknown;
00161 }
00162
00163 QString KMFolder::fileName()
const
00164
{
00165
return mStorage ? mStorage->
fileName() : QString::null;
00166 }
00167
00168 QString KMFolder::location()
const
00169
{
00170
return mStorage ? mStorage->
location() : QString::null;
00171 }
00172
00173 QString KMFolder::indexLocation()
const
00174
{
00175
return mStorage ? mStorage->
indexLocation() : QString::null;
00176 }
00177
00178 QString KMFolder::subdirLocation()
const
00179
{
00180
QString sLocation( path() );
00181
00182
if( !sLocation.isEmpty() )
00183 sLocation +=
'/';
00184 sLocation +=
'.' +
FolderStorage::dotEscape(
fileName() ) +
".directory";
00185
00186
return sLocation;
00187 }
00188
00189 KMFolderDir*
KMFolder::createChildFolder()
00190 {
00191
if( mChild )
00192
return mChild;
00193
00194
QString childName =
"." +
fileName() +
".directory";
00195
QString childDir = path() +
"/" + childName;
00196
if (access(QFile::encodeName(childDir), W_OK) != 0)
00197 {
00198
if (mkdir(QFile::encodeName(childDir), S_IRWXU) != 0
00199 && chmod(QFile::encodeName(childDir), S_IRWXU) != 0) {
00200
QString wmsg =
QString(
" '%1': %2").arg(childDir).arg(strerror(errno));
00201 KMessageBox::information(0,i18n(
"Failed to create folder") + wmsg);
00202
return 0;
00203 }
00204 }
00205
00206 mChild =
new KMFolderDir(
this, parent(), childName,
00207 (
folderType() == KMFolderTypeImap) ? KMImapDir : KMStandardDir);
00208
if( !mChild )
00209
return 0;
00210 mChild->
reload();
00211 parent()->append( mChild );
00212
return mChild;
00213 }
00214
00215 void KMFolder::setChild(
KMFolderDir* aChild )
00216 {
00217 mChild = aChild;
00218 mStorage->
updateChildrenState();
00219 }
00220
00221 bool KMFolder::noContent()
const
00222
{
00223
return mStorage->
noContent();
00224 }
00225
00226 void KMFolder::setNoContent(
bool aNoContent )
00227 {
00228 mStorage->
setNoContent( aNoContent );
00229 }
00230
00231 bool KMFolder::noChildren()
const
00232
{
00233
return mStorage->
noChildren();
00234 }
00235
00236 void KMFolder::setNoChildren(
bool aNoChildren )
00237 {
00238 mStorage->
setNoChildren( aNoChildren );
00239 }
00240
00241 KMMessage*
KMFolder::getMsg(
int idx )
00242 {
00243
return mStorage->
getMsg( idx );
00244 }
00245
00246 KMMsgInfo*
KMFolder::unGetMsg(
int idx )
00247 {
00248
return mStorage->
unGetMsg( idx );
00249 }
00250
00251 bool KMFolder::isMessage(
int idx )
00252 {
00253
return mStorage->
isMessage( idx );
00254 }
00255
00256 QCString&
KMFolder::getMsgString(
int idx,
QCString& mDest )
00257 {
00258
return mStorage->
getMsgString( idx, mDest );
00259 }
00260
00261 DwString
KMFolder::getDwString(
int idx )
00262 {
00263
return mStorage->
getDwString( idx );
00264 }
00265
00266 void KMFolder::ignoreJobsForMessage( KMMessage* m )
00267 {
00268 mStorage->
ignoreJobsForMessage( m );
00269 }
00270
00271 FolderJob*
KMFolder::createJob( KMMessage *msg, FolderJob::JobType jt,
00272
KMFolder *folder,
QString partSpecifier,
00273
const AttachmentStrategy *as )
const
00274
{
00275
return mStorage->
createJob( msg, jt, folder, partSpecifier, as );
00276 }
00277
00278 FolderJob*
KMFolder::createJob(
QPtrList<KMMessage>& msgList,
00279
const QString& sets,
00280 FolderJob::JobType jt,
KMFolder *folder )
const
00281
{
00282
return mStorage->
createJob( msgList, sets, jt, folder );
00283 }
00284
00285 const KMMsgBase*
KMFolder::getMsgBase(
int idx )
const
00286
{
00287
return mStorage->
getMsgBase( idx );
00288 }
00289
00290 KMMsgBase*
KMFolder::getMsgBase(
int idx )
00291 {
00292
return mStorage->
getMsgBase( idx );
00293 }
00294
00295 const KMMsgBase*
KMFolder::operator[](
int idx )
const
00296
{
00297
return mStorage->operator[]( idx );
00298 }
00299
00300 KMMsgBase*
KMFolder::operator[](
int idx )
00301 {
00302
return mStorage->operator[]( idx );
00303 }
00304
00305 KMMessage*
KMFolder::take(
int idx )
00306 {
00307
return mStorage->
take( idx );
00308 }
00309
00310
void KMFolder::take(
QPtrList<KMMessage> msgList )
00311 {
00312 mStorage->
take( msgList );
00313 }
00314
00315 int KMFolder::addMsg( KMMessage* msg,
int* index_return )
00316 {
00317
return mStorage->
addMsg( msg, index_return );
00318 }
00319
00320 int KMFolder::addMsgKeepUID( KMMessage* msg,
int* index_return )
00321 {
00322
return mStorage->
addMsgKeepUID( msg, index_return );
00323 }
00324
00325 void KMFolder::emitMsgAddedSignals(
int idx )
00326 {
00327 mStorage->
emitMsgAddedSignals( idx );
00328 }
00329
00330 void KMFolder::removeMsg(
int i,
bool imapQuiet )
00331 {
00332 mStorage->
removeMsg( i, imapQuiet );
00333 }
00334
00335
void KMFolder::removeMsg(
QPtrList<KMMessage> msgList,
bool imapQuiet )
00336 {
00337 mStorage->
removeMsg( msgList, imapQuiet );
00338 }
00339
00340 int KMFolder::expungeOldMsg(
int days )
00341 {
00342
return mStorage->
expungeOldMsg( days );
00343 }
00344
00345 int KMFolder::moveMsg( KMMessage* msg,
int* index_return )
00346 {
00347
return mStorage->
moveMsg( msg, index_return );
00348 }
00349
00350
int KMFolder::moveMsg(
QPtrList<KMMessage> q,
int* index_return )
00351 {
00352
return mStorage->
moveMsg( q, index_return );
00353 }
00354
00355 int KMFolder::find(
const KMMsgBase* msg )
const
00356
{
00357
return mStorage->
find( msg );
00358 }
00359
00360
int KMFolder::find(
const KMMessage* msg )
const
00361
{
00362
return mStorage->
find( msg );
00363 }
00364
00365 int KMFolder::count(
bool cache )
const
00366
{
00367
return mStorage->
count( cache );
00368 }
00369
00370 int KMFolder::countUnread()
00371 {
00372
return mStorage->
countUnread();
00373 }
00374
00375 int KMFolder::countUnreadRecursive()
00376 {
00377
KMFolder *folder;
00378
int count =
countUnread();
00379
KMFolderDir *dir =
child();
00380
if (!dir)
00381
return count;
00382
00383
QPtrListIterator<KMFolderNode> it(*dir);
00384
for ( ; it.current(); ++it )
00385
if (!it.current()->isDir()) {
00386 folder = static_cast<KMFolder*>(it.current());
00387 count += folder->
countUnreadRecursive();
00388 }
00389
00390
return count;
00391 }
00392
00393 void KMFolder::msgStatusChanged(
const KMMsgStatus oldStatus,
00394
const KMMsgStatus newStatus,
int idx )
00395 {
00396 mStorage->
msgStatusChanged( oldStatus, newStatus, idx );
00397 }
00398
00399 int KMFolder::open()
00400 {
00401
return mStorage->
open();
00402 }
00403
00404 int KMFolder::canAccess()
00405 {
00406
return mStorage->
canAccess();
00407 }
00408
00409 void KMFolder::close(
bool force )
00410 {
00411 mStorage->
close( force );
00412 }
00413
00414 void KMFolder::sync()
00415 {
00416 mStorage->
sync();
00417 }
00418
00419 bool KMFolder::isOpened()
const
00420
{
00421
return mStorage->
isOpened();
00422 }
00423
00424 void KMFolder::markNewAsUnread()
00425 {
00426 mStorage->
markNewAsUnread();
00427 }
00428
00429 void KMFolder::markUnreadAsRead()
00430 {
00431 mStorage->
markUnreadAsRead();
00432 }
00433
00434 int KMFolder::create(
bool imap )
00435 {
00436
return mStorage->
create( imap );
00437 }
00438
00439 void KMFolder::remove()
00440 {
00441 mStorage->
remove();
00442 }
00443
00444 int KMFolder::expunge()
00445 {
00446
return mStorage->
expunge();
00447 }
00448
00449 int KMFolder::rename(
const QString& newName,
KMFolderDir *aParent )
00450 {
00451
return mStorage->
rename( newName, aParent );
00452 }
00453
00454 bool KMFolder::autoCreateIndex()
const
00455
{
00456
return mStorage->
autoCreateIndex();
00457 }
00458
00459 void KMFolder::setAutoCreateIndex(
bool b )
00460 {
00461 mStorage->
setAutoCreateIndex( b );
00462 }
00463
00464 bool KMFolder::dirty()
const
00465
{
00466
return mStorage->
dirty();
00467 }
00468
00469 void KMFolder::setDirty(
bool f )
00470 {
00471 mStorage->
setDirty( f );
00472 }
00473
00474 bool KMFolder::needsCompacting()
const
00475
{
00476
return mStorage->
needsCompacting();
00477 }
00478
00479
void KMFolder::setNeedsCompacting(
bool f )
00480 {
00481 mStorage->
setNeedsCompacting( f );
00482 }
00483
00484 void KMFolder::quiet(
bool beQuiet )
00485 {
00486 mStorage->
quiet( beQuiet );
00487 }
00488
00489 bool KMFolder::isReadOnly()
const
00490
{
00491
return mStorage->
isReadOnly();
00492 }
00493
00494 QString KMFolder::label()
const
00495
{
00496
if ( !mSystemLabel.isEmpty() )
00497
return mSystemLabel;
00498
if ( !mLabel.isEmpty() )
00499
return mLabel;
00500
if (
isSystemFolder() )
00501
return i18n( name().latin1() );
00502
return name();
00503 }
00504
00505
00506 QString KMFolder::prettyURL()
const
00507
{
00508
if ( parent() )
00509
return parent()->prettyURL() +
"/" +
label();
00510
else
00511
return "/" +
label();
00512 }
00513
00514
00515
QString KMFolder::mailingListPostAddress()
const
00516
{
00517
if ( mMailingList.
features() & MailingList::Post ) {
00518 KURL::List::const_iterator it;
00519 KURL::List post = mMailingList.
postURLS();
00520
for( it = post.begin(); it != post.end(); ++it ) {
00521
00522
00523
if ( (*it).protocol() ==
"mailto" || (*it).protocol().isEmpty() )
00524
return (*it).path();
00525 }
00526 }
00527
return QString::null;
00528 }
00529
00530 const char*
KMFolder::type()
const
00531
{
00532
return mStorage->
type();
00533 }
00534
00535 bool KMFolder::hasAccounts()
const
00536
{
00537
return mStorage->
hasAccounts();
00538 }
00539
00540 void KMFolder::setMailingListEnabled(
bool enabled )
00541 {
00542 mMailingListEnabled = enabled;
00543 mStorage->
writeConfig();
00544 }
00545
00546
void KMFolder::setMailingList(
const MailingList& mlist )
00547 {
00548 mMailingList = mlist;
00549 mStorage->
writeConfig();
00550 }
00551
00552
void KMFolder::setIdentity( uint identity )
00553 {
00554 mIdentity = identity;
00555 kmkernel->slotRequestConfigSync();
00556 }
00557
00558
void KMFolder::setWhoField(
const QString& aWhoField )
00559 {
00560 mWhoField = aWhoField;
00561
#if 0
00562
00563 mStorage->
writeConfig();
00564
#endif
00565
}
00566
00567
void KMFolder::setUserWhoField(
const QString& whoField,
bool writeConfig )
00568 {
00569 mUserWhoField = whoField;
00570
if ( whoField.isEmpty() )
00571 {
00572
00573
const KPIM::Identity & identity =
00574 kmkernel->identityManager()->identityForUoidOrDefault( mIdentity );
00575
00576
if (
isSystemFolder() &&
folderType() != KMFolderTypeImap ) {
00577
00578
if (
this == kmkernel->inboxFolder() ||
00579
this == kmkernel->trashFolder() )
00580 mWhoField =
"From";
00581
if (
this == kmkernel->outboxFolder() ||
00582
this == kmkernel->sentFolder() ||
00583
this == kmkernel->draftsFolder() )
00584 mWhoField =
"To";
00585 }
else if ( identity.drafts() ==
idString()
00586 || identity.fcc() ==
idString() )
00587
00588 mWhoField =
"To";
00589
else
00590 mWhoField =
"From";
00591 }
else if ( whoField ==
"From" || whoField ==
"To" )
00592
00593 mWhoField = whoField;
00594
else
00595
00596 kdDebug(5006) <<
"Illegal setting " << whoField <<
" for userWhoField!"
00597 << endl;
00598
00599
if (writeConfig)
00600 mStorage->
writeConfig();
00601 }
00602
00603 void KMFolder::correctUnreadMsgsCount()
00604 {
00605 mStorage->
correctUnreadMsgsCount();
00606 }
00607
00608 QString KMFolder::idString()
const
00609
{
00610 KMFolderNode* folderNode = parent();
00611
if (!folderNode)
00612
return "";
00613
while ( folderNode->parent() )
00614 folderNode = folderNode->parent();
00615
QString myPath = path();
00616
int pathLen = myPath.length() - folderNode->path().length();
00617
QString relativePath = myPath.right( pathLen );
00618
if (!relativePath.isEmpty())
00619 relativePath = relativePath.right( relativePath.length() - 1 ) +
"/";
00620
QString escapedName = name();
00621
00622
00623 escapedName.replace(
"[",
"%(" );
00624 escapedName.replace(
"]",
"%)" );
00625
return relativePath + escapedName;
00626 }
00627
00628 void KMFolder::setAutoExpire(
bool enabled )
00629 {
00630
if( enabled != mExpireMessages ) {
00631 mExpireMessages = enabled;
00632 mStorage->
writeConfig();
00633 }
00634 }
00635
00636 void KMFolder::setUnreadExpireAge(
int age )
00637 {
00638
if( age >= 0 && age != mUnreadExpireAge ) {
00639 mUnreadExpireAge = age;
00640 mStorage->
writeConfig();
00641 }
00642 }
00643
00644 void KMFolder::setUnreadExpireUnits( ExpireUnits units )
00645 {
00646
if (units >= expireNever && units < expireMaxUnits)
00647 mUnreadExpireUnits = units;
00648 }
00649
00650 void KMFolder::setReadExpireAge(
int age )
00651 {
00652
if( age >= 0 && age != mReadExpireAge ) {
00653 mReadExpireAge = age;
00654 mStorage->
writeConfig();
00655 }
00656 }
00657
00658 void KMFolder::setReadExpireUnits( ExpireUnits units )
00659 {
00660
if (units >= expireNever && units <= expireMaxUnits)
00661 mReadExpireUnits = units;
00662 }
00663
00664
00665
void KMFolder::setExpireAction( ExpireAction a )
00666 {
00667
if ( a != mExpireAction ) {
00668 mExpireAction = a;
00669 mStorage->
writeConfig();
00670 }
00671 }
00672
00673
void KMFolder::setExpireToFolderId(
const QString&
id )
00674 {
00675
if (
id != mExpireToFolderId ) {
00676 mExpireToFolderId =
id;
00677 mStorage->
writeConfig();
00678 }
00679 }
00680
00681
00682
static int daysToExpire(
int number, ExpireUnits units )
00683 {
00684
switch (units) {
00685
case expireDays:
00686
return number;
00687
case expireWeeks:
00688
return number * 7;
00689
case expireMonths:
00690
return number * 31;
00691
default:
00692 ;
00693 }
00694
return -1;
00695 }
00696
00697
void KMFolder::daysToExpire(
int& unreadDays,
int& readDays) {
00698 unreadDays = ::daysToExpire(
getUnreadExpireAge(),
getUnreadExpireUnits() );
00699 readDays = ::daysToExpire(
getReadExpireAge(),
getReadExpireUnits() );
00700 }
00701
00702 void KMFolder::expireOldMessages(
bool immediate )
00703 {
00704
KMail::ScheduledExpireTask* task =
new KMail::ScheduledExpireTask(
this, immediate);
00705 kmkernel->jobScheduler()->registerTask( task );
00706
if ( immediate ) {
00707
00708
compact( CompactLater );
00709 }
00710 }
00711
00712 void KMFolder::compact( CompactOptions options )
00713 {
00714
if ( options == CompactLater ) {
00715
KMail::ScheduledCompactionTask* task =
new KMail::ScheduledCompactionTask(
this,
false);
00716 kmkernel->jobScheduler()->registerTask( task );
00717 }
else {
00718 mStorage->
compact( options == CompactSilentlyNow );
00719 }
00720 }
00721
00722 KMFolder*
KMFolder::trashFolder()
const
00723
{
00724
return mStorage ? mStorage->
trashFolder() : 0;
00725 }
00726
00727 int KMFolder::writeIndex(
bool createEmptyIndex )
00728 {
00729
return mStorage->
writeIndex( createEmptyIndex );
00730 }
00731
00732 void KMFolder::fillMsgDict( KMMsgDict* dict )
00733 {
00734 mStorage->
fillMsgDict( dict );
00735 }
00736
00737 int KMFolder::writeMsgDict( KMMsgDict* dict)
00738 {
00739
return mStorage->
writeMsgDict( dict );
00740 }
00741
00742 int KMFolder::touchMsgDict()
00743 {
00744
return mStorage->
touchMsgDict();
00745 }
00746
00747 int KMFolder::appendtoMsgDict(
int idx )
00748 {
00749
return mStorage->
appendtoMsgDict( idx );
00750 }
00751
00752 void KMFolder::setRDict( KMMsgDictREntry* rentry )
00753 {
00754 mStorage->
setRDict( rentry );
00755 }
00756
00757 KMMsgDictREntry*
KMFolder::rDict()
const
00758
{
00759
return mStorage->
rDict();
00760 }
00761
00762 void KMFolder::setStatus(
int idx, KMMsgStatus status,
bool toggle )
00763 {
00764 mStorage->
setStatus( idx, status, toggle );
00765 }
00766
00767 void KMFolder::setStatus(
QValueList<int>& ids, KMMsgStatus status,
00768
bool toggle )
00769 {
00770 mStorage->
setStatus( ids, status, toggle);
00771 }
00772
00773
void KMFolder::setIconPaths(
const QString &normalPath,
00774
const QString &unreadPath )
00775 {
00776 mNormalIconPath = normalPath;
00777 mUnreadIconPath = unreadPath;
00778 mStorage->
writeConfig();
00779 emit
iconsChanged();
00780 }
00781
00782
void KMFolder::removeJobs()
00783 {
00784 mStorage->
removeJobs();
00785 }
00786
00787 size_t
KMFolder::crlf2lf(
char* str,
const size_t strLen )
00788 {
00789
return FolderStorage::crlf2lf( str, strLen );
00790 }
00791
00792 int KMFolder::updateIndex()
00793 {
00794
return mStorage->
updateIndex();
00795 }
00796
00797 void KMFolder::reallyAddMsg( KMMessage* aMsg )
00798 {
00799 mStorage->
reallyAddMsg( aMsg );
00800 }
00801
00802 void KMFolder::reallyAddCopyOfMsg( KMMessage* aMsg )
00803 {
00804 mStorage->
reallyAddCopyOfMsg( aMsg );
00805 }
00806
00807
#include "kmfolder.moc"