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