kmsearchpattern.h

// -*- mode: C++; c-file-style: "gnu" -*-
// kmsearchpattern.h
// Author: Marc Mutz <Marc@Mutz.com>
// This code is under GPL!
 
#ifndef _kmsearchpattern_h_
#define _kmsearchpattern_h_
 
#include <tdelocale.h>
#include <tqptrlist.h>
#include <tqstring.h>
#include <tqcstring.h>
#include "kmmsgbase.h" // for KMMsgStatus
 
class KMMessage;
class TDEConfig;
class DwBoyerMoore;
class DwString;
 
 
// maximum number of filter rules per filter
const int FILTER_MAX_RULES=8;
 
class KMSearchRule
{
public:
  enum Function { FuncNone = -1,
                  FuncContains=0, FuncContainsNot,
          FuncEquals, FuncNotEqual,
          FuncRegExp, FuncNotRegExp,
          FuncIsGreater, FuncIsLessOrEqual,
          FuncIsLess, FuncIsGreaterOrEqual,
          FuncIsInAddressbook, FuncIsNotInAddressbook,
                  FuncIsInCategory, FuncIsNotInCategory,
          FuncHasAttachment, FuncHasNoAttachment};
  KMSearchRule ( const TQCString & field=0, Function=FuncContains,
                 const TQString &contents=TQString() );
  KMSearchRule ( const KMSearchRule &other );
 
  const KMSearchRule & operator=( const KMSearchRule & other );
 
  static KMSearchRule* createInstance( const TQCString & field=0,
                                      Function function=FuncContains,
                              const TQString & contents=TQString() );
 
  static KMSearchRule* createInstance( const TQCString & field,
                                       const char * function,
                                       const TQString & contents );
 
  static KMSearchRule * createInstance( const KMSearchRule & other );
 
  static KMSearchRule* createInstanceFromConfig( const TDEConfig * config, int aIdx );
 
  virtual ~KMSearchRule() {};
 
  virtual bool matches( const KMMessage * msg ) const = 0;
 
   virtual bool matches( const DwString & str, KMMessage & msg,
                         const DwBoyerMoore * headerField=0,
                         int headerLen=-1 ) const;
 
  virtual bool isEmpty() const = 0;
 
  virtual bool requiresBody() const { return true; }
 
 
  void writeConfig( TDEConfig * config, int aIdx ) const;
 
  Function function() const { return mFunction; }
 
  void setFunction( Function aFunction ) { mFunction = aFunction; }
 
  TQCString field() const { return mField; }
 
  void setField( const TQCString & field ) { mField = field; }
 
  TQString contents() const { return mContents; }
  void setContents( const TQString & aContents ) { mContents = aContents; }
 
  const TQString asString() const;
 
private:
  static Function configValueToFunc( const char * str );
  static TQString functionToString( Function function );
 
  TQCString mField;
  Function mFunction;
  TQString  mContents;
};
 
 
// subclasses representing the different kinds of searches
 
class KMSearchRuleString : public KMSearchRule
{
public:
  KMSearchRuleString( const TQCString & field=0, Function function=FuncContains,
        const TQString & contents=TQString() );
  KMSearchRuleString( const KMSearchRuleString & other );
  const KMSearchRuleString & operator=( const KMSearchRuleString & other );
 
  virtual ~KMSearchRuleString();
  virtual bool isEmpty() const ;
  virtual bool requiresBody() const;
 
  virtual bool matches( const KMMessage * msg ) const;
 
  virtual bool matches( const DwString & str, KMMessage & msg,
                        const DwBoyerMoore * headerField=0,
                        int headerLen=-1 ) const;
 
  bool matchesInternal( const TQString & msgContents ) const;
 
private:
  const DwBoyerMoore *mBmHeaderField;
};
 
 
class KMSearchRuleNumerical : public KMSearchRule
{
public:
  KMSearchRuleNumerical( const TQCString & field=0, Function function=FuncContains,
                 const TQString & contents=TQString() );
  virtual bool isEmpty() const ;
 
  virtual bool matches( const KMMessage * msg ) const;
 
  bool matchesInternal( long numericalValue, long numericalMsgContents,
                        const TQString & msgContents ) const;
};
 
 
namespace KMail {
// The below are used in several places and here so they are accessible.
  struct MessageStatus {
    const char * const text;
    const char * const icon;
  };
 
  // If you change the ordering here; also do it in the enum below
  static const MessageStatus StatusValues[] = {
    { I18N_NOOP( "Important" ),        "kmmsgflag"   },
    { I18N_NOOP( "New" ),              "kmmsgnew"   },
    { I18N_NOOP( "Unread" ),           "kmmsgunseen"   },
    { I18N_NOOP( "Read" ),             "kmmsgread"   },
    { I18N_NOOP( "Old" ),              0   },
    { I18N_NOOP( "Deleted" ),          "kmmsgdel"   },
    { I18N_NOOP( "Replied" ),          "kmmsgreplied"   },
    { I18N_NOOP( "Forwarded" ),        "kmmsgforwarded"   },
    { I18N_NOOP( "Queued" ),           "kmmsgqueued"   },
    { I18N_NOOP( "Sent" ),             "kmmsgsent"   },
    { I18N_NOOP( "Watched" ),          "kmmsgwatched"   },
    { I18N_NOOP( "Ignored" ),          "kmmsgignored"   },
    { I18N_NOOP( "Spam" ),             "kmmsgspam"   },
    { I18N_NOOP( "Ham" ),              "kmmsgham"   },
    { I18N_NOOP( "To Do" ),            "kmmsgtodo"   },
    { I18N_NOOP( "Invitation" ),       "kmmsginvitation"   },
    { I18N_NOOP( "Has Attachment"),    "kmmsgattachment"   }  //must be last
  };
  // If you change the ordering here; also do it in the array above
  enum StatusValueTypes {
    StatusImportant = 0,
    StatusNew = 1,
    StatusUnread = 2,
    StatusRead = 3,
    StatusOld = 4,
    StatusDeleted = 5,
    StatusReplied = 6,
    StatusForwarded = 7,
    StatusQueued = 8,
    StatusSent = 9,
    StatusWatched = 10,
    StatusIgnored = 11,
    StatusSpam = 12,
    StatusHam = 13,
    StatusToDo = 14,
    StatusInvitation = 15,
    StatusHasAttachment = 16  //must be last
  };
 
  static const int StatusValueCount =
    sizeof( StatusValues ) / sizeof( MessageStatus );
  // we want to show all status entries in the quick search bar, but only the
  // ones up to attachment in the search/filter dialog, because there the
  // attachment case is handled separately.
  static const int StatusValueCountWithoutHidden = StatusValueCount - 1;
}
 
class KMSearchRuleStatus : public KMSearchRule
{
public:
   KMSearchRuleStatus( const TQCString & field=0, Function function=FuncContains,
               const TQString & contents=TQString() );
   KMSearchRuleStatus( int status, Function function=FuncContains );
 
  virtual bool isEmpty() const ;
  virtual bool matches( const KMMessage * msg ) const;
  //Not possible to implement this form for status searching
  virtual bool matches( const DwString &, KMMessage &,
                        const DwBoyerMoore *,
            int ) const;
  static KMMsgStatus statusFromEnglishName(const TQString&);
  private:
  KMMsgStatus mStatus;
};
 
// ------------------------------------------------------------------------
 
class KMSearchPattern : public TQPtrList<KMSearchRule>
{
 
public:
  enum Operator { OpAnd, OpOr };
  KMSearchPattern( const TDEConfig * config=0 );
 
  ~KMSearchPattern();
 
  bool matches( const KMMessage * msg, bool ignoreBody = false ) const;
  bool matches( const DwString & str, bool ignoreBody = false ) const;
  bool matches( TQ_UINT32 sernum, bool ignoreBody = false ) const;
 
  bool requiresBody() const;
 
  void purify();
 
  void readConfig( const TDEConfig * config );
  void writeConfig( TDEConfig * config ) const;
 
  TQString name() const { return mName; }
  void setName( const TQString & newName ) { mName = newName ; }
 
  KMSearchPattern::Operator op() const { return mOperator; }
  void setOp( KMSearchPattern::Operator aOp ) { mOperator = aOp; }
 
  TQString asString() const;
 
  const KMSearchPattern & operator=( const KMSearchPattern & aPattern );
 
private:
  void importLegacyConfig( const TDEConfig * config );
  void init();
 
  TQString  mName;
  Operator mOperator;
};
 
#endif /* _kmsearchpattern_h_ */