1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #ifndef NMMESSAGEENVELOPE_CPP_

    19 #define NMMESSAGEENVELOPE_CPP_

    20 

    21 #include "emailtrace.h"

    22 

    23 #include "nmmessageenvelope.h"

    24 

    25 /*!

    26     Constructor of NmMessageEnvelopePrivate object

    27  */

    28 NmMessageEnvelopePrivate::NmMessageEnvelopePrivate()

    29 :mMessageId(0),

    30 mFolderId(0),

    31 mMailboxId(0),

    32 mMessageFlags(0)

    33 {

    34     NM_FUNCTION;

    35 }

    36 

    37 /*!

    38     Destructor of NmMessageEnvelopePrivate object

    39  */

    40 NmMessageEnvelopePrivate::~NmMessageEnvelopePrivate()

    41 {

    42     NM_FUNCTION;

    43 }

    44 

    45 NmMessageFlags NmMessageEnvelopePrivate::flags() const

    46 {

    47     NM_FUNCTION;

    48     

    49     return mMessageFlags;

    50 }

    51 

    52 void NmMessageEnvelopePrivate::setFlags(const NmMessageFlags flags, bool set)

    53 {

    54     NM_FUNCTION;

    55     

    56     if (set) {

    57         mMessageFlags |= flags;

    58     } else {

    59         mMessageFlags &= ~flags;

    60     }

    61 }

    62 

    63 void NmMessageEnvelopePrivate::setFlag(const NmMessageFlag flag, bool set)

    64 {

    65     NM_FUNCTION;

    66     

    67     if (set) {

    68         mMessageFlags |= flag;

    69     } else {

    70         mMessageFlags &= ~flag;

    71     }

    72 }

    73 

    74 bool NmMessageEnvelopePrivate::isFlagSet(const NmMessageFlag flag) const

    75 {

    76     NM_FUNCTION;

    77     

    78     return mMessageFlags.testFlag(flag);

    79 }

    80 

    81 

    82 /*!

    83     \class NmMessageEnvelope

    84     \brief Represents model for message data that is needed to show one message on

    85            message list

    86  */

    87 

    88 

    89 /*!

    90     Constructor

    91  */

    92 NmMessageEnvelope::NmMessageEnvelope()

    93 {

    94     NM_FUNCTION;

    95     

    96     d = new NmMessageEnvelopePrivate();

    97 }

    98 

    99 /*!

   100     Constructor with id

   101  */

   102 NmMessageEnvelope::NmMessageEnvelope(const NmId &messageId)

   103 {

   104     NM_FUNCTION;

   105     

   106     d = new NmMessageEnvelopePrivate();

   107     d->mMessageId = messageId;

   108 }

   109 

   110 /*!

   111     Copy constructor

   112  */

   113 NmMessageEnvelope::NmMessageEnvelope(const NmMessageEnvelope &envelope):d(envelope.d)

   114 {

   115     NM_FUNCTION;

   116 }

   117 

   118 /*!

   119     Constructs new NmMessageEnvelope object from private envelope data

   120  */

   121 NmMessageEnvelope::NmMessageEnvelope(QExplicitlySharedDataPointer<NmMessageEnvelopePrivate> nmPrivateMessageEnvelope)

   122 {

   123     NM_FUNCTION;

   124     

   125     d = nmPrivateMessageEnvelope;

   126 }

   127 

   128 /*!

   129     Assignment operator

   130  */

   131 NmMessageEnvelope &NmMessageEnvelope::operator=(const NmMessageEnvelope &envelope)

   132 {

   133     NM_FUNCTION;

   134     

   135     if (this != &envelope) {

   136         d = envelope.d;

   137     }

   138     return *this;

   139 }

   140 

   141 

   142 /*!

   143     Equal operator returns true if all values are same,

   144     function is case insensitive

   145  */

   146 bool NmMessageEnvelope::operator==(const NmMessageEnvelope &envelope) const

   147 {

   148     NM_FUNCTION;

   149     

   150     bool ret = false;

   151     if (0 == subject().compare(envelope.subject(), Qt::CaseInsensitive)

   152         && sender() == envelope.sender()

   153         && sentTime() == envelope.sentTime()

   154         && flags() == envelope.flags()

   155         && mailboxId() == envelope.mailboxId()

   156         && folderId() == envelope.folderId()) {

   157         ret = true;

   158     }

   159     return ret;

   160 }

   161 

   162 /*!

   163     Not equal operator return true if at least one value in not equal,

   164     function is case insensitive

   165  */

   166 bool NmMessageEnvelope::operator!=(const NmMessageEnvelope &envelope) const

   167 {

   168     NM_FUNCTION;

   169     

   170     return !(*this==envelope);

   171 }

   172 

   173 /*!

   174     Destructor

   175  */

   176 NmMessageEnvelope::~NmMessageEnvelope()

   177 {

   178     NM_FUNCTION;

   179 }

   180 

   181 /*!

   182     Sets message id

   183  */

   184 void NmMessageEnvelope::setMessageId(const NmId &messageId)

   185 {

   186     NM_FUNCTION;

   187     

   188     d->mMessageId = messageId;

   189 }

   190 

   191 /*!

   192     Returns id of message

   193  */

   194 NmId NmMessageEnvelope::messageId() const

   195 {

   196     NM_FUNCTION;

   197     

   198     return d->mMessageId;

   199 }

   200 

   201 /*!

   202     Returns parent id of this envelope

   203  */

   204 NmId NmMessageEnvelope::folderId() const

   205 {

   206     NM_FUNCTION;

   207     

   208     return d->mFolderId;

   209 }

   210 

   211 /*!

   212     Sets the parent id for this envelope

   213  */

   214 void NmMessageEnvelope::setFolderId(const NmId &folderId)

   215 {

   216     NM_FUNCTION;

   217     

   218     d->mFolderId = folderId;

   219 }

   220 

   221 /*!

   222     Returns mailbox id of this envelope

   223  */

   224 NmId NmMessageEnvelope::mailboxId() const

   225 {

   226     NM_FUNCTION;

   227     

   228     return d->mMailboxId;

   229 }

   230 

   231 /*!

   232     Sets the mailbox id for this envelope

   233  */

   234 void NmMessageEnvelope::setMailboxId(const NmId &mailboxId)

   235 {

   236     NM_FUNCTION;

   237     

   238     d->mMailboxId = mailboxId;

   239 }

   240 

   241 /*!

   242     Sets message subject

   243  */

   244 void NmMessageEnvelope::setSubject(const QString &subject)

   245 {

   246     NM_FUNCTION;

   247     

   248     d->mSubject = subject;

   249 }

   250 

   251 /*!

   252     Retruns subject string

   253  */

   254 QString NmMessageEnvelope::subject() const

   255 {

   256     NM_FUNCTION;

   257     

   258   return d->mSubject;

   259 }

   260 

   261 /*!

   262     Sets \a sender as a sender's address

   263  */

   264 void NmMessageEnvelope::setSender(const NmAddress &sender)

   265 {

   266     NM_FUNCTION;

   267     

   268     d->mSender = sender;

   269 }

   270 

   271 /*!

   272     Returns sender string

   273  */

   274 NmAddress NmMessageEnvelope::sender() const

   275 {

   276     NM_FUNCTION;

   277     

   278     return d->mSender;

   279 }

   280 

   281 /*!

   282     Sets sent time to \a sentTime

   283  */

   284 void NmMessageEnvelope::setSentTime(const QDateTime &sentTime)

   285 {

   286     NM_FUNCTION;

   287     

   288     d->mSentTime = sentTime;

   289 }

   290 

   291 /*!

   292     Returns sent time, if not set returns null time

   293  */

   294 QDateTime NmMessageEnvelope::sentTime() const

   295 {

   296     NM_FUNCTION;

   297     

   298     return d->mSentTime;

   299 }

   300 

   301 /*!

   302     Sets message contains attachments if \a hasAttachments is true

   303  */

   304 void NmMessageEnvelope::setHasAttachments(bool hasAttachments)

   305 {

   306     NM_FUNCTION;

   307     

   308     d->setFlag(NmMessageFlagAttachments, hasAttachments);

   309 }

   310 

   311 /*!

   312     Returns true if message contains attachments

   313  */

   314 bool NmMessageEnvelope::hasAttachments() const

   315 {

   316     NM_FUNCTION;

   317     

   318     return d->isFlagSet(NmMessageFlagAttachments);

   319 }

   320 

   321 /*!

   322     Set message to read if \a read is true

   323  */

   324 void NmMessageEnvelope::setRead(bool read)

   325 {

   326     NM_FUNCTION;

   327     

   328     d->setFlag(NmMessageFlagRead, read);

   329 }

   330 

   331 /*!

   332     Returns true if message is read

   333  */

   334 bool NmMessageEnvelope::isRead() const

   335 {

   336     NM_FUNCTION;

   337     

   338     return d->isFlagSet(NmMessageFlagRead);

   339 }

   340 

   341 /*!

   342     Sets message to replied state if \a replyed is true

   343  */

   344 void NmMessageEnvelope::setReplied(bool replyed)

   345 {

   346     NM_FUNCTION;

   347     

   348     d->setFlag(NmMessageFlagAnswered, replyed);

   349 }

   350 

   351 /*!

   352     Returns true if message is replied

   353  */

   354 bool NmMessageEnvelope::isReplied() const

   355 {

   356     NM_FUNCTION;

   357     

   358     return d->isFlagSet(NmMessageFlagAnswered);

   359 }

   360 

   361 /*!

   362     Sets message to forwarded state if \a replyed is true

   363  */

   364 void NmMessageEnvelope::setForwarded(bool forwarded)

   365 {

   366     NM_FUNCTION;

   367     

   368     d->setFlag(NmMessageFlagForwarded, forwarded);

   369 }

   370 

   371 /*!

   372     Returns true if message is forwarded

   373  */

   374 bool NmMessageEnvelope::isForwarded() const

   375 {

   376     NM_FUNCTION;

   377     

   378     return d->isFlagSet(NmMessageFlagForwarded);

   379 }

   380 

   381 /*!

   382     Sets message priority

   383  */

   384 void NmMessageEnvelope::setPriority(NmMessagePriority priority)

   385 {

   386     NM_FUNCTION;

   387     

   388     if (priority == NmMessagePriorityLow) {

   389         d->setFlag(NmMessageFlagLow, true);

   390         d->setFlag(NmMessageFlagImportant, false);

   391     }

   392     else if (priority == NmMessagePriorityHigh) {

   393         d->setFlag(NmMessageFlagLow, false);

   394         d->setFlag(NmMessageFlagImportant, true);

   395     }

   396     else {

   397         d->setFlag(NmMessageFlagLow, false);

   398         d->setFlag(NmMessageFlagImportant, false);

   399     }

   400 }

   401 

   402 /*!

   403     Returns message priority

   404  */

   405 NmMessagePriority NmMessageEnvelope::priority() const

   406 {

   407     NM_FUNCTION;

   408     

   409     NmMessagePriority ret = NmMessagePriorityNormal;

   410     if (d->isFlagSet(NmMessageFlagImportant)) {

   411         ret = NmMessagePriorityHigh;

   412     }

   413     else if (d->isFlagSet(NmMessageFlagLow)) {

   414         ret = NmMessagePriorityLow;

   415     }

   416     return ret;

   417 }

   418 

   419 /*!

   420     Returns message flags

   421  */

   422 NmMessageFlags NmMessageEnvelope::flags() const

   423 {

   424     NM_FUNCTION;

   425     

   426     return d->flags();

   427 }

   428 

   429 /*!

   430     Returns list of 'to recipients'

   431  */

   432 QList<NmAddress>& NmMessageEnvelope::toRecipients() const

   433 {

   434     NM_FUNCTION;

   435     

   436     return d->mToRecipients;

   437 }

   438 

   439 /*!

   440     Sets the list of 'to recipients'

   441  */

   442 void NmMessageEnvelope::setToRecipients(QList<NmAddress> toRecipients)

   443 {

   444     NM_FUNCTION;

   445     

   446     clearToRecipients();

   447     d->mToRecipients = toRecipients;

   448 }

   449 

   450 /*!

   451     Clears the list of 'to recipients'

   452  */

   453 void NmMessageEnvelope::clearToRecipients()

   454 {

   455     NM_FUNCTION;

   456     

   457     d->mToRecipients.clear();

   458 }

   459 

   460 /*!

   461     Returns list of 'cc recipients'

   462  */

   463 QList<NmAddress>& NmMessageEnvelope::ccRecipients() const

   464 {

   465     NM_FUNCTION;

   466     

   467     return d->mCcRecipients;

   468 }

   469 

   470 /*!

   471     Sets the list of 'cc recipients'

   472  */

   473 void NmMessageEnvelope::setCcRecipients(QList<NmAddress> ccRecipients)

   474 {

   475     NM_FUNCTION;

   476     

   477     clearCcRecipients();

   478     d->mCcRecipients = ccRecipients;

   479 }

   480 

   481 /*!

   482     Clears the list of 'cc recipients'

   483  */

   484 void NmMessageEnvelope::clearCcRecipients()

   485 {

   486     NM_FUNCTION;

   487     

   488     d->mCcRecipients.clear();

   489 }

   490 

   491 /*!

   492     Returns list of 'Bcc recipients'

   493  */

   494 QList<NmAddress>& NmMessageEnvelope::bccRecipients() const

   495 {

   496     NM_FUNCTION;

   497     

   498     return d->mBccRecipients;

   499 }

   500 

   501 /*!

   502     Sets the list of 'Bcc recipients'

   503  */

   504 void NmMessageEnvelope::setBccRecipients(QList<NmAddress> bccRecipients)

   505 {

   506     NM_FUNCTION;

   507     

   508     clearBccRecipients();

   509     d->mBccRecipients = bccRecipients;

   510 }

   511 

   512 /*!

   513     Clears the list of 'bcc recipients'

   514  */

   515 void NmMessageEnvelope::clearBccRecipients()

   516 {

   517     NM_FUNCTION;

   518     

   519     d->mBccRecipients.clear();

   520 }

   521 

   522 #endif /* NMMESSAGEENVELOPE_CPP_ */