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 if ( d->mRelatedToUid == incidence->uid() ) {
00520 d->mRelatedToUid.clear();
00521 }
00522
00523 }
00524
00525
00526
00527 Recurrence *Incidence::recurrence() const
00528 {
00529 if ( !d->mRecurrence ) {
00530 d->mRecurrence = new Recurrence();
00531 d->mRecurrence->setStartDateTime( IncidenceBase::dtStart() );
00532 d->mRecurrence->setAllDay( allDay() );
00533 d->mRecurrence->setRecurReadOnly( mReadOnly );
00534 d->mRecurrence->addObserver( const_cast<KCal::Incidence*>( this ) );
00535 }
00536
00537 return d->mRecurrence;
00538 }
00539
00540 void Incidence::clearRecurrence()
00541 {
00542 delete d->mRecurrence;
00543 d->mRecurrence = 0;
00544 }
00545
00546 ushort Incidence::recurrenceType() const
00547 {
00548 if ( d->mRecurrence ) {
00549 return d->mRecurrence->recurrenceType();
00550 } else {
00551 return Recurrence::rNone;
00552 }
00553 }
00554
00555 bool Incidence::recurs() const
00556 {
00557 if ( d->mRecurrence ) {
00558 return d->mRecurrence->recurs();
00559 } else {
00560 return false;
00561 }
00562 }
00563
00564 bool Incidence::recursOn( const QDate &date,
00565 const KDateTime::Spec &timeSpec ) const
00566 {
00567 return d->mRecurrence && d->mRecurrence->recursOn( date, timeSpec );
00568 }
00569
00570 bool Incidence::recursAt( const KDateTime &qdt ) const
00571 {
00572 return d->mRecurrence && d->mRecurrence->recursAt( qdt );
00573 }
00574
00575 QList<KDateTime> Incidence::startDateTimesForDate( const QDate &date,
00576 const KDateTime::Spec &timeSpec ) const
00577 {
00578 KDateTime start = dtStart();
00579 KDateTime end = endDateRecurrenceBase();
00580
00581 QList<KDateTime> result;
00582
00583
00584 if ( !start.isValid() && ! end.isValid() ) {
00585 return result;
00586 }
00587
00588
00589 KDateTime kdate( date, timeSpec );
00590 if ( !recurs() ) {
00591 if ( !( start > kdate || end < kdate ) ) {
00592 result << start;
00593 }
00594 return result;
00595 }
00596
00597 int days = start.daysTo( end );
00598
00599 QDate tmpday( date.addDays( -days - 1 ) );
00600 KDateTime tmp;
00601 while ( tmpday <= date ) {
00602 if ( recurrence()->recursOn( tmpday, timeSpec ) ) {
00603 QList<QTime> times = recurrence()->recurTimesOn( tmpday, timeSpec );
00604 foreach ( const QTime &time, times ) {
00605 tmp = KDateTime( tmpday, time, start.timeSpec() );
00606 if ( endDateForStart( tmp ) >= kdate ) {
00607 result << tmp;
00608 }
00609 }
00610 }
00611 tmpday = tmpday.addDays( 1 );
00612 }
00613 return result;
00614 }
00615
00616 QList<KDateTime> Incidence::startDateTimesForDateTime( const KDateTime &datetime ) const
00617 {
00618 KDateTime start = dtStart();
00619 KDateTime end = endDateRecurrenceBase();
00620
00621 QList<KDateTime> result;
00622
00623
00624 if ( !start.isValid() && ! end.isValid() ) {
00625 return result;
00626 }
00627
00628
00629 if ( !recurs() ) {
00630 if ( !( start > datetime || end < datetime ) ) {
00631 result << start;
00632 }
00633 return result;
00634 }
00635
00636 int days = start.daysTo( end );
00637
00638 QDate tmpday( datetime.date().addDays( -days - 1 ) );
00639 KDateTime tmp;
00640 while ( tmpday <= datetime.date() ) {
00641 if ( recurrence()->recursOn( tmpday, datetime.timeSpec() ) ) {
00642
00643 QList<QTime> times = recurrence()->recurTimesOn( tmpday, start.timeSpec() );
00644 foreach ( const QTime &time, times ) {
00645 tmp = KDateTime( tmpday, time, start.timeSpec() );
00646 if ( !( tmp > datetime || endDateForStart( tmp ) < datetime ) ) {
00647 result << tmp;
00648 }
00649 }
00650 }
00651 tmpday = tmpday.addDays( 1 );
00652 }
00653 return result;
00654 }
00655
00656 KDateTime Incidence::endDateForStart( const KDateTime &startDt ) const
00657 {
00658 KDateTime start = dtStart();
00659 KDateTime end = endDateRecurrenceBase();
00660 if ( !end.isValid() ) {
00661 return start;
00662 }
00663 if ( !start.isValid() ) {
00664 return end;
00665 }
00666
00667 return startDt.addSecs( start.secsTo( end ) );
00668 }
00669
00670 void Incidence::addAttachment( Attachment *attachment )
00671 {
00672 if ( mReadOnly || !attachment ) {
00673 return;
00674 }
00675
00676 d->mAttachments.append( attachment );
00677 updated();
00678 }
00679
00680 void Incidence::deleteAttachment( Attachment *attachment )
00681 {
00682 d->mAttachments.removeRef( attachment );
00683 }
00684
00685 void Incidence::deleteAttachments( const QString &mime )
00686 {
00687 Attachment::List::Iterator it = d->mAttachments.begin();
00688 while ( it != d->mAttachments.end() ) {
00689 if ( (*it)->mimeType() == mime ) {
00690 d->mAttachments.removeRef( it );
00691 } else {
00692 ++it;
00693 }
00694 }
00695 }
00696
00697 Attachment::List Incidence::attachments() const
00698 {
00699 return d->mAttachments;
00700 }
00701
00702 Attachment::List Incidence::attachments( const QString &mime ) const
00703 {
00704 Attachment::List attachments;
00705 Attachment::List::ConstIterator it;
00706 foreach ( Attachment *attachment, d->mAttachments ) {
00707 if ( attachment->mimeType() == mime ) {
00708 attachments.append( attachment );
00709 }
00710 }
00711 return attachments;
00712 }
00713
00714 void Incidence::clearAttachments()
00715 {
00716 d->mAttachments.clearAll();
00717 }
00718
00719 void Incidence::setResources( const QStringList &resources )
00720 {
00721 if ( mReadOnly ) {
00722 return;
00723 }
00724
00725 d->mResources = resources;
00726 updated();
00727 }
00728
00729 QStringList Incidence::resources() const
00730 {
00731 return d->mResources;
00732 }
00733
00734 void Incidence::setPriority( int priority )
00735 {
00736 if ( mReadOnly ) {
00737 return;
00738 }
00739
00740 d->mPriority = priority;
00741 updated();
00742 }
00743
00744 int Incidence::priority() const
00745 {
00746 return d->mPriority;
00747 }
00748
00749 void Incidence::setStatus( Incidence::Status status )
00750 {
00751 if ( mReadOnly || status == StatusX ) {
00752 return;
00753 }
00754
00755 d->mStatus = status;
00756 d->mStatusString.clear();
00757 updated();
00758 }
00759
00760 void Incidence::setCustomStatus( const QString &status )
00761 {
00762 if ( mReadOnly ) {
00763 return;
00764 }
00765
00766 d->mStatus = status.isEmpty() ? StatusNone : StatusX;
00767 d->mStatusString = status;
00768 updated();
00769 }
00770
00771 Incidence::Status Incidence::status() const
00772 {
00773 return d->mStatus;
00774 }
00775
00776 QString Incidence::statusStr() const
00777 {
00778 if ( d->mStatus == StatusX ) {
00779 return d->mStatusString;
00780 }
00781
00782 return statusName( d->mStatus );
00783 }
00784
00785 QString Incidence::statusName( Incidence::Status status )
00786 {
00787 switch ( status ) {
00788 case StatusTentative:
00789 return i18nc( "@item event is tentative", "Tentative" );
00790 case StatusConfirmed:
00791 return i18nc( "@item event is definite", "Confirmed" );
00792 case StatusCompleted:
00793 return i18nc( "@item to-do is complete", "Completed" );
00794 case StatusNeedsAction:
00795 return i18nc( "@item to-do needs action", "Needs-Action" );
00796 case StatusCanceled:
00797 return i18nc( "@item event orto-do is canceled; journal is removed", "Canceled" );
00798 case StatusInProcess:
00799 return i18nc( "@item to-do is in process", "In-Process" );
00800 case StatusDraft:
00801 return i18nc( "@item journal is in draft form", "Draft" );
00802 case StatusFinal:
00803 return i18nc( "@item journal is in final form", "Final" );
00804 case StatusX:
00805 case StatusNone:
00806 default:
00807 return QString();
00808 }
00809 }
00810
00811 void Incidence::setSecrecy( Incidence::Secrecy secrecy )
00812 {
00813 if ( mReadOnly ) {
00814 return;
00815 }
00816
00817 d->mSecrecy = secrecy;
00818 updated();
00819 }
00820
00821 Incidence::Secrecy Incidence::secrecy() const
00822 {
00823 return d->mSecrecy;
00824 }
00825
00826 QString Incidence::secrecyStr() const
00827 {
00828 return secrecyName( d->mSecrecy );
00829 }
00830
00831 QString Incidence::secrecyName( Incidence::Secrecy secrecy )
00832 {
00833 switch ( secrecy ) {
00834 case SecrecyPublic:
00835 return i18nc( "@item incidence access if for everyone", "Public" );
00836 case SecrecyPrivate:
00837 return i18nc( "@item incidence access is by owner only", "Private" );
00838 case SecrecyConfidential:
00839 return i18nc( "@item incidence access is by owner and a controlled group", "Confidential" );
00840 default:
00841 return QString();
00842 }
00843 }
00844
00845 QStringList Incidence::secrecyList()
00846 {
00847 QStringList list;
00848 list << secrecyName( SecrecyPublic );
00849 list << secrecyName( SecrecyPrivate );
00850 list << secrecyName( SecrecyConfidential );
00851
00852 return list;
00853 }
00854
00855 const Alarm::List &Incidence::alarms() const
00856 {
00857 return d->mAlarms;
00858 }
00859
00860 Alarm *Incidence::newAlarm()
00861 {
00862 Alarm *alarm = new Alarm( this );
00863 d->mAlarms.append( alarm );
00864 return alarm;
00865 }
00866
00867 void Incidence::addAlarm( Alarm *alarm )
00868 {
00869 d->mAlarms.append( alarm );
00870 updated();
00871 }
00872
00873 void Incidence::removeAlarm( Alarm *alarm )
00874 {
00875 d->mAlarms.removeRef( alarm );
00876 updated();
00877 }
00878
00879 void Incidence::clearAlarms()
00880 {
00881 d->mAlarms.clearAll();
00882 updated();
00883 }
00884
00885 bool Incidence::isAlarmEnabled() const
00886 {
00887 foreach ( Alarm *alarm, d->mAlarms ) {
00888 if ( alarm->enabled() ) {
00889 return true;
00890 }
00891 }
00892 return false;
00893 }
00894
00895 void Incidence::setLocation( const QString &location, bool isRich )
00896 {
00897 if ( mReadOnly ) {
00898 return;
00899 }
00900
00901 d->mLocation = location;
00902 d->mLocationIsRich = isRich;
00903 updated();
00904 }
00905
00906 void Incidence::setLocation( const QString &location )
00907 {
00908 setLocation( location, Qt::mightBeRichText( location ) );
00909 }
00910
00911 QString Incidence::location() const
00912 {
00913 return d->mLocation;
00914 }
00915
00916 QString Incidence::richLocation() const
00917 {
00918 if ( locationIsRich() ) {
00919 return d->mLocation;
00920 } else {
00921 return Qt::escape( d->mLocation ).replace( '\n', "<br/>" );
00922 }
00923 }
00924
00925 bool Incidence::locationIsRich() const
00926 {
00927 return d->mLocationIsRich;
00928 }
00929
00930 void Incidence::setSchedulingID( const QString &sid )
00931 {
00932 d->mSchedulingID = sid;
00933 }
00934
00935 QString Incidence::schedulingID() const
00936 {
00937 if ( d->mSchedulingID.isNull() ) {
00938
00939 return uid();
00940 }
00941 return d->mSchedulingID;
00942 }
00943
00947 void Incidence::recurrenceUpdated( Recurrence *recurrence )
00948 {
00949 if ( recurrence == d->mRecurrence ) {
00950 updated();
00951 }
00952 }