/*
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 TQt, and distribute the resulting executable,
without including the source code for TQt 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/calhelper.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 <tdeglobal.h>
#include <kdebug.h>
#include <tdestandarddirs.h>
#include <tdefiledialog.h>
#include <tdemessagebox.h>
#include <knotifyclient.h>
#include <tdeconfig.h>
#include <krun.h>
#include <kdirwatch.h>
#include <tqapplication.h>
#include <tqclipboard.h>
#include <tqcursor.h>
#include <tqmultilineedit.h>
#include <tqtimer.h>
#include <tqwidgetstack.h>
#include <tqptrlist.h>
#include <tqfile.h>
#include <tqlayout.h>
#ifndef KORG_NOSPLITTER
#include <tqsplitter.h>
#endif
#include <tqvbox.h>
#include <tqwhatsthis.h>
#include <stdlib.h>
#include <assert.h>
using namespace KOrg;
CalendarView::CalendarView( TQWidget *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 );
mDateNavigator = new DateNavigator( this );
mDateChecker = new DateChecker( this );
TQBoxLayout *topLayout = new TQVBoxLayout( this );
#ifndef KORG_NOSPLITTER
// create the main layout frames.
mPanner = new TQSplitter( TQt::Horizontal, this,
"CalendarView::Panner" );
topLayout->addWidget( mPanner );
mLeftSplitter = new TQSplitter( TQt::Vertical, mPanner,
"CalendarView::LeftFrame" );
// mPanner->setResizeMode( mLeftSplitter, TQSplitter::Stretch );
mDateNavigatorContainer = new DateNavigatorContainer( mLeftSplitter,
"CalendarView::DateNavigator" );
// mLeftSplitter->setResizeMode( mDateNavigatorContainer, TQSplitter::Stretch );
mLeftSplitter->setCollapsible( mDateNavigatorContainer, true );
mTodoList = new KOTodoView( CalendarNull::self(), mLeftSplitter, "todolist" );
mEventViewer = new KOEventViewer( CalendarNull::self(), mLeftSplitter,"EventViewer" );
TQVBox *rightBox = new TQVBox( mPanner );
mNavigatorBar = new NavigatorBar( rightBox );
mRightFrame = new TQWidgetStack( rightBox );
rightBox->setStretchFactor( mRightFrame, 1 );
mLeftFrame = mLeftSplitter;
#else
TQWidget *mainBox;
TQWidget *leftFrame;
if ( KOPrefs::instance()->mVerticalScreen ) {
mainBox = new TQVBox( this );
leftFrame = new TQHBox( mainBox );
} else {
mainBox = new TQHBox( this );
leftFrame = new TQVBox( mainBox );
}
topLayout->addWidget( mainBox );
mDateNavigatorContainer = new KDateNavigator( leftFrame, true,
"CalendarView::DateNavigator",
TQDate::currentDate() );
mTodoList = new KOTodoView( CalendarNull::self(), leftFrame, "todolist" );
mEventViewer = new KOEventViewer ( CalendarNull::self(), leftFrame, "EventViewer" );
TQWidget *rightBox = new TQWidget( mainBox );
TQBoxLayout *rightLayout = new TQVBoxLayout( rightBox );
mNavigatorBar = new NavigatorBar( TQDate::currentDate(), rightBox );
rightLayout->addWidget( mNavigatorBar );
mRightFrame = new TQWidgetStack( rightBox );
rightLayout->addWidget( mRightFrame );
mLeftFrame = leftFrame;
if ( KOPrefs::instance()->mVerticalScreen ) {
// mTodoList->setFixedHeight( 60 );
mTodoList->setFixedHeight( mDateNavigatorContainer->sizeHint().height() );
}
#endif
// Signals emited by mDateNavigator
connect( mDateNavigator, TQ_SIGNAL( datesSelected( const KCal::DateList &, const TQDate & ) ),
TQ_SLOT( showDates( const KCal::DateList &, const TQDate & ) ) );
// Signals emited by mNavigatorBar
connect( mNavigatorBar, TQ_SIGNAL( prevYearClicked() ),
mDateNavigator, TQ_SLOT( selectPreviousYear() ) );
connect( mNavigatorBar, TQ_SIGNAL( nextYearClicked() ),
mDateNavigator, TQ_SLOT( selectNextYear() ) );
connect( mNavigatorBar, TQ_SIGNAL( prevMonthClicked() ),
mDateNavigator, TQ_SLOT( selectPreviousMonth() ) );
connect( mNavigatorBar, TQ_SIGNAL( nextMonthClicked() ),
mDateNavigator, TQ_SLOT( selectNextMonth() ) );
connect( mNavigatorBar, TQ_SIGNAL( monthSelected(int) ),
mDateNavigator, TQ_SLOT( selectMonth(int) ) );
connect( mNavigatorBar, TQ_SIGNAL( yearSelected(int)),
mDateNavigator, TQ_SLOT(selectYear(int)) );
// Signals emited by mDateNavigatorContainer
connect( mDateNavigatorContainer, TQ_SIGNAL( weekClicked( const TQDate & ) ),
this, TQ_SLOT( selectWeek( const TQDate & ) ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( prevMonthClicked(const TQDate &, const TQDate &, const TQDate &) ),
mDateNavigator, TQ_SLOT( selectPreviousMonth(const TQDate &, const TQDate &, const TQDate &) ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( nextMonthClicked(const TQDate &, const TQDate &, const TQDate &) ),
mDateNavigator, TQ_SLOT( selectNextMonth(const TQDate &, const TQDate &, const TQDate &) ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( prevYearClicked() ),
mDateNavigator, TQ_SLOT( selectPreviousYear() ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( nextYearClicked() ),
mDateNavigator, TQ_SLOT( selectNextYear() ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( monthSelected(int) ),
mDateNavigator, TQ_SLOT( selectMonth(int) ) );
connect( mDateNavigatorContainer, TQ_SIGNAL(yearSelected(int)),
mDateNavigator, TQ_SLOT(selectYear(int)) );
connect( mDateNavigatorContainer, TQ_SIGNAL( goPrevious() ),
mDateNavigator, TQ_SLOT( selectPrevious() ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( goNext() ),
mDateNavigator, TQ_SLOT( selectNext() ) );
connect( mDateNavigatorContainer, TQ_SIGNAL( datesSelected( const KCal::DateList & ) ),
mDateNavigator, TQ_SLOT( selectDates( const KCal::DateList & ) ) );
connect( mDateNavigatorContainer, TQ_SIGNAL(incidenceDropped(Incidence*, const TQDate&)),
TQ_SLOT( addIncidenceOn( Incidence *, const TQDate & ) ) );
connect( mDateNavigatorContainer, TQ_SIGNAL(incidenceDroppedMove(Incidence*,const TQDate&)),
TQ_SLOT( moveIncidenceTo( Incidence *, const TQDate & ) ) );
connect( mDateChecker, TQ_SIGNAL( dayPassed( const TQDate & ) ),
mTodoList, TQ_SLOT( dayPassed( const TQDate & ) ) );
connect( mDateChecker, TQ_SIGNAL( dayPassed( const TQDate & ) ),
TQ_SIGNAL( dayPassed( const TQDate & ) ) );
connect( mDateChecker, TQ_SIGNAL( dayPassed( const TQDate & ) ),
mDateNavigatorContainer, TQ_SLOT( updateToday() ) );
connect( this, TQ_SIGNAL( configChanged() ),
mDateNavigatorContainer, TQ_SLOT( updateConfig() ) );
connect( this, TQ_SIGNAL( incidenceSelected(Incidence *, const TQDate &) ),
mEventViewer, TQ_SLOT ( setIncidence (Incidence *, const TQDate &) ) );
//TODO: do a pretty Summary,
TQString 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 );
TQWhatsThis::add( mEventViewer,
i18n( "View the details of events, journal entries or to-dos "
"selected in KOrganizer's main view here." ) );
mEventViewer->setIncidence( 0, TQDate() );
mViewManager->connectTodoView( mTodoList );
mViewManager->connectView( mTodoList );
KOGlobals::self()->
setHolidays( new KHolidays( KOPrefs::instance()->mHolidays ) );
connect( TQApplication::clipboard(), TQ_SIGNAL( dataChanged() ),
TQ_SLOT( checkClipboard() ) );
connect( mTodoList, TQ_SIGNAL( incidenceSelected( Incidence *,const TQDate & ) ),
TQ_SLOT( processTodoListSelection( Incidence *,const TQDate & ) ) );
disconnect( mTodoList, TQ_SIGNAL( incidenceSelected( Incidence *,const TQDate & ) ),
this, TQ_SLOT( processMainViewSelection( Incidence *,const TQDate & ) ) );
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, TQ_SIGNAL( undone() ), TQ_SLOT( updateView() ) );
connect( mHistory, TQ_SIGNAL( redone() ), TQ_SLOT( updateView() ) );
if ( mChanger ) delete mChanger;
setIncidenceChanger( new IncidenceChanger( mCalendar, this ) );
mCalendar->registerObserver( this );
mDateNavigatorContainer->setCalendar( mCalendar );
mTodoList->setCalendar( mCalendar );
mEventViewer->setCalendar( mCalendar );
}
void CalendarView::setIncidenceChanger( IncidenceChangerBase *changer )
{
mChanger = changer;
emit newIncidenceChanger( mChanger );
connect( mChanger, TQ_SIGNAL( incidenceAdded( Incidence* ) ),
this, TQ_SLOT( incidenceAdded( Incidence* ) ) );
connect( mChanger, TQ_SIGNAL( incidenceChanged( Incidence*, Incidence*, KOGlobals::WhatChanged ) ),
this, TQ_SLOT( incidenceChanged( Incidence*, Incidence*, KOGlobals::WhatChanged ) ) );
connect( mChanger, TQ_SIGNAL( incidenceToBeDeleted( Incidence * ) ),
this, TQ_SLOT( incidenceToBeDeleted( Incidence * ) ) );
connect( mChanger, TQ_SIGNAL( incidenceDeleted( Incidence * ) ),
this, TQ_SLOT( incidenceDeleted( Incidence * ) ) );
connect( mChanger, TQ_SIGNAL( schedule( Scheduler::Method, Incidence*) ),
this, TQ_SLOT( schedule( Scheduler::Method, Incidence*) ) );
connect( this, TQ_SIGNAL( cancelAttendees( Incidence * ) ),
mChanger, TQ_SLOT( cancelAttendees( Incidence * ) ) );
}
Calendar *CalendarView::calendar()
{
if ( mCalendar ) return mCalendar;
else return CalendarNull::self();
}
TQPair<ResourceCalendar *, TQString> CalendarView::viewSubResourceCalendar()
{
TQPair<ResourceCalendar *, TQString> p( 0, TQString() );
KOrg::BaseView *cV = mViewManager->currentView();
if ( cV && cV == mViewManager->multiAgendaView() ) {
cV = mViewManager->multiAgendaView()->selectedAgendaView();
}
if ( cV ) {
p = qMakePair( cV->resourceCalendar(), cV->subResourceCalendar() );
}
return p;
}
KOIncidenceEditor *CalendarView::editorDialog( Incidence *incidence ) const
{
if (mDialogList.find(incidence) != mDialogList.end ())
return mDialogList[incidence];
else return 0;
}
TQDate CalendarView::activeDate( bool fallbackToToday )
{
KOrg::BaseView *curView = mViewManager->currentView();
if ( curView ) {
if ( curView->selectionStart().isValid() ) {
return curView->selectionStart().date();
}
// Try the view's selectedDates()
if ( !curView->selectedIncidenceDates().isEmpty() ) {
if ( curView->selectedIncidenceDates().first().isValid() ) {
return curView->selectedIncidenceDates().first();
}
}
}
// When all else fails, use the navigator start date, or today.
if ( fallbackToToday ) {
return TQDate::currentDate();
} else {
return mDateNavigator->selectedDates().first();
}
}
TQDate CalendarView::activeIncidenceDate()
{
KOrg::BaseView *curView = mViewManager->currentView();
if ( curView ) {
DateList dates = curView->selectedIncidenceDates();
if ( !dates.isEmpty() ) {
return dates.first();
}
}
return TQDate();
}
TQDate CalendarView::startDate()
{
DateList dates = mDateNavigator->selectedDates();
return dates.first();
}
TQDate CalendarView::endDate()
{
DateList dates = mDateNavigator->selectedDates();
return dates.last();
}
bool CalendarView::openCalendar(const TQString& filename, bool merge)
{
kdDebug(5850) << "CalendarView::openCalendar(): " << filename << endl;
if (filename.isEmpty()) {
kdDebug(5850) << "CalendarView::openCalendar(): Error! Empty filename." << endl;
return false;
}
if (!TQFile::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
CalendarResources *cl = dynamic_cast<CalendarResources *>( mCalendar );
if ( cl && !cl->hasCalendarResources() ) {
KMessageBox::sorry(
this,
i18n( "No calendars found, unable to merge the file into your calendar." ) );
return false;
}
// FIXME: This is a nasty hack, since we need to set a parent for the
// resource selection dialog. However, we don't have any UI methods
// in the calendar, only in the CalendarResources::DestinationPolicy
// So we need to type-cast it and extract it from the CalendarResources
TQWidget *tmpparent = 0;
if ( cl ) {
tmpparent = cl->dialogParentWidget();
cl->setDialogParentWidget( this );
}
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 TQString& 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;
TQString str;
// read settings from the TDEConfig, supplying reasonable
// defaults where none are to be found
TDEConfig *config = KOGlobals::self()->config();
#ifndef KORG_NOSPLITTER
config->setGroup( "KOrganizer Geometry" );
TQValueList<int> sizes = config->readIntListEntry( "Separator1" );
if ( sizes.count() != 2 ) {
sizes << mDateNavigatorContainer->minimumSizeHint().width();
sizes << 300;
}
mPanner->setSizes( sizes );
sizes = config->readIntListEntry( "Separator2" );
mLeftSplitter->setSizes( sizes );
#endif
mEventViewer->readSettings( config );
mViewManager->readSettings( config );
mTodoList->restoreLayout( config, TQString( "Todo Layout" ) );
readFilterSettings( config );
config->setGroup( "Views" );
const int dateCount = config->readNumEntry( "ShownDatesCount", 7 );
if ( dateCount == 7 ) {
mDateNavigator->selectWeek();
} else {
mDateNavigator->selectDates( mDateNavigator->selectedDates().first(), dateCount );
}
}
void CalendarView::writeSettings()
{
// kdDebug(5850) << "CalendarView::writeSettings" << endl;
TDEConfig *config = KOGlobals::self()->config();
#ifndef KORG_NOSPLITTER
config->setGroup( "KOrganizer Geometry" );
TQValueList<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, TQString( "Todo Layout" ) );
KOPrefs::instance()->writeConfig();
writeFilterSettings( config );
config->setGroup( "Views" );
config->writeEntry( "ShownDatesCount", mDateNavigator->selectedDates().count() );
config->sync();
}
void CalendarView::readFilterSettings( TDEConfig *config )
{
// kdDebug(5850) << "CalendarView::readFilterSettings()" << endl;
mFilters.clear();
config->setGroup( "General" );
// FIXME: Move the filter loading and saving to the CalFilter class in libkcal
TQStringList filterList = config->readListEntry ("CalendarFilters" );
TQString currentFilter = config->readEntry( "Current Filter" );
TQStringList::ConstIterator it = filterList.begin();
TQStringList::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( TDEConfig *config )
{
// kdDebug(5850) << "CalendarView::writeFilterSettings()" << endl;
TQStringList 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", TQString() );
}
}
void CalendarView::goDate( const TQDate &date )
{
mDateNavigator->selectDate( date );
}
void CalendarView::showDate( const TQDate &date )
{
int dateCount = mDateNavigator->datesCount();
if ( dateCount == 7 ) {
mDateNavigator->selectWeek( date );
} else {
mDateNavigator->selectDates( date, dateCount );
}
}
void CalendarView::goToday()
{
mDateNavigator->selectToday();
}
void CalendarView::goNext()
{
if ( dynamic_cast<KOMonthView*>( mViewManager->currentView() ) ) {
mDateNavigator->selectNextMonth();
} else {
mDateNavigator->selectNext();
}
}
void CalendarView::goPrevious()
{
if ( dynamic_cast<KOMonthView*>( mViewManager->currentView() ) ) {
mDateNavigator->selectPreviousMonth();
} else {
mDateNavigator->selectPrevious();
}
}
void CalendarView::updateConfig( const TQCString& receiver)
{
if ( receiver != "korganizer" ) return;
kdDebug(5850) << "CalendarView::updateConfig()" << endl;
KOGlobals::self()->
setHolidays( new KHolidays( KOPrefs::instance()->mHolidays ) );
TQString 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 TQString 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();
//switch beetween merged, side by side and tabbed agenda if needed
mViewManager->updateMultiCalendarDisplay();
// 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,
KOGlobals::WhatChanged modification )
{
KOIncidenceEditor *tmp = editorDialog( newIncidence );
if ( tmp ) {
kdDebug(5850) << "Incidence modified and open" << endl;
tmp->modified();
}
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() &&
( modification == KOGlobals::COMPLETION_MODIFIED ||
modification == KOGlobals::COMPLETION_MODIFIED_WITH_RECURRENCE ) ) {
Todo *todo = static_cast<Todo *>(newIncidence);
if ( todo->isCompleted() ||
modification == KOGlobals::COMPLETION_MODIFIED_WITH_RECURRENCE ) {
TQString timeStr = TDEGlobal::locale()->formatTime( TQTime::currentTime() );
TQString description = i18n( "To-do completed: %1 (%2)" ).arg(
newIncidence->summary() ).arg( timeStr );
Journal::List journals = calendar()->journals( TQDate::currentDate() );
Journal *journal;
if ( journals.isEmpty() ) {
journal = new Journal();
journal->setDtStart( TQDateTime::currentDateTime() );
TQString dateStr = TDEGlobal::locale()->formatDate( TQDate::currentDate() );
journal->setSummary( i18n("Journal of %1").arg( dateStr ) );
journal->setDescription( description );
//TODO: recorded to-dos should save into the standard resource always
if ( !mChanger->addIncidence( journal, 0, TQString(), 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,
KOGlobals::DESCRIPTION_MODIFIED, this ) ) {
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 TQString &text )
{
history()->startMultiModify( text );
}
void CalendarView::endMultiModify()
{
history()->endMultiModify();
}
void CalendarView::changeIncidenceDisplay( Incidence *incidence, int action )
{
mDateNavigatorContainer->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, activeDate( true ), action );
} else {
mViewManager->currentView()->updateView();
if ( mTodoList ) mTodoList->updateView();
}
}
void CalendarView::updateView(const TQDate &start, const TQDate &end)
{
mTodoList->updateView();
mViewManager->updateView(start, end);
mDateNavigatorContainer->updateView();
}
void CalendarView::updateView()
{
DateList tmpList = mDateNavigator->selectedDates();
// We assume that the navigator only selects consecutive days.
updateView( tmpList.first(), tmpList.last() );
}
void CalendarView::updateUnmanagedViews()
{
mDateNavigatorContainer->updateDayMatrix();
updateView();
}
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"),"edit-delete"));
}
void CalendarView::edit_cut()
{
Incidence *incidence = incToSendToClipboard( true );
if ( !incidence || !mChanger ) {
KNotifyClient::beep();
return;
}
Incidence::List incidences;
int km = KMessageBox::Yes;
if ( !incidence->relations().isEmpty() &&
incidence->type() == "Todo" ) { // Only todos (yet?)
km = KMessageBox::questionYesNoCancel( this,
i18n("The item \"%1\" has sub-to-dos. "
"Do you want to cut just this item and "
"make all its sub-to-dos independent, or "
"cut the to-do with all its sub-to-dos?"
).arg( incidence->summary() ),
i18n("KOrganizer Confirmation"),
i18n("Cut Only This"),
i18n("Cut All"));
}
if ( km == KMessageBox::Yes ) { // only one
incidences.append( incidence );
makeChildrenIndependent( incidence );
} else if ( km == KMessageBox::No ) { // all
// load incidence + children + grandchildren...
getIncidenceHierarchy( incidence, incidences );
}
if ( km != KMessageBox::Cancel ) {
mChanger->cutIncidences( incidences, this );
}
}
void CalendarView::edit_copy()
{
Incidence *incidence = incToSendToClipboard( false );
if ( !incidence ) {
KNotifyClient::beep();
return;
}
Incidence::List incidences;
int km = KMessageBox::Yes;
if ( !incidence->relations().isEmpty() &&
incidence->type() == "Todo" ) { // only todos.
km = KMessageBox::questionYesNoCancel( this,
i18n("The item \"%1\" has sub-to-dos. "
"Do you want to copy just this item or "
"copy the to-do with all its sub-to-dos?"
).arg( incidence->summary() ),
i18n("KOrganizer Confirmation"),
i18n("Copy Only This"),
i18n("Copy All"));
}
if ( km == KMessageBox::Yes ) { // only one
incidences.append( incidence );
} else if ( km == KMessageBox::No ) { // all
// load incidence + children + grandchildren...
getIncidenceHierarchy( incidence, incidences );
}
if ( km != KMessageBox::Cancel ) {
DndFactory factory( mCalendar );
if ( !factory.copyIncidences( incidences ) ) {
KNotifyClient::beep();
}
}
}
Incidence* CalendarView::incToSendToClipboard( bool cut )
{
Incidence *originalInc = selectedIncidence();
if ( originalInc && originalInc->doesRecur() &&
originalInc->type() == "Event" ) { // temporary, until recurring to-dos are fixed
Incidence *inc;
KOGlobals::WhichOccurrences chosenOption;
if ( cut ) {
inc = singleOccurrenceOrAll( originalInc, KOGlobals::CUT, chosenOption, TQDate(), true );
} else {
// The user is copying, the original incidence can't be changed
// we can only dissociate a copy
Incidence *originalIncSaved = originalInc->clone();
inc = singleOccurrenceOrAll( originalIncSaved, KOGlobals::COPY, chosenOption, TQDate(), false );
// no dissociation, no need to leak our clone
if ( chosenOption == KOGlobals::ALL ) {
inc = originalInc;
delete originalIncSaved;
}
// no need to leak our clone
if ( chosenOption == KOGlobals::NONE ) {
delete originalIncSaved;
}
}
return inc;
} else {
return originalInc;
}
}
void CalendarView::edit_paste()
{
// If in agenda and month view, use the selected time and date from there.
// In all other cases, use the navigator's selected date.
TQDate date; // null dates are invalid, that's what we want
bool timeSet = false;// flag denoting if the time has been set.
TQTime time; // null dates are valid, so rely on the timeSet flag
TQDateTime endDT; // null datetimes are invalid, that's what we want
bool useEndTime = false;
KOrg::BaseView *curView = mViewManager->currentView();
KOAgendaView *aView = mViewManager->agendaView();
KOMonthView *mView = mViewManager->monthView();
if ( curView == mViewManager->multiAgendaView() ) {
aView = mViewManager->multiAgendaView()->selectedAgendaView();
curView = aView;
}
if ( !curView ) {
return;
}
if ( curView == aView && aView->selectionStart().isValid() ) {
date = aView->selectionStart().date();
endDT = aView->selectionEnd();
useEndTime = !aView->selectedIsSingleCell();
if ( !aView->selectedIsAllDay() ) {
time = aView->selectionStart().time();
timeSet = true;
}
} else if ( curView == mView && mView->selectionStart().isValid() ) {
date = mView->selectionStart().date();
} else if ( !mDateNavigator->selectedDates().isEmpty() &&
curView->supportsDateNavigation() ) {
// default to the selected date from the navigator
date = mDateNavigator->selectedDates().first();
}
if ( !date.isValid() && curView->supportsDateNavigation() ) {
KMessageBox::sorry(
this,
i18n( "Paste failed: unable to determine a valid target date." ) );
return;
}
DndFactory factory( mCalendar );
Incidence::List pastedIncidences;
if ( timeSet && time.isValid() ) {
pastedIncidences = factory.pasteIncidences( date, &time );
} else {
pastedIncidences = factory.pasteIncidences( date );
}
Incidence::List::Iterator it;
for ( it = pastedIncidences.begin(); it != pastedIncidences.end(); ++it ) {
TQPair<ResourceCalendar *, TQString>p = viewSubResourceCalendar();
// FIXME: use a visitor here
if ( ( *it )->type() == "Event" ) {
Event *pastedEvent = static_cast<Event*>( *it );
// 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 );
}
}
// KCal supports events with relations, but korganizer doesn't
// so unset it. It can even come from other application.
pastedEvent->setRelatedTo( 0 );
pastedEvent->setRelatedToUid( TQString() );
mChanger->addIncidence( pastedEvent, p.first, p.second, this );
} else if ( ( *it )->type() == "Todo" ) {
Todo *pastedTodo = static_cast<Todo*>( *it );
Todo *_selectedTodo = selectedTodo();
// if we are cutting a hierarchy only the root
// should be son of _selectedTodo
if ( _selectedTodo && !pastedTodo->relatedTo() ) {
pastedTodo->setRelatedTo( _selectedTodo );
}
mChanger->addIncidence( pastedTodo, p.first, p.second, this );
}
}
}
void CalendarView::edit_options()
{
mDialogManager->showOptionsDialog();
}
void CalendarView::dateTimesForNewEvent( TQDateTime &startDt, TQDateTime &endDt, bool &allDay )
{
mViewManager->currentView()->eventDurationHint( startDt, endDt, allDay );
if ( !startDt.isValid() || !endDt.isValid() ) {
startDt.setDate( activeDate( true ) );
startDt.setTime( KOPrefs::instance()->mStartTime.time() );
int addSecs = ( KOPrefs::instance()->mDefaultDuration.time().hour() * 3600 ) +
( KOPrefs::instance()->mDefaultDuration.time().minute() * 60 );
endDt = startDt.addSecs( addSecs );
}
}
KOEventEditor *CalendarView::newEventEditor( ResourceCalendar *res, const TQString &subRes,
const TQDateTime &startDtParam,
const TQDateTime &endDtParam, bool allDayParam )
{
// let the current view change the default start/end datetime
bool allDay = allDayParam;
TQDateTime 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->setResource( res, subRes );
eventEditor->setDates( startDt, endDt, allDay );
mDialogManager->connectTypeAhead( eventEditor, dynamic_cast<KOrg::AgendaView*>(viewManager()->currentView()) );
return eventEditor;
}
void CalendarView::newEvent()
{
KOrg::BaseView *currentView = mViewManager->currentView();
if ( currentView == mViewManager->multiAgendaView() ) {
currentView = mViewManager->multiAgendaView()->selectedAgendaView();
}
if ( currentView ) {
newEvent( currentView->resourceCalendar(),
currentView->subResourceCalendar() );
}
}
void CalendarView::newEvent( ResourceCalendar *res, const TQString &subRes )
{
kdDebug(5850) << "CalendarView::newEvent()" << endl;
newEvent( res, subRes, TQDateTime(), TQDateTime() );
}
void CalendarView::newEvent( ResourceCalendar *res, const TQString &subRes,
const TQDate &dt )
{
TQDateTime startDt( dt, KOPrefs::instance()->mStartTime.time() );
newEvent( res, subRes, TQDateTime( dt ), TQDateTime() );
}
void CalendarView::newEvent( ResourceCalendar *res, const TQString &subRes,
const TQDateTime &startDt )
{
newEvent( res, subRes, startDt, TQDateTime() );
}
void CalendarView::newEvent( ResourceCalendar *res, const TQString &subRes,
const TQDateTime &startDt, const TQDateTime &endDt,
bool allDay )
{
KOEventEditor *eventEditor = newEventEditor( res, subRes,
startDt, endDt, allDay );
eventEditor->show();
}
void CalendarView::newEvent( ResourceCalendar *res, const TQString &subRes,
const TQString &summary, const TQString &description,
const TQStringList &attachments, const TQStringList &attendees,
const TQStringList &attachmentMimetypes, bool inlineAttachment )
{
KOEventEditor *eventEditor = newEventEditor( res, subRes );
eventEditor->setTexts( summary, description );
// if attach or attendee list is empty, these methods don't do anything, so
// it's safe to call them in every case
eventEditor->addAttachments( attachments, attachmentMimetypes, inlineAttachment );
eventEditor->addAttendees( attendees );
eventEditor->show();
}
void CalendarView::newTodo( ResourceCalendar *res, const TQString &subRes,
const TQString &summary, const TQString &description,
const TQStringList &attachments, const TQStringList &attendees,
const TQStringList &attachmentMimetypes,
bool inlineAttachment, bool isTask )
{
kdDebug(5850) << k_funcinfo << endl;
KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
connectIncidenceEditor( todoEditor );
todoEditor->newTodo();
todoEditor->setResource( res, subRes );
todoEditor->setTexts( summary, description );
todoEditor->addAttachments( attachments, attachmentMimetypes, inlineAttachment );
todoEditor->addAttendees( attendees );
todoEditor->selectCreateTask( isTask );
todoEditor->show();
}
void CalendarView::newTodo()
{
KOrg::BaseView *currentView = mViewManager->currentView();
if ( currentView == mViewManager->multiAgendaView() ) {
currentView = mViewManager->multiAgendaView()->selectedAgendaView();
}
if ( currentView ) {
newTodo( currentView->resourceCalendar(),
currentView->subResourceCalendar() );
}
}
void CalendarView::newTodo( ResourceCalendar *res, const TQString &subRes )
{
kdDebug(5850) << k_funcinfo << endl;
TQDateTime dtDue;
bool allday = true;
KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
connectIncidenceEditor( todoEditor );
todoEditor->newTodo();
todoEditor->setResource( res, subRes );
if ( mViewManager->currentView()->isEventView() ) {
dtDue.setDate( mDateNavigator->selectedDates().first() );
TQDateTime dtDummy = TQDateTime::currentDateTime();
mViewManager->currentView()->eventDurationHint( dtDue, dtDummy, allday );
todoEditor->setDates( dtDue, allday );
}
todoEditor->show();
}
void CalendarView::newTodo( ResourceCalendar *res, const TQString &subRes,
const TQDate &date )
{
KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
connectIncidenceEditor( todoEditor );
todoEditor->newTodo();
todoEditor->setResource( res, subRes );
todoEditor->setDates( TQDateTime( date, TQTime::currentTime() ), true );
todoEditor->show();
}
void CalendarView::newJournal()
{
KOrg::BaseView *currentView = mViewManager->currentView();
if ( currentView == mViewManager->multiAgendaView() ) {
currentView = mViewManager->multiAgendaView()->selectedAgendaView();
}
if ( currentView ) {
newJournal( currentView->resourceCalendar(),
currentView->subResourceCalendar() );
}
}
void CalendarView::newJournal( ResourceCalendar *res, const TQString &subRes )
{
kdDebug(5850) << "CalendarView::newJournal()" << endl;
newJournal( res, subRes, TQString(), TQDate() );
}
void CalendarView::newJournal( ResourceCalendar *res, const TQString &subRes,
const TQDate &date)
{
newJournal( res, subRes, TQString(), date );
}
void CalendarView::newJournal( ResourceCalendar *res, const TQString &subRes,
const TQString &text, const TQDate &date )
{
KOJournalEditor *journalEditor = mDialogManager->getJournalEditor();
connectIncidenceEditor( journalEditor );
journalEditor->newJournal();
journalEditor->setResource( res, subRes );
journalEditor->setTexts( text );
if ( !date.isValid() ) {
journalEditor->setDate( mDateNavigator->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( TQDateTime(), false, parentEvent );
todoEditor->show();
}
bool CalendarView::addIncidence( const TQString &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, 0, TQString(), this ) ) {
delete incidence;
return false;
}
return true;
}
void CalendarView::appointment_show()
{
Incidence *incidence = selectedIncidence();
if ( incidence ) {
showIncidence( incidence, activeIncidenceDate() );
} else {
KNotifyClient::beep();
}
}
void CalendarView::appointment_edit()
{
Incidence *incidence = selectedIncidence();
if ( incidence ) {
editIncidence( incidence, activeIncidenceDate() );
} 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( incidence_unsub ( anTodo ) ) {
updateView();
}
}
bool CalendarView::incidence_unsub( Incidence *inc )
{
bool status = false;
if ( !inc || !inc->relatedTo() ) {
return false;
}
if ( mChanger->beginChange( inc, 0, TQString() ) ) {
Incidence *oldInc = inc->clone();
inc->setRelatedTo( 0 );
mChanger->changeIncidence( oldInc, inc, KOGlobals::RELATION_MODIFIED, this );
mChanger->endChange( inc, 0, TQString() );
delete oldInc;
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::makeSubTodosIndependent ( )
{
bool status = false;
Todo *aTodo = selectedTodo();
if ( makeChildrenIndependent( aTodo ) ) {
updateView();
status = true;
}
return status;
}
bool CalendarView::makeChildrenIndependent ( Incidence *inc )
{
if ( !inc || inc->relations().isEmpty() ) {
return false;
}
startMultiModify ( i18n( "Make sub-to-dos independent" ) );
Incidence::List subIncs( inc->relations() );
Incidence::List::Iterator it;
for ( it= subIncs.begin(); it != subIncs.end(); ++it ) {
incidence_unsub ( *it );
}
endMultiModify();
return true;
}
bool CalendarView::deleteIncidence( const TQString &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, 0, TQString() ) ) {
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->setType( Alarm::Display );
alm->setEnabled( true );
int duration; // in secs
switch( KOPrefs::instance()->mReminderTimeUnits ) {
default:
case 0: // mins
duration = KOPrefs::instance()->mReminderTime * 60;
break;
case 1: // hours
duration = KOPrefs::instance()->mReminderTime * 60 * 60;
break;
case 2: // days
duration = KOPrefs::instance()->mReminderTime * 60 * 60 * 24;
break;
}
if ( incidence->type() == "Event" ) {
alm->setStartOffset( KCal::Duration( -duration ) );
} else {
alm->setEndOffset( KCal::Duration( -duration ) );
}
}
mChanger->changeIncidence( oldincidence, incidence, KOGlobals::ALARM_MODIFIED, this );
mChanger->endChange( incidence, 0, TQString() );
delete oldincidence;
// mClickedItem->updateIcons();
}
void CalendarView::dissociateOccurrence( Incidence *incidence, const TQDate &date )
{
if ( !incidence || !mChanger ) {
kdDebug(5850) << "CalendarView::toggleAlarm() called without having a clicked item" << endl;
return;
}
TQPair<ResourceCalendar *, TQString>p =
CalHelper::incSubResourceCalendar( calendar(), incidence );
if ( !mChanger->beginChange( incidence, p.first, p.second ) ) {
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 [FIXME]: Use the same resource instead of asking again!
// See also koagenda.cpp: endItemAction()
bool success = mChanger->addIncidence( newInc, p.first, p.second, this );
if ( success )
mChanger->changeIncidence( oldincidence, incidence, KOGlobals::NOTHING_MODIFIED, this );
} else {
KMessageBox::sorry( this, i18n("Dissociating the occurrence failed."),
i18n("Dissociating Failed") );
}
mChanger->endChange( incidence, p.first, p.second );
endMultiModify();
delete oldincidence;
}
void CalendarView::dissociateFutureOccurrence( Incidence *incidence, const TQDate &date )
{
if ( !incidence || !mChanger ) {
kdDebug(5850) << "CalendarView::toggleAlarm() called without having a clicked item" << endl;
return;
}
TQPair<ResourceCalendar *, TQString>p =
CalHelper::incSubResourceCalendar( calendar(), incidence );
if ( !mChanger->beginChange( incidence, p.first, p.second ) ) {
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 ) {
mChanger->changeIncidence( oldincidence, incidence, KOGlobals::NOTHING_MODIFIED, this );
mChanger->addIncidence( newInc, p.first, p.second, this );
} else {
KMessageBox::sorry( this, i18n("Dissociating the future occurrences failed."),
i18n("Dissociating Failed") );
}
endMultiModify();
mChanger->endChange( incidence, p.first, p.second );
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() == TQDialog::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 ) {
incidence = selectedIncidence();
}
if ( !incidence ) {
KMessageBox::information(
this,
i18n( "No item selected." ),
i18n( "Forwarding" ),
"ForwardNoEventSelected" );
return;
}
PublishDialog publishdlg;
if ( publishdlg.exec() == TQDialog::Accepted ) {
TQString recipients = publishdlg.addresses();
if ( incidence->organizer().isEmpty() ) {
incidence->setOrganizer( Person( KOPrefs::instance()->fullName(),
KOPrefs::instance()->email() ) );
}
ICalFormat format;
TQString 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() ),
i18n( "Forwarding Error" ) );
}
}
}
void CalendarView::mailFreeBusy( int daysToPublish )
{
TQDateTime start = TQDateTime::currentDateTime();
TQDateTime 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: "
<< TDEGlobal::locale()->formatDateTime( start ) << " End Date: "
<< TDEGlobal::locale()->formatDateTime( end ) << endl;
PublishDialog *publishdlg = new PublishDialog();
if ( publishdlg->exec() == TQDialog::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, TQ_SIGNAL(configChanged()), &printer, TQ_SLOT(updateConfig()) );
KOrg::BaseView *currentView = mViewManager->currentView();
CalPrinterBase::PrintType printType = CalPrinterBase::Month;
if ( currentView ) {
printType = currentView->printType();
}
DateList tmpDateList = mDateNavigator->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 tdeconfigxt objects don't
// seem to load the config theirselves
if ( settings ) settings->readConfig();
ExportWebDialog *dlg = new ExportWebDialog( settings, this );
connect( dlg, TQ_SIGNAL( exportHTML( HTMLExportSettings* ) ),
this, TQ_SIGNAL( exportHTML( HTMLExportSettings* ) ) );
dlg->show();
}
void CalendarView::exportICalendar()
{
TQString filename = KFileDialog::getSaveFileName("icalout.ics",i18n("*.ics|ICalendars"),this);
if ( !filename.isEmpty() )
{
// Force correct extension
if (filename.right(4) != ".ics") filename += ".ics";
if ( TQFile( filename ).exists() ) {
if ( KMessageBox::No == KMessageBox::warningYesNo(
this,
i18n( "Do you want to overwrite %1?").arg(filename) ) ) {
return;
}
}
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;
}
TQString filename = KFileDialog::getSaveFileName("vcalout.vcs",i18n("*.vcs|vCalendars"),this);
if ( !filename.isEmpty() )
{
// TODO: I don't like forcing extensions:
// Force correct extension
if (filename.right(4) != ".vcs") filename += ".vcs";
if ( TQFile( filename ).exists() ) {
if ( KMessageBox::No == KMessageBox::warningYesNo(
this,
i18n( "Do you want to overwrite %1?").arg(filename ) ) ) {
return;
}
}
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, const TQDate &date )
{
if ( incidence ) mTodoList->clearSelection();
processIncidenceSelection( incidence, date );
}
void CalendarView::processTodoListSelection( Incidence *incidence, const TQDate &date )
{
if ( incidence && mViewManager->currentView() ) {
mViewManager->currentView()->clearSelection();
}
processIncidenceSelection( incidence, date );
}
void CalendarView::processIncidenceSelection( Incidence *incidence, const TQDate &date )
{
if ( incidence != mSelectedIncidence ) {
// This signal also must be emitted if incidence is 0
emit incidenceSelected( incidence, date );
}
if ( !incidence ) {
mSelectedIncidence = incidence;
return;
}
if ( incidence == mSelectedIncidence ) {
if ( !incidence->doesRecur() || mSaveDate == date ) {
return;
}
}
mSelectedIncidence = incidence;
mSaveDate = date;
emit incidenceSelected( mSelectedIncidence, date );
bool organizerEvents = false;
bool groupEvents = false;
bool todo = false;
bool subtodo = false;
organizerEvents = KOPrefs::instance()->thatIsMe( incidence->organizer().email() );
groupEvents = incidence->attendeeByMails( KOPrefs::instance()->allEmails() );
if ( 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(TQApplication::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, const TQDate &preferredMonth )
{
mDateNavigatorContainer->selectDates( selectedDates, preferredMonth );
mNavigatorBar->selectDates( selectedDates );
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()
{
TQStringList 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();
}
TQString 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 )
mDateNavigatorContainer->show();
else
mDateNavigatorContainer->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, 0, TQString() );
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(), activeIncidenceDate() );
}
void CalendarView::editIncidence()
{
editIncidence( selectedIncidence(), activeIncidenceDate() );
}
bool CalendarView::editIncidence( const TQString &uid )
{
return editIncidence( mCalendar->incidence( uid ), TQDate() );
}
bool CalendarView::editIncidence( const TQString &uid, const TQDate &date )
{
return editIncidence( mCalendar->incidence( uid ), date );
}
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, const TQDate &date )
{
if ( !incidence ) {
return;
}
KOEventViewerDialog *eventViewer = new KOEventViewerDialog( calendar(), this );
eventViewer->setIncidence( incidence, date );
eventViewer->show();
}
bool CalendarView::editIncidence( Incidence *incidence, const TQDate &date, bool isCounter )
{
kdDebug(5850) << "CalendarView::editEvent()" << endl;
CalendarResources *stdcal = dynamic_cast<CalendarResources *>( mCalendar );
if( stdcal && !stdcal->hasCalendarResources() ) {
KMessageBox::sorry(
this,
i18n( "No resources found. We can not edit the item." ) );
return false;
}
// FIXME: This is a nasty hack, since we need to set a parent for the
// resource selection dialog. However, we don't have any UI methods
// in the calendar, only in the CalendarResources::DestinationPolicy
// So we need to type-cast it and extract it from the CalendarResources
TQWidget *tmpparent = 0;
if ( stdcal ) {
tmpparent = stdcal->dialogParentWidget();
stdcal->setDialogParentWidget( this );
}
if ( !incidence ) {
kdDebug(5850) << "Empty Incidence" << endl;
KNotifyClient::beep();
return false;
}
if ( !mChanger ) {
kdDebug(5850) << "Empty Changer" << endl;
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, date );
return true;
}
TQPair<ResourceCalendar *, TQString>p =
CalHelper::incSubResourceCalendar( calendar(), incidence );
Incidence *savedIncidence = incidence->clone();
Incidence *incToChange;
if ( incidence->doesRecur() ) {
KOGlobals::WhichOccurrences chosenOption;
incToChange = singleOccurrenceOrAll( incidence, KOGlobals::EDIT, chosenOption, date );
} else {
incToChange = incidence;
}
// If the user pressed cancel incToChange is 0
if ( incToChange ) {
if ( !isCounter && !mChanger->beginChange( incToChange, p.first, p.second ) ) {
warningChangeFailed( incToChange );
showIncidence( incToChange, date );
return false;
}
kdDebug(5850) << "CalendarView::editIncidence() new IncidenceEditor" << endl;
KOIncidenceEditor *incidenceEditor = mDialogManager->getEditor( incToChange );
connectIncidenceEditor( incidenceEditor );
mDialogList.insert( incToChange, incidenceEditor );
if ( incidence != incToChange ) {
incidenceEditor->setRecurringIncidence( savedIncidence, incidence );
}
incidenceEditor->setResource( p.first, p.second );
incidenceEditor->editIncidence( incToChange, date, mCalendar );
incidenceEditor->show();
return true;
} else {
return false;
}
}
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, this );
}
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, this );
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 ) {
// Instead of making a subto-do independent, why not relate
// it to it's dead father's parent?
makeChildrenIndependent ( todo );
mChanger->deleteIncidence( todo, this );
} 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() ) {
TQDate itemDate = mViewManager->currentSelectionDate();
kdDebug(5850) << "Recurrence-Date: " << TQString(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, TQMessageBox::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( TDEGlobal::locale()->formatDate(itemDate)),
i18n("KOrganizer Confirmation"), i18n("Delete C&urrent"),
i18n("Delete &Future"),
i18n("Delete &All"));
}
}
TQPair<ResourceCalendar *, TQString>p =
CalHelper::incSubResourceCalendar( calendar(), incidence );
switch(km) {
case KMessageBox::Ok: // Continue // all
case KMessageBox::Continue:
mChanger->deleteIncidence( incidence, this );
break;
case KMessageBox::Yes: // just this one
if ( mChanger->beginChange( incidence, p.first, p.second ) ) {
Incidence *oldIncidence = incidence->clone();
if (incidence->recurrence()->startDate() == itemDate) {
// Moving the first in a series...don't bother with the nonstandard exclusion list
Recurrence *recur = incidence->recurrence();
Event* thisevent = static_cast<Event*>(incidence);
TQDateTime newEnd;
TQDateTime newRecurEnd;
newRecurEnd = recur->endDateTime();
newEnd.setTime_t( incidence->dtEnd().toTime_t() + ( recur->getNextDateTime( recur->startDateTime() ).toTime_t() - recur->startDateTime().toTime_t() ) );
thisevent->setDtEnd( newEnd );
incidence->setDtStart( recur->getNextDateTime( recur->startDateTime() ) );
recur->setEndDateTime(newRecurEnd);
}
else {
// No choice but to use the exclusion list
incidence->recurrence()->addExDate( itemDate );
}
mChanger->changeIncidence( oldIncidence, incidence, KOGlobals::RECURRENCE_MODIFIED_ONE_ONLY, this );
mChanger->endChange( incidence, p.first, p.second );
delete oldIncidence;
}
break;
case KMessageBox::No: // all future items
if ( mChanger->beginChange( incidence, p.first, p.second ) ) {
Incidence *oldIncidence = incidence->clone();
Recurrence *recur = incidence->recurrence();
recur->setEndDate( itemDate.addDays(-1) );
mChanger->changeIncidence( oldIncidence, incidence, KOGlobals::RECURRENCE_MODIFIED_ONE_ONLY, this );
mChanger->endChange( incidence, p.first, p.second );
delete oldIncidence;
}
break;
}
} else {
bool doDelete = true;
if ( !force && KOPrefs::instance()->mConfirm ) {
doDelete = ( msgItemDelete( incidence ) == KMessageBox::Continue );
}
if ( doDelete ) {
mChanger->deleteIncidence( incidence, this );
processIncidenceSelection( 0, TQDate() );
}
}
updateView();
}
void CalendarView::connectIncidenceEditor( KOIncidenceEditor *editor )
{
connect( this, TQ_SIGNAL( newIncidenceChanger( IncidenceChangerBase* ) ),
editor, TQ_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, this ) )
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::warningChangeFailed( Incidence *incidence )
{
if ( incidence ) {
KMessageBox::sorry(
this,
i18n( "Unable to edit \"%1\" because it is locked by another process." ).
arg( incidence->summary() ) );
}
}
void CalendarView::editCanceled( Incidence *incidence )
{
mCalendar->endChange( incidence );
}
void CalendarView::showErrorMessage( const TQString &msg )
{
KMessageBox::error( this, msg );
}
void CalendarView::updateCategories()
{
TQStringList allCats( calendar()->categories() );
allCats.sort();
TQStringList categories( KOPrefs::instance()->mCustomCategories );
for ( TQStringList::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 TQDate &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
TQDateTime start = event->dtStart();
TQDateTime 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);
TQDateTime due = todo->dtDue();
due.setDate( dt );
todo->setDtDue( due );
todo->setHasDueDate( true );
}
TQPair<ResourceCalendar *, TQString>p = viewSubResourceCalendar();
if ( !mChanger->addIncidence( incidence, p.first, p.second, this ) ) {
KODialogManager::errorSaveIncidence( this, incidence );
delete incidence;
}
}
void CalendarView::moveIncidenceTo( Incidence *incmove, const TQDate &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();
TQPair<ResourceCalendar *, TQString>p = viewSubResourceCalendar();
if ( !mChanger->beginChange( incidence, p.first, p.second ) ) {
delete oldIncidence;
return;
}
if ( incidence->type() == "Event" ) {
Event *event = static_cast<Event*>(incidence);
// Adjust date
TQDateTime start = event->dtStart();
TQDateTime 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);
TQDateTime due = todo->dtDue();
due.setDate( dt );
todo->setDtDue( due );
todo->setHasDueDate( true );
}
mChanger->changeIncidence( oldIncidence, incidence, KOGlobals::DATE_MODIFIED,this );
mChanger->endChange( incidence, p.first, p.second );
delete oldIncidence;
}
void CalendarView::resourcesChanged()
{
mViewManager->resourcesChanged();
mDateNavigatorContainer->setUpdateNeeded();
updateView();
}
Incidence* CalendarView::singleOccurrenceOrAll( Incidence *inc,
KOGlobals::OccurrenceAction userAction,
KOGlobals::WhichOccurrences &chosenOption,
const TQDate &itemDate,
const bool commitToCalendar )
{
// temporary, until recurring to-dos are fixed
if ( inc->type() != "Event" ) {
chosenOption = KOGlobals::ALL;
return inc;
}
Incidence *incToReturn = 0;
Incidence *incSaved = 0;
KOGlobals::WhatChanged whatChanged;
bool dissociationOccurred = false;
const TQDate &dt = itemDate.isValid() ? itemDate : activeIncidenceDate();
TQString dialogTitle;
TQString dialogText;
if ( userAction == KOGlobals::CUT ) {
dialogTitle = i18n( "Cutting Recurring Item" );
dialogText = i18n("The item you try to cut is a recurring item. Do you want to cut "
"only this single occurrence, only future items, "
"or all items in the recurrence?");
} else if ( userAction == KOGlobals::COPY ) {
dialogTitle = i18n( "Copying Recurring Item" );
dialogText = i18n("The item you try to copy is a recurring item. Do you want to copy "
"only this single occurrence, only future items, "
"or all items in the recurrence?");
} else {
dialogTitle = i18n( "Changing Recurring Item" );
dialogText = i18n( "The item you try to change is a recurring item. Shall the changes "
"be applied only to this single occurrence, only to the future items, "
"or to all items in the recurrence?" );
}
int res = KOMessageBox::fourBtnMsgBox( this, TQMessageBox::Question,
dialogText,
dialogTitle,
i18n("Only &This Item"), i18n("Only &Future Items"), i18n("&All Occurrences") );
switch ( res ) {
case KMessageBox::Ok: // All occurrences
incToReturn = inc;
chosenOption = KOGlobals::ALL;
break;
case KMessageBox::Yes: { // Just this occurrence
// Dissociate this occurrence:
// create clone of event, set relation to old event, set cloned event
// for mActionItem, add exception date to old event, changeIncidence
// for the old event, remove the recurrence from the new copy and then just
// go on with the newly adjusted mActionItem and let the usual code take
// care of the new time!
chosenOption = KOGlobals::ONLY_THIS_ONE;
whatChanged = KOGlobals::RECURRENCE_MODIFIED_ONE_ONLY;
startMultiModify( i18n("Dissociate event from recurrence") );
incSaved = inc->clone();
incToReturn = mCalendar->dissociateOccurrence( inc, dt );
if ( incToReturn ) {
dissociationOccurred = true;
} else {
KMessageBox::sorry( this, i18n("Unable to add the exception item to the "
"calendar. No change will be done."), i18n("Error Occurred") );
incToReturn = 0;
}
break; }
case KMessageBox::No/*Future*/: { // All future occurrences
// Dissociate this occurrence:
// create clone of event, set relation to old event, set cloned event
// for mActionItem, add recurrence end date to old event, changeIncidence
// for the old event, adjust the recurrence for the new copy and then just
// go on with the newly adjusted mActionItem and let the usual code take
// care of the new time!
chosenOption = KOGlobals::ONLY_FUTURE;
whatChanged = KOGlobals::RECURRENCE_MODIFIED_ALL_FUTURE;
startMultiModify( i18n("Split future recurrences") );
incSaved = inc->clone();
incToReturn = mCalendar->dissociateOccurrence( inc, dt, false );
if ( incToReturn ) {
dissociationOccurred = true;
} else {
KMessageBox::sorry( this, i18n("Unable to add the future items to the "
"calendar. No change will be done."), i18n("Error Occurred") );
incToReturn = 0;
}
break; }
default:
chosenOption = KOGlobals::NONE;
}
if ( dissociationOccurred && commitToCalendar ) {
TQPair<ResourceCalendar *, TQString>p = viewSubResourceCalendar();
mChanger->addIncidence( incToReturn, p.first, p.second, this );
mChanger->changeIncidence( incSaved, inc, whatChanged, this );
}
return incToReturn;
}
void CalendarView::selectWeek( const TQDate &date )
{
if ( KOPrefs::instance()->mWeekNumbersShowWork &&
mViewManager->agendaIsSelected() &&
mViewManager->agendaMode() == KOViewManager::AGENDA_WORK_WEEK ) {
mDateNavigator->selectWorkWeek( date );
} else {
mDateNavigator->selectWeek( date );
}
}
void CalendarView::getIncidenceHierarchy( Incidence *inc,
Incidence::List &children )
{
// protecion against looping hierarchies
if ( inc && !children.contains( inc ) ) {
Incidence::List::ConstIterator it;
Incidence::List immediateChildren = inc->relations();
for ( it = immediateChildren.constBegin(); it != immediateChildren.constEnd(); ++it ) {
getIncidenceHierarchy( *it, children );
}
children.append( inc );
}
}
#include "calendarview.moc"