00001
00002
00003
00004
00005
00006
#ifdef HAVE_CONFIG_H
00007
#include <config.h>
00008
#endif
00009
00010
#include "kmfilteraction.h"
00011
00012
#include "kmcommands.h"
00013
#include "kmmsgpart.h"
00014
#include "kmfiltermgr.h"
00015
#include "kmfolderindex.h"
00016
#include "kmfoldermgr.h"
00017
#include "kmsender.h"
00018
#include <libkpimidentities/identity.h>
00019
#include <libkpimidentities/identitymanager.h>
00020
#include <libkpimidentities/identitycombo.h>
00021
#include <libkdepim/kfileio.h>
00022
#include <libkdepim/collectingprocess.h>
00023
using KPIM::CollectingProcess;
00024
#include "kmfawidgets.h"
00025
#include "kmfoldercombobox.h"
00026
#include "kmmsgbase.h"
00027
#include "messageproperty.h"
00028
#include "actionscheduler.h"
00029
using KMail::MessageProperty;
00030
using KMail::ActionScheduler;
00031
#include <kregexp3.h>
00032
#include <ktempfile.h>
00033
#include <kdebug.h>
00034
#include <klocale.h>
00035
#include <kprocess.h>
00036
#include <kaudioplayer.h>
00037
#include <kurlrequester.h>
00038
00039
#include <qlabel.h>
00040
#include <qlayout.h>
00041
#include <qtextcodec.h>
00042
#include <qtimer.h>
00043
#include <qobject.h>
00044
#include <assert.h>
00045
00046
00047
00048
00049
00050
00051
00052
00053 KMFilterAction::KMFilterAction(
const char* aName,
const QString aLabel )
00054 {
00055 mName = aName;
00056 mLabel = aLabel;
00057 }
00058
00059 KMFilterAction::~KMFilterAction()
00060 {
00061 }
00062
00063 void KMFilterAction::processAsync(KMMessage* msg)
const
00064
{
00065 ActionScheduler *handler = MessageProperty::filterHandler( msg );
00066
ReturnCode result =
process( msg );
00067
if (handler)
00068 handler->actionMessage( result );
00069 }
00070
00071 bool KMFilterAction::requiresBody(KMMsgBase*)
const
00072
{
00073
return true;
00074 }
00075
00076 KMFilterAction*
KMFilterAction::newAction()
00077 {
00078
return 0;
00079 }
00080
00081 QWidget*
KMFilterAction::createParamWidget(
QWidget* parent)
const
00082
{
00083
return new QWidget(parent);
00084 }
00085
00086 void KMFilterAction::applyParamWidgetValue(
QWidget*)
00087 {
00088 }
00089
00090 void KMFilterAction::setParamWidgetValue(
QWidget * )
const
00091
{
00092 }
00093
00094 void KMFilterAction::clearParamWidget(
QWidget * )
const
00095
{
00096 }
00097
00098 bool KMFilterAction::folderRemoved(
KMFolder*,
KMFolder*)
00099 {
00100
return FALSE;
00101 }
00102
00103 int KMFilterAction::tempOpenFolder(
KMFolder* aFolder)
00104 {
00105
return kmkernel->filterMgr()->tempOpenFolder(aFolder);
00106 }
00107
00108 void KMFilterAction::sendMDN( KMMessage * msg, KMime::MDN::DispositionType d,
00109
const QValueList<KMime::MDN::DispositionModifier> & m ) {
00110
if ( !msg )
return;
00111 KMMessage * mdn = msg->createMDN( KMime::MDN::AutomaticAction, d,
false, m );
00112
if ( mdn && !kmkernel->msgSender()->send( mdn, FALSE ) ) {
00113 kdDebug(5006) <<
"KMFilterAction::sendMDN(): sending failed." << endl;
00114
00115 }
00116 }
00117
00118
00119
00120
00121
00122
00123
00124
00125 KMFilterActionWithNone::KMFilterActionWithNone(
const char* aName,
const QString aLabel )
00126 :
KMFilterAction( aName, aLabel )
00127 {
00128 }
00129
00130
00131
00132
00133
00134
00135
00136
00137 KMFilterActionWithUOID::KMFilterActionWithUOID(
const char* aName,
const QString aLabel )
00138 :
KMFilterAction( aName, aLabel ), mParameter( 0 )
00139 {
00140 }
00141
00142 void KMFilterActionWithUOID::argsFromString(
const QString argsStr )
00143 {
00144 mParameter = argsStr.stripWhiteSpace().toUInt();
00145 }
00146
00147 const QString KMFilterActionWithUOID::argsAsString()
const
00148
{
00149
return QString::number( mParameter );
00150 }
00151
00152
00153
00154
00155
00156
00157
00158 KMFilterActionWithString::KMFilterActionWithString(
const char* aName,
const QString aLabel )
00159 :
KMFilterAction( aName, aLabel )
00160 {
00161 }
00162
00163 QWidget*
KMFilterActionWithString::createParamWidget(
QWidget* parent )
const
00164
{
00165
QLineEdit *le =
new KLineEdit(parent);
00166 le->setText( mParameter );
00167
return le;
00168 }
00169
00170 void KMFilterActionWithString::applyParamWidgetValue(
QWidget* paramWidget )
00171 {
00172 mParameter = ((
QLineEdit*)paramWidget)->text();
00173 }
00174
00175 void KMFilterActionWithString::setParamWidgetValue(
QWidget* paramWidget )
const
00176
{
00177 ((
QLineEdit*)paramWidget)->setText( mParameter );
00178 }
00179
00180 void KMFilterActionWithString::clearParamWidget(
QWidget* paramWidget )
const
00181
{
00182 ((
QLineEdit*)paramWidget)->clear();
00183 }
00184
00185 void KMFilterActionWithString::argsFromString(
const QString argsStr )
00186 {
00187 mParameter = argsStr;
00188 }
00189
00190 const QString KMFilterActionWithString::argsAsString()
const
00191
{
00192
return mParameter;
00193 }
00194
00195
00196
00197
00198
00199
00200
00201 KMFilterActionWithStringList::KMFilterActionWithStringList(
const char* aName,
const QString aLabel )
00202 :
KMFilterActionWithString( aName, aLabel )
00203 {
00204 }
00205
00206 QWidget*
KMFilterActionWithStringList::createParamWidget(
QWidget* parent )
const
00207
{
00208
QComboBox *cb =
new QComboBox( FALSE, parent );
00209 cb->insertStringList( mParameterList );
00210
setParamWidgetValue( cb );
00211
return cb;
00212 }
00213
00214 void KMFilterActionWithStringList::applyParamWidgetValue(
QWidget* paramWidget )
00215 {
00216 mParameter = ((
QComboBox*)paramWidget)->currentText();
00217 }
00218
00219 void KMFilterActionWithStringList::setParamWidgetValue(
QWidget* paramWidget )
const
00220
{
00221
int idx = mParameterList.findIndex( mParameter );
00222 ((
QComboBox*)paramWidget)->setCurrentItem( idx >= 0 ? idx : 0 );
00223 }
00224
00225 void KMFilterActionWithStringList::clearParamWidget(
QWidget* paramWidget )
const
00226
{
00227 ((
QComboBox*)paramWidget)->setCurrentItem(0);
00228 }
00229
00230 void KMFilterActionWithStringList::argsFromString(
const QString argsStr )
00231 {
00232
int idx = mParameterList.findIndex( argsStr );
00233
if ( idx < 0 ) {
00234 mParameterList.append( argsStr );
00235 idx = mParameterList.count() - 1;
00236 }
00237 mParameter = *mParameterList.at( idx );
00238 }
00239
00240
00241
00242
00243
00244
00245
00246
00247 KMFilterActionWithFolder::KMFilterActionWithFolder(
const char* aName,
const QString aLabel )
00248 :
KMFilterAction( aName, aLabel )
00249 {
00250 mFolder = 0;
00251 }
00252
00253 QWidget*
KMFilterActionWithFolder::createParamWidget(
QWidget* parent )
const
00254
{
00255 KMFolderComboBox *cb =
new KMFolderComboBox( parent );
00256 cb->showImapFolders(
false );
00257
setParamWidgetValue( cb );
00258
return cb;
00259 }
00260
00261 void KMFilterActionWithFolder::applyParamWidgetValue(
QWidget* paramWidget )
00262 {
00263 mFolder = ((KMFolderComboBox *)paramWidget)->getFolder();
00264
if (mFolder)
00265 {
00266 mFolderName = QString::null;
00267 }
00268
else
00269 {
00270 mFolderName = ((KMFolderComboBox *)paramWidget)->currentText();
00271 }
00272 }
00273
00274 void KMFilterActionWithFolder::setParamWidgetValue(
QWidget* paramWidget )
const
00275
{
00276
if ( mFolder )
00277 ((KMFolderComboBox *)paramWidget)->setFolder( mFolder );
00278
else
00279 ((KMFolderComboBox *)paramWidget)->setFolder( mFolderName );
00280 }
00281
00282 void KMFilterActionWithFolder::clearParamWidget(
QWidget* paramWidget )
const
00283
{
00284 ((KMFolderComboBox *)paramWidget)->setFolder( kmkernel->inboxFolder() );
00285 }
00286
00287 void KMFilterActionWithFolder::argsFromString(
const QString argsStr )
00288 {
00289 mFolder = kmkernel->folderMgr()->findIdString( argsStr );
00290
if (!mFolder)
00291 mFolder = kmkernel->dimapFolderMgr()->findIdString( argsStr );
00292
if (mFolder)
00293 mFolderName = QString::null;
00294
else
00295 mFolderName = argsStr;
00296 }
00297
00298 const QString KMFilterActionWithFolder::argsAsString()
const
00299
{
00300
QString result;
00301
if ( mFolder )
00302 result = mFolder->idString();
00303
else
00304 result = mFolderName;
00305
return result;
00306 }
00307
00308 bool KMFilterActionWithFolder::folderRemoved(
KMFolder* aFolder,
KMFolder* aNewFolder )
00309 {
00310
if ( aFolder == mFolder ) {
00311 mFolder = aNewFolder;
00312
if ( aNewFolder )
00313 mFolderName = QString::null;
00314
else
00315 mFolderName = i18n(
"<select a folder>" );
00316
return TRUE;
00317 }
else
00318
return FALSE;
00319 }
00320
00321
00322
00323
00324
00325
00326
00327 KMFilterActionWithAddress::KMFilterActionWithAddress(
const char* aName,
const QString aLabel )
00328 :
KMFilterActionWithString( aName, aLabel )
00329 {
00330 }
00331
00332 QWidget*
KMFilterActionWithAddress::createParamWidget(
QWidget* parent )
const
00333
{
00334 KMFilterActionWithAddressWidget *w =
new KMFilterActionWithAddressWidget(parent);
00335 w->setText( mParameter );
00336
return w;
00337 }
00338
00339 void KMFilterActionWithAddress::applyParamWidgetValue(
QWidget* paramWidget )
00340 {
00341 mParameter = ((KMFilterActionWithAddressWidget*)paramWidget)->text();
00342 }
00343
00344 void KMFilterActionWithAddress::setParamWidgetValue(
QWidget* paramWidget )
const
00345
{
00346 ((KMFilterActionWithAddressWidget*)paramWidget)->setText( mParameter );
00347 }
00348
00349 void KMFilterActionWithAddress::clearParamWidget(
QWidget* paramWidget )
const
00350
{
00351 ((KMFilterActionWithAddressWidget*)paramWidget)->clear();
00352 }
00353
00354
00355
00356
00357
00358
00359
00360 KMFilterActionWithCommand::KMFilterActionWithCommand(
const char* aName,
const QString aLabel )
00361 :
KMFilterActionWithUrl( aName, aLabel )
00362 {
00363 }
00364
00365
QWidget* KMFilterActionWithCommand::createParamWidget(
QWidget* parent )
const
00366
{
00367
return KMFilterActionWithUrl::createParamWidget( parent );
00368 }
00369
00370
void KMFilterActionWithCommand::applyParamWidgetValue(
QWidget* paramWidget )
00371 {
00372
KMFilterActionWithUrl::applyParamWidgetValue( paramWidget );
00373 }
00374
00375
void KMFilterActionWithCommand::setParamWidgetValue(
QWidget* paramWidget )
const
00376
{
00377
KMFilterActionWithUrl::setParamWidgetValue( paramWidget );
00378 }
00379
00380
void KMFilterActionWithCommand::clearParamWidget(
QWidget* paramWidget )
const
00381
{
00382
KMFilterActionWithUrl::clearParamWidget( paramWidget );
00383 }
00384
00385
QString KMFilterActionWithCommand::substituteCommandLineArgsFor( KMMessage *aMsg,
QPtrList<KTempFile> & aTempFileList )
const
00386
{
00387
QString result = mParameter;
00388
QValueList<int> argList;
00389
QRegExp r(
"%[0-9-]+" );
00390
00391
00392
int start = -1;
00393
while ( ( start = r.search( result, start + 1 ) ) > 0 ) {
00394
int len = r.matchedLength();
00395
00396
bool OK =
false;
00397
int n = result.mid( start + 1, len - 1 ).toInt( &OK );
00398
if ( OK )
00399 argList.append( n );
00400 }
00401
00402
00403 qHeapSort( argList );
00404
00405
00406
int lastSeen = -2;
00407
QString tempFileName;
00408
for (
QValueList<int>::Iterator it = argList.begin() ; it != argList.end() ; ++it ) {
00409
00410
if ( (*it) != lastSeen ) {
00411 KTempFile *tf =
new KTempFile();
00412
if ( tf->status() != 0 ) {
00413 tf->close();
00414
delete tf;
00415 kdDebug(5006) <<
"KMFilterActionWithCommand: Could not create temp file!" << endl;
00416
return QString::null;
00417 }
00418 tf->setAutoDelete(TRUE);
00419 aTempFileList.append( tf );
00420 tempFileName = tf->name();
00421
if ((*it) == -1)
00422 KPIM::kCStringToFile( aMsg->asString(), tempFileName,
00423
false,
false,
false );
00424
else if (aMsg->numBodyParts() == 0)
00425 KPIM::kByteArrayToFile( aMsg->bodyDecodedBinary(), tempFileName,
00426
false,
false,
false );
00427
else {
00428 KMMessagePart msgPart;
00429 aMsg->bodyPart( (*it), &msgPart );
00430 KPIM::kByteArrayToFile( msgPart.bodyDecodedBinary(), tempFileName,
00431
false,
false,
false );
00432 }
00433 tf->close();
00434 }
00435
00436
00437
00438
if ((*it) == -1) result.replace(
"%-1", tempFileName );
00439
else result = result.arg( tempFileName );
00440 }
00441
00442
00443
00444
QRegExp header_rx(
"%\\{([a-z0-9-]+)\\}",
false );
00445
int idx = 0;
00446
while ( ( idx = header_rx.search( result, idx ) ) != -1 ) {
00447
QString replacement = KProcess::quote( aMsg->headerField( header_rx.cap(1).latin1() ) );
00448 result.replace( idx, header_rx.matchedLength(), replacement );
00449 idx += replacement.length();
00450 }
00451
00452
return result;
00453 }
00454
00455
00456
KMFilterAction::ReturnCode KMFilterActionWithCommand::genericProcess(KMMessage* aMsg,
bool withOutput)
const
00457
{
00458 Q_ASSERT( aMsg );
00459
00460
if ( mParameter.isEmpty() )
00461
return ErrorButGoOn;
00462
00463
00464
00465 KTempFile * inFile =
new KTempFile;
00466 inFile->setAutoDelete(TRUE);
00467
00468
QPtrList<KTempFile> atmList;
00469 atmList.setAutoDelete(TRUE);
00470 atmList.append( inFile );
00471
00472
QString commandLine = substituteCommandLineArgsFor( aMsg , atmList );
00473
if ( commandLine.isEmpty() )
00474
return ErrorButGoOn;
00475
00476
00477
00478
00479
00480
00481
00482
00483 commandLine =
"(" + commandLine +
") <" + inFile->name();
00484
00485
00486
QString tempFileName = inFile->name();
00487 KPIM::kCStringToFile( aMsg->asString(), tempFileName,
00488
false,
false,
false );
00489 inFile->close();
00490
00491 CollectingProcess shProc;
00492 shProc.setUseShell(
true);
00493 shProc << commandLine;
00494
00495
00496
if ( !shProc.start( KProcess::Block,
00497 withOutput ? KProcess::Stdout
00498 : KProcess::NoCommunication ) )
00499
return ErrorButGoOn;
00500
00501
if ( !shProc.normalExit() || shProc.exitStatus() != 0 ) {
00502
return ErrorButGoOn;
00503 }
00504
00505
if ( withOutput ) {
00506
00507
QByteArray msgText = shProc.collectedStdout();
00508
00509
if ( !msgText.isEmpty() ) {
00510
00511
00512
00513
00514
00515
QString uid = aMsg->headerField(
"X-UID");
00516 aMsg->fromByteArray( msgText );
00517 aMsg->setHeaderField(
"X-UID",uid);
00518 }
00519
else
00520
return ErrorButGoOn;
00521 }
00522
return GoOn;
00523 }
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
class KMFilterActionBounce :
public KMFilterActionWithNone
00537 {
00538
public:
00539 KMFilterActionBounce();
00540
virtual ReturnCode process(KMMessage* msg)
const;
00541
static KMFilterAction*
newAction(
void);
00542 };
00543
00544
KMFilterAction*
KMFilterActionBounce::newAction(
void)
00545 {
00546
return (
new KMFilterActionBounce);
00547 }
00548
00549 KMFilterActionBounce::KMFilterActionBounce()
00550 :
KMFilterActionWithNone( "bounce", i18n("Bounce") )
00551 {
00552 }
00553
00554
KMFilterAction::ReturnCode KMFilterActionBounce::process(KMMessage* msg)
const
00555
{
00556 KMMessage *bounceMsg = msg->createBounce( FALSE );
00557
if ( !bounceMsg )
return ErrorButGoOn;
00558
00559
00560
00561 kmkernel->msgSender()->send( bounceMsg, FALSE );
00562
00563
return GoOn;
00564 }
00565
00566
00567
00568
00569
00570
00571
class KMFilterActionSendReceipt :
public KMFilterActionWithNone
00572 {
00573
public:
00574 KMFilterActionSendReceipt();
00575
virtual ReturnCode process(KMMessage* msg)
const;
00576
static KMFilterAction*
newAction(
void);
00577 };
00578
00579
KMFilterAction*
KMFilterActionSendReceipt::newAction(
void)
00580 {
00581
return (
new KMFilterActionSendReceipt);
00582 }
00583
00584 KMFilterActionSendReceipt::KMFilterActionSendReceipt()
00585 :
KMFilterActionWithNone( "confirm delivery", i18n("Confirm Delivery") )
00586 {
00587 }
00588
00589
KMFilterAction::ReturnCode KMFilterActionSendReceipt::process(KMMessage* msg)
const
00590
{
00591 KMMessage *receipt = msg->createDeliveryReceipt();
00592
if ( !receipt )
return ErrorButGoOn;
00593
00594
00595
00596 kmkernel->msgSender()->send( receipt, FALSE );
00597
00598
return GoOn;
00599 }
00600
00601
00602
00603
00604
00605
00606
00607
class KMFilterActionTransport:
public KMFilterActionWithString
00608 {
00609
public:
00610 KMFilterActionTransport();
00611
virtual ReturnCode process(KMMessage* msg)
const;
00612
static KMFilterAction*
newAction(
void);
00613 };
00614
00615
KMFilterAction*
KMFilterActionTransport::newAction(
void)
00616 {
00617
return (
new KMFilterActionTransport);
00618 }
00619
00620 KMFilterActionTransport::KMFilterActionTransport()
00621 :
KMFilterActionWithString( "set transport", i18n("Set Transport To") )
00622 {
00623 }
00624
00625
KMFilterAction::ReturnCode KMFilterActionTransport::process(KMMessage* msg)
const
00626
{
00627
if ( mParameter.isEmpty() )
00628
return ErrorButGoOn;
00629 msg->setHeaderField(
"X-KMail-Transport", mParameter );
00630
return GoOn;
00631 }
00632
00633
00634
00635
00636
00637
00638
class KMFilterActionReplyTo:
public KMFilterActionWithString
00639 {
00640
public:
00641 KMFilterActionReplyTo();
00642
virtual ReturnCode process(KMMessage* msg)
const;
00643
static KMFilterAction*
newAction(
void);
00644 };
00645
00646
KMFilterAction*
KMFilterActionReplyTo::newAction(
void)
00647 {
00648
return (
new KMFilterActionReplyTo);
00649 }
00650
00651 KMFilterActionReplyTo::KMFilterActionReplyTo()
00652 :
KMFilterActionWithString( "set Reply-To", i18n("Set Reply-To To") )
00653 {
00654 mParameter =
"";
00655 }
00656
00657
KMFilterAction::ReturnCode KMFilterActionReplyTo::process(KMMessage* msg)
const
00658
{
00659 msg->setHeaderField(
"Reply-To", mParameter );
00660
return GoOn;
00661 }
00662
00663
00664
00665
00666
00667
00668
00669
class KMFilterActionIdentity:
public KMFilterActionWithUOID
00670 {
00671
public:
00672 KMFilterActionIdentity();
00673
virtual ReturnCode process(KMMessage* msg)
const;
00674
static KMFilterAction*
newAction();
00675
00676
QWidget * createParamWidget(
QWidget * parent )
const;
00677
void applyParamWidgetValue(
QWidget * parent );
00678
void setParamWidgetValue(
QWidget * parent )
const;
00679
void clearParamWidget(
QWidget * param )
const;
00680 };
00681
00682
KMFilterAction*
KMFilterActionIdentity::newAction()
00683 {
00684
return (
new KMFilterActionIdentity);
00685 }
00686
00687 KMFilterActionIdentity::KMFilterActionIdentity()
00688 :
KMFilterActionWithUOID( "set identity", i18n("Set Identity To") )
00689 {
00690 mParameter = kmkernel->identityManager()->defaultIdentity().uoid();
00691 }
00692
00693
KMFilterAction::ReturnCode KMFilterActionIdentity::process(KMMessage* msg)
const
00694
{
00695 msg->setHeaderField(
"X-KMail-Identity", QString::number( mParameter ) );
00696
return GoOn;
00697 }
00698
00699
QWidget * KMFilterActionIdentity::createParamWidget(
QWidget * parent )
const
00700
{
00701 KPIM::IdentityCombo * ic =
new KPIM::IdentityCombo( kmkernel->identityManager(), parent );
00702 ic->setCurrentIdentity( mParameter );
00703
return ic;
00704 }
00705
00706
void KMFilterActionIdentity::applyParamWidgetValue(
QWidget * paramWidget )
00707 {
00708 KPIM::IdentityCombo * ic = dynamic_cast<KPIM::IdentityCombo*>( paramWidget );
00709 assert( ic );
00710 mParameter = ic->currentIdentity();
00711 }
00712
00713
void KMFilterActionIdentity::clearParamWidget(
QWidget * paramWidget )
const
00714
{
00715 KPIM::IdentityCombo * ic = dynamic_cast<KPIM::IdentityCombo*>( paramWidget );
00716 assert( ic );
00717 ic->setCurrentItem( 0 );
00718
00719 }
00720
00721
void KMFilterActionIdentity::setParamWidgetValue(
QWidget * paramWidget )
const
00722
{
00723 KPIM::IdentityCombo * ic = dynamic_cast<KPIM::IdentityCombo*>( paramWidget );
00724 assert( ic );
00725 ic->setCurrentIdentity( mParameter );
00726 }
00727
00728
00729
00730
00731
00732
class KMFilterActionSetStatus:
public KMFilterActionWithStringList
00733 {
00734
public:
00735 KMFilterActionSetStatus();
00736
virtual ReturnCode process(KMMessage* msg)
const;
00737
virtual bool requiresBody(KMMsgBase*) const;
00738
00739 static
KMFilterAction* newAction();
00740
00741 virtual
bool isEmpty()
const {
return false; }
00742
00743
virtual void argsFromString(
const QString argsStr );
00744
virtual const QString argsAsString() const;
00745 };
00746
00747
00748 static const KMMsgStatus stati[] =
00749 {
00750 KMMsgStatusFlag,
00751 KMMsgStatusRead,
00752 KMMsgStatusUnread,
00753 KMMsgStatusReplied,
00754 KMMsgStatusForwarded,
00755 KMMsgStatusOld,
00756 KMMsgStatusNew,
00757 KMMsgStatusWatched,
00758 KMMsgStatusIgnored,
00759 KMMsgStatusSpam,
00760 KMMsgStatusHam
00761 };
00762
static const int StatiCount =
sizeof( stati ) /
sizeof( KMMsgStatus );
00763
00764
KMFilterAction*
KMFilterActionSetStatus::newAction()
00765 {
00766
return (
new KMFilterActionSetStatus);
00767 }
00768
00769 KMFilterActionSetStatus::KMFilterActionSetStatus()
00770 :
KMFilterActionWithStringList( "set status", i18n("Mark As") )
00771 {
00772
00773
00774 mParameterList.append(
"" );
00775 mParameterList.append( i18n(
"msg status",
"Important") );
00776 mParameterList.append( i18n(
"msg status",
"Read") );
00777 mParameterList.append( i18n(
"msg status",
"Unread") );
00778 mParameterList.append( i18n(
"msg status",
"Replied") );
00779 mParameterList.append( i18n(
"msg status",
"Forwarded") );
00780 mParameterList.append( i18n(
"msg status",
"Old") );
00781 mParameterList.append( i18n(
"msg status",
"New") );
00782 mParameterList.append( i18n(
"msg status",
"Watched") );
00783 mParameterList.append( i18n(
"msg status",
"Ignored") );
00784 mParameterList.append( i18n(
"msg status",
"Spam") );
00785 mParameterList.append( i18n(
"msg status",
"Ham") );
00786
00787 mParameter = *mParameterList.at(0);
00788 }
00789
00790
KMFilterAction::ReturnCode KMFilterActionSetStatus::process(KMMessage* msg)
const
00791
{
00792
int idx = mParameterList.findIndex( mParameter );
00793
if ( idx < 1 )
return ErrorButGoOn;
00794
00795 KMMsgStatus status = stati[idx-1] ;
00796 msg->setStatus( status );
00797
return GoOn;
00798 }
00799
00800
bool KMFilterActionSetStatus::requiresBody(KMMsgBase*)
const
00801
{
00802
return false;
00803 }
00804
00805
void KMFilterActionSetStatus::argsFromString(
const QString argsStr )
00806 {
00807
if ( argsStr.length() == 1 ) {
00808
for (
int i = 0 ; i < StatiCount ; i++ )
00809
if ( KMMsgBase::statusToStr(stati[i])[0] == argsStr[0] ) {
00810 mParameter = *mParameterList.at(i+1);
00811
return;
00812 }
00813 }
00814 mParameter = *mParameterList.at(0);
00815 }
00816
00817
const QString KMFilterActionSetStatus::argsAsString()
const
00818
{
00819
int idx = mParameterList.findIndex( mParameter );
00820
if ( idx < 1 )
return QString::null;
00821
00822 KMMsgStatus status = stati[idx-1];
00823
return KMMsgBase::statusToStr(status);
00824 }
00825
00826
00827
00828
00829
00830
00831
class KMFilterActionFakeDisposition:
public KMFilterActionWithStringList
00832 {
00833
public:
00834 KMFilterActionFakeDisposition();
00835
virtual ReturnCode process(KMMessage* msg)
const;
00836
static KMFilterAction*
newAction() {
00837
return (
new KMFilterActionFakeDisposition);
00838 }
00839
00840
virtual bool isEmpty()
const {
return false; }
00841
00842
virtual void argsFromString(
const QString argsStr );
00843
virtual const QString argsAsString() const;
00844 };
00845
00846
00847
00848
00849 static const KMime::MDN::DispositionType mdns[] =
00850 {
00851 KMime::MDN::Displayed,
00852 KMime::MDN::Deleted,
00853 KMime::MDN::Dispatched,
00854 KMime::MDN::Processed,
00855 KMime::MDN::Denied,
00856 KMime::MDN::Failed,
00857 };
00858
static const int numMDNs =
sizeof mdns /
sizeof *mdns;
00859
00860
00861 KMFilterActionFakeDisposition::KMFilterActionFakeDisposition()
00862 :
KMFilterActionWithStringList( "fake mdn", i18n("Send Fake MDN") )
00863 {
00864
00865
00866 mParameterList.append(
"" );
00867 mParameterList.append( i18n(
"MDN type",
"Ignore") );
00868 mParameterList.append( i18n(
"MDN type",
"Displayed") );
00869 mParameterList.append( i18n(
"MDN type",
"Deleted") );
00870 mParameterList.append( i18n(
"MDN type",
"Dispatched") );
00871 mParameterList.append( i18n(
"MDN type",
"Processed") );
00872 mParameterList.append( i18n(
"MDN type",
"Denied") );
00873 mParameterList.append( i18n(
"MDN type",
"Failed") );
00874
00875 mParameter = *mParameterList.at(0);
00876 }
00877
00878
KMFilterAction::ReturnCode KMFilterActionFakeDisposition::process(KMMessage* msg)
const
00879
{
00880
int idx = mParameterList.findIndex( mParameter );
00881
if ( idx < 1 )
return ErrorButGoOn;
00882
00883
if ( idx == 1 )
00884 msg->setMDNSentState( KMMsgMDNIgnore );
00885
else
00886
sendMDN( msg, mdns[idx-2] );
00887
return GoOn;
00888 }
00889
00890
void KMFilterActionFakeDisposition::argsFromString(
const QString argsStr )
00891 {
00892
if ( argsStr.length() == 1 ) {
00893
if ( argsStr[0] ==
'I' ) {
00894 mParameter = *mParameterList.at(1);
00895
return;
00896 }
00897
for (
int i = 0 ; i < numMDNs ; i++ )
00898
if ( char(mdns[i]) == argsStr[0] ) {
00899 mParameter = *mParameterList.at(i+2);
00900
return;
00901 }
00902 }
00903 mParameter = *mParameterList.at(0);
00904 }
00905
00906
const QString KMFilterActionFakeDisposition::argsAsString()
const
00907
{
00908
int idx = mParameterList.findIndex( mParameter );
00909
if ( idx < 1 )
return QString::null;
00910
00911
return QString(
QChar( idx < 2 ?
'I' :
char(mdns[idx-2]) ) );
00912 }
00913
00914
00915
00916
00917
00918
00919
class KMFilterActionRemoveHeader:
public KMFilterActionWithStringList
00920 {
00921
public:
00922 KMFilterActionRemoveHeader();
00923
virtual ReturnCode process(KMMessage* msg)
const;
00924
virtual QWidget* createParamWidget(
QWidget* parent )
const;
00925
virtual void setParamWidgetValue(
QWidget* paramWidget )
const;
00926
00927
static KMFilterAction*
newAction();
00928 };
00929
00930
KMFilterAction*
KMFilterActionRemoveHeader::newAction()
00931 {
00932
return (
new KMFilterActionRemoveHeader);
00933 }
00934
00935 KMFilterActionRemoveHeader::KMFilterActionRemoveHeader()
00936 :
KMFilterActionWithStringList( "remove header", i18n("Remove Header") )
00937 {
00938 mParameterList <<
""
00939 <<
"Reply-To"
00940 <<
"Delivered-To"
00941 <<
"X-KDE-PR-Message"
00942 <<
"X-KDE-PR-Package"
00943 <<
"X-KDE-PR-Keywords";
00944 mParameter = *mParameterList.at(0);
00945 }
00946
00947
QWidget* KMFilterActionRemoveHeader::createParamWidget(
QWidget* parent )
const
00948
{
00949
QComboBox *cb =
new QComboBox( TRUE, parent );
00950 cb->setInsertionPolicy( QComboBox::AtBottom );
00951
setParamWidgetValue( cb );
00952
return cb;
00953 }
00954
00955
KMFilterAction::ReturnCode KMFilterActionRemoveHeader::process(KMMessage* msg)
const
00956
{
00957
if ( mParameter.isEmpty() )
return ErrorButGoOn;
00958
00959
while ( !msg->headerField( mParameter.latin1() ).isEmpty() )
00960 msg->removeHeaderField( mParameter.latin1() );
00961
return GoOn;
00962 }
00963
00964
void KMFilterActionRemoveHeader::setParamWidgetValue(
QWidget* paramWidget )
const
00965
{
00966
QComboBox * cb = dynamic_cast<QComboBox*>(paramWidget);
00967 Q_ASSERT( cb );
00968
00969
int idx = mParameterList.findIndex( mParameter );
00970 cb->clear();
00971 cb->insertStringList( mParameterList );
00972
if ( idx < 0 ) {
00973 cb->insertItem( mParameter );
00974 cb->setCurrentItem( cb->count() - 1 );
00975 }
else {
00976 cb->setCurrentItem( idx );
00977 }
00978 }
00979
00980
00981
00982
00983
00984
00985
class KMFilterActionAddHeader:
public KMFilterActionWithStringList
00986 {
00987
public:
00988 KMFilterActionAddHeader();
00989
virtual ReturnCode process(KMMessage* msg)
const;
00990
virtual QWidget* createParamWidget(
QWidget* parent )
const;
00991
virtual void setParamWidgetValue(
QWidget* paramWidget )
const;
00992
virtual void applyParamWidgetValue(
QWidget* paramWidget );
00993
virtual void clearParamWidget(
QWidget* paramWidget )
const;
00994
00995
virtual const QString argsAsString() const;
00996 virtual
void argsFromString( const
QString argsStr );
00997
00998 static
KMFilterAction* newAction()
00999 {
01000
return (
new KMFilterActionAddHeader);
01001 }
01002
private:
01003
QString mValue;
01004 };
01005
01006 KMFilterActionAddHeader::KMFilterActionAddHeader()
01007 :
KMFilterActionWithStringList( "add header", i18n("Add Header") )
01008 {
01009 mParameterList <<
""
01010 <<
"Reply-To"
01011 <<
"Delivered-To"
01012 <<
"X-KDE-PR-Message"
01013 <<
"X-KDE-PR-Package"
01014 <<
"X-KDE-PR-Keywords";
01015 mParameter = *mParameterList.at(0);
01016 }
01017
01018
KMFilterAction::ReturnCode KMFilterActionAddHeader::process(KMMessage* msg)
const
01019
{
01020
if ( mParameter.isEmpty() )
return ErrorButGoOn;
01021
01022 msg->setHeaderField( mParameter.latin1(), mValue );
01023
return GoOn;
01024 }
01025
01026
QWidget* KMFilterActionAddHeader::createParamWidget(
QWidget* parent )
const
01027
{
01028
QWidget *w =
new QWidget( parent );
01029
QHBoxLayout *hbl =
new QHBoxLayout( w );
01030 hbl->setSpacing( 4 );
01031
QComboBox *cb =
new QComboBox( TRUE, w,
"combo" );
01032 cb->setInsertionPolicy( QComboBox::AtBottom );
01033 hbl->addWidget( cb, 0 );
01034
QLabel *l =
new QLabel( i18n(
"With value:"), w );
01035 l->setFixedWidth( l->sizeHint().width() );
01036 hbl->addWidget( l, 0 );
01037
QLineEdit *le =
new KLineEdit( w,
"ledit" );
01038 hbl->addWidget( le, 1 );
01039
setParamWidgetValue( w );
01040
return w;
01041 }
01042
01043
void KMFilterActionAddHeader::setParamWidgetValue( QWidget* paramWidget )
const
01044
{
01045
int idx = mParameterList.findIndex( mParameter );
01046 QComboBox *cb = (QComboBox*)paramWidget->child(
"combo");
01047 Q_ASSERT( cb );
01048 cb->clear();
01049 cb->insertStringList( mParameterList );
01050
if ( idx < 0 ) {
01051 cb->insertItem( mParameter );
01052 cb->setCurrentItem( cb->count() - 1 );
01053 }
else {
01054 cb->setCurrentItem( idx );
01055 }
01056
QLineEdit *le = (
QLineEdit*)paramWidget->child(
"ledit");
01057 Q_ASSERT( le );
01058 le->setText( mValue );
01059 }
01060
01061
void KMFilterActionAddHeader::applyParamWidgetValue( QWidget* paramWidget )
01062 {
01063 QComboBox *cb = (QComboBox*)paramWidget->child(
"combo");
01064 Q_ASSERT( cb );
01065 mParameter = cb->currentText();
01066
01067
QLineEdit *le = (
QLineEdit*)paramWidget->child(
"ledit");
01068 Q_ASSERT( le );
01069 mValue = le->text();
01070 }
01071
01072
void KMFilterActionAddHeader::clearParamWidget( QWidget* paramWidget )
const
01073
{
01074 QComboBox *cb = (QComboBox*)paramWidget->child(
"combo");
01075 Q_ASSERT( cb );
01076 cb->setCurrentItem(0);
01077
QLineEdit *le = (
QLineEdit*)paramWidget->child(
"ledit");
01078 Q_ASSERT( le );
01079 le->clear();
01080 }
01081
01082
const QString KMFilterActionAddHeader::argsAsString()
const
01083
{
01084
QString result = mParameter;
01085 result +=
'\t';
01086 result += mValue;
01087
01088
return result;
01089 }
01090
01091
void KMFilterActionAddHeader::argsFromString(
const QString argsStr )
01092 {
01093
QStringList l = QStringList::split(
'\t', argsStr, TRUE );
01094
QString s;
01095
if ( l.count() < 2 ) {
01096 s = l[0];
01097 mValue =
"";
01098 }
else {
01099 s = l[0];
01100 mValue = l[1];
01101 }
01102
01103
int idx = mParameterList.findIndex( s );
01104
if ( idx < 0 ) {
01105 mParameterList.append( s );
01106 idx = mParameterList.count() - 1;
01107 }
01108 mParameter = *mParameterList.at( idx );
01109 }
01110
01111
01112
01113
01114
01115
01116
class KMFilterActionRewriteHeader:
public KMFilterActionWithStringList
01117 {
01118
public:
01119 KMFilterActionRewriteHeader();
01120
virtual ReturnCode process(KMMessage* msg)
const;
01121
virtual QWidget* createParamWidget( QWidget* parent )
const;
01122
virtual void setParamWidgetValue( QWidget* paramWidget )
const;
01123
virtual void applyParamWidgetValue( QWidget* paramWidget );
01124
virtual void clearParamWidget( QWidget* paramWidget )
const;
01125
01126
virtual const QString argsAsString() const;
01127 virtual
void argsFromString( const
QString argsStr );
01128
01129 static
KMFilterAction* newAction()
01130 {
01131
return (
new KMFilterActionRewriteHeader);
01132 }
01133
private:
01134 KRegExp3 mRegExp;
01135
QString mReplacementString;
01136 };
01137
01138 KMFilterActionRewriteHeader::KMFilterActionRewriteHeader()
01139 :
KMFilterActionWithStringList( "rewrite header", i18n("Rewrite Header") )
01140 {
01141 mParameterList <<
""
01142 <<
"Subject"
01143 <<
"Reply-To"
01144 <<
"Delivered-To"
01145 <<
"X-KDE-PR-Message"
01146 <<
"X-KDE-PR-Package"
01147 <<
"X-KDE-PR-Keywords";
01148 mParameter = *mParameterList.at(0);
01149 }
01150
01151
KMFilterAction::ReturnCode KMFilterActionRewriteHeader::process(KMMessage* msg)
const
01152
{
01153
if ( mParameter.isEmpty() || !mRegExp.isValid() )
01154
return ErrorButGoOn;
01155
01156 KRegExp3 rx = mRegExp;
01157
01158
QString newValue = rx.replace( msg->headerField( mParameter.latin1() ),
01159 mReplacementString );
01160
01161 msg->setHeaderField( mParameter.latin1(), newValue );
01162
return GoOn;
01163 }
01164
01165 QWidget* KMFilterActionRewriteHeader::createParamWidget( QWidget* parent )
const
01166
{
01167 QWidget *w =
new QWidget( parent );
01168 QHBoxLayout *hbl =
new QHBoxLayout( w );
01169 hbl->setSpacing( 4 );
01170
01171 QComboBox *cb =
new QComboBox( TRUE, w,
"combo" );
01172 cb->setInsertionPolicy( QComboBox::AtBottom );
01173 hbl->addWidget( cb, 0 );
01174
01175 QLabel *l =
new QLabel( i18n(
"Replace:"), w );
01176 l->setFixedWidth( l->sizeHint().width() );
01177 hbl->addWidget( l, 0 );
01178
01179
QLineEdit *le =
new KLineEdit( w,
"search" );
01180 hbl->addWidget( le, 1 );
01181
01182 l =
new QLabel( i18n(
"With:"), w );
01183 l->setFixedWidth( l->sizeHint().width() );
01184 hbl->addWidget( l, 0 );
01185
01186 le =
new KLineEdit( w,
"replace" );
01187 hbl->addWidget( le, 1 );
01188
01189
setParamWidgetValue( w );
01190
return w;
01191 }
01192
01193
void KMFilterActionRewriteHeader::setParamWidgetValue( QWidget* paramWidget )
const
01194
{
01195
int idx = mParameterList.findIndex( mParameter );
01196 QComboBox *cb = (QComboBox*)paramWidget->child(
"combo");
01197 Q_ASSERT( cb );
01198
01199 cb->clear();
01200 cb->insertStringList( mParameterList );
01201
if ( idx < 0 ) {
01202 cb->insertItem( mParameter );
01203 cb->setCurrentItem( cb->count() - 1 );
01204 }
else {
01205 cb->setCurrentItem( idx );
01206 }
01207
01208
QLineEdit *le = (
QLineEdit*)paramWidget->child(
"search");
01209 Q_ASSERT( le );
01210 le->setText( mRegExp.pattern() );
01211
01212 le = (
QLineEdit*)paramWidget->child(
"replace");
01213 Q_ASSERT( le );
01214 le->setText( mReplacementString );
01215 }
01216
01217
void KMFilterActionRewriteHeader::applyParamWidgetValue( QWidget* paramWidget )
01218 {
01219 QComboBox *cb = (QComboBox*)paramWidget->child(
"combo");
01220 Q_ASSERT( cb );
01221 mParameter = cb->currentText();
01222
01223
QLineEdit *le = (
QLineEdit*)paramWidget->child(
"search");
01224 Q_ASSERT( le );
01225 mRegExp.setPattern( le->text() );
01226
01227 le = (
QLineEdit*)paramWidget->child(
"replace");
01228 Q_ASSERT( le );
01229 mReplacementString = le->text();
01230 }
01231
01232
void KMFilterActionRewriteHeader::clearParamWidget( QWidget* paramWidget )
const
01233
{
01234 QComboBox *cb = (QComboBox*)paramWidget->child(
"combo");
01235 Q_ASSERT( cb );
01236 cb->setCurrentItem(0);
01237
01238
QLineEdit *le = (
QLineEdit*)paramWidget->child(
"search");
01239 Q_ASSERT( le );
01240 le->clear();
01241
01242 le = (
QLineEdit*)paramWidget->child(
"replace");
01243 Q_ASSERT( le );
01244 le->clear();
01245 }
01246
01247
const QString KMFilterActionRewriteHeader::argsAsString()
const
01248
{
01249
QString result = mParameter;
01250 result +=
'\t';
01251 result += mRegExp.pattern();
01252 result +=
'\t';
01253 result += mReplacementString;
01254
01255
return result;
01256 }
01257
01258
void KMFilterActionRewriteHeader::argsFromString(
const QString argsStr )
01259 {
01260
QStringList l = QStringList::split(
'\t', argsStr, TRUE );
01261
QString s;
01262
01263 s = l[0];
01264 mRegExp.setPattern( l[1] );
01265 mReplacementString = l[2];
01266
01267
int idx = mParameterList.findIndex( s );
01268
if ( idx < 0 ) {
01269 mParameterList.append( s );
01270 idx = mParameterList.count() - 1;
01271 }
01272 mParameter = *mParameterList.at( idx );
01273 }
01274
01275
01276
01277
01278
01279
01280
class KMFilterActionMove:
public KMFilterActionWithFolder
01281 {
01282
public:
01283 KMFilterActionMove();
01284
virtual ReturnCode process(KMMessage* msg)
const;
01285
virtual bool requiresBody(KMMsgBase*) const;
01286 static
KMFilterAction* newAction(
void);
01287 };
01288
01289
KMFilterAction* KMFilterActionMove::newAction(
void)
01290 {
01291
return (
new KMFilterActionMove);
01292 }
01293
01294 KMFilterActionMove::KMFilterActionMove()
01295 :
KMFilterActionWithFolder( "transfer", i18n("File into Folder") )
01296 {
01297 }
01298
01299
KMFilterAction::ReturnCode KMFilterActionMove::process(KMMessage* msg)
const
01300
{
01301
if ( !mFolder )
01302
return ErrorButGoOn;
01303
01304 MessageProperty::setFilterFolder( msg, mFolder );
01305
return GoOn;
01306 }
01307
01308
bool KMFilterActionMove::requiresBody(KMMsgBase*)
const
01309
{
01310
return false;
01311 }
01312
01313
01314
01315
01316
01317
class KMFilterActionForward:
public KMFilterActionWithAddress
01318 {
01319
public:
01320 KMFilterActionForward();
01321
virtual ReturnCode process(KMMessage* msg)
const;
01322
static KMFilterAction*
newAction(
void);
01323 };
01324
01325
KMFilterAction*
KMFilterActionForward::newAction(
void)
01326 {
01327
return (
new KMFilterActionForward);
01328 }
01329
01330 KMFilterActionForward::KMFilterActionForward()
01331 :
KMFilterActionWithAddress( "forward", i18n("Forward To") )
01332 {
01333 }
01334
01335
KMFilterAction::ReturnCode KMFilterActionForward::process(KMMessage* aMsg)
const
01336
{
01337
if ( mParameter.isEmpty() )
01338
return ErrorButGoOn;
01339
01340
01341
01342
if ( KMMessage::addressIsInAddressList( mParameter, aMsg->to() ) )
01343
return ErrorButGoOn;
01344
01345
01346
01347
01348
01349
01350
01351 KMMessage* msg =
new KMMessage;
01352
01353 msg->initFromMessage( aMsg );
01354
01355
QString st = QString::fromUtf8( aMsg->createForwardBody() );
01356
QCString
01357 encoding = KMMsgBase::autoDetectCharset( aMsg->charset(),
01358 KMMessage::preferredCharsets(),
01359 st );
01360
if( encoding.isEmpty() )
01361 encoding =
"utf-8";
01362
QCString str = KMMsgBase::codecForName( encoding )->fromUnicode( st );
01363
01364 msg->setCharset( encoding );
01365 msg->setTo( mParameter );
01366 msg->setSubject(
"Fwd: " + aMsg->subject() );
01367
01368
bool isQP = kmkernel->msgSender()->sendQuotedPrintable();
01369
01370
if( aMsg->numBodyParts() == 0 )
01371 {
01372 msg->setAutomaticFields(
true );
01373 msg->setHeaderField(
"Content-Type",
"text/plain" );
01374
01375
QValueList<int> dummy;
01376 msg->setBodyAndGuessCte(str, dummy, !isQP);
01377 msg->setCharset( encoding );
01378
if( isQP )
01379 msg->setBodyEncoded( str );
01380
else
01381 msg->setBody( str );
01382 }
01383
else
01384 {
01385 KMMessagePart bodyPart, msgPart;
01386
01387 msg->removeHeaderField(
"Content-Type" );
01388 msg->removeHeaderField(
"Content-Transfer-Encoding" );
01389 msg->setAutomaticFields(
true );
01390 msg->setBody(
"This message is in MIME format.\n\n" );
01391
01392 bodyPart.setTypeStr(
"text" );
01393 bodyPart.setSubtypeStr(
"plain" );
01394
01395
QValueList<int> dummy;
01396 bodyPart.setBodyAndGuessCte(str, dummy, !isQP);
01397 bodyPart.setCharset( encoding );
01398 bodyPart.setBodyEncoded( str );
01399 msg->addBodyPart( &bodyPart );
01400
01401
for(
int i = 0; i < aMsg->numBodyParts(); i++ )
01402 {
01403 aMsg->bodyPart( i, &msgPart );
01404
if( i > 0 || qstricmp( msgPart.typeStr(),
"text" ) != 0 )
01405 msg->addBodyPart( &msgPart );
01406 }
01407 }
01408 msg->cleanupHeader();
01409 msg->link( aMsg, KMMsgStatusForwarded );
01410
01411
sendMDN( aMsg, KMime::MDN::Dispatched );
01412
01413
if ( !kmkernel->msgSender()->send( msg, FALSE ) ) {
01414 kdDebug(5006) <<
"KMFilterAction: could not forward message (sending failed)" << endl;
01415
return ErrorButGoOn;
01416 }
01417
return GoOn;
01418 }
01419
01420
01421
01422
01423
01424
01425
class KMFilterActionRedirect:
public KMFilterActionWithAddress
01426 {
01427
public:
01428 KMFilterActionRedirect();
01429
virtual ReturnCode process(KMMessage* msg)
const;
01430
static KMFilterAction*
newAction(
void);
01431 };
01432
01433
KMFilterAction*
KMFilterActionRedirect::newAction(
void)
01434 {
01435
return (
new KMFilterActionRedirect);
01436 }
01437
01438 KMFilterActionRedirect::KMFilterActionRedirect()
01439 :
KMFilterActionWithAddress( "redirect", i18n("Redirect To") )
01440 {
01441 }
01442
01443
KMFilterAction::ReturnCode KMFilterActionRedirect::process(KMMessage* aMsg)
const
01444
{
01445 KMMessage* msg;
01446
if ( mParameter.isEmpty() )
01447
return ErrorButGoOn;
01448
01449 msg = aMsg->createRedirect2( mParameter );
01450
01451
sendMDN( aMsg, KMime::MDN::Dispatched );
01452
01453
if ( !kmkernel->msgSender()->send( msg, FALSE ) ) {
01454 kdDebug(5006) <<
"KMFilterAction: could not redirect message (sending failed)" << endl;
01455
return ErrorButGoOn;
01456 }
01457
return GoOn;
01458 }
01459
01460
01461
01462
01463
01464
01465
class KMFilterActionExec :
public KMFilterActionWithCommand
01466 {
01467
public:
01468 KMFilterActionExec();
01469
virtual ReturnCode process(KMMessage* msg)
const;
01470
static KMFilterAction* newAction(
void);
01471 };
01472
01473
KMFilterAction* KMFilterActionExec::newAction(
void)
01474 {
01475
return (
new KMFilterActionExec());
01476 }
01477
01478 KMFilterActionExec::KMFilterActionExec()
01479 : KMFilterActionWithCommand( "execute", i18n("Execute Command") )
01480 {
01481 }
01482
01483
KMFilterAction::ReturnCode KMFilterActionExec::process(KMMessage *aMsg)
const
01484
{
01485
return KMFilterActionWithCommand::genericProcess( aMsg,
false );
01486 }
01487
01488
01489
01490
01491
01492
01493
01494
#include <weaver.h>
01495
class PipeJob :
public KPIM::ThreadWeaver::Job
01496 {
01497
public:
01498 PipeJob(
QObject* parent = 0 ,
const char* name = 0, KMMessage* aMsg = 0,
QString cmd = 0,
QString tempFileName = 0 )
01499 : Job (parent, name),
01500 mTempFileName(tempFileName),
01501 mCmd(cmd),
01502 mMsg( aMsg )
01503 {
01504 }
01505
01506 ~PipeJob() {}
01507
virtual void processEvent( KPIM::ThreadWeaver::Event *ev )
01508 {
01509 KPIM::ThreadWeaver::Job::processEvent( ev );
01510
if ( ev->action() == KPIM::ThreadWeaver::Event::JobFinished )
01511 deleteLater( );
01512 }
01513
protected:
01514
void run()
01515 {
01516 KPIM::ThreadWeaver::debug (1,
"PipeJob::run: doing it .\n");
01517 FILE *p;
01518
QByteArray ba;
01519
01520 p = popen(QFile::encodeName(mCmd),
"r");
01521
int len =100;
01522
char buffer[100];
01523
01524
while (
true) {
01525
if (! fgets( buffer, len, p ) )
break;
01526
int oldsize = ba.size();
01527 ba.resize( oldsize + strlen(buffer) );
01528 qmemmove( ba.begin() + oldsize, buffer, strlen(buffer) );
01529 }
01530 pclose(p);
01531
if ( !ba.isEmpty() ) {
01532 KPIM::ThreadWeaver::debug (1,
"PipeJob::run: %s",
QString(ba).latin1() );
01533 mMsg->fromByteArray( ba );
01534 }
01535
01536 KPIM::ThreadWeaver::debug (1,
"PipeJob::run: done.\n" );
01537
01538 QFile::remove(mTempFileName);
01539 }
01540
QString mTempFileName;
01541
QString mCmd;
01542 KMMessage *mMsg;
01543 };
01544
01545
class KMFilterActionExtFilter:
public KMFilterActionWithCommand
01546 {
01547
public:
01548 KMFilterActionExtFilter();
01549
virtual ReturnCode process(KMMessage* msg)
const;
01550
virtual void processAsync(KMMessage* msg)
const;
01551
static KMFilterAction* newAction(
void);
01552 };
01553
01554
KMFilterAction* KMFilterActionExtFilter::newAction(
void)
01555 {
01556
return (
new KMFilterActionExtFilter);
01557 }
01558
01559 KMFilterActionExtFilter::KMFilterActionExtFilter()
01560 : KMFilterActionWithCommand( "filter app", i18n("Pipe Through") )
01561 {
01562 }
01563
KMFilterAction::ReturnCode KMFilterActionExtFilter::process(KMMessage* aMsg)
const
01564
{
01565
return KMFilterActionWithCommand::genericProcess( aMsg,
true );
01566 }
01567
01568
void KMFilterActionExtFilter::processAsync(KMMessage* aMsg)
const
01569
{
01570
01571 ActionScheduler *handler = MessageProperty::filterHandler( aMsg->getMsgSerNum() );
01572 KTempFile * inFile =
new KTempFile;
01573 inFile->setAutoDelete(FALSE);
01574
01575
QPtrList<KTempFile> atmList;
01576 atmList.setAutoDelete(TRUE);
01577 atmList.append( inFile );
01578
01579
QString commandLine = substituteCommandLineArgsFor( aMsg , atmList );
01580
if ( commandLine.isEmpty() )
01581 handler->actionMessage( ErrorButGoOn );
01582
01583
01584
01585
01586
01587
01588
01589
01590 commandLine =
"(" + commandLine +
") <" + inFile->name();
01591
01592
01593
QString tempFileName = inFile->name();
01594 KPIM::kCStringToFile( aMsg->asString(), tempFileName,
01595
false,
false,
false );
01596 inFile->close();
01597
01598 PipeJob *job =
new PipeJob(0, 0, aMsg, commandLine, tempFileName);
01599 QObject::connect ( job, SIGNAL( done() ), handler, SLOT( actionMessage() ) );
01600 kmkernel->weaver()->enqueue(job);
01601 }
01602
01603
01604
01605
01606
01607
class KMFilterActionExecSound :
public KMFilterActionWithTest
01608 {
01609
public:
01610 KMFilterActionExecSound();
01611
virtual ReturnCode process(KMMessage* msg)
const;
01612
virtual bool requiresBody(KMMsgBase*) const;
01613 static
KMFilterAction* newAction(
void);
01614 };
01615
01616 KMFilterActionWithTest::KMFilterActionWithTest( const
char* aName, const
QString aLabel )
01617 :
KMFilterAction( aName, aLabel )
01618 {
01619 }
01620
01621 KMFilterActionWithTest::~KMFilterActionWithTest()
01622 {
01623 }
01624
01625 QWidget*
KMFilterActionWithTest::createParamWidget( QWidget* parent )
const
01626
{
01627 KMSoundTestWidget *le =
new KMSoundTestWidget(parent);
01628 le->setUrl( mParameter );
01629
return le;
01630 }
01631
01632
01633
void KMFilterActionWithTest::applyParamWidgetValue( QWidget* paramWidget )
01634 {
01635 mParameter = ((KMSoundTestWidget*)paramWidget)->url();
01636 }
01637
01638
void KMFilterActionWithTest::setParamWidgetValue( QWidget* paramWidget )
const
01639
{
01640 ((KMSoundTestWidget*)paramWidget)->setUrl( mParameter );
01641 }
01642
01643
void KMFilterActionWithTest::clearParamWidget( QWidget* paramWidget )
const
01644
{
01645 ((KMSoundTestWidget*)paramWidget)->clear();
01646 }
01647
01648
void KMFilterActionWithTest::argsFromString(
const QString argsStr )
01649 {
01650 mParameter = argsStr;
01651 }
01652
01653
const QString KMFilterActionWithTest::argsAsString()
const
01654
{
01655
return mParameter;
01656 }
01657
01658
01659 KMFilterActionExecSound::KMFilterActionExecSound()
01660 : KMFilterActionWithTest( "play sound", i18n("Play Sound") )
01661 {
01662 }
01663
01664
KMFilterAction* KMFilterActionExecSound::newAction(
void)
01665 {
01666
return (
new KMFilterActionExecSound());
01667 }
01668
01669
KMFilterAction::ReturnCode KMFilterActionExecSound::process(KMMessage*)
const
01670
{
01671
if ( mParameter.isEmpty() )
01672
return ErrorButGoOn;
01673
QString play = mParameter;
01674
QString file = QString::fromLatin1(
"file:");
01675
if (mParameter.startsWith(file))
01676 play = mParameter.mid(file.length());
01677 KAudioPlayer::play(QFile::encodeName(play));
01678
return GoOn;
01679 }
01680
01681
bool KMFilterActionExecSound::requiresBody(KMMsgBase*)
const
01682
{
01683
return false;
01684 }
01685
01686 KMFilterActionWithUrl::KMFilterActionWithUrl(
const char* aName,
const QString aLabel )
01687 :
KMFilterAction( aName, aLabel )
01688 {
01689 }
01690
01691 KMFilterActionWithUrl::~KMFilterActionWithUrl()
01692 {
01693 }
01694
01695 QWidget*
KMFilterActionWithUrl::createParamWidget( QWidget* parent )
const
01696
{
01697 KURLRequester *le =
new KURLRequester(parent);
01698 le->setURL( mParameter );
01699
return le;
01700 }
01701
01702
01703 void KMFilterActionWithUrl::applyParamWidgetValue( QWidget* paramWidget )
01704 {
01705 mParameter = ((KURLRequester*)paramWidget)->url();
01706 }
01707
01708 void KMFilterActionWithUrl::setParamWidgetValue( QWidget* paramWidget )
const
01709
{
01710 ((KURLRequester*)paramWidget)->setURL( mParameter );
01711 }
01712
01713 void KMFilterActionWithUrl::clearParamWidget( QWidget* paramWidget )
const
01714
{
01715 ((KURLRequester*)paramWidget)->clear();
01716 }
01717
01718 void KMFilterActionWithUrl::argsFromString(
const QString argsStr )
01719 {
01720 mParameter = argsStr;
01721 }
01722
01723 const QString KMFilterActionWithUrl::argsAsString()
const
01724
{
01725
return mParameter;
01726 }
01727
01728
01729
01730
01731
01732
01733
01734 void KMFilterActionDict::init(
void)
01735 {
01736
insert( KMFilterActionMove::newAction );
01737
insert( KMFilterActionIdentity::newAction );
01738
insert( KMFilterActionSetStatus::newAction );
01739
insert( KMFilterActionFakeDisposition::newAction );
01740
insert( KMFilterActionTransport::newAction );
01741
insert( KMFilterActionReplyTo::newAction );
01742
insert( KMFilterActionForward::newAction );
01743
insert( KMFilterActionRedirect::newAction );
01744
insert( KMFilterActionBounce::newAction );
01745
insert( KMFilterActionSendReceipt::newAction );
01746
insert( KMFilterActionExec::newAction );
01747
insert( KMFilterActionExtFilter::newAction );
01748
insert( KMFilterActionRemoveHeader::newAction );
01749
insert( KMFilterActionAddHeader::newAction );
01750
insert( KMFilterActionRewriteHeader::newAction );
01751
insert( KMFilterActionExecSound::newAction );
01752
01753 }
01754
01755
01756 KMFilterActionDict::KMFilterActionDict()
01757 :
QDict<
KMFilterActionDesc>(23)
01758 {
01759 mList.setAutoDelete(TRUE);
01760
init();
01761 }
01762
01763 void KMFilterActionDict::insert( KMFilterActionNewFunc aNewFunc )
01764 {
01765
KMFilterAction *action = aNewFunc();
01766
KMFilterActionDesc* desc =
new KMFilterActionDesc;
01767 desc->
name = action->
name();
01768 desc->
label = action->
label();
01769 desc->
create = aNewFunc;
01770
QDict<KMFilterActionDesc>::insert( desc->
name, desc );
01771
QDict<KMFilterActionDesc>::insert( desc->
label, desc );
01772 mList.append( desc );
01773
delete action;
01774 }