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

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