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.
1086 lines
35 KiB
1086 lines
35 KiB
/*
|
|
* functions.cpp - miscellaneous functions
|
|
* Program: kalarm
|
|
* Copyright © 2001-2009 by David Jarvie <djarvie@kde.org>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include "kalarm.h"
|
|
#include "functions.h"
|
|
|
|
#include "alarmcalendar.h"
|
|
#include "alarmevent.h"
|
|
#include "alarmlistview.h"
|
|
#include "daemon.h"
|
|
#include "kalarmapp.h"
|
|
#include "kamail.h"
|
|
#include "mainwindow.h"
|
|
#include "messagewin.h"
|
|
#include "preferences.h"
|
|
#include "shellprocess.h"
|
|
#include "templatelistview.h"
|
|
#include "templatemenuaction.h"
|
|
|
|
#include <tqdeepcopy.h>
|
|
#include <tqdir.h>
|
|
#include <tqregexp.h>
|
|
|
|
#include <tdeconfig.h>
|
|
#include <tdeaction.h>
|
|
#include <tdeglobal.h>
|
|
#include <tdelocale.h>
|
|
#include <kstdguiitem.h>
|
|
#include <tdestdaccel.h>
|
|
#include <tdemessagebox.h>
|
|
#include <tdefiledialog.h>
|
|
#include <dcopclient.h>
|
|
#include <dcopref.h>
|
|
#include <kdcopservicestarter.h>
|
|
#include <kdebug.h>
|
|
|
|
#include <libkcal/event.h>
|
|
#include <libkcal/icalformat.h>
|
|
#include <libkpimidentities/identitymanager.h>
|
|
#include <libkpimidentities/identity.h>
|
|
#include <libkcal/person.h>
|
|
|
|
|
|
namespace
|
|
{
|
|
bool resetDaemonQueued = false;
|
|
TQCString korganizerName = "korganizer";
|
|
TQString korgStartError;
|
|
#define KORG_DCOP_OBJECT "KOrganizerIface"
|
|
//const char* KORG_DCOP_WINDOW = "KOrganizer MainWindow"; // not used
|
|
const char* KMAIL_DCOP_WINDOW = "kmail-mainwindow#1";
|
|
|
|
bool sendToKOrganizer(const KAEvent&);
|
|
bool deleteFromKOrganizer(const TQString& eventID);
|
|
bool runKOrganizer();
|
|
}
|
|
|
|
|
|
namespace KAlarm
|
|
{
|
|
|
|
/******************************************************************************
|
|
* Display a main window with the specified event selected.
|
|
*/
|
|
MainWindow* displayMainWindowSelected(const TQString& eventID)
|
|
{
|
|
MainWindow* win = MainWindow::firstWindow();
|
|
if (!win)
|
|
{
|
|
if (theApp()->checkCalendarDaemon()) // ensure calendar is open and daemon started
|
|
{
|
|
win = MainWindow::create();
|
|
win->show();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// There is already a main window, so make it the active window
|
|
bool visible = win->isVisible();
|
|
if (visible)
|
|
win->hide(); // in case it's on a different desktop
|
|
if (!visible || win->isMinimized())
|
|
win->showNormal();
|
|
win->raise();
|
|
win->setActiveWindow();
|
|
}
|
|
if (win && !eventID.isEmpty())
|
|
win->selectEvent(eventID);
|
|
return win;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Create a New Alarm TDEAction.
|
|
*/
|
|
TDEAction* createNewAlarmAction(const TQString& label, TQObject* receiver, const char* slot, TDEActionCollection* actions, const char* name)
|
|
{
|
|
return new TDEAction(label, "document-new", TDEStdAccel::openNew(), receiver, slot, actions, name);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Create a New From Template TDEAction.
|
|
*/
|
|
TemplateMenuAction* createNewFromTemplateAction(const TQString& label, TQObject* receiver, const char* slot, TDEActionCollection* actions, const char* name)
|
|
{
|
|
return new TemplateMenuAction(label, "new_from_template", receiver, slot, actions, name);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Add a new active (non-expired) alarm.
|
|
* Save it in the calendar file and add it to every main window instance.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the new
|
|
* event in that listView instance.
|
|
* 'event' is updated with the actual event ID.
|
|
*/
|
|
UpdateStatus addEvent(KAEvent& event, AlarmListView* selectionView, TQWidget* errmsgParent, bool useEventID, bool allowKOrgUpdate)
|
|
{
|
|
kdDebug(5950) << "KAlarm::addEvent(): " << event.id() << endl;
|
|
UpdateStatus status = UPDATE_OK;
|
|
if (!theApp()->checkCalendarDaemon()) // ensure calendar is open and daemon started
|
|
return UPDATE_FAILED;
|
|
else
|
|
{
|
|
// Save the event details in the calendar file, and get the new event ID
|
|
AlarmCalendar* cal = AlarmCalendar::activeCalendar();
|
|
if (!cal->addEvent(event, useEventID))
|
|
status = UPDATE_FAILED;
|
|
else if (!cal->save())
|
|
status = SAVE_FAILED;
|
|
}
|
|
if (status == UPDATE_OK)
|
|
{
|
|
if (allowKOrgUpdate && event.copyToKOrganizer())
|
|
{
|
|
if (!sendToKOrganizer(event)) // tell KOrganizer to show the event
|
|
status = UPDATE_KORG_ERR;
|
|
}
|
|
|
|
// Update the window lists
|
|
AlarmListView::addEvent(event, selectionView);
|
|
return status;
|
|
}
|
|
|
|
if (errmsgParent)
|
|
displayUpdateError(errmsgParent, status, ERR_ADD, 1);
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Save the event in the expired calendar file and adjust every main window instance.
|
|
* The event's ID is changed to an expired ID if necessary.
|
|
*/
|
|
bool addExpiredEvent(KAEvent& event)
|
|
{
|
|
kdDebug(5950) << "KAlarm::addExpiredEvent(" << event.id() << ")\n";
|
|
AlarmCalendar* cal = AlarmCalendar::expiredCalendarOpen();
|
|
if (!cal)
|
|
return false;
|
|
bool archiving = (KAEvent::uidStatus(event.id()) == KAEvent::ACTIVE);
|
|
if (archiving)
|
|
event.setSaveDateTime(TQDateTime::currentDateTime()); // time stamp to control purging
|
|
KCal::Event* kcalEvent = cal->addEvent(event);
|
|
cal->save();
|
|
|
|
// Update window lists
|
|
if (!archiving)
|
|
AlarmListView::addEvent(event, 0);
|
|
else if (kcalEvent)
|
|
AlarmListView::modifyEvent(KAEvent(*kcalEvent), 0);
|
|
return true;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Add a new template.
|
|
* Save it in the calendar file and add it to every template list view.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the new
|
|
* event in that listView instance.
|
|
* 'event' is updated with the actual event ID.
|
|
*/
|
|
UpdateStatus addTemplate(KAEvent& event, TemplateListView* selectionView, TQWidget* errmsgParent)
|
|
{
|
|
kdDebug(5950) << "KAlarm::addTemplate(): " << event.id() << endl;
|
|
UpdateStatus status = UPDATE_OK;
|
|
|
|
// Add the template to the calendar file
|
|
AlarmCalendar* cal = AlarmCalendar::templateCalendarOpen();
|
|
if (!cal || !cal->addEvent(event))
|
|
status = UPDATE_FAILED;
|
|
else if (!cal->save())
|
|
status = SAVE_FAILED;
|
|
else
|
|
{
|
|
cal->emitEmptyStatus();
|
|
|
|
// Update the window lists
|
|
TemplateListView::addEvent(event, selectionView);
|
|
return UPDATE_OK;
|
|
}
|
|
|
|
if (errmsgParent)
|
|
displayUpdateError(errmsgParent, status, ERR_TEMPLATE, 1);
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Modify an active (non-expired) alarm in the calendar file and in every main
|
|
* window instance.
|
|
* The new event will have a different event ID from the old one.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the
|
|
* modified event in that listView instance.
|
|
*/
|
|
UpdateStatus modifyEvent(KAEvent& oldEvent, const KAEvent& newEvent, AlarmListView* selectionView, TQWidget* errmsgParent)
|
|
{
|
|
kdDebug(5950) << "KAlarm::modifyEvent(): '" << oldEvent.id() << endl;
|
|
|
|
UpdateStatus status = UPDATE_OK;
|
|
if (!newEvent.valid())
|
|
{
|
|
deleteEvent(oldEvent, true);
|
|
status = UPDATE_FAILED;
|
|
}
|
|
else
|
|
{
|
|
if (oldEvent.copyToKOrganizer())
|
|
{
|
|
// Tell KOrganizer to delete its old event.
|
|
// But ignore errors, because the user could have manually
|
|
// deleted it since KAlarm asked KOrganizer to set it up.
|
|
deleteFromKOrganizer(oldEvent.id());
|
|
}
|
|
|
|
// Update the event in the calendar file, and get the new event ID
|
|
AlarmCalendar* cal = AlarmCalendar::activeCalendar();
|
|
if (!cal->deleteEvent(oldEvent.id())
|
|
|| !cal->addEvent(const_cast<KAEvent&>(newEvent), true))
|
|
status = UPDATE_FAILED;
|
|
else if (!cal->save())
|
|
status = SAVE_FAILED;
|
|
if (status == UPDATE_OK)
|
|
{
|
|
if (newEvent.copyToKOrganizer())
|
|
{
|
|
if (!sendToKOrganizer(newEvent)) // tell KOrganizer to show the new event
|
|
status = UPDATE_KORG_ERR;
|
|
}
|
|
|
|
// Update the window lists
|
|
AlarmListView::modifyEvent(oldEvent.id(), newEvent, selectionView);
|
|
return status;
|
|
}
|
|
}
|
|
|
|
if (errmsgParent)
|
|
displayUpdateError(errmsgParent, status, ERR_ADD, 1);
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Update an active (non-expired) alarm from the calendar file and from every
|
|
* main window instance.
|
|
* The new event will have the same event ID as the old one.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the
|
|
* updated event in that listView instance.
|
|
* The event is not updated in KOrganizer, since this function is called when an
|
|
* existing alarm is rescheduled (due to recurrence or deferral).
|
|
*/
|
|
UpdateStatus updateEvent(KAEvent& event, AlarmListView* selectionView, TQWidget* errmsgParent, bool archiveOnDelete, bool incRevision)
|
|
{
|
|
kdDebug(5950) << "KAlarm::updateEvent(): " << event.id() << endl;
|
|
|
|
if (!event.valid())
|
|
deleteEvent(event, archiveOnDelete);
|
|
else
|
|
{
|
|
// Update the event in the calendar file.
|
|
if (incRevision)
|
|
event.incrementRevision(); // ensure alarm daemon sees the event has changed
|
|
AlarmCalendar* cal = AlarmCalendar::activeCalendar();
|
|
cal->updateEvent(event);
|
|
if (!cal->save())
|
|
{
|
|
if (errmsgParent)
|
|
displayUpdateError(errmsgParent, SAVE_FAILED, ERR_ADD, 1);
|
|
return SAVE_FAILED;
|
|
}
|
|
|
|
// Update the window lists
|
|
AlarmListView::modifyEvent(event, selectionView);
|
|
}
|
|
return UPDATE_OK;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Update a template in the calendar file and in every template list view.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the
|
|
* updated event in that listView instance.
|
|
*/
|
|
UpdateStatus updateTemplate(const KAEvent& event, TemplateListView* selectionView, TQWidget* errmsgParent)
|
|
{
|
|
UpdateStatus status = UPDATE_OK;
|
|
AlarmCalendar* cal = AlarmCalendar::templateCalendarOpen();
|
|
if (!cal)
|
|
status = UPDATE_FAILED;
|
|
else
|
|
{
|
|
cal->updateEvent(event);
|
|
if (!cal->save())
|
|
status = SAVE_FAILED;
|
|
else
|
|
{
|
|
TemplateListView::modifyEvent(event.id(), event, selectionView);
|
|
return UPDATE_OK;
|
|
}
|
|
}
|
|
|
|
if (errmsgParent)
|
|
displayUpdateError(errmsgParent, SAVE_FAILED, ERR_TEMPLATE, 1);
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Delete an alarm from the calendar file and from every main window instance.
|
|
* If the event is archived, the event's ID is changed to an expired ID if necessary.
|
|
*/
|
|
UpdateStatus deleteEvent(KAEvent& event, bool archive, TQWidget* errmsgParent)
|
|
{
|
|
TQString id = event.id();
|
|
kdDebug(5950) << "KAlarm::deleteEvent(): " << id << endl;
|
|
|
|
// Update the window lists
|
|
AlarmListView::deleteEvent(id);
|
|
|
|
UpdateStatus status = UPDATE_OK;
|
|
AlarmCalendar* cal;
|
|
|
|
// Delete the event from the calendar file
|
|
if (KAEvent::uidStatus(id) == KAEvent::EXPIRED)
|
|
{
|
|
cal = AlarmCalendar::expiredCalendarOpen();
|
|
if (!cal)
|
|
status = UPDATE_FAILED;
|
|
}
|
|
else
|
|
{
|
|
if (event.copyToKOrganizer())
|
|
{
|
|
// The event was shown in KOrganizer, so tell KOrganizer to
|
|
// delete it. Note that an error could occur if the user
|
|
// manually deleted it from KOrganizer since it was set up.
|
|
if (!deleteFromKOrganizer(event.id()))
|
|
status = UPDATE_KORG_ERR;
|
|
}
|
|
if (archive && event.toBeArchived())
|
|
addExpiredEvent(event); // this changes the event ID to an expired ID
|
|
cal = AlarmCalendar::activeCalendar();
|
|
}
|
|
if (status != UPDATE_FAILED)
|
|
{
|
|
if (!cal->deleteEvent(id, true)) // save calendar after deleting
|
|
status = SAVE_FAILED;
|
|
}
|
|
if (status > UPDATE_KORG_ERR && errmsgParent)
|
|
displayUpdateError(errmsgParent, SAVE_FAILED, ERR_DELETE, 1);
|
|
return status;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Delete a template from the calendar file and from every template list view.
|
|
*/
|
|
UpdateStatus deleteTemplate(const KAEvent& event)
|
|
{
|
|
TQString id = event.id();
|
|
|
|
// Delete the template from the calendar file
|
|
AlarmCalendar* cal = AlarmCalendar::templateCalendarOpen();
|
|
if (!cal)
|
|
return UPDATE_FAILED;
|
|
if (!cal->deleteEvent(id, true)) // save calendar after deleting
|
|
return SAVE_FAILED;
|
|
cal->emitEmptyStatus();
|
|
|
|
// Update the window lists
|
|
TemplateListView::deleteEvent(id);
|
|
return UPDATE_OK;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Delete an alarm from the display calendar.
|
|
*/
|
|
void deleteDisplayEvent(const TQString& eventID)
|
|
{
|
|
kdDebug(5950) << "KAlarm::deleteDisplayEvent(" << eventID << ")\n";
|
|
|
|
if (KAEvent::uidStatus(eventID) == KAEvent::DISPLAYING)
|
|
{
|
|
AlarmCalendar* cal = AlarmCalendar::displayCalendarOpen();
|
|
if (cal)
|
|
cal->deleteEvent(eventID, true); // save calendar after deleting
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Undelete an expired alarm, and update every main window instance.
|
|
* The archive bit is set to ensure that it gets re-archived if it is deleted again.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the
|
|
* restored event in that listView instance.
|
|
*/
|
|
UpdateStatus reactivateEvent(KAEvent& event, AlarmListView* selectionView, bool useEventID)
|
|
{
|
|
TQString id = event.id();
|
|
kdDebug(5950) << "KAlarm::reactivateEvent(): " << id << endl;
|
|
|
|
// Delete the event from the expired calendar file
|
|
if (KAEvent::uidStatus(id) == KAEvent::EXPIRED)
|
|
{
|
|
TQDateTime now = TQDateTime::currentDateTime();
|
|
if (event.occursAfter(now, true))
|
|
{
|
|
if (event.recurs() || event.repeatCount())
|
|
event.setNextOccurrence(now); // skip any recurrences in the past
|
|
event.setArchive(); // ensure that it gets re-archived if it is deleted
|
|
|
|
// Save the event details in the calendar file, and get the new event ID
|
|
AlarmCalendar* cal = AlarmCalendar::activeCalendar();
|
|
if (!cal->addEvent(event, useEventID))
|
|
return UPDATE_FAILED;
|
|
if (!cal->save())
|
|
return SAVE_FAILED;
|
|
|
|
UpdateStatus status = UPDATE_OK;
|
|
if (event.copyToKOrganizer())
|
|
{
|
|
if (!sendToKOrganizer(event)) // tell KOrganizer to show the event
|
|
status = UPDATE_KORG_ERR;
|
|
}
|
|
|
|
// Update the window lists
|
|
AlarmListView::undeleteEvent(id, event, selectionView);
|
|
|
|
cal = AlarmCalendar::expiredCalendarOpen();
|
|
if (cal)
|
|
cal->deleteEvent(id, true); // save calendar after deleting
|
|
return status;
|
|
}
|
|
}
|
|
return UPDATE_FAILED;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Enable or disable an alarm in the calendar file and in every main window instance.
|
|
* The new event will have the same event ID as the old one.
|
|
* If 'selectionView' is non-null, the selection highlight is moved to the
|
|
* updated event in that listView instance.
|
|
*/
|
|
UpdateStatus enableEvent(KAEvent& event, AlarmListView* selectionView, bool enable)
|
|
{
|
|
kdDebug(5950) << "KAlarm::enableEvent(" << enable << "): " << event.id() << endl;
|
|
|
|
if (enable != event.enabled())
|
|
{
|
|
event.setEnabled(enable);
|
|
|
|
// Update the event in the calendar file
|
|
AlarmCalendar* cal = AlarmCalendar::activeCalendar();
|
|
cal->updateEvent(event);
|
|
if (!cal->save())
|
|
return SAVE_FAILED;
|
|
|
|
// If we're disabling a display alarm, close any message window
|
|
if (!enable && event.displayAction())
|
|
{
|
|
MessageWin* win = MessageWin::findEvent(event.id());
|
|
delete win;
|
|
}
|
|
|
|
// Update the window lists
|
|
AlarmListView::modifyEvent(event, selectionView);
|
|
}
|
|
return UPDATE_OK;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Display an error message about an error saving an event.
|
|
*/
|
|
void displayUpdateError(TQWidget* parent, UpdateStatus, UpdateError code, int nAlarms)
|
|
{
|
|
TQString errmsg;
|
|
switch (code)
|
|
{
|
|
case ERR_ADD:
|
|
errmsg = (nAlarms > 1) ? i18n("Error saving alarms")
|
|
: i18n("Error saving alarm");
|
|
break;
|
|
case ERR_DELETE:
|
|
errmsg = (nAlarms > 1) ? i18n("Error deleting alarms")
|
|
: i18n("Error deleting alarm");
|
|
break;
|
|
case ERR_REACTIVATE:
|
|
errmsg = (nAlarms > 1) ? i18n("Error saving reactivated alarms")
|
|
: i18n("Error saving reactivated alarm");
|
|
break;
|
|
case ERR_TEMPLATE:
|
|
errmsg = i18n("Error saving alarm template");
|
|
break;
|
|
}
|
|
KMessageBox::error(parent, errmsg);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Display an error message corresponding to a specified alarm update error code.
|
|
*/
|
|
void displayKOrgUpdateError(TQWidget* parent, KOrgUpdateError code, int nAlarms)
|
|
{
|
|
TQString errmsg;
|
|
switch (code)
|
|
{
|
|
case KORG_ERR_ADD:
|
|
errmsg = (nAlarms > 1) ? i18n("Unable to show alarms in KOrganizer")
|
|
: i18n("Unable to show alarm in KOrganizer");
|
|
break;
|
|
case KORG_ERR_MODIFY:
|
|
errmsg = i18n("Unable to update alarm in KOrganizer");
|
|
break;
|
|
case KORG_ERR_DELETE:
|
|
errmsg = (nAlarms > 1) ? i18n("Unable to delete alarms from KOrganizer")
|
|
: i18n("Unable to delete alarm from KOrganizer");
|
|
break;
|
|
}
|
|
KMessageBox::error(parent, errmsg);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Display the alarm edit dialogue to edit a specified alarm.
|
|
*/
|
|
bool edit(const TQString& eventID)
|
|
{
|
|
AlarmCalendar* cal;
|
|
switch (KAEvent::uidStatus(eventID))
|
|
{
|
|
case KAEvent::ACTIVE:
|
|
cal = AlarmCalendar::activeCalendar();
|
|
break;
|
|
case KAEvent::TEMPLATE:
|
|
cal = AlarmCalendar::templateCalendarOpen();
|
|
break;
|
|
default:
|
|
kdError(5950) << "KAlarm::edit(" << eventID << "): event not active or template" << endl;
|
|
return false;
|
|
}
|
|
KCal::Event* kcalEvent = cal->event(eventID);
|
|
if (!kcalEvent)
|
|
{
|
|
kdError(5950) << "KAlarm::edit(): event ID not found: " << eventID << endl;
|
|
return false;
|
|
}
|
|
KAEvent event(*kcalEvent);
|
|
MainWindow::executeEdit(event);
|
|
return true;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Display the alarm edit dialogue to edit a new alarm, optionally preset with
|
|
* a template.
|
|
*/
|
|
bool editNew(const TQString& templateName)
|
|
{
|
|
bool result = true;
|
|
if (!templateName.isEmpty())
|
|
{
|
|
AlarmCalendar* cal = AlarmCalendar::templateCalendarOpen();
|
|
if (cal)
|
|
{
|
|
KAEvent templateEvent = KAEvent::findTemplateName(*cal, templateName);
|
|
if (templateEvent.valid())
|
|
{
|
|
MainWindow::executeNew(templateEvent);
|
|
return true;
|
|
}
|
|
kdWarning(5950) << "KAlarm::editNew(" << templateName << "): template not found" << endl;
|
|
}
|
|
result = false;
|
|
}
|
|
MainWindow::executeNew();
|
|
return result;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Returns a list of all alarm templates.
|
|
* If shell commands are disabled, command alarm templates are omitted.
|
|
*/
|
|
TQValueList<KAEvent> templateList()
|
|
{
|
|
TQValueList<KAEvent> templates;
|
|
AlarmCalendar* cal = AlarmCalendar::templateCalendarOpen();
|
|
if (cal)
|
|
{
|
|
bool includeCmdAlarms = ShellProcess::authorised();
|
|
KCal::Event::List events = cal->events();
|
|
for (KCal::Event::List::ConstIterator it = events.begin(); it != events.end(); ++it)
|
|
{
|
|
KCal::Event* kcalEvent = *it;
|
|
KAEvent event(*kcalEvent);
|
|
if (includeCmdAlarms || event.action() != KAEvent::COMMAND)
|
|
templates.append(event);
|
|
}
|
|
}
|
|
return templates;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* To be called after an alarm has been edited.
|
|
* Prompt the user to re-enable alarms if they are currently disabled, and if
|
|
* it's an email alarm, warn if no 'From' email address is configured.
|
|
*/
|
|
void outputAlarmWarnings(TQWidget* parent, const KAEvent* event)
|
|
{
|
|
if (event && event->action() == KAEvent::EMAIL
|
|
&& Preferences::emailAddress().isEmpty())
|
|
KMessageBox::information(parent, i18n("Please set the 'From' email address...",
|
|
"%1\nPlease set it in the Preferences dialog.").arg(KAMail::i18n_NeedFromEmailAddress()));
|
|
|
|
if (!Daemon::monitoringAlarms())
|
|
{
|
|
if (KMessageBox::warningYesNo(parent, i18n("Alarms are currently disabled.\nDo you want to enable alarms now?"),
|
|
TQString(), i18n("Enable"), i18n("Keep Disabled"),
|
|
TQString::fromLatin1("EditEnableAlarms"))
|
|
== KMessageBox::Yes)
|
|
Daemon::setAlarmsEnabled();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Reset the alarm daemon and reload the calendar.
|
|
* If the daemon is not already running, start it.
|
|
*/
|
|
void resetDaemon()
|
|
{
|
|
kdDebug(5950) << "KAlarm::resetDaemon()" << endl;
|
|
if (!resetDaemonQueued)
|
|
{
|
|
resetDaemonQueued = true;
|
|
theApp()->processQueue();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* This method must only be called from the main KAlarm queue processing loop,
|
|
* to prevent asynchronous calendar operations interfering with one another.
|
|
*
|
|
* If resetDaemon() has been called, reset the alarm daemon and reload the calendars.
|
|
* If the daemon is not already running, start it.
|
|
*/
|
|
void resetDaemonIfQueued()
|
|
{
|
|
if (resetDaemonQueued)
|
|
{
|
|
kdDebug(5950) << "KAlarm::resetDaemonIfNeeded()" << endl;
|
|
AlarmCalendar::activeCalendar()->reload();
|
|
AlarmCalendar::expiredCalendar()->reload();
|
|
|
|
// Close any message windows for alarms which are now disabled
|
|
KAEvent event;
|
|
KCal::Event::List events = AlarmCalendar::activeCalendar()->events();
|
|
for (KCal::Event::List::ConstIterator it = events.begin(); it != events.end(); ++it)
|
|
{
|
|
KCal::Event* kcalEvent = *it;
|
|
event.set(*kcalEvent);
|
|
if (!event.enabled() && event.displayAction())
|
|
{
|
|
MessageWin* win = MessageWin::findEvent(event.id());
|
|
delete win;
|
|
}
|
|
}
|
|
|
|
MainWindow::refresh();
|
|
if (!Daemon::reset())
|
|
Daemon::start();
|
|
resetDaemonQueued = false;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Start KMail if it isn't already running, and optionally iconise it.
|
|
* Reply = reason for failure to run KMail (which may be the empty string)
|
|
* = null string if success.
|
|
*/
|
|
TQString runKMail(bool minimise)
|
|
{
|
|
TQCString dcopName;
|
|
TQString errmsg;
|
|
if (!runProgram("kmail", (minimise ? KMAIL_DCOP_WINDOW : ""), dcopName, errmsg))
|
|
return i18n("Unable to start KMail\n(%1)").arg(errmsg);
|
|
return TQString();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Start another program for DCOP access if it isn't already running.
|
|
* If 'windowName' is not empty, the program's window of that name is iconised.
|
|
* On exit, 'dcopName' contains the DCOP name to access the application, and
|
|
* 'errorMessage' contains an error message if failure.
|
|
* Reply = true if the program is now running.
|
|
*/
|
|
bool runProgram(const TQCString& program, const TQCString& windowName, TQCString& dcopName, TQString& errorMessage)
|
|
{
|
|
if (!kapp->dcopClient()->isApplicationRegistered(program))
|
|
{
|
|
// KOrganizer is not already running, so start it
|
|
if (TDEApplication::startServiceByDesktopName(TQString::fromLatin1(program), TQString(), &errorMessage, &dcopName))
|
|
{
|
|
kdError(5950) << "runProgram(): couldn't start " << program << " (" << errorMessage << ")\n";
|
|
return false;
|
|
}
|
|
// Minimise its window - don't use hide() since this would remove all
|
|
// trace of it from the panel if it is not configured to be docked in
|
|
// the system tray.
|
|
kapp->dcopClient()->send(dcopName, windowName, "minimize()", TQString());
|
|
}
|
|
else if (dcopName.isEmpty())
|
|
dcopName = program;
|
|
errorMessage = TQString();
|
|
return true;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Read the size for the specified window from the config file, for the
|
|
* current screen resolution.
|
|
* Reply = true if size set in the config file, in which case 'result' is set
|
|
* = false if no size is set, in which case 'result' is unchanged.
|
|
*/
|
|
bool readConfigWindowSize(const char* window, TQSize& result)
|
|
{
|
|
TDEConfig* config = TDEGlobal::config();
|
|
config->setGroup(TQString::fromLatin1(window));
|
|
TQWidget* desktop = TQT_TQWIDGET(TDEApplication::desktop());
|
|
TQSize s = TQSize(config->readNumEntry(TQString::fromLatin1("Width %1").arg(desktop->width()), 0),
|
|
config->readNumEntry(TQString::fromLatin1("Height %1").arg(desktop->height()), 0));
|
|
if (s.isEmpty())
|
|
return false;
|
|
result = s;
|
|
return true;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Write the size for the specified window to the config file, for the
|
|
* current screen resolution.
|
|
*/
|
|
void writeConfigWindowSize(const char* window, const TQSize& size)
|
|
{
|
|
TDEConfig* config = TDEGlobal::config();
|
|
config->setGroup(TQString::fromLatin1(window));
|
|
TQWidget* desktop = TQT_TQWIDGET(TDEApplication::desktop());
|
|
config->writeEntry(TQString::fromLatin1("Width %1").arg(desktop->width()), size.width());
|
|
config->writeEntry(TQString::fromLatin1("Height %1").arg(desktop->height()), size.height());
|
|
config->sync();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Return the current KAlarm version number.
|
|
*/
|
|
int Version()
|
|
{
|
|
static int version = 0;
|
|
if (!version)
|
|
version = getVersionNumber(KALARM_VERSION);
|
|
return version;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Convert the supplied KAlarm version string to a version number.
|
|
* Reply = version number (double digit for each of major, minor & issue number,
|
|
* e.g. 010203 for 1.2.3
|
|
* = 0 if invalid version string.
|
|
*/
|
|
int getVersionNumber(const TQString& version, TQString* subVersion)
|
|
{
|
|
// N.B. Remember to change Version(int major, int minor, int rev)
|
|
// if the representation returned by this method changes.
|
|
if (subVersion)
|
|
*subVersion = TQString();
|
|
int count = version.contains('.') + 1;
|
|
if (count < 2)
|
|
return 0;
|
|
bool ok;
|
|
unsigned vernum = version.section('.', 0, 0).toUInt(&ok) * 10000; // major version
|
|
if (!ok)
|
|
return 0;
|
|
unsigned v = version.section('.', 1, 1).toUInt(&ok); // minor version
|
|
if (!ok)
|
|
return 0;
|
|
vernum += (v < 99 ? v : 99) * 100;
|
|
if (count >= 3)
|
|
{
|
|
// Issue number: allow other characters to follow the last digit
|
|
TQString issue = version.section('.', 2);
|
|
if (!issue.at(0).isDigit())
|
|
return 0;
|
|
int n = issue.length();
|
|
int i;
|
|
for (i = 0; i < n && issue.at(i).isDigit(); ++i) ;
|
|
if (subVersion)
|
|
*subVersion = issue.mid(i);
|
|
v = issue.left(i).toUInt(); // issue number
|
|
vernum += (v < 99 ? v : 99);
|
|
}
|
|
return vernum;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Check from its mime type whether a file appears to be a text or image file.
|
|
* If a text file, its type is distinguished.
|
|
* Reply = file type.
|
|
*/
|
|
FileType fileType(const TQString& mimetype)
|
|
{
|
|
static const char* applicationTypes[] = {
|
|
"x-shellscript", "x-nawk", "x-awk", "x-perl", "x-python",
|
|
"x-desktop", "x-troff", 0 };
|
|
static const char* formattedTextTypes[] = {
|
|
"html", "xml", 0 };
|
|
|
|
if (mimetype.startsWith(TQString::fromLatin1("image/")))
|
|
return Image;
|
|
int slash = mimetype.find('/');
|
|
if (slash < 0)
|
|
return Unknown;
|
|
TQString type = mimetype.mid(slash + 1);
|
|
const char* typel = type.latin1();
|
|
if (mimetype.startsWith(TQString::fromLatin1("application")))
|
|
{
|
|
for (int i = 0; applicationTypes[i]; ++i)
|
|
if (!strcmp(typel, applicationTypes[i]))
|
|
return TextApplication;
|
|
}
|
|
else if (mimetype.startsWith(TQString::fromLatin1("text")))
|
|
{
|
|
for (int i = 0; formattedTextTypes[i]; ++i)
|
|
if (!strcmp(typel, formattedTextTypes[i]))
|
|
return TextFormatted;
|
|
return TextPlain;
|
|
}
|
|
return Unknown;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Display a modal dialogue to choose an existing file, initially highlighting
|
|
* any specified file.
|
|
* @param initialFile The file to initially highlight - must be a full path name or URL.
|
|
* @param defaultDir The directory to start in if @p initialFile is empty. If empty,
|
|
* the user's home directory will be used. Updated to the
|
|
* directory containing the selected file, if a file is chosen.
|
|
* @param mode OR of KFile::Mode values, e.g. ExistingOnly, LocalOnly.
|
|
* Reply = URL selected. If none is selected, URL.isEmpty() is true.
|
|
*/
|
|
TQString browseFile(const TQString& caption, TQString& defaultDir, const TQString& initialFile,
|
|
const TQString& filter, int mode, TQWidget* parent, const char* name)
|
|
{
|
|
TQString initialDir = !initialFile.isEmpty() ? TQString(initialFile).remove(TQRegExp("/[^/]*$"))
|
|
: !defaultDir.isEmpty() ? defaultDir
|
|
: TQDir::homeDirPath();
|
|
KFileDialog fileDlg(initialDir, filter, parent, name, true);
|
|
fileDlg.setOperationMode(mode & KFile::ExistingOnly ? KFileDialog::Opening : KFileDialog::Saving);
|
|
fileDlg.setMode(KFile::File | mode);
|
|
fileDlg.setCaption(caption);
|
|
if (!initialFile.isEmpty())
|
|
fileDlg.setSelection(initialFile);
|
|
if (fileDlg.exec() != TQDialog::Accepted)
|
|
return TQString();
|
|
KURL url = fileDlg.selectedURL();
|
|
defaultDir = url.path();
|
|
return (mode & KFile::LocalOnly) ? url.path() : url.prettyURL();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Return the first day of the week for the user's locale.
|
|
* Reply = 1 (Mon) .. 7 (Sun).
|
|
*/
|
|
int localeFirstDayOfWeek()
|
|
{
|
|
static int firstDay = 0;
|
|
if (!firstDay)
|
|
firstDay = TDEGlobal::locale()->weekStartDay();
|
|
return firstDay;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Return the supplied string with any accelerator code stripped out.
|
|
*/
|
|
TQString stripAccel(const TQString& text)
|
|
{
|
|
unsigned len = text.length();
|
|
TQString out = TQDeepCopy<TQString>(text);
|
|
TQChar *corig = (TQChar*)out.unicode();
|
|
TQChar *cout = corig;
|
|
TQChar *cin = cout;
|
|
while (len)
|
|
{
|
|
if ( *cin == '&' )
|
|
{
|
|
++cin;
|
|
--len;
|
|
if ( !len )
|
|
break;
|
|
}
|
|
*cout = *cin;
|
|
++cout;
|
|
++cin;
|
|
--len;
|
|
}
|
|
unsigned newlen = cout - corig;
|
|
if (newlen != out.length())
|
|
out.truncate(newlen);
|
|
return out;
|
|
}
|
|
|
|
} // namespace KAlarm
|
|
|
|
|
|
namespace {
|
|
|
|
/******************************************************************************
|
|
* Tell KOrganizer to put an alarm in its calendar.
|
|
* It will be held by KOrganizer as a simple event, without alarms - KAlarm
|
|
* is still responsible for alarming.
|
|
*/
|
|
bool sendToKOrganizer(const KAEvent& event)
|
|
{
|
|
KCal::Event* kcalEvent = event.event();
|
|
TQString uid = KAEvent::uid(event.id(), KAEvent::KORGANIZER);
|
|
kcalEvent->setUid(uid);
|
|
kcalEvent->clearAlarms();
|
|
TQString userEmail;
|
|
switch (event.action())
|
|
{
|
|
case KAEvent::MESSAGE:
|
|
case KAEvent::FILE:
|
|
case KAEvent::COMMAND:
|
|
kcalEvent->setSummary(event.cleanText());
|
|
userEmail = Preferences::emailAddress();
|
|
break;
|
|
case KAEvent::EMAIL:
|
|
{
|
|
TQString from = event.emailFromId()
|
|
? KAMail::identityManager()->identityForUoid(event.emailFromId()).fullEmailAddr()
|
|
: Preferences::emailAddress();
|
|
AlarmText atext;
|
|
atext.setEmail(event.emailAddresses(", "), from, TQString(), TQString(), event.emailSubject(), TQString());
|
|
kcalEvent->setSummary(atext.displayText());
|
|
userEmail = from;
|
|
break;
|
|
}
|
|
}
|
|
kcalEvent->setOrganizer(KCal::Person(TQString(), userEmail));
|
|
|
|
// Translate the event into string format
|
|
KCal::ICalFormat format;
|
|
format.setTimeZone(TQString(), false);
|
|
TQString iCal = format.toICalString(kcalEvent);
|
|
kdDebug(5950)<<"Korg->"<<iCal<<endl;
|
|
delete kcalEvent;
|
|
|
|
// Send the event to KOrganizer
|
|
if (!runKOrganizer()) // start KOrganizer if it isn't already running
|
|
return false;
|
|
TQByteArray data, replyData;
|
|
TQCString replyType;
|
|
TQDataStream arg(data, IO_WriteOnly);
|
|
arg << iCal;
|
|
if (kapp->dcopClient()->call(korganizerName, KORG_DCOP_OBJECT, "addIncidence(TQString)", data, replyType, replyData)
|
|
&& replyType == "bool")
|
|
{
|
|
bool result;
|
|
TQDataStream reply(replyData, IO_ReadOnly);
|
|
reply >> result;
|
|
if (result)
|
|
{
|
|
kdDebug(5950) << "sendToKOrganizer(" << uid << "): success\n";
|
|
return true;
|
|
}
|
|
}
|
|
kdError(5950) << "sendToKOrganizer(): KOrganizer addEvent(" << uid << ") dcop call failed\n";
|
|
return false;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Tell KOrganizer to delete an event from its calendar.
|
|
*/
|
|
bool deleteFromKOrganizer(const TQString& eventID)
|
|
{
|
|
if (!runKOrganizer()) // start KOrganizer if it isn't already running
|
|
return false;
|
|
TQString newID = KAEvent::uid(eventID, KAEvent::KORGANIZER);
|
|
TQByteArray data, replyData;
|
|
TQCString replyType;
|
|
TQDataStream arg(data, IO_WriteOnly);
|
|
arg << newID << true;
|
|
if (kapp->dcopClient()->call(korganizerName, KORG_DCOP_OBJECT, "deleteIncidence(TQString,bool)", data, replyType, replyData)
|
|
&& replyType == "bool")
|
|
{
|
|
bool result;
|
|
TQDataStream reply(replyData, IO_ReadOnly);
|
|
reply >> result;
|
|
if (result)
|
|
{
|
|
kdDebug(5950) << "deleteFromKOrganizer(" << newID << "): success\n";
|
|
return true;
|
|
}
|
|
}
|
|
kdError(5950) << "sendToKOrganizer(): KOrganizer deleteEvent(" << newID << ") dcop call failed\n";
|
|
return false;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Start KOrganizer if not already running, and create its DCOP interface.
|
|
*/
|
|
bool runKOrganizer()
|
|
{
|
|
TQString error;
|
|
TQCString dcopService;
|
|
int result = KDCOPServiceStarter::self()->findServiceFor("DCOP/Organizer", TQString(), TQString(), &error, &dcopService);
|
|
if (result)
|
|
{
|
|
kdDebug(5950) << "Unable to start DCOP/Organizer: " << dcopService << " " << error << endl;
|
|
return false;
|
|
}
|
|
// If Kontact is running, there is be a load() method which needs to be called
|
|
// to load KOrganizer into Kontact. But if KOrganizer is running independently,
|
|
// the load() method doesn't exist.
|
|
TQCString dummy;
|
|
if (!kapp->dcopClient()->findObject(dcopService, KORG_DCOP_OBJECT, "", TQByteArray(), dummy, dummy))
|
|
{
|
|
DCOPRef ref(dcopService, dcopService); // talk to the KUniqueApplication or its Kontact wrapper
|
|
DCOPReply reply = ref.call("load()");
|
|
if (!reply.isValid() || !(bool)reply)
|
|
{
|
|
kdWarning(5950) << "Error loading " << dcopService << endl;
|
|
return false;
|
|
}
|
|
if (!kapp->dcopClient()->findObject(dcopService, KORG_DCOP_OBJECT, "", TQByteArray(), dummy, dummy))
|
|
{
|
|
kdWarning(5950) << "Unable to access KOrganizer's " KORG_DCOP_OBJECT " DCOP object" << endl;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
#ifdef HAVE_XTEST
|
|
#include <X11/keysym.h>
|
|
#include <X11/extensions/XTest.h>
|
|
#include <tqwindowdefs.h>
|
|
|
|
/******************************************************************************
|
|
* Cancel the screen saver, in case it is active.
|
|
* Only implemented if the X11 XTest extension is installed.
|
|
*/
|
|
void x11_cancelScreenSaver()
|
|
{
|
|
kdDebug(5950) << "KAlarm::cancelScreenSaver()" << endl;
|
|
Display* display = tqt_xdisplay();
|
|
static int XTestKeyCode = 0;
|
|
if (!XTestKeyCode)
|
|
XTestKeyCode = XKeysymToKeycode(display, XK_Shift_L);
|
|
XTestFakeKeyEvent(display, XTestKeyCode, true, CurrentTime);
|
|
XTestFakeKeyEvent(display, XTestKeyCode, false, CurrentTime);
|
|
XSync(display, false);
|
|
}
|
|
#endif // HAVE_XTEST
|