1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "qmessagefilter.h"

    42 #include "qmfhelpers_p.h"

    43 

    44 #include <qmailaccountkey.h>

    45 #include <qmailfolderkey.h>

    46 #include <qmailmessagekey.h>

    47 

    48 using namespace QTM_PREPEND_NAMESPACE(QmfHelpers);

    49 

    50 QTM_BEGIN_NAMESPACE

    51 

    52 class QMessageFilterPrivate

    53 {

    54 public:

    55     QMessageFilterPrivate() : _key(), _matchFlags(0) {}

    56 

    57     QMailMessageKey _key;

    58     QMessageDataComparator::MatchFlags _matchFlags;

    59 

    60     //static QMessageFilter convert(const QMailMessageKey &key);

    61     static QMailMessageKey convert(const QMessageFilter &key);

    62 };

    63 

    64 /*

    65 QMessageFilter QMessageFilterPrivate::convert(const QMailMessageKey &key)

    66 {

    67     QMessageFilter result;

    68     result.d_ptr->_key = key;

    69     return result;

    70 }

    71 */

    72 

    73 QMailMessageKey QMessageFilterPrivate::convert(const QMessageFilter &key)

    74 {

    75     return key.d_ptr->_key;

    76 }

    77 

    78 namespace QmfHelpers {

    79 

    80 /*

    81 QMessageFilter convert(const QMailMessageKey &key)

    82 {

    83     return QMessageFilterPrivate::convert(key);

    84 }

    85 */

    86 

    87 QMailMessageKey convert(const QMessageFilter &key)

    88 {

    89     return QMessageFilterPrivate::convert(key);

    90 }

    91 

    92 }

    93 

    94 namespace {

    95 

    96 // QMF stores dates in localtime

    97 QDateTime adjusted(const QDateTime &dt)

    98 {

    99     if (dt.timeSpec() == Qt::LocalTime ) {

   100         return dt;

   101     }

   102 

   103     return dt.toLocalTime();

   104 }

   105 

   106 }

   107 

   108 QMessageFilter::QMessageFilter()

   109     : d_ptr(new QMessageFilterPrivate)

   110 {

   111 }

   112 

   113 QMessageFilter::QMessageFilter(const QMessageFilter &other)

   114     : d_ptr(new QMessageFilterPrivate)

   115 {

   116     this->operator=(other);

   117 }

   118 

   119 QMessageFilter::~QMessageFilter()

   120 {

   121     delete d_ptr;

   122     d_ptr = 0;

   123 }

   124 

   125 QMessageFilter& QMessageFilter::operator=(const QMessageFilter& other)

   126 {

   127     if (&other != this) {

   128         d_ptr->_key = other.d_ptr->_key;

   129         d_ptr->_matchFlags = other.d_ptr->_matchFlags;

   130     }

   131 

   132     return *this;

   133 }

   134 

   135 void QMessageFilter::setMatchFlags(QMessageDataComparator::MatchFlags matchFlags)

   136 {

   137     d_ptr->_matchFlags = matchFlags;

   138 }

   139 

   140 QMessageDataComparator::MatchFlags QMessageFilter::matchFlags() const

   141 {

   142     return d_ptr->_matchFlags;

   143 }

   144 

   145 bool QMessageFilter::isEmpty() const

   146 {

   147     return d_ptr->_key.isEmpty();

   148 }

   149 

   150 bool QMessageFilter::isSupported() const

   151 {

   152     return !d_ptr->_matchFlags;

   153 }

   154 

   155 QMessageFilter QMessageFilter::operator~() const

   156 {

   157     QMessageFilter result;

   158     result.d_ptr->_key = ~d_ptr->_key;

   159     return result;

   160 }

   161 

   162 QMessageFilter QMessageFilter::operator&(const QMessageFilter& other) const

   163 {

   164     QMessageFilter result;

   165     result.d_ptr->_key = d_ptr->_key & other.d_ptr->_key;

   166     result.d_ptr->_matchFlags = d_ptr->_matchFlags | other.d_ptr->_matchFlags; // matchFlags not supported

   167     return result;

   168 }

   169 

   170 QMessageFilter QMessageFilter::operator|(const QMessageFilter& other) const

   171 {

   172     QMessageFilter result;

   173     result.d_ptr->_key = d_ptr->_key | other.d_ptr->_key;

   174     result.d_ptr->_matchFlags = d_ptr->_matchFlags | other.d_ptr->_matchFlags; // matchFlags not supported

   175     return result;

   176 }

   177 

   178 const QMessageFilter& QMessageFilter::operator&=(const QMessageFilter& other)

   179 {

   180     d_ptr->_key &= other.d_ptr->_key;

   181     d_ptr->_matchFlags |= other.d_ptr->_matchFlags; // matchFlags not supported

   182     return *this;

   183 }

   184 

   185 const QMessageFilter& QMessageFilter::operator|=(const QMessageFilter& other)

   186 {

   187     d_ptr->_key |= other.d_ptr->_key;

   188     d_ptr->_matchFlags |= other.d_ptr->_matchFlags; // matchFlags not supported

   189     return *this;

   190 }

   191 

   192 bool QMessageFilter::operator==(const QMessageFilter& other) const

   193 {

   194     return ((d_ptr->_key == other.d_ptr->_key)

   195             && (d_ptr->_matchFlags == other.d_ptr->_matchFlags));

   196 }

   197 

   198 QMessageFilter QMessageFilter::byId(const QMessageId &id, QMessageDataComparator::EqualityComparator cmp)

   199 {

   200     QMessageFilter result;

   201     result.d_ptr->_key = QMailMessageKey::id(convert(id), convert(cmp));

   202     return result;

   203 }

   204 

   205 QMessageFilter QMessageFilter::byId(const QMessageIdList &ids, QMessageDataComparator::InclusionComparator cmp)

   206 {

   207     QMessageFilter result;

   208     result.d_ptr->_key = QMailMessageKey::id(convert(ids), convert(cmp));

   209     return result;

   210 }

   211 

   212 QMessageFilter QMessageFilter::byId(const QMessageFilter &key, QMessageDataComparator::InclusionComparator cmp)

   213 {

   214     QMessageFilter result;

   215     result.d_ptr->_key = QMailMessageKey::id(convert(key), convert(cmp));

   216     return result;

   217 }

   218 

   219 QMessageFilter QMessageFilter::byType(QMessage::Type type, QMessageDataComparator::EqualityComparator cmp)

   220 {

   221     QMessageFilter result;

   222     result.d_ptr->_key = QMailMessageKey::messageType(convert(type), convert(cmp));

   223     return result;

   224 }

   225 

   226 QMessageFilter QMessageFilter::byType(QMessage::TypeFlags type, QMessageDataComparator::InclusionComparator cmp)

   227 {

   228     QMessageFilter result;

   229     result.d_ptr->_key = QMailMessageKey::messageType(convert(type), convert(cmp));

   230     return result;

   231 }

   232 

   233 QMessageFilter QMessageFilter::bySender(const QString &value, QMessageDataComparator::EqualityComparator cmp)

   234 {

   235     QMessageFilter result;

   236     result.d_ptr->_key = QMailMessageKey::sender(value, convert(cmp));

   237     return result;

   238 }

   239 

   240 QMessageFilter QMessageFilter::bySender(const QString &value, QMessageDataComparator::InclusionComparator cmp)

   241 {

   242     QMessageFilter result;

   243     result.d_ptr->_key = QMailMessageKey::sender(value, convert(cmp));

   244     return result;

   245 }

   246 

   247 QMessageFilter QMessageFilter::byRecipients(const QString &value, QMessageDataComparator::InclusionComparator cmp)

   248 {

   249     QMessageFilter result;

   250     result.d_ptr->_key = QMailMessageKey::recipients(value, convert(cmp));

   251     return result;

   252 }

   253 

   254 QMessageFilter QMessageFilter::bySubject(const QString &value, QMessageDataComparator::EqualityComparator cmp)

   255 {

   256     QMessageFilter result;

   257     result.d_ptr->_key = QMailMessageKey::subject(value, convert(cmp));

   258     return result;

   259 }

   260 

   261 QMessageFilter QMessageFilter::bySubject(const QString &value, QMessageDataComparator::InclusionComparator cmp)

   262 {

   263     QMessageFilter result;

   264     result.d_ptr->_key = QMailMessageKey::subject(value, convert(cmp));

   265     return result;

   266 }

   267 

   268 QMessageFilter QMessageFilter::byTimeStamp(const QDateTime &value, QMessageDataComparator::EqualityComparator cmp)

   269 {

   270     QMessageFilter result;

   271     result.d_ptr->_key = QMailMessageKey::timeStamp(adjusted(value), convert(cmp));

   272     return result;

   273 }

   274 

   275 QMessageFilter QMessageFilter::byTimeStamp(const QDateTime &value, QMessageDataComparator::RelationComparator cmp)

   276 {

   277     QMessageFilter result;

   278     result.d_ptr->_key = QMailMessageKey::timeStamp(adjusted(value), convert(cmp));

   279     return result;

   280 }

   281 

   282 QMessageFilter QMessageFilter::byReceptionTimeStamp(const QDateTime &value, QMessageDataComparator::EqualityComparator cmp)

   283 {

   284     QMessageFilter result;

   285     result.d_ptr->_key = QMailMessageKey::receptionTimeStamp(adjusted(value), convert(cmp));

   286     return result;

   287 }

   288 

   289 QMessageFilter QMessageFilter::byReceptionTimeStamp(const QDateTime &value, QMessageDataComparator::RelationComparator cmp)

   290 {

   291     QMessageFilter result;

   292     result.d_ptr->_key = QMailMessageKey::receptionTimeStamp(adjusted(value), convert(cmp));

   293     return result;

   294 }

   295 

   296 QMessageFilter QMessageFilter::byStatus(QMessage::Status value, QMessageDataComparator::EqualityComparator cmp)

   297 {

   298     QMessageFilter result;

   299     result.d_ptr->_key = QMailMessageKey::status(convert(value), (cmp == QMessageDataComparator::Equal ? QMailDataComparator::Includes : QMailDataComparator::Excludes));

   300     return result;

   301 }

   302 

   303 QMessageFilter QMessageFilter::byStatus(QMessage::StatusFlags mask, QMessageDataComparator::InclusionComparator cmp)

   304 {

   305     QMailMessageKey key;

   306 

   307     // This should be interpreted as specifying a match or otherwise on each of the flags set in the mask

   308     if (mask & QMessage::Read) {

   309         key &= QMailMessageKey::status(convert(QMessage::Read), convert(cmp));

   310     }

   311     if (mask & QMessage::HasAttachments) {

   312         key &= QMailMessageKey::status(convert(QMessage::HasAttachments), convert(cmp));

   313     }

   314     if (mask & QMessage::Incoming) {

   315         key &= QMailMessageKey::status(convert(QMessage::Incoming), convert(cmp));

   316     }

   317     if (mask & QMessage::Removed) {

   318         key &= QMailMessageKey::status(convert(QMessage::Removed), convert(cmp));

   319     }

   320 

   321     QMessageFilter result;

   322     result.d_ptr->_key = (key.isEmpty() ? QMailMessageKey::nonMatchingKey() : key);

   323     return result;

   324 }

   325 

   326 QMessageFilter QMessageFilter::byPriority(QMessage::Priority value, QMessageDataComparator::EqualityComparator cmp)

   327 {

   328     QMessageFilter result;

   329 

   330     switch (value)

   331     {

   332     case QMessage::HighPriority: 

   333         result.d_ptr->_key = QMailMessageKey::status(highPriorityMask(), (cmp == QMessageDataComparator::Equal ? QMailDataComparator::Includes : QMailDataComparator::Excludes)); 

   334         break;

   335 

   336     case QMessage::LowPriority: 

   337         result.d_ptr->_key = QMailMessageKey::status(lowPriorityMask(), (cmp == QMessageDataComparator::Equal ? QMailDataComparator::Includes : QMailDataComparator::Excludes)); 

   338         break;

   339 

   340     case QMessage::NormalPriority:

   341         result.d_ptr->_key = QMailMessageKey::status(lowPriorityMask() | highPriorityMask(), (cmp == QMessageDataComparator::Equal ? QMailDataComparator::Excludes : QMailDataComparator::Includes)); 

   342         break;

   343     }

   344 

   345     return result;

   346 }

   347 

   348 QMessageFilter QMessageFilter::bySize(int value, QMessageDataComparator::EqualityComparator cmp)

   349 {

   350     QMessageFilter result;

   351     result.d_ptr->_key = QMailMessageKey::size(value, convert(cmp));

   352     return result;

   353 }

   354 

   355 QMessageFilter QMessageFilter::bySize(int value, QMessageDataComparator::RelationComparator cmp)

   356 {

   357     QMessageFilter result;

   358     result.d_ptr->_key = QMailMessageKey::size(value, convert(cmp));

   359     return result;

   360 }

   361 

   362 QMessageFilter QMessageFilter::byParentAccountId(const QMessageAccountId &id, QMessageDataComparator::EqualityComparator cmp)

   363 {

   364     QMessageFilter result;

   365     result.d_ptr->_key = QMailMessageKey::parentAccountId(convert(id), convert(cmp));

   366     return result;

   367 }

   368 

   369 QMessageFilter QMessageFilter::byParentAccountId(const QMessageAccountFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   370 {

   371     QMessageFilter result;

   372     result.d_ptr->_key = QMailMessageKey::parentAccountId(convert(filter), convert(cmp));

   373     return result;

   374 }

   375 

   376 QMessageFilter QMessageFilter::byStandardFolder(QMessage::StandardFolder folder, QMessageDataComparator::EqualityComparator cmp)

   377 {

   378     QMessageFilter result;

   379     QMessageManager mgr; // Ensure standard folders are initialized

   380     Q_UNUSED(mgr)

   381 

   382     QMailDataComparator::InclusionComparator comparator(cmp == QMessageDataComparator::Equal ? QMailDataComparator::Includes : QMailDataComparator::Excludes); 

   383 

   384     switch (folder)

   385     {

   386     case QMessage::InboxFolder:

   387         result.d_ptr->_key = QMailMessageKey::status(QMailMessage::Incoming, comparator);

   388 

   389         // Exclude any trash messages

   390         result.d_ptr->_key &= ~QMailMessageKey::status(QMailMessage::Trash, comparator);

   391         break;

   392 

   393     case QMessage::OutboxFolder:

   394         result.d_ptr->_key = QMailMessageKey::status(QMailMessage::Outbox, comparator);

   395         break;

   396 

   397     case QMessage::DraftsFolder:

   398         result.d_ptr->_key = QMailMessageKey::status(QMailMessage::Draft, comparator);

   399         break;

   400 

   401     case QMessage::SentFolder:

   402         result.d_ptr->_key = QMailMessageKey::status(QMailMessage::Sent, comparator);

   403         break;

   404 

   405     case QMessage::TrashFolder:

   406         result.d_ptr->_key = QMailMessageKey::status(QMailMessage::Trash, comparator);

   407         break;

   408     }

   409 

   410     return result;

   411 }

   412 

   413 QMessageFilter QMessageFilter::byParentFolderId(const QMessageFolderId &id, QMessageDataComparator::EqualityComparator cmp)

   414 {

   415     QMessageFilter result;

   416     result.d_ptr->_key = QMailMessageKey::parentFolderId(convert(id), convert(cmp));

   417     return result;

   418 }

   419 

   420 QMessageFilter QMessageFilter::byParentFolderId(const QMessageFolderFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   421 {

   422     QMessageFilter result;

   423     result.d_ptr->_key = QMailMessageKey::parentFolderId(convert(filter), convert(cmp));

   424     return result;

   425 }

   426 

   427 QMessageFilter QMessageFilter::byAncestorFolderIds(const QMessageFolderId &id, QMessageDataComparator::InclusionComparator cmp)

   428 {

   429     QMessageFilter result;

   430     result.d_ptr->_key = QMailMessageKey::ancestorFolderIds(convert(id), convert(cmp));

   431     return result;

   432 }

   433 

   434 QMessageFilter QMessageFilter::byAncestorFolderIds(const QMessageFolderFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   435 {

   436     QMessageFilter result;

   437     result.d_ptr->_key = QMailMessageKey::ancestorFolderIds(convert(filter), convert(cmp));

   438     return result;

   439 }

   440 

   441 QTM_END_NAMESPACE