• Skip to content
  • Skip to link menu
KDE 4.1 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   Alarm::List::ConstIterator it;
00162   for ( it = i.d->mAlarms.begin(); it != i.d->mAlarms.end(); ++it ) {
00163     Alarm *b = new Alarm( **it );
00164     b->setParent( this );
00165     d->mAlarms.append( b );
00166   }
00167 
00168   Attachment::List::ConstIterator it1;
00169   for ( it1 = i.d->mAttachments.begin(); it1 != i.d->mAttachments.end(); ++it1 ) {
00170     Attachment *a = new Attachment( **it1 );
00171     d->mAttachments.append( a );
00172   }
00173 
00174   if ( i.d->mRecurrence ) {
00175     d->mRecurrence = new Recurrence( *( i.d->mRecurrence ) );
00176     d->mRecurrence->addObserver( this );
00177   } else {
00178     d->mRecurrence = 0;
00179   }
00180 }
00181 
00182 Incidence::~Incidence()
00183 {
00184   Incidence::List relations = d->mRelations;
00185   foreach ( Incidence *incidence, relations ) {
00186     if ( incidence->relatedTo() == this ) {
00187       incidence->setRelatedTo( 0 );
00188     }
00189   }
00190 
00191   if ( relatedTo() ) {
00192     relatedTo()->removeRelation( this );
00193   }
00194   delete d->mRecurrence;
00195   delete d;
00196 }
00197 
00198 //@cond PRIVATE
00199 // A string comparison that considers that null and empty are the same
00200 static bool stringCompare( const QString &s1, const QString &s2 )
00201 {
00202   return ( s1.isEmpty() && s2.isEmpty() ) || ( s1 == s2 );
00203 }
00204 
00205 //@endcond
00206 Incidence &Incidence::operator=( const Incidence &other )
00207 {
00208   d->clear();
00209   //TODO: should relations be cleared out, as in destructor???
00210   IncidenceBase::operator=( other );
00211   init( other );
00212   return *this;
00213 }
00214 
00215 bool Incidence::operator==( const Incidence &i2 ) const
00216 {
00217   if ( alarms().count() != i2.alarms().count() ) {
00218     return false; // no need to check further
00219   }
00220 
00221   Alarm::List::ConstIterator a1 = alarms().begin();
00222   Alarm::List::ConstIterator a2 = i2.alarms().begin();
00223   for ( ; a1 != alarms().end() && a2 != i2.alarms().end(); ++a1, ++a2 ) {
00224     if ( **a1 == **a2 ) {
00225       continue;
00226     } else {
00227       return false;
00228     }
00229   }
00230 
00231   if ( !IncidenceBase::operator==( i2 ) ) {
00232     return false;
00233   }
00234 
00235   bool recurrenceEqual = ( d->mRecurrence == 0 && i2.d->mRecurrence == 0 );
00236   if ( !recurrenceEqual ) {
00237     recurrenceEqual = d->mRecurrence != 0 &&
00238                       i2.d->mRecurrence != 0 &&
00239                       *d->mRecurrence == *i2.d->mRecurrence;
00240   }
00241 
00242   return
00243     recurrenceEqual &&
00244     created() == i2.created() &&
00245     stringCompare( description(), i2.description() ) &&
00246     stringCompare( summary(), i2.summary() ) &&
00247     categories() == i2.categories() &&
00248     // no need to compare mRelatedTo
00249     stringCompare( relatedToUid(), i2.relatedToUid() ) &&
00250     relations() == i2.relations() &&
00251     attachments() == i2.attachments() &&
00252     resources() == i2.resources() &&
00253     d->mStatus == i2.d->mStatus &&
00254     ( d->mStatus == StatusNone ||
00255       stringCompare( d->mStatusString, i2.d->mStatusString ) ) &&
00256     secrecy() == i2.secrecy() &&
00257     priority() == i2.priority() &&
00258     stringCompare( location(), i2.location() ) &&
00259     stringCompare( schedulingID(), i2.schedulingID() );
00260 }
00261 
00262 void Incidence::recreate()
00263 {
00264   KDateTime nowUTC = KDateTime::currentUtcDateTime();
00265   setCreated( nowUTC );
00266 
00267   setUid( CalFormat::createUniqueId() );
00268   setSchedulingID( QString() );
00269 
00270   setRevision( 0 );
00271 
00272   setLastModified( nowUTC );
00273 }
00274 
00275 void Incidence::setReadOnly( bool readOnly )
00276 {
00277   IncidenceBase::setReadOnly( readOnly );
00278   if ( d->mRecurrence ) {
00279     d->mRecurrence->setRecurReadOnly( readOnly );
00280   }
00281 }
00282 
00283 void Incidence::setAllDay( bool allDay )
00284 {
00285   if ( mReadOnly ) {
00286     return;
00287   }
00288   if ( recurrence() ) {
00289     recurrence()->setAllDay( allDay );
00290   }
00291   IncidenceBase::setAllDay( allDay );
00292 }
00293 
00294 void Incidence::setCreated( const KDateTime &created )
00295 {
00296   if ( mReadOnly ) {
00297     return;
00298   }
00299 
00300   d->mCreated = created.toUtc();
00301 
00302 // FIXME: Shouldn't we call updated for the creation date, too?
00303 //  updated();
00304 }
00305 
00306 KDateTime Incidence::created() const
00307 {
00308   return d->mCreated;
00309 }
00310 
00311 void Incidence::setRevision( int rev )
00312 {
00313   if ( mReadOnly ) {
00314     return;
00315   }
00316 
00317   d->mRevision = rev;
00318 
00319   updated();
00320 }
00321 
00322 int Incidence::revision() const
00323 {
00324   return d->mRevision;
00325 }
00326 
00327 void Incidence::setDtStart( const KDateTime &dt )
00328 {
00329   if ( d->mRecurrence ) {
00330     d->mRecurrence->setStartDateTime( dt );
00331     d->mRecurrence->setAllDay( allDay() );
00332   }
00333   IncidenceBase::setDtStart( dt );
00334 }
00335 
00336 KDateTime Incidence::dtEnd() const
00337 {
00338   return KDateTime();
00339 }
00340 
00341 void Incidence::shiftTimes( const KDateTime::Spec &oldSpec,
00342                             const KDateTime::Spec &newSpec )
00343 {
00344   IncidenceBase::shiftTimes( oldSpec, newSpec );
00345   if ( d->mRecurrence ) {
00346     d->mRecurrence->shiftTimes( oldSpec, newSpec );
00347   }
00348   for ( int i = 0, end = d->mAlarms.count();  i < end;  ++i ) {
00349     d->mAlarms[i]->shiftTimes( oldSpec, newSpec );
00350   }
00351 }
00352 
00353 void Incidence::setDescription( const QString &description, bool isRich )
00354 {
00355   if ( mReadOnly ) {
00356     return;
00357   }
00358   d->mDescription = description;
00359   d->mDescriptionIsRich = isRich;
00360   updated();
00361 }
00362 
00363 void Incidence::setDescription( const QString &description )
00364 {
00365   setDescription( description, Qt::mightBeRichText( description ) );
00366 }
00367 
00368 QString Incidence::description() const
00369 {
00370   return d->mDescription;
00371 }
00372 
00373 QString Incidence::richDescription() const
00374 {
00375   if ( descriptionIsRich() ) {
00376     return d->mDescription;
00377   } else {
00378     return Qt::escape( d->mDescription ).replace( '\n', "<br/>" );
00379   }
00380 }
00381 
00382 bool Incidence::descriptionIsRich() const
00383 {
00384   return d->mDescriptionIsRich;
00385 }
00386 
00387 void Incidence::setSummary( const QString &summary, bool isRich )
00388 {
00389   if ( mReadOnly ) {
00390     return;
00391   }
00392   d->mSummary = summary;
00393   d->mSummaryIsRich = isRich;
00394   updated();
00395 }
00396 
00397 void Incidence::setSummary( const QString &summary )
00398 {
00399   setSummary( summary, Qt::mightBeRichText( summary ) );
00400 }
00401 
00402 QString Incidence::summary() const
00403 {
00404   return d->mSummary;
00405 }
00406 
00407 QString Incidence::richSummary() const
00408 {
00409   if ( summaryIsRich() ) {
00410     return d->mSummary;
00411   } else {
00412     return Qt::escape( d->mSummary ).replace( '\n', "<br/>" );
00413   }
00414 }
00415 
00416 bool Incidence::summaryIsRich() const
00417 {
00418   return d->mSummaryIsRich;
00419 }
00420 
00421 void Incidence::setCategories( const QStringList &categories )
00422 {
00423   if ( mReadOnly ) {
00424     return;
00425   }
00426   d->mCategories = categories;
00427   updated();
00428 }
00429 
00430 void Incidence::setCategories( const QString &catStr )
00431 {
00432   if ( mReadOnly ) {
00433     return;
00434   }
00435   d->mCategories.clear();
00436 
00437   if ( catStr.isEmpty() ) {
00438     return;
00439   }
00440 
00441   d->mCategories = catStr.split( ',' );
00442 
00443   QStringList::Iterator it;
00444   for ( it = d->mCategories.begin();it != d->mCategories.end(); ++it ) {
00445     *it = (*it).trimmed();
00446   }
00447 
00448   updated();
00449 }
00450 
00451 QStringList Incidence::categories() const
00452 {
00453   return d->mCategories;
00454 }
00455 
00456 QString Incidence::categoriesStr() const
00457 {
00458   return d->mCategories.join( "," );
00459 }
00460 
00461 void Incidence::setRelatedToUid( const QString &relatedToUid )
00462 {
00463   if ( mReadOnly || d->mRelatedToUid == relatedToUid ) {
00464     return;
00465   }
00466   d->mRelatedToUid = relatedToUid;
00467   updated();
00468 }
00469 
00470 QString Incidence::relatedToUid() const
00471 {
00472   return d->mRelatedToUid;
00473 }
00474 
00475 void Incidence::setRelatedTo( Incidence *incidence )
00476 {
00477   if ( mReadOnly || d->mRelatedTo == incidence ) {
00478     return;
00479   }
00480   if ( d->mRelatedTo ) {
00481     d->mRelatedTo->removeRelation( this );
00482   }
00483   d->mRelatedTo = incidence;
00484   if ( d->mRelatedTo ) {
00485     d->mRelatedTo->addRelation( this );
00486     if ( d->mRelatedTo->uid() != d->mRelatedToUid ) {
00487       setRelatedToUid( d->mRelatedTo->uid() );
00488     }
00489   } else {
00490     setRelatedToUid( QString() );
00491   }
00492 }
00493 
00494 Incidence *Incidence::relatedTo() const
00495 {
00496   return d->mRelatedTo;
00497 }
00498 
00499 Incidence::List Incidence::relations() const
00500 {
00501   return d->mRelations;
00502 }
00503 
00504 void Incidence::addRelation( Incidence *incidence )
00505 {
00506   if ( !d->mRelations.contains( incidence ) ) {
00507     d->mRelations.append( incidence );
00508   }
00509 }
00510 
00511 void Incidence::removeRelation( Incidence *incidence )
00512 {
00513   d->mRelations.removeRef( incidence );
00514   d->mRelatedToUid.clear();
00515 //  if (incidence->getRelatedTo() == this) incidence->setRelatedTo(0);
00516 }
00517 
00518 // %%%%%%%%%%%%  Recurrence-related methods %%%%%%%%%%%%%%%%%%%%
00519 
00520 Recurrence *Incidence::recurrence() const
00521 {
00522   if ( !d->mRecurrence ) {
00523     d->mRecurrence = new Recurrence();
00524     d->mRecurrence->setStartDateTime( IncidenceBase::dtStart() );
00525     d->mRecurrence->setAllDay( allDay() );
00526     d->mRecurrence->setRecurReadOnly( mReadOnly );
00527     d->mRecurrence->addObserver( const_cast<KCal::Incidence*>( this ) );
00528   }
00529 
00530   return d->mRecurrence;
00531 }
00532 
00533 void Incidence::clearRecurrence()
00534 {
00535   delete d->mRecurrence;
00536   d->mRecurrence = 0;
00537 }
00538 
00539 ushort Incidence::recurrenceType() const
00540 {
00541   if ( d->mRecurrence ) {
00542     return d->mRecurrence->recurrenceType();
00543   } else {
00544     return Recurrence::rNone;
00545   }
00546 }
00547 
00548 bool Incidence::recurs() const
00549 {
00550   if ( d->mRecurrence ) {
00551     return d->mRecurrence->recurs();
00552   } else {
00553     return false;
00554   }
00555 }
00556 
00557 bool Incidence::recursOn( const QDate &date,
00558                           const KDateTime::Spec &timeSpec ) const
00559 {
00560   return d->mRecurrence && d->mRecurrence->recursOn( date, timeSpec );
00561 }
00562 
00563 bool Incidence::recursAt( const KDateTime &qdt ) const
00564 {
00565   return d->mRecurrence && d->mRecurrence->recursAt( qdt );
00566 }
00567 
00568 QList<KDateTime> Incidence::startDateTimesForDate( const QDate &date,
00569                                                    const KDateTime::Spec &timeSpec ) const
00570 {
00571   KDateTime start = dtStart();
00572   KDateTime end = endDateRecurrenceBase();
00573 
00574   QList<KDateTime> result;
00575 
00576   // TODO_Recurrence: Also work if only due date is given...
00577   if ( !start.isValid() && ! end.isValid() ) {
00578     return result;
00579   }
00580 
00581   // if the incidence doesn't recur,
00582   KDateTime kdate( date, timeSpec );
00583   if ( !recurs() ) {
00584     if ( !( start > kdate || end < kdate ) ) {
00585       result << start;
00586     }
00587     return result;
00588   }
00589 
00590   int days = start.daysTo( end );
00591   // Account for possible recurrences going over midnight, while the original event doesn't
00592   QDate tmpday( date.addDays( -days - 1 ) );
00593   KDateTime tmp;
00594   while ( tmpday <= date ) {
00595     if ( recurrence()->recursOn( tmpday, timeSpec ) ) {
00596       QList<QTime> times = recurrence()->recurTimesOn( tmpday, timeSpec );
00597       for ( QList<QTime>::ConstIterator it = times.begin(); it != times.end(); ++it ) {
00598         tmp = KDateTime( tmpday, *it, start.timeSpec() );
00599         if ( endDateForStart( tmp ) >= kdate ) {
00600           result << tmp;
00601         }
00602       }
00603     }
00604     tmpday = tmpday.addDays( 1 );
00605   }
00606   return result;
00607 }
00608 
00609 QList<KDateTime> Incidence::startDateTimesForDateTime( const KDateTime &datetime ) const
00610 {
00611   KDateTime start = dtStart();
00612   KDateTime end = endDateRecurrenceBase();
00613 
00614   QList<KDateTime> result;
00615 
00616   // TODO_Recurrence: Also work if only due date is given...
00617   if ( !start.isValid() && ! end.isValid() ) {
00618     return result;
00619   }
00620 
00621   // if the incidence doesn't recur,
00622   if ( !recurs() ) {
00623     if ( !( start > datetime || end < datetime ) ) {
00624       result << start;
00625     }
00626     return result;
00627   }
00628 
00629   int days = start.daysTo( end );
00630   // Account for possible recurrences going over midnight, while the original event doesn't
00631   QDate tmpday( datetime.date().addDays( -days - 1 ) );
00632   KDateTime tmp;
00633   while ( tmpday <= datetime.date() ) {
00634     if ( recurrence()->recursOn( tmpday, datetime.timeSpec() ) ) {
00635       // Get the times during the day (in start date's time zone) when recurrences happen
00636       QList<QTime> times = recurrence()->recurTimesOn( tmpday, start.timeSpec() );
00637       for ( QList<QTime>::ConstIterator it = times.begin(); it != times.end(); ++it ) {
00638         tmp = KDateTime( tmpday, *it, start.timeSpec() );
00639         if ( !( tmp > datetime || endDateForStart( tmp ) < datetime ) ) {
00640           result << tmp;
00641         }
00642       }
00643     }
00644     tmpday = tmpday.addDays( 1 );
00645   }
00646   return result;
00647 }
00648 
00649 KDateTime Incidence::endDateForStart( const KDateTime &startDt ) const
00650 {
00651   KDateTime start = dtStart();
00652   KDateTime end = endDateRecurrenceBase();
00653   if ( !end.isValid() ) {
00654     return start;
00655   }
00656   if ( !start.isValid() ) {
00657     return end;
00658   }
00659 
00660   return startDt.addSecs( start.secsTo( end ) );
00661 }
00662 
00663 void Incidence::addAttachment( Attachment *attachment )
00664 {
00665   if ( mReadOnly || !attachment ) {
00666     return;
00667   }
00668 
00669   d->mAttachments.append( attachment );
00670   updated();
00671 }
00672 
00673 void Incidence::deleteAttachment( Attachment *attachment )
00674 {
00675   d->mAttachments.removeRef( attachment );
00676 }
00677 
00678 void Incidence::deleteAttachments( const QString &mime )
00679 {
00680   Attachment::List::Iterator it = d->mAttachments.begin();
00681   while ( it != d->mAttachments.end() ) {
00682     if ( (*it)->mimeType() == mime ) {
00683       d->mAttachments.removeRef( it );
00684     } else {
00685       ++it;
00686     }
00687   }
00688 }
00689 
00690 Attachment::List Incidence::attachments() const
00691 {
00692   return d->mAttachments;
00693 }
00694 
00695 Attachment::List Incidence::attachments( const QString &mime ) const
00696 {
00697   Attachment::List attachments;
00698   Attachment::List::ConstIterator it;
00699   for ( it = d->mAttachments.begin(); it != d->mAttachments.end(); ++it ) {
00700     if ( (*it)->mimeType() == mime ) {
00701       attachments.append( *it );
00702     }
00703   }
00704   return attachments;
00705 }
00706 
00707 void Incidence::clearAttachments()
00708 {
00709   d->mAttachments.clearAll();
00710 }
00711 
00712 void Incidence::setResources( const QStringList &resources )
00713 {
00714   if ( mReadOnly ) {
00715     return;
00716   }
00717 
00718   d->mResources = resources;
00719   updated();
00720 }
00721 
00722 QStringList Incidence::resources() const
00723 {
00724   return d->mResources;
00725 }
00726 
00727 void Incidence::setPriority( int priority )
00728 {
00729   if ( mReadOnly ) {
00730     return;
00731   }
00732 
00733   d->mPriority = priority;
00734   updated();
00735 }
00736 
00737 int Incidence::priority() const
00738 {
00739   return d->mPriority;
00740 }
00741 
00742 void Incidence::setStatus( Incidence::Status status )
00743 {
00744   if ( mReadOnly || status == StatusX ) {
00745     return;
00746   }
00747 
00748   d->mStatus = status;
00749   d->mStatusString.clear();
00750   updated();
00751 }
00752 
00753 void Incidence::setCustomStatus( const QString &status )
00754 {
00755   if ( mReadOnly ) {
00756     return;
00757   }
00758 
00759   d->mStatus = status.isEmpty() ? StatusNone : StatusX;
00760   d->mStatusString = status;
00761   updated();
00762 }
00763 
00764 Incidence::Status Incidence::status() const
00765 {
00766   return d->mStatus;
00767 }
00768 
00769 QString Incidence::statusStr() const
00770 {
00771   if ( d->mStatus == StatusX ) {
00772     return d->mStatusString;
00773   }
00774 
00775   return statusName( d->mStatus );
00776 }
00777 
00778 QString Incidence::statusName( Incidence::Status status )
00779 {
00780   switch ( status ) {
00781   case StatusTentative:
00782     return i18nc( "@item event is tentative", "Tentative" );
00783   case StatusConfirmed:
00784     return i18nc( "@item event is definite", "Confirmed" );
00785   case StatusCompleted:
00786     return i18nc( "@item to-do is complete", "Completed" );
00787   case StatusNeedsAction:
00788     return i18nc( "@item to-do needs action", "Needs-Action" );
00789   case StatusCanceled:
00790     return i18nc( "@item event orto-do is canceled; journal is removed", "Canceled" );
00791   case StatusInProcess:
00792     return i18nc( "@item to-do is in process", "In-Process" );
00793   case StatusDraft:
00794     return i18nc( "@item journal is in draft form", "Draft" );
00795   case StatusFinal:
00796     return i18nc( "@item journal is in final form", "Final" );
00797   case StatusX:
00798   case StatusNone:
00799   default:
00800     return QString();
00801   }
00802 }
00803 
00804 void Incidence::setSecrecy( Incidence::Secrecy secrecy )
00805 {
00806   if ( mReadOnly ) {
00807     return;
00808   }
00809 
00810   d->mSecrecy = secrecy;
00811   updated();
00812 }
00813 
00814 Incidence::Secrecy Incidence::secrecy() const
00815 {
00816   return d->mSecrecy;
00817 }
00818 
00819 QString Incidence::secrecyStr() const
00820 {
00821   return secrecyName( d->mSecrecy );
00822 }
00823 
00824 QString Incidence::secrecyName( Incidence::Secrecy secrecy )
00825 {
00826   switch ( secrecy ) {
00827   case SecrecyPublic:
00828     return i18nc( "@item incidence access if for everyone", "Public" );
00829   case SecrecyPrivate:
00830     return i18nc( "@item incidence access is by owner only", "Private" );
00831   case SecrecyConfidential:
00832     return i18nc( "@item incidence access is by owner and a controlled group", "Confidential" );
00833   default:
00834     return QString();  // to make compilers happy
00835   }
00836 }
00837 
00838 QStringList Incidence::secrecyList()
00839 {
00840   QStringList list;
00841   list << secrecyName( SecrecyPublic );
00842   list << secrecyName( SecrecyPrivate );
00843   list << secrecyName( SecrecyConfidential );
00844 
00845   return list;
00846 }
00847 
00848 const Alarm::List &Incidence::alarms() const
00849 {
00850   return d->mAlarms;
00851 }
00852 
00853 Alarm *Incidence::newAlarm()
00854 {
00855   Alarm *alarm = new Alarm( this );
00856   d->mAlarms.append( alarm );
00857   return alarm;
00858 }
00859 
00860 void Incidence::addAlarm( Alarm *alarm )
00861 {
00862   d->mAlarms.append( alarm );
00863   updated();
00864 }
00865 
00866 void Incidence::removeAlarm( Alarm *alarm )
00867 {
00868   d->mAlarms.removeRef( alarm );
00869   updated();
00870 }
00871 
00872 void Incidence::clearAlarms()
00873 {
00874   d->mAlarms.clearAll();
00875   updated();
00876 }
00877 
00878 bool Incidence::isAlarmEnabled() const
00879 {
00880   Alarm::List::ConstIterator it;
00881   for ( it = d->mAlarms.begin(); it != d->mAlarms.end(); ++it ) {
00882     if ( (*it)->enabled() ) {
00883       return true;
00884     }
00885   }
00886   return false;
00887 }
00888 
00889 void Incidence::setLocation( const QString &location, bool isRich )
00890 {
00891   if ( mReadOnly ) {
00892     return;
00893   }
00894 
00895   d->mLocation = location;
00896   d->mLocationIsRich = isRich;
00897   updated();
00898 }
00899 
00900 void Incidence::setLocation( const QString &location )
00901 {
00902   setLocation( location, Qt::mightBeRichText( location ) );
00903 }
00904 
00905 QString Incidence::location() const
00906 {
00907   return d->mLocation;
00908 }
00909 
00910 QString Incidence::richLocation() const
00911 {
00912   if ( locationIsRich() ) {
00913     return d->mLocation;
00914   } else {
00915     return Qt::escape( d->mLocation ).replace( '\n', "<br/>" );
00916   }
00917 }
00918 
00919 bool Incidence::locationIsRich() const
00920 {
00921   return d->mLocationIsRich;
00922 }
00923 
00924 void Incidence::setSchedulingID( const QString &sid )
00925 {
00926   d->mSchedulingID = sid;
00927 }
00928 
00929 QString Incidence::schedulingID() const
00930 {
00931   if ( d->mSchedulingID.isNull() ) {
00932     // Nothing set, so use the normal uid
00933     return uid();
00934   }
00935   return d->mSchedulingID;
00936 }
00937 
00941 void Incidence::recurrenceUpdated( Recurrence *recurrence )
00942 {
00943   if ( recurrence == d->mRecurrence ) {
00944     updated();
00945   }
00946 }

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
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.4
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