resourcecached.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <qdatetime.h>
00023 #include <qstring.h>
00024 #include <qptrlist.h>
00025
00026 #include <kdebug.h>
00027 #include <klocale.h>
00028 #include <kurl.h>
00029
00030 #include "exceptions.h"
00031 #include "incidence.h"
00032 #include "event.h"
00033 #include "todo.h"
00034 #include "journal.h"
00035
00036 #include "resourcecached.h"
00037
00038 using namespace KCal;
00039
00040 ResourceCached::ResourceCached( const KConfig* config )
00041 : ResourceCalendar( config ), mReloadPolicy( ReloadNever ),
00042 mReloadInterval( 10 ), mReloaded( false ), mSavePolicy( SaveNever ),
00043 mSaveInterval( 10 )
00044 {
00045 connect( &mReloadTimer, SIGNAL( timeout() ), SLOT( slotReload() ) );
00046 connect( &mSaveTimer, SIGNAL( timeout() ), SLOT( slotSave() ) );
00047 }
00048
00049 ResourceCached::~ResourceCached()
00050 {
00051 }
00052
00053 void ResourceCached::setReloadPolicy( int i )
00054 {
00055 mReloadPolicy = i;
00056
00057 setupReloadTimer();
00058 }
00059
00060 int ResourceCached::reloadPolicy() const
00061 {
00062 return mReloadPolicy;
00063 }
00064
00065 void ResourceCached::setReloadInterval( int minutes )
00066 {
00067 mReloadInterval = minutes;
00068 }
00069
00070 int ResourceCached::reloadInterval() const
00071 {
00072 return mReloadInterval;
00073 }
00074
00075 void ResourceCached::setSavePolicy( int i )
00076 {
00077 mSavePolicy = i;
00078
00079 setupSaveTimer();
00080 }
00081
00082 int ResourceCached::savePolicy() const
00083 {
00084 return mSavePolicy;
00085 }
00086
00087 void ResourceCached::setSaveInterval( int minutes )
00088 {
00089 mSaveInterval = minutes;
00090 }
00091
00092 int ResourceCached::saveInterval() const
00093 {
00094 return mSaveInterval;
00095 }
00096
00097 void ResourceCached::readConfig( const KConfig *config )
00098 {
00099 mReloadPolicy = config->readNumEntry( "ReloadPolicy", ReloadNever );
00100 mReloadInterval = config->readNumEntry( "ReloadInterval", 10 );
00101
00102 mSaveInterval = config->readNumEntry( "SaveInterval", 10 );
00103 mSavePolicy = config->readNumEntry( "SavePolicy", SaveNever );
00104
00105 mLastLoad = config->readDateTimeEntry( "LastLoad" );
00106 mLastSave = config->readDateTimeEntry( "LastSave" );
00107
00108 setupSaveTimer();
00109 setupReloadTimer();
00110 }
00111
00112 void ResourceCached::setupSaveTimer()
00113 {
00114 if ( mSavePolicy == SaveInterval ) {
00115 kdDebug(5800) << "ResourceCached::setSavePolicy(): start save timer (interval "
00116 << mSaveInterval << " minutes)." << endl;
00117 mSaveTimer.start( mSaveInterval * 60 * 1000 );
00118 } else {
00119 mSaveTimer.stop();
00120 }
00121 }
00122
00123 void ResourceCached::setupReloadTimer()
00124 {
00125 if ( mReloadPolicy == ReloadInterval ) {
00126 kdDebug(5800) << "ResourceCached::setSavePolicy(): start reload timer "
00127 "(interval " << mReloadInterval << " minutes)" << endl;
00128 mReloadTimer.start( mReloadInterval * 60 * 1000 );
00129 } else {
00130 mReloadTimer.stop();
00131 }
00132 }
00133
00134 void ResourceCached::writeConfig( KConfig *config )
00135 {
00136 config->writeEntry( "ReloadPolicy", mReloadPolicy );
00137 config->writeEntry( "ReloadInterval", mReloadInterval );
00138
00139 config->writeEntry( "SavePolicy", mSavePolicy );
00140 config->writeEntry( "SaveInterval", mSaveInterval );
00141
00142 config->writeEntry( "LastLoad", mLastLoad );
00143 config->writeEntry( "LastSave", mLastSave );
00144 }
00145
00146 bool ResourceCached::addEvent(Event *event)
00147 {
00148 return mCalendar.addEvent( event );
00149 }
00150
00151
00152 void ResourceCached::deleteEvent( Event *event )
00153 {
00154 kdDebug(5800) << "ResourceCached::deleteEvent" << endl;
00155
00156 mCalendar.deleteEvent( event );
00157 }
00158
00159
00160 Event *ResourceCached::event( const QString &uid )
00161 {
00162 return mCalendar.event( uid );
00163 }
00164
00165 Event::List ResourceCached::rawEventsForDate( const QDate &qd, bool sorted )
00166 {
00167 Event::List list = mCalendar.rawEventsForDate( qd, sorted );
00168
00169 return list;
00170 }
00171
00172
00173 Event::List ResourceCached::rawEvents( const QDate &start, const QDate &end,
00174 bool inclusive )
00175 {
00176 return mCalendar.rawEvents( start, end, inclusive );
00177 }
00178
00179 Event::List ResourceCached::rawEventsForDate( const QDateTime &qdt )
00180 {
00181 return mCalendar.rawEventsForDate( qdt.date() );
00182 }
00183
00184 Event::List ResourceCached::rawEvents()
00185 {
00186 return mCalendar.rawEvents();
00187 }
00188
00189 bool ResourceCached::addTodo( Todo *todo )
00190 {
00191 return mCalendar.addTodo( todo );
00192 }
00193
00194 void ResourceCached::deleteTodo( Todo *todo )
00195 {
00196 mCalendar.deleteTodo( todo );
00197 }
00198
00199 void ResourceCached::deleteJournal( Journal *journal )
00200 {
00201 mCalendar.deleteJournal( journal );
00202 }
00203
00204
00205 Todo::List ResourceCached::rawTodos()
00206 {
00207 return mCalendar.rawTodos();
00208 }
00209
00210 Todo *ResourceCached::todo( const QString &uid )
00211 {
00212 return mCalendar.todo( uid );
00213 }
00214
00215 Todo::List ResourceCached::rawTodosForDate( const QDate &date )
00216 {
00217 return mCalendar.rawTodosForDate( date );
00218 }
00219
00220
00221 bool ResourceCached::addJournal( Journal *journal )
00222 {
00223 kdDebug(5800) << "Adding Journal on " << journal->dtStart().toString() << endl;
00224
00225 return mCalendar.addJournal( journal );
00226 }
00227
00228 Journal *ResourceCached::journal( const QDate &date )
00229 {
00230
00231
00232 return mCalendar.journal( date );
00233 }
00234
00235 Journal *ResourceCached::journal( const QString &uid )
00236 {
00237 return mCalendar.journal( uid );
00238 }
00239
00240 Journal::List ResourceCached::journals()
00241 {
00242 return mCalendar.journals();
00243 }
00244
00245
00246 Alarm::List ResourceCached::alarmsTo( const QDateTime &to )
00247 {
00248 return mCalendar.alarmsTo( to );
00249 }
00250
00251 Alarm::List ResourceCached::alarms( const QDateTime &from, const QDateTime &to )
00252 {
00253
00254
00255 return mCalendar.alarms( from, to );
00256 }
00257
00258
00259 void ResourceCached::setTimeZoneId( const QString& tzid )
00260 {
00261 mCalendar.setTimeZoneId( tzid );
00262 }
00263
00264 QString ResourceCached::timeZoneId() const
00265 {
00266 return mCalendar.timeZoneId();
00267 }
00268
00269 void ResourceCached::clearChanges()
00270 {
00271 mAddedIncidences.clear();
00272 mChangedIncidences.clear();
00273 mDeletedIncidences.clear();
00274 }
00275
00276 void ResourceCached::calendarIncidenceAdded( Incidence *i )
00277 {
00278 #if 1
00279 kdDebug(5800) << "ResourceCached::calendarIncidenceAdded(): "
00280 << i->uid() << endl;
00281 #endif
00282
00283 QMap<Incidence *,bool>::ConstIterator it;
00284 it = mAddedIncidences.find( i );
00285 if ( it == mAddedIncidences.end() ) {
00286 mAddedIncidences.insert( i, true );
00287 }
00288
00289 checkForAutomaticSave();
00290 }
00291
00292 void ResourceCached::calendarIncidenceChanged( Incidence *i )
00293 {
00294 #if 1
00295 kdDebug(5800) << "ResourceCached::calendarIncidenceChanged(): "
00296 << i->uid() << endl;
00297 #endif
00298
00299 QMap<Incidence *,bool>::ConstIterator it;
00300 it = mChangedIncidences.find( i );
00301 if ( it == mChangedIncidences.end() ) {
00302 mChangedIncidences.insert( i, true );
00303 }
00304
00305 checkForAutomaticSave();
00306 }
00307
00308 void ResourceCached::calendarIncidenceDeleted( Incidence *i )
00309 {
00310 #if 1
00311 kdDebug(5800) << "ResourceCached::calendarIncidenceDeleted(): "
00312 << i->uid() << endl;
00313 #endif
00314
00315 QMap<Incidence *,bool>::ConstIterator it;
00316 it = mDeletedIncidences.find( i );
00317 if ( it == mDeletedIncidences.end() ) {
00318 mDeletedIncidences.insert( i, true );
00319 }
00320
00321 checkForAutomaticSave();
00322 }
00323
00324 Incidence::List ResourceCached::addedIncidences() const
00325 {
00326 Incidence::List added;
00327 QMap<Incidence *,bool>::ConstIterator it;
00328 for( it = mAddedIncidences.begin(); it != mAddedIncidences.end(); ++it ) {
00329 added.append( it.key() );
00330 }
00331 return added;
00332 }
00333
00334 Incidence::List ResourceCached::changedIncidences() const
00335 {
00336 Incidence::List changed;
00337 QMap<Incidence *,bool>::ConstIterator it;
00338 for( it = mChangedIncidences.begin(); it != mChangedIncidences.end(); ++it ) {
00339 changed.append( it.key() );
00340 }
00341 return changed;
00342 }
00343
00344 Incidence::List ResourceCached::deletedIncidences() const
00345 {
00346 Incidence::List deleted;
00347 QMap<Incidence *,bool>::ConstIterator it;
00348 for( it = mDeletedIncidences.begin(); it != mDeletedIncidences.end(); ++it ) {
00349 deleted.append( it.key() );
00350 }
00351 return deleted;
00352 }
00353
00354 Incidence::List ResourceCached::allChanges() const
00355 {
00356 Incidence::List changes;
00357 QMap<Incidence *,bool>::ConstIterator it;
00358 for( it = mAddedIncidences.begin(); it != mAddedIncidences.end(); ++it ) {
00359 changes.append( it.key() );
00360 }
00361 for( it = mChangedIncidences.begin(); it != mChangedIncidences.end(); ++it ) {
00362 changes.append( it.key() );
00363 }
00364 for( it = mDeletedIncidences.begin(); it != mDeletedIncidences.end(); ++it ) {
00365 changes.append( it.key() );
00366 }
00367 return changes;
00368 }
00369
00370 bool ResourceCached::hasChanges() const
00371 {
00372 return !( mAddedIncidences.isEmpty() && mChangedIncidences.isEmpty() &&
00373 mDeletedIncidences.isEmpty() );
00374 }
00375
00376 void ResourceCached::clearChange( Incidence *incidence )
00377 {
00378 mAddedIncidences.remove( incidence );
00379 mChangedIncidences.remove( incidence );
00380 mDeletedIncidences.remove( incidence );
00381 }
00382
00383 void ResourceCached::enableChangeNotification()
00384 {
00385 mCalendar.registerObserver( this );
00386 }
00387
00388 void ResourceCached::disableChangeNotification()
00389 {
00390 mCalendar.unregisterObserver( this );
00391 }
00392
00393 void ResourceCached::slotReload()
00394 {
00395 kdDebug(5800) << "ResourceCached::slotReload()" << endl;
00396
00397 load();
00398 }
00399
00400 void ResourceCached::slotSave()
00401 {
00402 kdDebug(5800) << "ResourceCached::slotSave()" << endl;
00403
00404 save();
00405 }
00406
00407 void ResourceCached::checkForAutomaticSave()
00408 {
00409 if ( mSavePolicy == SaveAlways ) {
00410 kdDebug() << "ResourceCached::checkForAutomaticSave(): save now" << endl;
00411 mSaveTimer.start( 1 * 1000, true );
00412 } else if ( mSavePolicy == SaveDelayed ) {
00413 kdDebug() << "ResourceCached::checkForAutomaticSave(): save delayed"
00414 << endl;
00415 mSaveTimer.start( 15 * 1000, true );
00416 }
00417 }
00418
00419 bool ResourceCached::checkForReload()
00420 {
00421 if ( mReloadPolicy == ReloadNever ) return false;
00422 if ( mReloadPolicy == ReloadOnStartup ) return !mReloaded;
00423 return true;
00424 }
00425
00426 bool ResourceCached::checkForSave()
00427 {
00428 if ( mSavePolicy == SaveNever ) return false;
00429 return true;
00430 }
00431
00432 void ResourceCached::addInfoText( QString &txt ) const
00433 {
00434 if ( mLastLoad.isValid() ) {
00435 txt += "<br>";
00436 txt += i18n("Last loaded: %1")
00437 .arg( KGlobal::locale()->formatDateTime( mLastLoad ) );
00438 }
00439 if ( mLastSave.isValid() ) {
00440 txt += "<br>";
00441 txt += i18n("Last saved: %1")
00442 .arg( KGlobal::locale()->formatDateTime( mLastSave ) );
00443 }
00444 }
00445
00446 #include "resourcecached.moc"
This file is part of the documentation for libkcal Library Version 3.3.2.