00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
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>
00044
00045 using namespace KCal;
00046
00051
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
00085
00086
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;
00100 int mRevision;
00101
00102 QString mDescription;
00103 bool mDescriptionIsRich;
00104 QString mSummary;
00105 bool mSummaryIsRich;
00106 QString mLocation;
00107 bool mLocationIsRich;
00108 QStringList mCategories;
00109 mutable Recurrence *mRecurrence;
00110 Attachment::List mAttachments;
00111 Alarm::List mAlarms;
00112 QStringList mResources;
00113 Status mStatus;
00114 QString mStatusString;
00115 Secrecy mSecrecy;
00116 int mPriority;
00117 QString mSchedulingID;
00118
00119 Incidence *mRelatedTo;
00120 QString mRelatedToUid;
00121 Incidence::List mRelations;
00122 };
00123
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
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
00148 d->mRelatedTo = 0;
00149 d->mRelatedToUid = i.d->mRelatedToUid;
00150
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
00159
00160
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
00200
00201 static bool stringCompare( const QString &s1, const QString &s2 )
00202 {
00203 return s1.isEmpty() && s2.isEmpty() || s1 == s2;
00204 }
00205
00206
00207 Incidence &Incidence::operator=( const Incidence &other )
00208 {
00209 d->clear();
00210
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;
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
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
00304
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
00517 }
00518
00519
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
00578 if ( !start.isValid() && ! end.isValid() ) {
00579 return result;
00580 }
00581
00582
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
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
00618 if ( !start.isValid() && ! end.isValid() ) {
00619 return result;
00620 }
00621
00622
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
00632 QDate tmpday( datetime.date().addDays( -days - 1 ) );
00633 KDateTime tmp;
00634 while ( tmpday <= datetime.date() ) {
00635 if ( recurrence()->recursOn( tmpday, datetime.timeSpec() ) ) {
00636
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();
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
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 }