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

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