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

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