• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdepim

• Sitemap
• Contact Us

 

kmail

kmsearchpattern.h

Go to the documentation of this file.

/* -*- mode: C++; c-file-style: "gnu" -*-
  kmsearchpattern.h
  Author: Marc Mutz <Marc@Mutz.com>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/

#ifndef _kmsearchpattern_h_
#define _kmsearchpattern_h_

#include <klocale.h>
#include <messagestatus.h>
using KPIM::MessageStatus;

#include <QList>
#include <QString>

class KMMessage;
class KConfigGroup;
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};
  explicit KMSearchRule ( const QByteArray & field=0, Function=FuncContains,
                 const QString &contents=QString() );
  KMSearchRule ( const KMSearchRule &other );

  const KMSearchRule & operator=( const KMSearchRule & other );

  static KMSearchRule* createInstance( const QByteArray & field=0,
                                      Function function=FuncContains,
                                      const QString & contents=QString() );

  static KMSearchRule* createInstance( const QByteArray & field,
                                       const char * function,
                                       const QString & contents );

  static KMSearchRule * createInstance( const KMSearchRule & other );

  static KMSearchRule* createInstanceFromConfig( const KConfigGroup & 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( KConfigGroup & config, int aIdx ) const;

  Function function() const { return mFunction; }

  void setFunction( Function aFunction ) { mFunction = aFunction; }

  QByteArray field() const { return mField; }

  void setField( const QByteArray & field ) { mField = field; }

  QString contents() const { return mContents; }
  void setContents( const QString & aContents ) { mContents = aContents; }

  const QString asString() const;

private:
  static Function configValueToFunc( const char * str );
  static QString functionToString( Function function );

  QByteArray mField;
  Function mFunction;
  QString  mContents;
};


// subclasses representing the different kinds of searches

class KMSearchRuleString : public KMSearchRule
{
public:
  explicit KMSearchRuleString( const QByteArray & field=0,
                Function function=FuncContains, const QString & contents=QString() );
  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 QString & msgContents ) const;

private:
  const DwBoyerMoore *mBmHeaderField;
};


class KMSearchRuleNumerical : public KMSearchRule
{
public:
  explicit KMSearchRuleNumerical( const QByteArray & field=0,
                         Function function=FuncContains, const QString & contents=QString() );
  virtual bool isEmpty() const ;

  virtual bool matches( const KMMessage * msg ) const;

  // Optimized matching not implemented, will use the unoptimized matching
  // from KMSearchRule
  using KMSearchRule::matches;

  bool matchesInternal( long numericalValue, long numericalMsgContents,
                        const QString & 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_NOOP2( "message status", "Important" ),              "emblem-important"    },
    { I18N_NOOP2( "message status", "Action Item" ),            "mail-task"           },
    { I18N_NOOP2( "message status", "New" ),                    "mail-unread-new"     },
    { I18N_NOOP2( "message status", "Unread" ),                 "mail-unread"         },
    { I18N_NOOP2( "message status", "Read" ),                   "mail-read"           },
    { I18N_NOOP2( "message status", "Deleted" ),                "mail-deleted"        },
    { I18N_NOOP2( "message status", "Replied" ),                "mail-replied"        },
    { I18N_NOOP2( "message status", "Forwarded" ),              "mail-forwarded"      },
    { I18N_NOOP2( "message status", "Queued" ),                 "mail-queued"         },
    { I18N_NOOP2( "message status", "Sent" ),                   "mail-sent"           },
    { I18N_NOOP2( "message status", "Watched" ),                "mail-thread-watch"   },
    { I18N_NOOP2( "message status", "Ignored" ),                "mail-thread-ignored" },
    { I18N_NOOP2( "message status", "Spam" ),                   "mail-mark-junk"      },
    { I18N_NOOP2( "message status", "Ham" ),                    "mail-mark-notjunk"   },
    { I18N_NOOP2( "message status", "Has Attachment"),          "mail-attachment"     } //must be last
  };
  // If you change the ordering here; also do it in the array above
  enum StatusValueTypes {
    StatusImportant = 0,
    StatusToAct = 1,
    StatusNew = 2,
    StatusUnread = 3,
    StatusRead = 4,
    StatusDeleted = 5,
    StatusReplied = 6,
    StatusForwarded = 7,
    StatusQueued = 8,
    StatusSent = 9,
    StatusWatched = 10,
    StatusIgnored = 11,
    StatusSpam = 12,
    StatusHam = 13,
    StatusHasAttachment = 14 //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:
   explicit KMSearchRuleStatus( const QByteArray & field=0, Function function=FuncContains,
                                const QString & contents=QString() );
   KMSearchRuleStatus( MessageStatus status, Function function=FuncContains );

   virtual bool isEmpty() const ;
   virtual bool matches( const KMMessage * msg ) const;

   //Not possible to implement optimized form for status searching
   using KMSearchRule::matches;


   static MessageStatus statusFromEnglishName(const QString&);
private:
   MessageStatus mStatus;
};

// ------------------------------------------------------------------------

class KMSearchPattern : public QList<KMSearchRule*>
{

public:
  enum Operator { OpAnd, OpOr };

  KMSearchPattern();

  KMSearchPattern( const KConfigGroup & config );

  ~KMSearchPattern();

  bool matches( const KMMessage * msg, bool ignoreBody = false ) const;
  bool matches( const DwString & str, bool ignoreBody = false ) const;
  bool matches( quint32 sernum, bool ignoreBody = false ) const;

  bool requiresBody() const;

  void purify();

  void readConfig( const KConfigGroup & config );

  void writeConfig( KConfigGroup & config ) const;

  QString name() const { return mName; }
  void setName( const QString & newName ) { mName = newName ; }

  KMSearchPattern::Operator op() const { return mOperator; }
  void setOp( KMSearchPattern::Operator aOp ) { mOperator = aOp; }

  QString asString() const;

  const KMSearchPattern & operator=( const KMSearchPattern & aPattern );

private:
  void importLegacyConfig( const KConfigGroup & config );

  void init();

  QString  mName;
  Operator mOperator;
};

#endif /* _kmsearchpattern_h_ */

kmail

Skip menu "kmail"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

kdepim

Skip menu "kdepim"

• akonadi
•   clients
•   kabc
•   kcal
•   kcm
• akregator
• console
•   kabcclient
•   konsolekalendar
• kaddressbook
• kalarm
•   lib
• kdgantt
• kdgantt1
• kjots
• kleopatra
• kmail
• kmobiletools
• knode
• knotes
• kontact
• kontactinterfaces
• korganizer
•   korgac
• kpilot
• ktimetracker
•   doc
• libkdepim
• libkholidays
• libkleo
• libkpgp
• maildir

Generated for kdepim by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal