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

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
  • kholidays
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  • kpimtextedit
  •   richtextbuilders
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • microblog
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.8
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