• Skip to content
  • Skip to link menu
KDE 4.2 API Reference
  • KDE API Reference
  • KDE-PIM Libraries
  • Sitemap
  • Contact Us
 

KCal Library

incidence.cpp

Go to the documentation of this file.
00001 /*
00002   This file is part of the kcal library.
00003 
00004   Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
00005   Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
00006 
00007   This library is free software; you can redistribute it and/or
00008   modify it under the terms of the GNU Library General Public
00009   License as published by the Free Software Foundation; either
00010   version 2 of the License, or (at your option) any later version.
00011 
00012   This library is distributed in the hope that it will be useful,
00013   but WITHOUT ANY WARRANTY; without even the implied warranty of
00014   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015   Library General Public License for more details.
00016 
00017   You should have received a copy of the GNU Library General Public License
00018   along with this library; see the file COPYING.LIB.  If not, write to
00019   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00020   Boston, MA 02110-1301, USA.
00021 */
00035 #include "incidence.h"
00036 #include "calformat.h"
00037 
00038 #include <kglobal.h>
00039 #include <klocale.h>
00040 #include <kdebug.h>
00041 
00042 #include <QtCore/QList>
00043 #include <QTextDocument> // for Qt::escape() and Qt::mightBeRichText()
00044 
00045 using namespace KCal;
00046 
00051 //@cond PRIVATE
00052 class KCal::Incidence::Private
00053 {
00054   public:
00055     Private()
00056       : mRecurrence( 0 ),
00057         mStatus( StatusNone ),
00058         mSecrecy( SecrecyPublic ),
00059         mPriority( 0 ),
00060         mRelatedTo( 0 )
00061     {
00062       mAlarms.setAutoDelete( true );
00063       mAttachments.setAutoDelete( true );
00064     }
00065 
00066     Private( const Private &p )
00067       : mCreated( p.mCreated ),
00068         mRevision( p.mRevision ),
00069         mDescription( p.mDescription ),
00070         mDescriptionIsRich( p.mDescriptionIsRich ),
00071         mSummary( p.mSummary ),
00072         mSummaryIsRich( p.mSummaryIsRich ),
00073         mLocation( p.mLocation ),
00074         mLocationIsRich( p.mLocationIsRich ),
00075         mCategories( p.mCategories ),
00076         mResources( p.mResources ),
00077         mStatus( p.mStatus ),
00078         mStatusString( p.mStatusString ),
00079         mSecrecy( p.mSecrecy ),
00080         mPriority( p.mPriority ),
00081         mSchedulingID( p.mSchedulingID ),
00082         mRelatedTo( 0 ),
00083         mRelatedToUid( p.mRelatedToUid )
00084 // TODO: reenable attributes currently commented out.
00085 //  Incidence *mRelatedTo;          Incidence *mRelatedTo;
00086 //  Incidence::List mRelations;    Incidence::List mRelations;
00087     {
00088       mAlarms.setAutoDelete( true );
00089       mAttachments.setAutoDelete( true );
00090     }
00091 
00092     void clear()
00093     {
00094       mAlarms.clearAll();
00095       mAttachments.clearAll();
00096       delete mRecurrence;
00097     }
00098 
00099     KDateTime mCreated;              // creation datetime
00100     int mRevision;                   // revision number
00101 
00102     QString mDescription;            // description string
00103     bool mDescriptionIsRich;         // description string is richtext.
00104     QString mSummary;                // summary string
00105     bool mSummaryIsRich;             // summary string is richtext.
00106     QString mLocation;               // location string
00107     bool mLocationIsRich;            // location string is richtext.
00108     QStringList mCategories;         // category list
00109     mutable Recurrence *mRecurrence; // recurrence
00110     Attachment::List mAttachments;   // attachments list
00111     Alarm::List mAlarms;             // alarms list
00112     QStringList mResources;          // resources list (not calendar resources)
00113     Status mStatus;                  // status
00114     QString mStatusString;           // status string, for custom status
00115     Secrecy mSecrecy;                // secrecy
00116     int mPriority;                   // priority: 1 = highest, 2 = less, etc.
00117     QString mSchedulingID;           // ID for scheduling mails
00118 
00119     Incidence *mRelatedTo;           // incidence this is related to
00120     QString mRelatedToUid;           // incidence (by Uid) this is related to
00121     Incidence::List mRelations;      // a list of incidences this is related to
00122 };
00123 //@endcond
00124 
00125 Incidence::Incidence()
00126   : IncidenceBase(), d( new KCal::Incidence::Private )
00127 {
00128   recreate();
00129 }
00130 
00131 Incidence::Incidence( const Incidence &i )
00132   : IncidenceBase( i ),
00133     Recurrence::RecurrenceObserver(),
00134     d( new KCal::Incidence::Private( *i.d ) )
00135 {
00136   init( i );
00137 }
00138 
00139 void Incidence::init( const Incidence &i )
00140 {
00141 // TODO: reenable attributes currently commented out.
00142   d->mRevision = i.d->mRevision;
00143   d->mCreated = i.d->mCreated;
00144   d->mDescription = i.d->mDescription;
00145   d->mSummary = i.d->mSummary;
00146   d->mCategories = i.d->mCategories;
00147 //  Incidence *mRelatedTo;          Incidence *mRelatedTo;
00148   d->mRelatedTo = 0;
00149   d->mRelatedToUid = i.d->mRelatedToUid;
00150 //  Incidence::List mRelations;    Incidence::List mRelations;
00151   d->mResources = i.d->mResources;
00152   d->mStatusString = i.d->mStatusString;
00153   d->mStatus = i.d->mStatus;
00154   d->mSecrecy = i.d->mSecrecy;
00155   d->mPriority = i.d->mPriority;
00156   d->mLocation = i.d->mLocation;
00157 
00158   // Alarms and Attachments are stored in ListBase<...>, which is a QValueList<...*>.
00159   // We need to really duplicate the objects stored therein, otherwise deleting
00160   // i will also delete all attachments from this object (setAutoDelete...)
00161   foreach ( Alarm *alarm, i.d->mAlarms ) {
00162     Alarm *b = new Alarm( *alarm );
00163     b->setParent( this );
00164     d->mAlarms.append( b );
00165   }
00166 
00167   foreach ( Attachment *attachment, i.d->mAttachments ) {
00168     Attachment *a = new Attachment( *attachment );
00169     d->mAttachments.append( a );
00170   }
00171 
00172   if ( i.d->mRecurrence ) {
00173     d->mRecurrence = new Recurrence( *( i.d->mRecurrence ) );
00174     d->mRecurrence->addObserver( this );
00175   } else {
00176     d->mRecurrence = 0;
00177   }
00178 }
00179 
00180 Incidence::~Incidence()
00181 {
00182   Incidence::List relations = d->mRelations;
00183   foreach ( Incidence *incidence, relations ) {
00184     if ( incidence->relatedTo() == this ) {
00185       incidence->setRelatedTo( 0 );
00186     }
00187   }
00188 
00189   if ( relatedTo() ) {
00190     relatedTo()->removeRelation( this );
00191   }
00192   delete d->mRecurrence;
00193   delete d;
00194 }
00195 
00196 //@cond PRIVATE
00197 // A string comparison that considers that null and empty are the same
00198 static bool stringCompare( const QString &s1, const QString &s2 )
00199 {
00200   return ( s1.isEmpty() && s2.isEmpty() ) || ( s1 == s2 );
00201 }
00202 
00203 //@endcond
00204 Incidence &Incidence::operator=( const Incidence &other )
00205 {
00206   // check for self assignment
00207   if ( &other == this ) {
00208     return *this;
00209   }
00210 
00211   d->clear();
00212   //TODO: should relations be cleared out, as in destructor???
00213   IncidenceBase::operator=( other );
00214   init( other );
00215   return *this;
00216 }
00217 
00218 bool Incidence::operator==( const Incidence &i2 ) const
00219 {
00220   if ( alarms().count() != i2.alarms().count() ) {
00221     return false; // no need to check further
00222   }
00223 
00224   Alarm::List::ConstIterator a1 = alarms().constBegin();
00225   Alarm::List::ConstIterator a1end = alarms().constEnd();
00226   Alarm::List::ConstIterator a2 = i2.alarms().begin();
00227   Alarm::List::ConstIterator a2end = i2.alarms().constEnd();
00228   for ( ; a1 != a1end && a2 != a2end; ++a1, ++a2 ) {
00229     if ( **a1 == **a2 ) {
00230       continue;
00231     } else {
00232       return false;
00233     }
00234   }
00235 
00236   if ( !IncidenceBase::operator==( i2 ) ) {
00237     return false;
00238   }
00239 
00240   bool recurrenceEqual = ( d->mRecurrence == 0 && i2.d->mRecurrence == 0 );
00241   if ( !recurrenceEqual ) {
00242     recurrenceEqual = d->mRecurrence != 0 &&
00243                       i2.d->mRecurrence != 0 &&
00244                       *d->mRecurrence == *i2.d->mRecurrence;
00245   }
00246 
00247   return
00248     recurrenceEqual &&
00249     created() == i2.created() &&
00250     stringCompare( description(), i2.description() ) &&
00251     stringCompare( summary(), i2.summary() ) &&
00252     categories() == i2.categories() &&
00253     // no need to compare mRelatedTo
00254     stringCompare( relatedToUid(), i2.relatedToUid() ) &&
00255     relations() == i2.relations() &&
00256     attachments() == i2.attachments() &&
00257     resources() == i2.resources() &&
00258     d->mStatus == i2.d->mStatus &&
00259     ( d->mStatus == StatusNone ||
00260       stringCompare( d->mStatusString, i2.d->mStatusString ) ) &&
00261     secrecy() == i2.secrecy() &&
00262     priority() == i2.priority() &&
00263     stringCompare( location(), i2.location() ) &&
00264     stringCompare( schedulingID(), i2.schedulingID() );
00265 }
00266 
00267 void Incidence::recreate()
00268 {
00269   KDateTime nowUTC = KDateTime::currentUtcDateTime();
00270   setCreated( nowUTC );
00271 
00272   setUid( CalFormat::createUniqueId() );
00273   setSchedulingID( QString() );
00274 
00275   setRevision( 0 );
00276 
00277   setLastModified( nowUTC );
00278 }
00279 
00280 void Incidence::setReadOnly( bool readOnly )
00281 {
00282   IncidenceBase::setReadOnly( readOnly );
00283   if ( d->mRecurrence ) {
00284     d->mRecurrence->setRecurReadOnly( readOnly );
00285   }
00286 }
00287 
00288 void Incidence::setAllDay( bool allDay )
00289 {
00290   if ( mReadOnly ) {
00291     return;
00292   }
00293   if ( recurrence() ) {
00294     recurrence()->setAllDay( allDay );
00295   }
00296   IncidenceBase::setAllDay( allDay );
00297 }
00298 
00299 void Incidence::setCreated( const KDateTime &created )
00300 {
00301   if ( mReadOnly ) {
00302     return;
00303   }
00304 
00305   d->mCreated = created.toUtc();
00306 
00307 // FIXME: Shouldn't we call updated for the creation date, too?
00308 //  updated();
00309 }
00310 
00311 KDateTime Incidence::created() const
00312 {
00313   return d->mCreated;
00314 }
00315 
00316 void Incidence::setRevision( int rev )
00317 {
00318   if ( mReadOnly ) {
00319     return;
00320   }
00321 
00322   d->mRevision = rev;
00323 
00324   updated();
00325 }
00326 
00327 int Incidence::revision() const
00328 {
00329   return d->mRevision;
00330 }
00331 
00332 void Incidence::setDtStart( const KDateTime &dt )
00333 {
00334   if ( d->mRecurrence ) {
00335     d->mRecurrence->setStartDateTime( dt );
00336     d->mRecurrence->setAllDay( allDay() );
00337   }
00338   IncidenceBase::setDtStart( dt );
00339 }
00340 
00341 KDateTime Incidence::dtEnd() const
00342 {
00343   return KDateTime();
00344 }
00345 
00346 void Incidence::shiftTimes( const KDateTime::Spec &oldSpec,
00347                             const KDateTime::Spec &newSpec )
00348 {
00349   IncidenceBase::shiftTimes( oldSpec, newSpec );
00350   if ( d->mRecurrence ) {
00351     d->mRecurrence->shiftTimes( oldSpec, newSpec );
00352   }
00353   for ( int i = 0, end = d->mAlarms.count();  i < end;  ++i ) {
00354     d->mAlarms[i]->shiftTimes( oldSpec, newSpec );
00355   }
00356 }
00357 
00358 void Incidence::setDescription( const QString &description, bool isRich )
00359 {
00360   if ( mReadOnly ) {
00361     return;
00362   }
00363   d->mDescription = description;
00364   d->mDescriptionIsRich = isRich;
00365   updated();
00366 }
00367 
00368 void Incidence::setDescription( const QString &description )
00369 {
00370   setDescription( description, Qt::mightBeRichText( description ) );
00371 }
00372 
00373 QString Incidence::description() const
00374 {
00375   return d->mDescription;
00376 }
00377 
00378 QString Incidence::richDescription() const
00379 {
00380   if ( descriptionIsRich() ) {
00381     return d->mDescription;
00382   } else {
00383     return Qt::escape( d->mDescription ).replace( '\n', "<br/>" );
00384   }
00385 }
00386 
00387 bool Incidence::descriptionIsRich() const
00388 {
00389   return d->mDescriptionIsRich;
00390 }
00391 
00392 void Incidence::setSummary( const QString &summary, bool isRich )
00393 {
00394   if ( mReadOnly ) {
00395     return;
00396   }
00397   d->mSummary = summary;
00398   d->mSummaryIsRich = isRich;
00399   updated();
00400 }
00401 
00402 void Incidence::setSummary( const QString &summary )
00403 {
00404   setSummary( summary, Qt::mightBeRichText( summary ) );
00405 }
00406 
00407 QString Incidence::summary() const
00408 {
00409   return d->mSummary;
00410 }
00411 
00412 QString Incidence::richSummary() const
00413 {
00414   if ( summaryIsRich() ) {
00415     return d->mSummary;
00416   } else {
00417     return Qt::escape( d->mSummary ).replace( '\n', "<br/>" );
00418   }
00419 }
00420 
00421 bool Incidence::summaryIsRich() const
00422 {
00423   return d->mSummaryIsRich;
00424 }
00425 
00426 void Incidence::setCategories( const QStringList &categories )
00427 {
00428   if ( mReadOnly ) {
00429     return;
00430   }
00431   d->mCategories = categories;
00432   updated();
00433 }
00434 
00435 void Incidence::setCategories( const QString &catStr )
00436 {
00437   if ( mReadOnly ) {
00438     return;
00439   }
00440   d->mCategories.clear();
00441 
00442   if ( catStr.isEmpty() ) {
00443     return;
00444   }
00445 
00446   d->mCategories = catStr.split( ',' );
00447 
00448   QStringList::Iterator it;
00449   for ( it = d->mCategories.begin();it != d->mCategories.end(); ++it ) {
00450     *it = (*it).trimmed();
00451   }
00452 
00453   updated();
00454 }
00455 
00456 QStringList Incidence::categories() const
00457 {
00458   return d->mCategories;
00459 }
00460 
00461 QString Incidence::categoriesStr() const
00462 {
00463   return d->mCategories.join( "," );
00464 }
00465 
00466 void Incidence::setRelatedToUid( const QString &relatedToUid )
00467 {
00468   if ( d->mRelatedToUid == relatedToUid ) {
00469     return;
00470   }
00471   d->mRelatedToUid = relatedToUid;
00472   updated();
00473 }
00474 
00475 QString Incidence::relatedToUid() const
00476 {
00477   return d->mRelatedToUid;
00478 }
00479 
00480 void Incidence::setRelatedTo( Incidence *incidence )
00481 {
00482   if ( d->mRelatedTo == incidence ) {
00483     return;
00484   }
00485   if ( d->mRelatedTo ) {
00486     d->mRelatedTo->removeRelation( this );
00487   }
00488   d->mRelatedTo = incidence;
00489   if ( d->mRelatedTo ) {
00490     d->mRelatedTo->addRelation( this );
00491     if ( d->mRelatedTo->uid() != d->mRelatedToUid ) {
00492       setRelatedToUid( d->mRelatedTo->uid() );
00493     }
00494   } else {
00495     setRelatedToUid( QString() );
00496   }
00497 }
00498 
00499 Incidence *Incidence::relatedTo() const
00500 {
00501   return d->mRelatedTo;
00502 }
00503 
00504 Incidence::List Incidence::relations() const
00505 {
00506   return d->mRelations;
00507 }
00508 
00509 void Incidence::addRelation( Incidence *incidence )
00510 {
00511   if ( !d->mRelations.contains( incidence ) ) {
00512     d->mRelations.append( incidence );
00513   }
00514 }
00515 
00516 void Incidence::removeRelation( Incidence *incidence )
00517 {
00518   d->mRelations.removeRef( incidence );
00519   d->mRelatedToUid.clear();
00520 //  if (incidence->getRelatedTo() == this) incidence->setRelatedTo(0);
00521 }
00522 
00523 // %%%%%%%%%%%%  Recurrence-related methods %%%%%%%%%%%%%%%%%%%%
00524 
00525 Recurrence *Incidence::recurrence() const
00526 {
00527   if ( !d->mRecurrence ) {
00528     d->mRecurrence = new Recurrence();
00529     d->mRecurrence->setStartDateTime( IncidenceBase::dtStart() );
00530     d->mRecurrence->setAllDay( allDay() );
00531     d->mRecurrence->setRecurReadOnly( mReadOnly );
00532     d->mRecurrence->addObserver( const_cast<KCal::Incidence*>( this ) );
00533   }
00534 
00535   return d->mRecurrence;
00536 }
00537 
00538 void Incidence::clearRecurrence()
00539 {
00540   delete d->mRecurrence;
00541   d->mRecurrence = 0;
00542 }
00543 
00544 ushort Incidence::recurrenceType() const
00545 {
00546   if ( d->mRecurrence ) {
00547     return d->mRecurrence->recurrenceType();
00548   } else {
00549     return Recurrence::rNone;
00550   }
00551 }
00552 
00553 bool Incidence::recurs() const
00554 {
00555   if ( d->mRecurrence ) {
00556     return d->mRecurrence->recurs();
00557   } else {
00558     return false;
00559   }
00560 }
00561 
00562 bool Incidence::recursOn( const QDate &date,
00563                           const KDateTime::Spec &timeSpec ) const
00564 {
00565   return d->mRecurrence && d->mRecurrence->recursOn( date, timeSpec );
00566 }
00567 
00568 bool Incidence::recursAt( const KDateTime &qdt ) const
00569 {
00570   return d->mRecurrence && d->mRecurrence->recursAt( qdt );
00571 }
00572 
00573 QList<KDateTime> Incidence::startDateTimesForDate( const QDate &date,
00574                                                    const KDateTime::Spec &timeSpec ) const
00575 {
00576   KDateTime start = dtStart();
00577   KDateTime end = endDateRecurrenceBase();
00578 
00579   QList<KDateTime> result;
00580 
00581   // TODO_Recurrence: Also work if only due date is given...
00582   if ( !start.isValid() && ! end.isValid() ) {
00583     return result;
00584   }
00585 
00586   // if the incidence doesn't recur,
00587   KDateTime kdate( date, timeSpec );
00588   if ( !recurs() ) {
00589     if ( !( start > kdate || end < kdate ) ) {
00590       result << start;
00591     }
00592     return result;
00593   }
00594 
00595   int days = start.daysTo( end );
00596   // Account for possible recurrences going over midnight, while the original event doesn't
00597   QDate tmpday( date.addDays( -days - 1 ) );
00598   KDateTime tmp;
00599   while ( tmpday <= date ) {
00600     if ( recurrence()->recursOn( tmpday, timeSpec ) ) {
00601       QList<QTime> times = recurrence()->recurTimesOn( tmpday, timeSpec );
00602       foreach ( const QTime &time, times ) {
00603         tmp = KDateTime( tmpday, time, start.timeSpec() );
00604         if ( endDateForStart( tmp ) >= kdate ) {
00605           result << tmp;
00606         }
00607       }
00608     }
00609     tmpday = tmpday.addDays( 1 );
00610   }
00611   return result;
00612 }
00613 
00614 QList<KDateTime> Incidence::startDateTimesForDateTime( const KDateTime &datetime ) const
00615 {
00616   KDateTime start = dtStart();
00617   KDateTime end = endDateRecurrenceBase();
00618 
00619   QList<KDateTime> result;
00620 
00621   // TODO_Recurrence: Also work if only due date is given...
00622   if ( !start.isValid() && ! end.isValid() ) {
00623     return result;
00624   }
00625 
00626   // if the incidence doesn't recur,
00627   if ( !recurs() ) {
00628     if ( !( start > datetime || end < datetime ) ) {
00629       result << start;
00630     }
00631     return result;
00632   }
00633 
00634   int days = start.daysTo( end );
00635   // Account for possible recurrences going over midnight, while the original event doesn't
00636   QDate tmpday( datetime.date().addDays( -days - 1 ) );
00637   KDateTime tmp;
00638   while ( tmpday <= datetime.date() ) {
00639     if ( recurrence()->recursOn( tmpday, datetime.timeSpec() ) ) {
00640       // Get the times during the day (in start date's time zone) when recurrences happen
00641       QList<QTime> times = recurrence()->recurTimesOn( tmpday, start.timeSpec() );
00642       foreach ( const QTime &time, times ) {
00643         tmp = KDateTime( tmpday, time, start.timeSpec() );
00644         if ( !( tmp > datetime || endDateForStart( tmp ) < datetime ) ) {
00645           result << tmp;
00646         }
00647       }
00648     }
00649     tmpday = tmpday.addDays( 1 );
00650   }
00651   return result;
00652 }
00653 
00654 KDateTime Incidence::endDateForStart( const KDateTime &startDt ) const
00655 {
00656   KDateTime start = dtStart();
00657   KDateTime end = endDateRecurrenceBase();
00658   if ( !end.isValid() ) {
00659     return start;
00660   }
00661   if ( !start.isValid() ) {
00662     return end;
00663   }
00664 
00665   return startDt.addSecs( start.secsTo( end ) );
00666 }
00667 
00668 void Incidence::addAttachment( Attachment *attachment )
00669 {
00670   if ( mReadOnly || !attachment ) {
00671     return;
00672   }
00673 
00674   d->mAttachments.append( attachment );
00675   updated();
00676 }
00677 
00678 void Incidence::deleteAttachment( Attachment *attachment )
00679 {
00680   d->mAttachments.removeRef( attachment );
00681 }
00682 
00683 void Incidence::deleteAttachments( const QString &mime )
00684 {
00685   Attachment::List::Iterator it = d->mAttachments.begin();
00686   while ( it != d->mAttachments.end() ) {
00687     if ( (*it)->mimeType() == mime ) {
00688       d->mAttachments.removeRef( it );
00689     } else {
00690       ++it;
00691     }
00692   }
00693 }
00694 
00695 Attachment::List Incidence::attachments() const
00696 {
00697   return d->mAttachments;
00698 }
00699 
00700 Attachment::List Incidence::attachments( const QString &mime ) const
00701 {
00702   Attachment::List attachments;
00703   Attachment::List::ConstIterator it;
00704   foreach ( Attachment *attachment, d->mAttachments ) {
00705     if ( attachment->mimeType() == mime ) {
00706       attachments.append( attachment );
00707     }
00708   }
00709   return attachments;
00710 }
00711 
00712 void Incidence::clearAttachments()
00713 {
00714   d->mAttachments.clearAll();
00715 }
00716 
00717 void Incidence::setResources( const QStringList &resources )
00718 {
00719   if ( mReadOnly ) {
00720     return;
00721   }
00722 
00723   d->mResources = resources;
00724   updated();
00725 }
00726 
00727 QStringList Incidence::resources() const
00728 {
00729   return d->mResources;
00730 }
00731 
00732 void Incidence::setPriority( int priority )
00733 {
00734   if ( mReadOnly ) {
00735     return;
00736   }
00737 
00738   d->mPriority = priority;
00739   updated();
00740 }
00741 
00742 int Incidence::priority() const
00743 {
00744   return d->mPriority;
00745 }
00746 
00747 void Incidence::setStatus( Incidence::Status status )
00748 {
00749   if ( mReadOnly || status == StatusX ) {
00750     return;
00751   }
00752 
00753   d->mStatus = status;
00754   d->mStatusString.clear();
00755   updated();
00756 }
00757 
00758 void Incidence::setCustomStatus( const QString &status )
00759 {
00760   if ( mReadOnly ) {
00761     return;
00762   }
00763 
00764   d->mStatus = status.isEmpty() ? StatusNone : StatusX;
00765   d->mStatusString = status;
00766   updated();
00767 }
00768 
00769 Incidence::Status Incidence::status() const
00770 {
00771   return d->mStatus;
00772 }
00773 
00774 QString Incidence::statusStr() const
00775 {
00776   if ( d->mStatus == StatusX ) {
00777     return d->mStatusString;
00778   }
00779 
00780   return statusName( d->mStatus );
00781 }
00782 
00783 QString Incidence::statusName( Incidence::Status status )
00784 {
00785   switch ( status ) {
00786   case StatusTentative:
00787     return i18nc( "@item event is tentative", "Tentative" );
00788   case StatusConfirmed:
00789     return i18nc( "@item event is definite", "Confirmed" );
00790   case StatusCompleted:
00791     return i18nc( "@item to-do is complete", "Completed" );
00792   case StatusNeedsAction:
00793     return i18nc( "@item to-do needs action", "Needs-Action" );
00794   case StatusCanceled:
00795     return i18nc( "@item event orto-do is canceled; journal is removed", "Canceled" );
00796   case StatusInProcess:
00797     return i18nc( "@item to-do is in process", "In-Process" );
00798   case StatusDraft:
00799     return i18nc( "@item journal is in draft form", "Draft" );
00800   case StatusFinal:
00801     return i18nc( "@item journal is in final form", "Final" );
00802   case StatusX:
00803   case StatusNone:
00804   default:
00805     return QString();
00806   }
00807 }
00808 
00809 void Incidence::setSecrecy( Incidence::Secrecy secrecy )
00810 {
00811   if ( mReadOnly ) {
00812     return;
00813   }
00814 
00815   d->mSecrecy = secrecy;
00816   updated();
00817 }
00818 
00819 Incidence::Secrecy Incidence::secrecy() const
00820 {
00821   return d->mSecrecy;
00822 }
00823 
00824 QString Incidence::secrecyStr() const
00825 {
00826   return secrecyName( d->mSecrecy );
00827 }
00828 
00829 QString Incidence::secrecyName( Incidence::Secrecy secrecy )
00830 {
00831   switch ( secrecy ) {
00832   case SecrecyPublic:
00833     return i18nc( "@item incidence access if for everyone", "Public" );
00834   case SecrecyPrivate:
00835     return i18nc( "@item incidence access is by owner only", "Private" );
00836   case SecrecyConfidential:
00837     return i18nc( "@item incidence access is by owner and a controlled group", "Confidential" );
00838   default:
00839     return QString();  // to make compilers happy
00840   }
00841 }
00842 
00843 QStringList Incidence::secrecyList()
00844 {
00845   QStringList list;
00846   list << secrecyName( SecrecyPublic );
00847   list << secrecyName( SecrecyPrivate );
00848   list << secrecyName( SecrecyConfidential );
00849 
00850   return list;
00851 }
00852 
00853 const Alarm::List &Incidence::alarms() const
00854 {
00855   return d->mAlarms;
00856 }
00857 
00858 Alarm *Incidence::newAlarm()
00859 {
00860   Alarm *alarm = new Alarm( this );
00861   d->mAlarms.append( alarm );
00862   return alarm;
00863 }
00864 
00865 void Incidence::addAlarm( Alarm *alarm )
00866 {
00867   d->mAlarms.append( alarm );
00868   updated();
00869 }
00870 
00871 void Incidence::removeAlarm( Alarm *alarm )
00872 {
00873   d->mAlarms.removeRef( alarm );
00874   updated();
00875 }
00876 
00877 void Incidence::clearAlarms()
00878 {
00879   d->mAlarms.clearAll();
00880   updated();
00881 }
00882 
00883 bool Incidence::isAlarmEnabled() const
00884 {
00885   foreach ( Alarm *alarm, d->mAlarms ) {
00886     if ( alarm->enabled() ) {
00887       return true;
00888     }
00889   }
00890   return false;
00891 }
00892 
00893 void Incidence::setLocation( const QString &location, bool isRich )
00894 {
00895   if ( mReadOnly ) {
00896     return;
00897   }
00898 
00899   d->mLocation = location;
00900   d->mLocationIsRich = isRich;
00901   updated();
00902 }
00903 
00904 void Incidence::setLocation( const QString &location )
00905 {
00906   setLocation( location, Qt::mightBeRichText( location ) );
00907 }
00908 
00909 QString Incidence::location() const
00910 {
00911   return d->mLocation;
00912 }
00913 
00914 QString Incidence::richLocation() const
00915 {
00916   if ( locationIsRich() ) {
00917     return d->mLocation;
00918   } else {
00919     return Qt::escape( d->mLocation ).replace( '\n', "<br/>" );
00920   }
00921 }
00922 
00923 bool Incidence::locationIsRich() const
00924 {
00925   return d->mLocationIsRich;
00926 }
00927 
00928 void Incidence::setSchedulingID( const QString &sid )
00929 {
00930   d->mSchedulingID = sid;
00931 }
00932 
00933 QString Incidence::schedulingID() const
00934 {
00935   if ( d->mSchedulingID.isNull() ) {
00936     // Nothing set, so use the normal uid
00937     return uid();
00938   }
00939   return d->mSchedulingID;
00940 }
00941 
00945 void Incidence::recurrenceUpdated( Recurrence *recurrence )
00946 {
00947   if ( recurrence == d->mRecurrence ) {
00948     updated();
00949   }
00950 }

KCal Library

Skip menu "KCal Library"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

KDE-PIM Libraries

Skip menu "KDE-PIM Libraries"
  • akonadi
  • kabc
  • kblog
  • kcal
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  •   richtextbuilders
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.6
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal