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