• 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   if ( d->mRelatedToUid == incidence->uid() ) {
00520     d->mRelatedToUid.clear();
00521   }
00522 //  if (incidence->getRelatedTo() == this) incidence->setRelatedTo(0);
00523 }
00524 
00525 // %%%%%%%%%%%%  Recurrence-related methods %%%%%%%%%%%%%%%%%%%%
00526 
00527 Recurrence *Incidence::recurrence() const
00528 {
00529   if ( !d->mRecurrence ) {
00530     d->mRecurrence = new Recurrence();
00531     d->mRecurrence->setStartDateTime( IncidenceBase::dtStart() );
00532     d->mRecurrence->setAllDay( allDay() );
00533     d->mRecurrence->setRecurReadOnly( mReadOnly );
00534     d->mRecurrence->addObserver( const_cast<KCal::Incidence*>( this ) );
00535   }
00536 
00537   return d->mRecurrence;
00538 }
00539 
00540 void Incidence::clearRecurrence()
00541 {
00542   delete d->mRecurrence;
00543   d->mRecurrence = 0;
00544 }
00545 
00546 ushort Incidence::recurrenceType() const
00547 {
00548   if ( d->mRecurrence ) {
00549     return d->mRecurrence->recurrenceType();
00550   } else {
00551     return Recurrence::rNone;
00552   }
00553 }
00554 
00555 bool Incidence::recurs() const
00556 {
00557   if ( d->mRecurrence ) {
00558     return d->mRecurrence->recurs();
00559   } else {
00560     return false;
00561   }
00562 }
00563 
00564 bool Incidence::recursOn( const QDate &date,
00565                           const KDateTime::Spec &timeSpec ) const
00566 {
00567   return d->mRecurrence && d->mRecurrence->recursOn( date, timeSpec );
00568 }
00569 
00570 bool Incidence::recursAt( const KDateTime &qdt ) const
00571 {
00572   return d->mRecurrence && d->mRecurrence->recursAt( qdt );
00573 }
00574 
00575 QList<KDateTime> Incidence::startDateTimesForDate( const QDate &date,
00576                                                    const KDateTime::Spec &timeSpec ) const
00577 {
00578   KDateTime start = dtStart();
00579   KDateTime end = endDateRecurrenceBase();
00580 
00581   QList<KDateTime> result;
00582 
00583   // TODO_Recurrence: Also work if only due date is given...
00584   if ( !start.isValid() && ! end.isValid() ) {
00585     return result;
00586   }
00587 
00588   // if the incidence doesn't recur,
00589   KDateTime kdate( date, timeSpec );
00590   if ( !recurs() ) {
00591     if ( !( start > kdate || end < kdate ) ) {
00592       result << start;
00593     }
00594     return result;
00595   }
00596 
00597   int days = start.daysTo( end );
00598   // Account for possible recurrences going over midnight, while the original event doesn't
00599   QDate tmpday( date.addDays( -days - 1 ) );
00600   KDateTime tmp;
00601   while ( tmpday <= date ) {
00602     if ( recurrence()->recursOn( tmpday, timeSpec ) ) {
00603       QList<QTime> times = recurrence()->recurTimesOn( tmpday, timeSpec );
00604       foreach ( const QTime &time, times ) {
00605         tmp = KDateTime( tmpday, time, start.timeSpec() );
00606         if ( endDateForStart( tmp ) >= kdate ) {
00607           result << tmp;
00608         }
00609       }
00610     }
00611     tmpday = tmpday.addDays( 1 );
00612   }
00613   return result;
00614 }
00615 
00616 QList<KDateTime> Incidence::startDateTimesForDateTime( const KDateTime &datetime ) const
00617 {
00618   KDateTime start = dtStart();
00619   KDateTime end = endDateRecurrenceBase();
00620 
00621   QList<KDateTime> result;
00622 
00623   // TODO_Recurrence: Also work if only due date is given...
00624   if ( !start.isValid() && ! end.isValid() ) {
00625     return result;
00626   }
00627 
00628   // if the incidence doesn't recur,
00629   if ( !recurs() ) {
00630     if ( !( start > datetime || end < datetime ) ) {
00631       result << start;
00632     }
00633     return result;
00634   }
00635 
00636   int days = start.daysTo( end );
00637   // Account for possible recurrences going over midnight, while the original event doesn't
00638   QDate tmpday( datetime.date().addDays( -days - 1 ) );
00639   KDateTime tmp;
00640   while ( tmpday <= datetime.date() ) {
00641     if ( recurrence()->recursOn( tmpday, datetime.timeSpec() ) ) {
00642       // Get the times during the day (in start date's time zone) when recurrences happen
00643       QList<QTime> times = recurrence()->recurTimesOn( tmpday, start.timeSpec() );
00644       foreach ( const QTime &time, times ) {
00645         tmp = KDateTime( tmpday, time, start.timeSpec() );
00646         if ( !( tmp > datetime || endDateForStart( tmp ) < datetime ) ) {
00647           result << tmp;
00648         }
00649       }
00650     }
00651     tmpday = tmpday.addDays( 1 );
00652   }
00653   return result;
00654 }
00655 
00656 KDateTime Incidence::endDateForStart( const KDateTime &startDt ) const
00657 {
00658   KDateTime start = dtStart();
00659   KDateTime end = endDateRecurrenceBase();
00660   if ( !end.isValid() ) {
00661     return start;
00662   }
00663   if ( !start.isValid() ) {
00664     return end;
00665   }
00666 
00667   return startDt.addSecs( start.secsTo( end ) );
00668 }
00669 
00670 void Incidence::addAttachment( Attachment *attachment )
00671 {
00672   if ( mReadOnly || !attachment ) {
00673     return;
00674   }
00675 
00676   d->mAttachments.append( attachment );
00677   updated();
00678 }
00679 
00680 void Incidence::deleteAttachment( Attachment *attachment )
00681 {
00682   d->mAttachments.removeRef( attachment );
00683 }
00684 
00685 void Incidence::deleteAttachments( const QString &mime )
00686 {
00687   Attachment::List::Iterator it = d->mAttachments.begin();
00688   while ( it != d->mAttachments.end() ) {
00689     if ( (*it)->mimeType() == mime ) {
00690       d->mAttachments.removeRef( it );
00691     } else {
00692       ++it;
00693     }
00694   }
00695 }
00696 
00697 Attachment::List Incidence::attachments() const
00698 {
00699   return d->mAttachments;
00700 }
00701 
00702 Attachment::List Incidence::attachments( const QString &mime ) const
00703 {
00704   Attachment::List attachments;
00705   Attachment::List::ConstIterator it;
00706   foreach ( Attachment *attachment, d->mAttachments ) {
00707     if ( attachment->mimeType() == mime ) {
00708       attachments.append( attachment );
00709     }
00710   }
00711   return attachments;
00712 }
00713 
00714 void Incidence::clearAttachments()
00715 {
00716   d->mAttachments.clearAll();
00717 }
00718 
00719 void Incidence::setResources( const QStringList &resources )
00720 {
00721   if ( mReadOnly ) {
00722     return;
00723   }
00724 
00725   d->mResources = resources;
00726   updated();
00727 }
00728 
00729 QStringList Incidence::resources() const
00730 {
00731   return d->mResources;
00732 }
00733 
00734 void Incidence::setPriority( int priority )
00735 {
00736   if ( mReadOnly ) {
00737     return;
00738   }
00739 
00740   d->mPriority = priority;
00741   updated();
00742 }
00743 
00744 int Incidence::priority() const
00745 {
00746   return d->mPriority;
00747 }
00748 
00749 void Incidence::setStatus( Incidence::Status status )
00750 {
00751   if ( mReadOnly || status == StatusX ) {
00752     return;
00753   }
00754 
00755   d->mStatus = status;
00756   d->mStatusString.clear();
00757   updated();
00758 }
00759 
00760 void Incidence::setCustomStatus( const QString &status )
00761 {
00762   if ( mReadOnly ) {
00763     return;
00764   }
00765 
00766   d->mStatus = status.isEmpty() ? StatusNone : StatusX;
00767   d->mStatusString = status;
00768   updated();
00769 }
00770 
00771 Incidence::Status Incidence::status() const
00772 {
00773   return d->mStatus;
00774 }
00775 
00776 QString Incidence::statusStr() const
00777 {
00778   if ( d->mStatus == StatusX ) {
00779     return d->mStatusString;
00780   }
00781 
00782   return statusName( d->mStatus );
00783 }
00784 
00785 QString Incidence::statusName( Incidence::Status status )
00786 {
00787   switch ( status ) {
00788   case StatusTentative:
00789     return i18nc( "@item event is tentative", "Tentative" );
00790   case StatusConfirmed:
00791     return i18nc( "@item event is definite", "Confirmed" );
00792   case StatusCompleted:
00793     return i18nc( "@item to-do is complete", "Completed" );
00794   case StatusNeedsAction:
00795     return i18nc( "@item to-do needs action", "Needs-Action" );
00796   case StatusCanceled:
00797     return i18nc( "@item event orto-do is canceled; journal is removed", "Canceled" );
00798   case StatusInProcess:
00799     return i18nc( "@item to-do is in process", "In-Process" );
00800   case StatusDraft:
00801     return i18nc( "@item journal is in draft form", "Draft" );
00802   case StatusFinal:
00803     return i18nc( "@item journal is in final form", "Final" );
00804   case StatusX:
00805   case StatusNone:
00806   default:
00807     return QString();
00808   }
00809 }
00810 
00811 void Incidence::setSecrecy( Incidence::Secrecy secrecy )
00812 {
00813   if ( mReadOnly ) {
00814     return;
00815   }
00816 
00817   d->mSecrecy = secrecy;
00818   updated();
00819 }
00820 
00821 Incidence::Secrecy Incidence::secrecy() const
00822 {
00823   return d->mSecrecy;
00824 }
00825 
00826 QString Incidence::secrecyStr() const
00827 {
00828   return secrecyName( d->mSecrecy );
00829 }
00830 
00831 QString Incidence::secrecyName( Incidence::Secrecy secrecy )
00832 {
00833   switch ( secrecy ) {
00834   case SecrecyPublic:
00835     return i18nc( "@item incidence access if for everyone", "Public" );
00836   case SecrecyPrivate:
00837     return i18nc( "@item incidence access is by owner only", "Private" );
00838   case SecrecyConfidential:
00839     return i18nc( "@item incidence access is by owner and a controlled group", "Confidential" );
00840   default:
00841     return QString();  // to make compilers happy
00842   }
00843 }
00844 
00845 QStringList Incidence::secrecyList()
00846 {
00847   QStringList list;
00848   list << secrecyName( SecrecyPublic );
00849   list << secrecyName( SecrecyPrivate );
00850   list << secrecyName( SecrecyConfidential );
00851 
00852   return list;
00853 }
00854 
00855 const Alarm::List &Incidence::alarms() const
00856 {
00857   return d->mAlarms;
00858 }
00859 
00860 Alarm *Incidence::newAlarm()
00861 {
00862   Alarm *alarm = new Alarm( this );
00863   d->mAlarms.append( alarm );
00864   return alarm;
00865 }
00866 
00867 void Incidence::addAlarm( Alarm *alarm )
00868 {
00869   d->mAlarms.append( alarm );
00870   updated();
00871 }
00872 
00873 void Incidence::removeAlarm( Alarm *alarm )
00874 {
00875   d->mAlarms.removeRef( alarm );
00876   updated();
00877 }
00878 
00879 void Incidence::clearAlarms()
00880 {
00881   d->mAlarms.clearAll();
00882   updated();
00883 }
00884 
00885 bool Incidence::isAlarmEnabled() const
00886 {
00887   foreach ( Alarm *alarm, d->mAlarms ) {
00888     if ( alarm->enabled() ) {
00889       return true;
00890     }
00891   }
00892   return false;
00893 }
00894 
00895 void Incidence::setLocation( const QString &location, bool isRich )
00896 {
00897   if ( mReadOnly ) {
00898     return;
00899   }
00900 
00901   d->mLocation = location;
00902   d->mLocationIsRich = isRich;
00903   updated();
00904 }
00905 
00906 void Incidence::setLocation( const QString &location )
00907 {
00908   setLocation( location, Qt::mightBeRichText( location ) );
00909 }
00910 
00911 QString Incidence::location() const
00912 {
00913   return d->mLocation;
00914 }
00915 
00916 QString Incidence::richLocation() const
00917 {
00918   if ( locationIsRich() ) {
00919     return d->mLocation;
00920   } else {
00921     return Qt::escape( d->mLocation ).replace( '\n', "<br/>" );
00922   }
00923 }
00924 
00925 bool Incidence::locationIsRich() const
00926 {
00927   return d->mLocationIsRich;
00928 }
00929 
00930 void Incidence::setSchedulingID( const QString &sid )
00931 {
00932   d->mSchedulingID = sid;
00933 }
00934 
00935 QString Incidence::schedulingID() const
00936 {
00937   if ( d->mSchedulingID.isNull() ) {
00938     // Nothing set, so use the normal uid
00939     return uid();
00940   }
00941   return d->mSchedulingID;
00942 }
00943 
00947 void Incidence::recurrenceUpdated( Recurrence *recurrence )
00948 {
00949   if ( recurrence == d->mRecurrence ) {
00950     updated();
00951   }
00952 }

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.8
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