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

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