• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdepim

• Sitemap
• Contact Us

 

kalarm

functions.cpp

Go to the documentation of this file.

/*  functions.cpp  -  miscellaneous functions
 *  Program:  kalarm
 *  Copyright © 2001-2008 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"   //krazy:exclude=includes (kalarm.h must be first)
#include "functions.h"

#include "alarmcalendar.h"
#include "alarmevent.h"
#include "eventlistmodel.h"
#include "alarmlistview.h"
#include "alarmresources.h"
#include "editdlg.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 <QDir>
#include <QRegExp>
#include <QDesktopWidget>
#include <QtDBus/QtDBus>

#include <kconfiggroup.h>
#include <kaction.h>
#include <ktoggleaction.h>
#include <kactioncollection.h>
#include <kglobal.h>
#include <klocale.h>
#include <kstandarddirs.h>
#include <ksystemtimezone.h>
#include <KStandardGuiItem>
#include <kstandardshortcut.h>
#include <kmessagebox.h>
#include <kfiledialog.h>
#include <kwindowsystem.h>
#include <kicon.h>
#include <kdebug.h>

#include <kcal/event.h>
#include <kcal/icalformat.h>
#include <kpimidentities/identitymanager.h>
#include <kpimidentities/identity.h>
#include <kcal/person.h>
#include <libkholidays/kholidays.h>
#include <ktoolinvocation.h>


namespace
{
bool          refreshAlarmsQueued = false;
QString       korganizerName    = "korganizer";
QString       korgStartError;
QDBusInterface* korgInterface = 0;

const char*   KMAIL_DBUS_SERVICE      = "org.kde.kmail";
//const char*   KMAIL_DBUS_IFACE        = "org.kde.kmail.kmail";
const char*   KMAIL_DBUS_WINDOW_PATH  = "/kmail/kmail_mainwindow_1";
const char*   KORG_DBUS_SERVICE       = "org.kde.korganizer";
const char*   KORG_DBUS_IFACE         = "org.kde.korganizer.Korganizer";
const char*   KORG_DBUS_PATH          = "/";    // D-Bus object path of KOrganizer's notification interface
const char*   KORG_DBUS_WINDOW_PATH   = "/korganizer/MainWindow_1";
const QString KORGANIZER_UID         = QString::fromLatin1("-korg");

const char*   ALARM_OPTS_FILE        = "alarmopts";
const char*   DONT_SHOW_ERRORS_GROUP = "DontShowErrors";

bool sendToKOrganizer(const KAEvent*);
bool deleteFromKOrganizer(const QString& eventID);
bool runKOrganizer();
QString uidKOrganizer(const QString& eventID);
}


namespace KAlarm
{

void doEditNewAlarm(EditAlarmDlg*);


/******************************************************************************
*  Display a main window with the specified event selected.
*/
MainWindow* displayMainWindowSelected(const QString& eventID)
{
    MainWindow* win = MainWindow::firstWindow();
    if (!win)
    {
        if (theApp()->checkCalendar())    // ensure calendar is open
        {
            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->setWindowState(win->windowState() & ~Qt::WindowMinimized);
            win->show();
        }
        win->raise();
        win->activateWindow();
    }
    if (win  &&  !eventID.isEmpty())
        win->selectEvent(eventID);
    return win;
}

/******************************************************************************
* Create an "Alarms Enabled/Enable Alarms" action.
*/
KToggleAction* createAlarmEnableAction(QObject* parent)
{
    KToggleAction* action = new KToggleAction(i18nc("@action", "Enable &Alarms"), parent);
    action->setChecked(theApp()->alarmsEnabled());
    QObject::connect(action, SIGNAL(toggled(bool)), theApp(), SLOT(setAlarmsEnabled(bool)));
    // The following line ensures that all instances are kept in the same state
    QObject::connect(theApp(), SIGNAL(alarmEnabledToggled(bool)), action, SLOT(setChecked(bool)));
    return action;
}

/******************************************************************************
* Create a New From Template QAction.
*/
TemplateMenuAction* createNewFromTemplateAction(const QString& label, KActionCollection* actions, const QString& name)
{
    return new TemplateMenuAction(KIcon(QLatin1String("document-new-from-template")), label, actions, name);
}

/******************************************************************************
* Add a new active (non-archived) alarm.
* Save it in the calendar file and add it to every main window instance.
* Parameters: msgParent = parent widget for any resource selection prompt or
* error message.
* 'event' is updated with the actual event ID.
*/
UpdateStatus addEvent(KAEvent& event, AlarmResource* resource, QWidget* msgParent, int options, bool showKOrgErr)
{
    kDebug() << event.id();
    bool cancelled = false;
    UpdateStatus status = UPDATE_OK;
    if (!theApp()->checkCalendar())    // ensure calendar is open
        status = UPDATE_FAILED;
    else
    {
        // Save the event details in the calendar file, and get the new event ID
        AlarmCalendar* cal = AlarmCalendar::resources();
        KAEvent* newev = new KAEvent(event);
        if (!cal->addEvent(newev, msgParent, (options & USE_EVENT_ID), resource, (options & NO_RESOURCE_PROMPT), &cancelled))
        {
            delete newev;
            status = UPDATE_FAILED;
        }
        else
        {
            event = *newev;   // update event ID etc.
            if (!cal->save())
                status = SAVE_FAILED;
        }
        if (status == UPDATE_OK)
        {
            if ((options & ALLOW_KORG_UPDATE)  &&  event.copyToKOrganizer())
            {
                if (!sendToKOrganizer(newev))    // tell KOrganizer to show the event
                    status = UPDATE_KORG_ERR;
            }

            // Update the window lists
            EventListModel::alarms()->addEvent(newev);
        }
    }

    if (status != UPDATE_OK  &&  !cancelled  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_ADD, 1, 1, showKOrgErr);
    return status;
}

/******************************************************************************
* Add a list of new active (non-archived) alarms.
* Save them in the calendar file and add them to every main window instance.
* The events are updated with their actual event IDs.
*/
UpdateStatus addEvents(QList<KAEvent>& events, QWidget* msgParent, bool allowKOrgUpdate, bool showKOrgErr)
{
    kDebug() << events.count();
    if (events.isEmpty())
        return UPDATE_OK;
    int warnErr = 0;
    int warnKOrg = 0;
    UpdateStatus status = UPDATE_OK;
    AlarmResource* resource;
    if (!theApp()->checkCalendar())    // ensure calendar is open
        status = UPDATE_FAILED;
    else
    {
        resource = AlarmResources::instance()->destination(KCalEvent::ACTIVE, msgParent);
        if (!resource)
        {
            kDebug() << "No resource";
            status = UPDATE_FAILED;
        }
    }
    if (status == UPDATE_OK)
    {
        QString selectID;
        AlarmCalendar* cal = AlarmCalendar::resources();
        for (int i = 0, end = events.count();  i < end;  ++i)
        {
            // Save the event details in the calendar file, and get the new event ID
            KAEvent* newev = new KAEvent(events[i]);
            if (!cal->addEvent(newev, msgParent, false, resource))
            {
                delete newev;
                status = UPDATE_ERROR;
                ++warnErr;
                continue;
            }
            events[i] = *newev;   // update event ID etc.
            if (allowKOrgUpdate  &&  newev->copyToKOrganizer())
            {
                if (!sendToKOrganizer(newev))    // tell KOrganizer to show the event
                {
                    ++warnKOrg;
                    if (status == UPDATE_OK)
                        status = UPDATE_KORG_ERR;
                }
            }

            // Update the window lists, but not yet which item is selected
            EventListModel::alarms()->addEvent(newev);
//          selectID = newev->id();
        }
        if (warnErr == events.count())
            status = UPDATE_FAILED;
        else if (!cal->save())
        {
            status = SAVE_FAILED;
            warnErr = 0;    // everything failed
        }
    }

    if (status != UPDATE_OK  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_ADD, (warnErr ? warnErr : events.count()), warnKOrg, showKOrgErr);
    return status;
}

/******************************************************************************
* Save the event in the archived resource and adjust every main window instance.
* The event's ID is changed to an archived ID if necessary.
*/
bool addArchivedEvent(KAEvent& event, AlarmResource* resource)
{
    kDebug() << event.id();
    QString oldid = event.id();
    bool archiving = (event.category() == KCalEvent::ACTIVE);
    if (archiving  &&  !Preferences::archivedKeepDays())
        return false;   // expired alarms aren't being kept
    KAEvent* newev = new KAEvent(event);
    if (archiving)
    {
        newev->setCategory(KCalEvent::ARCHIVED);    // this changes the event ID
        newev->setSaveDateTime(KDateTime::currentUtcDateTime());   // time stamp to control purging
    }
    AlarmCalendar* cal = AlarmCalendar::resources();
    // Note that archived resources are automatically saved after changes are made
    if (!cal->addEvent(newev, 0, false, resource))
    {
        delete newev;     // failed to add to calendar - leave event in its original state
        return false;
    }
    event = *newev;   // update event ID etc.

    // Update window lists.
    // Note: updateEvent() is not used here since that doesn't trigger refiltering
    // of the alarm list, resulting in the archived event still remaining visible
    // even if archived events are supposed to be hidden.
    if (archiving)
        EventListModel::alarms()->removeEvent(oldid);
    EventListModel::alarms()->addEvent(newev);
    return true;
}

/******************************************************************************
* Add a new template.
* Save it in the calendar file and add it to every template list view.
* 'event' is updated with the actual event ID.
* Parameters: promptParent = parent widget for any resource selection prompt.
*/
UpdateStatus addTemplate(KAEvent& event, AlarmResource* resource, QWidget* msgParent)
{
    kDebug() << event.id();
    UpdateStatus status = UPDATE_OK;

    // Add the template to the calendar file
    KAEvent* newev = new KAEvent(event);
    AlarmCalendar* cal = AlarmCalendar::resources();
    if (!cal->addEvent(newev, msgParent, false, resource))
    {
        delete newev;
        status = UPDATE_FAILED;
    }
    else
    {
        event = *newev;   // update event ID etc.
        if (!cal->save())
            status = SAVE_FAILED;
        else
        {
            cal->emitEmptyStatus();

            // Update the window lists
            EventListModel::templates()->addEvent(newev);
            return UPDATE_OK;
        }
    }

    if (msgParent)
        displayUpdateError(msgParent, status, ERR_TEMPLATE, 1);
    return status;
}

/******************************************************************************
* Modify an active (non-archived) alarm in the calendar file and in every main
* window instance.
* The new event must have a different event ID from the old one.
*/
UpdateStatus modifyEvent(KAEvent& oldEvent, KAEvent& newEvent, QWidget* msgParent, bool showKOrgErr)
{
    kDebug() << oldEvent.id();

    UpdateStatus status = UPDATE_OK;
    if (!newEvent.valid())
    {
        deleteEvent(oldEvent, true);
        status = UPDATE_FAILED;
    }
    else
    {
        QString oldId = oldEvent.id();
        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(oldId);
        }
        // Delete from the window lists to prevent the event's invalid
        // pointer being accessed.
        EventListModel::alarms()->removeEvent(oldId);

        // Update the event in the calendar file, and get the new event ID
        KAEvent* newev = new KAEvent(newEvent);
        AlarmCalendar* cal = AlarmCalendar::resources();
        if (!cal->modifyEvent(oldId, newev))
        {
            delete newev;
            status = UPDATE_FAILED;
        }
        else
        {
            newEvent = *newev;
            if (!cal->save())
                status = SAVE_FAILED;
            if (status == UPDATE_OK)
            {
                if (newev->copyToKOrganizer())
                {
                    if (!sendToKOrganizer(newev))    // tell KOrganizer to show the new event
                        status = UPDATE_KORG_ERR;
                }

                // Remove "Don't show error messages again" for the old alarm
                setDontShowErrors(oldId);

                // Update the window lists
                EventListModel::alarms()->addEvent(newev);
            }
        }
    }

    if (status != UPDATE_OK  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_MODIFY, 1, 1, showKOrgErr);
    return status;
}

/******************************************************************************
* Update an active (non-archived) alarm from the calendar file and from every
* main window instance.
* The new event will have the same event ID as the old one.
* 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, QWidget* msgParent, bool archiveOnDelete)
{
    kDebug() << event.id();

    if (!event.valid())
        deleteEvent(event, archiveOnDelete);
    else
    {
        // Update the event in the calendar file.
        AlarmCalendar* cal = AlarmCalendar::resources();
        KAEvent* newEvent = cal->updateEvent(event);
        if (!cal->save())
        {
            if (msgParent)
                displayUpdateError(msgParent, SAVE_FAILED, ERR_ADD, 1);
            return SAVE_FAILED;
        }

        // Update the window lists
        EventListModel::alarms()->updateEvent(newEvent);
    }
    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(KAEvent& event, QWidget* msgParent)
{
    AlarmCalendar* cal = AlarmCalendar::resources();
    KAEvent* newEvent = cal->updateEvent(event);
    UpdateStatus status = UPDATE_OK;
    if (!newEvent)
        status = UPDATE_FAILED;
    else if (!cal->save())
        status = SAVE_FAILED;
    if (status != UPDATE_OK)
    {
        if (msgParent)
            displayUpdateError(msgParent, SAVE_FAILED, ERR_TEMPLATE, 1);
        return status;
    }

    EventListModel::templates()->updateEvent(newEvent);
    return UPDATE_OK;
}

/******************************************************************************
* Delete alarms from the calendar file and from every main window instance.
* If the events are archived, the events' IDs are changed to archived IDs if necessary.
*/
UpdateStatus deleteEvent(KAEvent& event, bool archive, QWidget* msgParent, bool showKOrgErr)
{
    KAEvent::List events;
    events += &event;
    return deleteEvents(events, archive, msgParent, showKOrgErr);
}

UpdateStatus deleteEvents(KAEvent::List& events, bool archive, QWidget* msgParent, bool showKOrgErr)
{
    kDebug() << events.count();
    if (events.isEmpty())
        return UPDATE_OK;
    int warnErr = 0;
    int warnKOrg = 0;
    UpdateStatus status = UPDATE_OK;
    AlarmCalendar* cal = AlarmCalendar::resources();
    for (int i = 0, end = events.count();  i < end;  ++i)
    {
        // Save the event details in the calendar file, and get the new event ID
        KAEvent* event = events[i];
        QString id = event->id();

        // Update the window lists
        EventListModel::alarms()->removeEvent(id);

        // Delete the event from the calendar file
        if (event->category() != KCalEvent::ARCHIVED)
        {
            if (event->copyToKOrganizer())
            {
                // The event was shown in KOrganizer, so tell KOrganizer to
                // delete it. But ignore errors, because the user could have
                // manually deleted it from KOrganizer since it was set up.
                if (!deleteFromKOrganizer(id))
                {
                    ++warnKOrg;
                    if (status == UPDATE_OK)
                        status = UPDATE_KORG_ERR;
                }
            }
            if (archive  &&  event->toBeArchived())
                addArchivedEvent(*event);     // this changes the event ID to an archived ID
        }
        if (!cal->deleteEvent(id, false))   // don't save calendar after deleting
        {
            status = UPDATE_ERROR;
            ++warnErr;
        }

        // Remove "Don't show error messages again" for this alarm
        setDontShowErrors(id);
    }

    if (warnErr == events.count())
        status = UPDATE_FAILED;
    else if (!cal->save())      // save the calendars now
    {
        status = SAVE_FAILED;
        warnErr = events.count();
    }
    if (status != UPDATE_OK  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_DELETE, warnErr, warnKOrg, showKOrgErr);
    return status;
}

/******************************************************************************
* Delete templates from the calendar file and from every template list view.
*/
UpdateStatus deleteTemplates(const QStringList& eventIDs, QWidget* msgParent)
{
    kDebug() << eventIDs.count();
    if (eventIDs.isEmpty())
        return UPDATE_OK;
    int warnErr = 0;
    UpdateStatus status = UPDATE_OK;
    AlarmCalendar* cal = AlarmCalendar::resources();
    for (int i = 0, end = eventIDs.count();  i < end;  ++i)
    {
        // Update the window lists
        QString id = eventIDs[i];
        EventListModel::templates()->removeEvent(id);

        // Delete the template from the calendar file
        AlarmCalendar* cal = AlarmCalendar::resources();
        if (!cal->deleteEvent(id, false))    // don't save calendar after deleting
        {
            status = UPDATE_ERROR;
            ++warnErr;
        }
    }

    if (warnErr == eventIDs.count())
        status = UPDATE_FAILED;
    else if (!cal->save())      // save the calendars now
    {
        status = SAVE_FAILED;
        warnErr = eventIDs.count();
    }
    cal->emitEmptyStatus();
    if (status != UPDATE_OK  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_TEMPLATE, warnErr);
    return status;
}

/******************************************************************************
* Delete an alarm from the display calendar.
*/
void deleteDisplayEvent(const QString& eventID)
{
    kDebug() << eventID;
    AlarmCalendar* cal = AlarmCalendar::displayCalendarOpen();
    if (cal)
        cal->deleteEvent(eventID, true);   // save calendar after deleting
}

/******************************************************************************
* Undelete archived alarms, and update every main window instance.
* The archive bit is set to ensure that they get re-archived if deleted again.
* 'ineligibleIDs' is filled in with the IDs of any ineligible events.
*/
UpdateStatus reactivateEvent(KAEvent& event, AlarmResource* resource, QWidget* msgParent, bool showKOrgErr)
{
    QStringList ids;
    KAEvent::List events;
    events += &event;
    return reactivateEvents(events, ids, resource, msgParent, showKOrgErr);
}

UpdateStatus reactivateEvents(KAEvent::List& events, QStringList& ineligibleIDs, AlarmResource* resource, QWidget* msgParent, bool showKOrgErr)
{
    kDebug() << events.count();
    ineligibleIDs.clear();
    if (events.isEmpty())
        return UPDATE_OK;
    int warnErr = 0;
    int warnKOrg = 0;
    UpdateStatus status = UPDATE_OK;
    if (!resource)
        resource = AlarmResources::instance()->destination(KCalEvent::ACTIVE, msgParent);
    if (!resource)
    {
        kDebug() << "No resource";
        status = UPDATE_FAILED;
        warnErr = events.count();
    }
    else
    {
        QString selectID;
        int count = 0;
        AlarmCalendar* cal = AlarmCalendar::resources();
        KDateTime now = KDateTime::currentUtcDateTime();
        for (int i = 0, end = events.count();  i < end;  ++i)
        {
            // Delete the event from the archived resource
            KAEvent* event = events[i];
            if (event->category() != KCalEvent::ARCHIVED
            ||  !event->occursAfter(now, true))
            {
                ineligibleIDs += event->id();
                continue;
            }
            ++count;

            KAEvent* newev = new KAEvent(*event);
            QString oldid = event->id();
            newev->setCategory(KCalEvent::ACTIVE);    // this changes the event ID
            if (newev->recurs()  ||  newev->repeatCount())
                newev->setNextOccurrence(now);   // skip any recurrences in the past
            newev->setArchive();    // ensure that it gets re-archived if it is deleted

            // Save the event details in the calendar file.
            // This converts the event ID.
            if (!cal->addEvent(newev, msgParent, true, resource))
            {
                delete newev;
                status = UPDATE_ERROR;
                ++warnErr;
                continue;
            }
            if (newev->copyToKOrganizer())
            {
                if (!sendToKOrganizer(newev))    // tell KOrganizer to show the event
                {
                    ++warnKOrg;
                    if (status == UPDATE_OK)
                        status = UPDATE_KORG_ERR;
                }
            }

            // Update the window lists
            EventListModel::alarms()->updateEvent(oldid, newev);
//          selectID = newev->id();

            if (cal->event(oldid)    // no error if event doesn't exist in archived resource
            &&  !cal->deleteEvent(oldid, false))   // don't save calendar after deleting
            {
                status = UPDATE_ERROR;
                ++warnErr;
            }
            events[i] = newev;
        }

        if (warnErr == count)
            status = UPDATE_FAILED;
        // Save the calendars, even if all events failed, since more than one calendar was updated
        if (!cal->save()  &&  status != UPDATE_FAILED)
        {
            status = SAVE_FAILED;
            warnErr = count;
        }
    }
    if (status != UPDATE_OK  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_REACTIVATE, warnErr, warnKOrg, showKOrgErr);
    return status;
}

/******************************************************************************
* Enable or disable alarms in the calendar file and in every main window instance.
* The new events will have the same event IDs as the old ones.
*/
UpdateStatus enableEvents(KAEvent::List& events, bool enable, QWidget* msgParent)
{
    kDebug() << events.count();
    if (events.isEmpty())
        return UPDATE_OK;
    UpdateStatus status = UPDATE_OK;
    AlarmCalendar* cal = AlarmCalendar::resources();
    for (int i = 0, end = events.count();  i < end;  ++i)
    {
        KAEvent* event = events[i];
        if (enable != event->enabled())
        {
            event->setEnabled(enable);

            // Update the event in the calendar file
            KAEvent* newev = cal->updateEvent(event);

            // 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
            EventListModel::alarms()->updateEvent(newev);
        }
    }

    if (!cal->save())
        status = SAVE_FAILED;
    if (status != UPDATE_OK  &&  msgParent)
        displayUpdateError(msgParent, status, ERR_ADD, events.count(), 0);
    return status;
}

/******************************************************************************
* This method must only be called from the main KAlarm queue processing loop,
* to prevent asynchronous calendar operations interfering with one another.
*
* Purge all archived events from the default archived alarm resource whose end
* time is longer ago than 'purgeDays'. All events are deleted if 'purgeDays' is
* zero.
*/
void purgeArchive(int purgeDays)
{
    if (purgeDays < 0)
        return;
    kDebug() << purgeDays;
    QDate cutoff = QDate::currentDate().addDays(-purgeDays);
    AlarmResource* resource = AlarmResources::instance()->getStandardResource(AlarmResource::ARCHIVED);
    if (!resource)
        return;
    KAEvent::List events = AlarmCalendar::resources()->events(resource);
    for (int i = 0;  i < events.count();  )
    {
        KAEvent* event = events[i];
        KCal::Incidence* kcalIncidence = resource->incidence(event->id());
        if (purgeDays  &&  kcalIncidence  &&  kcalIncidence->created().date() >= cutoff)
            events.removeAt(i);
        else
            EventListModel::alarms()->removeEvent(events[i++]);   // update the window lists
    }
    if (!events.isEmpty())
        AlarmCalendar::resources()->purgeEvents(events);   // delete the events and save the calendar
}

/******************************************************************************
* Display an error message about an error when saving an event.
*/
void displayUpdateError(QWidget* parent, UpdateStatus status, UpdateError code, int nAlarms, int nKOrgAlarms, bool showKOrgError)
{
    QString errmsg;
    if (status > UPDATE_KORG_ERR)
    {
        switch (code)
        {
            case ERR_ADD:
            case ERR_MODIFY:
                errmsg = (nAlarms > 1) ? i18nc("@info", "Error saving alarms")
                                       : i18nc("@info", "Error saving alarm");
                break;
            case ERR_DELETE:
                errmsg = (nAlarms > 1) ? i18nc("@info", "Error deleting alarms")
                                       : i18nc("@info", "Error deleting alarm");
                break;
            case ERR_REACTIVATE:
                errmsg = (nAlarms > 1) ? i18nc("@info", "Error saving reactivated alarms")
                                       : i18nc("@info", "Error saving reactivated alarm");
                break;
            case ERR_TEMPLATE:
                errmsg = (nAlarms > 1) ? i18nc("@info", "Error saving alarm templates")
                                       : i18nc("@info", "Error saving alarm template");
                break;
        }
        KMessageBox::error(parent, errmsg);
    }
    else if (showKOrgError)
        displayKOrgUpdateError(parent, code, nKOrgAlarms);
}

/******************************************************************************
* Display an error message corresponding to a specified alarm update error code.
*/
void displayKOrgUpdateError(QWidget* parent, UpdateError code, int nAlarms)
{
    QString errmsg;
    switch (code)
    {
        case ERR_ADD:
        case ERR_REACTIVATE:
            errmsg = (nAlarms > 1) ? i18nc("@info", "Unable to show alarms in KOrganizer")
                                   : i18nc("@info", "Unable to show alarm in KOrganizer");
            break;
        case ERR_MODIFY:
            errmsg = i18nc("@info", "Unable to update alarm in KOrganizer");
            break;
        case ERR_DELETE:
            errmsg = (nAlarms > 1) ? i18nc("@info", "Unable to delete alarms from KOrganizer")
                                   : i18nc("@info", "Unable to delete alarm from KOrganizer");
            break;
        case ERR_TEMPLATE:
            return;
    }
    KMessageBox::error(parent, errmsg);
}

/******************************************************************************
* Execute a New Alarm dialog for the specified alarm type.
*/
void editNewAlarm(EditAlarmDlg::Type type, QWidget* parent)
{
    EditAlarmDlg* editDlg = EditAlarmDlg::create(false, type, true, parent);
    doEditNewAlarm(editDlg);
    delete editDlg;
}

/******************************************************************************
* Execute a New Alarm dialog for the specified alarm type.
*/
void editNewAlarm(KAEvent::Action action, QWidget* parent, const AlarmText* text)
{
    bool setAction = false;
    EditAlarmDlg::Type type;
    switch (action)
    {
        case KAEvent::MESSAGE:
        case KAEvent::FILE:
            type = EditAlarmDlg::DISPLAY;
            setAction = true;
            break;
        case KAEvent::COMMAND:
            type = EditAlarmDlg::COMMAND;
            break;
        case KAEvent::EMAIL:
            type = EditAlarmDlg::EMAIL;
            break;
    }
    EditAlarmDlg* editDlg = EditAlarmDlg::create(false, type, true, parent);
    if (setAction  ||  text)
        editDlg->setAction(action, *text);
    doEditNewAlarm(editDlg);
    delete editDlg;
}

/******************************************************************************
* Execute a New Alarm dialog, optionally either presetting it to the supplied
* event, or setting the action and text.
*/
void editNewAlarm(const KAEvent* preset, QWidget* parent)
{
    EditAlarmDlg* editDlg = EditAlarmDlg::create(false, preset, true, parent);
    doEditNewAlarm(editDlg);
    delete editDlg;
}

/******************************************************************************
* Common code for editNewAlarm() variants.
*/
void doEditNewAlarm(EditAlarmDlg* editDlg)
{
    if (editDlg->exec() == QDialog::Accepted)
    {
        KAEvent event;
        AlarmResource* resource;
        editDlg->getEvent(event, resource);

        // Add the alarm to the displayed lists and to the calendar file
        switch (addEvent(event, resource, editDlg))
        {
            case UPDATE_FAILED:
                return;
            case UPDATE_KORG_ERR:
                displayKOrgUpdateError(editDlg, ERR_ADD, 1);
                break;
            default:
                break;
        }
        Undo::saveAdd(event, resource);

        outputAlarmWarnings(editDlg, &event);
    }
}

/******************************************************************************
* Display the alarm edit dialog to edit a new alarm, preset with a template.
*/
bool editNewAlarm(const QString& templateName, QWidget* parent)
{
    if (!templateName.isEmpty())
    {
        KAEvent* templateEvent = AlarmCalendar::resources()->templateEvent(templateName);
        if (templateEvent->valid())
        {
            editNewAlarm(templateEvent, parent);
            return true;
        }
        kWarning() << templateName << ": template not found";
    }
    return false;
}

/******************************************************************************
* Create a new template.
*/
void editNewTemplate(EditAlarmDlg::Type type, QWidget* parent)
{
    EditAlarmDlg* editDlg = EditAlarmDlg::create(true, type, true, parent);
    if (editDlg->exec() == QDialog::Accepted)
    {
        KAEvent event;
        AlarmResource* resource;
        editDlg->getEvent(event, resource);

        // Add the template to the displayed lists and to the calendar file
        addTemplate(event, resource, editDlg);
        Undo::saveAdd(event, resource);
    }
    delete editDlg;
}

/******************************************************************************
* Create a new template, based