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