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