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