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