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