diff --git a/src/Gui/ExportMenu.cpp b/src/Gui/ExportMenu.cpp
index b29085d..bb7b5eb 100644
--- a/src/Gui/ExportMenu.cpp
+++ b/src/Gui/ExportMenu.cpp
@@ -1,206 +1,206 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser 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 "ExportMenu.h"
 
 #include "Config.h"
 
 #include <KLocalizedString>
 #include <KMimeTypeTrader>
 #include <KRun>
 #include <KStandardShortcut>
 #ifdef KIPI_FOUND
 #include <KIPI/Plugin>
 #endif
 
 #include <QDebug>
 #include <QJsonArray>
 #include <QTimer>
 
 ExportMenu::ExportMenu(QWidget *parent) :
     QMenu(parent),
 #ifdef PURPOSE_FOUND
     mUpdatedImageAvailable(false),
     mPurposeMenu(new Purpose::Menu(this)),
 #endif
     mExportManager(ExportManager::instance())
 {
     QTimer::singleShot(300, this, &ExportMenu::populateMenu);
 }
 
 void ExportMenu::populateMenu()
 {
 #ifdef PURPOSE_FOUND
     loadPurposeMenu();
 #endif
 
 #ifdef KIPI_FOUND
     mKipiMenu = addMenu(i18n("More Online Services"));
     mKipiMenu->addAction(i18n("Please wait..."));
     mKipiMenuLoaded = false;
 
     connect(mKipiMenu, &QMenu::aboutToShow, this, &ExportMenu::loadKipiItems);
 #endif
 
     addSeparator();
     getKServiceItems();
 }
 
 
 void ExportMenu::imageUpdated()
 {
 #ifdef PURPOSE_FOUND
     // mark cached image as stale
     mUpdatedImageAvailable = true;
     mPurposeMenu->clear();
 #endif
 }
 
 
 void ExportMenu::getKServiceItems()
 {
     // populate all locally installed applications and services
     // which can handle images first
 
     const KService::List services = KMimeTypeTrader::self()->query(QStringLiteral("image/png"));
 
     Q_FOREACH (auto service, services) {
         QString name = service->name().replace(QLatin1Char('&'), QLatin1String("&&"));
-        QAction *action = new QAction(QIcon::fromTheme(service->icon()), name, nullptr);
+        QAction *action = new QAction(QIcon::fromTheme(service->icon()), name, this);
 
         connect(action, &QAction::triggered, [=]() {
             QList<QUrl> whereIs({ mExportManager->tempSave() });
             KRun::runService(*service, whereIs, parentWidget(), true);
         });
         addAction(action);
     }
 
     // now let the user manually chose an application to open the
     // image with
 
     addSeparator();
 
     QAction *openWith = new QAction(this);
     openWith->setText(i18n("Other Application"));
     openWith->setIcon(QIcon::fromTheme(QStringLiteral("document-share")));
     openWith->setShortcuts(KStandardShortcut::open());
 
     connect(openWith, &QAction::triggered, [=]() {
         QList<QUrl> whereIs({ mExportManager->tempSave() });
         KRun::displayOpenWithDialog(whereIs, parentWidget(), true);
     });
     addAction(openWith);
 }
 
 #ifdef KIPI_FOUND
 void ExportMenu::loadKipiItems()
 {
     if (!mKipiMenuLoaded) {
         QTimer::singleShot(500, this, &ExportMenu::getKipiItems);
         mKipiMenuLoaded = true;
     }
 }
 
 void ExportMenu::getKipiItems()
 {
     mKipiMenu->clear();
 
     mKipiInterface = new KSGKipiInterface(this);
     KIPI::PluginLoader *loader = new KIPI::PluginLoader;
 
     loader->setInterface(mKipiInterface);
     loader->init();
 
     KIPI::PluginLoader::PluginList pluginList = loader->pluginList();
 
     Q_FOREACH (const auto &pluginInfo, pluginList) {
         if (!(pluginInfo->shouldLoad())) {
             continue;
         }
 
         KIPI::Plugin *plugin = pluginInfo->plugin();
         if (!(plugin)) {
             qWarning() << i18n("KIPI plugin from library %1 failed to load", pluginInfo->library());
             continue;
         }
 
         plugin->setup(&mDummyWidget);
 
         QList<QAction *> actions = plugin->actions();
         QSet<QAction *> exportActions;
 
         Q_FOREACH (auto action, actions) {
             KIPI::Category category = plugin->category(action);
             if (category == KIPI::ExportPlugin) {
                 exportActions += action;
             } else if (category == KIPI::ImagesPlugin && pluginInfo->library().contains(QStringLiteral("kipiplugin_sendimages"))) {
                 exportActions += action;
             }
         }
 
         Q_FOREACH (auto action, exportActions) {
             mKipiMenu->addAction(action);
         }
     }
 
     // If there are no export actions, then perhaps the kipi-plugins package is not installed.
     if (mKipiMenu->isEmpty()) {
         mKipiMenu->addAction(i18n("No KIPI plugins available"))->setEnabled(false);
     }
 }
 #endif
 
 #ifdef PURPOSE_FOUND
 void ExportMenu::loadPurposeMenu()
 {
     // attach the menu
     QAction *purposeMenu = addMenu(mPurposeMenu);
     purposeMenu->setText(i18n("Share"));
 
     // set up the callback signal
     connect(mPurposeMenu, &Purpose::Menu::finished, this, [this](const QJsonObject &output, int error, const QString &message) {
         if (error) {
             emit imageShared(true, message);
         } else {
             emit imageShared(false, output[QStringLiteral("url")].toString());
         }
     });
 
     // update available options based on the latest picture
     connect(mPurposeMenu, &QMenu::aboutToShow, this, &ExportMenu::loadPurposeItems);
 }
 
 void ExportMenu::loadPurposeItems()
 {
     if (!mUpdatedImageAvailable) {
         return;
     }
 
     // updated image available, we lazily load it now
     QString dataUri = ExportManager::instance()->pixmapDataUri();
     mUpdatedImageAvailable = false;
 
     mPurposeMenu->model()->setInputData(QJsonObject {
         { QStringLiteral("mimeType"), QStringLiteral("image/png") },
         { QStringLiteral("urls"), QJsonArray({ dataUri }) }
     });
     mPurposeMenu->model()->setPluginType(QStringLiteral("Export"));
     mPurposeMenu->reload();
 }
 #endif
diff --git a/src/Gui/KSMainWindow.cpp b/src/Gui/KSMainWindow.cpp
index 282974f..c565eae 100644
--- a/src/Gui/KSMainWindow.cpp
+++ b/src/Gui/KSMainWindow.cpp
@@ -1,393 +1,393 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser 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 "KSMainWindow.h"
 
 #include "Config.h"
 #include "SettingsDialog/SettingsDialog.h"
 
 #include <KAboutData>
 #include <KGuiItem>
 #include <KHelpMenu>
 #include <KIO/OpenFileManagerWindowJob>
 #include <KLocalizedString>
 #include <KNS3/KMoreToolsMenuFactory>
 #include <KStandardAction>
 #include <KStandardGuiItem>
 #include <KWindowSystem>
 
 #include <QDesktopServices>
 #include <QJsonArray>
 #include <QPrintDialog>
 #include <QPushButton>
 #include <QTimer>
 #include <QVBoxLayout>
 #ifdef XCB_FOUND
 #include <QX11Info>
 #include <xcb/xcb.h>
 #endif
 
 
 static const int DEFAULT_WINDOW_HEIGHT = 420;
 static const int DEFAULT_WINDOW_WIDTH = 840;
 static const int MAXIMUM_WINDOW_WIDTH = 1000;
 
 KSMainWindow::KSMainWindow(bool onClickAvailable, QWidget *parent) :
     QDialog(parent),
     mKSWidget(new KSWidget),
     mDivider(new QFrame),
     mDialogButtonBox(new QDialogButtonBox),
     mConfigureButton(new QToolButton),
     mToolsButton(new QPushButton),
     mSendToButton(new QPushButton),
     mClipboardButton(new QToolButton),
     mSaveButton(new QToolButton),
     mSaveMenu(new QMenu),
-    mSaveAsAction(new QAction(nullptr)),
-    mSaveAction(new QAction(nullptr)),
+    mSaveAsAction(new QAction(this)),
+    mSaveAction(new QAction(this)),
     mMessageWidget(new KMessageWidget),
     mToolsMenu(new QMenu),
     mScreenRecorderToolsMenu(new QMenu),
     mExportMenu(new ExportMenu(this)),
     mOnClickAvailable(onClickAvailable)
 {
     // before we do anything, we need to set a window property
     // that skips the close/hide window animation on kwin. this
     // fixes a ghost image of the spectacle window that appears
     // on subsequent screenshots taken with the take new screenshot
     // button
     //
     // credits for this goes to Thomas Lübking <thomas.luebking@gmail.com>
 
 #ifdef XCB_FOUND
     if (KWindowSystem::isPlatformX11()) {
         // create a window if we haven't already. note that the QWidget constructor
         // should already have done this
 
         if (winId() == 0) {
             create(0, true, true);
         }
 
         // do the xcb shenanigans
 
         xcb_connection_t *xcbConn = QX11Info::connection();
         const QByteArray effectName = QByteArrayLiteral("_KDE_NET_WM_SKIP_CLOSE_ANIMATION");
 
         xcb_intern_atom_cookie_t atomCookie = xcb_intern_atom_unchecked(xcbConn, false, effectName.length(), effectName.constData());
         QScopedPointer<xcb_intern_atom_reply_t, QScopedPointerPodDeleter> atom(xcb_intern_atom_reply(xcbConn, atomCookie, nullptr));
         if (atom.isNull()) {
           goto done;
         }
 
         uint32_t value = 1;
         xcb_change_property(xcbConn, XCB_PROP_MODE_REPLACE, winId(), atom->atom, XCB_ATOM_CARDINAL, 32, 1, &value);
     }
 #endif
 
     done:
     QMetaObject::invokeMethod(this, "init", Qt::QueuedConnection);
 }
 
 KSMainWindow::~KSMainWindow()
 {}
 
 // GUI init
 
 void KSMainWindow::init()
 {
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
     KConfigGroup guiConfig(config, "GuiConfig");
 
     // window properties
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     QPoint location = guiConfig.readEntry("window-position", QPoint(50, 50));
     move(location);
 
     // change window title on save
 
     connect(ExportManager::instance(), &ExportManager::imageSaved, this, &KSMainWindow::setScreenshotWindowTitle);
 
     // the KSGWidget
 
     connect(mKSWidget, &KSWidget::newScreenshotRequest, this, &KSMainWindow::captureScreenshot);
     connect(mKSWidget, &KSWidget::dragInitiated, this, &KSMainWindow::dragAndDropRequest);
 
     // the Button Bar
 
     mDialogButtonBox->setStandardButtons(QDialogButtonBox::Help);
 
     mConfigureButton->setDefaultAction(KStandardAction::preferences(this, SLOT(showPreferencesDialog()), this));
     mConfigureButton->setText(i18n("Configure..."));
     mConfigureButton->setToolTip(i18n("Change Spectacle's settings."));
     mConfigureButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     mDialogButtonBox->addButton(mConfigureButton, QDialogButtonBox::ResetRole);
 
     KGuiItem::assign(mToolsButton, KGuiItem(i18n("Tools")));
     mToolsButton->setIcon(QIcon::fromTheme(QStringLiteral("application-menu")));
     mDialogButtonBox->addButton(mToolsButton, QDialogButtonBox::ActionRole);
     mToolsButton->setMenu(mToolsMenu);
 
     KGuiItem::assign(mSendToButton, KGuiItem(i18n("Export")));
     mSendToButton->setIcon(QIcon::fromTheme(QStringLiteral("document-share")));
     mDialogButtonBox->addButton(mSendToButton, QDialogButtonBox::ActionRole);
 
     mClipboardButton->setDefaultAction(KStandardAction::copy(this, SLOT(sendToClipboard()), this));
     mClipboardButton->setText(i18n("Copy To Clipboard"));
     mClipboardButton->setToolTip(i18n("Copy the current screenshot image to the clipboard."));
     mClipboardButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     mDialogButtonBox->addButton(mClipboardButton, QDialogButtonBox::ActionRole);
 
     mSaveButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     mSaveButton->setMenu(mSaveMenu);
     mSaveButton->setPopupMode(QToolButton::MenuButtonPopup);
     mDialogButtonBox->addButton(mSaveButton, QDialogButtonBox::ActionRole);
 
     // the help menu
     KHelpMenu *helpMenu = new KHelpMenu(this, KAboutData::applicationData(), true);
     mDialogButtonBox->button(QDialogButtonBox::Help)->setMenu(helpMenu->menu());
 
     // the tools menu
     mToolsMenu->addAction(QIcon::fromTheme(QStringLiteral("document-open-folder")),
                           i18n("Open Screenshots Folder"),
                           this, &KSMainWindow::openScreenshotsFolder);
     mToolsMenu->addAction(KStandardAction::print(this, &KSMainWindow::showPrintDialog, this));
     mScreenRecorderToolsMenu = mToolsMenu->addMenu(i18n("Record Screen"));
     connect(mScreenRecorderToolsMenu, &QMenu::aboutToShow, [this]()
     {
         mScreenrecorderToolsMenuFactory.reset(new KMoreToolsMenuFactory(QStringLiteral("spectacle/screenrecorder-tools")));
         mScreenRecorderToolsMenu->clear();
         mScreenrecorderToolsMenuFactory->fillMenuFromGroupingNames(mScreenRecorderToolsMenu, { QStringLiteral("screenrecorder") });
     } );
 
     // the save menu
     mSaveAsAction = KStandardAction::saveAs(this, &KSMainWindow::saveAs, this);
     mSaveAction = KStandardAction::save(this, &KSMainWindow::save, this);
     mSaveMenu->addAction(mSaveAsAction);
     mSaveMenu->addAction(mSaveAction);
     setDefaultSaveAction();
 
     // message widget
     connect(mMessageWidget, &KMessageWidget::linkActivated, this, [](const QString &str) { QDesktopServices::openUrl(QUrl(str)); } );
 
     // layouts
 
     mDivider->setFrameShape(QFrame::HLine);
     mDivider->setLineWidth(2);
 
     QVBoxLayout *layout = new QVBoxLayout(this);
     layout->addWidget(mKSWidget);
     layout->addWidget(mMessageWidget);
     layout->addWidget(mDivider);
     layout->addWidget(mDialogButtonBox);
     mMessageWidget->hide();
 
     // populate our send-to actions
 
     mSendToButton->setMenu(mExportMenu);
     connect(mExportMenu, &ExportMenu::imageShared, this, &KSMainWindow::showImageSharedFeedback);
 
     // disable onClick mode if not available on the platform
 
     if (!mOnClickAvailable) {
         mKSWidget->disableOnClick();
     }
     resize(QSize(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT).expandedTo(minimumSize()));
 
     // Allow Ctrl+Q to quit the app
     QAction *actionQuit = KStandardAction::quit(qApp, &QApplication::quit, this);
     actionQuit->setShortcut(QKeySequence::Quit);
     addAction(actionQuit);
 
     // done with the init
 }
 
 int KSMainWindow::windowWidth(const QPixmap &pixmap) const
 {
     // Calculates what the width of the window should be for the captured image to perfectly fit
     // the area reserved for the image, with the height already set.
 
     const float pixmapAspectRatio = (float)pixmap.width() / pixmap.height();
     const int imageHeight = mKSWidget->height() - 2 * layout()->spacing();
     const int imageWidth = pixmapAspectRatio * imageHeight;
 
     int alignedWindowWidth = qMin(mKSWidget->imagePaddingWidth() + imageWidth, MAXIMUM_WINDOW_WIDTH);
     alignedWindowWidth += layout()->contentsMargins().left() + layout()->contentsMargins().right();
     alignedWindowWidth += 2; // margins is removing 1 - 1 pixel for some reason
 
     return alignedWindowWidth;
 }
 
 void KSMainWindow::setDefaultSaveAction()
 {
     switch (SpectacleConfig::instance()->lastUsedSaveMode()) {
     case SaveMode::SaveAs:
         mSaveButton->setDefaultAction(mSaveAsAction);
         break;
     case SaveMode::Save:
         mSaveButton->setDefaultAction(mSaveAction);
         break;
     }
 }
 
 // overrides
 
 void KSMainWindow::moveEvent(QMoveEvent *event)
 {
     Q_UNUSED(event);
 
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
     KConfigGroup guiConfig(config, "GuiConfig");
 
     guiConfig.writeEntry("window-position", pos());
     guiConfig.sync();
 }
 
 // slots
 
 void KSMainWindow::captureScreenshot(ImageGrabber::GrabMode mode, int timeout, bool includePointer, bool includeDecorations)
 {
     hide();
     emit newScreenshotRequest(mode, timeout, includePointer, includeDecorations);
 }
 
 void KSMainWindow::setScreenshotAndShow(const QPixmap &pixmap)
 {
     mKSWidget->setScreenshotPixmap(pixmap);
     mExportMenu->imageUpdated();
 
     setWindowTitle(i18nc("Unsaved Screenshot", "Unsaved[*]"));
     setWindowModified(true);
 
     show();
 
     resize(QSize(windowWidth(pixmap), DEFAULT_WINDOW_HEIGHT));
 }
 
 void KSMainWindow::showPrintDialog()
 {
     QPrinter *printer = new QPrinter(QPrinter::HighResolution);
     QPrintDialog printDialog(printer, this);
     if (printDialog.exec() == QDialog::Accepted) {
         ExportManager::instance()->doPrint(printer);
         return;
     }
     delete printer;
 }
 
 void KSMainWindow::openScreenshotsFolder()
 {
     // Highlight last screenshot in file manager if user saved at least once,
     // or open default directory as determined by save button
     QUrl location = ExportManager::instance()->lastSavePath();
     if (!ExportManager::instance()->isFileExists(location)) {
         switch(SpectacleConfig::instance()->lastUsedSaveMode()) {
         case SaveMode::Save:
             location = QUrl::fromLocalFile(ExportManager::instance()->saveLocation() + QStringLiteral("/"));
             break;
         case SaveMode::SaveAs:
             location = SpectacleConfig::instance()->lastSaveAsLocation();  // already has a "/" at the end
             break;
         }
         if (!ExportManager::instance()->isFileExists(location)) {
             location = QUrl(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation) + QStringLiteral("/"));
         }
     }
     KIO::highlightInFileManager({location});
 }
 
 void KSMainWindow::showImageSharedFeedback(bool error, const QString &message)
 {
     if (error) {
         mMessageWidget->setMessageType(KMessageWidget::Error);
         mMessageWidget->setText(i18n("There was a problem sharing the image: %1", message));
         mMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("dialog-error")));
     } else {
         mMessageWidget->setMessageType(KMessageWidget::Positive);
         if (message.isEmpty())
             mMessageWidget->setText(i18n("Image shared"));
         else
             mMessageWidget->setText(i18n("You can find the shared image at: <a href=\"%1\">%1</a>", message));
         mMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("dialog-ok-apply")));
     }
 
     mMessageWidget->animatedShow();
     QTimer::singleShot(20000, mMessageWidget, &KMessageWidget::animatedHide);
 }
 
 void KSMainWindow::sendToClipboard()
 {
     ExportManager::instance()->doCopyToClipboard();
 
     if (SpectacleConfig::instance()->quitAfterSaveOrCopyChecked()) {
         qApp->setQuitOnLastWindowClosed(false);
         hide();
         QTimer::singleShot(250, qApp, &QApplication::quit);
     }
 
     mMessageWidget->setMessageType(KMessageWidget::Information);
     mMessageWidget->setText(i18n("The screenshot has been copied to the clipboard."));
     mMessageWidget->setIcon(QIcon::fromTheme(QStringLiteral("dialog-information")));
 
     mMessageWidget->animatedShow();
     QTimer::singleShot(10000, mMessageWidget, &KMessageWidget::animatedHide);
 }
 
 void KSMainWindow::showPreferencesDialog()
 {
     SettingsDialog prefDialog(this);
     prefDialog.exec();
 }
 
 void KSMainWindow::setScreenshotWindowTitle(QUrl location)
 {
     setWindowTitle(location.fileName());
     setWindowModified(false);
 }
 
 void KSMainWindow::save()
 {
     SpectacleConfig::instance()->setLastUsedSaveMode(SaveMode::Save);
     setDefaultSaveAction();
 
     if (SpectacleConfig::instance()->quitAfterSaveOrCopyChecked()) {
         ExportManager::instance()->doSave(QUrl(), true);
         qApp->setQuitOnLastWindowClosed(false);
         hide();
     }
     else {
         ExportManager::instance()->doSave();
     }
 }
 
 void KSMainWindow::saveAs()
 {
     SpectacleConfig::instance()->setLastUsedSaveMode(SaveMode::SaveAs);
     setDefaultSaveAction();
 
     if (SpectacleConfig::instance()->quitAfterSaveOrCopyChecked()) {
         if (ExportManager::instance()->doSaveAs(this, true)) {
             qApp->setQuitOnLastWindowClosed(false);
             hide();
         }
     }
     else {
         ExportManager::instance()->doSaveAs(this, false);
     }
 }
diff --git a/src/SpectacleCore.cpp b/src/SpectacleCore.cpp
index f80c36d..b230ced 100644
--- a/src/SpectacleCore.cpp
+++ b/src/SpectacleCore.cpp
@@ -1,307 +1,308 @@
 /*
  *  Copyright (C) 2015 Boudhayan Gupta <bgupta@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser 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 "SpectacleCore.h"
 
 #include "Config.h"
 #include "PlatformBackends/DummyImageGrabber.h"
 #ifdef XCB_FOUND
 #include "PlatformBackends/X11ImageGrabber.h"
 #endif
 #include "PlatformBackends/KWinWaylandImageGrabber.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KNotification>
 #include <KRun>
 #include <KWindowSystem>
 
 #include <QClipboard>
 #include <QDebug>
 #include <QDir>
 #include <QDrag>
 #include <QMimeData>
 #include <QTimer>
 
 SpectacleCore::SpectacleCore(StartMode startMode, ImageGrabber::GrabMode grabMode, QString &saveFileName,
                qint64 delayMsec, bool notifyOnGrab, QObject *parent) :
     QObject(parent),
     mExportManager(ExportManager::instance()),
     mStartMode(startMode),
     mNotify(notifyOnGrab),
     mImageGrabber(nullptr),
     mMainWindow(nullptr),
     isGuiInited(false)
 {
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
     KConfigGroup guiConfig(config, "GuiConfig");
 
     if (!(saveFileName.isEmpty() || saveFileName.isNull())) {
         if (QDir::isRelativePath(saveFileName)) {
             saveFileName = QDir::current().absoluteFilePath(saveFileName);
         }
         setFilename(saveFileName);
     }
 
     // We might be using the XCB platform (with Xwayland) in a wayland session,
     // but the X11 grabber won't work in that case. So force the Wayland grabber
     // in Wayland sessions.
     if (KWindowSystem::isPlatformWayland() || qstrcmp(qgetenv("XDG_SESSION_TYPE"), "wayland") == 0) {
         mImageGrabber = new KWinWaylandImageGrabber;
     }
 #ifdef XCB_FOUND
-    if (!mImageGrabber && KWindowSystem::isPlatformX11()) {
+    else if (KWindowSystem::isPlatformX11()) {
         mImageGrabber = new X11ImageGrabber;
     }
 #endif
 
-    if (!mImageGrabber) {
+    else {
         mImageGrabber = new DummyImageGrabber;
     }
 
     setGrabMode(grabMode);
     mImageGrabber->setCapturePointer(guiConfig.readEntry("includePointer", true));
     mImageGrabber->setCaptureDecorations(guiConfig.readEntry("includeDecorations", true));
 
     if ((!(mImageGrabber->onClickGrabSupported())) && (delayMsec < 0)) {
         delayMsec = 0;
     }
 
     connect(mExportManager, &ExportManager::errorMessage, this, &SpectacleCore::showErrorMessage);
     connect(this, &SpectacleCore::errorMessage, this, &SpectacleCore::showErrorMessage);
     connect(mImageGrabber, &ImageGrabber::pixmapChanged, this, &SpectacleCore::screenshotUpdated);
     connect(mImageGrabber, &ImageGrabber::windowTitleChanged, mExportManager, &ExportManager::setWindowTitle);
     connect(mImageGrabber, &ImageGrabber::imageGrabFailed, this, &SpectacleCore::screenshotFailed);
     connect(mExportManager, &ExportManager::imageSaved, this, &SpectacleCore::doCopyPath);
     connect(mExportManager, &ExportManager::forceNotify, this, &SpectacleCore::doNotify);
 
     switch (startMode) {
     case DBusMode:
         break;
     case BackgroundMode: {
             int msec = (KWindowSystem::compositingActive() ? 200 : 50) + delayMsec;
             QTimer::singleShot(msec, mImageGrabber, &ImageGrabber::doImageGrab);
         }
         break;
     case GuiMode:
         initGui();
         break;
     }
 }
 
 SpectacleCore::~SpectacleCore()
 {
     if (mMainWindow) {
         delete mMainWindow;
     }
+    delete mImageGrabber;
 }
 
 // Q_PROPERTY stuff
 
 QString SpectacleCore::filename() const
 {
     return mFileNameString;
 }
 
 void SpectacleCore::setFilename(const QString &filename)
 {
     mFileNameString = filename;
     mFileNameUrl = QUrl::fromUserInput(filename);
 }
 
 ImageGrabber::GrabMode SpectacleCore::grabMode() const
 {
     return mImageGrabber->grabMode();
 }
 
 void SpectacleCore::setGrabMode(const ImageGrabber::GrabMode &grabMode)
 {
     mImageGrabber->setGrabMode(grabMode);
     mExportManager->setGrabMode(grabMode);
 }
 
 // Slots
 
 void SpectacleCore::dbusStartAgent()
 {
     qApp->setQuitOnLastWindowClosed(true);
     if (!(mStartMode == GuiMode)) {
         mStartMode = GuiMode;
         return initGui();
     }
 }
 
 void SpectacleCore::takeNewScreenshot(const ImageGrabber::GrabMode &mode,
                                const int &timeout, const bool &includePointer, const bool &includeDecorations)
 {
     setGrabMode(mode);
     mImageGrabber->setCapturePointer(includePointer);
     mImageGrabber->setCaptureDecorations(includeDecorations);
 
     if (timeout < 0) {
         mImageGrabber->doOnClickGrab();
         return;
     }
 
     // when compositing is enabled, we need to give it enough time for the window
     // to disappear and all the effects are complete before we take the shot. there's
     // no way of knowing how long the disappearing effects take, but as per default
     // settings (and unless the user has set an extremely slow effect), 200
     // milliseconds is a good amount of wait time.
 
     const int msec = KWindowSystem::compositingActive() ? 200 : 50;
     QTimer::singleShot(timeout + msec, mImageGrabber, &ImageGrabber::doImageGrab);
 }
 
 void SpectacleCore::showErrorMessage(const QString &errString)
 {
     qDebug() << "ERROR: " << errString;
 
     if (mStartMode == GuiMode) {
         KMessageBox::error(0, errString);
     }
 }
 
 void SpectacleCore::screenshotUpdated(const QPixmap &pixmap)
 {
     mExportManager->setPixmap(pixmap);
 
     switch (mStartMode) {
     case BackgroundMode:
     case DBusMode:
         {
             if (mNotify) {
                 connect(mExportManager, &ExportManager::imageSaved, this, &SpectacleCore::doNotify);
             }
 
             QUrl savePath = (mStartMode == BackgroundMode && mFileNameUrl.isValid() && mFileNameUrl.isLocalFile()) ?
                     mFileNameUrl : QUrl();
             mExportManager->doSave(savePath);
 
             // if we notify, we emit allDone only if the user either dismissed the notification or pressed
             // the "Open" button, otherwise the app closes before it can react to it.
             if (!mNotify) {
                 emit allDone();
             }
         }
         break;
     case GuiMode:
         mMainWindow->setScreenshotAndShow(pixmap);
     }
 }
 
 void SpectacleCore::screenshotFailed()
 {
     switch (mStartMode) {
     case BackgroundMode:
         showErrorMessage(i18n("Screenshot capture canceled or failed"));
         emit allDone();
         return;
     case DBusMode:
         emit grabFailed();
         emit allDone();
         return;
     case GuiMode:
         mMainWindow->show();
     }
 }
 
 void SpectacleCore::doNotify(const QUrl &savedAt)
 {
     KNotification *notify = new KNotification(QStringLiteral("newScreenshotSaved"));
 
     switch(mImageGrabber->grabMode()) {
     case ImageGrabber::GrabMode::FullScreen:
         notify->setTitle(i18nc("The entire screen area was captured, heading", "Full Screen Captured"));
         break;
     case ImageGrabber::GrabMode::CurrentScreen:
         notify->setTitle(i18nc("The current screen was captured, heading", "Current Screen Captured"));
         break;
     case ImageGrabber::GrabMode::ActiveWindow:
         notify->setTitle(i18nc("The active window was captured, heading", "Active Window Captured"));
         break;
     case ImageGrabber::GrabMode::WindowUnderCursor:
         notify->setTitle(i18nc("The window under the mouse was captured, heading", "Window Under Cursor Captured"));
         break;
     case ImageGrabber::GrabMode::RectangularRegion:
         notify->setTitle(i18nc("A rectangular region was captured, heading", "Rectangular Region Captured"));
         break;
     default:
         break;
     }
 
     const QString &path = savedAt.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path();
 
     // a speaking message is prettier than a URL, special case for the default pictures location
     if (path == QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)) {
         notify->setText(i18nc("Placeholder is filename", "A screenshot was saved as '%1' to your Pictures folder.", savedAt.fileName()));
     } else {
         notify->setText(i18n("A screenshot was saved as '%1' to '%2'.", savedAt.fileName(), path));
     }
 
     notify->setActions({i18nc("Open the screenshot we just saved", "Open")});
     notify->setUrls({savedAt});
 
     connect(notify, &KNotification::action1Activated, this, [this, savedAt] {
         new KRun(savedAt, nullptr);
         QTimer::singleShot(250, this, &SpectacleCore::allDone);
     });
     connect(notify, &QObject::destroyed, this, &SpectacleCore::allDone);
 
     notify->sendEvent();
 }
 
 void SpectacleCore::doCopyPath(const QUrl &savedAt)
 {
     if (SpectacleConfig::instance()->copySaveLocationToClipboard()) {
         qApp->clipboard()->setText(savedAt.toLocalFile());
     }
 }
 
 void SpectacleCore::doStartDragAndDrop()
 {
     QUrl tempFile = mExportManager->tempSave();
     if (!tempFile.isValid()) {
         return;
     }
 
     QMimeData *mimeData = new QMimeData;
     mimeData->setUrls(QList<QUrl> { tempFile });
     mimeData->setData(QStringLiteral("application/x-kde-suggestedfilename"), QFile::encodeName(tempFile.fileName()));
 
     QDrag *dragHandler = new QDrag(this);
     dragHandler->setMimeData(mimeData);
     dragHandler->setPixmap(mExportManager->pixmap().scaled(256, 256, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation));
     dragHandler->exec(Qt::CopyAction);
 }
 
 // Private
 
 void SpectacleCore::initGui()
 {
     if (!isGuiInited) {
         mMainWindow = new KSMainWindow(mImageGrabber->onClickGrabSupported());
 
         connect(mMainWindow, &KSMainWindow::newScreenshotRequest, this, &SpectacleCore::takeNewScreenshot);
         connect(mMainWindow, &KSMainWindow::dragAndDropRequest, this, &SpectacleCore::doStartDragAndDrop);
 
         isGuiInited = true;
         QMetaObject::invokeMethod(mImageGrabber, "doImageGrab", Qt::QueuedConnection);
     }
 }