libkcal
incidence.cpp00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <tdeglobal.h>
00024 #include <tdelocale.h>
00025 #include <kdebug.h>
00026
00027 #include "calformat.h"
00028
00029 #include "incidence.h"
00030 #include "calendar.h"
00031
00032 using namespace KCal;
00033
00034 Incidence::Incidence() :
00035 IncidenceBase(),
00036 mRelatedTo(0), mStatus(StatusNone), mSecrecy(SecrecyPublic),
00037 mPriority(0), mRecurrence(0),
00038 mHasRecurrenceID( false ), mChildRecurrenceEvents()
00039 {
00040 recreate();
00041
00042 mAlarms.setAutoDelete(true);
00043 mAttachments.setAutoDelete(true);
00044 }
00045
00046 Incidence::Incidence( const Incidence &i ) : IncidenceBase( i ),Recurrence::Observer()
00047 {
00048
00049 mRevision = i.mRevision;
00050 mCreated = i.mCreated;
00051 mDescription = i.mDescription;
00052 mSummary = i.mSummary;
00053 mCategories = i.mCategories;
00054
00055 mRelatedTo = 0;
00056 mRelatedToUid = i.mRelatedToUid;
00057
00058 mResources = i.mResources;
00059 mStatusString = i.mStatusString;
00060 mStatus = i.mStatus;
00061 mSecrecy = i.mSecrecy;
00062 mPriority = i.mPriority;
00063 mLocation = i.mLocation;
00064 mRecurrenceID = i.mRecurrenceID;
00065 mHasRecurrenceID = i.mHasRecurrenceID;
00066 mChildRecurrenceEvents = i.mChildRecurrenceEvents;
00067
00068
00069
00070
00071 Alarm::List::ConstIterator it;
00072 for( it = i.mAlarms.begin(); it != i.mAlarms.end(); ++it ) {
00073 Alarm *b = new Alarm( **it );
00074 b->setParent( this );
00075 mAlarms.append( b );
00076 }
00077 mAlarms.setAutoDelete(true);
00078
00079 Attachment::List::ConstIterator it1;
00080 for ( it1 = i.mAttachments.begin(); it1 != i.mAttachments.end(); ++it1 ) {
00081 Attachment *a = new Attachment( **it1 );
00082 mAttachments.append( a );
00083 }
00084 mAttachments.setAutoDelete( true );
00085
00086 if (i.mRecurrence) {
00087 mRecurrence = new Recurrence( *(i.mRecurrence) );
00088 mRecurrence->addObserver( this );
00089 } else
00090 mRecurrence = 0;
00091
00092 mSchedulingID = i.mSchedulingID;
00093 }
00094
00095 Incidence::~Incidence()
00096 {
00097 Incidence::List Relations = mRelations;
00098 List::ConstIterator it;
00099 for ( it = Relations.begin(); it != Relations.end(); ++it ) {
00100 if ( (*it)->relatedTo() == this ) (*it)->mRelatedTo = 0;
00101 }
00102 if ( relatedTo() ) relatedTo()->removeRelation( this );
00103
00104 delete mRecurrence;
00105 }
00106
00107
00108 static bool stringCompare( const TQString& s1, const TQString& s2 )
00109 {
00110 return ( s1.isEmpty() && s2.isEmpty() ) || (s1 == s2);
00111 }
00112
00113 Incidence& Incidence::operator=( const Incidence &i )
00114 {
00115 if ( &i == this )
00116 return *this;
00117 IncidenceBase::operator=( i );
00118 mRevision = i.mRevision;
00119 mCreated = i.mCreated;
00120 mDescription = i.mDescription;
00121 mSummary = i.mSummary;
00122 mCategories = i.mCategories;
00123 mRelatedTo = 0;
00124 mRelatedToUid = i.mRelatedToUid;
00125 mRelations.clear();
00126 mResources = i.mResources;
00127 mStatusString = i.mStatusString;
00128 mStatus = i.mStatus;
00129 mSecrecy = i.mSecrecy;
00130 mPriority = i.mPriority;
00131 mLocation = i.mLocation;
00132 mRecurrenceID = i.mRecurrenceID;
00133 mHasRecurrenceID = i.mHasRecurrenceID;
00134 mChildRecurrenceEvents = i.mChildRecurrenceEvents;
00135
00136 mAlarms.clearAll();
00137 Alarm::List::ConstIterator it;
00138 for( it = i.mAlarms.begin(); it != i.mAlarms.end(); ++it ) {
00139 Alarm *b = new Alarm( **it );
00140 b->setParent( this );
00141 mAlarms.append( b );
00142 }
00143
00144 mAttachments.clearAll();
00145 Attachment::List::ConstIterator it1;
00146 for ( it1 = i.mAttachments.begin(); it1 != i.mAttachments.end(); ++it1 ) {
00147 Attachment *a = new Attachment( **it1 );
00148 mAttachments.append( a );
00149 }
00150
00151 delete mRecurrence;
00152 if (i.mRecurrence) {
00153 mRecurrence = new Recurrence( *(i.mRecurrence) );
00154 mRecurrence->addObserver( this );
00155 } else
00156 mRecurrence = 0;
00157
00158 mSchedulingID = i.mSchedulingID;
00159 return *this;
00160 }
00161
00162 bool Incidence::operator==( const Incidence& i2 ) const
00163 {
00164 if( alarms().count() != i2.alarms().count() ) {
00165 return false;
00166 }
00167
00168 Alarm::List::ConstIterator a1 = alarms().begin();
00169 Alarm::List::ConstIterator a2 = i2.alarms().begin();
00170 for( ; a1 != alarms().end() && a2 != i2.alarms().end(); ++a1, ++a2 )
00171 if( **a1 == **a2 )
00172 continue;
00173 else {
00174 return false;
00175 }
00176
00177 if ( !IncidenceBase::operator==(i2) )
00178 return false;
00179
00180 bool recurrenceEqual = ( mRecurrence == 0 && i2.mRecurrence == 0 );
00181 if ( !recurrenceEqual )
00182 {
00183 recurrenceEqual = mRecurrence != 0 &&
00184 i2.mRecurrence != 0 &&
00185 *mRecurrence == *i2.mRecurrence;
00186 }
00187
00188 return
00189 recurrenceEqual &&
00190 created() == i2.created() &&
00191 stringCompare( description(), i2.description() ) &&
00192 stringCompare( summary(), i2.summary() ) &&
00193 categories() == i2.categories() &&
00194
00195 stringCompare( relatedToUid(), i2.relatedToUid() ) &&
00196 relations() == i2.relations() &&
00197 attachments() == i2.attachments() &&
00198 resources() == i2.resources() &&
00199 mStatus == i2.mStatus &&
00200 ( mStatus == StatusNone || stringCompare( mStatusString, i2.mStatusString ) ) &&
00201 secrecy() == i2.secrecy() &&
00202 priority() == i2.priority() &&
00203 stringCompare( location(), i2.location() ) &&
00204 stringCompare( schedulingID(), i2.schedulingID() );
00205 }
00206
00207
00208 void Incidence::recreate()
00209 {
00210 setCreated(TQDateTime::currentDateTime());
00211
00212 setUid(CalFormat::createUniqueId());
00213 setSchedulingID( TQString() );
00214
00215 setRevision(0);
00216
00217 setLastModified(TQDateTime::currentDateTime());
00218 setPilotId( 0 );
00219 setSyncStatus( SYNCNONE );
00220 }
00221
00222 void Incidence::setReadOnly( bool readOnly )
00223 {
00224 IncidenceBase::setReadOnly( readOnly );
00225 if ( mRecurrence )
00226 mRecurrence->setRecurReadOnly( readOnly );
00227 }
00228
00229 void Incidence::setFloats(bool f)
00230 {
00231 if (mReadOnly) return;
00232 if ( recurrence() )
00233 recurrence()->setFloats( f );
00234 IncidenceBase::setFloats( f );
00235 }
00236
00237 void Incidence::setCreated( const TQDateTime &created )
00238 {
00239 if (mReadOnly) return;
00240 mCreated = created;
00241
00242
00243
00244 }
00245
00246 TQDateTime Incidence::created() const
00247 {
00248 return mCreated;
00249 }
00250
00251 void Incidence::setRevision( int rev )
00252 {
00253 if (mReadOnly) return;
00254 mRevision = rev;
00255
00256 updated();
00257 }
00258
00259 int Incidence::revision() const
00260 {
00261 return mRevision;
00262 }
00263
00264 void Incidence::setDtStart(const TQDateTime &dtStart)
00265 {
00266 if ( mRecurrence ) {
00267 mRecurrence->setStartDateTime( dtStart );
00268 mRecurrence->setFloats( doesFloat() );
00269 }
00270 IncidenceBase::setDtStart( dtStart );
00271 }
00272
00273 void Incidence::setDescription(const TQString &description)
00274 {
00275 if (mReadOnly) return;
00276 mDescription = description;
00277 updated();
00278 }
00279
00280 TQString Incidence::description() const
00281 {
00282 return mDescription;
00283 }
00284
00285
00286 void Incidence::setSummary(const TQString &summary)
00287 {
00288 if (mReadOnly) return;
00289 mSummary = summary;
00290 updated();
00291 }
00292
00293 TQString Incidence::summary() const
00294 {
00295 return mSummary;
00296 }
00297
00298 void Incidence::setCategories(const TQStringList &categories)
00299 {
00300 if (mReadOnly) return;
00301 mCategories = categories;
00302 updated();
00303 }
00304
00305
00306 void Incidence::setCategories(const TQString &catStr)
00307 {
00308 if (mReadOnly) return;
00309 mCategories.clear();
00310
00311 if (catStr.isEmpty()) return;
00312
00313 mCategories = TQStringList::split(",",catStr);
00314
00315 TQStringList::Iterator it;
00316 for(it = mCategories.begin();it != mCategories.end(); ++it) {
00317 *it = (*it).stripWhiteSpace();
00318 }
00319
00320 updated();
00321 }
00322
00323 TQStringList Incidence::categories() const
00324 {
00325 return mCategories;
00326 }
00327
00328 TQString Incidence::categoriesStr() const
00329 {
00330 return mCategories.join(",");
00331 }
00332
00333 void Incidence::setRelatedToUid(const TQString &relatedToUid)
00334 {
00335 if ( mReadOnly || mRelatedToUid == relatedToUid ) return;
00336 mRelatedToUid = relatedToUid;
00337 updated();
00338 }
00339
00340 TQString Incidence::relatedToUid() const
00341 {
00342 return mRelatedToUid;
00343 }
00344
00345 void Incidence::setRelatedTo(Incidence *relatedTo)
00346 {
00347 if (mReadOnly || mRelatedTo == relatedTo) return;
00348 if(mRelatedTo)
00349 mRelatedTo->removeRelation(this);
00350 mRelatedTo = relatedTo;
00351 if (mRelatedTo) {
00352 mRelatedTo->addRelation(this);
00353 if ( mRelatedTo->uid() != mRelatedToUid )
00354 setRelatedToUid( mRelatedTo->uid() );
00355 } else {
00356 setRelatedToUid( TQString() );
00357 }
00358 }
00359
00360 Incidence *Incidence::relatedTo() const
00361 {
00362 return mRelatedTo;
00363 }
00364
00365 Incidence::List Incidence::relations() const
00366 {
00367 return mRelations;
00368 }
00369
00370 void Incidence::addRelation( Incidence *event )
00371 {
00372 if ( mRelations.find( event ) == mRelations.end() ) {
00373 mRelations.append( event );
00374 }
00375 }
00376
00377 void Incidence::removeRelation(Incidence *event)
00378
00379
00380 {
00381 mRelations.removeRef(event);
00382
00383 mRelatedToUid=TQString();
00384 }
00385
00386
00387
00388
00389
00390 Recurrence *Incidence::recurrence() const
00391 {
00392 if (!mRecurrence)
00393 {
00394 const_cast<KCal::Incidence*>(this)->mRecurrence = new Recurrence();
00395 mRecurrence->setStartDateTime( IncidenceBase::dtStart() );
00396 mRecurrence->setFloats( doesFloat() );
00397 mRecurrence->setRecurReadOnly( mReadOnly );
00398 mRecurrence->addObserver( const_cast<KCal::Incidence*>(this) );
00399 }
00400
00401 return mRecurrence;
00402 }
00403
00404 void Incidence::clearRecurrence()
00405 {
00406 delete mRecurrence;
00407 mRecurrence = 0;
00408 }
00409
00410 uint Incidence::recurrenceType() const
00411 {
00412 if ( mRecurrence ) return mRecurrence->recurrenceType();
00413 else return Recurrence::rNone;
00414 }
00415
00416 bool Incidence::doesRecur() const
00417 {
00418 if ( mRecurrence ) return mRecurrence->doesRecur();
00419 else return false;
00420 }
00421
00422 bool Incidence::recursOn(const TQDate &qd) const
00423 {
00424 bool doesRecur = false;
00425 doesRecur = mRecurrence && mRecurrence->recursOn(qd);
00426
00427 return doesRecur;
00428 }
00429
00430 bool Incidence::recursAt(const TQDateTime &qdt) const
00431 {
00432 bool doesRecur = false;
00433 doesRecur = mRecurrence && mRecurrence->recursAt(qdt);
00434
00435 return doesRecur;
00436 }
00437
00438 bool Incidence::recursOn(const TQDate &qd, Calendar *cal) const
00439 {
00440 bool doesRecur = false;
00441 doesRecur = mRecurrence && mRecurrence->recursOn(qd);
00442
00443
00444 if (hasRecurrenceID() == false) {
00445 IncidenceList il = childIncidences();
00446 IncidenceListIterator it;
00447 for ( it = il.begin(); it != il.end(); ++it ) {
00448 TQDateTime modifiedDt = cal->incidence(*it)->recurrenceID();
00449 modifiedDt.setTime(TQTime());
00450 if (TQDateTime(qd) == modifiedDt) {
00451 doesRecur = false;
00452 }
00453 }
00454 }
00455
00456 return doesRecur;
00457 }
00458
00459 bool Incidence::recursAt(const TQDateTime &qdt, Calendar *cal) const
00460 {
00461 bool doesRecur = false;
00462 doesRecur = mRecurrence && mRecurrence->recursAt(qdt);
00463
00464
00465 if (hasRecurrenceID() == false) {
00466 IncidenceList il = childIncidences();
00467 IncidenceListIterator it;
00468 for ( it = il.begin(); it != il.end(); ++it ) {
00469 if (qdt == cal->incidence(*it)->recurrenceID()) {
00470 doesRecur = false;
00471 }
00472 }
00473 }
00474
00475 return doesRecur;
00476 }
00477
00486 TQValueList<TQDateTime> Incidence::startDateTimesForDate( const TQDate &date ) const
00487 {
00488
00489 TQDateTime start = dtStart();
00490 TQDateTime end = endDateRecurrenceBase();
00491
00492 TQValueList<TQDateTime> result;
00493
00494
00495 if ( !start.isValid() && ! end.isValid() ) {
00496 return result;
00497 }
00498
00499
00500 if ( !doesRecur() ) {
00501 if ( !(start.date() > date || end.date() < date ) ) {
00502 result << start;
00503 }
00504 return result;
00505 }
00506
00507 int days = start.daysTo( end );
00508
00509 TQDate tmpday( date.addDays( -days - 1 ) );
00510 TQDateTime tmp;
00511 while ( tmpday <= date ) {
00512 if ( recurrence()->recursOn( tmpday ) ) {
00513 TQValueList<TQTime> times = recurrence()->recurTimesOn( tmpday );
00514 for ( TQValueList<TQTime>::ConstIterator it = times.begin(); it != times.end(); ++it ) {
00515 tmp = TQDateTime( tmpday, *it );
00516 if ( endDateForStart( tmp ).date() >= date )
00517 result << tmp;
00518 }
00519 }
00520 tmpday = tmpday.addDays( 1 );
00521 }
00522 return result;
00523 }
00524
00533 TQValueList<TQDateTime> Incidence::startDateTimesForDateTime( const TQDateTime &datetime ) const
00534 {
00535
00536 TQDateTime start = dtStart();
00537 TQDateTime end = endDateRecurrenceBase();
00538
00539 TQValueList<TQDateTime> result;
00540
00541
00542 if ( !start.isValid() && ! end.isValid() ) {
00543 return result;
00544 }
00545
00546
00547 if ( !doesRecur() ) {
00548 if ( !(start > datetime || end < datetime ) ) {
00549 result << start;
00550 }
00551 return result;
00552 }
00553
00554 int days = start.daysTo( end );
00555
00556 TQDate tmpday( datetime.date().addDays( -days - 1 ) );
00557 TQDateTime tmp;
00558 while ( tmpday <= datetime.date() ) {
00559 if ( recurrence()->recursOn( tmpday ) ) {
00560 TQValueList<TQTime> times = recurrence()->recurTimesOn( tmpday );
00561 for ( TQValueList<TQTime>::ConstIterator it = times.begin(); it != times.end(); ++it ) {
00562 tmp = TQDateTime( tmpday, *it );
00563 if ( !(tmp > datetime || endDateForStart( tmp ) < datetime ) )
00564 result << tmp;
00565 }
00566 }
00567 tmpday = tmpday.addDays( 1 );
00568 }
00569 return result;
00570 }
00571
00573 TQDateTime Incidence::endDateForStart( const TQDateTime &startDt ) const
00574 {
00575 TQDateTime start = dtStart();
00576 TQDateTime end = endDateRecurrenceBase();
00577 if ( !end.isValid() ) return start;
00578 if ( !start.isValid() ) return end;
00579
00580 return startDt.addSecs( start.secsTo( end ) );
00581 }
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674 void Incidence::addAttachment(Attachment *attachment)
00675 {
00676 if (mReadOnly || !attachment) return;
00677 mAttachments.append(attachment);
00678 updated();
00679 }
00680
00681 void Incidence::deleteAttachment(Attachment *attachment)
00682 {
00683 mAttachments.removeRef(attachment);
00684 }
00685
00686 void Incidence::deleteAttachments( const TQString &mime )
00687 {
00688 Attachment::List::Iterator it = mAttachments.begin();
00689 while( it != mAttachments.end() ) {
00690 if ( (*it)->mimeType() == mime ) mAttachments.remove( it );
00691 else ++it;
00692 }
00693 }
00694
00695 Attachment::List Incidence::attachments() const
00696 {
00697 return mAttachments;
00698 }
00699
00700 Attachment::List Incidence::attachments(const TQString& mime) const
00701 {
00702 Attachment::List attachments;
00703 Attachment::List::ConstIterator it;
00704 for( it = mAttachments.begin(); it != mAttachments.end(); ++it ) {
00705 if ( (*it)->mimeType() == mime ) attachments.append( *it );
00706 }
00707
00708 return attachments;
00709 }
00710
00711 void Incidence::clearAttachments()
00712 {
00713 mAttachments.clearAll();
00714 }
00715
00716 void Incidence::setResources(const TQStringList &resources)
00717 {
00718 if (mReadOnly) return;
00719 mResources = resources;
00720 updated();
00721 }
00722
00723 TQStringList Incidence::resources() const
00724 {
00725 return mResources;
00726 }
00727
00728
00729 void Incidence::setPriority(int priority)
00730 {
00731 if (mReadOnly) return;
00732 mPriority = priority;
00733 updated();
00734 }
00735
00736 int Incidence::priority() const
00737 {
00738 return mPriority;
00739 }
00740
00741 void Incidence::setStatus(Incidence::Status status)
00742 {
00743 if (mReadOnly || status == StatusX) return;
00744 mStatus = status;
00745 mStatusString = TQString();
00746 updated();
00747 }
00748
00749 void Incidence::setCustomStatus(const TQString &status)
00750 {
00751 if (mReadOnly) return;
00752 mStatus = status.isEmpty() ? StatusNone : StatusX;
00753 mStatusString = status;
00754 updated();
00755 }
00756
00757 Incidence::Status Incidence::status() const
00758 {
00759 return mStatus;
00760 }
00761
00762 TQString Incidence::statusStr() const
00763 {
00764 if (mStatus == StatusX)
00765 return mStatusString;
00766 return statusName(mStatus);
00767 }
00768
00769 TQString Incidence::statusName(Incidence::Status status)
00770 {
00771 switch (status) {
00772 case StatusTentative: return i18n("incidence status", "Tentative");
00773 case StatusConfirmed: return i18n("Confirmed");
00774 case StatusCompleted: return i18n("Completed");
00775 case StatusNeedsAction: return i18n("Needs-Action");
00776 case StatusCanceled: return i18n("Canceled");
00777 case StatusInProcess: return i18n("In-Process");
00778 case StatusDraft: return i18n("Draft");
00779 case StatusFinal: return i18n("Final");
00780 case StatusX:
00781 case StatusNone:
00782 default: return TQString();
00783 }
00784 }
00785
00786 void Incidence::setSecrecy(int sec)
00787 {
00788 if (mReadOnly) return;
00789 mSecrecy = sec;
00790 updated();
00791 }
00792
00793 int Incidence::secrecy() const
00794 {
00795 return mSecrecy;
00796 }
00797
00798 TQString Incidence::secrecyStr() const
00799 {
00800 return secrecyName(mSecrecy);
00801 }
00802
00803 TQString Incidence::secrecyName(int secrecy)
00804 {
00805 switch (secrecy) {
00806 case SecrecyPublic:
00807 return i18n("Public");
00808 case SecrecyPrivate:
00809 return i18n("Private");
00810 case SecrecyConfidential:
00811 return i18n("Confidential");
00812 default:
00813 return i18n("Undefined");
00814 }
00815 }
00816
00817 TQStringList Incidence::secrecyList()
00818 {
00819 TQStringList list;
00820 list << secrecyName(SecrecyPublic);
00821 list << secrecyName(SecrecyPrivate);
00822 list << secrecyName(SecrecyConfidential);
00823
00824 return list;
00825 }
00826
00827
00828 const Alarm::List &Incidence::alarms() const
00829 {
00830 return mAlarms;
00831 }
00832
00833 Alarm* Incidence::newAlarm()
00834 {
00835 Alarm* alarm = new Alarm(this);
00836 mAlarms.append(alarm);
00837
00838 return alarm;
00839 }
00840
00841 void Incidence::addAlarm(Alarm *alarm)
00842 {
00843 mAlarms.append(alarm);
00844 updated();
00845 }
00846
00847 void Incidence::removeAlarm(Alarm *alarm)
00848 {
00849 mAlarms.removeRef(alarm);
00850 updated();
00851 }
00852
00853 void Incidence::clearAlarms()
00854 {
00855 mAlarms.clearAll();
00856 updated();
00857 }
00858
00859 bool Incidence::isAlarmEnabled() const
00860 {
00861 Alarm::List::ConstIterator it;
00862 for( it = mAlarms.begin(); it != mAlarms.end(); ++it ) {
00863 if ( (*it)->enabled() ) return true;
00864 }
00865 return false;
00866 }
00867
00868 void Incidence::setLocation(const TQString &location)
00869 {
00870 if (mReadOnly) return;
00871 mLocation = location;
00872 updated();
00873 }
00874
00875 TQString Incidence::location() const
00876 {
00877 return mLocation;
00878 }
00879
00880 void Incidence::setSchedulingID( const TQString& sid )
00881 {
00882 mSchedulingID = sid;
00883 }
00884
00885 TQString Incidence::schedulingID() const
00886 {
00887 if ( mSchedulingID.isNull() )
00888
00889 return uid();
00890 return mSchedulingID;
00891 }
00892
00893 bool Incidence::hasRecurrenceID() const
00894 {
00895 return mHasRecurrenceID;
00896 }
00897
00898 void Incidence::setHasRecurrenceID( bool hasRecurrenceID )
00899 {
00900 if ( mReadOnly ) {
00901 return;
00902 }
00903
00904 mHasRecurrenceID = hasRecurrenceID;
00905 updated();
00906 }
00907
00908 TQDateTime Incidence::recurrenceID() const
00909 {
00910 return mRecurrenceID;
00911 }
00912
00913 void Incidence::setRecurrenceID( const TQDateTime &recurrenceID )
00914 {
00915 if ( mReadOnly ) {
00916 return;
00917 }
00918
00919
00920 mRecurrenceID = recurrenceID;
00921 updated();
00922 }
00923
00924 void Incidence::addChildIncidence( TQString childIncidence )
00925 {
00926 mChildRecurrenceEvents.append(childIncidence);
00927 }
00928
00929 void Incidence::deleteChildIncidence( TQString childIncidence )
00930 {
00931 mChildRecurrenceEvents.remove(childIncidence);
00932 }
00933
00934 IncidenceList Incidence::childIncidences() const
00935 {
00936 return mChildRecurrenceEvents;
00937 }
00938
00942 void Incidence::recurrenceUpdated( Recurrence *recurrence )
00943 {
00944 if ( recurrence == mRecurrence )
00945 updated();
00946 }
00947
|