From 460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- korganizer/actionmanager.cpp | 1956 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1956 insertions(+) create mode 100644 korganizer/actionmanager.cpp (limited to 'korganizer/actionmanager.cpp') diff --git a/korganizer/actionmanager.cpp b/korganizer/actionmanager.cpp new file mode 100644 index 000000000..4a900abd3 --- /dev/null +++ b/korganizer/actionmanager.cpp @@ -0,0 +1,1956 @@ +/* + This file is part of KOrganizer. + + Copyright (c) 2002 Mike Pilone + Copyright (c) 2002 Don Sanders + Copyright (c) 2004 Cornelius Schumacher + Copyright (C) 2004 Reinhold Kainhofer + + 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 "actionmanager.h" + +#include "alarmclient.h" +#include "calendarview.h" +#include "kocore.h" +#include "kodialogmanager.h" +#include "koglobals.h" +#include "koprefs.h" +#include "koviewmanager.h" +#include "kowindowlist.h" +#include "kprocess.h" +#include "konewstuff.h" +#include "history.h" +#include "kogroupware.h" +#include "resourceview.h" +#include "importdialog.h" +#include "eventarchiver.h" +#include "stdcalendar.h" +#include "freebusymanager.h" + +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + + +// FIXME: Several places in the file don't use KConfigXT yet! +KOWindowList *ActionManager::mWindowList = 0; + +ActionManager::ActionManager( KXMLGUIClient *client, CalendarView *widget, + QObject *parent, KOrg::MainWindow *mainWindow, + bool isPart ) + : QObject( parent ), KCalendarIface(), mRecent( 0 ), + mResourceButtonsAction( 0 ), mResourceViewShowAction( 0 ), mCalendar( 0 ), + mCalendarResources( 0 ), mResourceView( 0 ), mIsClosing( false ) +{ + mGUIClient = client; + mACollection = mGUIClient->actionCollection(); + mCalendarView = widget; + mIsPart = isPart; + mTempFile = 0; + mNewStuff = 0; + mHtmlExportSync = false; + mMainWindow = mainWindow; +} + +ActionManager::~ActionManager() +{ + delete mNewStuff; + + // Remove Part plugins + KOCore::self()->unloadParts( mMainWindow, mParts ); + + delete mTempFile; + + // Take this window out of the window list. + mWindowList->removeWindow( mMainWindow ); + + delete mCalendarView; + + delete mCalendar; + + kdDebug(5850) << "~ActionManager() done" << endl; +} + +// see the Note: below for why this method is necessary +void ActionManager::init() +{ + // Construct the groupware object + KOGroupware::create( mCalendarView, mCalendarResources ); + + // add this instance of the window to the static list. + if ( !mWindowList ) { + mWindowList = new KOWindowList; + // Show tip of the day, when the first calendar is shown. + if ( !mIsPart ) + QTimer::singleShot( 0, this, SLOT( showTipOnStart() ) ); + } + // Note: We need this ActionManager to be fully constructed, and + // parent() to have a valid reference to it before the following + // addWindow is called. + mWindowList->addWindow( mMainWindow ); + + initActions(); + + // set up autoSaving stuff + mAutoSaveTimer = new QTimer( this ); + connect( mAutoSaveTimer,SIGNAL( timeout() ), SLOT( checkAutoSave() ) ); + if ( KOPrefs::instance()->mAutoSave && + KOPrefs::instance()->mAutoSaveInterval > 0 ) { + mAutoSaveTimer->start( 1000 * 60 * KOPrefs::instance()->mAutoSaveInterval ); + } + + mAutoArchiveTimer = new QTimer( this ); + connect( mAutoArchiveTimer, SIGNAL( timeout() ), SLOT( slotAutoArchive() ) ); + // First auto-archive should be in 5 minutes (like in kmail). + if ( KOPrefs::instance()->mAutoArchive ) + mAutoArchiveTimer->start( 5 * 60 * 1000, true ); // singleshot + + setTitle(); + + connect( mCalendarView, SIGNAL( modifiedChanged( bool ) ), SLOT( setTitle() ) ); + connect( mCalendarView, SIGNAL( configChanged() ), SLOT( updateConfig() ) ); + + connect( mCalendarView, SIGNAL( incidenceSelected( Incidence * ) ), + this, SLOT( processIncidenceSelection( Incidence * ) ) ); + connect( mCalendarView, SIGNAL( exportHTML( HTMLExportSettings * ) ), + this, SLOT( exportHTML( HTMLExportSettings * ) ) ); + + processIncidenceSelection( 0 ); + + // Update state of paste action + mCalendarView->checkClipboard(); +} + +void ActionManager::createCalendarLocal() +{ + mCalendar = new CalendarLocal( KOPrefs::instance()->mTimeZoneId ); + mCalendarView->setCalendar( mCalendar ); + mCalendarView->readSettings(); + + initCalendar( mCalendar ); +} + +void ActionManager::createCalendarResources() +{ + mCalendarResources = KOrg::StdCalendar::self(); + + CalendarResourceManager *manager = mCalendarResources->resourceManager(); + + kdDebug(5850) << "CalendarResources used by KOrganizer:" << endl; + CalendarResourceManager::Iterator it; + for( it = manager->begin(); it != manager->end(); ++it ) { + kdDebug(5850) << " " << (*it)->resourceName() << endl; + (*it)->setResolveConflict( true ); +// (*it)->dump(); + } + + setDestinationPolicy(); + + mCalendarView->setCalendar( mCalendarResources ); + mCalendarView->readSettings(); + + ResourceViewFactory factory( mCalendarResources, mCalendarView ); + mCalendarView->addExtension( &factory ); + mResourceView = factory.resourceView(); + + connect( mCalendarResources, SIGNAL( calendarChanged() ), + mCalendarView, SLOT( slotCalendarChanged() ) ); + connect( mCalendarResources, SIGNAL( signalErrorMessage( const QString & ) ), + mCalendarView, SLOT( showErrorMessage( const QString & ) ) ); + + connect( mCalendarView, SIGNAL( configChanged() ), + SLOT( updateConfig() ) ); + + initCalendar( mCalendarResources ); +} + +void ActionManager::initCalendar( Calendar *cal ) +{ + cal->setOwner( Person( KOPrefs::instance()->fullName(), + KOPrefs::instance()->email() ) ); + // setting fullName and email do not really count as modifying the calendar + mCalendarView->setModified( false ); +} + +void ActionManager::initActions() +{ + KAction *action; + + + //*************************** FILE MENU ********************************** + + //~~~~~~~~~~~~~~~~~~~~~~~ LOADING / SAVING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + if ( mIsPart ) { + if ( mMainWindow->hasDocument() ) { + KStdAction::openNew( this, SLOT(file_new()), mACollection, "korganizer_openNew" ); + KStdAction::open( this, SLOT( file_open() ), mACollection, "korganizer_open" ); + mRecent = KStdAction::openRecent( this, SLOT( file_open( const KURL& ) ), + mACollection, "korganizer_openRecent" ); + KStdAction::revert( this,SLOT( file_revert() ), mACollection, "korganizer_revert" ); + KStdAction::saveAs( this, SLOT( file_saveas() ), mACollection, + "korganizer_saveAs" ); + KStdAction::save( this, SLOT( file_save() ), mACollection, "korganizer_save" ); + } + KStdAction::print( mCalendarView, SLOT( print() ), mACollection, "korganizer_print" ); + } else { + KStdAction::openNew( this, SLOT( file_new() ), mACollection ); + KStdAction::open( this, SLOT( file_open() ), mACollection ); + mRecent = KStdAction::openRecent( this, SLOT( file_open( const KURL& ) ), + mACollection ); + if ( mMainWindow->hasDocument() ) { + KStdAction::revert( this,SLOT( file_revert() ), mACollection ); + KStdAction::save( this, SLOT( file_save() ), mACollection ); + KStdAction::saveAs( this, SLOT( file_saveas() ), mACollection ); + } + KStdAction::print( mCalendarView, SLOT( print() ), mACollection ); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~ IMPORT / EXPORT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + new KAction( i18n("Import &Calendar..."), 0, this, SLOT( file_merge() ), + mACollection, "import_icalendar" ); + new KAction( i18n("&Import From UNIX Ical tool"), 0, this, SLOT( file_icalimport() ), + mACollection, "import_ical" ); + new KAction( i18n("Get &Hot New Stuff..."), 0, this, + SLOT( downloadNewStuff() ), mACollection, + "downloadnewstuff" ); + + new KAction( i18n("Export &Web Page..."), "webexport", 0, + mCalendarView, SLOT( exportWeb() ), + mACollection, "export_web" ); + new KAction( i18n("&iCalendar..."), 0, + mCalendarView, SLOT( exportICalendar() ), + mACollection, "export_icalendar" ); + new KAction( i18n("&vCalendar..."), 0, + mCalendarView, SLOT( exportVCalendar() ), + mACollection, "export_vcalendar" ); + new KAction( i18n("Upload &Hot New Stuff..."), 0, this, + SLOT( uploadNewStuff() ), mACollection, + "uploadnewstuff" ); + + + + new KAction( i18n("Archive O&ld Entries..."), 0, this, SLOT( file_archive() ), + mACollection, "file_archive" ); + new KAction( i18n("delete completed to-dos", "Pur&ge Completed To-dos"), 0, + mCalendarView, SLOT( purgeCompleted() ), mACollection, + "purge_completed" ); + + + + + //************************** EDIT MENU ********************************* + KAction *pasteAction; + KOrg::History *h = mCalendarView->history(); + if ( mIsPart ) { + // edit menu + mCutAction = KStdAction::cut( mCalendarView, SLOT( edit_cut() ), + mACollection, "korganizer_cut" ); + mCopyAction = KStdAction::copy( mCalendarView, SLOT( edit_copy() ), + mACollection, "korganizer_copy" ); + pasteAction = KStdAction::paste( mCalendarView, SLOT( edit_paste() ), + mACollection, "korganizer_paste" ); + mUndoAction = KStdAction::undo( h, SLOT( undo() ), + mACollection, "korganizer_undo" ); + mRedoAction = KStdAction::redo( h, SLOT( redo() ), + mACollection, "korganizer_redo" ); + } else { + mCutAction = KStdAction::cut( mCalendarView,SLOT( edit_cut() ), + mACollection ); + mCopyAction = KStdAction::copy( mCalendarView,SLOT( edit_copy() ), + mACollection ); + pasteAction = KStdAction::paste( mCalendarView,SLOT( edit_paste() ), + mACollection ); + mUndoAction = KStdAction::undo( h, SLOT( undo() ), mACollection ); + mRedoAction = KStdAction::redo( h, SLOT( redo() ), mACollection ); + } + mDeleteAction = new KAction( i18n("&Delete"), "editdelete", 0, + mCalendarView, SLOT( appointment_delete() ), + mACollection, "edit_delete" ); + if ( mIsPart ) { + KStdAction::find( mCalendarView->dialogManager(), SLOT( showSearchDialog() ), + mACollection, "korganizer_find" ); + } else { + KStdAction::find( mCalendarView->dialogManager(), SLOT( showSearchDialog() ), + mACollection ); + } + pasteAction->setEnabled( false ); + mUndoAction->setEnabled( false ); + mRedoAction->setEnabled( false ); + connect( mCalendarView, SIGNAL( pasteEnabled( bool ) ), + pasteAction, SLOT( setEnabled( bool ) ) ); + connect( h, SIGNAL( undoAvailable( const QString & ) ), + SLOT( updateUndoAction( const QString & ) ) ); + connect( h, SIGNAL( redoAvailable( const QString & ) ), + SLOT( updateRedoAction( const QString & ) ) ); + + + + + //************************** VIEW MENU ********************************* + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~ VIEWS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + new KAction( i18n("What's &Next"), + KOGlobals::self()->smallIcon( "whatsnext" ), 0, + mCalendarView->viewManager(), SLOT( showWhatsNextView() ), + mACollection, "view_whatsnext" ); + new KAction( i18n("&Day"), + KOGlobals::self()->smallIcon( "1day" ), 0, + mCalendarView->viewManager(), SLOT( showDayView() ), + mACollection, "view_day" ); + mNextXDays = new KAction( "", + KOGlobals::self()->smallIcon( "xdays" ), 0, + mCalendarView->viewManager(), + SLOT( showNextXView() ), + mACollection, "view_nextx" ); + mNextXDays->setText( i18n( "&Next Day", "Ne&xt %n Days", + KOPrefs::instance()->mNextXDays ) ); + new KAction( i18n("W&ork Week"), + KOGlobals::self()->smallIcon( "5days" ), 0, + mCalendarView->viewManager(), SLOT( showWorkWeekView() ), + mACollection, "view_workweek" ); + new KAction( i18n("&Week"), + KOGlobals::self()->smallIcon( "7days" ), 0, + mCalendarView->viewManager(), SLOT( showWeekView() ), + mACollection, "view_week" ); + new KAction( i18n("&Month"), + KOGlobals::self()->smallIcon( "month" ), 0, + mCalendarView->viewManager(), SLOT( showMonthView() ), + mACollection, "view_month" ); + new KAction( i18n("&List"), + KOGlobals::self()->smallIcon( "list" ), 0, + mCalendarView->viewManager(), SLOT( showListView() ), + mACollection, "view_list" ); + new KAction( i18n("&To-do List"), + KOGlobals::self()->smallIcon( "todo" ), 0, + mCalendarView->viewManager(), SLOT( showTodoView() ), + mACollection, "view_todo" ); + new KAction( i18n("&Journal"), + KOGlobals::self()->smallIcon( "journal" ), 0, + mCalendarView->viewManager(), SLOT( showJournalView() ), + mACollection, "view_journal" ); + new KAction( i18n("&Timeline View"), + KOGlobals::self()->smallIcon( "timeline" ), 0, + mCalendarView->viewManager(), SLOT( showTimelineView() ), + mACollection, "view_timeline" ); + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~ FILTERS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + new KAction( i18n("&Refresh"), 0, + mCalendarView, SLOT( updateView() ), + mACollection, "update" ); +// TODO: +// new KAction( i18n("Hide &Completed To-dos"), 0, +// mCalendarView, SLOT( toggleHideCompleted() ), +// mACollection, "hide_completed_todos" ); + + mFilterAction = new KSelectAction( i18n("F&ilter"), 0, + mACollection, "filter_select" ); + mFilterAction->setEditable( false ); + connect( mFilterAction, SIGNAL( activated(int) ), + mCalendarView, SLOT( filterActivated( int ) ) ); + connect( mCalendarView, SIGNAL( newFilterListSignal( const QStringList & ) ), + mFilterAction, SLOT( setItems( const QStringList & ) ) ); + connect( mCalendarView, SIGNAL( selectFilterSignal( int ) ), + mFilterAction, SLOT( setCurrentItem( int ) ) ); + connect( mCalendarView, SIGNAL( filterChanged() ), + this, SLOT( setTitle() ) ); + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ZOOM ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + // TODO: try to find / create better icons for the following 4 actions + new KAction( i18n( "Zoom In Horizontally" ), "viewmag+", 0, + mCalendarView->viewManager(), SLOT( zoomInHorizontally() ), + mACollection, "zoom_in_horizontally" ); + new KAction( i18n( "Zoom Out Horizontally" ), "viewmag-", 0, + mCalendarView->viewManager(), SLOT( zoomOutHorizontally() ), + mACollection, "zoom_out_horizontally" ); + new KAction( i18n( "Zoom In Vertically" ), "viewmag+", 0, + mCalendarView->viewManager(), SLOT( zoomInVertically() ), + mACollection, "zoom_in_vertically" ); + new KAction( i18n( "Zoom Out Vertically" ), "viewmag-", 0, + mCalendarView->viewManager(), SLOT( zoomOutVertically() ), + mACollection, "zoom_out_vertically" ); + + + + + //************************** Actions MENU ********************************* + + new KAction( i18n("Go to &Today"), "today", 0, + mCalendarView,SLOT( goToday() ), + mACollection, "go_today" ); + bool isRTL = QApplication::reverseLayout(); + action = new KAction( i18n("Go &Backward"), isRTL ? "forward" : "back", 0, + mCalendarView,SLOT( goPrevious() ), + mACollection, "go_previous" ); + + // Changing the action text by setText makes the toolbar button disappear. + // This has to be fixed first, before the connects below can be reenabled. + /* + connect( mCalendarView, SIGNAL( changeNavStringPrev( const QString & ) ), + action, SLOT( setText( const QString & ) ) ); + connect( mCalendarView, SIGNAL( changeNavStringPrev( const QString & ) ), + this, SLOT( dumpText( const QString & ) ) );*/ + + action = new KAction( i18n("Go &Forward"), isRTL ? "back" : "forward", 0, + mCalendarView,SLOT( goNext() ), + mACollection, "go_next" ); + /* + connect( mCalendarView,SIGNAL( changeNavStringNext( const QString & ) ), + action,SLOT( setText( const QString & ) ) ); + */ + + + //************************** Actions MENU ********************************* + new KAction( i18n("New E&vent..."), + KOGlobals::self()->smallIcon( "newappointment" ), 0, + mCalendarView, SLOT( newEvent() ), + mACollection, "new_event" ); + new KAction( i18n("New &To-do..."), + KOGlobals::self()->smallIcon( "newtodo" ), 0, + mCalendarView, SLOT( newTodo() ), + mACollection, "new_todo" ); + action = new KAction( i18n("New Su&b-to-do..."), 0, + mCalendarView,SLOT( newSubTodo() ), + mACollection, "new_subtodo" ); + action->setEnabled( false ); + connect( mCalendarView,SIGNAL( todoSelected( bool ) ), + action,SLOT( setEnabled( bool ) ) ); + new KAction( i18n("New &Journal..."), + KOGlobals::self()->smallIcon( "newjournal" ), 0, + mCalendarView, SLOT( newJournal() ), + mACollection, "new_journal" ); + + mShowIncidenceAction = new KAction( i18n("&Show"), 0, + mCalendarView,SLOT( showIncidence() ), + mACollection, "show_incidence" ); + mEditIncidenceAction = new KAction( i18n("&Edit..."), 0, + mCalendarView,SLOT( editIncidence() ), + mACollection, "edit_incidence" ); + mDeleteIncidenceAction = new KAction( i18n("&Delete"), Key_Delete, + mCalendarView,SLOT( deleteIncidence()), + mACollection, "delete_incidence" ); + + action = new KAction( i18n("&Make Sub-to-do Independent"), 0, + mCalendarView,SLOT( todo_unsub() ), + mACollection, "unsub_todo" ); + action->setEnabled( false ); + connect( mCalendarView,SIGNAL( subtodoSelected( bool ) ), + action,SLOT( setEnabled( bool ) ) ); +// TODO: Add item to move the incidence to different resource +// mAssignResourceAction = new KAction( i18n("Assign &Resource..."), 0, +// mCalendarView, SLOT( assignResource()), +// mACollection, "assign_resource" ); +// TODO: Add item to quickly toggle the reminder of a given incidence +// mToggleAlarmAction = new KToggleAction( i18n("&Activate Reminder"), 0, +// mCalendarView, SLOT( toggleAlarm()), +// mACollection, "activate_alarm" ); + + + + + //************************** SCHEDULE MENU ******************************** + mPublishEvent = new KAction( i18n("&Publish Item Information..."), "mail_send", 0, + mCalendarView, SLOT( schedule_publish() ), + mACollection, "schedule_publish" ); + mPublishEvent->setEnabled( false ); + + action = new KAction( i18n("Send &Invitation to Attendees"),"mail_generic",0, + mCalendarView,SLOT( schedule_request() ), + mACollection,"schedule_request" ); + action->setEnabled( false ); + connect( mCalendarView, SIGNAL( organizerEventsSelected( bool ) ), + action, SLOT( setEnabled( bool ) ) ); + + action = new KAction( i18n("Re&quest Update"), 0, + mCalendarView, SLOT( schedule_refresh() ), + mACollection, "schedule_refresh" ); + action->setEnabled( false ); + connect( mCalendarView,SIGNAL( groupEventsSelected( bool ) ), + action,SLOT( setEnabled( bool ) ) ); + + action = new KAction( i18n("Send &Cancelation to Attendees"), 0, + mCalendarView, SLOT( schedule_cancel() ), + mACollection, "schedule_cancel" ); + action->setEnabled( false ); + connect( mCalendarView,SIGNAL( organizerEventsSelected( bool ) ), + action,SLOT( setEnabled( bool ) ) ); + + action = new KAction( i18n("Send Status &Update"),"mail_reply",0, + mCalendarView,SLOT( schedule_reply() ), + mACollection,"schedule_reply" ); + action->setEnabled( false ); + connect( mCalendarView,SIGNAL( groupEventsSelected( bool ) ), + action,SLOT( setEnabled( bool ) ) ); + + action = new KAction( i18n("counter proposal","Request Chan&ge"),0, + mCalendarView,SLOT( schedule_counter() ), + mACollection, "schedule_counter" ); + action->setEnabled( false ); + connect( mCalendarView,SIGNAL( groupEventsSelected( bool ) ), + action,SLOT( setEnabled( bool ) ) ); + + mForwardEvent = new KAction( i18n("&Send as iCalendar..."), "mail_forward", 0, + mCalendarView, SLOT(schedule_forward()), + mACollection, "schedule_forward" ); + mForwardEvent->setEnabled( false ); + + action = new KAction( i18n("&Mail Free Busy Information..."), 0, + mCalendarView, SLOT( mailFreeBusy() ), + mACollection, "mail_freebusy" ); + action->setEnabled( true ); + + action = new KAction( i18n("&Upload Free Busy Information"), 0, + mCalendarView, SLOT( uploadFreeBusy() ), + mACollection, "upload_freebusy" ); + action->setEnabled( true ); + + if ( !mIsPart ) { + action = new KAction( i18n("&Addressbook"),"contents",0, + mCalendarView,SLOT( openAddressbook() ), + mACollection,"addressbook" ); + } + + + + + //************************** SETTINGS MENU ******************************** + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SIDEBAR ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + mDateNavigatorShowAction = new KToggleAction( i18n("Show Date Navigator"), 0, + this, SLOT( toggleDateNavigator() ), + mACollection, "show_datenavigator" ); + mTodoViewShowAction = new KToggleAction ( i18n("Show To-do View"), 0, + this, SLOT( toggleTodoView() ), + mACollection, "show_todoview" ); + mEventViewerShowAction = new KToggleAction ( i18n("Show Item Viewer"), 0, + this, SLOT( toggleEventViewer() ), + mACollection, "show_eventviewer" ); + KConfig *config = KOGlobals::self()->config(); + config->setGroup( "Settings" ); + mDateNavigatorShowAction->setChecked( + config->readBoolEntry( "DateNavigatorVisible", true ) ); + // if we are a kpart, then let's not show the todo in the left pane by + // default since there's also a Todo part and we'll assume they'll be + // using that as well, so let's not duplicate it (by default) here + mTodoViewShowAction->setChecked( + config->readBoolEntry( "TodoViewVisible", mIsPart ? false : true ) ); + mEventViewerShowAction->setChecked( + config->readBoolEntry( "EventViewerVisible", true ) ); + toggleDateNavigator(); + toggleTodoView(); + toggleEventViewer(); + + if ( !mMainWindow->hasDocument() ) { + mResourceViewShowAction = new KToggleAction ( i18n("Show Resource View"), 0, + this, SLOT( toggleResourceView() ), + mACollection, "show_resourceview" ); + mResourceButtonsAction = new KToggleAction( i18n("Show &Resource Buttons"), 0, + this, SLOT( toggleResourceButtons() ), + mACollection, "show_resourcebuttons" ); + mResourceViewShowAction->setChecked( + config->readBoolEntry( "ResourceViewVisible", true ) ); + mResourceButtonsAction->setChecked( + config->readBoolEntry( "ResourceButtonsVisible", true ) ); + + toggleResourceView(); + toggleResourceButtons(); + } + + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SIDEBAR ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + new KAction( i18n("Configure &Date && Time..."), 0, + this, SLOT( configureDateTime() ), + mACollection, "conf_datetime" ); +// TODO: Add an item to show the resource management dlg +// new KAction( i18n("Manage &Resources..."), 0, +// this, SLOT( manageResources() ), +// mACollection, "conf_resources" ); + new KAction( i18n("Manage View &Filters..."), "configure", 0, + mCalendarView, SLOT( editFilters() ), + mACollection, "edit_filters" ); + new KAction( i18n("Manage C&ategories..."), 0, + mCalendarView->dialogManager(), SLOT( showCategoryEditDialog() ), + mACollection, "edit_categories" ); + if ( mIsPart ) { + new KAction( i18n("&Configure Calendar..."), "configure", 0, + mCalendarView, SLOT( edit_options() ), + mACollection, "korganizer_configure" ); + KStdAction::keyBindings( this, SLOT( keyBindings() ), + mACollection, "korganizer_configure_shortcuts" ); + } else { + KStdAction::preferences( mCalendarView, SLOT( edit_options() ), + mACollection ); + KStdAction::keyBindings( this, SLOT( keyBindings() ), mACollection ); + } + + + + + //**************************** HELP MENU ********************************** + KStdAction::tipOfDay( this, SLOT( showTip() ), mACollection, + "help_tipofday" ); +// new KAction( i18n("Show Intro Page"), 0, +// mCalendarView,SLOT( showIntro() ), +// mACollection,"show_intro" ); + + + + + //************************* TOOLBAR ACTIONS ******************************* + QLabel *filterLabel = new QLabel( i18n("Filter: "), mCalendarView ); + filterLabel->hide(); + new KWidgetAction( filterLabel, i18n("Filter: "), 0, 0, 0, + mACollection, "filter_label" ); + +} + +void ActionManager::readSettings() +{ + // read settings from the KConfig, supplying reasonable + // defaults where none are to be found + + KConfig *config = KOGlobals::self()->config(); + if ( mRecent ) mRecent->loadEntries( config ); + mCalendarView->readSettings(); +} + +void ActionManager::writeSettings() +{ + kdDebug(5850) << "ActionManager::writeSettings" << endl; + + KConfig *config = KOGlobals::self()->config(); + mCalendarView->writeSettings(); + + config->setGroup( "Settings" ); + if ( mResourceButtonsAction ) { + config->writeEntry( "ResourceButtonsVisible", + mResourceButtonsAction->isChecked() ); + } + if ( mDateNavigatorShowAction ) { + config->writeEntry( "DateNavigatorVisible", + mDateNavigatorShowAction->isChecked() ); + } + if ( mTodoViewShowAction ) { + config->writeEntry( "TodoViewVisible", + mTodoViewShowAction->isChecked() ); + } + if ( mResourceViewShowAction ) { + config->writeEntry( "ResourceViewVisible", + mResourceViewShowAction->isChecked() ); + } + if ( mEventViewerShowAction ) { + config->writeEntry( "EventViewerVisible", + mEventViewerShowAction->isChecked() ); + } + + if ( mRecent ) mRecent->saveEntries( config ); + + config->sync(); + + if ( mCalendarResources ) { + mCalendarResources->resourceManager()->writeConfig(); + } +} + +void ActionManager::file_new() +{ + emit actionNew(); +} + +void ActionManager::file_open() +{ + KURL url; + QString defaultPath = locateLocal( "data","korganizer/" ); + url = KFileDialog::getOpenURL( defaultPath,i18n("*.vcs *.ics|Calendar Files"), + dialogParent() ); + + file_open( url ); +} + +void ActionManager::file_open( const KURL &url ) +{ + if ( url.isEmpty() ) return; + + // is that URL already opened somewhere else? Activate that window + KOrg::MainWindow *korg=ActionManager::findInstance( url ); + if ( ( 0 != korg )&&( korg != mMainWindow ) ) { + KWin::setActiveWindow( korg->topLevelWidget()->winId() ); + return; + } + + kdDebug(5850) << "ActionManager::file_open(): " << url.prettyURL() << endl; + + // Open the calendar file in the same window only if we have an empty calendar window, and not the resource calendar + if ( !mCalendarView->isModified() && mFile.isEmpty() && !mCalendarResources ) { + openURL( url ); + } else { + emit actionNew( url ); + } +} + +void ActionManager::file_icalimport() +{ + // FIXME: eventually, we will need a dialog box to select import type, etc. + // for now, hard-coded to ical file, $HOME/.calendar. + int retVal = -1; + QString progPath; + KTempFile tmpfn; + + QString homeDir = QDir::homeDirPath() + QString::fromLatin1( "/.calendar" ); + + if ( !QFile::exists( homeDir ) ) { + KMessageBox::error( dialogParent(), + i18n( "You have no ical file in your home directory.\n" + "Import cannot proceed.\n" ) ); + return; + } + + KProcess proc; + proc << "ical2vcal" << tmpfn.name(); + bool success = proc.start( KProcess::Block ); + + if ( !success ) { + kdDebug(5850) << "Error starting ical2vcal." << endl; + return; + } else { + retVal = proc.exitStatus(); + } + + kdDebug(5850) << "ical2vcal return value: " << retVal << endl; + + if ( retVal >= 0 && retVal <= 2 ) { + // now we need to MERGE what is in the iCal to the current calendar. + mCalendarView->openCalendar( tmpfn.name(),1 ); + if ( !retVal ) + KMessageBox::information( dialogParent(), + i18n( "KOrganizer successfully imported and " + "merged your .calendar file from ical " + "into the currently opened calendar." ), + "dotCalendarImportSuccess" ); + else + KMessageBox::information( dialogParent(), + i18n( "KOrganizer encountered some unknown fields while " + "parsing your .calendar ical file, and had to " + "discard them; please check to see that all " + "your relevant data was correctly imported." ), + i18n("ICal Import Successful with Warning") ); + } else if ( retVal == -1 ) { + KMessageBox::error( dialogParent(), + i18n( "KOrganizer encountered an error parsing your " + ".calendar file from ical; import has failed." ) ); + } else if ( retVal == -2 ) { + KMessageBox::error( dialogParent(), + i18n( "KOrganizer does not think that your .calendar " + "file is a valid ical calendar; import has failed." ) ); + } + tmpfn.unlink(); +} + +void ActionManager::file_merge() +{ + KURL url = KFileDialog::getOpenURL( locateLocal( "data","korganizer/" ), + i18n("*.vcs *.ics|Calendar Files"), + dialogParent() ); + if ( ! url.isEmpty() ) // isEmpty if user cancelled the dialog + importCalendar( url ); +} + +void ActionManager::file_archive() +{ + mCalendarView->archiveCalendar(); +} + +void ActionManager::file_revert() +{ + openURL( mURL ); +} + +void ActionManager::file_saveas() +{ + KURL url = getSaveURL(); + + if ( url.isEmpty() ) return; + + saveAsURL( url ); +} + +void ActionManager::file_save() +{ + if ( mMainWindow->hasDocument() ) { + if ( mURL.isEmpty() ) { + file_saveas(); + return; + } else { + saveURL(); + } + } else { + mCalendarView->calendar()->save(); + } + + // export to HTML + if ( KOPrefs::instance()->mHtmlWithSave ) { + exportHTML(); + } +} + +void ActionManager::file_close() +{ + if ( !saveModifiedURL() ) return; + + mCalendarView->closeCalendar(); + KIO::NetAccess::removeTempFile( mFile ); + mURL=""; + mFile=""; + + setTitle(); +} + +bool ActionManager::openURL( const KURL &url,bool merge ) +{ + kdDebug(5850) << "ActionManager::openURL()" << endl; + + if ( url.isEmpty() ) { + kdDebug(5850) << "ActionManager::openURL(): Error! Empty URL." << endl; + return false; + } + if ( !url.isValid() ) { + kdDebug(5850) << "ActionManager::openURL(): Error! URL is malformed." << endl; + return false; + } + + if ( url.isLocalFile() ) { + mURL = url; + mFile = url.path(); + if ( !KStandardDirs::exists( mFile ) ) { + mMainWindow->showStatusMessage( i18n("New calendar '%1'.") + .arg( url.prettyURL() ) ); + mCalendarView->setModified(); + } else { + bool success = mCalendarView->openCalendar( mFile, merge ); + if ( success ) { + showStatusMessageOpen( url, merge ); + } + } + setTitle(); + } else { + QString tmpFile; + if( KIO::NetAccess::download( url, tmpFile, view() ) ) { + kdDebug(5850) << "--- Downloaded to " << tmpFile << endl; + bool success = mCalendarView->openCalendar( tmpFile, merge ); + if ( merge ) { + KIO::NetAccess::removeTempFile( tmpFile ); + if ( success ) + showStatusMessageOpen( url, merge ); + } else { + if ( success ) { + KIO::NetAccess::removeTempFile( mFile ); + mURL = url; + mFile = tmpFile; + KConfig *config = KOGlobals::self()->config(); + config->setGroup( "General" ); + setTitle(); + kdDebug(5850) << "-- Add recent URL: " << url.prettyURL() << endl; + if ( mRecent ) mRecent->addURL( url ); + showStatusMessageOpen( url, merge ); + } + } + return success; + } else { + QString msg; + msg = i18n("Cannot download calendar from '%1'.").arg( url.prettyURL() ); + KMessageBox::error( dialogParent(), msg ); + return false; + } + } + return true; +} + +bool ActionManager::addResource( const KURL &mUrl ) +{ + CalendarResources *cr = KOrg::StdCalendar::self(); + + CalendarResourceManager *manager = cr->resourceManager(); + + ResourceCalendar *resource = 0; + + QString name; + + kdDebug(5850) << "URL: " << mUrl << endl; + if ( mUrl.isLocalFile() ) { + kdDebug(5850) << "Local Resource" << endl; + resource = manager->createResource( "file" ); + if ( resource ) + resource->setValue( "File", mUrl.path() ); + name = mUrl.path(); + } else { + kdDebug(5850) << "Remote Resource" << endl; + resource = manager->createResource( "remote" ); + if ( resource ) + resource->setValue( "DownloadURL", mUrl.url() ); + name = mUrl.prettyURL(); + resource->setReadOnly( true ); + } + + if ( resource ) { + resource->setTimeZoneId( KOPrefs::instance()->mTimeZoneId ); + resource->setResourceName( name ); + manager->add( resource ); + mMainWindow->showStatusMessage( i18n( "Added calendar resource for URL '%1'." ) + .arg( name ) ); + // we have to call resourceAdded manually, because for in-process changes + // the dcop signals are not connected, so the resource's signals would not + // be connected otherwise + if ( mCalendarResources ) + mCalendarResources->resourceAdded( resource ); + } else { + QString msg = i18n("Unable to create calendar resource '%1'.") + .arg( name ); + KMessageBox::error( dialogParent(), msg ); + } + return true; +} + + +void ActionManager::showStatusMessageOpen( const KURL &url, bool merge ) +{ + if ( merge ) { + mMainWindow->showStatusMessage( i18n("Merged calendar '%1'.") + .arg( url.prettyURL() ) ); + } else { + mMainWindow->showStatusMessage( i18n("Opened calendar '%1'.") + .arg( url.prettyURL() ) ); + } +} + +void ActionManager::closeURL() +{ + kdDebug(5850) << "ActionManager::closeURL()" << endl; + + file_close(); +} + +bool ActionManager::saveURL() +{ + QString ext; + + if ( mURL.isLocalFile() ) { + ext = mFile.right( 4 ); + } else { + ext = mURL.filename().right( 4 ); + } + + if ( ext == ".vcs" ) { + int result = KMessageBox::warningContinueCancel( + dialogParent(), + i18n( "Your calendar will be saved in iCalendar format. Use " + "'Export vCalendar' to save in vCalendar format." ), + i18n("Format Conversion"), i18n("Proceed"), "dontaskFormatConversion", + true ); + if ( result != KMessageBox::Continue ) return false; + + QString filename = mURL.fileName(); + filename.replace( filename.length() - 4, 4, ".ics" ); + mURL.setFileName( filename ); + if ( mURL.isLocalFile() ) { + mFile = mURL.path(); + } + setTitle(); + if ( mRecent ) mRecent->addURL( mURL ); + } + + if ( !mCalendarView->saveCalendar( mFile ) ) { + kdDebug(5850) << "ActionManager::saveURL(): calendar view save failed." + << endl; + return false; + } else { + mCalendarView->setModified( false ); + } + + if ( !mURL.isLocalFile() ) { + if ( !KIO::NetAccess::upload( mFile, mURL, view() ) ) { + QString msg = i18n("Cannot upload calendar to '%1'") + .arg( mURL.prettyURL() ); + KMessageBox::error( dialogParent() ,msg ); + return false; + } + } + + // keep saves on a regular interval + if ( KOPrefs::instance()->mAutoSave ) { + mAutoSaveTimer->stop(); + mAutoSaveTimer->start( 1000*60*KOPrefs::instance()->mAutoSaveInterval ); + } + + mMainWindow->showStatusMessage( i18n("Saved calendar '%1'.").arg( mURL.prettyURL() ) ); + + return true; +} + +void ActionManager::exportHTML() +{ + HTMLExportSettings settings( "KOrganizer" ); + // Manually read in the config, because parametrized kconfigxt objects don't + // seem to load the config theirselves + settings.readConfig(); + + QDate qd1; + qd1 = QDate::currentDate(); + QDate qd2; + qd2 = QDate::currentDate(); + if ( settings.monthView() ) + qd2.addMonths( 1 ); + else + qd2.addDays( 7 ); + settings.setDateStart( qd1 ); + settings.setDateEnd( qd2 ); + exportHTML( &settings ); +} + +void ActionManager::exportHTML( HTMLExportSettings *settings ) +{ + if ( !settings || settings->outputFile().isEmpty() ) + return; + settings->setEMail( KOPrefs::instance()->email() ); + settings->setName( KOPrefs::instance()->fullName() ); + + settings->setCreditName( "KOrganizer" ); + settings->setCreditURL( "http://korganizer.kde.org" ); + + KCal::HtmlExport mExport( mCalendarView->calendar(), settings ); + + QDate cdate = settings->dateStart().date(); + QDate qd2 = settings->dateEnd().date(); + while ( cdate <= qd2 ) { + QStringList holidays = KOGlobals::self()->holiday( cdate ); + if ( !holidays.isEmpty() ) { + QStringList::ConstIterator it = holidays.begin(); + for ( ; it != holidays.end(); ++it ) { + mExport.addHoliday( cdate, *it ); + } + } + cdate = cdate.addDays( 1 ); + } + + KURL dest( settings->outputFile() ); + if ( dest.isLocalFile() ) { + mExport.save( dest.path() ); + } else { + KTempFile tf; + QString tfile = tf.name(); + tf.close(); + mExport.save( tfile ); + if ( !KIO::NetAccess::upload( tfile, dest, view() ) ) { + KNotifyClient::event ( view()->winId(), + i18n("Could not upload file.") ); + } + tf.unlink(); + } +} + +bool ActionManager::saveAsURL( const KURL &url ) +{ + kdDebug(5850) << "ActionManager::saveAsURL() " << url.prettyURL() << endl; + + if ( url.isEmpty() ) { + kdDebug(5850) << "ActionManager::saveAsURL(): Empty URL." << endl; + return false; + } + if ( !url.isValid() ) { + kdDebug(5850) << "ActionManager::saveAsURL(): Malformed URL." << endl; + return false; + } + + QString fileOrig = mFile; + KURL URLOrig = mURL; + + KTempFile *tempFile = 0; + if ( url.isLocalFile() ) { + mFile = url.path(); + } else { + tempFile = new KTempFile; + mFile = tempFile->name(); + } + mURL = url; + + bool success = saveURL(); // Save local file and upload local file + if ( success ) { + delete mTempFile; + mTempFile = tempFile; + KIO::NetAccess::removeTempFile( fileOrig ); + KConfig *config = KOGlobals::self()->config(); + config->setGroup( "General" ); + setTitle(); + if ( mRecent ) mRecent->addURL( mURL ); + } else { + KMessageBox::sorry( dialogParent(), i18n("Unable to save calendar to the file %1.").arg( mFile ), i18n("Error") ); + kdDebug(5850) << "ActionManager::saveAsURL() failed" << endl; + mURL = URLOrig; + mFile = fileOrig; + delete tempFile; + } + + return success; +} + + +bool ActionManager::saveModifiedURL() +{ + kdDebug(5850) << "ActionManager::saveModifiedURL()" << endl; + + // If calendar isn't modified do nothing. + if ( !mCalendarView->isModified() ) return true; + + mHtmlExportSync = true; + if ( KOPrefs::instance()->mAutoSave && !mURL.isEmpty() ) { + // Save automatically, when auto save is enabled. + return saveURL(); + } else { + int result = KMessageBox::warningYesNoCancel( + dialogParent(), + i18n("The calendar has been modified.\nDo you want to save it?"), + QString::null, + KStdGuiItem::save(), KStdGuiItem::discard() ); + switch( result ) { + case KMessageBox::Yes: + if ( mURL.isEmpty() ) { + KURL url = getSaveURL(); + return saveAsURL( url ); + } else { + return saveURL(); + } + case KMessageBox::No: + return true; + case KMessageBox::Cancel: + default: + { + mHtmlExportSync = false; + return false; + } + } + } +} + + +KURL ActionManager::getSaveURL() +{ + KURL url = KFileDialog::getSaveURL( locateLocal( "data","korganizer/" ), + i18n("*.vcs *.ics|Calendar Files"), + dialogParent() ); + + if ( url.isEmpty() ) return url; + + QString filename = url.fileName( false ); + + QString e = filename.right( 4 ); + if ( e != ".vcs" && e != ".ics" ) { + // Default save format is iCalendar + filename += ".ics"; + } + + url.setFileName( filename ); + + kdDebug(5850) << "ActionManager::getSaveURL(): url: " << url.url() << endl; + + return url; +} + +void ActionManager::saveProperties( KConfig *config ) +{ + kdDebug(5850) << "ActionManager::saveProperties" << endl; + + config->writeEntry( "UseResourceCalendar", !mMainWindow->hasDocument() ); + if ( mMainWindow->hasDocument() ) { + config->writePathEntry( "Calendar",mURL.url() ); + } +} + +void ActionManager::readProperties( KConfig *config ) +{ + kdDebug(5850) << "ActionManager::readProperties" << endl; + + bool isResourceCalendar( + config->readBoolEntry( "UseResourceCalendar", true ) ); + QString calendarUrl = config->readPathEntry( "Calendar" ); + + if ( !isResourceCalendar && !calendarUrl.isEmpty() ) { + mMainWindow->init( true ); + KURL u( calendarUrl ); + openURL( u ); + } else { + mMainWindow->init( false ); + } +} + +void ActionManager::checkAutoSave() +{ + kdDebug(5850) << "ActionManager::checkAutoSave()" << endl; + + // Don't save if auto save interval is zero + if ( KOPrefs::instance()->mAutoSaveInterval == 0 ) return; + + // has this calendar been saved before? If yes automatically save it. + if ( KOPrefs::instance()->mAutoSave ) { + if ( mCalendarResources || ( mCalendar && !url().isEmpty() ) ) { + saveCalendar(); + } + } +} + + +// Configuration changed as a result of the options dialog. +void ActionManager::updateConfig() +{ + kdDebug(5850) << "ActionManager::updateConfig()" << endl; + + if ( KOPrefs::instance()->mAutoSave && !mAutoSaveTimer->isActive() ) { + checkAutoSave(); + if ( KOPrefs::instance()->mAutoSaveInterval > 0 ) { + mAutoSaveTimer->start( 1000 * 60 * + KOPrefs::instance()->mAutoSaveInterval ); + } + } + if ( !KOPrefs::instance()->mAutoSave ) mAutoSaveTimer->stop(); + mNextXDays->setText( i18n( "&Next Day", "&Next %n Days", + KOPrefs::instance()->mNextXDays ) ); + + KOCore::self()->reloadPlugins(); + mParts = KOCore::self()->reloadParts( mMainWindow, mParts ); + + setDestinationPolicy(); + + if ( mResourceView ) + mResourceView->updateView(); + + KOGroupware::instance()->freeBusyManager()->setBrokenUrl( false ); +} + +void ActionManager::setDestinationPolicy() +{ + if ( mCalendarResources ) { + if ( KOPrefs::instance()->mDestination == KOPrefs::askDestination ) + mCalendarResources->setAskDestinationPolicy(); + else + mCalendarResources->setStandardDestinationPolicy(); + } +} + +void ActionManager::configureDateTime() +{ + KProcess *proc = new KProcess; + *proc << "kcmshell" << "language"; + + connect( proc,SIGNAL( processExited( KProcess * ) ), + SLOT( configureDateTimeFinished( KProcess * ) ) ); + + if ( !proc->start() ) { + KMessageBox::sorry( dialogParent(), + i18n("Could not start control module for date and time format.") ); + delete proc; + } +} + +void ActionManager::showTip() +{ + KTipDialog::showTip( dialogParent(),QString::null,true ); +} + +void ActionManager::showTipOnStart() +{ + KTipDialog::showTip( dialogParent() ); +} + +KOrg::MainWindow *ActionManager::findInstance( const KURL &url ) +{ + if ( mWindowList ) { + if ( url.isEmpty() ) return mWindowList->defaultInstance(); + else return mWindowList->findInstance( url ); + } else { + return 0; + } +} + +void ActionManager::dumpText( const QString &str ) +{ + kdDebug(5850) << "ActionManager::dumpText(): " << str << endl; +} + +void ActionManager::toggleDateNavigator() +{ + bool visible = mDateNavigatorShowAction->isChecked(); + if ( mCalendarView ) mCalendarView->showDateNavigator( visible ); +} + +void ActionManager::toggleTodoView() +{ + bool visible = mTodoViewShowAction->isChecked(); + if ( mCalendarView ) mCalendarView->showTodoView( visible ); +} + +void ActionManager::toggleEventViewer() +{ + bool visible = mEventViewerShowAction->isChecked(); + if ( mCalendarView ) mCalendarView->showEventViewer( visible ); +} + +void ActionManager::toggleResourceView() +{ + bool visible = mResourceViewShowAction->isChecked(); + kdDebug(5850) << "toggleResourceView: " << endl; + if ( mResourceView ) { + if ( visible ) mResourceView->show(); + else mResourceView->hide(); + } +} + +void ActionManager::toggleResourceButtons() +{ + bool visible = mResourceButtonsAction->isChecked(); + + kdDebug(5850) << "RESOURCE VIEW " << long( mResourceView ) << endl; + + if ( mResourceView ) mResourceView->showButtons( visible ); +} + +bool ActionManager::openURL( const QString &url ) +{ + return openURL( KURL( url ) ); +} + +bool ActionManager::mergeURL( const QString &url ) +{ + return openURL( KURL( url ),true ); +} + +bool ActionManager::saveAsURL( const QString &url ) +{ + return saveAsURL( KURL( url ) ); +} + +QString ActionManager::getCurrentURLasString() const +{ + return mURL.url(); +} + +bool ActionManager::editIncidence( const QString& uid ) +{ + return mCalendarView->editIncidence( uid ); +} + +bool ActionManager::deleteIncidence( const QString& uid, bool force ) +{ + return mCalendarView->deleteIncidence( uid, force ); +} + +bool ActionManager::addIncidence( const QString& ical ) +{ + return mCalendarView->addIncidence( ical ); +} + +void ActionManager::configureDateTimeFinished( KProcess *proc ) +{ + delete proc; +} + +void ActionManager::downloadNewStuff() +{ + kdDebug(5850) << "ActionManager::downloadNewStuff()" << endl; + + if ( !mNewStuff ) mNewStuff = new KONewStuff( mCalendarView ); + mNewStuff->download(); +} + +void ActionManager::uploadNewStuff() +{ + if ( !mNewStuff ) mNewStuff = new KONewStuff( mCalendarView ); + mNewStuff->upload(); +} + +QString ActionManager::localFileName() +{ + return mFile; +} + +class ActionManager::ActionStringsVisitor : public IncidenceBase::Visitor +{ + public: + ActionStringsVisitor() : mShow( 0 ), mEdit( 0 ), mDelete( 0 ) {} + + bool act( IncidenceBase *incidence, KAction *show, KAction *edit, KAction *del ) + { + mShow = show; + mEdit = edit; + mDelete = del; + return incidence->accept( *this ); + } + + protected: + bool visit( Event * ) { + if ( mShow ) mShow->setText( i18n("&Show Event") ); + if ( mEdit ) mEdit->setText( i18n("&Edit Event...") ); + if ( mDelete ) mDelete->setText( i18n("&Delete Event") ); + return true; + } + bool visit( Todo * ) { + if ( mShow ) mShow->setText( i18n("&Show To-do") ); + if ( mEdit ) mEdit->setText( i18n("&Edit To-do...") ); + if ( mDelete ) mDelete->setText( i18n("&Delete To-do") ); + return true; + } + bool visit( Journal * ) { return assignDefaultStrings(); } + protected: + bool assignDefaultStrings() { + if ( mShow ) mShow->setText( i18n("&Show") ); + if ( mEdit ) mEdit->setText( i18n("&Edit...") ); + if ( mDelete ) mDelete->setText( i18n("&Delete") ); + return true; + } + KAction *mShow; + KAction *mEdit; + KAction *mDelete; +}; + +void ActionManager::processIncidenceSelection( Incidence *incidence ) +{ +// kdDebug(5850) << "ActionManager::processIncidenceSelection()" << endl; + + if ( !incidence ) { + enableIncidenceActions( false ); + return; + } + + enableIncidenceActions( true ); + + if ( incidence->isReadOnly() ) { + mCutAction->setEnabled( false ); + mDeleteAction->setEnabled( false ); + } + + ActionStringsVisitor v; + if ( !v.act( incidence, mShowIncidenceAction, mEditIncidenceAction, mDeleteIncidenceAction ) ) { + mShowIncidenceAction->setText( i18n("&Show") ); + mEditIncidenceAction->setText( i18n("&Edit...") ); + mDeleteIncidenceAction->setText( i18n("&Delete") ); + } +} + +void ActionManager::enableIncidenceActions( bool enabled ) +{ + mShowIncidenceAction->setEnabled( enabled ); + mEditIncidenceAction->setEnabled( enabled ); + mDeleteIncidenceAction->setEnabled( enabled ); +// mAssignResourceAction->setEnabled( enabled ); + + mCutAction->setEnabled( enabled ); + mCopyAction->setEnabled( enabled ); + mDeleteAction->setEnabled( enabled ); + mPublishEvent->setEnabled( enabled ); + mForwardEvent->setEnabled( enabled ); +} + +void ActionManager::keyBindings() +{ + KKeyDialog dlg( false, view() ); + if ( mMainWindow ) + dlg.insert( mMainWindow->getActionCollection() ); + + KOrg::Part *part; + for ( part = mParts.first(); part; part = mParts.next() ) { + dlg.insert( part->actionCollection(), part->shortInfo() ); + } + dlg.configure(); +} + +void ActionManager::loadParts() +{ + mParts = KOCore::self()->loadParts( mMainWindow ); +} + +void ActionManager::setTitle() +{ + mMainWindow->setTitle(); +} + +KCalendarIface::ResourceRequestReply ActionManager::resourceRequest( const QValueList >&, + const QCString& resource, + const QString& vCalIn ) +{ + kdDebug(5850) << k_funcinfo << "resource=" << resource << " vCalIn=" << vCalIn << endl; + KCalendarIface::ResourceRequestReply reply; + reply.vCalOut = "VCalOut"; + return reply; +} + +void ActionManager::openEventEditor( const QString& text ) +{ + mCalendarView->newEvent( text ); +} + +void ActionManager::openEventEditor( const QString& summary, + const QString& description, + const QString& attachment ) +{ + mCalendarView->newEvent( summary, description, attachment ); +} + +void ActionManager::openEventEditor( const QString& summary, + const QString& description, + const QString& attachment, + const QStringList& attendees ) +{ + mCalendarView->newEvent( summary, description, attachment, attendees ); +} + +void ActionManager::openEventEditor( const QString & summary, + const QString & description, + const QString & uri, + const QString & file, + const QStringList & attendees, + const QString & attachmentMimetype ) +{ + int action = KOPrefs::instance()->defaultEmailAttachMethod(); + if ( attachmentMimetype != "message/rfc822" ) { + action = KOPrefs::Link; + } else if ( KOPrefs::instance()->defaultEmailAttachMethod() == KOPrefs::Ask ) { + KPopupMenu *menu = new KPopupMenu( 0 ); + menu->insertItem( i18n("Attach as &link"), KOPrefs::Link ); + menu->insertItem( i18n("Attach &inline"), KOPrefs::InlineFull ); + menu->insertItem( i18n("Attach inline &without attachments"), KOPrefs::InlineBody ); + menu->insertSeparator(); + menu->insertItem( SmallIcon("cancel"), i18n("C&ancel"), KOPrefs::Ask ); + action = menu->exec( QCursor::pos(), 0 ); + delete menu; + } + + QString attData; + KTempFile tf; + tf.setAutoDelete( true ); + switch ( action ) { + case KOPrefs::Ask: + return; + case KOPrefs::Link: + attData = uri; + break; + case KOPrefs::InlineFull: + attData = file; + break; + case KOPrefs::InlineBody: + { + QFile f( file ); + if ( !f.open( IO_ReadOnly ) ) + return; + KMime::Message *msg = new KMime::Message(); + msg->setContent( QCString( f.readAll() ) ); + QCString head = msg->head(); + msg->parse(); + if ( msg == msg->textContent() || msg->textContent() == 0 ) { // no attachments + attData = file; + } else { + if ( KMessageBox::warningContinueCancel( 0, + i18n("Removing attachments from an email might invalidate its signature."), + i18n("Remove Attachments"), KStdGuiItem::cont(), "BodyOnlyInlineAttachment" ) + != KMessageBox::Continue ) + return; + // due to kmime shortcomings in KDE3, we need to assemble the result manually + int begin = 0; + int end = head.find( '\n' ); + bool skipFolded = false; + while ( end >= 0 && end > begin ) { + if ( head.find( "Content-Type:", begin, false ) != begin && + head.find( "Content-Transfer-Encoding:", begin, false ) != begin && + !(skipFolded && (head[begin] == ' ' || head[end] == '\t')) ) { + QCString line = head.mid( begin, end - begin ); + tf.file()->writeBlock( line.data(), line.length() ); + tf.file()->writeBlock( "\n", 1 ); + skipFolded = false; + } else { + skipFolded = true; + } + + begin = end + 1; + end = head.find( '\n', begin ); + if ( end < 0 && begin < (int)head.length() ) + end = head.length() - 1; + } + QCString cte = msg->textContent()->contentTransferEncoding()->as7BitString(); + if ( !cte.stripWhiteSpace().isEmpty() ) { + tf.file()->writeBlock( cte.data(), cte.length() ); + tf.file()->writeBlock( "\n", 1 ); + } + QCString ct = msg->textContent()->contentType()->as7BitString(); + if ( !ct.stripWhiteSpace().isEmpty() ) + tf.file()->writeBlock( ct.data(), ct.length() ); + tf.file()->writeBlock( "\n", 1 ); + tf.file()->writeBlock( msg->textContent()->body() ); + attData = tf.name(); + } + tf.close(); + delete msg; + break; + } + default: + // menu could have been closed by cancel, if so, do nothing + return; + } + + mCalendarView->newEvent( summary, description, attData, attendees, attachmentMimetype, action != KOPrefs::Link ); +} + +void ActionManager::openTodoEditor( const QString& text ) +{ + mCalendarView->newTodo( text ); +} + +void ActionManager::openTodoEditor( const QString& summary, + const QString& description, + const QString& attachment ) +{ + mCalendarView->newTodo( summary, description, attachment ); +} + +void ActionManager::openTodoEditor( const QString& summary, + const QString& description, + const QString& attachment, + const QStringList& attendees ) +{ + mCalendarView->newTodo( summary, description, attachment, attendees ); +} + +void ActionManager::openTodoEditor(const QString & summary, + const QString & description, + const QString & uri, + const QString & file, + const QStringList & attendees, + const QString & attachmentMimetype) +{ + int action = KOPrefs::instance()->defaultTodoAttachMethod(); + if ( attachmentMimetype != "message/rfc822" ) { + action = KOPrefs::TodoAttachLink; + } else if ( KOPrefs::instance()->defaultTodoAttachMethod() == KOPrefs::TodoAttachAsk ) { + KPopupMenu *menu = new KPopupMenu( 0 ); + menu->insertItem( i18n("Attach as &link"), KOPrefs::TodoAttachLink ); + menu->insertItem( i18n("Attach &inline"), KOPrefs::TodoAttachInlineFull ); + menu->insertSeparator(); + menu->insertItem( SmallIcon("cancel"), i18n("C&ancel"), KOPrefs::TodoAttachAsk ); + action = menu->exec( QCursor::pos(), 0 ); + delete menu; + } + + QString attData; + switch ( action ) { + case KOPrefs::TodoAttachAsk: + return; + case KOPrefs::TodoAttachLink: + attData = uri; + break; + case KOPrefs::TodoAttachInlineFull: + attData = file; + break; + default: + // menu could have been closed by cancel, if so, do nothing + return; + } + + mCalendarView->newTodo( summary, description, attData, attendees, attachmentMimetype, action != KOPrefs::Link ); +} + +void ActionManager::openJournalEditor( const QDate& date ) +{ + mCalendarView->newJournal( date ); +} + +void ActionManager::openJournalEditor( const QString& text, const QDate& date ) +{ + mCalendarView->newJournal( text, date ); +} + +void ActionManager::openJournalEditor( const QString& text ) +{ + mCalendarView->newJournal( text ); +} + +//TODO: +// void ActionManager::openJournalEditor( const QString& summary, +// const QString& description, +// const QString& attachment ) +// { +// mCalendarView->newJournal( summary, description, attachment ); +// } + + +void ActionManager::showJournalView() +{ + mCalendarView->viewManager()->showJournalView(); +} + +void ActionManager::showTodoView() +{ + mCalendarView->viewManager()->showTodoView(); +} + +void ActionManager::showEventView() +{ + mCalendarView->viewManager()->showEventView(); +} + +void ActionManager::goDate( const QDate& date ) +{ + mCalendarView->goDate( date ); +} + +void ActionManager::goDate( const QString& date ) +{ + goDate( KGlobal::locale()->readDate( date ) ); +} + +void ActionManager::showDate(const QDate & date) +{ + mCalendarView->showDate( date ); +} + + +void ActionManager::updateUndoAction( const QString &text ) +{ + if ( text.isNull() ) { + mUndoAction->setEnabled( false ); + mUndoAction->setText( i18n("Undo") ); + } else { + mUndoAction->setEnabled( true ); + if ( text.isEmpty() ) mUndoAction->setText( i18n("Undo") ); + else mUndoAction->setText( i18n("Undo (%1)").arg( text ) ); + } +} + +void ActionManager::updateRedoAction( const QString &text ) +{ + if ( text.isNull() ) { + mRedoAction->setEnabled( false ); + mRedoAction->setText( i18n( "Redo" ) ); + } else { + mRedoAction->setEnabled( true ); + if ( text.isEmpty() ) mRedoAction->setText( i18n("Redo") ); + else mRedoAction->setText( i18n( "Redo (%1)" ).arg( text ) ); + } +} + +bool ActionManager::queryClose() +{ + kdDebug(5850) << "ActionManager::queryClose()" << endl; + + bool close = true; + + if ( mCalendar && mCalendar->isModified() ) { + int res = KMessageBox::questionYesNoCancel( dialogParent(), + i18n("The calendar contains unsaved changes. Do you want to save them before exiting?"), QString::null, KStdGuiItem::save(), KStdGuiItem::discard() ); + // Exit on yes and no, don't exit on cancel. If saving fails, ask for exiting. + if ( res == KMessageBox::Yes ) { + close = saveModifiedURL(); + if ( !close ) { + int res1 = KMessageBox::questionYesNo( dialogParent(), i18n("Unable to save the calendar. Do you still want to close this window?"), QString::null, KStdGuiItem::close(), KStdGuiItem::cancel() ); + close = ( res1 == KMessageBox::Yes ); + } + } else { + close = ( res == KMessageBox::No ); + } + } else if ( mCalendarResources ) { + if ( !mIsClosing ) { + kdDebug(5850) << "!mIsClosing" << endl; + if ( !saveResourceCalendar() ) return false; + + // FIXME: Put main window into a state indicating final saving. + mIsClosing = true; +// FIXME: Close main window when save is finished +// connect( mCalendarResources, SIGNAL( calendarSaved() ), +// mMainWindow, SLOT( close() ) ); + } + if ( mCalendarResources->isSaving() ) { + kdDebug(5850) << "ActionManager::queryClose(): isSaving" << endl; + close = false; + KMessageBox::information( dialogParent(), + i18n("Unable to exit. Saving still in progress.") ); + } else { + kdDebug(5850) << "ActionManager::queryClose(): close = true" << endl; + close = true; + } + } else { + close = true; + } + + return close; +} + +void ActionManager::saveCalendar() +{ + if ( mCalendar ) { + if ( view()->isModified() ) { + if ( !url().isEmpty() ) { + saveURL(); + } else { + QString location = locateLocal( "data", "korganizer/kontact.ics" ); + saveAsURL( location ); + } + } + } else if ( mCalendarResources ) { + mCalendarResources->save(); + // FIXME: Make sure that asynchronous saves don't fail. + } +} + +bool ActionManager::saveResourceCalendar() +{ + if ( !mCalendarResources ) return false; + CalendarResourceManager *m = mCalendarResources->resourceManager(); + + CalendarResourceManager::ActiveIterator it; + for ( it = m->activeBegin(); it != m->activeEnd(); ++it ) { + if ( (*it)->readOnly() ) continue; + if ( !(*it)->save() ) { + int result = KMessageBox::warningContinueCancel( view(), + i18n( "Saving of '%1' failed. Check that the resource is " + "properly configured.\nIgnore problem and continue without " + "saving or cancel save?" ).arg( (*it)->resourceName() ), + i18n("Save Error"), KStdGuiItem::dontSave() ); + if ( result == KMessageBox::Cancel ) return false; + } + } + return true; +} + +void ActionManager::importCalendar( const KURL &url ) +{ + if ( !url.isValid() ) { + KMessageBox::error( dialogParent(), + i18n("URL '%1' is invalid.").arg( url.prettyURL() ) ); + return; + } + + ImportDialog *dialog; + dialog = new ImportDialog( url, mMainWindow->topLevelWidget() ); + connect( dialog, SIGNAL( dialogFinished( ImportDialog * ) ), + SLOT( slotImportDialogFinished( ImportDialog * ) ) ); + connect( dialog, SIGNAL( openURL( const KURL &, bool ) ), + SLOT( openURL( const KURL &, bool ) ) ); + connect( dialog, SIGNAL( newWindow( const KURL & ) ), + SIGNAL( actionNew( const KURL & ) ) ); + connect( dialog, SIGNAL( addResource( const KURL & ) ), + SLOT( addResource( const KURL & ) ) ); + + dialog->show(); +} + +void ActionManager::slotImportDialogFinished( ImportDialog *dlg ) +{ + dlg->deleteLater(); + mCalendarView->updateView(); +} + +void ActionManager::slotAutoArchivingSettingsModified() +{ + if ( KOPrefs::instance()->mAutoArchive ) + mAutoArchiveTimer->start( 4 * 60 * 60 * 1000, true ); // check again in 4 hours + else + mAutoArchiveTimer->stop(); +} + +void ActionManager::slotAutoArchive() +{ + if ( !mCalendarView->calendar() ) // can this happen? + return; + mAutoArchiveTimer->stop(); + EventArchiver archiver; + connect( &archiver, SIGNAL( eventsDeleted() ), mCalendarView, SLOT( updateView() ) ); + archiver.runAuto( mCalendarView->calendar(), mCalendarView, false /*no gui*/ ); + // restart timer with the correct delay ( especially useful for the first time ) + slotAutoArchivingSettingsModified(); +} + +void ActionManager::loadProfile( const QString & path ) +{ + KOPrefs::instance()->writeConfig(); + KConfig* const cfg = KOPrefs::instance()->config(); + + const KConfig profile( path+"/korganizerrc", /*read-only=*/false, /*useglobals=*/false ); + const QStringList groups = profile.groupList(); + for ( QStringList::ConstIterator it = groups.begin(), end = groups.end(); it != end; ++it ) + { + cfg->setGroup( *it ); + typedef QMap StringMap; + const StringMap entries = profile.entryMap( *it ); + for ( StringMap::ConstIterator it2 = entries.begin(), end = entries.end(); it2 != end; ++it2 ) + { + cfg->writeEntry( it2.key(), it2.data() ); + } + } + + cfg->sync(); + KOPrefs::instance()->readConfig(); +} + +namespace { + void copyConfigEntry( KConfig* source, KConfig* dest, const QString& group, const QString& key, const QString& defaultValue=QString() ) + { + source->setGroup( group ); + dest->setGroup( group ); + dest->writeEntry( key, source->readEntry( key, defaultValue ) ); + } +} + +void ActionManager::saveToProfile( const QString & path ) const +{ + KOPrefs::instance()->writeConfig(); + KConfig* const cfg = KOPrefs::instance()->config(); + + KConfig profile( path+"/korganizerrc", /*read-only=*/false, /*useglobals=*/false ); + ::copyConfigEntry( cfg, &profile, "Views", "Agenda View Calendar Display" ); +} + +QWidget *ActionManager::dialogParent() +{ + return mCalendarView->topLevelWidget(); +} + +#include "actionmanager.moc" -- cgit v1.2.1