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

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
  • kholidays
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  • kpimtextedit
  •   richtextbuilders
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • microblog
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.8
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal