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