• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdepim

• Sitemap
• Contact Us

 

kalarm

kalarmapp.cpp

Go to the documentation of this file.

/*
 *  kalarmapp.cpp  -  the KAlarm application object
 *  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"
#include "kalarmapp.moc"

#include "alarmcalendar.h"
#include "eventlistmodel.h"
#include "alarmlistview.h"
#include "birthdaymodel.h"
#include "editdlg.h"
#include "dbushandler.h"
#include "functions.h"
#include "kamail.h"
#include "karecurrence.h"
#include "mainwindow.h"
#include "messagebox.h"
#include "messagewin.h"
#include "preferences.h"
#include "prefdlg.h"
#include "shellprocess.h"
#include "startdaytimer.h"
#include "traywindow.h"

#include <stdlib.h>
#include <ctype.h>
#include <iostream>
#include <climits>

#include <QObject>
#include <QTimer>
#include <QRegExp>
#include <QFile>
#include <QByteArray>
#include <QTextStream>

#include <kcmdlineargs.h>
#include <klocale.h>
#include <kstandarddirs.h>
#include <kconfig.h>
#include <kaboutdata.h>
#include <ktemporaryfile.h>
#include <kfileitem.h>
#include <kglobal.h>
#include <kstandardguiitem.h>
#include <kservicetypetrader.h>
#include <netwm.h>
#include <kdebug.h>
#include <kshell.h>

static bool convInterval(const QByteArray& timeParam, KARecurrence::Type&, int& timeInterval, bool allowMonthYear = false);

/******************************************************************************
* Find the maximum number of seconds late which a late-cancel alarm is allowed
* to be. This is calculated as the late cancel interval, plus a few seconds
* leeway to cater for any timing irregularities.
*/
static inline int maxLateness(int lateCancel)
{
    static const int LATENESS_LEEWAY = 5;
    int lc = (lateCancel >= 1) ? (lateCancel - 1)*60 : 0;
    return LATENESS_LEEWAY + lc;
}


KAlarmApp*  KAlarmApp::theInstance  = 0;
int         KAlarmApp::mActiveCount = 0;
int         KAlarmApp::mFatalError  = 0;
QString     KAlarmApp::mFatalMessage;


/******************************************************************************
* Construct the application.
*/
KAlarmApp::KAlarmApp()
    : KUniqueApplication(),
      mInitialised(false),
      mQuitting(false),
      mLoginAlarmsDone(false),
      mDBusHandler(new DBusHandler()),
      mTrayWindow(0),
      mAlarmTimer(new QTimer(this)),
      mArchivedPurgeDays(-1),      // default to not purging
      mPurgeDaysQueued(-1),
      mPendingQuit(false),
      mProcessingQueue(false),
      mSessionClosingDown(false),
      mAlarmsEnabled(true),
      mSpeechEnabled(false)
{
    kDebug();
    mAlarmTimer->setSingleShot(true);
    connect(mAlarmTimer, SIGNAL(timeout()), SLOT(checkNextDueAlarm()));

    setQuitOnLastWindowClosed(false);
    Preferences::self()->readConfig();
    Preferences::setAutoStart(true);
    Preferences::self()->writeConfig();
    Preferences::connect(SIGNAL(startOfDayChanged(const QTime&, const QTime&)), this, SLOT(changeStartOfDay()));
    Preferences::connect(SIGNAL(feb29TypeChanged(Feb29Type)), this, SLOT(slotFeb29TypeChanged(Feb29Type)));
    Preferences::connect(SIGNAL(showInSystemTrayChanged(bool)), this, SLOT(slotShowInSystemTrayChanged()));
    Preferences::connect(SIGNAL(archivedKeepDaysChanged(int)), this, SLOT(setArchivePurgeDays()));
    KARecurrence::setDefaultFeb29Type(Preferences::defaultFeb29Type());

    if (AlarmCalendar::initialiseCalendars())
    {
        connect(AlarmCalendar::resources(), SIGNAL(earliestAlarmChanged()), SLOT(checkNextDueAlarm()));

        KConfigGroup config(KGlobal::config(), "General");
        mNoSystemTray        = config.readEntry("NoSystemTray", false);
        mOldShowInSystemTray = wantShowInSystemTray();
        mStartOfDay          = Preferences::startOfDay();
        if (Preferences::hasStartOfDayChanged())
            mStartOfDay.setHMS(100,0,0);    // start of day time has changed: flag it as invalid
        DateTime::setStartOfDay(mStartOfDay);
        mPrefsArchivedColour = Preferences::archivedColour();
    }

    // Check if the speech synthesis daemon is installed
    mSpeechEnabled = (KServiceTypeTrader::self()->query("DBUS/Text-to-Speech", "Name == 'KTTSD'").count() > 0);
    if (!mSpeechEnabled)
        kDebug() << "Speech synthesis disabled (KTTSD not found)";
    // Check if KOrganizer is installed
    QString korg = QLatin1String("korganizer");
    mKOrganizerEnabled = !KStandardDirs::locate("exe", korg).isNull()  ||  !KStandardDirs::findExe(korg).isNull();
    if (!mKOrganizerEnabled)
        kDebug() << "KOrganizer options disabled (KOrganizer not found)";
}

/******************************************************************************
*/
KAlarmApp::~KAlarmApp()
{
    while (!mCommandProcesses.isEmpty())
    {
        ProcData* pd = mCommandProcesses[0];
        mCommandProcesses.pop_front();
        delete pd;
    }
    AlarmCalendar::terminateCalendars();
}

/******************************************************************************
* Return the one and only KAlarmApp instance.
* If it doesn't already exist, it is created first.
*/
KAlarmApp* KAlarmApp::getInstance()
{
    if (!theInstance)
    {
        theInstance = new KAlarmApp;

        if (mFatalError)
            theInstance->quitFatal();
    }
    return theInstance;
}

/******************************************************************************
* Restore the saved session if required.
*/
bool KAlarmApp::restoreSession()
{
    if (!isSessionRestored())
        return false;
    if (mFatalError)
    {
        quitFatal();
        return false;
    }

    // Process is being restored by session management.
    kDebug() << "Restoring";
    ++mActiveCount;
    if (!initCheck(true))     // open the calendar file (needed for main windows), don't process queue yet
    {
        --mActiveCount;
        quitIf(1, true);    // error opening the main calendar - quit
        return true;
    }
    MainWindow* trayParent = 0;
    for (int i = 1;  KMainWindow::canBeRestored(i);  ++i)
    {
        QString type = KMainWindow::classNameOfToplevel(i);
        if (type == QLatin1String("MainWindow"))
        {
            MainWindow* win = MainWindow::create(true);
            win->restore(i, false);
            if (win->isHiddenTrayParent())
                trayParent = win;
            else
                win->show();
        }
        else if (type == QLatin1String("MessageWin"))
        {
            MessageWin* win = new MessageWin;
            win->restore(i, false);
            if (win->isValid())
                win->show();
            else
                delete win;
        }
    }
    startProcessQueue();      // start processing the execution queue

    // Try to display the system tray icon if it is configured to be shown
    if (MainWindow::count()  &&  wantShowInSystemTray())
    {
        displayTrayIcon(true, trayParent);
        // Occasionally for no obvious reason, the main main window is
        // shown when it should be hidden, so hide it just to be sure.
        if (trayParent)
            trayParent->hide();
    }

    --mActiveCount;
    quitIf(0);           // quit if no windows are open
    return true;
}

/******************************************************************************
* Called for a KUniqueApplication when a new instance of the application is
* started.
*/
int KAlarmApp::newInstance()
{
    kDebug();
    if (mFatalError)
    {
        quitFatal();
        return 1;
    }
    ++mActiveCount;
    int exitCode = 0;               // default = success
    static bool firstInstance = true;
    bool dontRedisplay = false;
    if (!firstInstance || !isSessionRestored())
    {
        QString usage;
        KCmdLineArgs* args = KCmdLineArgs::parsedArgs();

        // Use a 'do' loop which is executed only once to allow easy error exits.
        // Errors use 'break' to skip to the end of the function.
        do
        {
            #define USAGE(message)  { usage = message; break; }
            if (args->isSet("tray"))
            {
                // Display only the system tray icon
                kDebug() << "--tray";
                args->clear();      // free up memory
                if (!KSystemTrayIcon::isSystemTrayAvailable())
                {
                    exitCode = 1;
                    break;
                }
                if (!initCheck())   // open the calendar, start processing execution queue
                {
                    exitCode = 1;
                    break;
                }
                if (!displayTrayIcon(true))
                {
                    exitCode = 1;
                    break;
                }
            }
            else
            if (args->isSet("triggerEvent")  ||  args->isSet("cancelEvent"))
            {
                // Display or delete the event with the specified event ID
                kDebug() << "Handle event";
                EventFunc function = EVENT_HANDLE;
                int count = 0;
                const char* option = 0;
                if (args->isSet("triggerEvent"))  { function = EVENT_TRIGGER;  option = "triggerEvent";  ++count; }
                if (args->isSet("cancelEvent"))   { function = EVENT_CANCEL;   option = "cancelEvent";   ++count; }
                if (count > 1)
                    USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--triggerEvent"), QLatin1String("--cancelEvent")));
                if (!initCheck(true))   // open the calendar, don't start processing execution queue yet
                {
                    exitCode = 1;
                    break;
                }
                QString eventID = args->getOption(option);
                args->clear();      // free up memory
                startProcessQueue();        // start processing the execution queue
                if (!handleEvent(eventID, function))
                {
                    exitCode = 1;
                    break;
                }
            }
            else
            if (args->isSet("edit"))
            {
                QString eventID = args->getOption("edit");
                if (!initCheck())
                {
                    exitCode = 1;
                    break;
                }
                if (!KAlarm::editAlarm(eventID))
                {
                    USAGE(i18nc("@info:shell", "<icode>%1</icode>: Event <resource>%2</resource> not found, or not editable", QString::fromLatin1("--edit"), eventID))
                    exitCode = 1;
                    break;
                }
            }
            else
            if (args->isSet("edit-new-display")  ||  args->isSet("edit-new-command")  ||  args->isSet("edit-new-email"))
            {
                EditAlarmDlg::Type type = args->isSet("edit-new-display") ? EditAlarmDlg::DISPLAY
                                        : args->isSet("edit-new-command") ? EditAlarmDlg::COMMAND
                                        : EditAlarmDlg::EMAIL;
                if (!initCheck())
                {
                    exitCode = 1;
                    break;
                }
                KAlarm::editNewAlarm(type);
            }
            else
            if (args->isSet("edit-new-preset"))
            {
                QString templ = args->getOption("edit-new-preset");
                if (!initCheck())
                {
                    exitCode = 1;
                    break;
                }
                KAlarm::editNewAlarm(templ);
            }
            else
            if (args->isSet("file")  ||  args->isSet("exec")  ||  args->isSet("exec-display")  ||  args->isSet("mail")  ||  args->count())
            {
                // Display a message or file, execute a command, or send an email
                KAEvent::Action action = KAEvent::MESSAGE;
                QString          alMessage;
                uint             alFromID;
                EmailAddressList alAddresses;
                QStringList      alAttachments;
                QString          alSubject;
                int flags = KAEvent::DEFAULT_FONT;
                if (args->isSet("file"))
                {
                    kDebug() << "File";
                    if (args->isSet("exec"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--exec"), QLatin1String("--file")))
                    if (args->isSet("mail"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--mail"), QLatin1String("--file")))
                    if (args->count())
                        USAGE(i18nc("@info:shell", "message incompatible with <icode>%1</icode>", QLatin1String("--file")))
                    alMessage = args->getOption("file");
                    action = KAEvent::FILE;
                }
                else if (args->isSet("exec-display"))
                {
                    kDebug() << "--exec-display";
                    if (args->isSet("exec"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--exec"), QLatin1String("--exec-display")))
                    if (args->isSet("mail"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--mail"), QLatin1String("--exec-display")))
                    alMessage = args->getOption("exec-display");
                    int n = args->count();
                    for (int i = 0;  i < n;  ++i)
                    {
                        alMessage += ' ';
                        alMessage += args->arg(i);
                    }
                    action = KAEvent::COMMAND;
                    flags |= KAEvent::DISPLAY_COMMAND;
                }
                else if (args->isSet("exec"))
                {
                    kDebug() << "--exec";
                    if (args->isSet("mail"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--mail"), QLatin1String("--exec")))
                    alMessage = args->getOption("exec");
                    int n = args->count();
                    for (int i = 0;  i < n;  ++i)
                    {
                        alMessage += ' ';
                        alMessage += args->arg(i);
                    }
                    action = KAEvent::COMMAND;
                }
                else if (args->isSet("mail"))
                {
                    kDebug() << "--mail";
                    if (args->isSet("subject"))
                        alSubject = args->getOption("subject");
                    if (args->isSet("from-id"))
                        alFromID = KAMail::identityUoid(args->getOption("from-id"));
                    QStringList params = args->getOptionList("mail");
                    for (QStringList::Iterator i = params.begin();  i != params.end();  ++i)
                    {
                        QString addr = *i;
                        if (!KAMail::checkAddress(addr))
                            USAGE(i18nc("@info:shell", "<icode>%1</icode>: invalid email address", QLatin1String("--mail")))
                        alAddresses += KCal::Person(QString(), addr);
                    }
                    params = args->getOptionList("attach");
                    for (QStringList::Iterator i = params.begin();  i != params.end();  ++i)
                        alAttachments += *i;
                    alMessage = args->arg(0);
                    action = KAEvent::EMAIL;
                }
                else
                {
                    kDebug() << "Message";
                    alMessage = args->arg(0);
                }

                if (action != KAEvent::EMAIL)
                {
                    if (args->isSet("subject"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--subject"), QLatin1String("--mail")))
                    if (args->isSet("from-id"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--from-id"), QLatin1String("--mail")))
                    if (args->isSet("attach"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--attach"), QLatin1String("--mail")))
                    if (args->isSet("bcc"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--bcc"), QLatin1String("--mail")))
                }

                KDateTime alarmTime, endTime;
                QColor    bgColour = Preferences::defaultBgColour();
                QColor    fgColour = Preferences::defaultFgColour();
                KARecurrence recurrence;
                int       repeatCount    = 0;
                int       repeatInterval = 0;
                if (args->isSet("color"))
                {
                    // Background colour is specified
                    QString colourText = args->getOption("color");
                    if (colourText[0] == '0' && colourText[1].toLower() == 'x')
                        colourText.replace(0, 2, "#");
                    bgColour.setNamedColor(colourText);
                    if (!bgColour.isValid())
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--color")))
                }
                if (args->isSet("colorfg"))
                {
                    // Foreground colour is specified
                    QString colourText = args->getOption("colorfg");
                    if (colourText[0] == '0' && colourText[1].toLower() == 'x')
                        colourText.replace(0, 2, "#");
                    fgColour.setNamedColor(colourText);
                    if (!fgColour.isValid())
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--colorfg")))
                }

                if (args->isSet("time"))
                {
                    QByteArray dateTime = args->getOption("time").toLocal8Bit();
                    if (!KAlarm::convTimeString(dateTime, alarmTime))
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--time")))
                }
                else
                    alarmTime = KDateTime::currentLocalDateTime();

                bool haveRecurrence = args->isSet("recurrence");
                if (haveRecurrence)
                {
                    if (args->isSet("login"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--login"), QLatin1String("--recurrence")))
                    if (args->isSet("until"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--until"), QLatin1String("--recurrence")))
                    QString rule = args->getOption("recurrence");
                    recurrence.set(rule);
                }
                if (args->isSet("interval"))
                {
                    // Repeat count is specified
                    int count;
                    if (args->isSet("login"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--login"), QLatin1String("--interval")))
                    bool ok;
                    if (args->isSet("repeat"))
                    {
                        count = args->getOption("repeat").toInt(&ok);
                        if (!ok || !count || count < -1 || (count < 0 && haveRecurrence))
                            USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--repeat")))
                    }
                    else if (haveRecurrence)
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--interval"), QLatin1String("--repeat")))
                    else if (args->isSet("until"))
                    {
                        count = 0;
                        QByteArray dateTime = args->getOption("until").toLocal8Bit();
                        bool ok;
                        if (args->isSet("time"))
                            ok = KAlarm::convTimeString(dateTime, endTime, alarmTime);
                        else
                            ok = KAlarm::convTimeString(dateTime, endTime);
                        if (!ok)
                            USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--until")))
                        if (alarmTime.isDateOnly()  &&  !endTime.isDateOnly())
                            USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter for date-only alarm", QLatin1String("--until")))
                        if (!alarmTime.isDateOnly()  &&  endTime.isDateOnly())
                            endTime.setTime(QTime(23,59,59));
                        if (endTime < alarmTime)
                            USAGE(i18nc("@info:shell", "<icode>%1</icode> earlier than <icode>%2</icode>", QLatin1String("--until"), QLatin1String("--time")))
                    }
                    else
                        count = -1;

                    // Get the recurrence interval
                    int interval;
                    KARecurrence::Type recurType;
                    if (!convInterval(args->getOption("interval").toLocal8Bit(), recurType, interval, !haveRecurrence)
                    ||  interval < 0)
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--interval")))
                    if (alarmTime.isDateOnly()  &&  recurType == KARecurrence::MINUTELY)
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter for date-only alarm", QLatin1String("--interval")))

                    if (haveRecurrence)
                    {
                        // There is a also a recurrence specified, so set up a sub-repetition
                        int longestInterval = recurrence.longestInterval();
                        if (count * interval > longestInterval)
                            USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> and <icode>%2</icode> parameters: repetition is longer than <icode>%3</icode> interval", QLatin1String("--interval"), QLatin1String("--repeat"), QLatin1String("--recurrence")));
                        repeatCount    = count;
                        repeatInterval = interval;
                    }
                    else
                    {
                        // There is no other recurrence specified, so convert the repetition
                        // parameters into a KCal::Recurrence
                        recurrence.set(recurType, interval, count, alarmTime, endTime);
                    }
                }
                else
                {
                    if (args->isSet("repeat"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--repeat"), QLatin1String("--interval")))
                    if (args->isSet("until"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--until"), QLatin1String("--interval")))
                }

                QString    audioFile;
                float      audioVolume = -1;
                bool       audioRepeat = args->isSet("play-repeat");
                if (audioRepeat  ||  args->isSet("play"))
                {
                    // Play a sound with the alarm
                    if (audioRepeat  &&  args->isSet("play"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--play"), QLatin1String("--play-repeat")))
                    if (args->isSet("beep"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--beep"), QLatin1String(audioRepeat ? "--play-repeat" : "--play")))
                    if (args->isSet("speak"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--speak"), QLatin1String(audioRepeat ? "--play-repeat" : "--play")))
                    audioFile = args->getOption(audioRepeat ? "play-repeat" : "play");
                    if (args->isSet("volume"))
                    {
                        bool ok;
                        int volumepc = args->getOption("volume").toInt(&ok);
                        if (!ok  ||  volumepc < 0  ||  volumepc > 100)
                            USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("--volume")))
                        audioVolume = static_cast<float>(volumepc) / 100;
                    }
                }
                else if (args->isSet("volume"))
                    USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode> or <icode>%3</icode>", QLatin1String("--volume"), QLatin1String("--play"), QLatin1String("--play-repeat")))
                if (args->isSet("speak"))
                {
                    if (args->isSet("beep"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--beep"), QLatin1String("--speak")))
                    if (!mSpeechEnabled)
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> requires speech synthesis to be configured using KTTSD", QLatin1String("--speak")))
                }
                int reminderMinutes = 0;
                bool onceOnly = args->isSet("reminder-once");
                if (args->isSet("reminder")  ||  onceOnly)
                {
                    // Issue a reminder alarm in advance of the main alarm
                    if (onceOnly  &&  args->isSet("reminder"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", QLatin1String("--reminder"), QLatin1String("--reminder-once")))
                    QString opt = onceOnly ? QLatin1String("--reminder-once") : QLatin1String("--reminder");
                    if (args->isSet("exec"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", opt, QLatin1String("--exec")))
                    if (args->isSet("mail"))
                        USAGE(i18nc("@info:shell", "<icode>%1</icode> incompatible with <icode>%2</icode>", opt, QLatin1String("--mail")))
                    KARecurrence::Type recurType;
                    QString optval = args->getOption(onceOnly ? "reminder-once" : "reminder");
                    if (!convInterval(args->getOption(onceOnly ? "reminder-once" : "reminder").toLocal8Bit(), recurType, reminderMinutes))
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", opt))
                    if (recurType == KARecurrence::MINUTELY  &&  alarmTime.isDateOnly())
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter for date-only alarm", opt))
                }

                int lateCancel = 0;
                if (args->isSet("late-cancel"))
                {
                    KARecurrence::Type recurType;
                    bool ok = convInterval(args->getOption("late-cancel").toLocal8Bit(), recurType, lateCancel);
                    if (!ok  ||  lateCancel <= 0)
                        USAGE(i18nc("@info:shell", "Invalid <icode>%1</icode> parameter", QLatin1String("late-cancel")))
                }
                else if (args->isSet("auto-close"))
                    USAGE(i18nc("@info:shell", "<icode>%1</icode> requires <icode>%2</icode>", QLatin1String("--auto-close"), QLatin1String("--late-cancel")))

                if (args->isSet("ack-confirm"))
                    flags |= KAEvent::CONFIRM_ACK;
                if (args->isSet("auto-close"))
                    flags |= KAEvent::AUTO_CLOSE;
                if (args->isSet("beep"))
                    flags |= KAEvent::BEEP;
                if (args->isSet("speak"))
                    flags |= KAEvent::SPEAK;
                if (args->isSet("korganizer"))
                    flags |= KAEvent::COPY_KORGANIZER;
                if (args->isSet("disable"))
                    flags |= KAEvent::DISABLED;
                if (audioRepeat)
                    flags |= KAEvent::REPEAT_SOUND;
                if (args->isSet("login"))
                    flags |= KAEvent::REPEAT_AT_LOGIN;
                if (args->isSet("bcc"))
                    flags |= KAEvent::EMAIL_BCC;
                if (alarmTime.isDateOnly())
                    flags |= KAEvent::ANY_TIME;
                args->clear();      // free up memory

                // Display or schedule the event
                if (!initCheck())
                {
                    exitCode = 1;
                    break;
                }
                if (!scheduleEvent(action, alMessage, alarmTime, lateCancel, flags, bgColour, fgColour, QFont(), audioFile,
                                   audioVolume, reminderMinutes, recurrence, repeatInterval, repeatCount,
                                   alFromID, alAddresses, alSubject, alAttachments))
                {
                    exitCode = 1;
                    break;
                }
            }
            else
            {
                // No arguments - run interactively & display the main window
                kDebug() << "Interactive";
                if (args->isSet("ack-confirm"))
                    usage += QLatin1String("--ack-confirm ");
                if (args->isSet("attach"))
                    usage += QLatin1String("--attach ");
                if (args->isSet("auto-close"))
                    usage += QLatin1String("--auto-close ");
                if (args->isSet("bcc"))
                    usage += QLatin1String("--bcc ");
                if (args->isSet("beep"))
                    usage += QLatin1String("--beep ");
                if (args->isSet("color"))
                    usage += QLatin1String("--color ");
                if (args->isSet("colorfg"))
                    usage += QLatin1String("--colorfg ");
                if (args->isSet("disable"))
                    usage += QLatin1String("--disable ");
                if (args->isSet("from-id"))
                    usage += QLatin1String("--from-id ");
                if (args->isSet("korganizer"))
                    usage += QLatin1String("--korganizer ");
                if (args->isSet("late-cancel"))
                    usage += QLatin1String("--late-cancel ");
                if (args->isSet("login"))
                    usage += QLatin1String("--login ");
                if (args->isSet("play"))
                    usage += QLatin1String("--play ");
                if (args->isSet("play-repeat"))
                    usage += QLatin1String("--play-repeat ");
                if (args->isSet("reminder"))
                    usage += QLatin1String("--reminder ");
                if (args->isSet("reminder-once"))
                    usage += QLatin1String("--reminder-once ");
                if (args->isSet("speak"))
                    usage += QLatin1String("--speak ");
                if (args->isSet("subject"))
                    usage += QLatin1String("--subject ");
                if (args->isSet("time"))
                    usage += QLatin1String("--time ");
                if (args->isSet("volume"))
                    usage += QLatin1String("--volume ");
                if (!usage.isEmpty())
                {
                    usage += i18nc("@info:shell", ": option(s) only valid with a message/<icode>%1</icode>/<icode>%2</icode>", QLatin1String("--file"), QLatin1String("--exec"));
                    break;
                }

                args->clear();      // free up memory
                if (!initCheck())
                {
                    exitCode = 1;
                    break;
                }

                (MainWindow::create())->show();
            }
        } while (0);    // only execute once

        if (!usage.isEmpty())
        {
            // Note: we can't use args->usage() since that also quits any other
            // running 'instances' of the program.
            std::cerr << usage.toLocal8Bit().data()
                      << i18nc("@info:shell", "\nUse --help to get a list of available command line options.\n").toLocal8Bit().data();
            exitCode = 1;
        }
    }
    if (firstInstance  &&  !dontRedisplay  &&  !exitCode)
        MessageWin::redisplayAlarms();

    --mActiveCount;
    firstInstance = false;

    // Quit the application if this was the last/only running "instance" of the program.
    // Executing 'return' doesn't work very well since the program continues to
    // run if no windows were created.
    quitIf(exitCode);
    return exitCode;
}

/******************************************************************************
* Quit the program, optionally only if there are no more "instances" running.
*/
void KAlarmApp::quitIf(int exitCode, bool force)
{
    if (force)
    {
        // Quit regardless, except for message windows
        mQuitting = true;
        MainWindow::closeAll();
        displayTrayIcon(false);
        if (MessageWin::instanceCount())
            return;
    }
    else if (mQuitting)
        return;   // MainWindow::closeAll() causes quitIf() to be called again
    else
    {
        // Quit only if there are no more "instances" running
        mPendingQuit = false;
        if (mActiveCount > 0  ||  MessageWin::instanceCount())
            return;
        int mwcount = MainWindow::count();
        MainWindow* mw = mwcount ? MainWindow::firstWindow() : 0;
        if (mwcount > 1  ||  (mwcount && (!mw->isHidden() || !mw->isTrayParent())))
            return;
        // There are no windows left except perhaps a main window which is a hidden tray icon parent
        if (mTrayWindow)
        {
            // There is a system tray icon.
            // Don't exit unless the system tray doesn't seem to exist.
            if (checkSystemTray())
                return;
        }
        if (!mDcopQueue.isEmpty()  ||  !mCommandProcesses.isEmpty())
        {
            // Don't quit yet if there are outstanding actions on the execution queue
            mPendingQuit = true;
            mPendingQuitCode = exitCode;
            return;
        }
    }

    // This was the last/only running "instance" of the program, so exit completely.
    kDebug() << exitCode << ": quitting";
    AlarmCalendar::terminateCalendars();
    BirthdayModel::close();
    exit(exitCode);
}

/******************************************************************************
* Called when the Quit menu item is selected.
* Closes the system tray window and all main windows, but does not exit the
* program if other windows are still open.
*/
void KAlarmApp::doQuit(QWidget* parent)
{
    kDebug();
    if (MessageBox::warningContinueCancel(parent, KMessageBox::Cancel,
                                          i18nc("@info", "Quitting will disable alarms (once any alarm message windows are closed)."),
                                          QString(), KStandardGuiItem::quit(), Preferences::QUIT_WARN
                                         ) != KMessageBox::Yes)
        return;
    quitIf(0, true);
}

/******************************************************************************
* Called when the session manager is about to close down the application.
*/
void KAlarmApp::commitData(QSessionManager& sm)
{
    mSessionClosingDown = true;
    KUniqueApplication::commitData(sm);
    mSessionClosingDown = false;         // reset in case shutdown is cancelled
}

/******************************************************************************
* Display an error message for a fatal error. Prevent further actions since
* the program state is unsafe.
*/
void KAlarmApp::displayFatalError(const QString& message)
{
    if (!mFatalError)
    {
        mFatalError = 1;
        mFatalMessage = message;
        if (theInstance)
            QTimer::singleShot(0, theInstance, SLOT(quitFatal()));
    }
}

/******************************************************************************
* Quit the program, once the fatal error message has been acknowledged.
*/
void KAlarmApp::quitFatal()
{
    switch (mFatalError)
    {
        case 0:
        case 2:
            return;
        case 1:
            mFatalError = 2;
            KMessageBox::error(0, mFatalMessage);
            mFatalError = 3;
            // fall through to '3'
        case 3:
            if (theInstance)
                theInstance->quitIf(1, true);
            break;
    }
    QTimer::singleShot(1000, this, SLOT(quitFatal()));
}

/******************************************************************************
* Called by the alarm timer when the next alarm is due.
* Also called when the execution queue has finished processing to check for the
* next alarm.
*/
void KAlarmApp::checkNextDueAlarm()
{
    if (!mAlarmsEnabled)
        return;
    // Find the first alarm due
    KAEvent* nextEvent = AlarmCalendar::resources()->earliestAlarm();
    if (!nextEvent)
        return;   // there are no alarms pending
    KDateTime nextDt = nextEvent->nextTrigger(KAEvent::ALL_TRIGGER).effectiveKDateTime();
    qint64 interval = KDateTime::currentDateTime(Preferences::timeZone()).secsTo_long(nextDt);
    if (interval <= 0)
    {
        // Queue the alarm
        queueAlarmId(nextEvent->id());
        kDebug() << nextEvent->id() << ": due now";
        QTimer::singleShot(0, this, SLOT(processQueue()));
    }
    else
    {
        // No alarm is due yet, so set timer to wake us when it's due.
        // Check for integer overflow before setting timer.
        interval *= 1000;
        if (interval > INT_MAX)
            interval = INT_MAX;
        kDebug() << nextEvent->id() << "wait" << interval/1000 << "seconds";
        mAlarmTimer->start(static_cast<int>(interval));
    }
}

/******************************************************************************
* Called by the alarm timer when the next alarm is due.
* Also called when the execution queue has finished processing to check for the
* next alarm.
*/
void KAlarmApp::queueAlarmId(const QString& id)
{
    for (int i = 0, end = mDcopQueue.count();  i < end;  ++i)
    {
        if (mDcopQueue[i].function == EVENT_HANDLE  &&  mDcopQueue[i].eventId