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