00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00035 #include "calendarresources.moc"
00036 #include "incidence.h"
00037 #include "journal.h"
00038 #include "resourcecalendar.h"
00039
00040 #include "kresources/manager.h"
00041 #include "kresources/selectdialog.h"
00042 #include "kabc/lock.h"
00043
00044 #include <kdebug.h>
00045 #include <kdatetime.h>
00046 #include <kstandarddirs.h>
00047 #include <klocale.h>
00048
00049 #include <QtCore/QString>
00050 #include <QtCore/QList>
00051
00052 #include <stdlib.h>
00053
00054 using namespace KCal;
00055
00060
00061 class KCal::CalendarResources::Private
00062 {
00063 public:
00064 Private( const QString &family )
00065 : mManager( new CalendarResourceManager( family ) ),
00066 mStandardPolicy( new StandardDestinationPolicy( mManager ) ),
00067 mDestinationPolicy( mStandardPolicy ),
00068 mAskPolicy( new AskDestinationPolicy( mManager ) ),
00069 mException( 0 ),
00070 mPendingDeleteFromResourceMap( false )
00071 {}
00072 ~Private()
00073 {
00074 delete mManager;
00075 delete mStandardPolicy;
00076 delete mAskPolicy;
00077 }
00078 bool mOpen;
00079
00080 KRES::Manager<ResourceCalendar>* mManager;
00081 QMap <Incidence*, ResourceCalendar*> mResourceMap;
00082
00083 StandardDestinationPolicy *mStandardPolicy;
00084 DestinationPolicy *mDestinationPolicy;
00085 AskDestinationPolicy *mAskPolicy;
00086
00087 QMap<ResourceCalendar *, Ticket *> mTickets;
00088 QMap<ResourceCalendar *, int> mChangeCounts;
00089
00090 ErrorFormat *mException;
00091
00092 bool mPendingDeleteFromResourceMap;
00093
00094 template< class IncidenceList >
00095 void appendIncidences( IncidenceList &result, const IncidenceList &extra,
00096 ResourceCalendar * );
00097 };
00098
00099 class KCal::CalendarResources::DestinationPolicy::Private
00100 {
00101 public:
00102 Private( CalendarResourceManager *manager, QWidget *parent )
00103 : mManager( manager ),
00104 mParent( parent )
00105 {}
00106 CalendarResourceManager *mManager;
00107 QWidget *mParent;
00108 };
00109
00110 class KCal::CalendarResources::StandardDestinationPolicy::Private
00111 {
00112 public:
00113 Private()
00114 {}
00115 };
00116
00117 class KCal::CalendarResources::AskDestinationPolicy::Private
00118 {
00119 public:
00120 Private()
00121 {}
00122 };
00123
00124 class KCal::CalendarResources::Ticket::Private
00125 {
00126 public:
00127 Private( ResourceCalendar *resource )
00128 : mResource( resource )
00129 {}
00130 ResourceCalendar *mResource;
00131 };
00132
00133
00134 CalendarResources::DestinationPolicy::DestinationPolicy(
00135 CalendarResourceManager *manager, QWidget *parent )
00136 : d( new KCal::CalendarResources::DestinationPolicy::Private( manager, parent ) )
00137 {
00138 }
00139
00140 CalendarResources::DestinationPolicy::~DestinationPolicy()
00141 {
00142 delete d;
00143 }
00144
00145 QWidget *CalendarResources::DestinationPolicy::parent()
00146 {
00147 return d->mParent;
00148 }
00149
00150 void CalendarResources::DestinationPolicy::setParent( QWidget *parent )
00151 {
00152 d->mParent = parent;
00153 }
00154
00155 CalendarResourceManager *CalendarResources::DestinationPolicy::resourceManager()
00156 {
00157 return d->mManager;
00158 }
00159
00160 CalendarResources::StandardDestinationPolicy::StandardDestinationPolicy(
00161 CalendarResourceManager *manager, QWidget *parent )
00162 : DestinationPolicy( manager, parent ),
00163 d( new KCal::CalendarResources::StandardDestinationPolicy::Private )
00164 {
00165 }
00166
00167 CalendarResources::StandardDestinationPolicy::~StandardDestinationPolicy()
00168 {
00169 delete d;
00170 }
00171
00172 ResourceCalendar *CalendarResources::StandardDestinationPolicy::destination( Incidence *incidence )
00173 {
00174 Q_UNUSED( incidence );
00175 return resourceManager()->standardResource();
00176 }
00177
00178 CalendarResources::AskDestinationPolicy::AskDestinationPolicy(
00179 CalendarResourceManager *manager, QWidget *parent )
00180 : DestinationPolicy( manager, parent ),
00181 d( new KCal::CalendarResources::AskDestinationPolicy::Private )
00182 {
00183 }
00184
00185 CalendarResources::AskDestinationPolicy::~AskDestinationPolicy()
00186 {
00187 delete d;
00188 }
00189
00190 ResourceCalendar *CalendarResources::AskDestinationPolicy::destination( Incidence *incidence )
00191 {
00192 Q_UNUSED( incidence );
00193 QList<KRES::Resource*> list;
00194
00195 CalendarResourceManager::ActiveIterator it;
00196 for ( it = resourceManager()->activeBegin();
00197 it != resourceManager()->activeEnd(); ++it ) {
00198 if ( !(*it)->readOnly() ) {
00199
00200 if ( resourceManager()->standardResource() == *it ) {
00201 list.insert( 0, *it );
00202 } else {
00203 list.append( *it );
00204 }
00205 }
00206 }
00207
00208 KRES::Resource *r;
00209 r = KRES::SelectDialog::getResource( list, parent() );
00210 return static_cast<ResourceCalendar *>( r );
00211 }
00212
00213 CalendarResources::CalendarResources( const KDateTime::Spec &timeSpec,
00214 const QString &family )
00215 : Calendar( timeSpec ),
00216 d( new KCal::CalendarResources::Private( family ) )
00217 {
00218 d->mManager->addObserver( this );
00219 }
00220
00221 CalendarResources::CalendarResources( const QString &timeZoneId,
00222 const QString &family )
00223 : Calendar( timeZoneId ),
00224 d( new KCal::CalendarResources::Private( family ) )
00225 {
00226 d->mManager->addObserver( this );
00227 }
00228
00229 CalendarResources::~CalendarResources()
00230 {
00231 close();
00232 clearException();
00233 delete d;
00234 }
00235
00236 void CalendarResources::clearException()
00237 {
00238 delete d->mException;
00239 d->mException = 0;
00240 }
00241
00242 ErrorFormat *CalendarResources::exception()
00243 {
00244 return d->mException;
00245 }
00246
00247 void CalendarResources::readConfig( KConfig *config )
00248 {
00249 d->mManager->readConfig( config );
00250
00251 CalendarResourceManager::Iterator it;
00252 for ( it = d->mManager->begin(); it != d->mManager->end(); ++it ) {
00253 connectResource( *it );
00254 }
00255 }
00256
00257 void CalendarResources::load()
00258 {
00259 if ( !d->mManager->standardResource() ) {
00260 kDebug() << "Warning! No standard resource yet.";
00261 }
00262
00263
00264
00265 CalendarResourceManager::Iterator i1;
00266 for ( i1 = d->mManager->begin(); i1 != d->mManager->end(); ++i1 ) {
00267 (*i1)->setTimeSpec( timeSpec() );
00268 }
00269
00270 QList<ResourceCalendar *> failed;
00271
00272
00273 CalendarResourceManager::ActiveIterator it;
00274 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00275 if ( !(*it)->load() ) {
00276 failed.append( *it );
00277 }
00278 Incidence::List incidences = (*it)->rawIncidences();
00279 Incidence::List::Iterator incit;
00280 for ( incit = incidences.begin(); incit != incidences.end(); ++incit ) {
00281 (*incit)->registerObserver( this );
00282 notifyIncidenceAdded( *incit );
00283 }
00284 }
00285
00286 QList<ResourceCalendar *>::ConstIterator it2;
00287 for ( it2 = failed.constBegin(); it2 != failed.constEnd(); ++it2 ) {
00288 (*it2)->setActive( false );
00289 emit signalResourceModified( *it2 );
00290 }
00291
00292 d->mOpen = true;
00293 emit calendarLoaded();
00294 }
00295
00296 bool CalendarResources::reload()
00297 {
00298 save();
00299 close();
00300 load();
00301 return true;
00302 }
00303
00304 CalendarResourceManager *CalendarResources::resourceManager() const
00305 {
00306 return d->mManager;
00307 }
00308
00309 void CalendarResources::setStandardDestinationPolicy()
00310 {
00311 d->mDestinationPolicy = d->mStandardPolicy;
00312 }
00313
00314 void CalendarResources::setAskDestinationPolicy()
00315 {
00316 d->mDestinationPolicy = d->mAskPolicy;
00317 }
00318
00319 QWidget *CalendarResources::dialogParentWidget()
00320 {
00321 return d->mDestinationPolicy->parent();
00322 }
00323
00324 void CalendarResources::setDialogParentWidget( QWidget *parent )
00325 {
00326 d->mDestinationPolicy->setParent( parent );
00327 }
00328
00329 void CalendarResources::close()
00330 {
00331 if ( d->mOpen ) {
00332 CalendarResourceManager::ActiveIterator it;
00333 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00334 (*it)->close();
00335 }
00336
00337 setModified( false );
00338 d->mOpen = false;
00339 }
00340 }
00341
00342 bool CalendarResources::save()
00343 {
00344 bool status = true;
00345 if ( d->mOpen && isModified() ) {
00346 status = false;
00347 CalendarResourceManager::ActiveIterator it;
00348 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00349 status = (*it)->save() || status;
00350 }
00351 setModified( false );
00352 }
00353
00354 return status;
00355 }
00356
00357 bool CalendarResources::isSaving()
00358 {
00359 CalendarResourceManager::ActiveIterator it;
00360 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00361 if ( (*it)->isSaving() ) {
00362 return true;
00363 }
00364 }
00365 return false;
00366 }
00367
00368 bool CalendarResources::addIncidence( Incidence *incidence,
00369 ResourceCalendar *resource )
00370 {
00371
00372 bool validRes = false;
00373 CalendarResourceManager::ActiveIterator it;
00374 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00375 if ( (*it) == resource ) {
00376 validRes = true;
00377 }
00378 }
00379
00380 ResourceCalendar *oldResource = 0;
00381 if ( d->mResourceMap.contains( incidence ) ) {
00382 oldResource = d->mResourceMap[incidence];
00383 }
00384 d->mResourceMap[incidence] = resource;
00385 if ( validRes && beginChange( incidence ) &&
00386 resource->addIncidence( incidence ) ) {
00387
00388 incidence->registerObserver( this );
00389 notifyIncidenceAdded( incidence );
00390 setModified( true );
00391 endChange( incidence );
00392 return true;
00393 } else {
00394 if ( oldResource ) {
00395 d->mResourceMap[incidence] = oldResource;
00396 } else {
00397 d->mResourceMap.remove( incidence );
00398 }
00399 }
00400
00401 return false;
00402 }
00403
00404 bool CalendarResources::addIncidence( Incidence *incidence )
00405 {
00406 clearException();
00407 ResourceCalendar *resource = d->mDestinationPolicy->destination( incidence );
00408
00409 if ( resource ) {
00410 d->mResourceMap[ incidence ] = resource;
00411
00412 if ( beginChange( incidence ) && resource->addIncidence( incidence ) ) {
00413 incidence->registerObserver( this );
00414 notifyIncidenceAdded( incidence );
00415
00416 d->mResourceMap[ incidence ] = resource;
00417 setModified( true );
00418 endChange( incidence );
00419 return true;
00420 } else {
00421 d->mResourceMap.remove( incidence );
00422 }
00423 } else {
00424 d->mException = new ErrorFormat( ErrorFormat::UserCancel );
00425 }
00426
00427 return false;
00428 }
00429
00430 bool CalendarResources::addEvent( Event *event )
00431 {
00432 return addIncidence( event );
00433 }
00434
00435 bool CalendarResources::addEvent( Event *Event, ResourceCalendar *resource )
00436 {
00437 return addIncidence( Event, resource );
00438 }
00439
00440 bool CalendarResources::deleteEvent( Event *event )
00441 {
00442 bool status;
00443 if ( d->mResourceMap.find( event ) != d->mResourceMap.end() ) {
00444 status = d->mResourceMap[event]->deleteEvent( event );
00445 if ( status ) {
00446 d->mPendingDeleteFromResourceMap = true;
00447 }
00448 } else {
00449 status = false;
00450 CalendarResourceManager::ActiveIterator it;
00451 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00452 status = (*it)->deleteEvent( event ) || status;
00453 }
00454 }
00455 if ( status ) {
00456 notifyIncidenceDeleted( event );
00457 }
00458
00459 setModified( status );
00460 return status;
00461 }
00462
00463 void CalendarResources::deleteAllEvents()
00464 {
00465 CalendarResourceManager::ActiveIterator it;
00466 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00467 (*it)->deleteAllEvents();
00468 }
00469 }
00470
00471 Event *CalendarResources::event( const QString &uid )
00472 {
00473 CalendarResourceManager::ActiveIterator it;
00474 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00475 Event *event = (*it)->event( uid );
00476 if ( event ) {
00477 d->mResourceMap[event] = *it;
00478 return event;
00479 }
00480 }
00481
00482
00483 return 0;
00484 }
00485
00486 bool CalendarResources::addTodo( Todo *todo )
00487 {
00488 return addIncidence( todo );
00489 }
00490
00491 bool CalendarResources::addTodo( Todo *todo, ResourceCalendar *resource )
00492 {
00493 return addIncidence( todo, resource );
00494 }
00495
00496 bool CalendarResources::deleteTodo( Todo *todo )
00497 {
00498 bool status;
00499 if ( d->mResourceMap.find( todo ) != d->mResourceMap.end() ) {
00500 status = d->mResourceMap[todo]->deleteTodo( todo );
00501 if ( status ) {
00502 d->mPendingDeleteFromResourceMap = true;
00503 }
00504 } else {
00505 CalendarResourceManager::ActiveIterator it;
00506 status = false;
00507 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00508 status = (*it)->deleteTodo( todo ) || status;
00509 }
00510 }
00511
00512 setModified( status );
00513 return status;
00514 }
00515
00516 void CalendarResources::deleteAllTodos()
00517 {
00518 CalendarResourceManager::ActiveIterator it;
00519 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00520 (*it)->deleteAllTodos();
00521 }
00522 }
00523
00524 Todo::List CalendarResources::rawTodos( TodoSortField sortField,
00525 SortDirection sortDirection )
00526 {
00527 Todo::List result;
00528
00529 CalendarResourceManager::ActiveIterator it;
00530 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00531 d->appendIncidences<Todo::List>( result,
00532 (*it)->rawTodos( TodoSortUnsorted ), *it );
00533 }
00534 return sortTodos( &result, sortField, sortDirection );
00535 }
00536
00537 Todo *CalendarResources::todo( const QString &uid )
00538 {
00539 CalendarResourceManager::ActiveIterator it;
00540 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00541 Todo *todo = (*it)->todo( uid );
00542 if ( todo ) {
00543 d->mResourceMap[todo] = *it;
00544 return todo;
00545 }
00546 }
00547
00548
00549 return 0;
00550 }
00551
00552 Todo::List CalendarResources::rawTodosForDate( const QDate &date )
00553 {
00554 Todo::List result;
00555
00556 CalendarResourceManager::ActiveIterator it;
00557 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00558 d->appendIncidences<Todo::List>( result,
00559 (*it)->rawTodosForDate( date ), *it );
00560 }
00561 return result;
00562 }
00563
00564 Alarm::List CalendarResources::alarmsTo( const KDateTime &to )
00565 {
00566 Alarm::List result;
00567 CalendarResourceManager::ActiveIterator it;
00568 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00569 result += (*it)->alarmsTo( to );
00570 }
00571 return result;
00572 }
00573
00574 Alarm::List CalendarResources::alarms( const KDateTime &from,
00575 const KDateTime &to )
00576 {
00577 Alarm::List result;
00578 CalendarResourceManager::ActiveIterator it;
00579 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00580 result += (*it)->alarms( from, to );
00581 }
00582 return result;
00583 }
00584
00585
00586
00587 Event::List CalendarResources::rawEventsForDate( const QDate &date,
00588 const KDateTime::Spec ×pec,
00589 EventSortField sortField,
00590 SortDirection sortDirection )
00591 {
00592 Event::List result;
00593 CalendarResourceManager::ActiveIterator it;
00594 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00595 d->appendIncidences<Event::List>( result,
00596 (*it)->rawEventsForDate( date, timespec ), *it );
00597 }
00598 return sortEvents( &result, sortField, sortDirection );
00599 }
00600
00601 Event::List CalendarResources::rawEvents( const QDate &start, const QDate &end,
00602 const KDateTime::Spec ×pec, bool inclusive )
00603 {
00604 Event::List result;
00605 CalendarResourceManager::ActiveIterator it;
00606 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00607 d->appendIncidences<Event::List>( result,
00608 (*it)->rawEvents( start, end, timespec, inclusive ), *it );
00609 }
00610 return result;
00611 }
00612
00613 Event::List CalendarResources::rawEventsForDate( const KDateTime &kdt )
00614 {
00615
00616 Event::List result;
00617 CalendarResourceManager::ActiveIterator it;
00618 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00619 d->appendIncidences<Event::List>( result,
00620 (*it)->rawEventsForDate( kdt ), *it );
00621 }
00622 return result;
00623 }
00624
00625 Event::List CalendarResources::rawEvents( EventSortField sortField,
00626 SortDirection sortDirection )
00627 {
00628 Event::List result;
00629 CalendarResourceManager::ActiveIterator it;
00630 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00631 d->appendIncidences<Event::List>( result,
00632 (*it)->rawEvents( EventSortUnsorted ), *it );
00633 }
00634 return sortEvents( &result, sortField, sortDirection );
00635 }
00636
00637 bool CalendarResources::addJournal( Journal *journal )
00638 {
00639 return addIncidence( journal );
00640 }
00641
00642 bool CalendarResources::deleteJournal( Journal *journal )
00643 {
00644 bool status;
00645 if ( d->mResourceMap.find( journal ) != d->mResourceMap.end() ) {
00646 status = d->mResourceMap[journal]->deleteJournal( journal );
00647 if ( status ) {
00648 d->mPendingDeleteFromResourceMap = true;
00649 }
00650 } else {
00651 CalendarResourceManager::ActiveIterator it;
00652 status = false;
00653 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00654 status = (*it)->deleteJournal( journal ) || status;
00655 }
00656 }
00657
00658 setModified( status );
00659 return status;
00660 }
00661
00662 void CalendarResources::deleteAllJournals()
00663 {
00664 CalendarResourceManager::ActiveIterator it;
00665 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00666 (*it)->deleteAllJournals();
00667 }
00668 }
00669
00670 bool CalendarResources::addJournal( Journal *journal,
00671 ResourceCalendar *resource )
00672 {
00673 return addIncidence( journal, resource );
00674 }
00675
00676 Journal *CalendarResources::journal( const QString &uid )
00677 {
00678 CalendarResourceManager::ActiveIterator it;
00679 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00680 Journal *journal = (*it)->journal( uid );
00681 if ( journal ) {
00682 d->mResourceMap[journal] = *it;
00683 return journal;
00684 }
00685 }
00686
00687
00688 return 0;
00689 }
00690
00691 Journal::List CalendarResources::rawJournals( JournalSortField sortField,
00692 SortDirection sortDirection )
00693 {
00694 Journal::List result;
00695 CalendarResourceManager::ActiveIterator it;
00696 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00697 d->appendIncidences<Journal::List>( result,
00698 (*it)->rawJournals( JournalSortUnsorted ), *it );
00699 }
00700 return sortJournals( &result, sortField, sortDirection );
00701 }
00702
00703 Journal::List CalendarResources::rawJournalsForDate( const QDate &date )
00704 {
00705
00706 Journal::List result;
00707
00708 CalendarResourceManager::ActiveIterator it;
00709 for ( it = d->mManager->activeBegin(); it != d->mManager->activeEnd(); ++it ) {
00710 d->appendIncidences<Journal::List>( result,
00711 (*it)->rawJournalsForDate( date ), *it );
00712 }
00713 return result;
00714 }
00715
00716
00717 template< class IncidenceList >
00718 void CalendarResources::Private::appendIncidences( IncidenceList &result,
00719 const IncidenceList &extra,
00720 ResourceCalendar *resource )
00721 {
00722 result += extra;
00723 for ( typename IncidenceList::ConstIterator it = extra.begin();
00724 it != extra.end();
00725 ++it ) {
00726 mResourceMap[ *it ] = resource;
00727 }
00728 }
00729
00730
00731 void CalendarResources::connectResource( ResourceCalendar *resource )
00732 {
00733 connect( resource, SIGNAL( resourceChanged( ResourceCalendar * ) ),
00734 SIGNAL( calendarChanged() ) );
00735 connect( resource, SIGNAL( resourceSaved( ResourceCalendar * ) ),
00736 SIGNAL( calendarSaved() ) );
00737
00738 connect( resource, SIGNAL( resourceLoadError( ResourceCalendar *,
00739 const QString & ) ),
00740 SLOT( slotLoadError( ResourceCalendar *, const QString & ) ) );
00741 connect( resource, SIGNAL( resourceSaveError( ResourceCalendar *,
00742 const QString & ) ),
00743 SLOT( slotSaveError( ResourceCalendar *, const QString & ) ) );
00744 }
00745
00746 ResourceCalendar *CalendarResources::resource( Incidence *incidence )
00747 {
00748 if ( d->mResourceMap.find( incidence ) != d->mResourceMap.end() ) {
00749 return d->mResourceMap[ incidence ];
00750 }
00751 return 0;
00752 }
00753
00754 void CalendarResources::resourceAdded( ResourceCalendar *resource )
00755 {
00756 if ( !resource->isActive() ) {
00757 return;
00758 }
00759
00760 if ( resource->open() ) {
00761 resource->load();
00762 }
00763
00764 connectResource( resource );
00765
00766 emit signalResourceAdded( resource );
00767 }
00768
00769 void CalendarResources::resourceModified( ResourceCalendar *resource )
00770 {
00771 emit signalResourceModified( resource );
00772 }
00773
00774 void CalendarResources::resourceDeleted( ResourceCalendar *resource )
00775 {
00776 emit signalResourceDeleted( resource );
00777 }
00778
00779 void CalendarResources::doSetTimeSpec( const KDateTime::Spec &timeSpec )
00780 {
00781
00782
00783 CalendarResourceManager::Iterator i1;
00784 for ( i1 = d->mManager->begin(); i1 != d->mManager->end(); ++i1 ) {
00785 (*i1)->setTimeSpec( timeSpec );
00786 }
00787 }
00788
00789 CalendarResources::Ticket::Ticket( ResourceCalendar *resource )
00790 : d( new KCal::CalendarResources::Ticket::Private( resource ) )
00791 {
00792 }
00793
00794 CalendarResources::Ticket::~Ticket()
00795 {
00796 delete d;
00797 }
00798
00799 CalendarResources::Ticket *CalendarResources::requestSaveTicket( ResourceCalendar *resource )
00800 {
00801 KABC::Lock *lock = resource->lock();
00802 if ( !lock ) {
00803 return 0;
00804 }
00805 if ( lock->lock() ) {
00806 return new Ticket( resource );
00807 } else {
00808 return 0;
00809 }
00810 }
00811
00812 ResourceCalendar *CalendarResources::Ticket::resource() const
00813 {
00814 return d->mResource;
00815 }
00816
00817 bool CalendarResources::save( Ticket *ticket, Incidence *incidence )
00818 {
00819 if ( !ticket || !ticket->resource() ) {
00820 return false;
00821 }
00822
00823
00824 if ( ticket->resource()->save( incidence ) ) {
00825 releaseSaveTicket( ticket );
00826 return true;
00827 }
00828
00829 return false;
00830 }
00831
00832 void CalendarResources::releaseSaveTicket( Ticket *ticket )
00833 {
00834 ticket->resource()->lock()->unlock();
00835 delete ticket;
00836 }
00837
00838 bool CalendarResources::beginChange( Incidence *incidence )
00839 {
00840 ResourceCalendar *r = resource( incidence );
00841 if ( !r ) {
00842 r = d->mDestinationPolicy->destination( incidence );
00843 if ( !r ) {
00844 kError() << "Unable to get destination resource.";
00845 return false;
00846 }
00847 d->mResourceMap[ incidence ] = r;
00848 }
00849 d->mPendingDeleteFromResourceMap = false;
00850
00851 int count = incrementChangeCount( r );
00852 if ( count == 1 ) {
00853 Ticket *ticket = requestSaveTicket( r );
00854 if ( !ticket ) {
00855 kDebug() << "unable to get ticket.";
00856 decrementChangeCount( r );
00857 return false;
00858 } else {
00859 d->mTickets[ r ] = ticket;
00860 }
00861 }
00862
00863 return true;
00864 }
00865
00866 bool CalendarResources::endChange( Incidence *incidence )
00867 {
00868 ResourceCalendar *r = resource( incidence );
00869 if ( !r ) {
00870 return false;
00871 }
00872
00873 int count = decrementChangeCount( r );
00874
00875 if ( d->mPendingDeleteFromResourceMap ) {
00876 d->mResourceMap.remove( incidence );
00877 d->mPendingDeleteFromResourceMap = false;
00878 }
00879
00880 if ( count == 0 ) {
00881 bool ok = save( d->mTickets[ r ], incidence );
00882 if ( ok ) {
00883 d->mTickets.remove( r );
00884 } else {
00885 return false;
00886 }
00887 }
00888
00889 return true;
00890 }
00891
00892 int CalendarResources::incrementChangeCount( ResourceCalendar *r )
00893 {
00894 if ( !d->mChangeCounts.contains( r ) ) {
00895 d->mChangeCounts.insert( r, 0 );
00896 }
00897
00898 int count = d->mChangeCounts[ r ];
00899 ++count;
00900 d->mChangeCounts[ r ] = count;
00901
00902 return count;
00903 }
00904
00905 int CalendarResources::decrementChangeCount( ResourceCalendar *r )
00906 {
00907 if ( !d->mChangeCounts.contains( r ) ) {
00908 kError() << "No change count for resource.";
00909 return 0;
00910 }
00911
00912 int count = d->mChangeCounts[ r ];
00913 --count;
00914 if ( count < 0 ) {
00915 kError() << "Can't decrement change count. It already is 0.";
00916 count = 0;
00917 }
00918 d->mChangeCounts[ r ] = count;
00919
00920 return count;
00921 }
00922
00923 void CalendarResources::slotLoadError( ResourceCalendar *r, const QString &err )
00924 {
00925 Q_UNUSED( r );
00926 emit signalErrorMessage( err );
00927 }
00928
00929 void CalendarResources::slotSaveError( ResourceCalendar *r, const QString &err )
00930 {
00931 Q_UNUSED( r );
00932 emit signalErrorMessage( err );
00933 }