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

     2 **

     3 ** Copyright (C) 2010 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 "qmessagesortorder.h"

    42 #include "qmessagesortorder_p.h"

    43 #include "qmessage_p.h"

    44 

    45 #define COMPARE(x,y) \

    46 if ((x) < (y)) { \

    47     return true; \

    48 } else if ((y) < (x)) { \

    49     return false; \

    50 } else { \

    51     continue; \

    52 }

    53 

    54 

    55 QTM_BEGIN_NAMESPACE

    56 

    57 QMessageSortOrderPrivate::QMessageSortOrderPrivate(QMessageSortOrder *sortOrder)

    58  : q_ptr(sortOrder),

    59    _valid(true)

    60 {

    61 }

    62 

    63 QMessageSortOrder QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Field field, Qt::SortOrder order)

    64 {

    65     QMessageSortOrder result;

    66     QPair<QMessageSortOrderPrivate::Field, Qt::SortOrder> fieldOrder(field, order);

    67     result.d_ptr->_fieldOrderList.append(fieldOrder);

    68     return result;

    69 }

    70 

    71 QMessageSortOrderPrivate* QMessageSortOrderPrivate::implementation(const QMessageSortOrder &sortOrder)

    72 

    73 {

    74     return sortOrder.d_ptr;

    75 }

    76 

    77 bool QMessageSortOrderPrivate::lessThan(const QMessageSortOrder &sortOrder,

    78                                        const QMessage &message1, const QMessage &message2)

    79 {

    80     QMessageSortOrderPrivate *d(sortOrder.d_ptr);

    81 

    82     QList<QPair<Field, Qt::SortOrder> >::iterator it(d->_fieldOrderList.begin());

    83     while (it != d->_fieldOrderList.end()) {

    84         Field field((*it).first);

    85         Qt::SortOrder order((*it).second);

    86         ++it;

    87 

    88         const QMessage *left;

    89         const QMessage *right;

    90         if (order == Qt::AscendingOrder) {

    91             left = &message1;

    92             right = &message2; 

    93         } else {

    94             left = &message2;

    95             right = &message1; 

    96         }

    97 

    98         switch (field)

    99         {

   100         case Type: COMPARE(left->type(), right->type())

   101         case Sender: COMPARE(QMessagePrivate::senderName(*left), QMessagePrivate::senderName(*right)); 

   102         case Recipients: {

   103             QString leftStr;

   104             QString rightStr;

   105             foreach (QMessageAddress a, left->to() + left->cc() + left->bcc()) {

   106                 leftStr.append(a.addressee() + ";");

   107             }

   108             foreach (QMessageAddress a, right->to() + right->cc() + right->bcc()) {

   109                 rightStr.append(a.addressee() + ";");

   110             }

   111             COMPARE(leftStr, rightStr)

   112         }

   113         case Subject: COMPARE(left->subject(), right->subject())

   114         case TimeStamp: COMPARE(left->date(), right->date())

   115         case ReceptionTimeStamp: COMPARE(left->receivedDate(), right->receivedDate())

   116         case Read: COMPARE(left->status() & QMessage::Read, right->status() & QMessage::Read)

   117         case HasAttachments: COMPARE(left->status() & QMessage::HasAttachments, right->status() & QMessage::HasAttachments)

   118         case Incoming: COMPARE(left->status() & QMessage::Incoming, right->status() & QMessage::Incoming)

   119         case Removed: COMPARE(left->status() & QMessage::Removed, right->status() & QMessage::Removed)

   120         case Priority: COMPARE(right->priority(), left->priority())

   121         case Size: COMPARE(left->size(), right->size())

   122         }

   123     }

   124     return false; // equality

   125 }

   126 

   127 QMessageSortOrder::QMessageSortOrder()

   128  : d_ptr(new QMessageSortOrderPrivate(this))

   129 {

   130 }

   131 

   132 QMessageSortOrder::QMessageSortOrder(const QMessageSortOrder &other)

   133  : d_ptr(new QMessageSortOrderPrivate(this))

   134 {

   135 	this->operator=(other);

   136 }

   137 

   138 QMessageSortOrder::~QMessageSortOrder()

   139 {

   140 	delete d_ptr;

   141 	d_ptr = 0;

   142 }

   143 

   144 QMessageSortOrder& QMessageSortOrder::operator=(const QMessageSortOrder& other)

   145 {

   146 	if (&other != this) {

   147 		d_ptr->_fieldOrderList = other.d_ptr->_fieldOrderList;

   148 		d_ptr->_valid = other.d_ptr->_valid;

   149 	}

   150 	

   151 	return *this;

   152 }

   153 

   154 bool QMessageSortOrder::isEmpty() const

   155 {

   156 	return d_ptr->_fieldOrderList.isEmpty();

   157 }

   158 

   159 bool QMessageSortOrder::isSupported() const

   160 {

   161 	return d_ptr->_valid;

   162 }

   163 

   164 QMessageSortOrder QMessageSortOrder::operator+(const QMessageSortOrder& other) const

   165 {

   166 	QMessageSortOrder sum;

   167 	sum.d_ptr->_fieldOrderList = d_ptr->_fieldOrderList + other.d_ptr->_fieldOrderList;

   168 	return sum;

   169 }

   170 

   171 QMessageSortOrder& QMessageSortOrder::operator+=(const QMessageSortOrder& other)

   172 {

   173 	if (&other == this) {

   174 		 return *this;

   175 	}

   176 	d_ptr->_fieldOrderList += other.d_ptr->_fieldOrderList;

   177 	return *this;

   178 }

   179 

   180 bool QMessageSortOrder::operator==(const QMessageSortOrder& other) const

   181 {

   182 	return (d_ptr->_fieldOrderList == other.d_ptr->_fieldOrderList);

   183 }

   184 

   185 QMessageSortOrder QMessageSortOrder::byType(Qt::SortOrder order)

   186 {

   187 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Type, order));

   188 	return result;

   189 }

   190 

   191 QMessageSortOrder QMessageSortOrder::bySender(Qt::SortOrder order)

   192 {

   193 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Sender, order));

   194 	return result;

   195 }

   196 

   197 QMessageSortOrder QMessageSortOrder::byRecipients(Qt::SortOrder order)

   198 {

   199 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Recipients, order));

   200 	return result;

   201 }

   202 

   203 QMessageSortOrder QMessageSortOrder::bySubject(Qt::SortOrder order)

   204 {

   205 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Subject, order));

   206 	return result;

   207 }

   208 

   209 QMessageSortOrder QMessageSortOrder::byTimeStamp(Qt::SortOrder order)

   210 {

   211 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::TimeStamp, order));

   212 	return result;

   213 }

   214 

   215 QMessageSortOrder QMessageSortOrder::byReceptionTimeStamp(Qt::SortOrder order)

   216 {

   217 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::ReceptionTimeStamp, order));

   218 	return result;

   219 }

   220 

   221 QMessageSortOrder QMessageSortOrder::byStatus(QMessage::Status flag, Qt::SortOrder order)

   222 {

   223 	QMessageSortOrder result;

   224 	switch (flag) {

   225 	case QMessage::Read:

   226 		result = QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Read, order);

   227 		break;

   228 	case QMessage::HasAttachments:

   229 		result = QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::HasAttachments, order);

   230 		break;

   231 	case QMessage::Incoming:

   232 		result = QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Incoming, order);

   233 		break;

   234 	case QMessage::Removed:

   235 		result = QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Removed, order);

   236 		break;

   237 	}

   238 	return result;

   239 }

   240 

   241 QMessageSortOrder QMessageSortOrder::byPriority(Qt::SortOrder order)

   242 {

   243 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Priority, order));

   244 	return result;

   245 }

   246 

   247 QMessageSortOrder QMessageSortOrder::bySize(Qt::SortOrder order)

   248 {

   249 	QMessageSortOrder result(QMessageSortOrderPrivate::from(QMessageSortOrderPrivate::Size, order));

   250 	return result;

   251 }

   252 

   253 QTM_END_NAMESPACE