16 */

    16 */

    17 

    17 

    18 #ifndef NMMESSAGEENVELOPE_CPP_

    18 #ifndef NMMESSAGEENVELOPE_CPP_

    19 #define NMMESSAGEENVELOPE_CPP_

    19 #define NMMESSAGEENVELOPE_CPP_

    20 

    20 

    21 #include "nmmessageenvelope.h"

    23 #include "nmmessageenvelope.h"

    22 

    24 

    23 /*!

    25 /*!

    24     Constructor of NmMessageEnvelopePrivate object

    26     Constructor of NmMessageEnvelopePrivate object

    25  */

    27  */

    27 :mMessageId(0),

    29 :mMessageId(0),

    28 mFolderId(0),

    30 mFolderId(0),

    29 mMailboxId(0),

    31 mMailboxId(0),

    30 mMessageFlags(0)

    32 mMessageFlags(0)

    31 {

    33 {

    32 }

    35 }

    33 

    36 

    34 /*!

    37 /*!

    35     Destructor of NmMessageEnvelopePrivate object

    38     Destructor of NmMessageEnvelopePrivate object

    36  */

    39  */

    37 NmMessageEnvelopePrivate::~NmMessageEnvelopePrivate()

    40 NmMessageEnvelopePrivate::~NmMessageEnvelopePrivate()

    38 {

    41 {

    39 }

    43 }

    40 

    44 

    41 NmMessageFlags NmMessageEnvelopePrivate::flags() const

    45 NmMessageFlags NmMessageEnvelopePrivate::flags() const

    42 {

    46 {

    43     return mMessageFlags;

    49     return mMessageFlags;

    44 }

    50 }

    45 

    51 

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

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

    47 {

    53 {

    48     if (set) {

    56     if (set) {

    49         mMessageFlags |= flags;

    57         mMessageFlags |= flags;

    50     } else {

    58     } else {

    51         mMessageFlags &= ~flags;

    59         mMessageFlags &= ~flags;

    52     }

    60     }

    53 }

    61 }

    54 

    62 

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

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

    56 {

    64 {

    57     if (set) {

    67     if (set) {

    58         mMessageFlags |= flag;

    68         mMessageFlags |= flag;

    59     } else {

    69     } else {

    60         mMessageFlags &= ~flag;

    70         mMessageFlags &= ~flag;

    61     }

    71     }

    62 }

    72 }

    63 

    73 

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

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

    65 {

    75 {

    66     return mMessageFlags.testFlag(flag);

    78     return mMessageFlags.testFlag(flag);

    67 }

    79 }

    68 

    80 

    69 

    81 

    70 /*!

    82 /*!

    77 /*!

    89 /*!

    78     Constructor

    90     Constructor

    79  */

    91  */

    80 NmMessageEnvelope::NmMessageEnvelope()

    92 NmMessageEnvelope::NmMessageEnvelope()

    81 {

    93 {

    82     d = new NmMessageEnvelopePrivate();

    96     d = new NmMessageEnvelopePrivate();

    83 }

    97 }

    84 

    98 

    85 /*!

    99 /*!

    86     Constructor with id

   100     Constructor with id

    87  */

   101  */

    88 NmMessageEnvelope::NmMessageEnvelope(const NmId &messageId)

   102 NmMessageEnvelope::NmMessageEnvelope(const NmId &messageId)

    89 {

   103 {

    90     d = new NmMessageEnvelopePrivate();

   106     d = new NmMessageEnvelopePrivate();

    91     d->mMessageId = messageId;

   107     d->mMessageId = messageId;

    92 }

   108 }

    93 

   109 

    94 /*!

   110 /*!

    95     Copy constructor

   111     Copy constructor

    96  */

   112  */

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

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

    98 {

   114 {

    99 }

   116 }

   100 

   117 

   101 /*!

   118 /*!

   102     Constructs new NmMessageEnvelope object from private envelope data

   119     Constructs new NmMessageEnvelope object from private envelope data

   103  */

   120  */

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

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

   105 {

   122 {

   106     d = nmPrivateMessageEnvelope;

   125     d = nmPrivateMessageEnvelope;

   107 }

   126 }

   108 

   127 

   109 /*!

   128 /*!

   110     Assignment operator

   129     Assignment operator

   111  */

   130  */

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

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

   113 {

   132 {

   114     if (this != &envelope) {

   135     if (this != &envelope) {

   115         d = envelope.d;

   136         d = envelope.d;

   116     }

   137     }

   117     return *this;

   138     return *this;

   118 }

   139 }

   122     Equal operator returns true if all values are same,

   143     Equal operator returns true if all values are same,

   123     function is case insensitive

   144     function is case insensitive

   124  */

   145  */

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

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

   126 {

   147 {

   127     bool ret = false;

   150     bool ret = false;

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

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

   129         && sender() == envelope.sender()

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

   130         && sentTime() == envelope.sentTime()

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

   131         && flags() == envelope.flags()

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

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

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

   141     function is case insensitive

   164     function is case insensitive

   142  */

   165  */

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

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

   144 {

   167 {

   145     return !(*this==envelope);

   170     return !(*this==envelope);

   146 }

   171 }

   147 

   172 

   148 /*!

   173 /*!

   149     Destructor

   174     Destructor

   150  */

   175  */

   151 NmMessageEnvelope::~NmMessageEnvelope()

   176 NmMessageEnvelope::~NmMessageEnvelope()

   152 {

   177 {

   153 }

   179 }

   154 

   180 

   155 /*!

   181 /*!

   156     Sets message id

   182     Sets message id

   157  */

   183  */

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

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

   159 {

   185 {

   160     d->mMessageId = messageId;

   188     d->mMessageId = messageId;

   161 }

   189 }

   162 

   190 

   163 /*!

   191 /*!

   164     Returns id of message

   192     Returns id of message

   165  */

   193  */

   166 NmId NmMessageEnvelope::messageId() const

   194 NmId NmMessageEnvelope::messageId() const

   167 {

   195 {

   168     return d->mMessageId;

   198     return d->mMessageId;

   169 }

   199 }

   170 

   200 

   171 /*!

   201 /*!

   172     Returns parent id of this envelope

   202     Returns parent id of this envelope

   173  */

   203  */

   174 NmId NmMessageEnvelope::folderId() const

   204 NmId NmMessageEnvelope::folderId() const

   175 {

   205 {

   176     return d->mFolderId;

   208     return d->mFolderId;

   177 }

   209 }

   178 

   210 

   179 /*!

   211 /*!

   180     Sets the parent id for this envelope

   212     Sets the parent id for this envelope

   181  */

   213  */

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

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

   183 {

   215 {

   184     d->mFolderId = folderId;

   218     d->mFolderId = folderId;

   185 }

   219 }

   186 

   220 

   187 /*!

   221 /*!

   188     Returns mailbox id of this envelope

   222     Returns mailbox id of this envelope

   189  */

   223  */

   190 NmId NmMessageEnvelope::mailboxId() const

   224 NmId NmMessageEnvelope::mailboxId() const

   191 {

   225 {

   192     return d->mMailboxId;

   228     return d->mMailboxId;

   193 }

   229 }

   194 

   230 

   195 /*!

   231 /*!

   196     Sets the mailbox id for this envelope

   232     Sets the mailbox id for this envelope

   197  */

   233  */

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

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

   199 {

   235 {

   200     d->mMailboxId = mailboxId;

   238     d->mMailboxId = mailboxId;

   201 }

   239 }

   202 

   240 

   203 /*!

   241 /*!

   204     Sets message subject

   242     Sets message subject

   205  */

   243  */

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

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

   207 {

   245 {

   208     d->mSubject = subject;

   248     d->mSubject = subject;

   209 }

   249 }

   210 

   250 

   211 /*!

   251 /*!

   212     Retruns subject string

   252     Retruns subject string

   213  */

   253  */

   214 QString NmMessageEnvelope::subject() const

   254 QString NmMessageEnvelope::subject() const

   215 {

   255 {

   216   return d->mSubject;

   258   return d->mSubject;

   217 }

   259 }

   218 

   260 

   219 /*!

   261 /*!

   220     Sets \a sender as a sender's address

   262     Sets \a sender as a sender's address

   221  */

   263  */

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

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

   223 {

   265 {

   224     d->mSender = sender;

   268     d->mSender = sender;

   225 }

   269 }

   226 

   270 

   227 /*!

   271 /*!

   228     Returns sender string

   272     Returns sender string

   229  */

   273  */

   230 NmAddress NmMessageEnvelope::sender() const

   274 NmAddress NmMessageEnvelope::sender() const

   231 {

   275 {

   232     return d->mSender;

   278     return d->mSender;

   233 }

   279 }

   234 

   280 

   235 /*!

   281 /*!

   236     Sets sent time to \a sentTime

   282     Sets sent time to \a sentTime

   237  */

   283  */

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

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

   239 {

   285 {

   240     d->mSentTime = sentTime;

   288     d->mSentTime = sentTime;

   241 }

   289 }

   242 

   290 

   243 /*!

   291 /*!

   244     Returns sent time, if not set returns null time

   292     Returns sent time, if not set returns null time

   245  */

   293  */

   246 QDateTime NmMessageEnvelope::sentTime() const

   294 QDateTime NmMessageEnvelope::sentTime() const

   247 {

   295 {

   248     return d->mSentTime;

   298     return d->mSentTime;

   249 }

   299 }

   250 

   300 

   251 /*!

   301 /*!

   252     Sets message contains attachments if \a hasAttachments is true

   302     Sets message contains attachments if \a hasAttachments is true

   253  */

   303  */

   254 void NmMessageEnvelope::setHasAttachments(bool hasAttachments)

   304 void NmMessageEnvelope::setHasAttachments(bool hasAttachments)

   255 {

   305 {

   256     d->setFlag(NmMessageFlagAttachments, hasAttachments);

   308     d->setFlag(NmMessageFlagAttachments, hasAttachments);

   257 }

   309 }

   258 

   310 

   259 /*!

   311 /*!

   260     Returns true if message contains attachments

   312     Returns true if message contains attachments

   261  */

   313  */

   262 bool NmMessageEnvelope::hasAttachments() const

   314 bool NmMessageEnvelope::hasAttachments() const

   263 {

   315 {

   264     return d->isFlagSet(NmMessageFlagAttachments);

   318     return d->isFlagSet(NmMessageFlagAttachments);

   265 }

   319 }

   266 

   320 

   267 /*!

   321 /*!

   268     Set message to read if \a read is true

   322     Set message to read if \a read is true

   269  */

   323  */

   270 void NmMessageEnvelope::setRead(bool read)

   324 void NmMessageEnvelope::setRead(bool read)

   271 {

   325 {

   272     d->setFlag(NmMessageFlagRead, read);

   328     d->setFlag(NmMessageFlagRead, read);

   273 }

   329 }

   274 

   330 

   275 /*!

   331 /*!

   276     Returns true if message is read

   332     Returns true if message is read

   277  */

   333  */

   278 bool NmMessageEnvelope::isRead() const

   334 bool NmMessageEnvelope::isRead() const

   279 {

   335 {

   280     return d->isFlagSet(NmMessageFlagRead);

   338     return d->isFlagSet(NmMessageFlagRead);

   281 }

   339 }

   282 

   340 

   283 /*!

   341 /*!

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

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

   285  */

   343  */

   286 void NmMessageEnvelope::setReplied(bool replyed)

   344 void NmMessageEnvelope::setReplied(bool replyed)

   287 {

   345 {

   288     d->setFlag(NmMessageFlagAnswered, replyed);

   348     d->setFlag(NmMessageFlagAnswered, replyed);

   289 }

   349 }

   290 

   350 

   291 /*!

   351 /*!

   292     Returns true if message is replied

   352     Returns true if message is replied

   293  */

   353  */

   294 bool NmMessageEnvelope::isReplied() const

   354 bool NmMessageEnvelope::isReplied() const

   295 {

   355 {

   296     return d->isFlagSet(NmMessageFlagAnswered);

   358     return d->isFlagSet(NmMessageFlagAnswered);

   297 }

   359 }

   298 

   360 

   299 /*!

   361 /*!

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

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

   301  */

   363  */

   302 void NmMessageEnvelope::setForwarded(bool forwarded)

   364 void NmMessageEnvelope::setForwarded(bool forwarded)

   303 {

   365 {

   304     d->setFlag(NmMessageFlagForwarded, forwarded);

   368     d->setFlag(NmMessageFlagForwarded, forwarded);

   305 }

   369 }

   306 

   370 

   307 /*!

   371 /*!

   308     Returns true if message is forwarded

   372     Returns true if message is forwarded

   309  */

   373  */

   310 bool NmMessageEnvelope::isForwarded() const

   374 bool NmMessageEnvelope::isForwarded() const

   311 {

   375 {

   312     return d->isFlagSet(NmMessageFlagForwarded);

   378     return d->isFlagSet(NmMessageFlagForwarded);

   313 }

   379 }

   314 

   380 

   315 /*!

   381 /*!

   316     Sets message priority

   382     Sets message priority

   317  */

   383  */

   318 void NmMessageEnvelope::setPriority(NmMessagePriority priority)

   384 void NmMessageEnvelope::setPriority(NmMessagePriority priority)

   319 {

   385 {

   320     if (priority == NmMessagePriorityLow) {

   388     if (priority == NmMessagePriorityLow) {

   321         d->setFlag(NmMessageFlagLow, true);

   389         d->setFlag(NmMessageFlagLow, true);

   322         d->setFlag(NmMessageFlagImportant, false);

   390         d->setFlag(NmMessageFlagImportant, false);

   323     }

   391     }

   324     else if (priority == NmMessagePriorityHigh) {

   392     else if (priority == NmMessagePriorityHigh) {

   334 /*!

   402 /*!

   335     Returns message priority

   403     Returns message priority

   336  */

   404  */

   337 NmMessagePriority NmMessageEnvelope::priority() const

   405 NmMessagePriority NmMessageEnvelope::priority() const

   338 {

   406 {

   339     NmMessagePriority ret = NmMessagePriorityNormal;

   409     NmMessagePriority ret = NmMessagePriorityNormal;

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

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

   341         ret = NmMessagePriorityHigh;

   411         ret = NmMessagePriorityHigh;

   342     }

   412     }

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

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

   349 /*!

   419 /*!

   350     Returns message flags

   420     Returns message flags

   351  */

   421  */

   352 NmMessageFlags NmMessageEnvelope::flags() const

   422 NmMessageFlags NmMessageEnvelope::flags() const

   353 {

   423 {

   354     return d->flags();

   426     return d->flags();

   355 }

   427 }

   356 

   428 

   357 /*!

   429 /*!

   358     Returns list of 'to recipients'

   430     Returns list of 'to recipients'

   359  */

   431  */

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

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

   361 {

   433 {

   362     return d->mToRecipients;

   436     return d->mToRecipients;

   363 }

   437 }

   364 

   438 

   365 /*!

   439 /*!

   366     Sets the list of 'to recipients'

   440     Sets the list of 'to recipients'

   367  */

   441  */

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

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

   369 {

   443 {

   370     clearToRecipients();

   446     clearToRecipients();

   371     d->mToRecipients = toRecipients;

   447     d->mToRecipients = toRecipients;

   372 }

   448 }

   373 

   449 

   374 /*!

   450 /*!

   375     Clears the list of 'to recipients'

   451     Clears the list of 'to recipients'

   376  */

   452  */

   377 void NmMessageEnvelope::clearToRecipients()

   453 void NmMessageEnvelope::clearToRecipients()

   378 {

   454 {

   379     d->mToRecipients.clear();

   457     d->mToRecipients.clear();

   380 }

   458 }

   381 

   459 

   382 /*!

   460 /*!

   383     Returns list of 'cc recipients'

   461     Returns list of 'cc recipients'

   384  */

   462  */

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

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

   386 {

   464 {

   387     return d->mCcRecipients;

   467     return d->mCcRecipients;

   388 }

   468 }

   389 

   469 

   390 /*!

   470 /*!

   391     Sets the list of 'cc recipients'

   471     Sets the list of 'cc recipients'

   392  */

   472  */

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

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

   394 {

   474 {

   395     clearCcRecipients();

   477     clearCcRecipients();

   396     d->mCcRecipients = ccRecipients;

   478     d->mCcRecipients = ccRecipients;

   397 }

   479 }

   398 

   480 

   399 /*!

   481 /*!

   400     Clears the list of 'cc recipients'

   482     Clears the list of 'cc recipients'

   401  */

   483  */

   402 void NmMessageEnvelope::clearCcRecipients()

   484 void NmMessageEnvelope::clearCcRecipients()

   403 {

   485 {

   404     d->mCcRecipients.clear();

   488     d->mCcRecipients.clear();

   405 }

   489 }

   406 

   490 

   407 /*!

   491 /*!

   408     Returns list of 'Bcc recipients'

   492     Returns list of 'Bcc recipients'

   409  */

   493  */

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

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

   411 {

   495 {

   412     return d->mBccRecipients;

   498     return d->mBccRecipients;

   413 }

   499 }

   414 

   500 

   415 /*!

   501 /*!

   416     Sets the list of 'Bcc recipients'

   502     Sets the list of 'Bcc recipients'

   417  */

   503  */

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

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

   419 {

   505 {

   420     clearBccRecipients();

   508     clearBccRecipients();

   421     d->mBccRecipients = bccRecipients;

   509     d->mBccRecipients = bccRecipients;

   422 }

   510 }

   423 

   511 

   424 /*!

   512 /*!

   425     Clears the list of 'bcc recipients'

   513     Clears the list of 'bcc recipients'

   426  */

   514  */

   427 void NmMessageEnvelope::clearBccRecipients()

   515 void NmMessageEnvelope::clearBccRecipients()

   428 {

   516 {

   429     d->mBccRecipients.clear();

   519     d->mBccRecipients.clear();

   430 }

   520 }

   431 

   521 

   432 #endif /* NMMESSAGEENVELOPE_CPP_ */

   522 #endif /* NMMESSAGEENVELOPE_CPP_ */