From 460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 Mon Sep 17 00:00:00 2001
From: toma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>
Date: Wed, 25 Nov 2009 17:56:58 +0000
Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
 BUG:215923

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
---
 kmail/kmsearchpattern.cpp | 929 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 929 insertions(+)
 create mode 100644 kmail/kmsearchpattern.cpp

(limited to 'kmail/kmsearchpattern.cpp')

diff --git a/kmail/kmsearchpattern.cpp b/kmail/kmsearchpattern.cpp
new file mode 100644
index 000000000..1b9e36530
--- /dev/null
+++ b/kmail/kmsearchpattern.cpp
@@ -0,0 +1,929 @@
+// -*- mode: C++; c-file-style: "gnu" -*-
+// kmsearchpattern.cpp
+// Author: Marc Mutz <Marc@Mutz.com>
+// This code is under GPL!
+
+#include <config.h>
+
+#include "kmaddrbook.h"
+#include "kmsearchpattern.h"
+#include "kmmsgdict.h"
+#include "filterlog.h"
+#include "kmkernel.h"
+#include "kmmsgdict.h"
+#include "kmfolder.h"
+using KMail::FilterLog;
+
+#include <libemailfunctions/email.h>
+
+#include <kglobal.h>
+#include <klocale.h>
+#include <kdebug.h>
+#include <kconfig.h>
+
+#include <kabc/stdaddressbook.h>
+
+#include <qregexp.h>
+
+#include <mimelib/string.h>
+#include <mimelib/boyermor.h>
+
+#include <assert.h>
+
+static const char* funcConfigNames[] =
+  { "contains", "contains-not", "equals", "not-equal", "regexp",
+    "not-regexp", "greater", "less-or-equal", "less", "greater-or-equal",
+    "is-in-addressbook", "is-not-in-addressbook" , "is-in-category", "is-not-in-category",
+    "has-attachment", "has-no-attachment"};
+static const int numFuncConfigNames = sizeof funcConfigNames / sizeof *funcConfigNames;
+
+struct _statusNames {
+  const char* name;
+  KMMsgStatus status;
+};
+
+static struct _statusNames statusNames[] = {
+  { "Important", KMMsgStatusFlag },
+  { "New", KMMsgStatusNew },
+  { "Unread", KMMsgStatusUnread | KMMsgStatusNew },
+  { "Read", KMMsgStatusRead },
+  { "Old", KMMsgStatusOld },
+  { "Deleted", KMMsgStatusDeleted },
+  { "Replied", KMMsgStatusReplied },
+  { "Forwarded", KMMsgStatusForwarded },
+  { "Queued", KMMsgStatusQueued },
+  { "Sent", KMMsgStatusSent },
+  { "Watched", KMMsgStatusWatched },
+  { "Ignored", KMMsgStatusIgnored },
+  { "To Do", KMMsgStatusTodo },
+  { "Spam", KMMsgStatusSpam },
+  { "Ham", KMMsgStatusHam },
+  { "Has Attachment", KMMsgStatusHasAttach }
+};
+
+static const int numStatusNames = sizeof statusNames / sizeof ( struct _statusNames );
+
+
+//==================================================
+//
+// class KMSearchRule (was: KMFilterRule)
+//
+//==================================================
+
+KMSearchRule::KMSearchRule( const QCString & field, Function func, const QString & contents )
+  : mField( field ),
+    mFunction( func ),
+    mContents( contents )
+{
+}
+
+KMSearchRule::KMSearchRule( const KMSearchRule & other )
+  : mField( other.mField ),
+    mFunction( other.mFunction ),
+    mContents( other.mContents )
+{
+}
+
+const KMSearchRule & KMSearchRule::operator=( const KMSearchRule & other ) {
+  if ( this == &other )
+    return *this;
+
+  mField = other.mField;
+  mFunction = other.mFunction;
+  mContents = other.mContents;
+
+  return *this;
+}
+
+KMSearchRule * KMSearchRule::createInstance( const QCString & field,
+                                             Function func,
+                                             const QString & contents )
+{
+  KMSearchRule *ret = 0;
+  if (field == "<status>")
+    ret = new KMSearchRuleStatus( field, func, contents );
+  else if ( field == "<age in days>" || field == "<size>" )
+    ret = new KMSearchRuleNumerical( field, func, contents );
+  else
+    ret = new KMSearchRuleString( field, func, contents );
+
+  return ret;
+}
+
+KMSearchRule * KMSearchRule::createInstance( const QCString & field,
+                                     const char *func,
+                                     const QString & contents )
+{
+  return ( createInstance( field, configValueToFunc( func ), contents ) );
+}
+
+KMSearchRule * KMSearchRule::createInstance( const KMSearchRule & other )
+{
+  return ( createInstance( other.field(), other.function(), other.contents() ) );
+}
+
+KMSearchRule * KMSearchRule::createInstanceFromConfig( const KConfig * config, int aIdx )
+{
+  const char cIdx = char( int('A') + aIdx );
+
+  static const QString & field = KGlobal::staticQString( "field" );
+  static const QString & func = KGlobal::staticQString( "func" );
+  static const QString & contents = KGlobal::staticQString( "contents" );
+
+  const QCString &field2 = config->readEntry( field + cIdx ).latin1();
+  Function func2 = configValueToFunc( config->readEntry( func + cIdx ).latin1() );
+  const QString & contents2 = config->readEntry( contents + cIdx );
+
+  if ( field2 == "<To or Cc>" ) // backwards compat
+    return KMSearchRule::createInstance( "<recipients>", func2, contents2 );
+  else
+    return KMSearchRule::createInstance( field2, func2, contents2 );
+}
+
+KMSearchRule::Function KMSearchRule::configValueToFunc( const char * str ) {
+  if ( !str )
+    return FuncNone;
+
+  for ( int i = 0 ; i < numFuncConfigNames ; ++i )
+    if ( qstricmp( funcConfigNames[i], str ) == 0 ) return (Function)i;
+
+  return FuncNone;
+}
+
+QString KMSearchRule::functionToString( Function function )
+{
+  if ( function != FuncNone )
+    return funcConfigNames[int( function )];
+  else
+    return "invalid";
+}
+
+void KMSearchRule::writeConfig( KConfig * config, int aIdx ) const {
+  const char cIdx = char('A' + aIdx);
+  static const QString & field = KGlobal::staticQString( "field" );
+  static const QString & func = KGlobal::staticQString( "func" );
+  static const QString & contents = KGlobal::staticQString( "contents" );
+
+  config->writeEntry( field + cIdx, QString(mField) );
+  config->writeEntry( func + cIdx, functionToString( mFunction ) );
+  config->writeEntry( contents + cIdx, mContents );
+}
+
+bool KMSearchRule::matches( const DwString & aStr, KMMessage & msg,
+                       const DwBoyerMoore *, int ) const
+{
+  if ( !msg.isComplete() ) {
+    msg.fromDwString( aStr );
+    msg.setComplete( true );
+  }
+  return matches( &msg );
+}
+
+const QString KMSearchRule::asString() const
+{
+  QString result  = "\"" + mField + "\" <";
+  result += functionToString( mFunction );
+  result += "> \"" + mContents + "\"";
+
+  return result;
+}
+
+//==================================================
+//
+// class KMSearchRuleString
+//
+//==================================================
+
+KMSearchRuleString::KMSearchRuleString( const QCString & field,
+                                        Function func, const QString & contents )
+          : KMSearchRule(field, func, contents)
+{
+  if ( field.isEmpty() || field[0] == '<' )
+    mBmHeaderField = 0;
+  else // make sure you handle the unrealistic case of the message starting with mField
+    mBmHeaderField = new DwBoyerMoore(("\n" + field + ": ").data());
+}
+
+KMSearchRuleString::KMSearchRuleString( const KMSearchRuleString & other )
+  : KMSearchRule( other ),
+    mBmHeaderField( 0 )
+{
+  if ( other.mBmHeaderField )
+    mBmHeaderField = new DwBoyerMoore( *other.mBmHeaderField );
+}
+
+const KMSearchRuleString & KMSearchRuleString::operator=( const KMSearchRuleString & other )
+{
+  if ( this == &other )
+    return *this;
+
+  setField( other.field() );
+  mBmHeaderField = new DwBoyerMoore( *other.mBmHeaderField );
+  setFunction( other.function() );
+  setContents( other.contents() );
+  delete mBmHeaderField; mBmHeaderField = 0;
+  if ( other.mBmHeaderField )
+    mBmHeaderField = new DwBoyerMoore( *other.mBmHeaderField );
+
+  return *this;
+}
+
+KMSearchRuleString::~KMSearchRuleString()
+{
+  delete mBmHeaderField;
+  mBmHeaderField = 0;
+}
+
+bool KMSearchRuleString::isEmpty() const
+{
+  return field().stripWhiteSpace().isEmpty() || contents().isEmpty();
+}
+
+bool KMSearchRuleString::requiresBody() const
+{
+  if (mBmHeaderField || (field() == "<recipients>" ))
+    return false;
+  return true;
+}
+
+bool KMSearchRuleString::matches( const DwString & aStr, KMMessage & msg,
+                       const DwBoyerMoore * aHeaderField, int aHeaderLen ) const
+{
+  if ( isEmpty() )
+    return false;
+
+  bool rc = false;
+
+  const DwBoyerMoore * headerField = aHeaderField ? aHeaderField : mBmHeaderField ;
+
+  const int headerLen = ( aHeaderLen > -1 ? aHeaderLen : field().length() ) + 2 ; // +1 for ': '
+
+  if ( headerField ) {
+    static const DwBoyerMoore lflf( "\n\n" );
+    static const DwBoyerMoore lfcrlf( "\n\r\n" );
+
+    size_t endOfHeader = lflf.FindIn( aStr, 0 );
+    if ( endOfHeader == DwString::npos )
+      endOfHeader = lfcrlf.FindIn( aStr, 0 );
+    const DwString headers = ( endOfHeader == DwString::npos ) ? aStr : aStr.substr( 0, endOfHeader );
+    // In case the searched header is at the beginning, we have to prepend
+    // a newline - see the comment in KMSearchRuleString constructor
+    DwString fakedHeaders( "\n" );
+    size_t start = headerField->FindIn( fakedHeaders.append( headers ), 0, false );
+    // if the header field doesn't exist then return false for positive
+    // functions and true for negated functions (e.g. "does not
+    // contain"); note that all negated string functions correspond
+    // to an odd value
+    if ( start == DwString::npos )
+      rc = ( ( function() & 1 ) == 1 );
+    else {
+      start += headerLen;
+      size_t stop = aStr.find( '\n', start );
+      char ch = '\0';
+      while ( stop != DwString::npos && ( ch = aStr.at( stop + 1 ) ) == ' ' || ch == '\t' )
+        stop = aStr.find( '\n', stop + 1 );
+      const int len = stop == DwString::npos ? aStr.length() - start : stop - start ;
+      const QCString codedValue( aStr.data() + start, len + 1 );
+      const QString msgContents = KMMsgBase::decodeRFC2047String( codedValue ).stripWhiteSpace(); // FIXME: This needs to be changed for IDN support.
+      rc = matchesInternal( msgContents );
+    }
+  } else if ( field() == "<recipients>" ) {
+    static const DwBoyerMoore to("\nTo: ");
+    static const DwBoyerMoore cc("\nCc: ");
+    static const DwBoyerMoore bcc("\nBcc: ");
+    // <recipients> "contains" "foo" is true if any of the fields contains
+    // "foo", while <recipients> "does not contain" "foo" is true if none
+    // of the fields contains "foo"
+    if ( ( function() & 1 ) == 0 ) {
+      // positive function, e.g. "contains"
+      rc = ( matches( aStr, msg, &to, 2 ) ||
+             matches( aStr, msg, &cc, 2 ) ||
+             matches( aStr, msg, &bcc, 3 ) );
+    }
+    else {
+      // negated function, e.g. "does not contain"
+      rc = ( matches( aStr, msg, &to, 2 ) &&
+             matches( aStr, msg, &cc, 2 ) &&
+             matches( aStr, msg, &bcc, 3 ) );
+    }
+  }
+  if ( FilterLog::instance()->isLogging() ) {
+    QString msg = ( rc ? "<font color=#00FF00>1 = </font>"
+                       : "<font color=#FF0000>0 = </font>" );
+    msg += FilterLog::recode( asString() );
+    // only log headers bcause messages and bodies can be pretty large
+// FIXME We have to separate the text which is used for filtering to be able to show it in the log
+//    if ( logContents )
+//      msg += " (<i>" + FilterLog::recode( msgContents ) + "</i>)";
+    FilterLog::instance()->add( msg, FilterLog::ruleResult );
+  }
+  return rc;
+}
+
+bool KMSearchRuleString::matches( const KMMessage * msg ) const
+{
+  assert( msg );
+
+  if ( isEmpty() )
+    return false;
+
+  QString msgContents;
+  // Show the value used to compare the rules against in the log.
+  // Overwrite the value for complete messages and all headers!
+  bool logContents = true;
+
+  if( field() == "<message>" ) {
+    msgContents = msg->asString();
+    logContents = false;
+  } else if ( field() == "<body>" ) {
+    msgContents = msg->bodyToUnicode();
+    logContents = false;
+  } else if ( field() == "<any header>" ) {
+    msgContents = msg->headerAsString();
+    logContents = false;
+  } else if ( field() == "<recipients>" ) {
+    // (mmutz 2001-11-05) hack to fix "<recipients> !contains foo" to
+    // meet user's expectations. See FAQ entry in KDE 2.2.2's KMail
+    // handbook
+    if ( function() == FuncEquals || function() == FuncNotEqual )
+      // do we need to treat this case specially? Ie.: What shall
+      // "equality" mean for recipients.
+      return matchesInternal( msg->headerField("To") )
+          || matchesInternal( msg->headerField("Cc") )
+          || matchesInternal( msg->headerField("Bcc") )
+          // sometimes messages have multiple Cc headers
+          || matchesInternal( msg->cc() );
+
+    msgContents = msg->headerField("To");
+    if ( !msg->headerField("Cc").compare( msg->cc() ) )
+      msgContents += ", " + msg->headerField("Cc");
+    else
+      msgContents += ", " + msg->cc();
+    msgContents += ", " + msg->headerField("Bcc");
+  }  else {
+    // make sure to treat messages with multiple header lines for
+    // the same header correctly
+    msgContents = msg->headerFields( field() ).join( " " );
+  }
+
+  if ( function() == FuncIsInAddressbook ||
+       function() == FuncIsNotInAddressbook ) {
+    // I think only the "from"-field makes sense.
+    msgContents = msg->headerField( field() );
+    if ( msgContents.isEmpty() )
+      return ( function() == FuncIsInAddressbook ) ? false : true;
+  }
+
+  // these two functions need the kmmessage therefore they don't call matchesInternal
+  if ( function() == FuncHasAttachment )
+    return ( msg->toMsgBase().attachmentState() == KMMsgHasAttachment );
+  if ( function() == FuncHasNoAttachment )
+    return ( ((KMMsgAttachmentState) msg->toMsgBase().attachmentState()) == KMMsgHasNoAttachment );
+
+  bool rc = matchesInternal( msgContents );
+  if ( FilterLog::instance()->isLogging() ) {
+    QString msg = ( rc ? "<font color=#00FF00>1 = </font>"
+                       : "<font color=#FF0000>0 = </font>" );
+    msg += FilterLog::recode( asString() );
+    // only log headers bcause messages and bodies can be pretty large
+    if ( logContents )
+      msg += " (<i>" + FilterLog::recode( msgContents ) + "</i>)";
+    FilterLog::instance()->add( msg, FilterLog::ruleResult );
+  }
+  return rc;
+}
+
+// helper, does the actual comparing
+bool KMSearchRuleString::matchesInternal( const QString & msgContents ) const
+{
+  switch ( function() ) {
+  case KMSearchRule::FuncEquals:
+      return ( QString::compare( msgContents.lower(), contents().lower() ) == 0 );
+
+  case KMSearchRule::FuncNotEqual:
+      return ( QString::compare( msgContents.lower(), contents().lower() ) != 0 );
+
+  case KMSearchRule::FuncContains:
+    return ( msgContents.find( contents(), 0, false ) >= 0 );
+
+  case KMSearchRule::FuncContainsNot:
+    return ( msgContents.find( contents(), 0, false ) < 0 );
+
+  case KMSearchRule::FuncRegExp:
+    {
+      QRegExp regexp( contents(), false );
+      return ( regexp.search( msgContents ) >= 0 );
+    }
+
+  case KMSearchRule::FuncNotRegExp:
+    {
+      QRegExp regexp( contents(), false );
+      return ( regexp.search( msgContents ) < 0 );
+    }
+
+  case FuncIsGreater:
+      return ( QString::compare( msgContents.lower(), contents().lower() ) > 0 );
+
+  case FuncIsLessOrEqual:
+      return ( QString::compare( msgContents.lower(), contents().lower() ) <= 0 );
+
+  case FuncIsLess:
+      return ( QString::compare( msgContents.lower(), contents().lower() ) < 0 );
+
+  case FuncIsGreaterOrEqual:
+      return ( QString::compare( msgContents.lower(), contents().lower() ) >= 0 );
+
+  case FuncIsInAddressbook: {
+    KABC::AddressBook *stdAb = KABC::StdAddressBook::self( true );
+    QStringList addressList =
+      KPIM::splitEmailAddrList( msgContents.lower() );
+    for( QStringList::ConstIterator it = addressList.begin();
+         ( it != addressList.end() );
+         ++it ) {
+      if ( !stdAb->findByEmail( KPIM::getEmailAddress( *it ) ).isEmpty() )
+        return true;
+    }
+    return false;
+  }
+
+  case FuncIsNotInAddressbook: {
+    KABC::AddressBook *stdAb = KABC::StdAddressBook::self( true );
+    QStringList addressList =
+      KPIM::splitEmailAddrList( msgContents.lower() );
+    for( QStringList::ConstIterator it = addressList.begin();
+         ( it != addressList.end() );
+         ++it ) {
+      if ( stdAb->findByEmail( KPIM::getEmailAddress( *it ) ).isEmpty() )
+        return true;
+    }
+    return false;
+  }
+
+  case FuncIsInCategory: {
+    QString category = contents();
+    QStringList addressList =  KPIM::splitEmailAddrList( msgContents.lower() );
+    KABC::AddressBook *stdAb = KABC::StdAddressBook::self( true );
+
+    for( QStringList::ConstIterator it = addressList.begin();
+      it != addressList.end(); ++it ) {
+        KABC::Addressee::List addresses = stdAb->findByEmail( KPIM::getEmailAddress( *it ) );
+
+          for ( KABC::Addressee::List::Iterator itAd = addresses.begin(); itAd != addresses.end(); ++itAd )
+              if ( (*itAd).hasCategory(category) )
+                return true;
+
+      }
+      return false;
+    }
+
+    case FuncIsNotInCategory: {
+      QString category = contents();
+      QStringList addressList =  KPIM::splitEmailAddrList( msgContents.lower() );
+      KABC::AddressBook *stdAb = KABC::StdAddressBook::self( true );
+
+      for( QStringList::ConstIterator it = addressList.begin();
+        it != addressList.end(); ++it ) {
+          KABC::Addressee::List addresses = stdAb->findByEmail( KPIM::getEmailAddress( *it ) );
+
+            for ( KABC::Addressee::List::Iterator itAd = addresses.begin(); itAd != addresses.end(); ++itAd )
+                if ( (*itAd).hasCategory(category) )
+                  return false;
+
+      }
+      return true;
+    }
+  default:
+    ;
+  }
+
+  return false;
+}
+
+
+//==================================================
+//
+// class KMSearchRuleNumerical
+//
+//==================================================
+
+KMSearchRuleNumerical::KMSearchRuleNumerical( const QCString & field,
+                                        Function func, const QString & contents )
+          : KMSearchRule(field, func, contents)
+{
+}
+
+bool KMSearchRuleNumerical::isEmpty() const
+{
+  bool ok = false;
+  contents().toInt( &ok );
+
+  return !ok;
+}
+
+
+bool KMSearchRuleNumerical::matches( const KMMessage * msg ) const
+{
+
+  QString msgContents;
+  int numericalMsgContents = 0;
+  int numericalValue = 0;
+
+  if ( field() == "<size>" ) {
+    numericalMsgContents = int( msg->msgLength() );
+    numericalValue = contents().toInt();
+    msgContents.setNum( numericalMsgContents );
+  } else if ( field() == "<age in days>" ) {
+    QDateTime msgDateTime;
+    msgDateTime.setTime_t( msg->date() );
+    numericalMsgContents = msgDateTime.daysTo( QDateTime::currentDateTime() );
+    numericalValue = contents().toInt();
+    msgContents.setNum( numericalMsgContents );
+  }
+  bool rc = matchesInternal( numericalValue, numericalMsgContents, msgContents );
+  if ( FilterLog::instance()->isLogging() ) {
+    QString msg = ( rc ? "<font color=#00FF00>1 = </font>"
+                       : "<font color=#FF0000>0 = </font>" );
+    msg += FilterLog::recode( asString() );
+    msg += " ( <i>" + QString::number( numericalMsgContents ) + "</i> )";
+    FilterLog::instance()->add( msg, FilterLog::ruleResult );
+  }
+  return rc;
+}
+
+bool KMSearchRuleNumerical::matchesInternal( long numericalValue,
+    long numericalMsgContents, const QString & msgContents ) const
+{
+  switch ( function() ) {
+  case KMSearchRule::FuncEquals:
+      return ( numericalValue == numericalMsgContents );
+
+  case KMSearchRule::FuncNotEqual:
+      return ( numericalValue != numericalMsgContents );
+
+  case KMSearchRule::FuncContains:
+    return ( msgContents.find( contents(), 0, false ) >= 0 );
+
+  case KMSearchRule::FuncContainsNot:
+    return ( msgContents.find( contents(), 0, false ) < 0 );
+
+  case KMSearchRule::FuncRegExp:
+    {
+      QRegExp regexp( contents(), false );
+      return ( regexp.search( msgContents ) >= 0 );
+    }
+
+  case KMSearchRule::FuncNotRegExp:
+    {
+      QRegExp regexp( contents(), false );
+      return ( regexp.search( msgContents ) < 0 );
+    }
+
+  case FuncIsGreater:
+      return ( numericalMsgContents > numericalValue );
+
+  case FuncIsLessOrEqual:
+      return ( numericalMsgContents <= numericalValue );
+
+  case FuncIsLess:
+      return ( numericalMsgContents < numericalValue );
+
+  case FuncIsGreaterOrEqual:
+      return ( numericalMsgContents >= numericalValue );
+
+  case FuncIsInAddressbook:  // since email-addresses are not numerical, I settle for false here
+    return false;
+
+  case FuncIsNotInAddressbook:
+    return false;
+
+  default:
+    ;
+  }
+
+  return false;
+}
+
+
+
+//==================================================
+//
+// class KMSearchRuleStatus
+//
+//==================================================
+QString englishNameForStatus( const KMMsgStatus& status )
+{
+  for ( int i=0; i< numStatusNames; i++ ) {
+    if ( statusNames[i].status == status ) {
+      return statusNames[i].name;
+    }
+  }
+  return QString::null;
+}
+
+KMSearchRuleStatus::KMSearchRuleStatus( const QCString & field,
+                                        Function func, const QString & aContents )
+          : KMSearchRule(field, func, aContents)
+{
+  // the values are always in english, both from the conf file as well as
+  // the patternedit gui
+  mStatus = statusFromEnglishName( aContents );
+}
+
+KMSearchRuleStatus::KMSearchRuleStatus( int status, Function func )
+: KMSearchRule( "<status>", func, englishNameForStatus( status ) )
+{
+    mStatus = status;
+}
+
+KMMsgStatus KMSearchRuleStatus::statusFromEnglishName( const QString & aStatusString )
+{
+  for ( int i=0; i< numStatusNames; i++ ) {
+    if ( !aStatusString.compare( statusNames[i].name ) ) {
+      return statusNames[i].status;
+    }
+  }
+  return KMMsgStatusUnknown;
+}
+
+bool KMSearchRuleStatus::isEmpty() const
+{
+  return field().stripWhiteSpace().isEmpty() || contents().isEmpty();
+}
+
+bool KMSearchRuleStatus::matches( const DwString &, KMMessage &,
+				  const DwBoyerMoore *, int ) const
+{
+  assert( 0 );
+  return false; // don't warn
+}
+
+bool KMSearchRuleStatus::matches( const KMMessage * msg ) const
+{
+
+  KMMsgStatus msgStatus = msg->status();
+  bool rc = false;
+
+  switch ( function() ) {
+    case FuncEquals: // fallthrough. So that "<status> 'is' 'read'" works
+    case FuncContains:
+      if (msgStatus & mStatus)
+        rc = true;
+      break;
+    case FuncNotEqual: // fallthrough. So that "<status> 'is not' 'read'" works
+    case FuncContainsNot:
+      if (! (msgStatus & mStatus) )
+        rc = true;
+      break;
+    // FIXME what about the remaining funcs, how can they make sense for
+    // stati?
+    default:
+      break;
+  }
+
+  if ( FilterLog::instance()->isLogging() ) {
+    QString msg = ( rc ? "<font color=#00FF00>1 = </font>"
+                       : "<font color=#FF0000>0 = </font>" );
+    msg += FilterLog::recode( asString() );
+    FilterLog::instance()->add( msg, FilterLog::ruleResult );
+  }
+  return rc;
+}
+
+// ----------------------------------------------------------------------------
+
+//==================================================
+//
+// class KMSearchPattern
+//
+//==================================================
+
+KMSearchPattern::KMSearchPattern( const KConfig * config )
+  : QPtrList<KMSearchRule>()
+{
+  setAutoDelete( true );
+  if ( config )
+    readConfig( config );
+  else
+    init();
+}
+
+KMSearchPattern::~KMSearchPattern()
+{
+}
+
+bool KMSearchPattern::matches( const KMMessage * msg, bool ignoreBody ) const
+{
+  if ( isEmpty() )
+    return true;
+
+  QPtrListIterator<KMSearchRule> it( *this );
+  switch ( mOperator ) {
+  case OpAnd: // all rules must match
+    for ( it.toFirst() ; it.current() ; ++it )
+      if ( !((*it)->requiresBody() && ignoreBody) )
+        if ( !(*it)->matches( msg ) )
+          return false;
+    return true;
+  case OpOr:  // at least one rule must match
+    for ( it.toFirst() ; it.current() ; ++it )
+      if ( !((*it)->requiresBody() && ignoreBody) )
+        if ( (*it)->matches( msg ) )
+          return true;
+    // fall through
+  default:
+    return false;
+  }
+}
+
+bool KMSearchPattern::matches( const DwString & aStr, bool ignoreBody ) const
+{
+  if ( isEmpty() )
+    return true;
+
+  KMMessage msg;
+  QPtrListIterator<KMSearchRule> it( *this );
+  switch ( mOperator ) {
+  case OpAnd: // all rules must match
+    for ( it.toFirst() ; it.current() ; ++it )
+      if ( !((*it)->requiresBody() && ignoreBody) )
+        if ( !(*it)->matches( aStr, msg ) )
+          return false;
+    return true;
+  case OpOr:  // at least one rule must match
+    for ( it.toFirst() ; it.current() ; ++it )
+      if ( !((*it)->requiresBody() && ignoreBody) )
+        if ( (*it)->matches( aStr, msg ) )
+          return true;
+    // fall through
+  default:
+    return false;
+  }
+}
+
+bool KMSearchPattern::matches( Q_UINT32 serNum, bool ignoreBody ) const
+{
+  if ( isEmpty() )
+    return true;
+
+  bool res;
+  int idx = -1;
+  KMFolder *folder = 0;
+  KMMsgDict::instance()->getLocation(serNum, &folder, &idx);
+  if (!folder || (idx == -1) || (idx >= folder->count())) {
+    return false;
+  }
+
+  KMFolderOpener openFolder(folder, "searchptr");
+  KMMsgBase *msgBase = folder->getMsgBase(idx);
+  if (requiresBody() && !ignoreBody) {
+    bool unGet = !msgBase->isMessage();
+    KMMessage *msg = folder->getMsg(idx);
+    res = false;
+    if ( msg ) {
+      res = matches( msg, ignoreBody );
+      if (unGet)
+        folder->unGetMsg(idx);
+    }
+  } else {
+    res = matches( folder->getDwString(idx), ignoreBody );
+  }
+  return res;
+}
+
+bool KMSearchPattern::requiresBody() const {
+  QPtrListIterator<KMSearchRule> it( *this );
+    for ( it.toFirst() ; it.current() ; ++it )
+      if ( (*it)->requiresBody() )
+	return true;
+  return false;
+}
+
+void KMSearchPattern::purify() {
+  QPtrListIterator<KMSearchRule> it( *this );
+  it.toLast();
+  while ( it.current() )
+    if ( (*it)->isEmpty() ) {
+#ifndef NDEBUG
+      kdDebug(5006) << "KMSearchPattern::purify(): removing " << (*it)->asString() << endl;
+#endif
+      remove( *it );
+    } else {
+      --it;
+    }
+}
+
+void KMSearchPattern::readConfig( const KConfig * config ) {
+  init();
+
+  mName = config->readEntry("name");
+  if ( !config->hasKey("rules") ) {
+    kdDebug(5006) << "KMSearchPattern::readConfig: found legacy config! Converting." << endl;
+    importLegacyConfig( config );
+    return;
+  }
+
+  mOperator = config->readEntry("operator") == "or" ? OpOr : OpAnd;
+
+  const int nRules = config->readNumEntry( "rules", 0 );
+
+  for ( int i = 0 ; i < nRules ; i++ ) {
+    KMSearchRule * r = KMSearchRule::createInstanceFromConfig( config, i );
+    if ( r->isEmpty() )
+      delete r;
+    else
+      append( r );
+  }
+}
+
+void KMSearchPattern::importLegacyConfig( const KConfig * config ) {
+  KMSearchRule * rule = KMSearchRule::createInstance( config->readEntry("fieldA").latin1(),
+					  config->readEntry("funcA").latin1(),
+					  config->readEntry("contentsA") );
+  if ( rule->isEmpty() ) {
+    // if the first rule is invalid,
+    // we really can't do much heuristics...
+    delete rule;
+    return;
+  }
+  append( rule );
+
+  const QString sOperator = config->readEntry("operator");
+  if ( sOperator == "ignore" ) return;
+
+  rule = KMSearchRule::createInstance( config->readEntry("fieldB").latin1(),
+			   config->readEntry("funcB").latin1(),
+			   config->readEntry("contentsB") );
+  if ( rule->isEmpty() ) {
+    delete rule;
+    return;
+  }
+  append( rule );
+
+  if ( sOperator == "or"  ) {
+    mOperator = OpOr;
+    return;
+  }
+  // This is the interesting case...
+  if ( sOperator == "unless" ) { // meaning "and not", ie we need to...
+    // ...invert the function (e.g. "equals" <-> "doesn't equal")
+    // We simply toggle the last bit (xor with 0x1)... This assumes that
+    // KMSearchRule::Function's come in adjacent pairs of pros and cons
+    KMSearchRule::Function func = last()->function();
+    unsigned int intFunc = (unsigned int)func;
+    func = KMSearchRule::Function( intFunc ^ 0x1 );
+
+    last()->setFunction( func );
+  }
+
+  // treat any other case as "and" (our default).
+}
+
+void KMSearchPattern::writeConfig( KConfig * config ) const {
+  config->writeEntry("name", mName);
+  config->writeEntry("operator", (mOperator == KMSearchPattern::OpOr) ? "or" : "and" );
+
+  int i = 0;
+  for ( QPtrListIterator<KMSearchRule> it( *this ) ; it.current() && i < FILTER_MAX_RULES ; ++i , ++it )
+    // we could do this ourselves, but we want the rules to be extensible,
+    // so we give the rule it's number and let it do the rest.
+    (*it)->writeConfig( config, i );
+
+  // save the total number of rules.
+  config->writeEntry( "rules", i );
+}
+
+void KMSearchPattern::init() {
+  clear();
+  mOperator = OpAnd;
+  mName = '<' + i18n("name used for a virgin filter","unknown") + '>';
+}
+
+QString KMSearchPattern::asString() const {
+  QString result;
+  if ( mOperator == OpOr )
+    result = i18n("(match any of the following)");
+  else
+    result = i18n("(match all of the following)");
+
+  for ( QPtrListIterator<KMSearchRule> it( *this ) ; it.current() ; ++it )
+    result += "\n\t" + FilterLog::recode( (*it)->asString() );
+
+  return result;
+}
+
+const KMSearchPattern & KMSearchPattern::operator=( const KMSearchPattern & other ) {
+  if ( this == &other )
+    return *this;
+
+  setOp( other.op() );
+  setName( other.name() );
+
+  clear(); // ###
+
+  for ( QPtrListIterator<KMSearchRule> it( other ) ; it.current() ; ++it ) {
+    KMSearchRule * rule = KMSearchRule::createInstance( **it ); // deep copy
+    append( rule );
+  }
+
+  return *this;
+}
-- 
cgit v1.2.1