kalarmapp.h 12.2 KB
Newer Older
1
/*
David Jarvie's avatar
David Jarvie committed
2
 *  kalarmapp.h  -  the KAlarm application object
3
 *  Program:  kalarm
4
 *  Copyright © 2001-2012 by David Jarvie <djarvie@kde.org>
5 6 7 8 9
 *
 *  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.
David Jarvie's avatar
David Jarvie committed
10 11 12 13 14 15
 *
 *  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.
 *
David Jarvie's avatar
David Jarvie committed
16 17
 *  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.,
David Jarvie's avatar
David Jarvie committed
18
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 20 21 22 23
 */

#ifndef KALARMAPP_H
#define KALARMAPP_H

24 25
/** @file kalarmapp.h - the KAlarm application object */

26 27 28
#include "kamail.h"
#include "preferences.h"

29 30
#include <kalarmcal/kaevent.h>

31 32
#include <kuniqueapplication.h>

33
#include <QPointer>
David Jarvie's avatar
David Jarvie committed
34 35
#include <QQueue>
#include <QList>
David Jarvie's avatar
David Jarvie committed
36

37
class KDateTime;
David Jarvie's avatar
David Jarvie committed
38
namespace KCal { class Event; }
39 40 41
#ifdef USE_AKONADI
namespace Akonadi { class Collection; }
#endif
42
class DBusHandler;
43
class MainWindow;
44
class TrayWindow;
45
class ShellProcess;
46
class OrgKdeKSpeechInterface;
47

48
using namespace KAlarmCal;
49

50

51 52
class KAlarmApp : public KUniqueApplication
{
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
        Q_OBJECT
    public:
        ~KAlarmApp();
        virtual int        newInstance();
        static KAlarmApp*  getInstance();
        bool               checkCalendar()                 { return initCheck(); }
        bool               wantShowInSystemTray() const;
        bool               alarmsEnabled() const           { return mAlarmsEnabled; }
        bool               speechEnabled() const           { return mSpeechEnabled; }
        OrgKdeKSpeechInterface* kspeechInterface(QString& error) const;
        bool               korganizerEnabled() const       { return mKOrganizerEnabled; }
        bool               restoreSession();
        bool               sessionClosingDown() const      { return mSessionClosingDown; }
        bool               quitIf()                        { return quitIf(0); }
        void               doQuit(QWidget* parent);
        static void        displayFatalError(const QString& message);
        void               addWindow(TrayWindow* w)        { mTrayWindow = w; }
        void               removeWindow(TrayWindow*);
        TrayWindow*        trayWindow() const              { return mTrayWindow; }
        MainWindow*        trayMainWindow() const;
        bool               displayTrayIcon(bool show, MainWindow* = 0);
        bool               trayIconDisplayed() const       { return mTrayWindow; }
        bool               editNewAlarm(MainWindow* = 0);
        virtual void       commitData(QSessionManager&);

        void*              execAlarm(KAEvent&, const KAAlarm&, bool reschedule, bool allowDefer = true, bool noPreAction = false);
        ShellProcess*      execCommandAlarm(const KAEvent&, const KAAlarm&, const QObject* receiver = 0, const char* slot = 0);
        void               alarmCompleted(const KAEvent&);
        void               rescheduleAlarm(KAEvent& e, const KAAlarm& a)   { rescheduleAlarm(e, a, true); }
        bool               deleteEvent(const QString& eventID)         { return handleEvent(eventID, EVENT_CANCEL); }
        void               purgeAll()             { purge(0); }
        void               commandMessage(ShellProcess*, QWidget* parent);
        void               notifyAudioPlaying(bool playing);
        void               setSpreadWindowsState(bool spread);
        // Methods called indirectly by the DCOP interface
88
        bool               scheduleEvent(KAEvent::SubAction, const QString& text, const KDateTime&,
89
                                         int lateCancel, KAEvent::Flags flags, const QColor& bg, const QColor& fg,
90 91
                                         const QFont&, const QString& audioFile, float audioVolume,
                                         int reminderMinutes, const KARecurrence& recurrence,
92 93 94 95 96 97
                                         int repeatInterval, int repeatCount,
#ifdef USE_AKONADI
                                         uint mailFromID = 0, const KCalCore::Person::List& mailAddresses = KCalCore::Person::List(),
#else
                                         uint mailFromID = 0, const QList<KCal::Person>& mailAddresses = QList<KCal::Person>(),
#endif
98 99 100 101 102 103 104 105
                                         const QString& mailSubject = QString(),
                                         const QStringList& mailAttachments = QStringList());
        bool               dbusTriggerEvent(const QString& eventID)   { return dbusHandleEvent(eventID, EVENT_TRIGGER); }
        bool               dbusDeleteEvent(const QString& eventID)    { return dbusHandleEvent(eventID, EVENT_CANCEL); }

    public slots:
        void               processQueue();
        void               setAlarmsEnabled(bool);
106
#ifdef USE_AKONADI
107
        void               purgeNewArchivedDefault(const Akonadi::Collection&);
108 109
        void               atLoginEventAdded(const KAEvent&);
#endif
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
        void               stopAudio();
        void               spreadWindows(bool);
        void               emailSent(KAMail::JobData&, const QStringList& errmsgs, bool copyerr = false);

    signals:
        void               trayIconToggled();
        void               alarmEnabledToggled(bool);
        void               audioPlaying(bool);
        void               spreadWindowsToggled(bool);
        void               execAlarmSuccess();

    protected:
        KAlarmApp();

    private:
        typedef Preferences::Feb29Type Feb29Type;   // allow it to be used in SIGNAL mechanism

    private slots:
        void               quitFatal();
        void               checkNextDueAlarm();
        void               checkKtimezoned();
        void               slotShowInSystemTrayChanged();
        void               changeStartOfDay();
        void               slotWorkTimeChanged(const QTime& start, const QTime& end, const QBitArray& days);
        void               slotHolidaysChanged(const KHolidays::HolidayRegion&);
        void               slotFeb29TypeChanged(Feb29Type);
        void               slotMessageFontChanged(const QFont&);
        void               setArchivePurgeDays();
        void               slotPurge()                     { purge(mArchivedPurgeDays); }
139 140 141
#ifdef USE_AKONADI
        void               purgeAfterDelay();
#endif
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
        void               slotCommandExited(ShellProcess*);
        void               slotDBusServiceUnregistered(const QString& serviceName);

    private:
        enum EventFunc
        {
            EVENT_HANDLE,    // if the alarm is due, execute it and then reschedule it
            EVENT_TRIGGER,   // execute the alarm regardless, and then reschedule it if it already due
            EVENT_CANCEL     // delete the alarm
        };
        struct ProcData
        {
            ProcData(ShellProcess*, KAEvent*, KAAlarm*, int flags = 0);
            ~ProcData();
            enum { PRE_ACTION = 0x01, POST_ACTION = 0x02, RESCHEDULE = 0x04, ALLOW_DEFER = 0x08,
                   TEMP_FILE = 0x10, EXEC_IN_XTERM = 0x20, DISP_OUTPUT = 0x40 };
158 159 160 161 162 163 164 165 166 167 168 169 170
            bool  preAction() const   { return flags & PRE_ACTION; }
            bool  postAction() const  { return flags & POST_ACTION; }
            bool  reschedule() const  { return flags & RESCHEDULE; }
            bool  allowDefer() const  { return flags & ALLOW_DEFER; }
            bool  tempFile() const    { return flags & TEMP_FILE; }
            bool  execInXterm() const { return flags & EXEC_IN_XTERM; }
            bool  dispOutput() const  { return flags & DISP_OUTPUT; }
            ShellProcess*     process;
            KAEvent*          event;
            KAAlarm*          alarm;
            QPointer<QWidget> messageBoxParent;
            QStringList       tempFiles;
            int               flags;
171
        };
172
        struct ActionQEntry
173
        {
174 175 176
            ActionQEntry(EventFunc f, const QString& id) : function(f), eventId(id) { }
            ActionQEntry(const KAEvent& e, EventFunc f = EVENT_HANDLE) : function(f), event(e) { }
            ActionQEntry() { }
177 178 179 180 181 182 183 184 185 186 187 188
            EventFunc  function;
            QString    eventId;
            KAEvent    event;
        };

        bool               initCheck(bool calendarOnly = false);
        bool               quitIf(int exitCode, bool force = false);
        bool               checkSystemTray();
        void               startProcessQueue();
        void               queueAlarmId(const QString& id);
        bool               dbusHandleEvent(const QString& eventID, EventFunc);
        bool               handleEvent(const QString& eventID, EventFunc);
189 190
        int                rescheduleAlarm(KAEvent&, const KAAlarm&, bool updateCalAndDisplay,
                                           const KDateTime& nextDt = KDateTime());
191
        bool               cancelAlarm(KAEvent&, KAAlarm::Type, bool updateCalAndDisplay);
192
        bool               cancelReminderAndDeferral(KAEvent&);
193 194 195 196
        ShellProcess*      doShellCommand(const QString& command, const KAEvent&, const KAAlarm*,
                                          int flags = 0, const QObject* receiver = 0, const char* slot = 0);
        QString            composeXTermCommand(const QString& command, const KAEvent&, const KAAlarm*,
                                               int flags, QString& tempScriptFile) const;
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
        QString            createTempScriptFile(const QString& command, bool insertShell, const KAEvent&, const KAAlarm&) const;
        void               commandErrorMsg(const ShellProcess*, const KAEvent&, const KAAlarm*, int flags = 0);
        void               purge(int daysToKeep);

        static KAlarmApp*  theInstance;          // the one and only KAlarmApp instance
        static int         mActiveCount;         // number of active instances without main windows
        static int         mFatalError;          // a fatal error has occurred - just wait to exit
        static QString     mFatalMessage;        // fatal error message to output
        bool               mInitialised;         // initialisation complete: ready to process execution queue
        bool               mQuitting;            // a forced quit is in progress
        bool               mLoginAlarmsDone;     // alarms repeated at login have been processed
        DBusHandler*       mDBusHandler;         // the parent of the main DCOP receiver object
        TrayWindow*        mTrayWindow;          // active system tray icon
        QTimer*            mAlarmTimer;          // activates KAlarm when next alarm is due
        QColor             mPrefsArchivedColour; // archived alarms text colour
        int                mArchivedPurgeDays;   // how long to keep archived alarms, 0 = don't keep, -1 = keep indefinitely
        int                mPurgeDaysQueued;     // >= 0 to purge the archive calendar from KAlarmApp::processLoop()
        QList<ProcData*>   mCommandProcesses;    // currently active command alarm processes
215
        QQueue<ActionQEntry> mActionQueue;       // queued commands and actions
216 217 218
        mutable OrgKdeKSpeechInterface* mKSpeech;// KSpeech D-Bus interface object
        int                mPendingQuitCode;     // exit code for a pending quit
        bool               mPendingQuit;         // quit once the DCOP command and shell command queues have been processed
219
        bool               mCancelRtcWake;       // cancel RTC wake on quitting
220
        bool               mProcessingQueue;     // a mActionQueue entry is currently being processed
221 222 223 224 225 226
        bool               mNoSystemTray;        // no system tray exists
        bool               mSessionClosingDown;  // session manager is closing the application
        bool               mOldShowInSystemTray; // showing in system tray was selected
        bool               mAlarmsEnabled;       // alarms are enabled
        bool               mSpeechEnabled;       // speech synthesis is enabled (kttsd exists)
        bool               mKOrganizerEnabled;   // KOrganizer options are enabled (korganizer exists)
227 228 229 230 231
};

inline KAlarmApp* theApp()  { return KAlarmApp::getInstance(); }

#endif // KALARMAPP_H
232 233

// vim: et sw=4: