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