Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 2291 insertions, 0 deletions

diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
new file mode 100644
index 00000000..75e7ee43
--- /dev/null
+++ b/korganizer/calendarview.cpp
@@ -0,0 +1,2291 @@
+/*
+    This file is part of KOrganizer.
+
+    Copyright (c) 1997, 1998, 1999
+    Preston Brown (preston.brown@yale.edu)
+    Fester Zigterman (F.J.F.ZigtermanRustenburg@student.utwente.nl)
+    Ian Dawes (iadawes@globalserve.net)
+    Laszlo Boloni (boloni@cs.purdue.edu)
+
+    Copyright (c) 2000, 2001, 2002, 2003, 2004
+    Cornelius Schumacher <schumacher@kde.org>
+    Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+    As a special exception, permission is given to link this program
+    with any edition of Qt, and distribute the resulting executable,
+    without including the source code for Qt in the source distribution.
+*/
+
+#include "calendarview.h"
+
+#ifndef KORG_NOPRINTER
+#include "calprinter.h"
+#endif
+#include "koeventeditor.h"
+#include "kotodoeditor.h"
+#include "kojournaleditor.h"
+#include "koprefs.h"
+#include "koeventviewerdialog.h"
+#include "publishdialog.h"
+#include "koglobals.h"
+#include "koviewmanager.h"
+#include "koagendaview.h"
+#include "kodialogmanager.h"
+#include "statusdialog.h"
+#include "datenavigatorcontainer.h"
+#include "kotodoview.h"
+#include "datenavigator.h"
+#include "resourceview.h"
+#include "navigatorbar.h"
+#include "history.h"
+#include "kogroupware.h"
+#include "freebusymanager.h"
+#include "komonthview.h"
+#include "datechecker.h"
+#include "komessagebox.h"
+#include "exportwebdialog.h"
+#include "kocorehelper.h"
+#include "incidencechanger.h"
+#include "kholidays.h"
+#include "mailscheduler.h"
+#include "komailclient.h"
+#include "multiagendaview.h"
+
+#include <libkcal/vcaldrag.h>
+#include <libkcal/icaldrag.h>
+#include <libkcal/icalformat.h>
+#include <libkcal/vcalformat.h>
+#include <libkcal/scheduler.h>
+#include <libkcal/calendarlocal.h>
+#include <libkcal/journal.h>
+#include <libkcal/calfilter.h>
+#include <libkcal/attendee.h>
+#include <libkcal/dndfactory.h>
+#include <libkcal/freebusy.h>
+#include <libkcal/filestorage.h>
+#include <libkcal/calendarresources.h>
+#include <libkcal/calendarnull.h>
+#include <libkcal/htmlexportsettings.h>
+
+#include <kglobal.h>
+#include <kdebug.h>
+#include <kstandarddirs.h>
+#include <kfiledialog.h>
+#include <kmessagebox.h>
+#include <knotifyclient.h>
+#include <kconfig.h>
+#include <krun.h>
+#include <kdirwatch.h>
+
+#include <qapplication.h>
+#include <qclipboard.h>
+#include <qcursor.h>
+#include <qmultilineedit.h>
+#include <qtimer.h>
+#include <qwidgetstack.h>
+#include <qptrlist.h>
+#include <qfile.h>
+#include <qlayout.h>
+#ifndef KORG_NOSPLITTER
+#include <qsplitter.h>
+#endif
+#include <qvbox.h>
+#include <qwhatsthis.h>
+
+#include <stdlib.h>
+#include <assert.h>
+
+using namespace KOrg;
+
+CalendarView::CalendarView( QWidget *parent, const char *name )
+  : CalendarViewBase( parent, name ),
+    mHistory( 0 ),
+    mCalendar( CalendarNull::self() ),
+    mChanger( 0 )
+{
+  kdDebug(5850) << "CalendarView::CalendarView( Calendar )" << endl;
+
+  mViewManager = new KOViewManager( this );
+  mDialogManager = new KODialogManager( this );
+
+  mModified = false;
+  mReadOnly = false;
+  mSelectedIncidence = 0;
+
+  mFilters.setAutoDelete( true );
+
+  mExtensions.setAutoDelete( true );
+
+  mNavigator = new DateNavigator( this );
+  mDateChecker = new DateChecker( this );
+
+  QBoxLayout *topLayout = new QVBoxLayout( this );
+
+#ifndef KORG_NOSPLITTER
+  // create the main layout frames.
+  mPanner = new QSplitter( QSplitter::Horizontal, this,
+                           "CalendarView::Panner" );
+  topLayout->addWidget( mPanner );
+
+  mLeftSplitter = new QSplitter( QSplitter::Vertical, mPanner,
+                                 "CalendarView::LeftFrame" );
+//  mPanner->setResizeMode( mLeftSplitter, QSplitter::Stretch );
+
+  mDateNavigator = new DateNavigatorContainer( mLeftSplitter,
+                                               "CalendarView::DateNavigator" );
+
+//  mLeftSplitter->setResizeMode( mDateNavigator, QSplitter::Stretch );
+  mLeftSplitter->setCollapsible( mDateNavigator, true );
+  mTodoList = new KOTodoView( CalendarNull::self(), mLeftSplitter, "todolist" );
+
+  mEventViewer = new KOEventViewer( mLeftSplitter,"EventViewer" );
+
+  QVBox *rightBox = new QVBox( mPanner );
+  mNavigatorBar = new NavigatorBar( rightBox );
+  mRightFrame = new QWidgetStack( rightBox );
+  rightBox->setStretchFactor( mRightFrame, 1 );
+
+  mLeftFrame = mLeftSplitter;
+#else
+  QWidget *mainBox;
+  QWidget *leftFrame;
+
+  if ( KOPrefs::instance()->mVerticalScreen ) {
+    mainBox = new QVBox( this );
+    leftFrame = new QHBox( mainBox );
+  } else {
+    mainBox = new QHBox( this );
+    leftFrame = new QVBox( mainBox );
+  }
+
+  topLayout->addWidget( mainBox );
+
+  mDateNavigator = new KDateNavigator( leftFrame, true,
+                                       "CalendarView::DateNavigator",
+                                       QDate::currentDate() );
+  mTodoList = new KOTodoView( CalendarNull::self(), leftFrame, "todolist" );
+
+  mEventViewer = new KOEventViewer ( leftFrame, "EventViewer" );
+
+  QWidget *rightBox = new QWidget( mainBox );
+  QBoxLayout *rightLayout = new QVBoxLayout( rightBox );
+
+  mNavigatorBar = new NavigatorBar( QDate::currentDate(), rightBox );
+  rightLayout->addWidget( mNavigatorBar );
+
+  mRightFrame = new QWidgetStack( rightBox );
+  rightLayout->addWidget( mRightFrame );
+
+  mLeftFrame = leftFrame;
+
+  if ( KOPrefs::instance()->mVerticalScreen ) {
+//    mTodoList->setFixedHeight( 60 );
+    mTodoList->setFixedHeight( mDateNavigator->sizeHint().height() );
+  }
+#endif
+
+  connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
+           SLOT( showDates( const KCal::DateList & ) ) );
+  connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
+           mDateNavigator, SLOT( selectDates( const KCal::DateList & ) ) );
+
+  connect( mNavigatorBar, SIGNAL( goPrevYear() ),
+           mNavigator, SLOT( selectPreviousYear() ) );
+  connect( mNavigatorBar, SIGNAL( goNextYear() ),
+           mNavigator, SLOT( selectNextYear() ) );
+  connect( mNavigatorBar, SIGNAL( goPrevMonth() ),
+           mNavigator, SLOT( selectPreviousMonth() ) );
+  connect( mNavigatorBar, SIGNAL( goNextMonth() ),
+           mNavigator, SLOT( selectNextMonth() ) );
+  connect( mNavigatorBar, SIGNAL( goMonth(int) ),
+           mNavigator, SLOT( selectMonth(int) ) );
+
+  connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
+           mNavigatorBar, SLOT( selectDates( const KCal::DateList & ) ) );
+
+  connect( mDateNavigator, SIGNAL( weekClicked( const QDate & ) ),
+           mNavigator, SLOT( selectWeek( const QDate & ) ) );
+
+  connect( mDateNavigator, SIGNAL( goPrevYear() ),
+           mNavigator, SLOT( selectPreviousYear() ) );
+  connect( mDateNavigator, SIGNAL( goNextYear() ),
+           mNavigator, SLOT( selectNextYear() ) );
+  connect( mDateNavigator, SIGNAL( goPrevMonth() ),
+           mNavigator, SLOT( selectPreviousMonth() ) );
+  connect( mDateNavigator, SIGNAL( goNextMonth() ),
+           mNavigator, SLOT( selectNextMonth() ) );
+  connect( mDateNavigator, SIGNAL( goMonth(int) ),
+           mNavigator, SLOT( selectMonth(int) ) );
+
+  connect( mDateNavigator, SIGNAL( goPrevious() ),
+           mNavigator, SLOT( selectPrevious() ) );
+  connect( mDateNavigator, SIGNAL( goNext() ),
+           mNavigator, SLOT( selectNext() ) );
+
+  connect( mDateNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
+           mNavigator, SLOT( selectDates( const KCal::DateList & ) ) );
+
+  connect( mDateNavigator, SIGNAL(incidenceDropped(Incidence*, const QDate&)),
+           SLOT( addIncidenceOn( Incidence *, const QDate & ) ) );
+  connect( mDateNavigator, SIGNAL(incidenceDroppedMove(Incidence*,const QDate&)),
+           SLOT( moveIncidenceTo( Incidence *, const QDate & ) ) );
+
+  connect( mDateChecker, SIGNAL( dayPassed( const QDate & ) ),
+           mTodoList, SLOT( dayPassed( const QDate & ) ) );
+  connect( mDateChecker, SIGNAL( dayPassed( const QDate & ) ),
+           SIGNAL( dayPassed( const QDate & ) ) );
+  connect( mDateChecker, SIGNAL( dayPassed( const QDate & ) ),
+           mDateNavigator, SLOT( updateToday() ) );
+
+  connect( this, SIGNAL( configChanged() ),
+           mDateNavigator, SLOT( updateConfig() ) );
+
+  connect( this, SIGNAL( incidenceSelected(Incidence *) ),
+           mEventViewer, SLOT ( setIncidence (Incidence *) ) );
+
+  //TODO: do a pretty Summary,
+  QString s;
+  s = i18n( "<p><em>No Item Selected</em></p>"
+           "<p>Select an event, to-do or journal entry to view its details "
+           "here.</p>");
+
+  mEventViewer->setDefaultText( s );
+  QWhatsThis::add( mEventViewer,
+                   i18n( "View the details of events, journal entries or to-dos "
+                         "selected in KOrganizer's main view here." ) );
+  mEventViewer->setIncidence( 0 );
+
+  mViewManager->connectTodoView( mTodoList );
+  mViewManager->connectView( mTodoList );
+
+  KOGlobals::self()->
+      setHolidays( new KHolidays( KOPrefs::instance()->mHolidays ) );
+
+  connect( QApplication::clipboard(), SIGNAL( dataChanged() ),
+           SLOT( checkClipboard() ) );
+
+  connect( mTodoList, SIGNAL( incidenceSelected( Incidence * ) ),
+           SLOT( processTodoListSelection( Incidence * ) ) );
+  disconnect( mTodoList, SIGNAL( incidenceSelected( Incidence * ) ),
+           this, SLOT( processMainViewSelection( Incidence * ) ) );
+
+  kdDebug(5850) << "CalendarView::CalendarView() done" << endl;
+}
+
+CalendarView::~CalendarView()
+{
+  kdDebug(5850) << "~CalendarView()" << endl;
+
+  mCalendar->unregisterObserver( this );
+
+  delete mDialogManager;
+  delete mViewManager;
+  delete mEventViewer;
+  kdDebug(5850) << "~CalendarView() done" << endl;
+}
+
+void CalendarView::setCalendar( Calendar *cal )
+{
+  kdDebug(5850)<<"CalendarView::setCalendar"<<endl;
+  mCalendar = cal;
+
+  delete mHistory;
+  mHistory = new History( mCalendar );
+  connect( mHistory, SIGNAL( undone() ), SLOT( updateView() ) );
+  connect( mHistory, SIGNAL( redone() ), SLOT( updateView() ) );
+
+  if ( mChanger ) delete mChanger;
+  setIncidenceChanger( new IncidenceChanger( mCalendar, this ) );
+
+  mCalendar->registerObserver( this );
+
+  mDateNavigator->setCalendar( mCalendar );
+
+  mTodoList->setCalendar( mCalendar );
+}
+
+void CalendarView::setIncidenceChanger( IncidenceChangerBase *changer )
+{
+  mChanger = changer;
+  emit newIncidenceChanger( mChanger );
+  connect( mChanger, SIGNAL( incidenceAdded( Incidence* ) ),
+           this, SLOT( incidenceAdded( Incidence* ) ) );
+  connect( mChanger, SIGNAL( incidenceChanged( Incidence*, Incidence*, int ) ),
+           this, SLOT( incidenceChanged( Incidence*, Incidence*, int ) ) );
+  connect( mChanger, SIGNAL( incidenceChanged( Incidence*, Incidence* ) ),
+           this, SLOT( incidenceChanged( Incidence*, Incidence* ) ) );
+  connect( mChanger, SIGNAL( incidenceToBeDeleted( Incidence * ) ),
+           this, SLOT( incidenceToBeDeleted( Incidence * ) ) );
+  connect( mChanger, SIGNAL( incidenceDeleted( Incidence * ) ),
+           this, SLOT( incidenceDeleted( Incidence * ) ) );
+
+  connect( mChanger, SIGNAL( schedule( Scheduler::Method, Incidence*) ),
+           this, SLOT( schedule( Scheduler::Method, Incidence*) ) );
+
+
+  connect( this, SIGNAL( cancelAttendees( Incidence * ) ),
+           mChanger, SLOT( cancelAttendees( Incidence * ) ) );
+}
+
+Calendar *CalendarView::calendar()
+{
+  if ( mCalendar ) return mCalendar;
+  else return CalendarNull::self();
+}
+
+KOIncidenceEditor *CalendarView::editorDialog( Incidence *incidence ) const
+{
+  if (mDialogList.find(incidence) != mDialogList.end ())
+    return mDialogList[incidence];
+  else return 0;
+}
+
+QDate CalendarView::startDate()
+{
+  DateList dates = mNavigator->selectedDates();
+
+  return dates.first();
+}
+
+QDate CalendarView::endDate()
+{
+  DateList dates = mNavigator->selectedDates();
+
+  return dates.last();
+}
+
+
+bool CalendarView::openCalendar(const QString& filename, bool merge)
+{
+  kdDebug(5850) << "CalendarView::openCalendar(): " << filename << endl;
+
+  if (filename.isEmpty()) {
+    kdDebug(5850) << "CalendarView::openCalendar(): Error! Empty filename." << endl;
+    return false;
+  }
+
+  if (!QFile::exists(filename)) {
+    kdDebug(5850) << "CalendarView::openCalendar(): Error! File '" << filename
+              << "' doesn't exist." << endl;
+  }
+
+  bool loadedSuccesfully = true;
+  if ( !merge ) {
+    mCalendar->close();
+    CalendarLocal *cl = dynamic_cast<CalendarLocal*>( mCalendar );
+    if ( cl ) {
+      loadedSuccesfully = cl->load( filename );
+    } else {
+      CalendarResources *cr = dynamic_cast<CalendarResources*>( mCalendar );
+      assert( cr ); // otherwise something is majorly wrong
+      // openCalendar called without merge and a filename, what should we do?
+      return false;
+    }
+  } else {
+    // merge in a file
+    FileStorage storage( mCalendar );
+    storage.setFileName( filename );
+    loadedSuccesfully = storage.load();
+  }
+
+  if ( loadedSuccesfully ) {
+    if ( merge )
+      setModified( true );
+    else {
+      setModified( false );
+      mViewManager->setDocumentId( filename );
+      mTodoList->setDocumentId( filename );
+    }
+    updateCategories();
+    updateView();
+    return true;
+  } else {
+    // while failing to load, the calendar object could
+    // have become partially populated.  Clear it out.
+    if ( !merge ) mCalendar->close();
+
+    KMessageBox::error(this,i18n("Could not load calendar '%1'.").arg(filename));
+
+    return false;
+  }
+}
+
+bool CalendarView::saveCalendar( const QString& filename )
+{
+  kdDebug(5850) << "CalendarView::saveCalendar(): " << filename << endl;
+
+  // Store back all unsaved data into calendar object
+  mViewManager->currentView()->flushView();
+
+  FileStorage storage( mCalendar );
+  storage.setFileName( filename );
+  storage.setSaveFormat( new ICalFormat );
+
+  bool success = storage.save();
+
+  if ( !success ) {
+    return false;
+  }
+
+  return true;
+}
+
+void CalendarView::closeCalendar()
+{
+  kdDebug(5850) << "CalendarView::closeCalendar()" << endl;
+
+  // child windows no longer valid
+  emit closingDown();
+
+  mCalendar->close();
+  setModified( false );
+  updateView();
+}
+
+void CalendarView::archiveCalendar()
+{
+  mDialogManager->showArchiveDialog();
+}
+
+
+void CalendarView::readSettings()
+{
+//  kdDebug(5850) << "CalendarView::readSettings()" << endl;
+
+  QString str;
+
+  // read settings from the KConfig, supplying reasonable
+  // defaults where none are to be found
+
+  KConfig *config = KOGlobals::self()->config();
+
+#ifndef KORG_NOSPLITTER
+  config->setGroup( "KOrganizer Geometry" );
+
+  QValueList<int> sizes = config->readIntListEntry( "Separator1" );
+  if ( sizes.count() != 2 ) {
+    sizes << mDateNavigator->minimumSizeHint().width();
+    sizes << 300;
+  }
+  mPanner->setSizes( sizes );
+
+  sizes = config->readIntListEntry( "Separator2" );
+  mLeftSplitter->setSizes( sizes );
+#endif
+
+  mEventViewer->readSettings( config );
+
+  mViewManager->readSettings( config );
+  mTodoList->restoreLayout( config, QString( "Todo Layout" ) );
+
+  readFilterSettings( config );
+
+  config->setGroup( "Views" );
+  int dateCount = config->readNumEntry( "ShownDatesCount", 7 );
+  if ( dateCount == 7 ) mNavigator->selectWeek();
+  else mNavigator->selectDates( mNavigator->selectedDates().first(), dateCount );
+}
+
+
+void CalendarView::writeSettings()
+{
+//  kdDebug(5850) << "CalendarView::writeSettings" << endl;
+
+  KConfig *config = KOGlobals::self()->config();
+
+#ifndef KORG_NOSPLITTER
+  config->setGroup( "KOrganizer Geometry" );
+
+  QValueList<int> list = mPanner->sizes();
+  config->writeEntry( "Separator1", list );
+
+  list = mLeftSplitter->sizes();
+  config->writeEntry( "Separator2", list );
+#endif
+  mEventViewer->writeSettings( config );
+  mViewManager->writeSettings( config );
+  mTodoList->saveLayout( config, QString( "Todo Layout" ) );
+
+  KOPrefs::instance()->writeConfig();
+
+  writeFilterSettings( config );
+
+  config->setGroup( "Views" );
+  config->writeEntry( "ShownDatesCount", mNavigator->selectedDates().count() );
+
+  config->sync();
+}
+
+void CalendarView::readFilterSettings( KConfig *config )
+{
+//  kdDebug(5850) << "CalendarView::readFilterSettings()" << endl;
+
+  mFilters.clear();
+
+  config->setGroup( "General" );
+  // FIXME: Move the filter loading and saving to the CalFilter class in libkcal
+  QStringList filterList = config->readListEntry ("CalendarFilters" );
+  QString currentFilter = config->readEntry( "Current Filter" );
+
+  QStringList::ConstIterator it = filterList.begin();
+  QStringList::ConstIterator end = filterList.end();
+  while( it != end ) {
+//    kdDebug(5850) << "  filter: " << (*it) << endl;
+    CalFilter *filter;
+    filter = new CalFilter( *it );
+    config->setGroup( "Filter_" + (*it) );
+    filter->setCriteria( config->readNumEntry( "Criteria", 0 ) );
+    filter->setCategoryList( config->readListEntry( "CategoryList" ) );
+    if ( filter->criteria() & KCal::CalFilter::HideTodosWithoutAttendeeInEmailList )
+      filter->setEmailList( KOPrefs::instance()->allEmails() );
+    filter->setCompletedTimeSpan( config->readNumEntry( "HideTodoDays", 0 ) );
+    mFilters.append( filter );
+
+    ++it;
+  }
+
+  config->setGroup( "General" );
+  int pos = filterList.findIndex( currentFilter );
+  mCurrentFilter = 0;
+  if ( pos>=0 ) {
+    mCurrentFilter = mFilters.at( pos );
+  }
+  updateFilter();
+}
+
+void CalendarView::writeFilterSettings( KConfig *config )
+{
+//  kdDebug(5850) << "CalendarView::writeFilterSettings()" << endl;
+
+  QStringList filterList;
+
+  CalFilter *filter = mFilters.first();
+  while( filter ) {
+//    kdDebug(5850) << " fn: " << filter->name() << endl;
+    filterList << filter->name();
+    config->setGroup( "Filter_" + filter->name() );
+    config->writeEntry( "Criteria", filter->criteria() );
+    config->writeEntry( "CategoryList", filter->categoryList() );
+    config->writeEntry( "HideTodoDays", filter->completedTimeSpan() );
+    filter = mFilters.next();
+  }
+  config->setGroup( "General" );
+  config->writeEntry( "CalendarFilters", filterList );
+  if ( mCurrentFilter ) {
+    config->writeEntry( "Current Filter", mCurrentFilter->name() );
+  } else {
+    config->writeEntry( "Current Filter", QString::null );
+  }
+}
+
+
+void CalendarView::goDate( const QDate& date )
+{
+  mNavigator->selectDate( date );
+}
+
+void CalendarView::showDate(const QDate & date)
+{
+  int dateCount = mNavigator->datesCount();
+  if ( dateCount == 7 )
+    mNavigator->selectWeek( date );
+  else
+    mNavigator->selectDates( date, dateCount );
+}
+
+void CalendarView::goToday()
+{
+  mNavigator->selectToday();
+}
+
+void CalendarView::goNext()
+{
+  if ( dynamic_cast<KOMonthView*>( mViewManager->currentView() ) )
+    mNavigator->selectNextMonth();
+  else
+    mNavigator->selectNext();
+}
+
+void CalendarView::goPrevious()
+{
+  if ( dynamic_cast<KOMonthView*>( mViewManager->currentView() ) )
+    mNavigator->selectPreviousMonth();
+  else
+    mNavigator->selectPrevious();
+}
+
+void CalendarView::updateConfig( const QCString& receiver)
+{
+  if ( receiver != "korganizer" ) return;
+  kdDebug(5850) << "CalendarView::updateConfig()" << endl;
+
+  KOGlobals::self()->
+    setHolidays( new KHolidays( KOPrefs::instance()->mHolidays ) );
+
+  QString tz(  mCalendar->timeZoneId() );
+  // Only set a new time zone if it changed. This prevents the window
+  // from being modified on start
+  if ( tz != KOPrefs::instance()->mTimeZoneId ) {
+
+    const QString question( i18n("The timezone setting was changed. Do you want to keep the absolute time of "
+                                "the items in your calendar, which will show them to be at a different time than "
+                                "before, or move them to be at the old time also in the new timezone?") );
+    int rc = KMessageBox::questionYesNo( this, question,
+                              i18n("Keep Absolute Times?"),
+                              KGuiItem(i18n("Keep Times")),
+                              KGuiItem(i18n("Move Times")),
+                              "calendarKeepAbsoluteTimes");
+    if ( rc == KMessageBox::Yes ) {
+      // user wants us to shift
+      mCalendar->setTimeZoneIdViewOnly( KOPrefs::instance()->mTimeZoneId );
+    } else {
+      // only set the new timezone, wihtout shifting events, they will be
+      // interpreted as being in the new timezone now
+      mCalendar->setTimeZoneId( KOPrefs::instance()->mTimeZoneId );
+    }
+  }
+  emit configChanged();
+
+  // force reload and handle agenda view type switch
+  const bool showMerged = KOPrefs::instance()->agendaViewCalendarDisplay() == KOPrefs::CalendarsMerged;
+  const bool showSideBySide = KOPrefs::instance()->agendaViewCalendarDisplay() == KOPrefs::CalendarsSideBySide;
+  KOrg::BaseView *view = mViewManager->currentView();
+  mViewManager->showAgendaView();
+  if ( view == mViewManager->agendaView() && showSideBySide )
+    view = mViewManager->multiAgendaView();
+  else if ( view == mViewManager->multiAgendaView() && showMerged )
+    view = mViewManager->agendaView();
+  mViewManager->showView( view );
+
+  // To make the "fill window" configurations work
+  mViewManager->raiseCurrentView();
+}
+
+
+void CalendarView::incidenceAdded( Incidence *incidence )
+{
+  setModified( true );
+  history()->recordAdd( incidence );
+  changeIncidenceDisplay( incidence, KOGlobals::INCIDENCEADDED );
+  updateUnmanagedViews();
+  checkForFilteredChange( incidence );
+}
+
+void CalendarView::incidenceChanged( Incidence *oldIncidence,
+                                     Incidence *newIncidence )
+{
+  incidenceChanged( oldIncidence, newIncidence, KOGlobals::UNKNOWN_MODIFIED );
+}
+
+void CalendarView::incidenceChanged( Incidence *oldIncidence,
+                                     Incidence *newIncidence, int what )
+{
+  // FIXME: Make use of the what flag, which indicates which parts of the incidence have changed!
+  KOIncidenceEditor *tmp = editorDialog( newIncidence );
+  if ( tmp ) {
+    kdDebug(5850) << "Incidence modified and open" << endl;
+    tmp->modified( what );
+  }
+  setModified( true );
+  history()->recordEdit( oldIncidence, newIncidence );
+
+  // Record completed todos in journals, if enabled. we should to this here in
+  // favour of the todolist. users can mark a task as completed in an editor
+  // as well.
+  if ( newIncidence->type() == "Todo"
+    && KOPrefs::instance()->recordTodosInJournals()
+    &&  ( what == KOGlobals::COMPLETION_MODIFIED
+    || what == KOGlobals::COMPLETION_MODIFIED_WITH_RECURRENCE ) ) {
+
+      Todo *todo = static_cast<Todo *>(newIncidence);
+      if ( todo->isCompleted()
+      || what == KOGlobals::COMPLETION_MODIFIED_WITH_RECURRENCE ) {
+        QString timeStr = KGlobal::locale()->formatTime( QTime::currentTime() );
+        QString description = i18n( "To-do completed: %1 (%2)" ).arg(
+          newIncidence->summary() ).arg( timeStr );
+
+        Journal::List journals = calendar()->journals( QDate::currentDate() );
+        Journal *journal;
+
+        if ( journals.isEmpty() ) {
+          journal = new Journal();
+          journal->setDtStart( QDateTime::currentDateTime() );
+
+          QString dateStr = KGlobal::locale()->formatDate( QDate::currentDate() );
+          journal->setSummary( i18n("Journal of %1").arg( dateStr ) );
+          journal->setDescription( description );
+
+          if ( !mChanger->addIncidence( journal, this ) ) {
+            KODialogManager::errorSaveIncidence( this, journal );
+            delete journal;
+            return;
+          }
+
+        } else { // journal list is not empty
+          journal = *(journals.at(0));
+          Journal *oldJournal = journal->clone();
+          journal->setDescription( journal->description().append( "\n" + description ) );
+
+          if ( !mChanger->changeIncidence( oldJournal, journal ) ) {
+            KODialogManager::errorSaveIncidence( this, journal );
+            delete journal;
+            return;
+          }
+        }
+      }
+  }
+
+  changeIncidenceDisplay( newIncidence, KOGlobals::INCIDENCEEDITED );
+  updateUnmanagedViews();
+  checkForFilteredChange( newIncidence );
+}
+
+void CalendarView::incidenceToBeDeleted( Incidence *incidence )
+{
+  KOIncidenceEditor *tmp = editorDialog( incidence );
+  if (tmp) {
+    kdDebug(5850) << "Incidence to be deleted and open in editor" << endl;
+    tmp->delayedDestruct();
+  }
+  setModified( true );
+  history()->recordDelete( incidence );
+//  changeIncidenceDisplay( incidence, KOGlobals::INCIDENCEDELETED );
+  updateUnmanagedViews();
+}
+
+void CalendarView::incidenceDeleted( Incidence *incidence )
+{
+  changeIncidenceDisplay( incidence, KOGlobals::INCIDENCEDELETED );
+  updateUnmanagedViews();
+}
+
+void CalendarView::checkForFilteredChange( Incidence *incidence )
+{
+  CalFilter *filter = calendar()->filter();
+  if ( filter && !filter->filterIncidence( incidence ) ) {
+    // Incidence is filtered and thus not shown in the view, tell the
+    // user so that he isn't surprised if his new event doesn't show up
+    KMessageBox::information( this, i18n("The item \"%1\" is filtered by "
+                 "your current filter rules, so it will be hidden and not "
+                 "appear in the view.").arg( incidence->summary() ),
+                 i18n("Filter Applied"), "ChangedIncidenceFiltered" );
+  }
+}
+
+void CalendarView::startMultiModify( const QString &text )
+{
+  history()->startMultiModify( text );
+}
+
+void CalendarView::endMultiModify()
+{
+  history()->endMultiModify();
+}
+
+
+void CalendarView::changeIncidenceDisplay( Incidence *incidence, int action )
+{
+  mDateNavigator->updateView();
+  mDialogManager->updateSearchDialog();
+
+  if ( incidence ) {
+    // If there is an event view visible update the display
+    mViewManager->currentView()->changeIncidenceDisplay( incidence, action );
+    if ( mTodoList ) mTodoList->changeIncidenceDisplay( incidence, action );
+    mEventViewer->changeIncidenceDisplay( incidence, action );
+  } else {
+    mViewManager->currentView()->updateView();
+    if ( mTodoList ) mTodoList->updateView();
+  }
+}
+
+
+void CalendarView::updateView(const QDate &start, const QDate &end)
+{
+  mTodoList->updateView();
+  mViewManager->updateView(start, end);
+  mDateNavigator->updateView();
+}
+
+void CalendarView::updateView()
+{
+  DateList tmpList = mNavigator->selectedDates();
+
+  // We assume that the navigator only selects consecutive days.
+  updateView( tmpList.first(), tmpList.last() );
+}
+
+void CalendarView::updateUnmanagedViews()
+{
+  mDateNavigator->updateDayMatrix();
+}
+
+int CalendarView::msgItemDelete( Incidence *incidence )
+{
+  return KMessageBox::warningContinueCancel(this,
+      i18n("The item \"%1\" will be permanently deleted.").arg( incidence->summary() ),
+      i18n("KOrganizer Confirmation"), KGuiItem(i18n("&Delete"),"editdelete"));
+}
+
+
+void CalendarView::edit_cut()
+{
+  Incidence *incidence = selectedIncidence();
+
+  if ( !incidence || !mChanger ) {
+    KNotifyClient::beep();
+    return;
+  }
+  mChanger->cutIncidence( incidence );
+}
+
+void CalendarView::edit_copy()
+{
+  Incidence *incidence = selectedIncidence();
+
+  if (!incidence) {
+    KNotifyClient::beep();
+    return;
+  }
+  DndFactory factory( mCalendar );
+  if ( !factory.copyIncidence( incidence ) ) {
+    KNotifyClient::beep();
+  }
+}
+
+void CalendarView::edit_paste()
+{
+// If in agenda view, use the selected time and date from there.
+// In all other cases, paste the event on the first day of the
+// selection in the day matrix on the left
+
+  QDate date;
+  // create an invalid time to check if we got a new time for the eevent
+  QTime time(-1,-1);
+  QDateTime startDT, endDT;
+  bool useEndTime = false;
+
+  KOAgendaView *aView = mViewManager->agendaView();
+  if (aView && aView->selectionStart().isValid()) {
+      date = aView->selectionStart().date();
+    startDT = aView->selectionStart();
+    endDT = aView->selectionEnd();
+    useEndTime = !aView->selectedIsSingleCell();
+    if (!aView->selectedIsAllDay()) {
+        time = aView->selectionStart().time();
+    }
+
+  } else {
+    date = mNavigator->selectedDates().first();
+  }
+
+  DndFactory factory( mCalendar );
+  Incidence *pastedIncidence;
+  if (time.isValid())
+    pastedIncidence = factory.pasteIncidence( date, &time );
+  else
+    pastedIncidence = factory.pasteIncidence( date );
+  if ( !pastedIncidence ) return;
+
+  // FIXME: use a visitor here
+  if (pastedIncidence->type() == "Event" ) {
+
+    Event* pastedEvent = static_cast<Event*>(pastedIncidence);
+    // only use selected area if event is of the same type (all-day or non-all-day
+    // as the current selection is
+    if ( aView && endDT.isValid() && useEndTime ) {
+      if ( (pastedEvent->doesFloat() && aView->selectedIsAllDay()) ||
+           (!pastedEvent->doesFloat() && ! aView->selectedIsAllDay()) ) {
+        pastedEvent->setDtEnd(endDT);
+      }
+    }
+    mChanger->addIncidence( pastedEvent, this );
+
+  } else if ( pastedIncidence->type() == "Todo" ) {
+    Todo* pastedTodo = static_cast<Todo*>(pastedIncidence);
+    Todo* _selectedTodo = selectedTodo();
+    if ( _selectedTodo )
+      pastedTodo->setRelatedTo( _selectedTodo );
+    mChanger->addIncidence( pastedTodo, this );
+  }
+}
+
+void CalendarView::edit_options()
+{
+  mDialogManager->showOptionsDialog();
+}
+
+void CalendarView::dateTimesForNewEvent( QDateTime &startDt, QDateTime &endDt, bool &allDay )
+{
+  if ( !startDt.isValid() ) {
+    // Default start is the first selected date with the preferred time as set
+    // in the config dlg.
+    if ( !startDt.date().isValid() ) {
+      startDt.setDate( mNavigator->selectedDates().first() );
+    }
+    if ( !startDt.time().isValid() ) {
+      startDt.setTime( KOPrefs::instance()->mStartTime.time() );
+    }
+  }
+  if ( !endDt.isValid() ) {
+    int addSecs = ( KOPrefs::instance()->mDefaultDuration.time().hour()*3600 ) +
+                  ( KOPrefs::instance()->mDefaultDuration.time().minute()*60 );
+    endDt = startDt.addSecs( addSecs );
+  }
+  mViewManager->currentView()->eventDurationHint( startDt, endDt, allDay );
+}
+
+KOEventEditor *CalendarView::newEventEditor( const QDateTime &startDtParam,
+     const QDateTime &endDtParam, bool allDayParam)
+{
+  // let the current view change the default start/end datetime
+  bool allDay = allDayParam;
+  QDateTime startDt( startDtParam ), endDt( endDtParam );
+  // Adjust the start/end date times (i.e. replace invalid values by defaults,
+  // and let the view adjust the type.
+  dateTimesForNewEvent( startDt, endDt, allDay );
+
+  KOEventEditor *eventEditor = mDialogManager->getEventEditor();
+  eventEditor->newEvent();
+  connectIncidenceEditor( eventEditor );
+  eventEditor->setDates( startDt, endDt, allDay );
+  mDialogManager->connectTypeAhead( eventEditor, dynamic_cast<KOrg::AgendaView*>(viewManager()->currentView()) );
+  return eventEditor;
+}
+
+
+
+
+void CalendarView::newEvent()
+{
+  kdDebug(5850) << "CalendarView::newEvent()" << endl;
+  newEvent( QDateTime(), QDateTime() );
+}
+
+void CalendarView::newEvent( const QDate &dt )
+{
+  QDateTime startDt( dt, KOPrefs::instance()->mStartTime.time() );
+  return newEvent( QDateTime( dt ), QDateTime() );
+}
+
+void CalendarView::newEvent( const QDateTime &startDt )
+{
+  return newEvent( startDt, QDateTime() );
+}
+
+void CalendarView::newEvent( const QDateTime &startDt, const QDateTime &endDt,
+                             bool allDay )
+{
+  KOEventEditor *eventEditor = newEventEditor( startDt, endDt, allDay );
+  eventEditor->show();
+}
+
+void CalendarView::newEvent( const QString &summary, const QString &description,
+                             const QStringList &attachments, const QStringList &attendees,
+                             const QStringList &attachmentMimetypes, bool inlineAttachment )
+{
+  KOEventEditor *eventEditor = newEventEditor();
+  eventEditor->setTexts( summary, description );
+  // if attach or attendee list is empty, these methods don't do anything, so
+  // it's save to call them in every case
+  eventEditor->addAttachments( attachments, attachmentMimetypes, inlineAttachment );
+  eventEditor->addAttendees( attendees );
+  eventEditor->show();
+}
+
+void CalendarView::newTodo( const QString &summary, const QString &description,
+                            const QStringList &attachments, const QStringList &attendees,
+                            const QStringList &attachmentMimetypes, bool inlineAttachment )
+{
+  kdDebug(5850) << k_funcinfo << endl;
+  KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
+  connectIncidenceEditor( todoEditor );
+  todoEditor->newTodo();
+  todoEditor->setTexts( summary, description );
+  todoEditor->addAttachments( attachments, attachmentMimetypes, inlineAttachment );
+  todoEditor->addAttendees( attendees );
+  todoEditor->show();
+}
+
+void CalendarView::newTodo()
+{
+  kdDebug(5850) << k_funcinfo << endl;
+  QDateTime dtDue;
+  bool allday = true;
+  KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
+  connectIncidenceEditor( todoEditor );
+  todoEditor->newTodo();
+  if ( mViewManager->currentView()->isEventView() ) {
+    dtDue.setDate( mNavigator->selectedDates().first() );
+    QDateTime dtDummy = QDateTime::currentDateTime();
+    mViewManager->currentView()->
+      eventDurationHint( dtDue, dtDummy, allday );
+    todoEditor->setDates( dtDue, allday );
+  }
+  todoEditor->show();
+}
+
+void CalendarView::newTodo( const QDate &date )
+{
+  KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
+  connectIncidenceEditor( todoEditor );
+  todoEditor->newTodo();
+  todoEditor->setDates( QDateTime( date, QTime::currentTime() ), true );
+  todoEditor->show();
+}
+
+void CalendarView::newJournal()
+{
+  kdDebug(5850) << "CalendarView::newJournal()" << endl;
+  newJournal( QString::null, QDate() );
+}
+
+void CalendarView::newJournal( const QDate &date)
+{
+  newJournal( QString::null, date );
+}
+
+void CalendarView::newJournal( const QString &text, const QDate &date )
+{
+  KOJournalEditor *journalEditor = mDialogManager->getJournalEditor();
+  connectIncidenceEditor( journalEditor );
+  journalEditor->newJournal();
+  journalEditor->setTexts( text );
+  if ( !date.isValid() ) {
+    journalEditor->setDate( mNavigator->selectedDates().first() );
+  } else {
+    journalEditor->setDate( date );
+  }
+  journalEditor->show();
+}
+
+void CalendarView::newSubTodo()
+{
+  Todo *todo = selectedTodo();
+  if ( todo ) newSubTodo( todo );
+}
+
+void CalendarView::newSubTodo(Todo *parentEvent)
+{
+  KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
+  connectIncidenceEditor( todoEditor );
+  todoEditor->newTodo();
+  todoEditor->setDates( QDateTime(), false, parentEvent );
+  todoEditor->show();
+}
+
+void CalendarView::newFloatingEvent()
+{
+  DateList tmpList = mNavigator->selectedDates();
+  QDate date = tmpList.first();
+
+  newEvent( QDateTime( date, QTime( 12, 0, 0 ) ),
+            QDateTime( date, QTime( 12, 0, 0 ) ), true );
+}
+
+bool CalendarView::addIncidence( const QString &ical )
+{
+  kdDebug(5850) << "CalendarView::addIncidence:\n" << ical << endl;
+  ICalFormat format;
+  format.setTimeZone( mCalendar->timeZoneId(), true );
+  Incidence *incidence = format.fromString( ical );
+  if ( !incidence ) return false;
+  if ( !mChanger->addIncidence( incidence, this ) ) {
+    delete incidence;
+    return false;
+  }
+  return true;
+}
+
+void CalendarView::appointment_show()
+{
+  Incidence *incidence = selectedIncidence();
+  if (incidence)
+    showIncidence( incidence );
+  else
+    KNotifyClient::beep();
+}
+
+void CalendarView::appointment_edit()
+{
+  Incidence *incidence = selectedIncidence();
+  if (incidence)
+    editIncidence( incidence );
+  else
+    KNotifyClient::beep();
+}
+
+void CalendarView::appointment_delete()
+{
+  Incidence *incidence = selectedIncidence();
+  if (incidence)
+    deleteIncidence( incidence );
+  else
+    KNotifyClient::beep();
+}
+
+void CalendarView::todo_unsub()
+{
+  Todo *anTodo = selectedTodo();
+  if( todo_unsub (anTodo ) ) {
+    updateView();
+  }
+}
+
+bool CalendarView::todo_unsub( Todo *todo )
+{
+  bool status= false;
+  if ( !todo || !todo->relatedTo() ) return false;
+
+  if ( mChanger->beginChange( todo ) ) {
+      Todo *oldTodo = todo->clone();
+      todo->setRelatedTo(0);
+      mChanger->changeIncidence( oldTodo, todo, KOGlobals::RELATION_MODIFIED );
+      mChanger->endChange( todo );
+      delete oldTodo;
+      setModified(true);
+      status = true;
+  }
+  if ( ! status ) {
+    KMessageBox::sorry( this, i18n("Unable to turn sub-to-do into a top-level "
+        "to-do, because it cannot be locked.") );
+  }
+
+  return status;
+}
+
+bool CalendarView::makeSubTodosIndependents ( )
+{
+  bool  status = false;
+  Todo *anTodo = selectedTodo();
+
+  if( makeSubTodosIndependents( anTodo ) ) {
+    updateView();
+    status = true;
+  }
+  return status;
+}
+
+bool CalendarView::makeSubTodosIndependents ( Todo *todo )
+{
+  if( !todo || todo->relations().isEmpty() ) return false;
+
+  startMultiModify ( i18n( "Make sub-to-dos independent" ) );
+  Incidence::List subTodos( todo->relations() );
+  Incidence::List::Iterator it;
+  Incidence *aIncidence;
+  Todo *aTodo;
+
+  for ( it= subTodos.begin(); it != subTodos.end(); ++it ) {
+    aIncidence = *it;
+    if( aIncidence && aIncidence->type() == "Todo" ) {
+      aTodo = static_cast<Todo*>( aIncidence );
+      todo_unsub ( aTodo );
+    }
+  }
+  endMultiModify();
+  return true;
+}
+
+bool CalendarView::deleteIncidence( const QString &uid, bool force )
+{
+  Incidence *inc = mCalendar->incidence( uid );
+  if ( inc ) {
+    deleteIncidence( inc, force );
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void CalendarView::toggleAlarm( Incidence *incidence )
+{
+  if ( !incidence || !mChanger ) {
+    kdDebug(5850) << "CalendarView::toggleAlarm() called without having a clicked item" << endl;
+    return;
+  }
+  Incidence*oldincidence = incidence->clone();
+  if ( !mChanger->beginChange( incidence ) ) {
+    kdDebug(5850) << "Unable to lock incidence " << endl;
+    delete oldincidence;
+    return;
+  }
+
+  Alarm::List alarms = incidence->alarms();
+  Alarm::List::ConstIterator it;
+  for( it = alarms.begin(); it != alarms.end(); ++it )
+    (*it)->toggleAlarm();
+  if (alarms.isEmpty()) {
+    // Add an alarm if it didn't have one
+    Alarm*alm = incidence->newAlarm();
+    alm->setEnabled(true);
+  }
+  mChanger->changeIncidence( oldincidence, incidence, KOGlobals::ALARM_MODIFIED );
+  mChanger->endChange( incidence );
+  delete oldincidence;
+
+//  mClickedItem->updateIcons();
+}
+
+void CalendarView::dissociateOccurrence( Incidence *incidence, const QDate &date )
+{
+  if ( !incidence || !mChanger ) {
+    kdDebug(5850) << "CalendarView::toggleAlarm() called without having a clicked item" << endl;
+    return;
+  }
+  if ( !mChanger->beginChange( incidence ) ) {
+    kdDebug(5850) << "Unable to lock incidence " << endl;
+    return;
+  }
+  startMultiModify( i18n("Dissociate occurrence") );
+  Incidence*oldincidence = incidence->clone();
+
+  Incidence* newInc = mCalendar->dissociateOccurrence( incidence, date, true );
+
+  if ( newInc ) {
+    // TODO: Use the same resource instead of asking again!
+    mChanger->changeIncidence( oldincidence, incidence );
+    mChanger->addIncidence( newInc, this );
+  } else {
+    KMessageBox::sorry( this, i18n("Dissociating the occurrence failed."),
+      i18n("Dissociating Failed") );
+  }
+  mChanger->endChange( incidence );
+  endMultiModify();
+  delete oldincidence;
+}
+
+void CalendarView::dissociateFutureOccurrence( Incidence *incidence, const QDate &date )
+{
+  if ( !incidence || !mChanger ) {
+    kdDebug(5850) << "CalendarView::toggleAlarm() called without having a clicked item" << endl;
+    return;
+  }
+  if ( !mChanger->beginChange( incidence ) ) {
+    kdDebug(5850) << "Unable to lock incidence " << endl;
+    return;
+  }
+  startMultiModify( i18n("Dissociate future occurrences") );
+  Incidence*oldincidence = incidence->clone();
+
+  Incidence* newInc = mCalendar->dissociateOccurrence( incidence, date, true );
+  if ( newInc ) {
+    // TODO: Use the same resource instead of asking again!
+    mChanger->changeIncidence( oldincidence, incidence );
+    mChanger->addIncidence( newInc, this );
+  } else {
+    KMessageBox::sorry( this, i18n("Dissociating the future occurrences failed."),
+      i18n("Dissociating Failed") );
+  }
+  endMultiModify();
+  mChanger->endChange( incidence );
+  delete oldincidence;
+}
+
+
+/*****************************************************************************/
+
+
+void CalendarView::schedule_publish(Incidence *incidence)
+{
+  if (incidence == 0)
+    incidence = selectedIncidence();
+
+  if (!incidence) {
+    KMessageBox::information( this, i18n("No item selected."),
+                              "PublishNoEventSelected" );
+    return;
+  }
+
+  PublishDialog *publishdlg = new PublishDialog();
+  if (incidence->attendeeCount()>0) {
+    Attendee::List attendees = incidence->attendees();
+    Attendee::List::ConstIterator it;
+    for( it = attendees.begin(); it != attendees.end(); ++it ) {
+      publishdlg->addAttendee( *it );
+    }
+  }
+  if ( publishdlg->exec() == QDialog::Accepted ) {
+    Incidence *inc = incidence->clone();
+    inc->registerObserver( 0 );
+    inc->clearAttendees();
+
+    // Send the mail
+    KCal::MailScheduler scheduler( mCalendar );
+    if ( scheduler.publish( incidence, publishdlg->addresses() ) ) {
+      KMessageBox::information( this, i18n("The item information was successfully sent."),
+                                i18n("Publishing"), "IncidencePublishSuccess" );
+    } else {
+      KMessageBox::error( this, i18n("Unable to publish the item '%1'").arg( incidence->summary() ) );
+    }
+  }
+  delete publishdlg;
+}
+
+void CalendarView::schedule_request(Incidence *incidence)
+{
+  schedule(Scheduler::Request,incidence);
+}
+
+void CalendarView::schedule_refresh(Incidence *incidence)
+{
+  schedule(Scheduler::Refresh,incidence);
+}
+
+void CalendarView::schedule_cancel(Incidence *incidence)
+{
+  schedule(Scheduler::Cancel,incidence);
+}
+
+void CalendarView::schedule_add(Incidence *incidence)
+{
+  schedule(Scheduler::Add,incidence);
+}
+
+void CalendarView::schedule_reply(Incidence *incidence)
+{
+  schedule(Scheduler::Reply,incidence);
+}
+
+void CalendarView::schedule_counter(Incidence *incidence)
+{
+  schedule(Scheduler::Counter,incidence);
+}
+
+void CalendarView::schedule_declinecounter(Incidence *incidence)
+{
+  schedule(Scheduler::Declinecounter,incidence);
+}
+
+void CalendarView::schedule_forward(Incidence * incidence)
+{
+  if (incidence == 0)
+    incidence = selectedIncidence();
+
+  if (!incidence) {
+    KMessageBox::information( this, i18n("No item selected."),
+                              "ForwardNoEventSelected" );
+    return;
+  }
+
+  PublishDialog publishdlg;
+  if ( publishdlg.exec() == QDialog::Accepted ) {
+    QString recipients = publishdlg.addresses();
+    ICalFormat format;
+    QString messageText = format.createScheduleMessage( incidence, Scheduler::Request );
+    KOMailClient mailer;
+    if ( mailer.mailTo( incidence, recipients, messageText ) ) {
+
+      KMessageBox::information( this, i18n("The item information was successfully sent."),
+                                i18n("Forwarding"), "IncidenceForwardSuccess" );
+    } else {
+      KMessageBox::error( this, i18n("Unable to forward the item '%1'").arg( incidence->summary() ) );
+    }
+  }
+}
+
+void CalendarView::mailFreeBusy( int daysToPublish )
+{
+  QDateTime start = QDateTime::currentDateTime();
+  QDateTime end = start.addDays(daysToPublish);
+
+  FreeBusy *freebusy = new FreeBusy(mCalendar, start, end);
+  freebusy->setOrganizer( Person( KOPrefs::instance()->fullName(),
+                      KOPrefs::instance()->email() ) );
+
+  kdDebug(5850) << "calendarview: schedule_publish_freebusy: startDate: "
+     << KGlobal::locale()->formatDateTime( start ) << " End Date: "
+     << KGlobal::locale()->formatDateTime( end ) << endl;
+
+  PublishDialog *publishdlg = new PublishDialog();
+  if ( publishdlg->exec() == QDialog::Accepted ) {
+    // Send the mail
+    KCal::MailScheduler scheduler( mCalendar );
+    if ( scheduler.publish( freebusy, publishdlg->addresses() ) ) {
+      KMessageBox::information( this, i18n("The free/busy information was successfully sent."),
+                                i18n("Sending Free/Busy"), "FreeBusyPublishSuccess" );
+    } else {
+      KMessageBox::error( this, i18n("Unable to publish the free/busy data.") );
+    }
+  }
+  delete freebusy;
+  delete publishdlg;
+}
+
+void CalendarView::uploadFreeBusy()
+{
+  KOGroupware::instance()->freeBusyManager()->publishFreeBusy();
+}
+
+void CalendarView::schedule(Scheduler::Method method, Incidence *incidence)
+{
+  if ( !incidence ) {
+    incidence = selectedIncidence();
+  }
+
+  if ( !incidence ) {
+    KMessageBox::sorry( this, i18n("No item selected."),
+                        "ScheduleNoEventSelected" );
+    return;
+  }
+
+  if( incidence->attendeeCount() == 0 && method != Scheduler::Publish ) {
+    KMessageBox::information( this, i18n("The item has no attendees."),
+                              "ScheduleNoIncidences" );
+    return;
+  }
+
+  Incidence *inc = incidence->clone();
+  inc->registerObserver( 0 );
+  inc->clearAttendees();
+
+  // Send the mail
+  KCal::MailScheduler scheduler( mCalendar );
+  if ( !scheduler.performTransaction( incidence, method ) ) {
+    KMessageBox::information( this, i18n("The groupware message for item '%1'"
+                                "was successfully sent.\nMethod: %2")
+                                .arg( incidence->summary() )
+                                .arg( Scheduler::methodName( method ) ),
+                              i18n("Sending Free/Busy"),
+                              "FreeBusyPublishSuccess" );
+  } else {
+    KMessageBox::error( this, i18n("Groupware message sending failed. "
+                        "%2 is request/reply/add/cancel/counter/etc.",
+                        "Unable to send the item '%1'.\nMethod: %2")
+                        .arg( incidence->summary() )
+                        .arg( Scheduler::methodName( method ) ) );
+  }
+}
+
+void CalendarView::openAddressbook()
+{
+  KRun::runCommand("kaddressbook");
+}
+
+void CalendarView::setModified(bool modified)
+{
+  if (mModified != modified) {
+    mModified = modified;
+    emit modifiedChanged(mModified);
+  }
+}
+
+bool CalendarView::isReadOnly()
+{
+  return mReadOnly;
+}
+
+void CalendarView::setReadOnly(bool readOnly)
+{
+  if (mReadOnly != readOnly) {
+    mReadOnly = readOnly;
+    emit readOnlyChanged(mReadOnly);
+  }
+}
+
+bool CalendarView::isModified()
+{
+  return mModified;
+}
+
+void CalendarView::print()
+{
+#ifndef KORG_NOPRINTER
+  KOCoreHelper helper;
+  CalPrinter printer( this, mCalendar, &helper );
+  connect( this, SIGNAL(configChanged()), &printer, SLOT(updateConfig()) );
+
+  KOrg::BaseView *currentView = mViewManager->currentView();
+
+  CalPrinterBase::PrintType printType = CalPrinterBase::Month;
+  if ( currentView ) printType = currentView->printType();
+
+  DateList tmpDateList = mNavigator->selectedDates();
+  Incidence::List selectedIncidences;
+  if ( mViewManager->currentView() ) {
+    selectedIncidences = mViewManager->currentView()->selectedIncidences();
+  }
+  printer.print( printType, tmpDateList.first(), tmpDateList.last(), selectedIncidences );
+#endif
+}
+
+void CalendarView::exportWeb()
+{
+  // FIXME: Get rid of the settings object. When can I delete it???
+  HTMLExportSettings *settings = new HTMLExportSettings( "KOrganizer" );
+  // Manually read in the config, because parametrized kconfigxt objects don't
+  // seem to load the config theirselves
+  if ( settings ) settings->readConfig();
+  ExportWebDialog *dlg = new ExportWebDialog( settings, this );
+  connect( dlg,  SIGNAL( exportHTML( HTMLExportSettings* ) ),
+           this, SIGNAL( exportHTML( HTMLExportSettings* ) ) );
+  dlg->show();
+}
+
+void CalendarView::exportICalendar()
+{
+  QString filename = KFileDialog::getSaveFileName("icalout.ics",i18n("*.ics|ICalendars"),this);
+
+  // Force correct extension
+  if (filename.right(4) != ".ics") filename += ".ics";
+
+  FileStorage storage( mCalendar, filename, new ICalFormat );
+  storage.save();
+}
+
+void CalendarView::exportVCalendar()
+{
+  if (mCalendar->journals().count() > 0) {
+    int result = KMessageBox::warningContinueCancel(this,
+        i18n("The journal entries can not be exported to a vCalendar file."),
+        i18n("Data Loss Warning"),i18n("Proceed"),"dontaskVCalExport",
+        true);
+    if (result != KMessageBox::Continue) return;
+  }
+
+  QString filename = KFileDialog::getSaveFileName("vcalout.vcs",i18n("*.vcs|vCalendars"),this);
+
+	// TODO: I don't like forcing extensions:
+  // Force correct extension
+  if (filename.right(4) != ".vcs") filename += ".vcs";
+
+  FileStorage storage( mCalendar, filename, new VCalFormat );
+  storage.save();
+}
+
+void CalendarView::eventUpdated(Incidence *)
+{
+  setModified();
+  // Don't call updateView here. The code, which has caused the update of the
+  // event is responsible for updating the view.
+//  updateView();
+}
+
+void CalendarView::adaptNavigationUnits()
+{
+  if (mViewManager->currentView()->isEventView()) {
+    int days = mViewManager->currentView()->currentDateCount();
+    if (days == 1) {
+      emit changeNavStringPrev(i18n("&Previous Day"));
+      emit changeNavStringNext(i18n("&Next Day"));
+    } else {
+      emit changeNavStringPrev(i18n("&Previous Week"));
+      emit changeNavStringNext(i18n("&Next Week"));
+    }
+  }
+}
+
+void CalendarView::processMainViewSelection( Incidence *incidence )
+{
+  if ( incidence ) mTodoList->clearSelection();
+  processIncidenceSelection( incidence );
+}
+
+void CalendarView::processTodoListSelection( Incidence *incidence )
+{
+  if ( incidence && mViewManager->currentView() ) {
+    mViewManager->currentView()->clearSelection();
+  }
+  processIncidenceSelection( incidence );
+}
+
+void CalendarView::processIncidenceSelection( Incidence *incidence )
+{
+  if ( incidence == mSelectedIncidence ) return;
+
+  mSelectedIncidence = incidence;
+
+  emit incidenceSelected( mSelectedIncidence );
+  bool organizerEvents = false;
+  bool groupEvents = false;
+  bool todo = false;
+  bool subtodo = false;
+
+  if ( incidence ) {
+    organizerEvents = KOPrefs::instance()->thatIsMe( incidence->organizer().email() );
+    groupEvents = incidence->attendeeByMails( KOPrefs::instance()->allEmails() );
+
+    if ( incidence && incidence->type() == "Todo" ) {
+      todo = true;
+      subtodo = ( incidence->relatedTo() != 0 );
+    }
+  }
+  emit todoSelected( todo );
+  emit subtodoSelected( subtodo );
+  emit organizerEventsSelected( organizerEvents );
+  emit groupEventsSelected( groupEvents );
+}
+
+
+void CalendarView::checkClipboard()
+{
+#ifndef KORG_NODND
+  if (ICalDrag::canDecode(QApplication::clipboard()->data())) {
+    kdDebug(5850) << "CalendarView::checkClipboard() true" << endl;
+    emit pasteEnabled(true);
+  } else {
+    kdDebug(5850) << "CalendarView::checkClipboard() false" << endl;
+    emit pasteEnabled(false);
+  }
+#endif
+}
+
+void CalendarView::showDates(const DateList &selectedDates)
+{
+//  kdDebug(5850) << "CalendarView::selectDates()" << endl;
+
+  if ( mViewManager->currentView() ) {
+    updateView( selectedDates.first(), selectedDates.last() );
+  } else {
+    mViewManager->showAgendaView();
+  }
+}
+
+void CalendarView::editFilters()
+{
+  kdDebug(5850) << "CalendarView::editFilters()" << endl;
+
+  CalFilter *filter = mFilters.first();
+  while(filter) {
+    kdDebug(5850) << " Filter: " << filter->name() << endl;
+    filter = mFilters.next();
+  }
+
+  mDialogManager->showFilterEditDialog(&mFilters);
+}
+
+/** Filter configuration changed
+*/
+void CalendarView::updateFilter()
+{
+  QStringList filters;
+  CalFilter *filter;
+
+  int pos = mFilters.find( mCurrentFilter );
+  if ( pos < 0 ) {
+    mCurrentFilter = 0;
+  }
+
+  filters << i18n("No filter");
+  for ( filter = mFilters.first(); filter; filter = mFilters.next() ) {
+    filters << filter->name();
+  }
+
+  emit newFilterListSignal( filters );
+  // account for the additional "No filter" at the beginning! if the
+  // filter is not in the list, pos == -1...
+  emit selectFilterSignal( pos+1 );
+  mCalendar->setFilter( mCurrentFilter );
+  updateView();
+}
+
+/** A different filter was selected
+*/
+void CalendarView::filterActivated( int filterNo )
+{
+  CalFilter *newFilter = 0;
+  if ( filterNo > 0 && filterNo <= int(mFilters.count()) ) {
+    newFilter = mFilters.at( filterNo-1 );
+  }
+  if ( newFilter != mCurrentFilter ) {
+    mCurrentFilter = newFilter;
+    mCalendar->setFilter( mCurrentFilter );
+    updateView();
+  }
+  emit filterChanged();
+}
+
+QString CalendarView::currentFilterName() const
+{
+  if ( mCurrentFilter) {
+    return mCurrentFilter->name();
+  } else return i18n("No filter");
+}
+
+void CalendarView::takeOverEvent()
+{
+  Incidence *incidence = currentSelection();
+
+  if (!incidence) return;
+
+  incidence->setOrganizer( Person( KOPrefs::instance()->fullName(),
+                           KOPrefs::instance()->email() ) );
+  incidence->recreate();
+  incidence->setReadOnly(false);
+
+  updateView();
+}
+
+void CalendarView::takeOverCalendar()
+{
+  Incidence::List incidences = mCalendar->rawIncidences();
+  Incidence::List::Iterator it;
+
+  for ( it = incidences.begin(); it != incidences.end(); ++it ) {
+    (*it)->setOrganizer( Person( KOPrefs::instance()->fullName(),
+                         KOPrefs::instance()->email() ) );
+    (*it)->recreate();
+    (*it)->setReadOnly(false);
+  }
+  updateView();
+}
+
+void CalendarView::showIntro()
+{
+  kdDebug(5850) << "To be implemented." << endl;
+}
+
+void CalendarView::showDateNavigator( bool show )
+{
+  if( show )
+    mDateNavigator->show();
+  else
+    mDateNavigator->hide();
+}
+
+void CalendarView::showTodoView( bool show )
+{
+  if( show )
+    mTodoList->show();
+  else
+    mTodoList->hide();
+}
+
+void CalendarView::showEventViewer( bool show )
+{
+  if( show )
+    mEventViewer->show();
+  else
+    mEventViewer->hide();
+}
+
+
+void CalendarView::addView(KOrg::BaseView *view)
+{
+  mViewManager->addView(view);
+}
+
+void CalendarView::showView(KOrg::BaseView *view)
+{
+  mViewManager->showView(view);
+}
+
+void CalendarView::addExtension( CalendarViewExtension::Factory *factory )
+{
+  CalendarViewExtension *extension = factory->create( mLeftSplitter );
+
+  mExtensions.append( extension );
+}
+
+void CalendarView::toggleExpand()
+{
+  showLeftFrame( mLeftFrame->isHidden() );
+}
+
+void CalendarView::showLeftFrame(bool show)
+{
+  if (show) {
+    mLeftFrame->show();
+    emit calendarViewExpanded( false );
+  } else {
+    mLeftFrame->hide();
+    emit calendarViewExpanded( true );
+  }
+}
+
+void CalendarView::calendarModified( bool modified, Calendar * )
+{
+  setModified( modified );
+}
+
+Todo *CalendarView::selectedTodo()
+{
+  Incidence *incidence = currentSelection();
+  if ( incidence && incidence->type() == "Todo" ) {
+    return static_cast<Todo *>( incidence );
+  }
+  incidence = 0;
+
+  Incidence::List selectedIncidences = mTodoList->selectedIncidences();
+  if ( !selectedIncidences.isEmpty() ) incidence = selectedIncidences.first();
+  if ( incidence && incidence->type() == "Todo" ) {
+    return static_cast<Todo *>( incidence );
+  }
+
+  return 0;
+}
+
+void CalendarView::dialogClosing( Incidence *in )
+{
+  // FIXME: this doesn't work, because if it's a new incidence, it's not locked!
+  mChanger->endChange( in );
+  mDialogList.remove( in );
+}
+
+Incidence *CalendarView::currentSelection()
+{
+  return mViewManager->currentSelection();
+}
+
+Incidence* CalendarView::selectedIncidence()
+{
+  Incidence *incidence = currentSelection();
+  if ( !incidence ) {
+    Incidence::List selectedIncidences = mTodoList->selectedIncidences();
+    if ( !selectedIncidences.isEmpty() )
+      incidence = selectedIncidences.first();
+  }
+  return incidence;
+}
+
+void CalendarView::showIncidence()
+{
+  showIncidence( selectedIncidence() );
+}
+
+void CalendarView::editIncidence()
+{
+  editIncidence( selectedIncidence() );
+}
+
+bool CalendarView::editIncidence( const QString& uid )
+{
+  kdDebug(5850) << "CalendarView::editIncidence()" << endl;
+  return editIncidence( mCalendar->incidence( uid ) );
+}
+
+void CalendarView::deleteIncidence()
+{
+  deleteIncidence( selectedIncidence() );
+}
+
+void CalendarView::cutIncidence(Incidence *)
+{
+  edit_cut();
+}
+
+void CalendarView::copyIncidence(Incidence *)
+{
+  edit_copy();
+}
+
+void CalendarView::pasteIncidence()
+{
+  edit_paste();
+}
+
+void CalendarView::showIncidence( Incidence *incidence )
+{
+  KOEventViewerDialog *eventViewer = new KOEventViewerDialog( this );
+  eventViewer->setIncidence( incidence );
+  eventViewer->show();
+}
+
+bool CalendarView::editIncidence( Incidence *incidence, bool isCounter )
+{
+  kdDebug(5850) << "CalendarView::editEvent()" << endl;
+
+  if ( !incidence || !mChanger ) {
+    KNotifyClient::beep();
+    return false;
+  }
+  KOIncidenceEditor *tmp = editorDialog( incidence );
+  if ( tmp ) {
+    kdDebug(5850) << "CalendarView::editIncidence() in List" << endl;
+    tmp->reload();
+    tmp->raise();
+    tmp->show();
+    return true;
+  }
+
+  if ( incidence->isReadOnly() ) {
+    showIncidence( incidence );
+    return true;
+  }
+
+  if ( !isCounter && !mChanger->beginChange( incidence ) ) {
+    warningChangeFailed( incidence );
+    showIncidence( incidence );
+    return false;
+  }
+
+  kdDebug(5850) << "CalendarView::editIncidence() new IncidenceEditor" << endl;
+  KOIncidenceEditor *incidenceEditor = mDialogManager->getEditor( incidence );
+  connectIncidenceEditor( incidenceEditor );
+
+  mDialogList.insert( incidence, incidenceEditor );
+  incidenceEditor->editIncidence( incidence, mCalendar );
+  incidenceEditor->show();
+  return true;
+}
+
+void CalendarView::deleteSubTodosIncidence ( Todo *todo )
+{
+  if( !todo ) return;
+
+  Incidence::List subTodos( todo->relations() );
+  Incidence::List::Iterator it;
+  Incidence *aIncidence;
+  Todo *aTodo;
+
+  for ( it= subTodos.begin(); it != subTodos.end(); ++it ) {
+    aIncidence = *it;
+    if( aIncidence && aIncidence->type() == "Todo" ) {
+      aTodo = static_cast<Todo*>( aIncidence );
+      deleteSubTodosIncidence ( aTodo );
+    }
+  }
+  mChanger->deleteIncidence ( todo );
+}
+
+void CalendarView::deleteTodoIncidence ( Todo *todo, bool force )
+{
+  if ( !todo ) return ;
+
+  // it a simple todo, ask and delete it.
+  if (todo->relations().isEmpty() ) {
+    bool doDelete = true;
+    if ( !force && KOPrefs::instance()->mConfirm ) {
+      doDelete = ( msgItemDelete( todo ) == KMessageBox::Continue );
+    }
+    if ( doDelete )
+      mChanger->deleteIncidence( todo );
+    return;
+  }
+
+  /* Ok, this to-do has sub-to-dos, ask what to do */
+  int km = KMessageBox::No;
+  if ( !force ) {
+    km=KMessageBox::questionYesNoCancel( this,
+                                i18n("The item \"%1\" has sub-to-dos. "
+                                     "Do you want to delete just this item and "
+                                     "make all its sub-to-dos independent, or "
+                                     "delete the to-do with all its sub-to-dos?"
+                                ).arg( todo->summary() ),
+                                i18n("KOrganizer Confirmation"),
+                                i18n("Delete Only This"),
+                                i18n("Delete All"));
+  }
+  startMultiModify( i18n("Deleting sub-to-dos" ) );
+  // Delete only the father
+  if( km == KMessageBox::Yes ) {
+
+    makeSubTodosIndependents ( todo );
+    mChanger->deleteIncidence( todo );
+  } else if ( km == KMessageBox::No ) {
+    // Delete all
+    // we have to hide the delete confirmation for each itemDate
+    deleteSubTodosIncidence ( todo );
+  }
+  endMultiModify();
+}
+
+void CalendarView::deleteIncidence(Incidence *incidence, bool force)
+{
+  if ( !incidence || !mChanger ) {
+    if ( !force ) {
+      KNotifyClient::beep();
+    }
+    return;
+  }
+  if ( incidence->isReadOnly() ) {
+    if ( !force ) {
+      KMessageBox::information( this, i18n("The item \"%1\" is marked read-only "
+                                "and cannot be deleted; it probably belongs to "
+                                "a read-only calendar resource.")
+                                .arg(incidence->summary()),
+                                i18n("Removing not possible"),
+                                "deleteReadOnlyIncidence" );
+    }
+    return;
+  }
+
+  CanDeleteIncidenceVisitor v;
+
+  // Let the visitor do special things for special incidence types.
+  // e.g. todos with children cannot be deleted, so act(..) returns false
+  if ( !v.act( incidence, this ) )
+    return;
+  //If it is a todo, there are specific delete function
+
+  if ( incidence && incidence->type()=="Todo" ) {
+    deleteTodoIncidence( static_cast<Todo*>(incidence), force );
+    return;
+  }
+
+  if ( incidence->doesRecur() ) {
+    QDate itemDate = mViewManager->currentSelectionDate();
+    kdDebug(5850) << "Recurrence-Date: " << itemDate.toString() << endl;
+    int km = KMessageBox::Ok;
+    if ( !force ) {
+      if ( !itemDate.isValid() ) {
+        kdDebug(5850) << "Date Not Valid" << endl;
+        km = KMessageBox::warningContinueCancel(this,
+          i18n("The calendar item \"%1\" recurs over multiple dates; "
+               "are you sure you want to delete it "
+               "and all its recurrences?").arg( incidence->summary() ),
+               i18n("KOrganizer Confirmation"), i18n("Delete All") );
+      } else {
+        km = KOMessageBox::fourBtnMsgBox( this, QMessageBox::Warning,
+          i18n("The calendar item \"%1\" recurs over multiple dates. "
+               "Do you want to delete only the current one on %2, only all "
+               "future recurrences, or all its recurrences?" )
+               .arg( incidence->summary() )
+               .arg( KGlobal::locale()->formatDate(itemDate)),
+               i18n("KOrganizer Confirmation"), i18n("Delete C&urrent"),
+               i18n("Delete &Future"),
+               i18n("Delete &All"));
+      }
+    }
+    switch(km) {
+      case KMessageBox::Ok: // Continue // all
+      case KMessageBox::Continue:
+        mChanger->deleteIncidence( incidence );
+        break;
+
+      case KMessageBox::Yes: // just this one
+        if ( mChanger->beginChange( incidence ) ) {
+          Incidence *oldIncidence = incidence->clone();
+          incidence->recurrence()->addExDate( itemDate );
+          mChanger->changeIncidence( oldIncidence, incidence );
+          mChanger->endChange( incidence );
+          delete oldIncidence;
+        }
+        break;
+      case KMessageBox::No: // all future items
+        if ( mChanger->beginChange( incidence ) ) {
+          Incidence *oldIncidence = incidence->clone();
+          Recurrence *recur = incidence->recurrence();
+          recur->setEndDate( itemDate.addDays(-1) );
+          mChanger->changeIncidence( oldIncidence, incidence );
+          mChanger->endChange( incidence );
+          delete oldIncidence;
+        }
+        break;
+    }
+  } else {
+    bool doDelete = true;
+    if ( !force && KOPrefs::instance()->mConfirm ) {
+      doDelete = ( msgItemDelete( incidence ) == KMessageBox::Continue );
+    }
+    if ( doDelete ) {
+      mChanger->deleteIncidence( incidence );
+      processIncidenceSelection( 0 );
+    }
+  }
+}
+
+void CalendarView::connectIncidenceEditor( KOIncidenceEditor *editor )
+{
+  connect( this, SIGNAL( newIncidenceChanger( IncidenceChangerBase* ) ),
+           editor, SLOT( setIncidenceChanger( IncidenceChangerBase* ) ) );
+  editor->setIncidenceChanger( mChanger );
+}
+
+bool CalendarView::purgeCompletedSubTodos( Todo* todo, bool &allPurged )
+{
+  if ( !todo ) return true;
+  bool deleteThisTodo = true;
+  Incidence::List subTodos( todo->relations() );
+  Incidence *aIncidence;
+  Todo *aTodo;
+  Incidence::List::Iterator it;
+  for ( it = subTodos.begin(); it != subTodos.end(); ++it ) {
+    aIncidence = *it;
+    if ( aIncidence && aIncidence->type()=="Todo" ) {
+      aTodo = static_cast<Todo*>( aIncidence );
+      deleteThisTodo &= purgeCompletedSubTodos( aTodo, allPurged );
+    }
+  }
+
+  if ( deleteThisTodo ) {
+    if ( todo->isCompleted() ) {
+      if ( !mChanger->deleteIncidence( todo ) )
+        allPurged = false;
+    } else {
+      deleteThisTodo = false;
+    }
+  } else {
+    if ( todo->isCompleted() ) {
+      allPurged = false;
+    }
+  }
+  return deleteThisTodo;
+}
+
+void CalendarView::purgeCompleted()
+{
+  int result = KMessageBox::warningContinueCancel(this,
+      i18n("Delete all completed to-dos?"),i18n("Purge To-dos"),i18n("Purge"));
+
+  if (result == KMessageBox::Continue) {
+    bool allDeleted = true;
+    startMultiModify( i18n("Purging completed to-dos") );
+    Todo::List todos = calendar()->rawTodos();
+    Todo::List rootTodos;
+    Todo::List::ConstIterator it;
+    for ( it = todos.begin(); it != todos.end(); ++it ) {
+      Todo *aTodo = *it;
+      if ( aTodo && !aTodo->relatedTo() )
+        rootTodos.append( aTodo );
+    }
+    // now that we have a list of all root todos, check them and their children
+    for ( it = rootTodos.begin(); it != rootTodos.end(); ++it ) {
+      purgeCompletedSubTodos( *it, allDeleted );
+    }
+    endMultiModify();
+    if ( !allDeleted ) {
+      KMessageBox::information( this, i18n("Unable to purge to-dos with "
+                                "uncompleted children."), i18n("Delete To-do"),
+                                "UncompletedChildrenPurgeTodos" );
+    }
+  }
+}
+
+void CalendarView::slotCalendarChanged()
+{
+  kdDebug(5850) << "CalendarView::slotCalendarChanged()" << endl;
+
+  updateView();
+}
+
+void CalendarView::warningChangeFailed( Incidence * )
+{
+  KMessageBox::sorry( this, i18n("Unable to edit item: "
+                                 "it is locked by another process.") );
+}
+
+void CalendarView::editCanceled( Incidence *i )
+{
+  mCalendar->endChange( i );
+}
+
+void CalendarView::showErrorMessage( const QString &msg )
+{
+  KMessageBox::error( this, msg );
+}
+
+void CalendarView::updateCategories()
+{
+  QStringList allCats( calendar()->categories() );
+  allCats.sort();
+  QStringList categories( KOPrefs::instance()->mCustomCategories );
+  for ( QStringList::ConstIterator si = allCats.constBegin(); si != allCats.constEnd(); ++si ) {
+    if ( categories.find( *si ) == categories.end() ) {
+      categories.append( *si );
+    }
+  }
+  KOPrefs::instance()->mCustomCategories = categories;
+  KOPrefs::instance()->writeConfig();
+  // Make the category editor update the list!
+  emit categoriesChanged();
+}
+
+void CalendarView::addIncidenceOn( Incidence *incadd, const QDate &dt )
+{
+  if ( !incadd || !mChanger ) {
+    KMessageBox::sorry(this, i18n("Unable to copy the item to %1.")
+                       .arg( dt.toString() ), i18n("Copying Failed") );
+    return;
+  }
+  Incidence *incidence = mCalendar->incidence( incadd->uid() );
+  if ( !incidence ) incidence = incadd;
+  // Create a copy of the incidence, since the incadd doesn't belong to us.
+  incidence = incidence->clone();
+  incidence->recreate();
+
+  if ( incidence->type() == "Event" ) {
+    Event *event = static_cast<Event*>(incidence);
+
+    // Adjust date
+    QDateTime start = event->dtStart();
+    QDateTime end = event->dtEnd();
+
+    int duration = start.daysTo( end );
+    start.setDate( dt );
+    end.setDate( dt.addDays( duration ) );
+
+    event->setDtStart( start );
+    event->setDtEnd( end );
+
+  } else if ( incidence->type() == "Todo" ) {
+    Todo *todo = static_cast<Todo*>(incidence);
+    QDateTime due = todo->dtDue();
+    due.setDate( dt );
+
+    todo->setDtDue( due );
+    todo->setHasDueDate( true );
+  }
+
+  if ( !mChanger->addIncidence( incidence, this ) ) {
+    KODialogManager::errorSaveIncidence( this, incidence );
+    delete incidence;
+  }
+}
+
+void CalendarView::moveIncidenceTo( Incidence *incmove, const QDate &dt )
+{
+  if ( !incmove || !mChanger ) {
+    KMessageBox::sorry( this, i18n("Unable to move the item to %1.")
+                        .arg( dt.toString() ), i18n("Moving Failed") );
+    return;
+  }
+  Incidence *incidence = mCalendar->incidence( incmove->uid() );
+  if ( !incidence ) {
+    addIncidenceOn( incidence, dt );
+    return;
+  }
+  Incidence *oldIncidence = incidence->clone();
+  if ( !mChanger->beginChange( incidence ) ) {
+    delete oldIncidence;
+    return;
+  }
+
+  if ( incidence->type() == "Event" ) {
+    Event *event = static_cast<Event*>(incidence);
+
+    // Adjust date
+    QDateTime start = event->dtStart();
+    QDateTime end = event->dtEnd();
+
+    int duration = start.daysTo( end );
+    start.setDate( dt );
+    end.setDate( dt.addDays( duration ) );
+
+    event->setDtStart( start );
+    event->setDtEnd( end );
+
+  } else if ( incidence->type() == "Todo" ) {
+    Todo *todo = static_cast<Todo*>(incidence);
+    QDateTime due = todo->dtDue();
+    due.setDate( dt );
+
+    todo->setDtDue( due );
+    todo->setHasDueDate( true );
+  }
+  mChanger->changeIncidence( oldIncidence, incidence );
+  mChanger->endChange( incidence );
+  delete oldIncidence;
+}
+
+void CalendarView::resourcesChanged()
+{
+  mViewManager->resourcesChanged();
+  updateView();
+}
+
+#include "calendarview.moc"