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