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

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
  •   contact
  •   kmime
  • kabc
  • kblog
  • kcal
  • kholidays
  • kimap
  • kioslave
  •   imap4
  •   mbox
  •   nntp
  • kldap
  • kmime
  • kontactinterface
  • kpimidentities
  • kpimtextedit
  •   richtextbuilders
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • microblog
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.6.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