kalarm/mainwindow.cpp

   1 /*
   2  *  mainwindow.cpp  -  main application window
   3  *  Program:  kalarm
   4  *  Copyright © 2001-2015 by David Jarvie <djarvie@kde.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License along
  17  *  with this program; if not, write to the Free Software Foundation, Inc.,
  18  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "kalarm.h"
  22 #include "mainwindow.h"
  23
  24 #include "alarmcalendar.h"
  25 #include "alarmlistdelegate.h"
  26 #include "autoqpointer.h"
  27 #include "alarmlistview.h"
  28 #include "birthdaydlg.h"
  29 #include "functions.h"
  30 #include "kalarmapp.h"
  31 #include "kamail.h"
  32 #include "messagebox.h"
  33 #include "newalarmaction.h"
  34 #include "prefdlg.h"
  35 #include "preferences.h"
  36 #include "resourceselector.h"
  37 #include "synchtimer.h"
  38 #include "templatedlg.h"
  39 #include "templatemenuaction.h"
  40 #include "templatepickdlg.h"
  41 #include "traywindow.h"
  42 #include "wakedlg.h"
  43
  44 #include <kalarmcal/alarmtext.h>
  45 #include <kalarmcal/kaevent.h>
  46
  47 #include <Libkdepim/MaillistDrag>
  48 #include <kmime/kmime_content.h>
  49 #include <KCalCore/MemoryCalendar>
  50 #include <KCalUtils/kcalutils/icaldrag.h>
  51 #include <AkonadiWidgets/controlgui.h>
  52 using namespace KCalCore;
  53 using namespace KCalUtils;
  54 #include <KLocale>
  55 #include <K4AboutData>
  56 #include <ktoolbar.h>
  57 #include <kactioncollection.h>
  58 #include <ksystemtrayicon.h>
  59 #include <kstandardaction.h>
  60 #include <kiconloader.h>
  61 #include <KLocalizedString>
  62 #include <KSharedConfig>
  63 #include <kconfiggroup.h>
  64 #include <kshortcutsdialog.h>
  65 #include <kedittoolbar.h>
  66 #include <kxmlguifactory.h>
  67 #include <ktoggleaction.h>
  68 #include <ktoolbarpopupaction.h>
  69 #include <KTimeZone>
  70
  71 #include <QAction>
  72 #include <QSplitter>
  73 #include <QByteArray>
  74 #include <QDragEnterEvent>
  75 #include <QDropEvent>
  76 #include <QResizeEvent>
  77 #include <QCloseEvent>
  78 #include <QDesktopWidget>
  79 #include <QMenu>
  80 #include <QMimeDatabase>
  81 #include <qinputdialog.h>
  82 #include <QUrl>
  83 #include "kalarm_debug.h"
  84
  85 using namespace KAlarmCal;
  86
  87 namespace
  88 {
  89 const QString UI_FILE(QStringLiteral("kalarmui.rc"));
  90 const char*   WINDOW_NAME = "MainWindow";
  91
  92 const char*   VIEW_GROUP         = "View";
  93 const char*   SHOW_TIME_KEY      = "ShowAlarmTime";
  94 const char*   SHOW_TIME_TO_KEY   = "ShowTimeToAlarm";
  95 const char*   SHOW_ARCHIVED_KEY  = "ShowArchivedAlarms";
  96 const char*   SHOW_RESOURCES_KEY = "ShowResources";
  97
  98 QString             undoText;
  99 QString             undoTextStripped;
 100 QList<QKeySequence> undoShortcut;
 101 QString             redoText;
 102 QString             redoTextStripped;
 103 QList<QKeySequence> redoShortcut;
 104 }
 105
 106
 107 /*=============================================================================
 108 =  Class: MainWindow
 109 =============================================================================*/
 110
 111 MainWindow::WindowList   MainWindow::mWindowList;
 112 TemplateDlg*             MainWindow::mTemplateDlg = Q_NULLPTR;
 113
 114 // Collect these widget labels together to ensure consistent wording and
 115 // translations across different modules.
 116 QString MainWindow::i18n_a_ShowAlarmTimes()        { return i18nc("@action", "Show &Alarm Times"); }
 117 QString MainWindow::i18n_chk_ShowAlarmTime()       { return i18nc("@option:check", "Show alarm time"); }
 118 QString MainWindow::i18n_o_ShowTimeToAlarms()      { return i18nc("@action", "Show Time t&o Alarms"); }
 119 QString MainWindow::i18n_chk_ShowTimeToAlarm()     { return i18nc("@option:check", "Show time until alarm"); }
 120
 121
 122 /******************************************************************************
 123 * Construct an instance.
 124 * To avoid resize() events occurring while still opening the calendar (and
 125 * resultant crashes), the calendar is opened before constructing the instance.
 126 */
 127 MainWindow* MainWindow::create(bool restored)
 128 {
 129     theApp()->checkCalendar();    // ensure calendar is open
 130     return new MainWindow(restored);
 131 }
 132
 133 MainWindow::MainWindow(bool restored)
 134     : MainWindowBase(Q_NULLPTR, Qt::WindowContextHelpButtonHint),
 135       mResourcesWidth(-1),
 136       mHiddenTrayParent(false),
 137       mShown(false),
 138       mResizing(false)
 139 {
 140     qCDebug(KALARM_LOG);
 141     setAttribute(Qt::WA_DeleteOnClose);
 142     setWindowModality(Qt::WindowModal);
 143     setObjectName(QStringLiteral("MainWin"));    // used by LikeBack
 144     setPlainCaption(KComponentData::mainComponent().aboutData()->programName());
 145     KConfigGroup config(KSharedConfig::openConfig(), VIEW_GROUP);
 146     mShowResources = config.readEntry(SHOW_RESOURCES_KEY, false);
 147     mShowArchived  = config.readEntry(SHOW_ARCHIVED_KEY, false);
 148     mShowTime      = config.readEntry(SHOW_TIME_KEY, true);
 149     mShowTimeTo    = config.readEntry(SHOW_TIME_TO_KEY, false);
 150     if (!restored)
 151     {
 152         KConfigGroup wconfig(KSharedConfig::openConfig(), WINDOW_NAME);
 153         mResourcesWidth = wconfig.readEntry(QStringLiteral("Splitter %1").arg(KApplication::desktop()->width()), (int)0);
 154     }
 155
 156     setAcceptDrops(true);         // allow drag-and-drop onto this window
 157     if (!mShowTimeTo)
 158         mShowTime = true;     // ensure at least one time column is visible
 159
 160     mSplitter = new QSplitter(Qt::Horizontal, this);
 161     mSplitter->setChildrenCollapsible(false);
 162     mSplitter->installEventFilter(this);
 163     setCentralWidget(mSplitter);
 164
 165     // Create the calendar resource selector widget
 166     Akonadi::ControlGui::widgetNeedsAkonadi(this);
 167     mResourceSelector = new ResourceSelector(mSplitter);
 168     mSplitter->setStretchFactor(0, 0);   // don't resize resource selector when window is resized
 169     mSplitter->setStretchFactor(1, 1);
 170
 171     // Create the alarm list widget
 172     mListFilterModel = new AlarmListModel(this);
 173     mListFilterModel->setEventTypeFilter(mShowArchived ? CalEvent::ACTIVE | CalEvent::ARCHIVED : CalEvent::ACTIVE);
 174     mListView = new AlarmListView(WINDOW_NAME, mSplitter);
 175     mListView->setModel(mListFilterModel);
 176     mListView->selectTimeColumns(mShowTime, mShowTimeTo);
 177     mListView->sortByColumn(mShowTime ? AlarmListModel::TimeColumn : AlarmListModel::TimeToColumn, Qt::AscendingOrder);
 178     mListView->setItemDelegate(new AlarmListDelegate(mListView));
 179     connect(mListView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), SLOT(slotSelection()));
 180     connect(mListView, &AlarmListView::contextMenuRequested, this, &MainWindow::slotContextMenuRequested);
 181     connect(AkonadiModel::instance(), SIGNAL(collectionStatusChanged(Akonadi::Collection,AkonadiModel::Change,QVariant,bool)),
 182                        SLOT(slotCalendarStatusChanged()));
 183     connect(mResourceSelector, &ResourceSelector::resized, this, &MainWindow::resourcesResized);
 184     mListView->installEventFilter(this);
 185     initActions();
 186
 187     setAutoSaveSettings(QLatin1String(WINDOW_NAME), true);    // save toolbars, window sizes etc.
 188     mWindowList.append(this);
 189     if (mWindowList.count() == 1)
 190     {
 191         // It's the first main window
 192         if (theApp()->wantShowInSystemTray())
 193             theApp()->displayTrayIcon(true, this);     // create system tray icon for run-in-system-tray mode
 194         else if (theApp()->trayWindow())
 195             theApp()->trayWindow()->setAssocMainWindow(this);    // associate this window with the system tray icon
 196     }
 197     slotCalendarStatusChanged();   // initialise action states now that window is registered
 198 }
 199
 200 MainWindow::~MainWindow()
 201 {
 202     qCDebug(KALARM_LOG);
 203     bool trayParent = isTrayParent();   // must call before removing from window list
 204     mWindowList.removeAt(mWindowList.indexOf(this));
 205
 206     // Prevent view updates during window destruction
 207     delete mResourceSelector;
 208     mResourceSelector = Q_NULLPTR;
 209     delete mListView;
 210     mListView = Q_NULLPTR;
 211
 212     if (theApp()->trayWindow())
 213     {
 214         if (trayParent)
 215             delete theApp()->trayWindow();
 216         else
 217             theApp()->trayWindow()->removeWindow(this);
 218     }
 219     KSharedConfig::openConfig()->sync();    // save any new window size to disc
 220     theApp()->quitIf();
 221 }
 222
 223 /******************************************************************************
 224 * Save settings to the session managed config file, for restoration
 225 * when the program is restored.
 226 */
 227 void MainWindow::saveProperties(KConfigGroup& config)
 228 {
 229     config.writeEntry("HiddenTrayParent", isTrayParent() && isHidden());
 230     config.writeEntry("ShowArchived", mShowArchived);
 231     config.writeEntry("ShowTime", mShowTime);
 232     config.writeEntry("ShowTimeTo", mShowTimeTo);
 233     config.writeEntry("ResourcesWidth", mResourceSelector->isHidden() ? 0 : mResourceSelector->width());
 234 }
 235
 236 /******************************************************************************
 237 * Read settings from the session managed config file.
 238 * This function is automatically called whenever the app is being
 239 * restored. Read in whatever was saved in saveProperties().
 240 */
 241 void MainWindow::readProperties(const KConfigGroup& config)
 242 {
 243     mHiddenTrayParent = config.readEntry("HiddenTrayParent", true);
 244     mShowArchived     = config.readEntry("ShowArchived", false);
 245     mShowTime         = config.readEntry("ShowTime", true);
 246     mShowTimeTo       = config.readEntry("ShowTimeTo", false);
 247     mResourcesWidth   = config.readEntry("ResourcesWidth", (int)0);
 248     mShowResources    = (mResourcesWidth > 0);
 249 }
 250
 251 /******************************************************************************
 252 * Get the main main window, i.e. the parent of the system tray icon, or if
 253 * none, the first main window to be created. Visible windows take precedence
 254 * over hidden ones.
 255 */
 256 MainWindow* MainWindow::mainMainWindow()
 257 {
 258     MainWindow* tray = theApp()->trayWindow() ? theApp()->trayWindow()->assocMainWindow() : Q_NULLPTR;
 259     if (tray  &&  tray->isVisible())
 260         return tray;
 261     for (int i = 0, end = mWindowList.count();  i < end;  ++i)
 262         if (mWindowList[i]->isVisible())
 263             return mWindowList[i];
 264     if (tray)
 265         return tray;
 266     if (mWindowList.isEmpty())
 267         return Q_NULLPTR;
 268     return mWindowList[0];
 269 }
 270
 271 /******************************************************************************
 272 * Check whether this main window is effectively the parent of the system tray icon.
 273 */
 274 bool MainWindow::isTrayParent() const
 275 {
 276     TrayWindow* tray = theApp()->trayWindow();
 277     if (!tray  ||  !KSystemTrayIcon::isSystemTrayAvailable())
 278         return false;
 279     if (tray->assocMainWindow() == this)
 280         return true;
 281     return mWindowList.count() == 1;
 282 }
 283
 284 /******************************************************************************
 285 * Close all main windows.
 286 */
 287 void MainWindow::closeAll()
 288 {
 289     while (!mWindowList.isEmpty())
 290         delete mWindowList[0];    // N.B. the destructor removes the window from the list
 291 }
 292
 293 /******************************************************************************
 294 * Intercept events for the splitter widget.
 295 */
 296 bool MainWindow::eventFilter(QObject* obj, QEvent* e)
 297 {
 298     if (obj == mSplitter)
 299     {
 300         switch (e->type())
 301         {
 302             case QEvent::Resize:
 303                 // Don't change resources size while WINDOW is being resized.
 304                 // Resize event always occurs before Paint.
 305                 mResizing = true;
 306                 break;
 307             case QEvent::Paint:
 308                 // Allow resources to be resized again
 309                 mResizing = false;
 310                 break;
 311             default:
 312                 break;
 313         }
 314     }
 315     else if (obj == mListView)
 316     {
 317         switch (e->type())
 318         {
 319             case QEvent::KeyPress:
 320             {
 321                 QKeyEvent* ke = static_cast<QKeyEvent*>(e);
 322                 if (ke->key() == Qt::Key_Delete  &&  ke->modifiers() == Qt::ShiftModifier)
 323                 {
 324                     // Prevent Shift-Delete being processed by EventListDelegate
 325                     mActionDeleteForce->trigger();
 326                     return true;
 327                 }
 328                 break;
 329             }
 330             default:
 331                 break;
 332         }
 333     }
 334     return false;
 335 }
 336
 337 /******************************************************************************
 338 * Called when the window's size has changed (before it is painted).
 339 * Sets the last column in the list view to extend at least to the right hand
 340 * edge of the list view.
 341 * Records the new size in the config file.
 342 */
 343 void MainWindow::resizeEvent(QResizeEvent* re)
 344 {
 345     // Save the window's new size only if it's the first main window
 346     MainWindowBase::resizeEvent(re);
 347     if (mResourcesWidth > 0)
 348     {
 349         QList<int> widths;
 350         widths.append(mResourcesWidth);
 351         widths.append(width() - mResourcesWidth - mSplitter->handleWidth());
 352         mSplitter->setSizes(widths);
 353     }
 354 }
 355
 356 void MainWindow::resourcesResized()
 357 {
 358     if (!mShown  ||  mResizing)
 359         return;
 360     QList<int> widths = mSplitter->sizes();
 361     if (widths.count() > 1)
 362     {
 363         mResourcesWidth = widths[0];
 364         // Width is reported as non-zero when resource selector is
 365         // actually invisible, so note a zero width in these circumstances.
 366         if (mResourcesWidth <= 5)
 367             mResourcesWidth = 0;
 368         else if (mainMainWindow() == this)
 369         {
 370             KConfigGroup config(KSharedConfig::openConfig(), WINDOW_NAME);
 371             config.writeEntry(QStringLiteral("Splitter %1").arg(KApplication::desktop()->width()), mResourcesWidth);
 372         }
 373     }
 374 }
 375
 376 /******************************************************************************
 377 * Called when the window is first displayed.
 378 * Sets the last column in the list view to extend at least to the right hand
 379 * edge of the list view.
 380 */
 381 void MainWindow::showEvent(QShowEvent* se)
 382 {
 383     if (mResourcesWidth > 0)
 384     {
 385         QList<int> widths;
 386         widths.append(mResourcesWidth);
 387         widths.append(width() - mResourcesWidth - mSplitter->handleWidth());
 388         mSplitter->setSizes(widths);
 389     }
 390     MainWindowBase::showEvent(se);
 391     mShown = true;
 392 }
 393
 394 /******************************************************************************
 395 * Display the window.
 396 */
 397 void MainWindow::show()
 398 {
 399     MainWindowBase::show();
 400     if (mMenuError)
 401     {
 402         // Show error message now that the main window has been displayed.
 403         // Waiting until now lets the user easily associate the message with
 404         // the main window which is faulty.
 405         KAMessageBox::error(this, xi18nc("@info", "Failure to create menus (perhaps <filename>%1</filename> missing or corrupted)", UI_FILE));
 406         mMenuError = false;
 407     }
 408 }
 409
 410 /******************************************************************************
 411 * Called after the window is hidden.
 412 */
 413 void MainWindow::hideEvent(QHideEvent* he)
 414 {
 415     MainWindowBase::hideEvent(he);
 416 }
 417
 418 /******************************************************************************
 419 * Initialise the menu, toolbar and main window actions.
 420 */
 421 void MainWindow::initActions()
 422 {
 423     //KShortcut dummy;
 424     KActionCollection* actions = actionCollection();
 425
 426     mActionTemplates = new QAction(i18nc("@action", "&Templates..."), this);
 427     actions->addAction(QStringLiteral("templates"), mActionTemplates);
 428     connect(mActionTemplates, &QAction::triggered, this, &MainWindow::slotTemplates);
 429
 430     mActionNew = new NewAlarmAction(false, i18nc("@action", "&New"), this);
 431     actions->addAction(QStringLiteral("new"), mActionNew);
 432
 433     QAction* action = mActionNew->displayAlarmAction();
 434     actions->addAction(QStringLiteral("newDisplay"), action);
 435 #pragma message("port QT5")
 436     //QT5 action->setGlobalShortcut(dummy);   // actions->addAction() must be called first!
 437     connect(action, &QAction::triggered, this, &MainWindow::slotNewDisplay);
 438
 439     action = mActionNew->commandAlarmAction();
 440     actions->addAction(QStringLiteral("newCommand"), action);
 441 #pragma message("port QT5")
 442     //QT5 action->setGlobalShortcut(dummy);   // actions->addAction() must be called first!
 443     connect(action, &QAction::triggered, this, &MainWindow::slotNewCommand);
 444
 445     action = mActionNew->emailAlarmAction();
 446     actions->addAction(QStringLiteral("newEmail"), action);
 447 #pragma message("port QT5")
 448     //QT5 action->setGlobalShortcut(dummy);   // actions->addAction() must be called first!
 449     connect(action, &QAction::triggered, this, &MainWindow::slotNewEmail);
 450
 451     action = mActionNew->audioAlarmAction();
 452     actions->addAction(QStringLiteral("newAudio"), action);
 453 #pragma message("port QT5")
 454     //QT5 action->setGlobalShortcut(dummy);   // actions->addAction() must be called first!
 455     connect(action, &QAction::triggered, this, &MainWindow::slotNewAudio);
 456
 457     TemplateMenuAction *templateMenuAction = mActionNew->fromTemplateAlarmAction();
 458     actions->addAction(QStringLiteral("newFromTemplate"), templateMenuAction);
 459     connect(templateMenuAction, &TemplateMenuAction::selected, this, &MainWindow::slotNewFromTemplate);
 460
 461     mActionCreateTemplate = new QAction(i18nc("@action", "Create Tem&plate..."), this);
 462     actions->addAction(QStringLiteral("createTemplate"), mActionCreateTemplate);
 463     connect(mActionCreateTemplate, &QAction::triggered, this, &MainWindow::slotNewTemplate);
 464
 465     mActionCopy = new QAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18nc("@action", "&Copy..."), this);
 466     actions->addAction(QStringLiteral("copy"), mActionCopy);
 467     actions->setDefaultShortcut(mActionCopy, QKeySequence(Qt::SHIFT + Qt::Key_Insert));
 468     connect(mActionCopy, &QAction::triggered, this, &MainWindow::slotCopy);
 469
 470     mActionModify = new QAction(QIcon::fromTheme(QStringLiteral("document-properties")), i18nc("@action", "&Edit..."), this);
 471     actions->addAction(QStringLiteral("modify"), mActionModify);
 472     actions->setDefaultShortcut(mActionModify, QKeySequence(Qt::CTRL + Qt::Key_E));
 473     connect(mActionModify, &QAction::triggered, this, &MainWindow::slotModify);
 474
 475     mActionDelete = new QAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18nc("@action", "&Delete"), this);
 476     actions->addAction(QStringLiteral("delete"), mActionDelete);
 477     actions->setDefaultShortcut(mActionDelete, QKeySequence::Delete);
 478     connect(mActionDelete, &QAction::triggered, this, &MainWindow::slotDeleteIf);
 479
 480     // Set up Shift-Delete as a shortcut to delete without confirmation
 481     mActionDeleteForce = new QAction(i18nc("@action", "Delete Without Confirmation"), this);
 482     actions->addAction(QStringLiteral("delete-force"), mActionDeleteForce);
 483     actions->setDefaultShortcut(mActionDeleteForce, QKeySequence::Delete + Qt::SHIFT);
 484     connect(mActionDeleteForce, &QAction::triggered, this, &MainWindow::slotDeleteForce);
 485
 486     mActionReactivate = new QAction(i18nc("@action", "Reac&tivate"), this);
 487     actions->addAction(QStringLiteral("undelete"), mActionReactivate);
 488     actions->setDefaultShortcut(mActionReactivate, QKeySequence(Qt::CTRL + Qt::Key_R));
 489     connect(mActionReactivate, &QAction::triggered, this, &MainWindow::slotReactivate);
 490
 491     mActionEnable = new QAction(this);
 492     actions->addAction(QStringLiteral("disable"), mActionEnable);
 493     actions->setDefaultShortcut(mActionEnable, QKeySequence(Qt::CTRL + Qt::Key_B));
 494     connect(mActionEnable, &QAction::triggered, this, &MainWindow::slotEnable);
 495
 496     action = new QAction(i18nc("@action", "Wake From Suspend..."), this);
 497     actions->addAction(QStringLiteral("wakeSuspend"), action);
 498     connect(action, &QAction::triggered, this, &MainWindow::slotWakeFromSuspend);
 499
 500     action = KAlarm::createStopPlayAction(this);
 501     actions->addAction(QStringLiteral("stopAudio"), action);
 502     //QT5 action->setGlobalShortcut(dummy);   // actions->addAction() must be called first!
 503
 504     mActionShowTime = new KToggleAction(i18n_a_ShowAlarmTimes(), this);
 505     actions->addAction(QStringLiteral("showAlarmTimes"), mActionShowTime);
 506     connect(mActionShowTime, &KToggleAction::triggered, this, &MainWindow::slotShowTime);
 507
 508     mActionShowTimeTo = new KToggleAction(i18n_o_ShowTimeToAlarms(), this);
 509     actions->addAction(QStringLiteral("showTimeToAlarms"), mActionShowTimeTo);
 510     actions->setDefaultShortcut(mActionShowTimeTo, QKeySequence(Qt::CTRL + Qt::Key_I));
 511     connect(mActionShowTimeTo, &KToggleAction::triggered, this, &MainWindow::slotShowTimeTo);
 512
 513     mActionShowArchived = new KToggleAction(i18nc("@action", "Show Archi&ved Alarms"), this);
 514     actions->addAction(QStringLiteral("showArchivedAlarms"), mActionShowArchived);
 515     actions->setDefaultShortcut(mActionShowArchived, QKeySequence(Qt::CTRL + Qt::Key_P));
 516     connect(mActionShowArchived, &KToggleAction::triggered, this, &MainWindow::slotShowArchived);
 517
 518     mActionToggleTrayIcon = new KToggleAction(i18nc("@action", "Show in System &Tray"), this);
 519     actions->addAction(QStringLiteral("showInSystemTray"), mActionToggleTrayIcon);
 520     connect(mActionToggleTrayIcon, &KToggleAction::triggered, this, &MainWindow::slotToggleTrayIcon);
 521
 522     mActionToggleResourceSel = new KToggleAction(QIcon::fromTheme(QStringLiteral("view-choose")), i18nc("@action", "Show &Calendars"), this);
 523     actions->addAction(QStringLiteral("showResources"), mActionToggleResourceSel);
 524     connect(mActionToggleResourceSel, &KToggleAction::triggered, this, &MainWindow::slotToggleResourceSelector);
 525
 526     mActionSpreadWindows = KAlarm::createSpreadWindowsAction(this);
 527     actions->addAction(QStringLiteral("spread"), mActionSpreadWindows);
 528 #pragma message("port QT5")
 529
 530     //QT5 mActionSpreadWindows->setGlobalShortcut(dummy);   // actions->addAction() must be called first!
 531
 532     mActionImportAlarms = new QAction(i18nc("@action", "Import &Alarms..."), this);
 533     actions->addAction(QStringLiteral("importAlarms"), mActionImportAlarms);
 534     connect(mActionImportAlarms, &QAction::triggered, this, &MainWindow::slotImportAlarms);
 535
 536     mActionImportBirthdays = new QAction(i18nc("@action", "Import &Birthdays..."), this);
 537     actions->addAction(QStringLiteral("importBirthdays"), mActionImportBirthdays);
 538     connect(mActionImportBirthdays, &QAction::triggered, this, &MainWindow::slotBirthdays);
 539
 540     mActionExportAlarms = new QAction(i18nc("@action", "E&xport Selected Alarms..."), this);
 541     actions->addAction(QStringLiteral("exportAlarms"), mActionExportAlarms);
 542     connect(mActionExportAlarms, &QAction::triggered, this, &MainWindow::slotExportAlarms);
 543
 544     mActionExport = new QAction(i18nc("@action", "E&xport..."), this);
 545     actions->addAction(QStringLiteral("export"), mActionExport);
 546     connect(mActionExport, &QAction::triggered, this, &MainWindow::slotExportAlarms);
 547
 548     action = new QAction(QIcon::fromTheme(QStringLiteral("view-refresh")), i18nc("@action", "&Refresh Alarms"), this);
 549     actions->addAction(QStringLiteral("refreshAlarms"), action);
 550     connect(action, &QAction::triggered, this, &MainWindow::slotRefreshAlarms);
 551
 552     KToggleAction* toggleAction = KAlarm::createAlarmEnableAction(this);
 553     actions->addAction(QStringLiteral("alarmsEnable"), toggleAction);
 554     if (undoText.isNull())
 555     {
 556         // Get standard texts, etc., for Undo and Redo actions
 557         QAction* act = KStandardAction::undo(this, Q_NULLPTR, actions);
 558         undoShortcut     = act->shortcuts();
 559         undoText         = act->text();
 560         undoTextStripped = KLocalizedString::removeAcceleratorMarker(undoText);
 561         delete act;
 562         act = KStandardAction::redo(this, Q_NULLPTR, actions);
 563         redoShortcut     = act->shortcuts();
 564         redoText         = act->text();
 565         redoTextStripped = KLocalizedString::removeAcceleratorMarker(redoText);
 566         delete act;
 567     }
 568     mActionUndo = new KToolBarPopupAction(QIcon::fromTheme(QStringLiteral("edit-undo")), undoText, this);
 569     actions->addAction(QStringLiteral("edit_undo"), mActionUndo);
 570     mActionUndo->setShortcuts(undoShortcut);
 571     connect(mActionUndo, &KToolBarPopupAction::triggered, this, &MainWindow::slotUndo);
 572
 573     mActionRedo = new KToolBarPopupAction(QIcon::fromTheme(QStringLiteral("edit-redo")), redoText, this);
 574     actions->addAction(QStringLiteral("edit_redo"), mActionRedo);
 575     mActionRedo->setShortcuts(redoShortcut);
 576     connect(mActionRedo, &KToolBarPopupAction::triggered, this, &MainWindow::slotRedo);
 577
 578     KStandardAction::find(mListView, SLOT(slotFind()), actions);
 579     mActionFindNext = KStandardAction::findNext(mListView, SLOT(slotFindNext()), actions);
 580     mActionFindPrev = KStandardAction::findPrev(mListView, SLOT(slotFindPrev()), actions);
 581     KStandardAction::selectAll(mListView, SLOT(selectAll()), actions);
 582     KStandardAction::deselect(mListView, SLOT(clearSelection()), actions);
 583     // Quit only once the event loop is called; otherwise, the parent window will
 584     // be deleted while still processing the action, resulting in a crash.
 585     QAction* act = KStandardAction::quit(Q_NULLPTR, Q_NULLPTR, actions);
 586     connect(act, &QAction::triggered, this, &MainWindow::slotQuit, Qt::QueuedConnection);
 587     KStandardAction::keyBindings(this, SLOT(slotConfigureKeys()), actions);
 588     KStandardAction::configureToolbars(this, SLOT(slotConfigureToolbar()), actions);
 589     KStandardAction::preferences(this, SLOT(slotPreferences()), actions);
 590     mResourceSelector->initActions(actions);
 591     setStandardToolBarMenuEnabled(true);
 592     createGUI(UI_FILE);
 593     // Load menu and toolbar settings
 594     applyMainWindowSettings(KSharedConfig::openConfig()->group(WINDOW_NAME));
 595
 596     mContextMenu = static_cast<QMenu*>(factory()->container(QStringLiteral("listContext"), this));
 597     mActionsMenu = static_cast<QMenu*>(factory()->container(QStringLiteral("actions"), this));
 598     QMenu* resourceMenu = static_cast<QMenu*>(factory()->container(QStringLiteral("resourceContext"), this));
 599     mResourceSelector->setContextMenu(resourceMenu);
 600     mMenuError = (!mContextMenu  ||  !mActionsMenu  ||  !resourceMenu);
 601     connect(mActionUndo->menu(), SIGNAL(aboutToShow()), SLOT(slotInitUndoMenu()));
 602     connect(mActionUndo->menu(), SIGNAL(triggered(QAction*)), SLOT(slotUndoItem(QAction*)));
 603     connect(mActionRedo->menu(), SIGNAL(aboutToShow()), SLOT(slotInitRedoMenu()));
 604     connect(mActionRedo->menu(), SIGNAL(triggered(QAction*)), SLOT(slotRedoItem(QAction*)));
 605     connect(Undo::instance(), SIGNAL(changed(QString,QString)), SLOT(slotUndoStatus(QString,QString)));
 606     connect(mListView, &AlarmListView::findActive, this, &MainWindow::slotFindActive);
 607     Preferences::connect(SIGNAL(archivedKeepDaysChanged(int)), this, SLOT(updateKeepArchived(int)));
 608     Preferences::connect(SIGNAL(showInSystemTrayChanged(bool)), this, SLOT(updateTrayIconAction()));
 609     connect(theApp(), SIGNAL(trayIconToggled()), SLOT(updateTrayIconAction()));
 610
 611     // Set menu item states
 612     setEnableText(true);
 613     mActionShowTime->setChecked(mShowTime);
 614     mActionShowTimeTo->setChecked(mShowTimeTo);
 615     mActionShowArchived->setChecked(mShowArchived);
 616     if (!Preferences::archivedKeepDays())
 617         mActionShowArchived->setEnabled(false);
 618     mActionToggleResourceSel->setChecked(mShowResources);
 619     slotToggleResourceSelector();
 620     updateTrayIconAction();         // set the correct text for this action
 621     mActionUndo->setEnabled(Undo::haveUndo());
 622     mActionRedo->setEnabled(Undo::haveRedo());
 623     mActionFindNext->setEnabled(false);
 624     mActionFindPrev->setEnabled(false);
 625
 626     mActionCopy->setEnabled(false);
 627     mActionModify->setEnabled(false);
 628     mActionDelete->setEnabled(false);
 629     mActionReactivate->setEnabled(false);
 630     mActionEnable->setEnabled(false);
 631     mActionCreateTemplate->setEnabled(false);
 632     mActionExport->setEnabled(false);
 633
 634     Undo::emitChanged();     // set the Undo/Redo menu texts
 635 //    Daemon::monitoringAlarms();
 636 }
 637
 638 /******************************************************************************
 639 * Enable or disable the Templates menu item in every main window instance.
 640 */
 641 void MainWindow::enableTemplateMenuItem(bool enable)
 642 {
 643     for (int i = 0, end = mWindowList.count();  i < end;  ++i)
 644         mWindowList[i]->mActionTemplates->setEnabled(enable);
 645 }
 646
 647 /******************************************************************************
 648 * Refresh the alarm list in every main window instance.
 649 */
 650 void MainWindow::refresh()
 651 {
 652     qCDebug(KALARM_LOG);
 653     AkonadiModel::instance()->reload();
 654 }
 655
 656 /******************************************************************************
 657 * Called when the keep archived alarm setting changes in the user preferences.
 658 * Enable/disable Show archived alarms option.
 659 */
 660 void MainWindow::updateKeepArchived(int days)
 661 {
 662     qCDebug(KALARM_LOG) << (bool)days;
 663     if (mShowArchived  &&  !days)
 664         slotShowArchived();   // toggle Show Archived option setting
 665     mActionShowArchived->setEnabled(days);
 666 }
 667
 668 /******************************************************************************
 669 * Select an alarm in the displayed list.
 670 */
 671 void MainWindow::selectEvent(Akonadi::Item::Id eventId)
 672 {
 673     mListView->clearSelection();
 674     QModelIndex index = mListFilterModel->eventIndex(eventId);
 675     if (index.isValid())
 676     {
 677         mListView->select(index);
 678         mListView->scrollTo(index);
 679     }
 680 }
 681
 682 /******************************************************************************
 683 * Return the single selected alarm in the displayed list.
 684 */
 685 KAEvent MainWindow::selectedEvent() const
 686 {
 687     return mListView->selectedEvent();
 688 }
 689
 690 /******************************************************************************
 691 * Deselect all alarms in the displayed list.
 692 */
 693 void MainWindow::clearSelection()
 694 {
 695     mListView->clearSelection();
 696 }
 697
 698 /******************************************************************************
 699 * Called when the New button is clicked to edit a new alarm to add to the list.
 700 */
 701 void MainWindow::slotNew(EditAlarmDlg::Type type)
 702 {
 703     KAlarm::editNewAlarm(type, mListView);
 704 }
 705
 706 /******************************************************************************
 707 * Called when a template is selected from the New From Template popup menu.
 708 * Executes a New Alarm dialog, preset from the selected template.
 709 */
 710 void MainWindow::slotNewFromTemplate(const KAEvent* tmplate)
 711 {
 712     KAlarm::editNewAlarm(tmplate, mListView);
 713 }
 714
 715 /******************************************************************************
 716 * Called when the New Template button is clicked to create a new template
 717 * based on the currently selected alarm.
 718 */
 719 void MainWindow::slotNewTemplate()
 720 {
 721     KAEvent event = mListView->selectedEvent();
 722     if (event.isValid())
 723         KAlarm::editNewTemplate(&event, this);
 724 }
 725
 726 /******************************************************************************
 727 * Called when the Copy button is clicked to edit a copy of an existing alarm,
 728 * to add to the list.
 729 */
 730 void MainWindow::slotCopy()
 731 {
 732     KAEvent event = mListView->selectedEvent();
 733     if (event.isValid())
 734         KAlarm::editNewAlarm(&event, this);
 735 }
 736
 737 /******************************************************************************
 738 * Called when the Modify button is clicked to edit the currently highlighted
 739 * alarm in the list.
 740 */
 741 void MainWindow::slotModify()
 742 {
 743     KAEvent event = mListView->selectedEvent();
 744     if (event.isValid())
 745         KAlarm::editAlarm(&event, this);   // edit alarm (view-only mode if archived or read-only)
 746 }
 747
 748 /******************************************************************************
 749 * Called when the Delete button is clicked to delete the currently highlighted
 750 * alarms in the list.
 751 */
 752 void MainWindow::slotDelete(bool force)
 753 {
 754     QVector<KAEvent> events = mListView->selectedEvents();
 755     if (!force  &&  Preferences::confirmAlarmDeletion())
 756     {
 757         int n = events.count();
 758         if (KAMessageBox::warningContinueCancel(this, i18ncp("@info", "Do you really want to delete the selected alarm?",
 759                                                              "Do you really want to delete the %1 selected alarms?", n),
 760                                                 i18ncp("@title:window", "Delete Alarm", "Delete Alarms", n),
 761                                                 KGuiItem(i18nc("@action:button", "&Delete"), QStringLiteral("edit-delete")),
 762                                                 KStandardGuiItem::cancel(),
 763                                                 Preferences::CONFIRM_ALARM_DELETION)
 764             != KMessageBox::Continue)
 765             return;
 766     }
 767
 768     // Remove any events which have just triggered, from the list to delete.
 769     Undo::EventList undos;
 770     AlarmCalendar* resources = AlarmCalendar::resources();
 771     for (int i = 0;  i < events.count();  )
 772     {
 773         Akonadi::Collection c = resources->collectionForEvent(events[i].itemId());
 774         if (!c.isValid())
 775             events.remove(i);
 776         else
 777             undos.append(events[i++], c);
 778     }
 779
 780     if (events.isEmpty())
 781         qCDebug(KALARM_LOG) << "No alarms left to delete";
 782     else
 783     {
 784         // Delete the events from the calendar and displays
 785         KAlarm::deleteEvents(events, true, this);
 786         Undo::saveDeletes(undos);
 787     }
 788 }
 789
 790 /******************************************************************************
 791 * Called when the Reactivate button is clicked to reinstate the currently
 792 * highlighted archived alarms in the list.
 793 */
 794 void MainWindow::slotReactivate()
 795 {
 796     QVector<KAEvent> events = mListView->selectedEvents();
 797     mListView->clearSelection();
 798
 799     // Add the alarms to the displayed lists and to the calendar file
 800     Undo::EventList undos;
 801     QVector<EventId> ineligibleIDs;
 802     KAlarm::reactivateEvents(events, ineligibleIDs, Q_NULLPTR, this);
 803
 804     // Create the undo list, excluding ineligible events
 805     AlarmCalendar* resources = AlarmCalendar::resources();
 806     for (int i = 0, end = events.count();  i < end;  ++i)
 807     {
 808         if (!ineligibleIDs.contains(EventId(events[i])))
 809         {
 810             undos.append(events[i], resources->collectionForEvent(events[i].itemId()));
 811         }
 812     }
 813     Undo::saveReactivates(undos);
 814 }
 815
 816 /******************************************************************************
 817 * Called when the Enable/Disable button is clicked to enable or disable the
 818 * currently highlighted alarms in the list.
 819 */
 820 void MainWindow::slotEnable()
 821 {
 822     bool enable = mActionEnableEnable;    // save since changed in response to KAlarm::enableEvent()
 823     QVector<KAEvent> events = mListView->selectedEvents();
 824     QVector<KAEvent> eventCopies;
 825     for (int i = 0, end = events.count();  i < end;  ++i)
 826         eventCopies += events[i];
 827     KAlarm::enableEvents(eventCopies, enable, this);
 828     slotSelection();   // update Enable/Disable action text
 829 }
 830
 831 /******************************************************************************
 832 * Called when the Show Alarm Times menu item is selected or deselected.
 833 */
 834 void MainWindow::slotShowTime()
 835 {
 836     mShowTime = !mShowTime;
 837     mActionShowTime->setChecked(mShowTime);
 838     if (!mShowTime  &&  !mShowTimeTo)
 839         slotShowTimeTo();    // at least one time column must be displayed
 840     else
 841     {
 842         mListView->selectTimeColumns(mShowTime, mShowTimeTo);
 843         KConfigGroup config(KSharedConfig::openConfig(), VIEW_GROUP);
 844         config.writeEntry(SHOW_TIME_KEY, mShowTime);
 845         config.writeEntry(SHOW_TIME_TO_KEY, mShowTimeTo);
 846     }
 847 }
 848
 849 /******************************************************************************
 850 * Called when the Show Time To Alarms menu item is selected or deselected.
 851 */
 852 void MainWindow::slotShowTimeTo()
 853 {
 854     mShowTimeTo = !mShowTimeTo;
 855     mActionShowTimeTo->setChecked(mShowTimeTo);
 856     if (!mShowTimeTo  &&  !mShowTime)
 857         slotShowTime();    // at least one time column must be displayed
 858     else
 859     {
 860         mListView->selectTimeColumns(mShowTime, mShowTimeTo);
 861         KConfigGroup config(KSharedConfig::openConfig(), VIEW_GROUP);
 862         config.writeEntry(SHOW_TIME_KEY, mShowTime);
 863         config.writeEntry(SHOW_TIME_TO_KEY, mShowTimeTo);
 864     }
 865 }
 866
 867 /******************************************************************************
 868 * Called when the Show Archived Alarms menu item is selected or deselected.
 869 */
 870 void MainWindow::slotShowArchived()
 871 {
 872     mShowArchived = !mShowArchived;
 873     mActionShowArchived->setChecked(mShowArchived);
 874     mActionShowArchived->setToolTip(mShowArchived ? i18nc("@info:tooltip", "Hide Archived Alarms")
 875                                                   : i18nc("@info:tooltip", "Show Archived Alarms"));
 876     mListFilterModel->setEventTypeFilter(mShowArchived ? CalEvent::ACTIVE | CalEvent::ARCHIVED : CalEvent::ACTIVE);
 877     mListView->reset();
 878     KConfigGroup config(KSharedConfig::openConfig(), VIEW_GROUP);
 879     config.writeEntry(SHOW_ARCHIVED_KEY, mShowArchived);
 880 }
 881
 882 /******************************************************************************
 883 * Called when the Spread Windows global shortcut is selected, to spread alarm
 884 * windows so that they are all visible.
 885 */
 886 void MainWindow::slotSpreadWindowsShortcut()
 887 {
 888     mActionSpreadWindows->trigger();
 889 }
 890
 891 /******************************************************************************
 892 * Called when the Wake From Suspend menu option is selected.
 893 */
 894 void MainWindow::slotWakeFromSuspend()
 895 {
 896     (WakeFromSuspendDlg::create(this))->show();
 897 }
 898
 899 /******************************************************************************
 900 * Called when the Import Alarms menu item is selected, to merge alarms from an
 901 * external calendar into the current calendars.
 902 */
 903 void MainWindow::slotImportAlarms()
 904 {
 905     AlarmCalendar::importAlarms(this);
 906 }
 907
 908 /******************************************************************************
 909 * Called when the Export Alarms menu item is selected, to export the selected
 910 * alarms to an external calendar.
 911 */
 912 void MainWindow::slotExportAlarms()
 913 {
 914     QVector<KAEvent> events = mListView->selectedEvents();
 915     if (!events.isEmpty())
 916     {
 917         KAEvent::List evts = KAEvent::ptrList(events);
 918         AlarmCalendar::exportAlarms(evts, this);
 919     }
 920 }
 921
 922 /******************************************************************************
 923 * Called when the Import Birthdays menu item is selected, to display birthdays
 924 * from the address book for selection as alarms.
 925 */
 926 void MainWindow::slotBirthdays()
 927 {
 928     // Use AutoQPointer to guard against crash on application exit while
 929     // the dialogue is still open. It prevents double deletion (both on
 930     // deletion of MainWindow, and on return from this function).
 931     AutoQPointer<BirthdayDlg> dlg = new BirthdayDlg(this);
 932     if (dlg->exec() == QDialog::Accepted)
 933     {
 934         QVector<KAEvent> events = dlg->events();
 935         if (!events.isEmpty())
 936         {
 937             mListView->clearSelection();
 938             // Add alarm to the displayed lists and to the calendar file
 939             KAlarm::UpdateResult status = KAlarm::addEvents(events, dlg, true, true);
 940
 941             Undo::EventList undos;
 942             AlarmCalendar* resources = AlarmCalendar::resources();
 943             for (int i = 0, end = events.count();  i < end;  ++i)
 944             {
 945                 Akonadi::Collection c = resources->collectionForEvent(events[i].itemId());
 946                 undos.append(events[i], c);
 947             }
 948             Undo::saveAdds(undos, i18nc("@info", "Import birthdays"));
 949
 950             if (status != KAlarm::UPDATE_FAILED)
 951                 KAlarm::outputAlarmWarnings(dlg);
 952         }
 953     }
 954 }
 955
 956 /******************************************************************************
 957 * Called when the Templates menu item is selected, to display the alarm
 958 * template editing dialog.
 959 */
 960 void MainWindow::slotTemplates()
 961 {
 962     if (!mTemplateDlg)
 963     {
 964         mTemplateDlg = TemplateDlg::create(this);
 965         enableTemplateMenuItem(false);     // disable menu item in all windows
 966         connect(mTemplateDlg, SIGNAL(finished()), SLOT(slotTemplatesEnd()));
 967         mTemplateDlg->show();
 968     }
 969 }
 970
 971 /******************************************************************************
 972 * Called when the alarm template editing dialog has exited.
 973 */
 974 void MainWindow::slotTemplatesEnd()
 975 {
 976     if (mTemplateDlg)
 977     {
 978         mTemplateDlg->deleteLater();   // this deletes the dialog once it is safe to do so
 979         mTemplateDlg = Q_NULLPTR;
 980         enableTemplateMenuItem(true);      // re-enable menu item in all windows
 981     }
 982 }
 983
 984 /******************************************************************************
 985 * Called when the Display System Tray Icon menu item is selected.
 986 */
 987 void MainWindow::slotToggleTrayIcon()
 988 {
 989     theApp()->displayTrayIcon(!theApp()->trayIconDisplayed(), this);
 990 }
 991
 992 /******************************************************************************
 993 * Called when the Show Resource Selector menu item is selected.
 994 */
 995 void MainWindow::slotToggleResourceSelector()
 996 {
 997     mShowResources = mActionToggleResourceSel->isChecked();
 998     if (mShowResources)
 999     {
1000         if (mResourcesWidth <= 0)
1001         {
1002             mResourcesWidth = mResourceSelector->sizeHint().width();
1003             mResourceSelector->resize(mResourcesWidth, mResourceSelector->height());
1004             QList<int> widths = mSplitter->sizes();
1005             if (widths.count() == 1)
1006             {
1007                 int listwidth = widths[0] - mSplitter->handleWidth() - mResourcesWidth;
1008                 mListView->resize(listwidth, mListView->height());
1009                 widths.append(listwidth);
1010                 widths[0] = mResourcesWidth;
1011             }
1012             mSplitter->setSizes(widths);
1013         }
1014         mResourceSelector->show();
1015     }
1016     else
1017         mResourceSelector->hide();
1018
1019     KConfigGroup config(KSharedConfig::openConfig(), VIEW_GROUP);
1020     config.writeEntry(SHOW_RESOURCES_KEY, mShowResources);
1021 }
1022
1023 /******************************************************************************
1024 * Called when an error occurs in the resource calendar, to display a message.
1025 */
1026 void MainWindow::showErrorMessage(const QString& msg)
1027 {
1028     KAMessageBox::error(this, msg);
1029 }
1030
1031 /******************************************************************************
1032 * Called when the system tray icon is created or destroyed.
1033 * Set the system tray icon menu text according to whether or not the system
1034 * tray icon is currently visible.
1035 */
1036 void MainWindow::updateTrayIconAction()
1037 {
1038     mActionToggleTrayIcon->setEnabled(KSystemTrayIcon::isSystemTrayAvailable());
1039     mActionToggleTrayIcon->setChecked(theApp()->trayIconDisplayed());
1040 }
1041
1042 /******************************************************************************
1043 * Called when the active status of Find changes.
1044 */
1045 void MainWindow::slotFindActive(bool active)
1046 {
1047     mActionFindNext->setEnabled(active);
1048     mActionFindPrev->setEnabled(active);
1049 }
1050
1051 /******************************************************************************
1052 * Called when the Undo action is selected.
1053 */
1054 void MainWindow::slotUndo()
1055 {
1056     Undo::undo(this, KLocalizedString::removeAcceleratorMarker(mActionUndo->text()));
1057 }
1058
1059 /******************************************************************************
1060 * Called when the Redo action is selected.
1061 */
1062 void MainWindow::slotRedo()
1063 {
1064     Undo::redo(this, KLocalizedString::removeAcceleratorMarker(mActionRedo->text()));
1065 }
1066
1067 /******************************************************************************
1068 * Called when an Undo item is selected.
1069 */
1070 void MainWindow::slotUndoItem(QAction* action)
1071 {
1072     int id = mUndoMenuIds[action];
1073     Undo::undo(id, this, Undo::actionText(Undo::UNDO, id));
1074 }
1075
1076 /******************************************************************************
1077 * Called when a Redo item is selected.
1078 */
1079 void MainWindow::slotRedoItem(QAction* action)
1080 {
1081     int id = mUndoMenuIds[action];
1082     Undo::redo(id, this, Undo::actionText(Undo::REDO, id));
1083 }
1084
1085 /******************************************************************************
1086 * Called when the Undo menu is about to show.
1087 * Populates the menu.
1088 */
1089 void MainWindow::slotInitUndoMenu()
1090 {
1091     initUndoMenu(mActionUndo->menu(), Undo::UNDO);
1092 }
1093
1094 /******************************************************************************
1095 * Called when the Redo menu is about to show.
1096 * Populates the menu.
1097 */
1098 void MainWindow::slotInitRedoMenu()
1099 {
1100     initUndoMenu(mActionRedo->menu(), Undo::REDO);
1101 }
1102
1103 /******************************************************************************
1104 * Populate the undo or redo menu.
1105 */
1106 void MainWindow::initUndoMenu(QMenu* menu, Undo::Type type)
1107 {
1108     menu->clear();
1109     mUndoMenuIds.clear();
1110     const QString& action = (type == Undo::UNDO) ? undoTextStripped : redoTextStripped;
1111     QList<int> ids = Undo::ids(type);
1112     for (int i = 0, end = ids.count();  i < end;  ++i)
1113     {
1114         int id = ids[i];
1115         QString actText = Undo::actionText(type, id);
1116         QString descrip = Undo::description(type, id);
1117         QString text = descrip.isEmpty()
1118                      ? i18nc("@action Undo/Redo [action]", "%1 %2", action, actText)
1119                      : i18nc("@action Undo [action]: message", "%1 %2: %3", action, actText, descrip);
1120         QAction* act = menu->addAction(text);
1121         mUndoMenuIds[act] = id;
1122     }
1123 }
1124
1125 /******************************************************************************
1126 * Called when the status of the Undo or Redo list changes.
1127 * Change the Undo or Redo text to include the action which would be undone/redone.
1128 */
1129 void MainWindow::slotUndoStatus(const QString& undo, const QString& redo)
1130 {
1131     if (undo.isNull())
1132     {
1133         mActionUndo->setEnabled(false);
1134         mActionUndo->setText(undoText);
1135     }
1136     else
1137     {
1138         mActionUndo->setEnabled(true);
1139         mActionUndo->setText(QStringLiteral("%1 %2").arg(undoText).arg(undo));
1140     }
1141     if (redo.isNull())
1142     {
1143         mActionRedo->setEnabled(false);
1144         mActionRedo->setText(redoText);
1145     }
1146     else
1147     {
1148         mActionRedo->setEnabled(true);
1149         mActionRedo->setText(QStringLiteral("%1 %2").arg(redoText).arg(redo));
1150     }
1151 }
1152
1153 /******************************************************************************
1154 * Called when the Refresh Alarms menu item is selected.
1155 */
1156 void MainWindow::slotRefreshAlarms()
1157 {
1158     KAlarm::refreshAlarms();
1159 }
1160
1161 /******************************************************************************
1162 * Called when the "Configure KAlarm" menu item is selected.
1163 */
1164 void MainWindow::slotPreferences()
1165 {
1166     KAlarmPrefDlg::display();
1167 }
1168
1169 /******************************************************************************
1170 * Called when the Configure Keys menu item is selected.
1171 */
1172 void MainWindow::slotConfigureKeys()
1173 {
1174     KShortcutsDialog::configure(actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, this);
1175 }
1176
1177 /******************************************************************************
1178 * Called when the Configure Toolbars menu item is selected.
1179 */
1180 void MainWindow::slotConfigureToolbar()
1181 {
1182     KConfigGroup grp(KSharedConfig::openConfig()->group(WINDOW_NAME));
1183     saveMainWindowSettings(grp);
1184     KEditToolBar dlg(factory());
1185     connect(&dlg, &KEditToolBar::newToolBarConfig, this, &MainWindow::slotNewToolbarConfig);
1186     dlg.exec();
1187 }
1188
1189 /******************************************************************************
1190 * Called when OK or Apply is clicked in the Configure Toolbars dialog, to save
1191 * the new configuration.
1192 */
1193 void MainWindow::slotNewToolbarConfig()
1194 {
1195     createGUI(UI_FILE);
1196     applyMainWindowSettings(KSharedConfig::openConfig()->group(WINDOW_NAME));
1197 }
1198
1199 /******************************************************************************
1200 * Called when the Quit menu item is selected.
1201 * Note that this must be called by the event loop, not directly from the menu
1202 * item, since otherwise the window will be deleted while still processing the
1203 * menu, resulting in a crash.
1204 */
1205 void MainWindow::slotQuit()
1206 {
1207     theApp()->doQuit(this);
1208 }
1209
1210 /******************************************************************************
1211 * Called when the user or the session manager attempts to close the window.
1212 */
1213 void MainWindow::closeEvent(QCloseEvent* ce)
1214 {
1215     if (!theApp()->sessionClosingDown())
1216     {
1217         // The user (not the session manager) wants to close the window.
1218         if (isTrayParent())
1219         {
1220             // It's the parent window of the system tray icon, so just hide
1221             // it to prevent the system tray icon closing.
1222             hide();
1223             theApp()->quitIf();
1224             ce->ignore();
1225             return;
1226         }
1227     }
1228     ce->accept();
1229 }
1230
1231 /******************************************************************************
1232 * Called when the drag cursor enters a main or system tray window, to accept
1233 * or reject the dragged object.
1234 */
1235 void MainWindow::executeDragEnterEvent(QDragEnterEvent* e)
1236 {
1237     const QMimeData* data = e->mimeData();
1238     bool accept = ICalDrag::canDecode(data) ? !e->source()   // don't accept "text/calendar" objects from this application
1239                                                :    data->hasText()
1240                                                  || data->hasUrls()
1241                                                  || KPIM::MailList::canDecode(data);
1242     if (accept)
1243         e->acceptProposedAction();
1244 }
1245
1246 /******************************************************************************
1247 * Called when an object is dropped on the window.
1248 * If the object is recognised, the edit alarm dialog is opened appropriately.
1249 */
1250 void MainWindow::dropEvent(QDropEvent* e)
1251 {
1252     executeDropEvent(this, e);
1253 }
1254
1255 static QString getMailHeader(const char* header, KMime::Content& content)
1256 {
1257     KMime::Headers::Base* hd = content.headerByType(header);
1258     return hd ? hd->asUnicodeString() : QString();
1259 }
1260
1261 /******************************************************************************
1262 * Called when an object is dropped on a main or system tray window, to
1263 * evaluate the action required and extract the text.
1264 */
1265 void MainWindow::executeDropEvent(MainWindow* win, QDropEvent* e)
1266 {
1267     qCDebug(KALARM_LOG) << "Formats:" << e->mimeData()->formats();
1268     const QMimeData* data = e->mimeData();
1269     KAEvent::SubAction action = KAEvent::MESSAGE;
1270     QByteArray         bytes;
1271     AlarmText          alarmText;
1272     KPIM::MailList     mailList;
1273     QList<QUrl>        files;
1274     MemoryCalendar::Ptr calendar(new MemoryCalendar(Preferences::timeZone(true)));
1275 #ifndef NDEBUG
1276     QString fmts = data->formats().join(QStringLiteral(", "));
1277     qCDebug(KALARM_LOG) << fmts;
1278 #endif
1279
1280     /* The order of the tests below matters, since some dropped objects
1281      * provide more than one mime type.
1282      * Don't change them without careful thought !!
1283      */
1284     if (!(bytes = data->data(QStringLiteral("message/rfc822"))).isEmpty())
1285     {
1286         // Email message(s). Ignore all but the first.
1287         qCDebug(KALARM_LOG) << "email";
1288         KMime::Content content;
1289         content.setContent(bytes);
1290         content.parse();
1291         QString body;
1292         if (content.textContent())
1293             body = content.textContent()->decodedText(true, true);    // strip trailing newlines & spaces
1294         unsigned long sernum = 0;
1295         if (KPIM::MailList::canDecode(data))
1296         {
1297             // Get its KMail serial number to allow the KMail message
1298             // to be called up from the alarm message window.
1299             mailList = KPIM::MailList::fromMimeData(data);
1300             if (!mailList.isEmpty())
1301                 sernum = mailList[0].serialNumber();
1302         }
1303         alarmText.setEmail(getMailHeader("To", content),
1304                            getMailHeader("From", content),
1305                            getMailHeader("Cc", content),
1306                            getMailHeader("Date", content),
1307                            getMailHeader("Subject", content),
1308                    body, sernum);
1309     }
1310     else if (KPIM::MailList::canDecode(data))
1311     {
1312         mailList = KPIM::MailList::fromMimeData(data);
1313         // KMail message(s). Ignore all but the first.
1314         qCDebug(KALARM_LOG) << "KMail_list";
1315         if (mailList.isEmpty())
1316             return;
1317         KPIM::MailSummary& summary = mailList[0];
1318         QDateTime dt;
1319         dt.setTime_t(summary.date());
1320         QString body = KAMail::getMailBody(summary.serialNumber());
1321         alarmText.setEmail(summary.to(), summary.from(), QString(),
1322                            KLocale::global()->formatDateTime(dt), summary.subject(),
1323                            body, summary.serialNumber());
1324     }
1325     else if (ICalDrag::fromMimeData(data, calendar))
1326     {
1327         // iCalendar - If events are included, use the first event
1328         qCDebug(KALARM_LOG) << "iCalendar";
1329         Event::List events = calendar->rawEvents();
1330         if (!events.isEmpty())
1331         {
1332             KAEvent ev(events[0]);
1333             KAlarm::editNewAlarm(&ev, win);
1334             return;
1335         }
1336         // If todos are included, use the first todo
1337         Todo::List todos = calendar->rawTodos();
1338         if (todos.isEmpty())
1339             return;
1340         Todo::Ptr todo = todos[0];
1341         alarmText.setTodo(todo);
1342         KDateTime start = todo->dtStart(true);
1343         if (!start.isValid()  &&  todo->hasDueDate())
1344             start = todo->dtDue(true);
1345         KAEvent::Flags flags = KAEvent::DEFAULT_FONT;
1346         if (start.isDateOnly())
1347             flags |= KAEvent::ANY_TIME;
1348         KAEvent ev(start, alarmText.displayText(), Preferences::defaultBgColour(), Preferences::defaultFgColour(),
1349                    QFont(), KAEvent::MESSAGE, 0, flags, true);
1350         if (todo->recurs())
1351         {
1352             ev.setRecurrence(*todo->recurrence());
1353             ev.setNextOccurrence(KDateTime::currentUtcDateTime());
1354         }
1355         ev.endChanges();
1356         KAlarm::editNewAlarm(&ev, win);
1357         return;
1358     }
1359     else if (!(files = data->urls()).isEmpty())
1360     {
1361         qCDebug(KALARM_LOG) << "URL";
1362         // Try to find the mime type of the file, without downloading a remote file
1363         QMimeDatabase mimeDb;
1364         const QString mimeTypeName = mimeDb.mimeTypeForUrl(files[0]).name();
1365         action = mimeTypeName.startsWith(QStringLiteral("audio/")) ? KAEvent::AUDIO : KAEvent::FILE;
1366         alarmText.setText(files[0].toDisplayString());
1367     }
1368     else if (data->hasText())
1369     {
1370         QString text = data->text();
1371         qCDebug(KALARM_LOG) << "text";
1372         alarmText.setText(text);
1373     }
1374     else
1375         return;
1376
1377     if (!alarmText.isEmpty())
1378     {
1379         if (action == KAEvent::MESSAGE
1380         &&  (alarmText.isEmail() || alarmText.isScript()))
1381         {
1382             // If the alarm text could be interpreted as an email or command script,
1383             // prompt for which type of alarm to create.
1384             QStringList types;
1385             types += i18nc("@item:inlistbox", "Display Alarm");
1386             if (alarmText.isEmail())
1387                 types += i18nc("@item:inlistbox", "Email Alarm");
1388             else if (alarmText.isScript())
1389                 types += i18nc("@item:inlistbox", "Command Alarm");
1390             bool ok = false;
1391             QString type = QInputDialog::getItem(mainMainWindow(), i18nc("@title:window", "Alarm Type"),
1392                                                  i18nc("@info", "Choose alarm type to create:"), types, 0, false, &ok);
1393             if (!ok)
1394                 return;   // user didn't press OK
1395             int i = types.indexOf(type);
1396             if (i == 1)
1397                 action = alarmText.isEmail() ? KAEvent::EMAIL : KAEvent::COMMAND;
1398         }
1399         KAlarm::editNewAlarm(action, win, &alarmText);
1400     }
1401 }
1402
1403 /******************************************************************************
1404 * Called when the status of a calendar has changed.
1405 * Enable or disable actions appropriately.
1406 */
1407 void MainWindow::slotCalendarStatusChanged()
1408 {
1409     // Find whether there are any writable calendars
1410     bool active  = !CollectionControlModel::enabledCollections(CalEvent::ACTIVE, true).isEmpty();
1411     bool templat = !CollectionControlModel::enabledCollections(CalEvent::TEMPLATE, true).isEmpty();
1412     for (int i = 0, end = mWindowList.count();  i < end;  ++i)
1413     {
1414         MainWindow* w = mWindowList[i];
1415         w->mActionImportAlarms->setEnabled(active || templat);
1416         w->mActionImportBirthdays->setEnabled(active);
1417         w->mActionCreateTemplate->setEnabled(templat);
1418         // Note: w->mActionNew enabled status is set in the NewAlarmAction class.
1419         w->slotSelection();
1420     }
1421 }
1422
1423 /******************************************************************************
1424 * Called when the selected items in the ListView change.
1425 * Enables the actions appropriately.
1426 */
1427 void MainWindow::slotSelection()
1428 {
1429     // Find which events have been selected
1430     QVector<KAEvent> events = mListView->selectedEvents();
1431     int count = events.count();
1432     if (!count)
1433     {
1434         selectionCleared();    // disable actions
1435         Q_EMIT selectionChanged();
1436         return;
1437     }
1438
1439     // Find whether there are any writable resources
1440     bool active = mActionNew->isEnabled();
1441
1442     bool readOnly = false;
1443     bool allArchived = true;
1444     bool enableReactivate = true;
1445     bool enableEnableDisable = true;
1446     bool enableEnable = false;
1447     bool enableDisable = false;
1448     AlarmCalendar* resources = AlarmCalendar::resources();
1449     KDateTime now = KDateTime::currentUtcDateTime();
1450     for (int i = 0;  i < count;  ++i)
1451     {
1452         KAEvent* ev = resources->event(EventId(events[i]));   // get up-to-date status
1453         KAEvent* event = ev ? ev : &events[i];
1454         bool expired = event->expired();
1455         if (!expired)
1456             allArchived = false;
1457         if (resources->eventReadOnly(event->itemId()))
1458             readOnly = true;
1459         if (enableReactivate
1460         &&  (!expired  ||  !event->occursAfter(now, true)))
1461             enableReactivate = false;
1462         if (enableEnableDisable)
1463         {
1464             if (expired)
1465                 enableEnableDisable = enableEnable = enableDisable = false;
1466             else
1467             {
1468                 if (!enableEnable  &&  !event->enabled())
1469                     enableEnable = true;
1470                 if (!enableDisable  &&  event->enabled())
1471                     enableDisable = true;
1472             }
1473         }
1474     }
1475
1476     qCDebug(KALARM_LOG) << "true";
1477     mActionCreateTemplate->setEnabled((count == 1) && !CollectionControlModel::enabledCollections(CalEvent::TEMPLATE, true).isEmpty());
1478     mActionExportAlarms->setEnabled(true);
1479     mActionExport->setEnabled(true);
1480     mActionCopy->setEnabled(active && count == 1);
1481     mActionModify->setEnabled(count == 1);
1482     mActionDelete->setEnabled(!readOnly && (active || allArchived));
1483     mActionReactivate->setEnabled(active && enableReactivate);
1484     mActionEnable->setEnabled(active && !readOnly && (enableEnable || enableDisable));
1485     if (enableEnable || enableDisable)
1486         setEnableText(enableEnable);
1487
1488     Q_EMIT selectionChanged();
1489 }
1490
1491 /******************************************************************************
1492 * Called when a context menu is requested in the ListView.
1493 * Displays a context menu to modify or delete the selected item.
1494 */
1495 void MainWindow::slotContextMenuRequested(const QPoint& globalPos)
1496 {
1497     qCDebug(KALARM_LOG);
1498     if (mContextMenu)
1499         mContextMenu->popup(globalPos);
1500 }
1501
1502 /******************************************************************************
1503 * Disables actions when no item is selected.
1504 */
1505 void MainWindow::selectionCleared()
1506 {
1507     mActionCreateTemplate->setEnabled(false);
1508     mActionExportAlarms->setEnabled(false);
1509     mActionExport->setEnabled(false);
1510     mActionCopy->setEnabled(false);
1511     mActionModify->setEnabled(false);
1512     mActionDelete->setEnabled(false);
1513     mActionReactivate->setEnabled(false);
1514     mActionEnable->setEnabled(false);
1515 }
1516
1517 /******************************************************************************
1518 * Set the text of the Enable/Disable menu action.
1519 */
1520 void MainWindow::setEnableText(bool enable)
1521 {
1522     mActionEnableEnable = enable;
1523     mActionEnable->setText(enable ? i18nc("@action", "Ena&ble") : i18nc("@action", "Disa&ble"));
1524 }
1525
1526 /******************************************************************************
1527 * Display or hide the specified main window.
1528 * This should only be called when the application doesn't run in the system tray.
1529 */
1530 MainWindow* MainWindow::toggleWindow(MainWindow* win)
1531 {
1532     if (win  &&  mWindowList.indexOf(win) != -1)
1533     {
1534         // A window is specified (and it exists)
1535         if (win->isVisible())
1536         {
1537             // The window is visible, so close it
1538             win->close();
1539             return Q_NULLPTR;
1540         }
1541         else
1542         {
1543             // The window is hidden, so display it
1544             win->hide();        // in case it's on a different desktop
1545             win->setWindowState(win->windowState() & ~Qt::WindowMinimized);
1546             win->raise();
1547             win->activateWindow();
1548             return win;
1549         }
1550     }
1551
1552     // No window is specified, or the window doesn't exist. Open a new one.
1553     win = create();
1554     win->show();
1555     return win;
1556 }
1557
1558 /******************************************************************************
1559 * Called when the Edit button is clicked in an alarm message window.
1560 * This controls the alarm edit dialog created by the alarm window, and allows
1561 * it to remain unaffected by the alarm window closing.
1562 * See MessageWin::slotEdit() for more information.
1563 */
1564 void MainWindow::editAlarm(EditAlarmDlg* dlg, const KAEvent& event)
1565 {
1566     mEditAlarmMap[dlg] = event;
1567     connect(dlg, &KEditToolBar::accepted, this, &MainWindow::editAlarmOk);
1568     connect(dlg, &KEditToolBar::destroyed, this, &MainWindow::editAlarmDeleted);
1569     dlg->setAttribute(Qt::WA_DeleteOnClose, true);   // ensure no memory leaks
1570     dlg->show();
1571 }
1572
1573 /******************************************************************************
1574 * Called when OK is clicked in the alarm edit dialog shown by editAlarm().
1575 * Updates the event which has been edited.
1576 */
1577 void MainWindow::editAlarmOk()
1578 {
1579     EditAlarmDlg* dlg = qobject_cast<EditAlarmDlg*>(sender());
1580     if (!dlg)
1581         return;
1582     QMap<EditAlarmDlg*, KAEvent>::Iterator it = mEditAlarmMap.find(dlg);
1583     if (it == mEditAlarmMap.end())
1584         return;
1585     KAEvent event = it.value();
1586     mEditAlarmMap.erase(it);
1587     if (!event.isValid())
1588         return;
1589     if (dlg->result() != QDialog::Accepted)
1590         return;
1591     Akonadi::Collection c = AkonadiModel::instance()->collection(event);
1592     KAlarm::updateEditedAlarm(dlg, event, c);
1593 }
1594
1595 /******************************************************************************
1596 * Called when the alarm edit dialog shown by editAlarm() is deleted.
1597 * Removes the dialog from the pending list.
1598 */
1599 void MainWindow::editAlarmDeleted(QObject* obj)
1600 {
1601     mEditAlarmMap.remove(static_cast<EditAlarmDlg*>(obj));
1602 }
1603
1604 // vim: et sw=4: