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

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.7.1
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