• Skip to content
  • Skip to link menu
KDE 4.2 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         mException( 0 )
00070     {}
00071     ~Private()
00072     {
00073       delete mManager;
00074       delete mStandardPolicy;
00075       delete mAskPolicy;
00076     }
00077     bool mOpen;  //flag that indicates if the resources are "open"
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 //@endcond
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       //Insert the first the Standard resource to get be the default selected.
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   // set the timezone for all resources. Otherwise we'll have those terrible tz
00261   // troubles ;-((
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   // Open all active resources
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   // FIXME: Use proper locking via begin/endChange!
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 //    d->mResourceMap[incidence] = resource;
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   // Not found
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   // Not found
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 /****************************** PROTECTED METHODS ****************************/
00579 
00580 Event::List CalendarResources::rawEventsForDate( const QDate &date,
00581                                                  const KDateTime::Spec &timespec,
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 &timespec, 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   // @TODO: Remove the code duplication by the resourcemap iteration block.
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   // Not found
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 //@cond PRIVATE
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 //@endcond
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   // set the timezone for all resources. Otherwise we'll have those terrible
00775   // tz troubles ;-((
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   // @TODO: Check if the resource was changed at all. If not, don't save.
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 }

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
  •   richtextbuilders
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.6
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