• Skip to content
  • Skip to link menu
KDE 4.1 API Reference
  • KDE API Reference
  • KDE-PIM Libraries
  • Sitemap
  • Contact Us
 

KCal Library

calendarresources.cpp

Go to the documentation of this file.
00001 /*
00002   This file is part of the kcal library.
00003 
00004   Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
00005   Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
00006 
00007   This library is free software; you can redistribute it and/or
00008   modify it under the terms of the GNU Library General Public
00009   License as published by the Free Software Foundation; either
00010   version 2 of the License, or (at your option) any later version.
00011 
00012   This library is distributed in the hope that it will be useful,
00013   but WITHOUT ANY WARRANTY; without even the implied warranty of
00014   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015   Library General Public License for more details.
00016 
00017   You should have received a copy of the GNU Library General Public License
00018   along with this library; see the file COPYING.LIB.  If not, write to
00019   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00020   Boston, MA 02110-1301, USA.
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 //@cond PRIVATE
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;  //flag that indicates if the resources are "open"
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 //@endcond
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       //Insert the first the Standard resource to get be the default selected.
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() << "Warning! No standard resource yet.";
00243   }
00244 
00245   // set the timezone for all resources. Otherwise we'll have those terrible tz
00246   // troubles ;-((
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   // Open all active resources
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   // FIXME: Use proper locking via begin/endChange!
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 //    d->mResourceMap[incidence] = resource;
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() << "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   // Not found
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   // Not found
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 /****************************** PROTECTED METHODS ****************************/
00563 
00564 Event::List CalendarResources::rawEventsForDate( const QDate &date,
00565                                                  const KDateTime::Spec &timespec,
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 &timespec, 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   // @TODO: Remove the code duplication by the resourcemap iteration block.
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   // Not found
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 //@cond PRIVATE
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 //@endcond
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   // set the timezone for all resources. Otherwise we'll have those terrible
00759   // tz troubles ;-((
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   // @TODO: Check if the resource was changed at all. If not, don't save.
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() << "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 }

KCal Library

Skip menu "KCal Library"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

KDE-PIM Libraries

Skip menu "KDE-PIM Libraries"
  • akonadi
  • kabc
  • kblog
  • kcal
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal