You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdepim/korganizer/calendarview.cpp

2310 lines
68 KiB

/*
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 <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 );
mNavigator = new DateNavigator( this );
mDateChecker = new DateChecker( this );
TQBoxLayout *topLayout = new TQVBoxLayout( this );
#ifndef KORG_NOSPLITTER
// create the main layout frames.
mPanner = new TQSplitter( TQSplitter::Horizontal, this,
"CalendarView::Panner" );
topLayout->addWidget( mPanner );
mLeftSplitter = new TQSplitter( TQSplitter::Vertical, mPanner,
"CalendarView::LeftFrame" );
// mPanner->setResizeMode( mLeftSplitter, TQSplitter::Stretch );
mDateNavigator = new DateNavigatorContainer( mLeftSplitter,
"CalendarView::DateNavigator" );
// mLeftSplitter->setResizeMode( mDateNavigator, TQSplitter::Stretch );
mLeftSplitter->setCollapsible( mDateNavigator, true );
mTodoList = new KOTodoView( CalendarNull::self(), mLeftSplitter, "todolist" );
mEventViewer = new KOEventViewer( 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 );
mDateNavigator = new KDateNavigator( leftFrame, true,
"CalendarView::DateNavigator",
TQDate::currentDate() );
mTodoList = new KOTodoView( CalendarNull::self(), leftFrame, "todolist" );
mEventViewer = new KOEventViewer ( 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( mDateNavigator->sizeHint().height() );
}
#endif
connect( mNavigator, TQT_SIGNAL( datesSelected( const KCal::DateList & ) ),
TQT_SLOT( showDates( const KCal::DateList & ) ) );
connect( mNavigator, TQT_SIGNAL( datesSelected( const KCal::DateList & ) ),
mDateNavigator, TQT_SLOT( selectDates( const KCal::DateList & ) ) );
connect( mNavigatorBar, TQT_SIGNAL( goPrevYear() ),
mNavigator, TQT_SLOT( selectPreviousYear() ) );
connect( mNavigatorBar, TQT_SIGNAL( goNextYear() ),
mNavigator, TQT_SLOT( selectNextYear() ) );
connect( mNavigatorBar, TQT_SIGNAL( goPrevMonth() ),
mNavigator, TQT_SLOT( selectPreviousMonth() ) );
connect( mNavigatorBar, TQT_SIGNAL( goNextMonth() ),
mNavigator, TQT_SLOT( selectNextMonth() ) );
connect( mNavigatorBar, TQT_SIGNAL( goMonth(int) ),
mNavigator, TQT_SLOT( selectMonth(int) ) );
connect( mNavigator, TQT_SIGNAL( datesSelected( const KCal::DateList & ) ),
mNavigatorBar, TQT_SLOT( selectDates( const KCal::DateList & ) ) );
connect( mDateNavigator, TQT_SIGNAL( weekClicked( const TQDate & ) ),
mNavigator, TQT_SLOT( selectWeek( const TQDate & ) ) );
connect( mDateNavigator, TQT_SIGNAL( goPrevYear() ),
mNavigator, TQT_SLOT( selectPreviousYear() ) );
connect( mDateNavigator, TQT_SIGNAL( goNextYear() ),
mNavigator, TQT_SLOT( selectNextYear() ) );
connect( mDateNavigator, TQT_SIGNAL( goPrevMonth() ),
mNavigator, TQT_SLOT( selectPreviousMonth() ) );
connect( mDateNavigator, TQT_SIGNAL( goNextMonth() ),
mNavigator, TQT_SLOT( selectNextMonth() ) );
connect( mDateNavigator, TQT_SIGNAL( goMonth(int) ),
mNavigator, TQT_SLOT( selectMonth(int) ) );
connect( mDateNavigator, TQT_SIGNAL( goPrevious() ),
mNavigator, TQT_SLOT( selectPrevious() ) );
connect( mDateNavigator, TQT_SIGNAL( goNext() ),
mNavigator, TQT_SLOT( selectNext() ) );
connect( mDateNavigator, TQT_SIGNAL( datesSelected( const KCal::DateList & ) ),
mNavigator, TQT_SLOT( selectDates( const KCal::DateList & ) ) );
connect( mDateNavigator, TQT_SIGNAL(incidenceDropped(Incidence*, const TQDate&)),
TQT_SLOT( addIncidenceOn( Incidence *, const TQDate & ) ) );
connect( mDateNavigator, TQT_SIGNAL(incidenceDroppedMove(Incidence*,const TQDate&)),
TQT_SLOT( moveIncidenceTo( Incidence *, const TQDate & ) ) );
connect( mDateChecker, TQT_SIGNAL( dayPassed( const TQDate & ) ),
mTodoList, TQT_SLOT( dayPassed( const TQDate & ) ) );
connect( mDateChecker, TQT_SIGNAL( dayPassed( const TQDate & ) ),
TQT_SIGNAL( dayPassed( const TQDate & ) ) );
connect( mDateChecker, TQT_SIGNAL( dayPassed( const TQDate & ) ),
mDateNavigator, TQT_SLOT( updateToday() ) );
connect( this, TQT_SIGNAL( configChanged() ),
mDateNavigator, TQT_SLOT( updateConfig() ) );
connect( this, TQT_SIGNAL( incidenceSelected(Incidence *) ),
mEventViewer, TQT_SLOT ( setIncidence (Incidence *) ) );
//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 );
mViewManager->connectTodoView( mTodoList );
mViewManager->connectView( mTodoList );
KOGlobals::self()->
setHolidays( new KHolidays( KOPrefs::instance()->mHolidays ) );
connect( TQApplication::clipboard(), TQT_SIGNAL( dataChanged() ),
TQT_SLOT( checkClipboard() ) );
connect( mTodoList, TQT_SIGNAL( incidenceSelected( Incidence * ) ),
TQT_SLOT( processTodoListSelection( Incidence * ) ) );
disconnect( mTodoList, TQT_SIGNAL( incidenceSelected( Incidence * ) ),
this, TQT_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, TQT_SIGNAL( undone() ), TQT_SLOT( updateView() ) );
connect( mHistory, TQT_SIGNAL( redone() ), TQT_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, TQT_SIGNAL( incidenceAdded( Incidence* ) ),
this, TQT_SLOT( incidenceAdded( Incidence* ) ) );
connect( mChanger, TQT_SIGNAL( incidenceChanged( Incidence*, Incidence*, int ) ),
this, TQT_SLOT( incidenceChanged( Incidence*, Incidence*, int ) ) );
connect( mChanger, TQT_SIGNAL( incidenceChanged( Incidence*, Incidence* ) ),
this, TQT_SLOT( incidenceChanged( Incidence*, Incidence* ) ) );
connect( mChanger, TQT_SIGNAL( incidenceToBeDeleted( Incidence * ) ),
this, TQT_SLOT( incidenceToBeDeleted( Incidence * ) ) );
connect( mChanger, TQT_SIGNAL( incidenceDeleted( Incidence * ) ),
this, TQT_SLOT( incidenceDeleted( Incidence * ) ) );
connect( mChanger, TQT_SIGNAL( schedule( Scheduler::Method, Incidence*) ),
this, TQT_SLOT( schedule( Scheduler::Method, Incidence*) ) );
connect( this, TQT_SIGNAL( cancelAttendees( Incidence * ) ),
mChanger, TQT_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;
}
TQDate CalendarView::startDate()
{
DateList dates = mNavigator->selectedDates();
return dates.first();
}
TQDate CalendarView::endDate()
{
DateList dates = mNavigator->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
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 KConfig, supplying reasonable
// defaults where none are to be found
KConfig *config = KOGlobals::self()->config();
#ifndef KORG_NOSPLITTER
config->setGroup( "KOrganizer Geometry" );
TQValueList<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, TQString( "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" );
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", 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
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( KConfig *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::null );
}
}
void CalendarView::goDate( const TQDate& date )
{
mNavigator->selectDate( date );
}
void CalendarView::showDate(const TQDate & 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 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();
// 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 ) {
TQString timeStr = KGlobal::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 = KGlobal::locale()->formatDate( TQDate::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 TQString &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 TQDate &start, const TQDate &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();
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"),"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
TQDate date;
// create an invalid time to check if we got a new time for the eevent
TQTime time(-1,-1);
TQDateTime 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( TQDateTime &startDt, TQDateTime &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 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->setDates( startDt, endDt, allDay );
mDialogManager->connectTypeAhead( eventEditor, dynamic_cast<KOrg::AgendaView*>(viewManager()->currentView()) );
return eventEditor;
}
void CalendarView::newEvent()
{
kdDebug(5850) << "CalendarView::newEvent()" << endl;
newEvent( TQDateTime(), TQDateTime() );
}
void CalendarView::newEvent( const TQDate &dt )
{
TQDateTime startDt( dt, KOPrefs::instance()->mStartTime.time() );
return newEvent( TQDateTime( dt ), TQDateTime() );
}
void CalendarView::newEvent( const TQDateTime &startDt )
{
return newEvent( startDt, TQDateTime() );
}
void CalendarView::newEvent( const TQDateTime &startDt, const TQDateTime &endDt,
bool allDay )
{
KOEventEditor *eventEditor = newEventEditor( startDt, endDt, allDay );
eventEditor->show();
}
void CalendarView::newEvent( const TQString &summary, const TQString &description,
const TQStringList &attachments, const TQStringList &attendees,
const TQStringList &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 TQString &summary, const TQString &description,
const TQStringList &attachments, const TQStringList &attendees,
const TQStringList &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;
TQDateTime dtDue;
bool allday = true;
KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
connectIncidenceEditor( todoEditor );
todoEditor->newTodo();
if ( mViewManager->currentView()->isEventView() ) {
dtDue.setDate( mNavigator->selectedDates().first() );
TQDateTime dtDummy = TQDateTime::currentDateTime();
mViewManager->currentView()->
eventDurationHint( dtDue, dtDummy, allday );
todoEditor->setDates( dtDue, allday );
}
todoEditor->show();
}
void CalendarView::newTodo( const TQDate &date )
{
KOTodoEditor *todoEditor = mDialogManager->getTodoEditor();
connectIncidenceEditor( todoEditor );
todoEditor->newTodo();
todoEditor->setDates( TQDateTime( date, TQTime::currentTime() ), true );
todoEditor->show();
}
void CalendarView::newJournal()
{
kdDebug(5850) << "CalendarView::newJournal()" << endl;
newJournal( TQString::null, TQDate() );
}
void CalendarView::newJournal( const TQDate &date)
{
newJournal( TQString::null, date );
}
void CalendarView::newJournal( const TQString &text, const TQDate &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( TQDateTime(), false, parentEvent );
todoEditor->show();
}
void CalendarView::newFloatingEvent()
{
DateList tmpList = mNavigator->selectedDates();
TQDate date = tmpList.first();
newEvent( TQDateTime( date, TQTime( 12, 0, 0 ) ),
TQDateTime( date, TQTime( 12, 0, 0 ) ), true );
}
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, 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 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 ) ) {
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 TQDate &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 [FIXME]: Use the same resource instead of asking again!
// See also koagenda.cpp: endItemAction()
bool success = mChanger->addIncidence( newInc, this );
if ( success )
mChanger->changeIncidence( oldincidence, incidence );
} else {
KMessageBox::sorry( this, i18n("Dissociating the occurrence failed."),
i18n("Dissociating Failed") );
}
mChanger->endChange( incidence );
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;
}
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() == 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 == 0)
incidence = selectedIncidence();
if (!incidence) {
KMessageBox::information( this, i18n("No item selected."),
"ForwardNoEventSelected" );
return;
}
PublishDialog publishdlg;
if ( publishdlg.exec() == TQDialog::Accepted ) {
TQString recipients = publishdlg.addresses();
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() ) );
}
}
}
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: "
<< KGlobal::locale()->formatDateTime( start ) << " End Date: "
<< KGlobal::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, TQT_SIGNAL(configChanged()), &printer, TQT_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, TQT_SIGNAL( exportHTML( HTMLExportSettings* ) ),
this, TQT_SIGNAL( exportHTML( HTMLExportSettings* ) ) );
dlg->show();
}
void CalendarView::exportICalendar()
{
TQString 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;
}
TQString 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(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)
{
// 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()
{
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 )
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 TQString& 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() ) {
TQDate 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, 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( 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();
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);
QDateTime newEnd;
QDateTime 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 );
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 );
}
}
updateView();
}
void CalendarView::connectIncidenceEditor( KOIncidenceEditor *editor )
{
connect( this, TQT_SIGNAL( newIncidenceChanger( IncidenceChangerBase* ) ),
editor, TQT_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;
}
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 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 );
}
if ( !mChanger->addIncidence( incidence, 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();
if ( !mChanger->beginChange( incidence ) ) {
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 );
mChanger->endChange( incidence );
delete oldIncidence;
}
void CalendarView::resourcesChanged()
{
mViewManager->resourcesChanged();
updateView();
}
#include "calendarview.moc"