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

akonadi

  • akonadi
  • calendar
calendarbase.cpp
1 /*
2  Copyright (C) 2011 Sérgio Martins <sergio.martins@kdab.com>
3  Copyright (C) 2012 Sérgio Martins <iamsergio@gmail.com>
4 
5  This library is free software; you can redistribute it and/or modify it
6  under the terms of the GNU Library General Public License as published by
7  the Free Software Foundation; either version 2 of the License, or (at your
8  option) any later version.
9 
10  This library is distributed in the hope that it will be useful, but WITHOUT
11  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13  License for more details.
14 
15  You should have received a copy of the GNU Library General Public License
16  along with this library; see the file COPYING.LIB. If not, write to the
17  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18  02110-1301, USA.
19 */
20 
21 #include "calendarbase.h"
22 #include "calendarbase_p.h"
23 #include "incidencechanger.h"
24 #include "utils_p.h"
25 
26 #include <akonadi/item.h>
27 #include <akonadi/collection.h>
28 
29 #include <KSystemTimeZones>
30 
31 using namespace Akonadi;
32 using namespace KCalCore;
33 
34 static QString itemToString(const Akonadi::Item &item)
35 {
36  const KCalCore::Incidence::Ptr &incidence = CalendarUtils::incidence(item);
37  QString str;
38  QTextStream stream(&str);
39  stream << item.id()
40  << "; summary=" << incidence->summary() << "; uid=" << incidence->uid() << "; type="
41  << incidence->type() << "; recurs=" << incidence->recurs() << "; recurrenceId="
42  << incidence->recurrenceId().toString() << "; dtStart=" << incidence->dtStart().toString()
43  << "; dtEnd=" << incidence->dateTime(Incidence::RoleEnd).toString()
44  << "; parentCollection=" << item.storageCollectionId() << item.parentCollection().displayName();
45 
46  return str;
47 }
48 
49 CalendarBasePrivate::CalendarBasePrivate(CalendarBase *qq) : QObject()
50  , mIncidenceChanger(new IncidenceChanger())
51  , mBatchInsertionCancelled(false)
52  , mListensForNewItems(false)
53  , q(qq)
54 {
55  connect(mIncidenceChanger,
56  SIGNAL(createFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
57  SLOT(slotCreateFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)));
58 
59  connect(mIncidenceChanger,
60  SIGNAL(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)),
61  SLOT(slotDeleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)));
62 
63  connect(mIncidenceChanger,
64  SIGNAL(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
65  SLOT(slotModifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)));
66 
67  mIncidenceChanger->setDestinationPolicy(IncidenceChanger::DestinationPolicyAsk);
68  mIncidenceChanger->setGroupwareCommunication(false);
69  mIncidenceChanger->setHistoryEnabled(false);
70 }
71 
72 CalendarBasePrivate::~CalendarBasePrivate()
73 {
74  delete mIncidenceChanger;
75  mIncidenceChanger = 0;
76 }
77 
78 void CalendarBasePrivate::internalInsert(const Akonadi::Item &item)
79 {
80  Q_ASSERT(item.isValid());
81  Q_ASSERT(item.hasPayload<KCalCore::Incidence::Ptr>());
82  KCalCore::Incidence::Ptr incidence = CalendarUtils::incidence(item);
83 
84  if (!incidence) {
85  kError() << "Incidence is null. id=" << item.id()
86  << "; hasPayload()=" << item.hasPayload()
87  << "; has incidence=" << item.hasPayload<KCalCore::Incidence::Ptr>()
88  << "; mime type=" << item.mimeType();
89  Q_ASSERT(false);
90  return;
91  }
92 
93  //kDebug() << "Inserting incidence in calendar. id=" << item.id() << "uid=" << incidence->uid();
94  const QString uid = incidence->instanceIdentifier();
95 
96  if (uid.isEmpty()) {
97  // This code path should never happen
98  kError() << "Incidence has empty UID. id=" << item.id()
99  << "; summary=" << incidence->summary()
100  << "Please fix it. Ignoring this incidence.";
101  return;
102  }
103 
104  if (mItemIdByUid.contains(uid) && mItemIdByUid[uid] != item.id()) {
105  // We only allow duplicate UIDs if they have the same item id, for example
106  // when using virtual folders.
107  kWarning() << "Discarding duplicate incidence with instanceIdentifier=" << uid
108  << "and summary " << incidence->summary()
109  << "; recurrenceId() =" << incidence->recurrenceId()
110  << "; new id=" << item.id()
111  << "; existing id=" << mItemIdByUid[uid];
112  return;
113  }
114 
115  if (incidence->type() == KCalCore::Incidence::TypeEvent && !incidence->dtStart().isValid()) {
116  // TODO: make the parser discard them would also be a good idea
117  kWarning() << "Discarding event with invalid DTSTART. identifier="
118  << incidence->instanceIdentifier() << "; summary=" << incidence->summary();
119  return;
120  }
121 
122  Akonadi::Collection collection = item.parentCollection();
123  if (collection.isValid()) {
124  // Some items don't have collection set
125  incidence->setReadOnly(!(collection.rights() & Akonadi::Collection::CanChangeItem));
126  }
127 
128  mItemById.insert(item.id(), item);
129  mItemIdByUid.insert(uid, item.id());
130  mItemsByCollection.insert(item.storageCollectionId(), item);
131 
132  if (!incidence->hasRecurrenceId()) {
133  // Insert parent relationships
134  const QString parentUid = incidence->relatedTo();
135  if (!parentUid.isEmpty()) {
136  mParentUidToChildrenUid[parentUid].append(incidence->uid());
137  mUidToParent.insert(uid, parentUid);
138  }
139  }
140 
141  incidence->setCustomProperty("VOLATILE", "AKONADI-ID", QString::number(item.id()));
142  // Must be the last one due to re-entrancy
143  const bool result = q->MemoryCalendar::addIncidence(incidence);
144  if (!result) {
145  kError() << "Error adding incidence " << itemToString(item);
146  Q_ASSERT(false);
147  }
148 }
149 
150 void CalendarBasePrivate::internalRemove(const Akonadi::Item &item)
151 {
152  Q_ASSERT(item.isValid());
153 
154  Incidence::Ptr tmp = CalendarUtils::incidence(item);
155  if (!tmp) {
156  kError() << "CalendarBase::internalRemove1: incidence is null, item.id=" << item.id();
157  return;
158  }
159 
160  // We want the one stored in the calendar
161  Incidence::Ptr incidence = q->incidence(tmp->uid(), tmp->recurrenceId());
162 
163  // Null incidence means it was deleted via CalendarBase::deleteIncidence(), but then
164  // the ETMCalendar received the monitor notification and tried to delete it again.
165  if (incidence) {
166  mItemById.remove(item.id());
167  // kDebug() << "Deleting incidence from calendar .id=" << item.id() << "uid=" << incidence->uid();
168  mItemIdByUid.remove(incidence->instanceIdentifier());
169 
170  mItemsByCollection.remove(item.storageCollectionId(), item);
171 
172  if (!incidence->hasRecurrenceId()) {
173  const QString uid = incidence->uid();
174  const QString parentUid = incidence->relatedTo();
175  mParentUidToChildrenUid.remove(uid);
176  if (!parentUid.isEmpty()) {
177  mParentUidToChildrenUid[parentUid].removeAll(uid);
178  mUidToParent.remove(uid);
179  }
180  }
181  // Must be the last one due to re-entrancy
182  const bool result = q->MemoryCalendar::deleteIncidence(incidence);
183  if (!result) {
184  kError() << "Error removing incidence " << itemToString(item);
185  Q_ASSERT(false);
186  }
187  } else {
188  kWarning() << "CalendarBase::internalRemove2: incidence is null, item.id=" << itemToString(item);
189  }
190 }
191 
192 void CalendarBasePrivate::deleteAllIncidencesOfType(const QString &mimeType)
193 {
194  kWarning() << "Refusing to delete your Incidences.";
195  Q_UNUSED(mimeType);
196  /*
197  QHash<Item::Id, Item>::iterator i;
198  Item::List incidences;
199  for ( i = mItemById.begin(); i != mItemById.end(); ++i ) {
200  if ( i.value().payload<KCalCore::Incidence::Ptr>()->mimeType() == mimeType )
201  incidences.append( i.value() );
202  }
203 
204  mIncidenceChanger->deleteIncidences( incidences );
205  */
206 }
207 
208 void CalendarBasePrivate::slotDeleteFinished(int changeId,
209  const QVector<Akonadi::Item::Id> &itemIds,
210  IncidenceChanger::ResultCode resultCode,
211  const QString &errorMessage)
212 {
213  Q_UNUSED(changeId);
214  if (resultCode == IncidenceChanger::ResultCodeSuccess) {
215  foreach(const Akonadi::Item::Id &id, itemIds) {
216  if (mItemById.contains(id))
217  internalRemove(mItemById.value(id));
218  }
219  }
220  emit q->deleteFinished(resultCode == IncidenceChanger::ResultCodeSuccess, errorMessage);
221 }
222 
223 void CalendarBasePrivate::slotCreateFinished(int changeId,
224  const Akonadi::Item &item,
225  IncidenceChanger::ResultCode resultCode,
226  const QString &errorMessage)
227 {
228  Q_UNUSED(changeId);
229  Q_UNUSED(item);
230  if (resultCode == IncidenceChanger::ResultCodeSuccess && !mListensForNewItems) {
231  Q_ASSERT(item.isValid());
232  Q_ASSERT(item.hasPayload<KCalCore::Incidence::Ptr>());
233  internalInsert(item);
234  }
235  emit q->createFinished(resultCode == IncidenceChanger::ResultCodeSuccess, errorMessage);
236 }
237 
238 void CalendarBasePrivate::slotModifyFinished(int changeId,
239  const Akonadi::Item &item,
240  IncidenceChanger::ResultCode resultCode,
241  const QString &errorMessage)
242 {
243  Q_UNUSED(changeId);
244  Q_UNUSED(item);
245  QString message = errorMessage;
246  if (resultCode == IncidenceChanger::ResultCodeSuccess) {
247  KCalCore::Incidence::Ptr incidence = CalendarUtils::incidence(item);
248  Q_ASSERT(incidence);
249  KCalCore::Incidence::Ptr localIncidence = q->incidence(incidence->instanceIdentifier());
250 
251  if (localIncidence) {
252  //update our local one
253  *(static_cast<KCalCore::IncidenceBase*>(localIncidence.data())) = *(incidence.data());
254  } else {
255  // This shouldn't happen, unless the incidence gets deleted between event loops
256  kWarning() << "CalendarBasePrivate::slotModifyFinished() Incidence was deleted already probably? id=" << item.id();
257  message = QLatin1String("Could not find incidence to update, probably was deleted recently.");
258  resultCode = IncidenceChanger::ResultCodeAlreadyDeleted;
259  }
260  }
261  emit q->modifyFinished(resultCode == IncidenceChanger::ResultCodeSuccess, message);
262 }
263 
264 void CalendarBasePrivate::handleUidChange(const Akonadi::Item &oldItem,
265  const Akonadi::Item &newItem, const QString &newIdentifier)
266 {
267  Q_ASSERT(oldItem.isValid());
268  Incidence::Ptr newIncidence = CalendarUtils::incidence(newItem);
269  Q_ASSERT(newIncidence);
270  Incidence::Ptr oldIncidence = CalendarUtils::incidence(oldItem);
271  Q_ASSERT(oldIncidence);
272 
273  const QString newUid = newIncidence->uid();
274  if (mItemIdByUid.contains(newIdentifier)) {
275  Incidence::Ptr oldIncidence = CalendarUtils::incidence(oldItem);
276  kWarning() << "New uid shouldn't be known: " << newIdentifier << "; id="
277  << newItem.id() << "; oldItem.id=" << mItemIdByUid[newIdentifier]
278  << "; new summary= " << newIncidence->summary()
279  << "; new recurrenceId=" << newIncidence->recurrenceId()
280  << "; oldIncidence" << oldIncidence;
281  if (oldIncidence) {
282  kWarning() << "; oldIncidence uid=" << oldIncidence->uid()
283  << "; oldIncidence recurrenceId = " << oldIncidence->recurrenceId()
284  << "; oldIncidence summary = " << oldIncidence->summary();
285  }
286  Q_ASSERT(false);
287  return;
288  }
289 
290  mItemIdByUid[newIdentifier] = newItem.id();
291 
292  // Get the real pointer
293  oldIncidence = q->MemoryCalendar::incidence(oldIncidence->uid());
294 
295  if (!oldIncidence) {
296  // How can this happen ?
297  kWarning() << "Couldn't find old incidence";
298  Q_ASSERT(false);
299  return;
300  }
301 
302  if (newIncidence->instanceIdentifier() == oldIncidence->instanceIdentifier()) {
303  kWarning() << "New uid=" << newIncidence->uid() << "; old uid=" << oldIncidence->uid()
304  << "; new recurrenceId="
305  << newIncidence->recurrenceId()
306  << "; old recurrenceId=" << oldIncidence->recurrenceId()
307  << "; new summary = " << newIncidence->summary()
308  << "; old summary = " << oldIncidence->summary()
309  << "; id = " << newItem.id();
310  Q_ASSERT(false); // The reason we're here in the first place
311  return;
312  }
313 
314  mItemIdByUid.remove(oldIncidence->instanceIdentifier());
315  const QString oldUid = oldIncidence->uid();
316 
317  if (mParentUidToChildrenUid.contains(oldUid)) {
318  Q_ASSERT(!mParentUidToChildrenUid.contains(newIdentifier));
319  QStringList children = mParentUidToChildrenUid.value(oldUid);
320  mParentUidToChildrenUid.insert(newIdentifier, children);
321  mParentUidToChildrenUid.remove(oldUid);
322  }
323 
324  // Update internal maps of the base class, MemoryCalendar
325  q->setObserversEnabled(false);
326  q->MemoryCalendar::deleteIncidence(oldIncidence);
327  q->MemoryCalendar::addIncidence(newIncidence);
328 
329  newIncidence->setUid(oldUid); // We set and unset just to notify observers of a change.
330  q->setObserversEnabled(true);
331  newIncidence->setUid(newUid);
332 }
333 
334 void CalendarBasePrivate::handleParentChanged(const KCalCore::Incidence::Ptr &newIncidence)
335 {
336  Q_ASSERT(newIncidence);
337 
338  if (newIncidence->hasRecurrenceId()) { // These ones don't/shouldn't have a parent
339  return;
340  }
341 
342  const QString originalParentUid = mUidToParent.value(newIncidence->uid());
343  const QString newParentUid = newIncidence->relatedTo();
344 
345  if (originalParentUid == newParentUid) {
346  return; // nothing changed
347  }
348 
349  if (!originalParentUid.isEmpty()) {
350  // Remove this child from it's old parent:
351  Q_ASSERT(mParentUidToChildrenUid.contains(originalParentUid));
352  mParentUidToChildrenUid[originalParentUid].removeAll(newIncidence->uid());
353  }
354 
355  mUidToParent.remove(newIncidence->uid());
356 
357  if (!newParentUid.isEmpty()) {
358  // Deliver this child to it's new parent:
359  Q_ASSERT(!mParentUidToChildrenUid[newParentUid].contains(newIncidence->uid()));
360  mParentUidToChildrenUid[newParentUid].append(newIncidence->uid());
361  mUidToParent.insert(newIncidence->uid(), newParentUid);
362  }
363 }
364 
365 CalendarBase::CalendarBase(QObject *parent) : MemoryCalendar(KSystemTimeZones::local())
366  , d_ptr(new CalendarBasePrivate(this))
367 {
368  setParent(parent);
369  setDeletionTracking(false);
370 }
371 
372 CalendarBase::CalendarBase(CalendarBasePrivate *const dd,
373  QObject *parent) : MemoryCalendar(KSystemTimeZones::local())
374  , d_ptr(dd)
375 {
376  setParent(parent);
377  setDeletionTracking(false);
378 }
379 
380 CalendarBase::~CalendarBase()
381 {
382 }
383 
384 Akonadi::Item CalendarBase::item(Akonadi::Item::Id id) const
385 {
386  Q_D(const CalendarBase);
387  Akonadi::Item i;
388  if (d->mItemById.contains(id)) {
389  i = d->mItemById[id];
390  } else {
391  kDebug() << "Can't find any item with id " << id;
392  }
393  return i;
394 }
395 
396 Akonadi::Item CalendarBase::item(const QString &uid) const
397 {
398  Q_D(const CalendarBase);
399  Akonadi::Item i;
400 
401  if (uid.isEmpty())
402  return i;
403 
404  if (d->mItemIdByUid.contains(uid)) {
405  const Akonadi::Item::Id id = d->mItemIdByUid[uid];
406  if (!d->mItemById.contains(id)) {
407  kError() << "Item with id " << id << "(uid=" << uid << ") not found, but in uid map";
408  Q_ASSERT_X(false, "CalendarBase::item", "not in mItemById");
409  }
410  i = d->mItemById[id];
411  } else {
412  kDebug() << "Can't find any incidence with uid " << uid;
413  }
414  return i;
415 }
416 
417 Item CalendarBase::item(const Incidence::Ptr &incidence) const
418 {
419  return incidence ? item(incidence->instanceIdentifier()) : Item();
420 }
421 
422 Akonadi::Item::List CalendarBase::items() const
423 {
424  Q_D(const CalendarBase);
425  return d->mItemById.values();
426 }
427 
428 Akonadi::Item::List CalendarBase::itemList(const KCalCore::Incidence::List &incidences) const
429 {
430  Akonadi::Item::List items;
431 
432  foreach(const KCalCore::Incidence::Ptr &incidence, incidences) {
433  if (incidence) {
434  items << item(incidence->instanceIdentifier());
435  } else {
436  items << Akonadi::Item();
437  }
438  }
439 
440  return items;
441 }
442 
443 KCalCore::Incidence::List CalendarBase::childIncidences(const Akonadi::Item::Id &parentId) const
444 {
445  Q_D(const CalendarBase);
446  KCalCore::Incidence::List childs;
447 
448  if (d->mItemById.contains(parentId)) {
449  const Akonadi::Item item = d->mItemById.value(parentId);
450  Q_ASSERT(item.isValid());
451  KCalCore::Incidence::Ptr parent = CalendarUtils::incidence(item);
452 
453  if (parent) {
454  childs = childIncidences(parent->uid());
455  } else {
456  Q_ASSERT(false);
457  }
458  }
459 
460  return childs;
461 }
462 
463 KCalCore::Incidence::List CalendarBase::childIncidences(const QString &parentUid) const
464 {
465  Q_D(const CalendarBase);
466  KCalCore::Incidence::List children;
467  const QStringList uids = d->mParentUidToChildrenUid.value(parentUid);
468  Q_FOREACH(const QString &uid, uids) {
469  Incidence::Ptr child = incidence(uid);
470  if (child)
471  children.append(child);
472  else
473  kWarning() << "Invalid child with uid " << uid;
474  }
475  return children;
476 }
477 
478 Akonadi::Item::List CalendarBase::childItems(const Akonadi::Item::Id &parentId) const
479 {
480  Q_D(const CalendarBase);
481  Akonadi::Item::List childs;
482 
483  if (d->mItemById.contains(parentId)) {
484  const Akonadi::Item item = d->mItemById.value(parentId);
485  Q_ASSERT(item.isValid());
486  KCalCore::Incidence::Ptr parent = CalendarUtils::incidence(item);
487 
488  if (parent) {
489  childs = childItems(parent->uid());
490  } else {
491  Q_ASSERT(false);
492  }
493  }
494 
495  return childs;
496 }
497 
498 Akonadi::Item::List CalendarBase::childItems(const QString &parentUid) const
499 {
500  Q_D(const CalendarBase);
501  Akonadi::Item::List children;
502  const QStringList uids = d->mParentUidToChildrenUid.value(parentUid);
503  Q_FOREACH(const QString &uid, uids) {
504  Akonadi::Item child = item(uid);
505  if (child.isValid() && child.hasPayload<KCalCore::Incidence::Ptr>())
506  children.append(child);
507  else
508  kWarning() << "Invalid child with uid " << uid;
509  }
510  return children;
511 }
512 
513 bool CalendarBase::addEvent(const KCalCore::Event::Ptr &event)
514 {
515  return addIncidence(event);
516 }
517 
518 bool CalendarBase::deleteEvent(const KCalCore::Event::Ptr &event)
519 {
520  return deleteIncidence(event);
521 }
522 
523 void CalendarBase::deleteAllEvents()
524 {
525  Q_D(CalendarBase);
526  d->deleteAllIncidencesOfType(Event::eventMimeType());
527 }
528 
529 bool CalendarBase::addTodo(const KCalCore::Todo::Ptr &todo)
530 {
531  return addIncidence(todo);
532 }
533 
534 bool CalendarBase::deleteTodo(const KCalCore::Todo::Ptr &todo)
535 {
536  return deleteIncidence(todo);
537 }
538 
539 void CalendarBase::deleteAllTodos()
540 {
541  Q_D(CalendarBase);
542  d->deleteAllIncidencesOfType(Todo::todoMimeType());
543 }
544 
545 bool CalendarBase::addJournal(const KCalCore::Journal::Ptr &journal)
546 {
547  return addIncidence(journal);
548 }
549 
550 bool CalendarBase::deleteJournal(const KCalCore::Journal::Ptr &journal)
551 {
552  return deleteIncidence(journal);
553 }
554 
555 void CalendarBase::deleteAllJournals()
556 {
557  Q_D(CalendarBase);
558  d->deleteAllIncidencesOfType(Journal::journalMimeType());
559 }
560 
561 bool CalendarBase::addIncidence(const KCalCore::Incidence::Ptr &incidence)
562 {
563  //TODO: Parent for dialogs
564  Q_D(CalendarBase);
565 
566  // User canceled on the collection selection dialog
567  if (batchAdding() && d->mBatchInsertionCancelled) {
568  return false;
569  }
570 
571  Akonadi::Collection collection;
572 
573  if (batchAdding() && d->mCollectionForBatchInsertion.isValid()) {
574  collection = d->mCollectionForBatchInsertion;
575  }
576 
577  if (incidence->hasRecurrenceId() && !collection.isValid()) {
578  // We are creating an exception, reuse the same collection that the main incidence uses
579  Item mainItem = item(incidence->uid());
580  if (mainItem.isValid()) {
581  collection = Collection(mainItem.storageCollectionId());
582  }
583  }
584 
585  const int changeId = d->mIncidenceChanger->createIncidence(incidence, collection);
586 
587  if (batchAdding()) {
588  const Akonadi::Collection lastCollection = d->mIncidenceChanger->lastCollectionUsed();
589  if (changeId != -1 && !lastCollection.isValid()) {
590  d->mBatchInsertionCancelled = true;
591  } else if (lastCollection.isValid() && !d->mCollectionForBatchInsertion.isValid()) {
592  d->mCollectionForBatchInsertion = d->mIncidenceChanger->lastCollectionUsed();
593  }
594  }
595 
596  return changeId != -1;
597 }
598 
599 bool CalendarBase::deleteIncidence(const KCalCore::Incidence::Ptr &incidence)
600 {
601  Q_D(CalendarBase);
602  Q_ASSERT(incidence);
603  Akonadi::Item item_ = item(incidence->instanceIdentifier());
604  return -1 != d->mIncidenceChanger->deleteIncidence(item_);
605 }
606 
607 bool CalendarBase::modifyIncidence(const KCalCore::Incidence::Ptr &newIncidence)
608 {
609  Q_D(CalendarBase);
610  Q_ASSERT(newIncidence);
611  Akonadi::Item item_ = item(newIncidence->instanceIdentifier());
612  item_.setPayload<KCalCore::Incidence::Ptr>(newIncidence);
613  return -1 != d->mIncidenceChanger->modifyIncidence(item_);
614 }
615 
616 void CalendarBase::setWeakPointer(const QWeakPointer<CalendarBase> &pointer)
617 {
618  Q_D(CalendarBase);
619  d->mWeakPointer = pointer;
620 }
621 
622 QWeakPointer<CalendarBase> CalendarBase::weakPointer() const
623 {
624  Q_D(const CalendarBase);
625  return d->mWeakPointer;
626 }
627 
628 IncidenceChanger* CalendarBase::incidenceChanger() const
629 {
630  Q_D(const CalendarBase);
631  return d->mIncidenceChanger;
632 }
633 
634 void CalendarBase::startBatchAdding()
635 {
636  KCalCore::MemoryCalendar::startBatchAdding();
637 }
638 
639 void CalendarBase::endBatchAdding()
640 {
641  Q_D(CalendarBase);
642  d->mCollectionForBatchInsertion = Akonadi::Collection();
643  d->mBatchInsertionCancelled = false;
644  KCalCore::MemoryCalendar::endBatchAdding();
645 }
646 
647 #include "calendarbase.moc"
648 #include "calendarbase_p.moc"
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Fri Jan 3 2014 22:27:33 by doxygen 1.8.3.1 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

akonadi

Skip menu "akonadi"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • Modules
  • Related Pages

kdepimlibs-4.11.5 API Reference

Skip menu "kdepimlibs-4.11.5 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