messagecore/messagestatus.cpp

   1 /*
   2     This file is part of KDEPIM.
   3     Copyright (c) 2003 Andreas Gungl <a.gungl@gmx.de>
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public License
  16     along with this library; see the file COPYING.LIB.  If not, write to the
  17     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18     Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include "messagestatus.h"
  22
  23 #include <KDE/KDebug>
  24 #include <QString>
  25
  26 using namespace KPIM;
  27
  28 /** The message status format. These can be or'd together.
  29     Note, that the KMMsgStatusIgnored implies the
  30     status to be Read even if the flags are set
  31     to Unread or New. This is done in isRead()
  32     and related getters. So we can preserve the state
  33     when switching a thread to Ignored and back. */
  34 enum MsgStatus {
  35     KMMsgStatusUnknown =           0x00000000,
  36     KMMsgStatusNew =               0x00000001,
  37     KMMsgStatusUnread =            0x00000002,
  38     KMMsgStatusRead =              0x00000004,
  39     KMMsgStatusOld =               0x00000008,
  40     KMMsgStatusDeleted =           0x00000010,
  41     KMMsgStatusReplied =           0x00000020,
  42     KMMsgStatusForwarded =         0x00000040,
  43     KMMsgStatusQueued =            0x00000080,
  44     KMMsgStatusSent =              0x00000100,
  45     KMMsgStatusFlag =              0x00000200, // flag means important
  46     KMMsgStatusWatched =           0x00000400,
  47     KMMsgStatusIgnored =           0x00000800, // forces isRead()
  48     KMMsgStatusToAct =             0x00001000,
  49     KMMsgStatusSpam =              0x00002000,
  50     KMMsgStatusHam =               0x00004000,
  51     KMMsgStatusHasAttach =         0x00008000
  52 };
  53
  54 MessageStatus::MessageStatus()
  55 {
  56   mStatus = KMMsgStatusUnknown;
  57 }
  58
  59 MessageStatus &MessageStatus::operator = ( const MessageStatus &other )
  60 {
  61   mStatus = other.mStatus;
  62   return *this;
  63 }
  64
  65 bool MessageStatus::operator == ( const MessageStatus &other ) const
  66 {
  67   return ( mStatus == other.mStatus );
  68 }
  69
  70 bool MessageStatus::operator != ( const MessageStatus &other ) const
  71 {
  72   return ( mStatus != other.mStatus );
  73 }
  74
  75 bool MessageStatus::operator & ( const MessageStatus &other ) const
  76 {
  77   return ( mStatus & other.mStatus );
  78 }
  79
  80 void MessageStatus::clear()
  81 {
  82   mStatus = KMMsgStatusUnknown;
  83 }
  84
  85 void MessageStatus::set( const MessageStatus &other )
  86 {
  87   // Those stati are exclusive, but we have to lock at the
  88   // internal representation because Ignored can manipulate
  89   // the result of the getter methods.
  90   if ( other.mStatus & KMMsgStatusNew ) {
  91     setNew();
  92   }
  93   if ( other.mStatus & KMMsgStatusUnread ) {
  94     setUnread();
  95   }
  96   if ( other.mStatus & KMMsgStatusRead ) {
  97     setRead();
  98   }
  99   if ( other.mStatus & KMMsgStatusOld ) {
 100     setOld();
 101   }
 102
 103   if ( other.isDeleted() ) {
 104     setDeleted();
 105   }
 106   if ( other.isReplied() ) {
 107     setReplied();
 108   }
 109   if ( other.isForwarded() ) {
 110     setForwarded();
 111   }
 112   if ( other.isQueued() ) {
 113     setQueued();
 114   }
 115   if ( other.isSent() ) {
 116     setSent();
 117   }
 118   if ( other.isImportant() ) {
 119     setImportant();
 120   }
 121
 122   if ( other.isWatched() ) {
 123     setWatched();
 124   }
 125   if ( other.isIgnored() ) {
 126     setIgnored();
 127   }
 128   if ( other.isToAct() ) {
 129     setToAct();
 130   }
 131   if ( other.isSpam() ) {
 132     setSpam();
 133   }
 134   if ( other.isHam() ) {
 135     setHam();
 136   }
 137   if ( other.hasAttachment() ) {
 138     setHasAttachment();
 139   }
 140 }
 141
 142 void MessageStatus::toggle( const MessageStatus &other )
 143 {
 144   if ( other.isDeleted() ) {
 145     setDeleted( !( mStatus & KMMsgStatusDeleted ) );
 146   }
 147   if ( other.isReplied() ) {
 148     setReplied( !( mStatus & KMMsgStatusReplied ) );
 149   }
 150   if ( other.isForwarded() ) {
 151     setForwarded( !( mStatus & KMMsgStatusForwarded ) );
 152   }
 153   if ( other.isQueued() ) {
 154     setQueued( !( mStatus & KMMsgStatusQueued ) );
 155   }
 156   if ( other.isSent() ) {
 157     setSent( !( mStatus & KMMsgStatusSent ) );
 158   }
 159   if ( other.isImportant() ) {
 160     setImportant( !( mStatus & KMMsgStatusFlag ) );
 161   }
 162
 163   if ( other.isWatched() ) {
 164     setWatched( !( mStatus & KMMsgStatusWatched ) );
 165   }
 166   if ( other.isIgnored() ) {
 167     setIgnored( !( mStatus & KMMsgStatusIgnored ) );
 168   }
 169   if ( other.isToAct() ) {
 170     setToAct( !( mStatus & KMMsgStatusToAct ) );
 171   }
 172   if ( other.isSpam() ) {
 173     setSpam( !( mStatus & KMMsgStatusSpam ) );
 174   }
 175   if ( other.isHam() ) {
 176     setHam( !( mStatus & KMMsgStatusHam ) );
 177   }
 178   if ( other.hasAttachment() ) {
 179     setHasAttachment( !( mStatus & KMMsgStatusHasAttach ) );
 180   }
 181 }
 182
 183 bool MessageStatus::isOfUnknownStatus() const
 184 {
 185   return ( mStatus == KMMsgStatusUnknown );
 186 }
 187
 188 bool MessageStatus::isNew() const
 189 {
 190   return ( mStatus & KMMsgStatusNew && !( mStatus & KMMsgStatusIgnored ) );
 191 }
 192
 193 bool MessageStatus::isUnread() const
 194 {
 195   return ( mStatus & KMMsgStatusUnread && !( mStatus & KMMsgStatusIgnored ) );
 196 }
 197
 198 bool MessageStatus::isRead() const
 199 {
 200   return ( mStatus & KMMsgStatusRead || mStatus & KMMsgStatusIgnored );
 201 }
 202
 203 bool MessageStatus::isOld() const
 204 {
 205   return ( mStatus & KMMsgStatusOld );
 206 }
 207
 208 bool MessageStatus::isDeleted() const
 209 {
 210   return ( mStatus & KMMsgStatusDeleted );
 211 }
 212
 213 bool MessageStatus::isReplied() const
 214 {
 215   return ( mStatus & KMMsgStatusReplied );
 216 }
 217
 218 bool MessageStatus::isForwarded() const
 219 {
 220   return ( mStatus & KMMsgStatusForwarded );
 221 }
 222
 223 bool MessageStatus::isQueued() const
 224 {
 225   return ( mStatus & KMMsgStatusQueued );
 226 }
 227
 228 bool MessageStatus::isSent() const
 229 {
 230    return ( mStatus & KMMsgStatusSent );
 231 }
 232
 233 bool MessageStatus::isImportant() const
 234 {
 235   return ( mStatus & KMMsgStatusFlag );
 236 }
 237
 238 bool MessageStatus::isWatched() const
 239 {
 240   return ( mStatus & KMMsgStatusWatched );
 241 }
 242
 243 bool MessageStatus::isIgnored() const
 244 {
 245   return ( mStatus & KMMsgStatusIgnored );
 246 }
 247
 248 bool MessageStatus::isToAct() const
 249 {
 250   return ( mStatus & KMMsgStatusToAct );
 251 }
 252
 253 bool MessageStatus::isSpam() const
 254 {
 255   return ( mStatus & KMMsgStatusSpam );
 256 }
 257
 258 bool MessageStatus::isHam() const
 259 {
 260   return ( mStatus & KMMsgStatusHam );
 261 }
 262
 263 bool MessageStatus::hasAttachment() const
 264 {
 265   return ( mStatus & KMMsgStatusHasAttach );
 266 }
 267
 268 void MessageStatus::setNew()
 269 {
 270   // new overrides old and read
 271   mStatus &= ~KMMsgStatusOld;
 272   mStatus &= ~KMMsgStatusRead;
 273   mStatus &= ~KMMsgStatusUnread;
 274   mStatus |= KMMsgStatusNew;
 275 }
 276
 277 void MessageStatus::setUnread()
 278 {
 279   // unread overrides read
 280   mStatus &= ~KMMsgStatusOld;
 281   mStatus &= ~KMMsgStatusRead;
 282   mStatus &= ~KMMsgStatusNew;
 283   mStatus |= KMMsgStatusUnread;
 284 }
 285
 286 void MessageStatus::setRead()
 287 {
 288   // Unset unread and new, set read
 289   mStatus &= ~KMMsgStatusUnread;
 290   mStatus &= ~KMMsgStatusNew;
 291   mStatus |= KMMsgStatusRead;
 292 }
 293
 294 void MessageStatus::setOld()
 295 {
 296   // old can't be new or unread
 297   mStatus &= ~KMMsgStatusNew;
 298   mStatus &= ~KMMsgStatusUnread;
 299   mStatus |= KMMsgStatusOld;
 300 }
 301
 302 void MessageStatus::setDeleted( bool deleted )
 303 {
 304   if ( deleted ) {
 305     mStatus |= KMMsgStatusDeleted;
 306   } else {
 307     mStatus &= ~KMMsgStatusDeleted;
 308   }
 309 }
 310
 311 void MessageStatus::setReplied( bool replied )
 312 {
 313   if ( replied ) {
 314     mStatus |= KMMsgStatusReplied;
 315   } else {
 316     mStatus &= ~KMMsgStatusReplied;
 317   }
 318 }
 319
 320 void MessageStatus::setForwarded( bool forwarded )
 321 {
 322   if ( forwarded ) {
 323     mStatus |= KMMsgStatusForwarded;
 324   } else {
 325     mStatus &= ~KMMsgStatusForwarded;
 326   }
 327 }
 328
 329 void MessageStatus::setQueued( bool queued )
 330 {
 331   if ( queued ) {
 332     mStatus |= KMMsgStatusQueued;
 333   } else {
 334     mStatus &= ~KMMsgStatusQueued;
 335   }
 336 }
 337
 338 void MessageStatus::setSent( bool sent )
 339 {
 340   if ( sent ) {
 341     mStatus &= ~KMMsgStatusQueued;
 342     // FIXME to be discussed if sent messages are Read
 343     mStatus &= ~KMMsgStatusUnread;
 344     mStatus &= ~KMMsgStatusNew;
 345     mStatus |= KMMsgStatusSent;
 346   } else {
 347     mStatus &= ~KMMsgStatusSent;
 348   }
 349 }
 350
 351 void MessageStatus::setImportant( bool important )
 352 {
 353   if ( important ) {
 354     mStatus |= KMMsgStatusFlag;
 355   } else {
 356     mStatus &= ~KMMsgStatusFlag;
 357   }
 358 }
 359
 360 // Watched and ignored are mutually exclusive
 361 void MessageStatus::setWatched( bool watched )
 362 {
 363   if ( watched ) {
 364     mStatus &= ~KMMsgStatusIgnored;
 365     mStatus |= KMMsgStatusWatched;
 366   } else {
 367     mStatus &= ~KMMsgStatusWatched;
 368   }
 369 }
 370
 371 void MessageStatus::setIgnored( bool ignored )
 372 {
 373   if ( ignored ) {
 374     mStatus &= ~KMMsgStatusWatched;
 375     mStatus |= KMMsgStatusIgnored;
 376   } else {
 377     mStatus &= ~KMMsgStatusIgnored;
 378   }
 379 }
 380
 381 void MessageStatus::setToAct( bool toAct )
 382 {
 383   if ( toAct ) {
 384     mStatus |= KMMsgStatusToAct;
 385   } else {
 386     mStatus &= ~KMMsgStatusToAct;
 387   }
 388 }
 389
 390 // Ham and Spam are mutually exclusive
 391 void MessageStatus::setSpam( bool spam )
 392 {
 393   if ( spam ) {
 394     mStatus &= ~KMMsgStatusHam;
 395     mStatus |= KMMsgStatusSpam;
 396   } else {
 397     mStatus &= ~KMMsgStatusSpam;
 398   }
 399 }
 400
 401 void MessageStatus::setHam( bool ham )
 402 {
 403   if ( ham ) {
 404     mStatus &= ~KMMsgStatusSpam;
 405     mStatus |= KMMsgStatusHam;
 406   } else {
 407     mStatus &= ~KMMsgStatusHam;
 408   }
 409 }
 410
 411 void MessageStatus::setHasAttachment( bool withAttachment )
 412 {
 413   if ( withAttachment ) {
 414     mStatus |= KMMsgStatusHasAttach;
 415   } else {
 416     mStatus &= ~KMMsgStatusHasAttach;
 417   }
 418 }
 419
 420 qint32 MessageStatus::toQInt32() const
 421 {
 422   return mStatus;
 423 }
 424
 425 void MessageStatus::fromQInt32( qint32 status )
 426 {
 427   mStatus = status;
 428 }
 429
 430 QString MessageStatus::getStatusStr() const
 431 {
 432   QString sstr;
 433   if ( mStatus & KMMsgStatusNew ) {
 434     sstr += 'N';
 435   }
 436   if ( mStatus & KMMsgStatusUnread ) {
 437     sstr += 'U';
 438   }
 439   if ( mStatus & KMMsgStatusOld ) {
 440     sstr += 'O';
 441   }
 442   if ( mStatus & KMMsgStatusRead ) {
 443     sstr += 'R';
 444   }
 445   if ( mStatus & KMMsgStatusDeleted ) {
 446     sstr += 'D';
 447   }
 448   if ( mStatus & KMMsgStatusReplied ) {
 449     sstr += 'A';
 450   }
 451   if ( mStatus & KMMsgStatusForwarded ) {
 452     sstr += 'F';
 453   }
 454   if ( mStatus & KMMsgStatusQueued ) {
 455     sstr += 'Q';
 456   }
 457   if ( mStatus & KMMsgStatusToAct ) {
 458     sstr += 'K';
 459   }
 460   if ( mStatus & KMMsgStatusSent ) {
 461     sstr += 'S';
 462   }
 463   if ( mStatus & KMMsgStatusFlag ) {
 464     sstr += 'G';
 465   }
 466   if ( mStatus & KMMsgStatusWatched ) {
 467     sstr += 'W';
 468   }
 469   if ( mStatus & KMMsgStatusIgnored ) {
 470     sstr += 'I';
 471   }
 472   if ( mStatus & KMMsgStatusSpam ) {
 473     sstr += 'P';
 474   }
 475   if ( mStatus & KMMsgStatusHam ) {
 476     sstr += 'H';
 477   }
 478   if ( mStatus & KMMsgStatusHasAttach ) {
 479     sstr += 'T';
 480   }
 481
 482   return sstr;
 483 }
 484
 485 void MessageStatus::setStatusFromStr( const QString& aStr )
 486 {
 487   mStatus = KMMsgStatusUnknown;
 488
 489   if ( aStr.contains( 'N' ) ) {
 490     setNew();
 491   }
 492   if ( aStr.contains( 'U' ) ) {
 493     setUnread();
 494   }
 495   if ( aStr.contains( 'O' ) ) {
 496     setOld();
 497   }
 498   if ( aStr.contains( 'R' ) ) {
 499     setRead();
 500   }
 501   if ( aStr.contains( 'D' ) ) {
 502     setDeleted();
 503   }
 504   if ( aStr.contains( 'A' ) ) {
 505     setReplied();
 506   }
 507   if ( aStr.contains( 'F' ) ) {
 508     setForwarded();
 509   }
 510   if ( aStr.contains( 'Q' ) ) {
 511     setQueued();
 512   }
 513   if ( aStr.contains( 'K' ) ) {
 514     setToAct();
 515   }
 516   if ( aStr.contains( 'S' ) ) {
 517     setSent();
 518   }
 519   if ( aStr.contains( 'G' ) ) {
 520     setImportant();
 521   }
 522   if ( aStr.contains( 'W' ) ) {
 523     setWatched();
 524   }
 525   if ( aStr.contains( 'I' ) ) {
 526     setIgnored();
 527   }
 528   if ( aStr.contains( 'P' ) ) {
 529     setSpam();
 530   }
 531   if ( aStr.contains( 'H' ) ) {
 532     setHam();
 533   }
 534   if ( aStr.contains( 'T' ) ) {
 535     setHasAttachment();
 536   }
 537   if ( aStr.contains( 'C' ) ) {
 538     setHasAttachment( false );
 539   }
 540 }
 541
 542 QString MessageStatus::getSortRank() const
 543 {
 544   QString sstr = "bcbbbbbbbb";
 545
 546   // put watched ones first, then normal ones, ignored ones last
 547   if ( mStatus & KMMsgStatusWatched ) {
 548     sstr[0] = 'a';
 549   }
 550   if ( mStatus & KMMsgStatusIgnored ) {
 551     sstr[0] = 'c';
 552   }
 553
 554   // Second level. One of new, old, read, unread
 555   if ( mStatus & KMMsgStatusNew ) {
 556     sstr[1] = 'a';
 557   }
 558   if ( mStatus & KMMsgStatusUnread ) {
 559     sstr[1] = 'b';
 560   }
 561   //if ( mStatus & KMMsgStatusOld ) {
 562   //  sstr[1] = 'c';
 563   //}
 564   //if ( mStatus & KMMsgStatusRead ) {
 565   //  sstr[1] = 'c';
 566   //}
 567
 568   // Third level. In somewhat arbitrary order.
 569   if ( mStatus & KMMsgStatusDeleted ) {
 570     sstr[2] = 'a';
 571   }
 572   if ( mStatus & KMMsgStatusFlag ) {
 573     sstr[3] = 'a';
 574   }
 575   if ( mStatus & KMMsgStatusReplied ) {
 576     sstr[4] = 'a';
 577   }
 578   if ( mStatus & KMMsgStatusForwarded ) {
 579     sstr[5] = 'a';
 580   }
 581   if ( mStatus & KMMsgStatusQueued ) {
 582     sstr[6] = 'a';
 583   }
 584   if ( mStatus & KMMsgStatusSent ) {
 585     sstr[7] = 'a';
 586   }
 587   if ( mStatus & KMMsgStatusHam ) {
 588     sstr[8] = 'a';
 589   }
 590   if ( mStatus & KMMsgStatusSpam ) {
 591     sstr[8] = 'c';
 592   }
 593   if ( mStatus & KMMsgStatusToAct ) {
 594     sstr[9] = 'a';
 595   }
 596
 597   return sstr;
 598 }
 599
 600 QSet<QByteArray> MessageStatus::getStatusFlags() const
 601 {
 602   QSet<QByteArray> flags;
 603
 604   // Non handled status:
 605   // * KMMsgStatusQueued
 606   // * KMMsgStatusSent
 607   // * KMMsgStatusSpam
 608   // * KMMsgStatusHam
 609   // * KMMsgStatusHasAttach
 610
 611   if ( mStatus & KMMsgStatusDeleted ) {
 612     flags+= "\\DELETED";
 613   } else {
 614     if ( mStatus & ( KMMsgStatusOld | KMMsgStatusRead ) )
 615       flags+= "\\SEEN ";
 616     if ( mStatus & KMMsgStatusReplied )
 617       flags+= "\\ANSWERED ";
 618     if ( mStatus & KMMsgStatusFlag )
 619       flags+= "\\FLAGGED ";
 620     // non standard flags
 621     if ( mStatus & KMMsgStatusForwarded )
 622       flags+= "$FORWARDED ";
 623     if ( mStatus & KMMsgStatusToAct )
 624       flags+= "$TODO ";
 625     if ( mStatus & KMMsgStatusWatched )
 626       flags+= "$WATCHED ";
 627     if ( mStatus & KMMsgStatusIgnored )
 628       flags+= "$IGNORED ";
 629   }
 630
 631   return flags;
 632 }
 633
 634 void MessageStatus::setStatusFromFlags( const QSet<QByteArray> &flags )
 635 {
 636   mStatus = KMMsgStatusUnknown;
 637   setNew();
 638
 639   // Non handled status:
 640   // * KMMsgStatusQueued
 641   // * KMMsgStatusSent
 642   // * KMMsgStatusSpam
 643   // * KMMsgStatusHam
 644   // * KMMsgStatusHasAttach
 645
 646   foreach ( const QByteArray &flag, flags ) {
 647     if ( flag.toUpper() == QByteArray( "\\DELETED" ) ) {
 648       setDeleted();
 649     } else if ( flag.toUpper() == QByteArray( "\\SEEN" ) ) {
 650       setRead();
 651     } else if ( flag.toUpper() == QByteArray( "\\ANSWERED" ) ) {
 652       setReplied();
 653     } else if ( flag.toUpper() == QByteArray( "\\FLAGGED" ) ) {
 654       setImportant();
 655
 656     // non standard flags
 657     } else if ( flag.toUpper() == QByteArray( "$FORWARDED" ) ) {
 658       setForwarded();
 659     } else if ( flag.toUpper() == QByteArray( "$TODO" ) ) {
 660       setToAct();
 661     } else if ( flag.toUpper() == QByteArray( "$WATCHED" ) ) {
 662       setWatched();
 663     } else if ( flag.toUpper() == QByteArray( "$IGNORED" ) ) {
 664       setIgnored();
 665     } else {
 666       kWarning() << "Unknown flag:" << flag;
 667     }
 668   }
 669 }
 670
 671 MessageStatus MessageStatus::statusNew()
 672 {
 673   MessageStatus st;
 674   st.setNew();
 675   return st;
 676 }
 677
 678 MessageStatus MessageStatus::statusRead()
 679 {
 680   MessageStatus st;
 681   st.setRead();
 682   return st;
 683 }
 684
 685 MessageStatus MessageStatus::statusUnread()
 686 {
 687   MessageStatus st;
 688   st.setUnread();
 689   return st;
 690 }
 691
 692 MessageStatus MessageStatus::statusNewAndUnread()
 693 {
 694   MessageStatus st;
 695   // set the "new and unread" pseudo status; we have to set the internal
 696   // representation directly because new and unread are mutually exclusive
 697   st.fromQInt32( statusNew().toQInt32() | statusUnread().toQInt32() );
 698   return st;
 699 }
 700
 701 MessageStatus MessageStatus::statusOld()
 702 {
 703   MessageStatus st;
 704   st.setOld();
 705   return st;
 706 }
 707
 708 MessageStatus MessageStatus::statusDeleted()
 709 {
 710   MessageStatus st;
 711   st.setDeleted();
 712   return st;
 713 }
 714
 715 MessageStatus MessageStatus::statusReplied()
 716 {
 717   MessageStatus st;
 718   st.setReplied();
 719   return st;
 720 }
 721
 722 MessageStatus MessageStatus::statusForwarded()
 723 {
 724   MessageStatus st;
 725   st.setForwarded();
 726   return st;
 727 }
 728
 729 MessageStatus MessageStatus::statusQueued()
 730 {
 731   MessageStatus st;
 732   st.setQueued();
 733   return st;
 734 }
 735
 736 MessageStatus MessageStatus::statusSent()
 737 {
 738   MessageStatus st;
 739   st.setSent();
 740   return st;
 741 }
 742
 743 MessageStatus MessageStatus::statusImportant()
 744 {
 745   MessageStatus st;
 746   st.setImportant();
 747   return st;
 748 }
 749
 750 MessageStatus MessageStatus::statusWatched()
 751 {
 752   MessageStatus st;
 753   st.setWatched();
 754   return st;
 755 }
 756
 757 MessageStatus MessageStatus::statusIgnored()
 758 {
 759   MessageStatus st;
 760   st.setIgnored();
 761   return st;
 762 }
 763
 764 MessageStatus MessageStatus::statusToAct()
 765 {
 766   MessageStatus st;
 767   st.setToAct();
 768   return st;
 769 }
 770
 771 MessageStatus MessageStatus::statusSpam()
 772 {
 773   MessageStatus st;
 774   st.setSpam();
 775   return st;
 776 }
 777
 778 MessageStatus MessageStatus::statusHam()
 779 {
 780   MessageStatus st;
 781   st.setHam();
 782   return st;
 783 }
 784
 785 MessageStatus MessageStatus::statusHasAttachment()
 786 {
 787   MessageStatus st;
 788   st.setHasAttachment();
 789   return st;
 790 }