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