• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdepimlibs-4.11.3 API Reference
  • KDE Home
  • Contact Us
 

KCalCore Library

  • kcalcore
memorycalendar.cpp
Go to the documentation of this file.
1 /*
2  This file is part of the kcalcore library.
3 
4  Copyright (c) 1998 Preston Brown <pbrown@kde.org>
5  Copyright (c) 2001,2003,2004 Cornelius Schumacher <schumacher@kde.org>
6  Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
7 
8  This library is free software; you can redistribute it and/or
9  modify it under the terms of the GNU Library General Public
10  License as published by the Free Software Foundation; either
11  version 2 of the License, or (at your option) any later version.
12 
13  This library is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  Library General Public License for more details.
17 
18  You should have received a copy of the GNU Library General Public License
19  along with this library; see the file COPYING.LIB. If not, write to
20  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  Boston, MA 02110-1301, USA.
22 */
35 #include "memorycalendar.h"
36 
37 #include <KDebug>
38 #include <QDate>
39 
40 using namespace KCalCore;
41 
46 //@cond PRIVATE
47 class KCalCore::MemoryCalendar::Private
48 {
49  public:
50  Private( MemoryCalendar *qq )
51  : q( qq ), mFormat( 0 )
52  {
53  }
54  ~Private()
55  {
56  }
57 
58  MemoryCalendar *q;
59  CalFormat *mFormat; // calendar format
60  QString mIncidenceBeingUpdated; // Instance identifier of Incidence currently beeing updated
61 
66  QMap<IncidenceBase::IncidenceType, QMultiHash<QString, Incidence::Ptr> > mIncidences;
67 
71  QHash<QString,KCalCore::Incidence::Ptr> mIncidencesByIdentifier;
72 
77  QMap<IncidenceBase::IncidenceType, QMultiHash<QString, Incidence::Ptr> > mDeletedIncidences;
78 
90  QMap<IncidenceBase::IncidenceType, QMultiHash<QString, IncidenceBase::Ptr> > mIncidencesForDate;
91 
92  void insertIncidence( const Incidence::Ptr &incidence );
93 
94  Incidence::Ptr incidence( const QString &uid,
95  const IncidenceBase::IncidenceType type,
96  const KDateTime &recurrenceId = KDateTime() ) const;
97 
98  Incidence::Ptr deletedIncidence( const QString &uid,
99  const KDateTime &recurrenceId,
100  const IncidenceBase::IncidenceType type ) const;
101 
102  void deleteAllIncidences( const IncidenceBase::IncidenceType type );
103 
104 };
105 //@endcond
106 
107 MemoryCalendar::MemoryCalendar( const KDateTime::Spec &timeSpec )
108  : Calendar( timeSpec ),
109  d( new KCalCore::MemoryCalendar::Private( this ) )
110 {
111 }
112 
113 MemoryCalendar::MemoryCalendar( const QString &timeZoneId )
114  : Calendar( timeZoneId ),
115  d( new KCalCore::MemoryCalendar::Private( this ) )
116 {
117 }
118 
119 MemoryCalendar::~MemoryCalendar()
120 {
121  close();
122  delete d;
123 }
124 
125 void MemoryCalendar::close()
126 {
127  setObserversEnabled( false );
128 
129  // Don't call the virtual function deleteEvents() etc, the base class might have
130  // other ways of deleting the data.
131  d->deleteAllIncidences(Incidence::TypeEvent);
132  d->deleteAllIncidences(Incidence::TypeTodo);
133  d->deleteAllIncidences(Incidence::TypeJournal);
134 
135  d->mIncidencesByIdentifier.clear();
136  d->mDeletedIncidences.clear();
137 
138  setModified( false );
139 
140  setObserversEnabled( true );
141 }
142 
143 bool MemoryCalendar::deleteIncidence( const Incidence::Ptr &incidence )
144 {
145  // Handle orphaned children
146  // relations is an Incidence's property, not a Todo's, so
147  // we remove relations in deleteIncidence, not in deleteTodo.
148  removeRelations( incidence );
149  const Incidence::IncidenceType type = incidence->type();
150  const QString uid = incidence->uid();
151  if ( d->mIncidences[type].remove( uid, incidence ) ) {
152  d->mIncidencesByIdentifier.remove( incidence->instanceIdentifier() );
153  setModified( true );
154  notifyIncidenceDeleted( incidence );
155  if ( deletionTracking() )
156  d->mDeletedIncidences[type].insert( uid, incidence );
157 
158  const KDateTime dt = incidence->dateTime( Incidence::RoleCalendarHashing );
159  if ( dt.isValid() ) {
160  d->mIncidencesForDate[type].remove( dt.date().toString(), incidence );
161  }
162  // Delete child-incidences.
163  if ( !incidence->hasRecurrenceId() ) {
164  deleteIncidenceInstances( incidence );
165  }
166  return true;
167  } else {
168  kWarning() << incidence->typeStr() << " not found.";
169  return false;
170  }
171 }
172 
173 bool MemoryCalendar::deleteIncidenceInstances( const Incidence::Ptr &incidence )
174 {
175  const Incidence::IncidenceType type = incidence->type();
176  QList<Incidence::Ptr> values = d->mIncidences[type].values( incidence->uid() );
177  QList<Incidence::Ptr>::const_iterator it;
178  for ( it = values.constBegin(); it != values.constEnd(); ++it ) {
179  Incidence::Ptr i = *it;
180  if ( i->hasRecurrenceId() ) {
181  kDebug() << "deleting child"
182  << ", type=" << int( type )
183  << ", uid=" << i->uid()
184  << ", start=" << i->dtStart()
185  << " from calendar";
186  deleteIncidence( i );
187  }
188  }
189 
190  return true;
191 }
192 
193 //@cond PRIVATE
194 void MemoryCalendar::Private::deleteAllIncidences( const Incidence::IncidenceType incidenceType )
195 {
196  QHashIterator<QString, Incidence::Ptr>i( mIncidences[incidenceType] );
197  while ( i.hasNext() ) {
198  i.next();
199  q->notifyIncidenceDeleted( i.value() );
200  i.value()->unRegisterObserver( q );
201  }
202  mIncidences[incidenceType].clear();
203  mIncidencesForDate[incidenceType].clear();
204 }
205 
206 Incidence::Ptr MemoryCalendar::Private::incidence( const QString &uid,
207  const Incidence::IncidenceType type,
208  const KDateTime &recurrenceId ) const
209 {
210  QList<Incidence::Ptr> values = mIncidences[type].values( uid );
211  QList<Incidence::Ptr>::const_iterator it;
212  for ( it = values.constBegin(); it != values.constEnd(); ++it ) {
213  Incidence::Ptr i = *it;
214  if ( recurrenceId.isNull() ) {
215  if ( !i->hasRecurrenceId() ) {
216  return i;
217  }
218  } else {
219  if ( i->hasRecurrenceId() && i->recurrenceId() == recurrenceId ) {
220  return i;
221  }
222  }
223  }
224  return Incidence::Ptr();
225 }
226 
227 Incidence::Ptr
228 MemoryCalendar::Private::deletedIncidence( const QString &uid,
229  const KDateTime &recurrenceId,
230  const IncidenceBase::IncidenceType type ) const
231 {
232  if ( !q->deletionTracking() ) {
233  return Incidence::Ptr();
234  }
235 
236  QList<Incidence::Ptr> values = mDeletedIncidences[type].values( uid );
237  QList<Incidence::Ptr>::const_iterator it;
238  for ( it = values.constBegin(); it != values.constEnd(); ++it ) {
239  Incidence::Ptr i = *it;
240  if ( recurrenceId.isNull() ) {
241  if ( !i->hasRecurrenceId() ) {
242  return i;
243  }
244  } else {
245  if ( i->hasRecurrenceId() && i->recurrenceId() == recurrenceId ) {
246  return i;
247  }
248  }
249  }
250  return Incidence::Ptr();
251 }
252 
253 void MemoryCalendar::Private::insertIncidence( const Incidence::Ptr &incidence )
254 {
255  const QString uid = incidence->uid();
256  const Incidence::IncidenceType type = incidence->type();
257  if ( !mIncidences[type].contains( uid, incidence ) ) {
258  mIncidences[type].insert( uid, incidence );
259  mIncidencesByIdentifier.insert( incidence->instanceIdentifier(), incidence );
260  const KDateTime dt = incidence->dateTime( Incidence::RoleCalendarHashing );
261  if ( dt.isValid() ) {
262  mIncidencesForDate[type].insert( dt.date().toString(), incidence );
263  }
264 
265  } else {
266 #ifndef NDEBUG
267  // if we already have an to-do with this UID, it must be the same incidence,
268  // otherwise something's really broken
269  Q_ASSERT( mIncidences[type].value( uid ) == incidence );
270 #endif
271  }
272 }
273 //@endcond
274 
275 bool MemoryCalendar::addIncidence( const Incidence::Ptr &incidence )
276 {
277  d->insertIncidence( incidence );
278 
279  notifyIncidenceAdded( incidence );
280 
281  incidence->registerObserver( this );
282 
283  setupRelations( incidence );
284 
285  setModified( true );
286 
287  return true;
288 }
289 
290 bool MemoryCalendar::addEvent( const Event::Ptr &event )
291 {
292  return addIncidence( event );
293 }
294 
295 bool MemoryCalendar::deleteEvent( const Event::Ptr &event )
296 {
297  return deleteIncidence( event );
298 }
299 
300 bool MemoryCalendar::deleteEventInstances( const Event::Ptr &event )
301 {
302  return deleteIncidenceInstances( event );
303 }
304 
305 void MemoryCalendar::deleteAllEvents()
306 {
307  d->deleteAllIncidences( Incidence::TypeEvent );
308 }
309 
310 Event::Ptr MemoryCalendar::event( const QString &uid,
311  const KDateTime &recurrenceId ) const
312 {
313  return d->incidence( uid, Incidence::TypeEvent, recurrenceId ).staticCast<Event>();
314 }
315 
316 Event::Ptr MemoryCalendar::deletedEvent( const QString &uid, const KDateTime &recurrenceId ) const
317 {
318  return d->deletedIncidence( uid, recurrenceId, Incidence::TypeEvent ).staticCast<Event>();
319 }
320 
321 bool MemoryCalendar::addTodo( const Todo::Ptr &todo )
322 {
323  return addIncidence( todo );
324 }
325 
326 bool MemoryCalendar::deleteTodo( const Todo::Ptr &todo )
327 {
328  return deleteIncidence( todo );
329 }
330 
331 bool MemoryCalendar::deleteTodoInstances( const Todo::Ptr &todo )
332 {
333  return deleteIncidenceInstances( todo );
334 }
335 
336 void MemoryCalendar::deleteAllTodos()
337 {
338  d->deleteAllIncidences( Incidence::TypeTodo );
339 }
340 
341 Todo::Ptr MemoryCalendar::todo( const QString &uid,
342  const KDateTime &recurrenceId ) const
343 {
344  return d->incidence( uid, Incidence::TypeTodo, recurrenceId ).staticCast<Todo>();
345 }
346 
347 Todo::Ptr MemoryCalendar::deletedTodo( const QString &uid,
348  const KDateTime &recurrenceId ) const
349 {
350  return d->deletedIncidence( uid, recurrenceId, Incidence::TypeTodo ).staticCast<Todo>();
351 }
352 
353 Todo::List MemoryCalendar::rawTodos( TodoSortField sortField,
354  SortDirection sortDirection ) const
355 {
356  Todo::List todoList;
357  QHashIterator<QString, Incidence::Ptr>i( d->mIncidences[Incidence::TypeTodo] );
358  while ( i.hasNext() ) {
359  i.next();
360  todoList.append( i.value().staticCast<Todo>() );
361  }
362  return Calendar::sortTodos( todoList, sortField, sortDirection );
363 }
364 
365 Todo::List MemoryCalendar::deletedTodos( TodoSortField sortField,
366  SortDirection sortDirection ) const
367 {
368  if ( !deletionTracking() ) {
369  return Todo::List();
370  }
371 
372  Todo::List todoList;
373  QHashIterator<QString, Incidence::Ptr >i( d->mDeletedIncidences[Incidence::TypeTodo] );
374  while ( i.hasNext() ) {
375  i.next();
376  todoList.append( i.value().staticCast<Todo>() );
377  }
378  return Calendar::sortTodos( todoList, sortField, sortDirection );
379 }
380 
381 Todo::List MemoryCalendar::todoInstances( const Incidence::Ptr &todo,
382  TodoSortField sortField,
383  SortDirection sortDirection ) const
384 {
385  Todo::List list;
386 
387  QList<Incidence::Ptr > values = d->mIncidences[Incidence::TypeTodo].values( todo->uid() );
388  QList<Incidence::Ptr>::const_iterator it;
389  for ( it = values.constBegin(); it != values.constEnd(); ++it ) {
390  Todo::Ptr t = ( *it ).staticCast<Todo>();
391  if ( t->hasRecurrenceId() ) {
392  list.append( t );
393  }
394  }
395  return Calendar::sortTodos( list, sortField, sortDirection );
396 }
397 
398 Todo::List MemoryCalendar::rawTodosForDate( const QDate &date ) const
399 {
400  Todo::List todoList;
401  Todo::Ptr t;
402 
403  KDateTime::Spec ts = timeSpec();
404  const QString dateStr = date.toString();
405  QMultiHash<QString, IncidenceBase::Ptr >::const_iterator it =
406  d->mIncidencesForDate[Incidence::TypeTodo].constFind( dateStr );
407  while ( it != d->mIncidencesForDate[Incidence::TypeTodo].constEnd() && it.key() == dateStr ) {
408  t = it.value().staticCast<Todo>();
409  todoList.append( t );
410  ++it;
411  }
412 
413  // Iterate over all todos. Look for recurring todoss that occur on this date
414  QHashIterator<QString, Incidence::Ptr >i( d->mIncidences[Incidence::TypeTodo] );
415  while ( i.hasNext() ) {
416  i.next();
417  t = i.value().staticCast<Todo>();
418  if ( t->recurs() ) {
419  if ( t->recursOn( date, ts ) ) {
420  todoList.append( t );
421  }
422  }
423  }
424 
425  return todoList;
426 }
427 
428 Todo::List MemoryCalendar::rawTodos( const QDate &start,
429  const QDate &end,
430  const KDateTime::Spec &timespec,
431  bool inclusive ) const
432 {
433  Q_UNUSED( inclusive ); // use only exact dtDue/dtStart, not dtStart and dtEnd
434 
435  Todo::List todoList;
436  KDateTime::Spec ts = timespec.isValid() ? timespec : timeSpec();
437  KDateTime st( start, ts );
438  KDateTime nd( end, ts );
439 
440  // Get todos
441  QHashIterator<QString, Incidence::Ptr >i( d->mIncidences[Incidence::TypeTodo] );
442  Todo::Ptr todo;
443  while ( i.hasNext() ) {
444  i.next();
445  todo = i.value().staticCast<Todo>();
446  if ( !isVisible( todo ) ) {
447  continue;
448  }
449 
450  KDateTime rStart = todo->hasDueDate() ? todo->dtDue() :
451  todo->hasStartDate() ? todo->dtStart() : KDateTime();
452  if ( !rStart.isValid() ) {
453  continue;
454  }
455 
456  if ( !todo->recurs() ) { // non-recurring todos
457  if ( nd.isValid() && nd < rStart ) {
458  continue;
459  }
460  if ( st.isValid() && rStart < st ) {
461  continue;
462  }
463  } else { // recurring events
464  switch ( todo->recurrence()->duration() ) {
465  case -1: // infinite
466  break;
467  case 0: // end date given
468  default: // count given
469  KDateTime rEnd( todo->recurrence()->endDate(), ts );
470  if ( !rEnd.isValid() ) {
471  continue;
472  }
473  if ( st.isValid() && rEnd < st ) {
474  continue;
475  }
476  break;
477  } // switch(duration)
478  } //if(recurs)
479 
480  todoList.append( todo );
481  }
482 
483  return todoList;
484 }
485 
486 Alarm::List MemoryCalendar::alarmsTo( const KDateTime &to ) const
487 {
488  return alarms( KDateTime( QDate( 1900, 1, 1 ) ), to );
489 }
490 
491 Alarm::List MemoryCalendar::alarms( const KDateTime &from, const KDateTime &to ) const
492 {
493  Alarm::List alarmList;
494  QHashIterator<QString, Incidence::Ptr>ie( d->mIncidences[Incidence::TypeEvent] );
495  Event::Ptr e;
496  while ( ie.hasNext() ) {
497  ie.next();
498  e = ie.value().staticCast<Event>();
499  if ( e->recurs() ) {
500  appendRecurringAlarms( alarmList, e, from, to );
501  } else {
502  appendAlarms( alarmList, e, from, to );
503  }
504  }
505 
506  QHashIterator<QString, Incidence::Ptr>it( d->mIncidences[Incidence::TypeTodo] );
507  Todo::Ptr t;
508  while ( it.hasNext() ) {
509  it.next();
510  t = it.value().staticCast<Todo>();
511 
512  if ( !t->isCompleted() ) {
513  appendAlarms( alarmList, t, from, to );
514  if ( t->recurs() ) {
515  appendRecurringAlarms( alarmList, t, from, to );
516  } else {
517  appendAlarms( alarmList, t, from, to );
518  }
519  }
520  }
521 
522  return alarmList;
523 }
524 
525 void MemoryCalendar::incidenceUpdate( const QString &uid, const KDateTime &recurrenceId )
526 {
527  Incidence::Ptr inc = incidence( uid, recurrenceId );
528 
529  if ( inc ) {
530  if ( !d->mIncidenceBeingUpdated.isEmpty() ) {
531  kWarning() << "Incidence::update() called twice without an updated() call in between.";
532  }
533 
534  // Save it so we can detect changes to uid or recurringId.
535  d->mIncidenceBeingUpdated = inc->instanceIdentifier();
536 
537  const KDateTime dt = inc->dateTime( Incidence::RoleCalendarHashing );
538  if ( dt.isValid() ) {
539  const Incidence::IncidenceType type = inc->type();
540  d->mIncidencesForDate[type].remove( dt.date().toString(), inc );
541  }
542  }
543 }
544 
545 void MemoryCalendar::incidenceUpdated( const QString &uid, const KDateTime &recurrenceId )
546 {
547  Incidence::Ptr inc = incidence( uid, recurrenceId );
548 
549  if ( inc ) {
550 
551  if ( d->mIncidenceBeingUpdated.isEmpty() ) {
552  kWarning() << "Incidence::updated() called twice without an update() call in between.";
553  } else if ( inc->instanceIdentifier() != d->mIncidenceBeingUpdated ) {
554  // Instance identifier changed, update our hash table
555  d->mIncidencesByIdentifier.remove( d->mIncidenceBeingUpdated );
556  d->mIncidencesByIdentifier.insert( inc->instanceIdentifier(), inc );
557  }
558 
559  d->mIncidenceBeingUpdated = QString();
560 
561  inc->setLastModified( KDateTime::currentUtcDateTime() );
562  // we should probably update the revision number here,
563  // or internally in the Event itself when certain things change.
564  // need to verify with ical documentation.
565 
566  const KDateTime dt = inc->dateTime( Incidence::RoleCalendarHashing );
567  if ( dt.isValid() ) {
568  const Incidence::IncidenceType type = inc->type();
569  d->mIncidencesForDate[type].insert( dt.date().toString(), inc );
570  }
571 
572  notifyIncidenceChanged( inc );
573 
574  setModified( true );
575  }
576 }
577 
578 Event::List MemoryCalendar::rawEventsForDate( const QDate &date,
579  const KDateTime::Spec &timespec,
580  EventSortField sortField,
581  SortDirection sortDirection ) const
582 {
583  Event::List eventList;
584 
585  if ( !date.isValid() ) {
586  // There can't be events on invalid dates
587  return eventList;
588  }
589 
590  Event::Ptr ev;
591 
592  // Find the hash for the specified date
593  const QString dateStr = date.toString();
594  QMultiHash<QString, IncidenceBase::Ptr >::const_iterator it =
595  d->mIncidencesForDate[Incidence::TypeEvent].constFind( dateStr );
596  // Iterate over all non-recurring, single-day events that start on this date
597  KDateTime::Spec ts = timespec.isValid() ? timespec : timeSpec();
598  KDateTime kdt( date, ts );
599  while ( it != d->mIncidencesForDate[Incidence::TypeEvent].constEnd() && it.key() == dateStr ) {
600  ev = it.value().staticCast<Event>();
601  KDateTime end( ev->dtEnd().toTimeSpec( ev->dtStart() ) );
602  if ( ev->allDay() ) {
603  end.setDateOnly( true );
604  } else {
605  end = end.addSecs( -1 );
606  }
607  if ( end >= kdt ) {
608  eventList.append( ev );
609  }
610  ++it;
611  }
612 
613  // Iterate over all events. Look for recurring events that occur on this date
614  QHashIterator<QString, Incidence::Ptr>i( d->mIncidences[Incidence::TypeEvent] );
615  while ( i.hasNext() ) {
616  i.next();
617  ev = i.value().staticCast<Event>();
618  if ( ev->recurs() ) {
619  if ( ev->isMultiDay() ) {
620  int extraDays = ev->dtStart().date().daysTo( ev->dtEnd().date() );
621  for ( int i = 0; i <= extraDays; ++i ) {
622  if ( ev->recursOn( date.addDays( -i ), ts ) ) {
623  eventList.append( ev );
624  break;
625  }
626  }
627  } else {
628  if ( ev->recursOn( date, ts ) ) {
629  eventList.append( ev );
630  }
631  }
632  } else {
633  if ( ev->isMultiDay() ) {
634  if ( ev->dtStart().date() <= date && ev->dtEnd().date() >= date ) {
635  eventList.append( ev );
636  }
637  }
638  }
639  }
640 
641  return Calendar::sortEvents( eventList, sortField, sortDirection );
642 }
643 
644 Event::List MemoryCalendar::rawEvents( const QDate &start,
645  const QDate &end,
646  const KDateTime::Spec &timespec,
647  bool inclusive ) const
648 {
649  Event::List eventList;
650  KDateTime::Spec ts = timespec.isValid() ? timespec : timeSpec();
651  KDateTime st( start, ts );
652  KDateTime nd( end, ts );
653  KDateTime yesterStart = st.addDays( -1 );
654 
655  // Get non-recurring events
656  QHashIterator<QString, Incidence::Ptr>i( d->mIncidences[Incidence::TypeEvent] );
657  Event::Ptr event;
658  while ( i.hasNext() ) {
659  i.next();
660  event = i.value().staticCast<Event>();
661  KDateTime rStart = event->dtStart();
662  if ( nd < rStart ) {
663  continue;
664  }
665  if ( inclusive && rStart < st ) {
666  continue;
667  }
668 
669  if ( !event->recurs() ) { // non-recurring events
670  KDateTime rEnd = event->dtEnd();
671  if ( rEnd < st ) {
672  continue;
673  }
674  if ( inclusive && nd < rEnd ) {
675  continue;
676  }
677  } else { // recurring events
678  switch ( event->recurrence()->duration() ) {
679  case -1: // infinite
680  if ( inclusive ) {
681  continue;
682  }
683  break;
684  case 0: // end date given
685  default: // count given
686  KDateTime rEnd( event->recurrence()->endDate(), ts );
687  if ( !rEnd.isValid() ) {
688  continue;
689  }
690  if ( rEnd < st ) {
691  continue;
692  }
693  if ( inclusive && nd < rEnd ) {
694  continue;
695  }
696  break;
697  } // switch(duration)
698  } //if(recurs)
699 
700  eventList.append( event );
701  }
702 
703  return eventList;
704 }
705 
706 Event::List MemoryCalendar::rawEventsForDate( const KDateTime &kdt ) const
707 {
708  return rawEventsForDate( kdt.date(), kdt.timeSpec() );
709 }
710 
711 Event::List MemoryCalendar::rawEvents( EventSortField sortField,
712  SortDirection sortDirection ) const
713 {
714  Event::List eventList;
715  QHashIterator<QString, Incidence::Ptr> i( d->mIncidences[Incidence::TypeEvent] );
716  while ( i.hasNext() ) {
717  i.next();
718  eventList.append( i.value().staticCast<Event>() );
719  }
720  return Calendar::sortEvents( eventList, sortField, sortDirection );
721 }
722 
723 Event::List MemoryCalendar::deletedEvents( EventSortField sortField,
724  SortDirection sortDirection ) const
725 {
726  if ( !deletionTracking() ) {
727  return Event::List();
728  }
729 
730  Event::List eventList;
731  QHashIterator<QString, Incidence::Ptr>i( d->mDeletedIncidences[Incidence::TypeEvent] );
732  while ( i.hasNext() ) {
733  i.next();
734  eventList.append( i.value().staticCast<Event>() );
735  }
736  return Calendar::sortEvents( eventList, sortField, sortDirection );
737 }
738 
739 Event::List MemoryCalendar::eventInstances( const Incidence::Ptr &event,
740  EventSortField sortField,
741  SortDirection sortDirection ) const
742 {
743  Event::List list;
744 
745  QList<Incidence::Ptr> values = d->mIncidences[Incidence::TypeEvent].values( event->uid() );
746  QList<Incidence::Ptr>::const_iterator it;
747  for ( it = values.constBegin(); it != values.constEnd(); ++it ) {
748  Event::Ptr ev = ( *it ).staticCast<Event>();
749  if ( ev->hasRecurrenceId() ) {
750  list.append( ev );
751  }
752  }
753  return Calendar::sortEvents( list, sortField, sortDirection );
754 }
755 
756 bool MemoryCalendar::addJournal( const Journal::Ptr &journal )
757 {
758  return addIncidence( journal );
759 }
760 
761 bool MemoryCalendar::deleteJournal( const Journal::Ptr &journal )
762 {
763  return deleteIncidence( journal );
764 }
765 
766 bool MemoryCalendar::deleteJournalInstances( const Journal::Ptr &journal )
767 {
768  return deleteIncidenceInstances( journal );
769 }
770 
771 void MemoryCalendar::deleteAllJournals()
772 {
773  d->deleteAllIncidences( Incidence::TypeJournal );
774 }
775 
776 Journal::Ptr MemoryCalendar::journal( const QString &uid,
777  const KDateTime &recurrenceId ) const
778 {
779  return d->incidence( uid, Incidence::TypeJournal, recurrenceId ).staticCast<Journal>();
780 }
781 
782 Journal::Ptr MemoryCalendar::deletedJournal( const QString &uid,
783  const KDateTime &recurrenceId ) const
784 {
785  return d->deletedIncidence( uid, recurrenceId, Incidence::TypeJournal ).staticCast<Journal>();
786 }
787 
788 Journal::List MemoryCalendar::rawJournals( JournalSortField sortField,
789  SortDirection sortDirection ) const
790 {
791  Journal::List journalList;
792  QHashIterator<QString, Incidence::Ptr>i( d->mIncidences[Incidence::TypeJournal] );
793  while ( i.hasNext() ) {
794  i.next();
795  journalList.append( i.value().staticCast<Journal>() );
796  }
797  return Calendar::sortJournals( journalList, sortField, sortDirection );
798 }
799 
800 Journal::List MemoryCalendar::deletedJournals( JournalSortField sortField,
801  SortDirection sortDirection ) const
802 {
803  if ( !deletionTracking() ) {
804  return Journal::List();
805  }
806 
807  Journal::List journalList;
808  QHashIterator<QString, Incidence::Ptr>i( d->mDeletedIncidences[Incidence::TypeJournal] );
809  while ( i.hasNext() ) {
810  i.next();
811  journalList.append( i.value().staticCast<Journal>() );
812  }
813  return Calendar::sortJournals( journalList, sortField, sortDirection );
814 }
815 
816 Journal::List MemoryCalendar::journalInstances( const Incidence::Ptr &journal,
817  JournalSortField sortField,
818  SortDirection sortDirection ) const
819 {
820  Journal::List list;
821 
822  QList<Incidence::Ptr> values = d->mIncidences[Incidence::TypeJournal].values( journal->uid() );
823  QList<Incidence::Ptr>::const_iterator it;
824  for ( it = values.constBegin(); it != values.constEnd(); ++it ) {
825  Journal::Ptr j = ( *it ).staticCast<Journal>();
826  if ( j->hasRecurrenceId() ) {
827  list.append( j );
828  }
829  }
830  return Calendar::sortJournals( list, sortField, sortDirection );
831 }
832 
833 Journal::List MemoryCalendar::rawJournalsForDate( const QDate &date ) const
834 {
835  Journal::List journalList;
836  Journal::Ptr j;
837 
838  QString dateStr = date.toString();
839  QMultiHash<QString, IncidenceBase::Ptr >::const_iterator it =
840  d->mIncidencesForDate[Incidence::TypeJournal].constFind( dateStr );
841 
842  while ( it != d->mIncidencesForDate[Incidence::TypeJournal].constEnd() && it.key() == dateStr ) {
843  j = it.value().staticCast<Journal>();
844  journalList.append( j );
845  ++it;
846  }
847  return journalList;
848 }
849 
850 Incidence::Ptr MemoryCalendar::instance(const QString &identifier) const
851 {
852  return d->mIncidencesByIdentifier.value(identifier);
853 }
854 
855 void MemoryCalendar::virtual_hook( int id, void *data )
856 {
857  Q_UNUSED( id );
858  Q_UNUSED( data );
859  Q_ASSERT( false );
860 }
KCalCore::MemoryCalendar::deleteIncidence
bool deleteIncidence(const Incidence::Ptr &incidence)
Removes an Incidence from the calendar.
KCalCore::JournalSortField
JournalSortField
Calendar Journal sort keys.
Definition: calendar.h:100
KCalCore::MemoryCalendar::incidenceUpdated
void incidenceUpdated(const QString &uid, const KDateTime &recurrenceId)
The Observer interface.
KCalCore::MemoryCalendar::rawJournals
Journal::List rawJournals(JournalSortField sortField=JournalSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all Journals for this Calendar.
KCalCore::MemoryCalendar::deletedJournals
Journal::List deletedJournals(JournalSortField sortField=JournalSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all deleted Journals for this Calendar.
KCalCore::MemoryCalendar::deleteTodo
bool deleteTodo(const Todo::Ptr &todo)
Removes a Todo from the calendar.
KCalCore::MemoryCalendar::virtual_hook
virtual void virtual_hook(int id, void *data)
Standard trick to add virtuals later.
KCalCore::Journal::List
QVector< Ptr > List
List of journals.
Definition: journal.h:54
KCalCore::MemoryCalendar::close
void close()
Clears out the current calendar, freeing all used memory etc.
KCalCore::IncidenceBase::RoleCalendarHashing
Role for looking up an incidence in a Calendar.
Definition: incidencebase.h:135
KCalCore::MemoryCalendar::deleteAllTodos
void deleteAllTodos()
Removes all To-dos from the calendar.
KCalCore::MemoryCalendar::deletedTodos
Todo::List deletedTodos(TodoSortField sortField=TodoSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all deleted Todos for this Calendar.
KCalCore::IncidenceBase::TypeTodo
Type is a to-do.
Definition: incidencebase.h:121
memorycalendar.h
This file is part of the API for handling calendar data and defines the MemoryCalendar class...
KCalCore::Event::Ptr
QSharedPointer< Event > Ptr
A shared pointer to an Event object.
Definition: event.h:55
KCalCore::CalFormat
An abstract base class that provides an interface to various calendar formats.
Definition: calformat.h:48
KCalCore::MemoryCalendar::event
Event::Ptr event(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the Event associated with the given unique identifier.
KCalCore::MemoryCalendar::MemoryCalendar
MemoryCalendar(const KDateTime::Spec &timeSpec)
Constructs a calendar with a specified time zone timeZoneid.
KCalCore::MemoryCalendar::deleteEvent
bool deleteEvent(const Event::Ptr &event)
Removes an Event from the calendar.
KCalCore::MemoryCalendar::rawEvents
Event::List rawEvents(EventSortField sortField=EventSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all Events for this Calendar.
KCalCore::IncidenceBase::TypeJournal
Type is a journal.
Definition: incidencebase.h:122
KCalCore::MemoryCalendar::deleteAllJournals
void deleteAllJournals()
Removes all Journals from the calendar.
KCalCore::Calendar::timeSpec
KDateTime::Spec timeSpec() const
Get the time specification (time zone etc.) used for creating or modifying incidences in the Calendar...
KCalCore::Alarm::List
QVector< Ptr > List
List of alarms.
Definition: alarm.h:81
KCalCore::EventSortField
EventSortField
Calendar Event sort keys.
Definition: calendar.h:77
KCalCore::Incidence::Ptr
QSharedPointer< Incidence > Ptr
A shared pointer to an Incidence.
Definition: incidence.h:112
KCalCore::Calendar::notifyIncidenceDeleted
void notifyIncidenceDeleted(const Incidence::Ptr &incidence)
Let Calendar subclasses notify that they removed an Incidence.
Definition: calendar.cpp:1302
KCalCore::Calendar::appendAlarms
void appendAlarms(Alarm::List &alarms, const Incidence::Ptr &incidence, const KDateTime &from, const KDateTime &to) const
Appends alarms of incidence in interval to list of alarms.
Definition: calendar.cpp:1387
KCalCore::IncidenceBase::IncidenceType
IncidenceType
The different types of incidences, per RFC2445.
Definition: incidencebase.h:119
KCalCore::Todo::hasDueDate
bool hasDueDate() const
Returns if the todo has a due datetime.
Definition: todo.cpp:183
KCalCore::Calendar::sortEvents
static Event::List sortEvents(const Event::List &eventList, EventSortField sortField, SortDirection sortDirection)
Sort a list of Events.
Definition: calendar.cpp:594
KCalCore::MemoryCalendar::~MemoryCalendar
~MemoryCalendar()
Destroys the calendar.
KCalCore::Calendar::incidence
Incidence::Ptr incidence(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the Incidence associated with the given unique identifier.
Definition: calendar.cpp:813
KCalCore::MemoryCalendar::incidenceUpdate
void incidenceUpdate(const QString &uid, const KDateTime &recurrenceId)
The IncidenceObserver interface.
KCalCore::MemoryCalendar::instance
Incidence::Ptr instance(const QString &identifier) const
Returns an incidence by identifier.
KCalCore::Calendar::removeRelations
virtual void removeRelations(const Incidence::Ptr &incidence)
Removes all Relations from an Incidence.
Definition: calendar.cpp:1064
KCalCore::MemoryCalendar::journal
Journal::Ptr journal(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the Journal associated with the given unique identifier.
KCalCore::Event::List
QVector< Ptr > List
List of events.
Definition: event.h:60
KCalCore::MemoryCalendar
This class provides a calendar stored in memory.
Definition: memorycalendar.h:46
KCalCore::Calendar::setupRelations
virtual void setupRelations(const Incidence::Ptr &incidence)
Setup Relations for an Incidence.
Definition: calendar.cpp:1021
KCalCore::Calendar::sortJournals
static Journal::List sortJournals(const Journal::List &journalList, JournalSortField sortField, SortDirection sortDirection)
Sort a list of Journals.
Definition: calendar.cpp:970
KCalCore::SortDirection
SortDirection
Calendar Incidence sort directions.
Definition: calendar.h:69
KCalCore::Calendar::isVisible
bool isVisible(const Incidence::Ptr &incidence) const
Check if incidence is visible.
KCalCore::MemoryCalendar::eventInstances
Event::List eventInstances(const Incidence::Ptr &event, EventSortField sortField=EventSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all possible instances for this recurring Event.
KCalCore::MemoryCalendar::deleteEventInstances
bool deleteEventInstances(const Event::Ptr &event)
Delete all events that are instances of recurring event event.
KCalCore::MemoryCalendar::rawJournalsForDate
Journal::List rawJournalsForDate(const QDate &date) const
Returns an unfiltered list of all Journals for on the specified date.
KCalCore::MemoryCalendar::journalInstances
Journal::List journalInstances(const Incidence::Ptr &journal, JournalSortField sortField=JournalSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
KCalCore::MemoryCalendar::todo
Todo::Ptr todo(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the Todo associated with the given unique identifier.
KCalCore::MemoryCalendar::deleteAllEvents
void deleteAllEvents()
Removes all Events from the calendar.
KCalCore::Calendar::setModified
void setModified(bool modified)
Sets if the calendar has been modified.
Definition: calendar.cpp:1222
KCalCore::Calendar::notifyIncidenceChanged
void notifyIncidenceChanged(const Incidence::Ptr &incidence)
Let Calendar subclasses notify that they modified an Incidence.
Definition: calendar.cpp:1287
KCalCore::MemoryCalendar::addTodo
bool addTodo(const Todo::Ptr &todo)
Inserts a Todo into the calendar.
KCalCore::TodoSortField
TodoSortField
Calendar Todo sort keys.
Definition: calendar.h:87
KCalCore::Calendar::deletionTracking
bool deletionTracking() const
Returns if deletion tracking is enabled.
Definition: calendar.cpp:1538
KCalCore::MemoryCalendar::todoInstances
Todo::List todoInstances(const Incidence::Ptr &todo, TodoSortField sortField=TodoSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all possible instances for this recurring Todo.
KCalCore::MemoryCalendar::addJournal
bool addJournal(const Journal::Ptr &journal)
Inserts a Journal into the calendar.
KCalCore::Journal
Provides a Journal in the sense of RFC2445.
Definition: journal.h:43
KCalCore::Todo::List
QVector< Ptr > List
List of to-dos.
Definition: todo.h:55
KCalCore::MemoryCalendar::deletedTodo
Todo::Ptr deletedTodo(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the deleted Todo associated with the given unique identifier.
KCalCore::Calendar::appendRecurringAlarms
void appendRecurringAlarms(Alarm::List &alarms, const Incidence::Ptr &incidence, const KDateTime &from, const KDateTime &to) const
Appends alarms of recurring events in interval to list of alarms.
Definition: calendar.cpp:1404
KCalCore::MemoryCalendar::addIncidence
bool addIncidence(const Incidence::Ptr &incidence)
Inserts an Incidence into the calendar.
KCalCore::MemoryCalendar::deleteJournalInstances
bool deleteJournalInstances(const Journal::Ptr &journal)
Delete all journals that are instances of recurring journal journal.
KCalCore::MemoryCalendar::deletedEvent
Event::Ptr deletedEvent(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the deleted Event associated with the given unique identifier.
KCalCore::IncidenceBase::TypeEvent
Type is an event.
Definition: incidencebase.h:120
KCalCore::Todo
Provides a To-do in the sense of RFC2445.
Definition: todo.h:44
KCalCore::Event
This class provides an Event in the sense of RFC2445.
Definition: event.h:41
KCalCore::MemoryCalendar::rawEventsForDate
Event::List rawEventsForDate(const QDate &date, const KDateTime::Spec &timeSpec=KDateTime::Spec(), EventSortField sortField=EventSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns an unfiltered list of all Events which occur on the given date.
KCalCore::Calendar::notifyIncidenceAdded
void notifyIncidenceAdded(const Incidence::Ptr &incidence)
Let Calendar subclasses notify that they inserted an Incidence.
Definition: calendar.cpp:1272
KCalCore::MemoryCalendar::alarmsTo
Alarm::List alarmsTo(const KDateTime &to) const
Return a list of Alarms that occur before the specified timestamp.
KCalCore::MemoryCalendar::deletedEvents
Event::List deletedEvents(EventSortField sortField=EventSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all deleted Events for this Calendar.
KCalCore::Calendar
Represents the main calendar class.
Definition: calendar.h:128
KCalCore::MemoryCalendar::deleteJournal
bool deleteJournal(const Journal::Ptr &journal)
Removes a Journal from the calendar.
KCalCore::MemoryCalendar::deleteIncidenceInstances
bool deleteIncidenceInstances(const Incidence::Ptr &incidence)
Delete all incidences that are instances of recurring incidence incidence.
KCalCore::MemoryCalendar::deleteTodoInstances
bool deleteTodoInstances(const Todo::Ptr &todo)
Delete all to-dos that are instances of recurring to-do todo.
KCalCore::MemoryCalendar::addEvent
bool addEvent(const Event::Ptr &event)
Inserts an Event into the calendar.
KCalCore::Todo::Ptr
QSharedPointer< Todo > Ptr
A shared pointer to a Todo object.
Definition: todo.h:50
KCalCore::MemoryCalendar::deletedJournal
Journal::Ptr deletedJournal(const QString &uid, const KDateTime &recurrenceId=KDateTime()) const
Returns the deleted Journal associated with the given unique identifier.
KCalCore::Calendar::sortTodos
static Todo::List sortTodos(const Todo::List &todoList, TodoSortField sortField, SortDirection sortDirection)
Sort a list of Todos.
Definition: calendar.cpp:874
KCalCore::Journal::Ptr
QSharedPointer< Journal > Ptr
A shared pointer to a Journal object.
Definition: journal.h:49
KCalCore::Calendar::setObserversEnabled
void setObserversEnabled(bool enabled)
Let Calendar subclasses notify that they enabled an Observer.
Definition: calendar.cpp:1382
KCalCore::MemoryCalendar::rawTodos
Todo::List rawTodos(TodoSortField sortField=TodoSortUnsorted, SortDirection sortDirection=SortDirectionAscending) const
Returns a sorted, unfiltered list of all Todos for this Calendar.
KCalCore::MemoryCalendar::rawTodosForDate
Todo::List rawTodosForDate(const QDate &date) const
Returns an unfiltered list of all Todos which due on the specified date.
KCalCore::IncidenceBase::dtStart
virtual KDateTime dtStart() const
Returns an incidence&#39;s starting date/time as a KDateTime.
Definition: incidencebase.cpp:319
KCalCore::MemoryCalendar::alarms
Alarm::List alarms(const KDateTime &from, const KDateTime &to) const
Returns a list of Alarms within a time range for this Calendar.
This file is part of the KDE documentation.
Documentation copyright © 1996-2013 The KDE developers.
Generated on Tue Nov 26 2013 09:02:04 by doxygen 1.8.5 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KCalCore Library

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

kdepimlibs-4.11.3 API Reference

Skip menu "kdepimlibs-4.11.3 API Reference"
  • akonadi
  •   contact
  •   kmime
  •   socialutils
  • kabc
  • kalarmcal
  • kblog
  • kcal
  • kcalcore
  • kcalutils
  • kholidays
  • kimap
  • kioslave
  •   imap4
  •   mbox
  •   nntp
  • kldap
  • kmbox
  • kmime
  • kontactinterface
  • kpimidentities
  • kpimtextedit
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • microblog
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal