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