path: root/user/screengrab/revert-kwindowsystem-bump.patch

diff '--color=auto' -Nurd screengrab-2.7.0/CMakeLists.txt screengrab-2.7.0.new/CMakeLists.txt
--- screengrab-2.7.0/CMakeLists.txt	2023-11-05 04:30:13.000000000 -0800
+++ screengrab-2.7.0.new/CMakeLists.txt	2023-11-26 01:15:30.572898382 -0800
@@ -15,7 +15,7 @@
 option(UPDATE_TRANSLATIONS "Update source translation translations/*.ts files" OFF)
 
 # Minimum Versions
-set(KF5_MINIMUM_VERSION "5.101.0")
+set(KF5_MINIMUM_VERSION "5.36.0")
 set(QT_MINIMUM_VERSION "5.15.0")
 set(QTXDG_MINIMUM_VERSION "3.12.0")
 
diff '--color=auto' -Nurd screengrab-2.7.0/CMakeLists.txt.orig screengrab-2.7.0.new/CMakeLists.txt.orig
--- screengrab-2.7.0/CMakeLists.txt.orig	1969-12-31 16:00:00.000000000 -0800
+++ screengrab-2.7.0.new/CMakeLists.txt.orig	2023-11-26 01:13:58.403649484 -0800
@@ -0,0 +1,224 @@
+cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
+# CMP0000: Call the cmake_minimum_required() command at the beginning of the top-level
+# CMakeLists.txt file even before calling the project() command.
+# The cmake_minimum_required(VERSION) command implicitly invokes the cmake_policy(VERSION)
+# command to specify that the current project code is written for the given range of CMake
+# versions.
+project(screengrab)
+
+include(GNUInstallDirs)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# options
+option(SG_DBUS_NOTIFY "Enable D-Bus notifications" ON)
+option(SG_EXT_EDIT "Enable ability to edit screenshots in external editor" ON)
+option(UPDATE_TRANSLATIONS "Update source translation translations/*.ts files" OFF)
+
+# Minimum Versions
+set(KF5_MINIMUM_VERSION "5.101.0")
+set(QT_MINIMUM_VERSION "5.15.0")
+set(QTXDG_MINIMUM_VERSION "3.12.0")
+
+find_package(Qt5LinguistTools  ${QT_MINIMUM_VERSION} REQUIRED)
+find_package(Qt5Network ${QT_MINIMUM_VERSION} REQUIRED)
+find_package(Qt5Widgets ${QT_MINIMUM_VERSION} REQUIRED)
+find_package(Qt5X11Extras ${QT_MINIMUM_VERSION} REQUIRED)
+find_package(KF5WindowSystem ${KF5_MINIMUM_VERSION} REQUIRED)
+
+# right now we declare it as required
+find_package(X11 REQUIRED)
+set(HAVE_X11 1)
+
+find_package(
+    XCB REQUIRED MODULE COMPONENTS
+        XCB
+        SHAPE
+        XFIXES
+)
+
+find_package(
+    X11_XCB REQUIRED MODULE
+)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+set(SCREENGRAB_VERSION "2.7.0")
+
+if (DEV_VERSION)
+    set(VERSION "${SCREENGRAB_VERSION}-dev (${DEV_VERSION})")
+else()
+    set(VERSION ${SCREENGRAB_VERSION})
+endif()
+
+add_definitions(
+    -DVERSION="${VERSION}"
+    -DQT_NO_FOREACH
+)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
+message(STATUS "Install prefix: " ${CMAKE_INSTALL_PREFIX})
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Woverloaded-virtual -Wall -Wextra")
+
+# Although the names, LXQtTranslateTs and LXQtTranslateDesktop, they don't
+#   bring any dependency on lxqt.
+include(LXQtTranslateTs)
+include(LXQtTranslateDesktop)
+include(Qt5TranslationLoader)
+
+if(SG_EXT_EDIT)
+    add_definitions( -DSG_EXT_EDIT="1")
+    find_package(Qt5Xdg ${QTXDG_MINIMUM_VERSION} REQUIRED)
+endif()
+
+if(SG_DBUS_NOTIFY)
+    find_package(Qt5DBus ${QT_MINIMUM_VERSION} REQUIRED)
+    add_definitions( -DSG_DBUS_NOTIFY="1")
+endif()
+
+message(STATUS "Editing screenshots in external editor support: " ${SG_EXT_EDIT})
+message(STATUS "Enable D-Bus notifications: " ${SG_DBUS_NOTIFY})
+message(STATUS "Use system Qxt Library: " ${SG_USE_SYSTEM_QXT})
+message(STATUS "Update source translation translations/*.ts files: " ${UPDATE_TRANSLATIONS})
+
+# docs
+# CMAKE_INSTALL_FULL_DOCDIR = CMAKE_INSTALL_PREFIX/CMAKE_INSTALL_DATADIR/doc/PROJECT_NAME
+message(STATUS "Documentation directory: " ${CMAKE_INSTALL_FULL_DOCDIR})
+add_definitions(-DSG_DOCDIR="${CMAKE_INSTALL_FULL_DOCDIR}")
+
+# app icon path
+add_definitions(-DSG_ICONPATH="${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATADIR}/icons/hicolor/scalable/apps/screengrab.svg")
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src")
+add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/src/common/qkeysequencewidget")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/common/qkeysequencewidget/src")
+
+if (SG_EXT_EDIT)
+    include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/modules/extedit")
+    add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/src/modules/extedit")
+endif()
+
+set(SCREENGRAB_SRC
+    src/core/main.cpp
+    src/core/singleapp.cpp
+    src/core/core.cpp
+    src/core/config.cpp
+    src/core/regionselect.cpp
+    src/core/shortcutmanager.cpp
+    src/core/modulemanager.cpp
+    src/core/ui/configwidget.cpp
+    src/core/ui/about.cpp
+    src/core/ui/mainwindow.cpp
+)
+
+if(SG_DBUS_NOTIFY)
+    set(SCREENGRAB_SRC ${SCREENGRAB_SRC} src/core/dbusnotifier.cpp)
+endif()
+
+if(X11_FOUND)
+    set(SCREENGRAB_SRC ${SCREENGRAB_SRC} src/core/x11utils.cpp)
+endif()
+
+set(SCREENGRAB_HDR
+    src/core/singleapp.h
+)
+
+set(SCREENGRAB_UI
+    src/core/ui/configwidget.ui
+    src/core/ui/aboutwidget.ui
+    src/core/ui/mainwindow.ui
+)
+
+# Qt resource file
+set(SCREENGRAB_QRC screengrab.qrc)
+qt5_add_resources(QRC_SOURCES ${SCREENGRAB_QRC})
+
+message(STATUS "Generating localize ...")
+
+set(SCREENGRAB_CONFIG_FILES
+    screengrab.conf
+)
+
+set(SCREENGRAB_DESKTOP_FILES_IN
+    screengrab.desktop.in
+)
+
+lxqt_translate_ts(SCREENGRAB_QMS
+    USE_QT5 TRUE
+    UPDATE_TRANSLATIONS ${UPDATE_TRANSLATIONS}
+    SOURCES
+        ${SCREENGRAB_SRC}
+        ${SCREENGRAB_UI}
+    INSTALL_DIR "${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/translations"
+)
+
+lxqt_translate_desktop(SCREENGRAB_DESKTOP_FILES
+    SOURCES ${SCREENGRAB_DESKTOP_FILES_IN}
+    USE_YAML
+)
+
+qt5_translation_loader(SCREENGRAB_QM_LOADER
+    "${CMAKE_INSTALL_FULL_DATADIR}/${PROJECT_NAME}/translations"
+    ${PROJECT_NAME}
+)
+
+# generating executable
+add_executable(screengrab
+    ${SCREENGRAB_SRC}
+    ${SCREENGRAB_UI_H}
+    ${QRC_SOURCES}
+    ${SCREENGRAB_QMS}
+    ${SCREENGRAB_DESKTOP_FILES}
+    ${SCREENGRAB_QM_LOADER}
+)
+
+if(SG_EXT_EDIT)
+    target_link_libraries(screengrab extedit)
+endif()
+
+if(SG_DBUS_NOTIFY)
+    target_link_libraries(screengrab Qt5::DBus)
+endif()
+
+if (X11_XCB_FOUND)
+    add_definitions( -DX11_XCB_FOUND="1")
+    target_link_libraries(screengrab ${X11_XCB_LIBRARIES})
+endif()
+
+if (XCB_XCB_FOUND)
+    add_definitions( -DXCB_XCB_FOUND="1")
+    target_link_libraries(screengrab ${XCB_XCB_LIBRARY})
+endif()
+
+if (XCB_SHAPE_FOUND)
+    add_definitions( -DXCB_SHAPE_FOUND="1")
+    target_link_libraries(screengrab ${XCB_SHAPE_LIBRARY})
+endif()
+
+if (XCB_XFIXES_FOUND)
+    add_definitions( -DXCB_XFOXES_FOUND="1")
+    target_link_libraries(screengrab ${XCB_XFIXES_LIBRARY})
+endif()
+
+# Link with Network and X11Extras. See pull#86. TODO: Should be optional when upload module is needed.
+target_link_libraries(screengrab qkeysequencewidget Qt5::Widgets KF5::WindowSystem Qt5::X11Extras Qt5::Network ${X11_LIBRARIES})
+
+# installing
+install(TARGETS screengrab RUNTIME DESTINATION bin)
+# install html docs
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/docs/html" DESTINATION "${CMAKE_INSTALL_FULL_DOCDIR}")
+# install config files
+install(FILES ${SCREENGRAB_CONFIG_FILES} DESTINATION ${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME})
+# install desktop files
+install(FILES ${SCREENGRAB_DESKTOP_FILES} DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+# install pixmap
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/img/screengrab.svg" DESTINATION "${CMAKE_INSTALL_DATADIR}/icons/hicolor/scalable/apps")
+install(FILES screengrab.metainfo.xml
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/metainfo
+)
diff '--color=auto' -Nurd screengrab-2.7.0/src/core/core.cpp screengrab-2.7.0.new/src/core/core.cpp
--- screengrab-2.7.0/src/core/core.cpp	2023-11-05 04:30:13.000000000 -0800
+++ screengrab-2.7.0.new/src/core/core.cpp	2023-11-26 01:15:31.602889989 -0800
@@ -32,8 +32,7 @@
 #include <XdgMimeApps>
 #include <qt5xdg/XdgDesktopFile>
 
-#include <KWindowSystem/KWindowSystem>
-#include <KWindowSystem/KX11Extras>
+#include <KF5/KWindowSystem/KWindowSystem>
 #include <xcb/xfixes.h>
 
 #ifdef X11_XCB_FOUND
@@ -269,15 +268,15 @@
     if (screen == nullptr)
         screen = QGuiApplication::screens().at(0);
 
-    WId wnd = KX11Extras::activeWindow();
+    WId wnd = KWindowSystem::activeWindow();
 
     // this window screenshot will be invalid
     // if there's no active window or the active window is ours
-    bool invalid(!wnd || !KX11Extras::hasWId(wnd) || (_wnd && _wnd->winId() == wnd));
+    bool invalid(!wnd || !KWindowSystem::hasWId(wnd) || (_wnd && _wnd->winId() == wnd));
     if (!invalid)
     { // or if it isn't on the current desktop
         KWindowInfo info(wnd, NET::WMDesktop);
-        invalid = info.valid() && !info.isOnDesktop(KX11Extras::currentDesktop());
+        invalid = info.valid() && !info.isOnDesktop(KWindowSystem::currentDesktop());
         if (!invalid)
         { // or if it is a desktop or panel/dock
             info = KWindowInfo(wnd, NET::WMWindowType);
diff '--color=auto' -Nurd screengrab-2.7.0/src/core/core.cpp.orig screengrab-2.7.0.new/src/core/core.cpp.orig
--- screengrab-2.7.0/src/core/core.cpp.orig	1969-12-31 16:00:00.000000000 -0800
+++ screengrab-2.7.0.new/src/core/core.cpp.orig	2023-11-26 01:13:58.413649402 -0800
@@ -0,0 +1,623 @@
+/***************************************************************************
+ *   Copyright (C) 2009 - 2013 by Artem 'DOOMer' Galichkin                 *
+ *   doomer3d@gmail.com                                                    *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ ***************************************************************************/
+
+#include <QMutex>
+#include <QWaitCondition>
+#include <QApplication>
+#include <QScreen>
+#include <QChar>
+#include <QBuffer>
+#include <QFile>
+#include <QDir>
+#include <QUuid>
+#include <QMimeDatabase>
+
+#include <QDebug>
+
+#include <XdgMimeApps>
+#include <qt5xdg/XdgDesktopFile>
+
+#include <KWindowSystem/KWindowSystem>
+#include <KWindowSystem/KX11Extras>
+#include <xcb/xfixes.h>
+
+#ifdef X11_XCB_FOUND
+#include "x11utils.h"
+#endif
+
+#include "core/core.h"
+
+#ifdef SG_DBUS_NOTIFY
+#include "dbusnotifier.h"
+#endif
+
+Core* Core::corePtr = nullptr;
+
+Core::Core()
+{
+    qRegisterMetaType<StateNotifyMessage>("StateNotifyMessage");
+
+    _conf = Config::instance();
+    _conf->loadSettings();
+    _lastSelectedArea = _conf->getLastSelection();
+
+    _pixelMap = new QPixmap;
+    _selector = nullptr;
+    _firstScreen = true;
+
+    _cmdLine.setApplicationDescription(QStringLiteral("ScreenGrab ") + tr("is a crossplatform application for fast creating screenshots of your desktop."));
+    _cmdLine.addHelpOption();
+    _cmdLine.addVersionOption();
+
+    QCommandLineOption optFullScreen(QStringList() << QStringLiteral("f") << QStringLiteral("fullscreen"), tr("Take a fullscreen screenshot"));
+    _cmdLine.addOption(optFullScreen);
+    _screenTypeOpts.append(optFullScreen);
+
+    QCommandLineOption optActiveWnd(QStringList() << QStringLiteral("a") << QStringLiteral("active"), tr("Take a screenshot of the active window"));
+    _cmdLine.addOption(optActiveWnd);
+    _screenTypeOpts.append(optActiveWnd);
+
+    QCommandLineOption optSelectedRect(QStringList() << QStringLiteral("r") << QStringLiteral("region"), tr("Take a screenshot of a selection of the screen"));
+    _cmdLine.addOption(optSelectedRect);
+    _screenTypeOpts.append(optSelectedRect);
+
+    QCommandLineOption optRunMinimized(QStringList() << QStringLiteral("m") << QStringLiteral("minimized"), tr("Run the application with a hidden main window"));
+    _cmdLine.addOption(optRunMinimized);
+
+    sleep(250);
+
+    _wnd = nullptr;
+}
+
+Core::Core(const Core& ): QObject()
+{
+}
+
+Core& Core::operator=(const Core &)
+{
+    return *this;
+}
+
+Core* Core::instance()
+{
+    if (!corePtr)
+        corePtr = new Core;
+    return corePtr;
+}
+
+Core::~Core()
+{
+    killTempFile();
+    delete _pixelMap;
+    _conf->killInstance();
+}
+
+void Core::initWindow(const QString& ipcMessage)
+{
+    if (!_wnd) {
+        _wnd = new MainWindow;
+        _wnd->setConfig(_conf);
+        _wnd->updateModulesActions(_modules.generateModulesActions());
+        _wnd->updateModulesMenus(_modules.generateModulesMenus());
+
+        screenShot(true); // first screenshot
+
+        _wnd->resize(_conf->getRestoredWndSize());
+
+        if (_wnd) {
+            if (runAsMinimized())
+            {
+                if (_wnd->isTrayed())
+                    _wnd->windowHideShow();
+                else
+                    _wnd->showMinimized();
+            } else
+                _wnd->show();
+        }
+    } else {
+        _wnd->showWindow(ipcMessage);
+        screenShot();
+    }
+}
+
+void Core::sleep(int msec)
+{
+    QMutex mutex;
+    mutex.lock();
+    QWaitCondition pause;
+    pause.wait(&mutex, msec); // def 240
+    mutex.unlock();
+}
+
+void Core::coreQuit()
+{
+    _conf->setLastSelection(_lastSelectedArea);
+    _conf->saveScreenshotSettings();
+
+    if (_wnd) {
+        _conf->setRestoredWndSize(_wnd->width(), _wnd->height());
+        _conf->saveWndSize();
+        _wnd->close();
+    }
+
+    if (corePtr)
+    {
+        delete corePtr;
+        corePtr = nullptr;
+    }
+
+    qApp->quit();
+}
+
+void Core::setScreen()
+{
+    _wnd->hideToShot();
+
+    // new code experimental
+    if (_conf->getDelay() == 0)
+        QTimer::singleShot(200, this, SLOT(screenShot()));
+    else
+        QTimer::singleShot(1000 * _conf->getDelay(), this, SLOT(screenShot()));
+
+}
+
+void Core::getFullScreenPixmap(QScreen* screen)
+{
+    const auto siblings = screen->virtualSiblings();
+    if (siblings.size() == 1)
+        *_pixelMap = screen->grabWindow(0); // 0 for the entire screen
+    else
+    { // consider all siblings
+        QPixmap pix = QPixmap(screen->virtualSize());
+        pix.fill(Qt::transparent);
+        QPainter painter(&pix);
+        for (const auto& sc : siblings)
+            painter.drawPixmap(sc->geometry().topLeft(), sc->grabWindow(0));
+        *_pixelMap = pix;
+    }
+}
+
+// get screenshot
+void Core::screenShot(bool first)
+{
+    killTempFile(); // remove the old temp file if any
+
+    sleep(400); // delay for hide "fade effect" bug in the KWin with compositing
+    _firstScreen = first;
+
+    // Update the last saving date, if this is the first screenshot
+    if (_firstScreen)
+        _conf->updateLastSaveDate();
+
+    switch(_conf->getDefScreenshotType())
+    {
+    case Core::FullScreen:
+    {
+        auto screen = QGuiApplication::screenAt(QCursor::pos());
+        if (screen == nullptr)
+            screen = QGuiApplication::screens().at(0);
+        getFullScreenPixmap(screen);
+        grabCursor(0, 0);
+
+        checkAutoSave(first);
+        _wnd->updatePixmap(_pixelMap);
+        break;
+    }
+    case Core::Window:
+    {
+        getActiveWindow();
+        checkAutoSave(first);
+        _wnd->updatePixmap(_pixelMap);
+        break;
+    }
+    case Core::Area:
+    {
+        _selector = new RegionSelect(_conf);
+        connect(_selector, &RegionSelect::processDone, this, &Core::regionGrabbed);
+        break;
+    }
+    case Core::PreviousSelection:
+    {
+        _selector = new RegionSelect(_conf, _lastSelectedArea);
+        connect(_selector, &RegionSelect::processDone, this, &Core::regionGrabbed);
+        break;
+    }
+    default:
+        getFullScreenPixmap(QGuiApplication::primaryScreen());
+        break;
+    }
+
+
+
+    _wnd->updatePixmap(_pixelMap);
+    _wnd->restoreFromShot();
+}
+
+void Core::checkAutoSave(bool first)
+{
+    if (_conf->getAutoSave())
+    {
+        // hack
+        if (first)
+        {
+            if (_conf->getAutoSaveFirst())
+                QTimer::singleShot(600, this, SLOT(autoSave()));
+        }
+        else
+            autoSave();
+    }
+}
+
+void Core::getActiveWindow() // called only with window screenshots
+{
+    auto screen = QGuiApplication::screenAt(QCursor::pos());
+    if (screen == nullptr)
+        screen = QGuiApplication::screens().at(0);
+
+    WId wnd = KX11Extras::activeWindow();
+
+    // this window screenshot will be invalid
+    // if there's no active window or the active window is ours
+    bool invalid(!wnd || !KX11Extras::hasWId(wnd) || (_wnd && _wnd->winId() == wnd));
+    if (!invalid)
+    { // or if it isn't on the current desktop
+        KWindowInfo info(wnd, NET::WMDesktop);
+        invalid = info.valid() && !info.isOnDesktop(KX11Extras::currentDesktop());
+        if (!invalid)
+        { // or if it is a desktop or panel/dock
+            info = KWindowInfo(wnd, NET::WMWindowType);
+            QFlags<NET::WindowTypeMask> flags;
+            flags |= NET::DesktopMask;
+            flags |= NET::DockMask;
+            invalid = info.valid() && NET::typeMatchesMask(info.windowType(NET::AllTypesMask), flags);
+        }
+    }
+
+    // also invalid if the window is shaded/invisible
+    KWindowInfo info(wnd, NET::XAWMState | NET::WMFrameExtents);
+    if (!invalid && info.mappingState() != NET::Visible)
+        invalid = true;
+
+    // if this is an invalid screenshot, take a fullscreen shot instead
+    if (invalid)
+    {
+        qWarning() << "Could not take a window screenshot.";
+        *_pixelMap = screen->grabWindow(0);
+        return;
+    }
+
+    // no decorations option is selected
+    if (_conf->getNoDecoration())
+    {
+        *_pixelMap = screen->grabWindow(wnd);
+        return;
+    }
+
+    QRect geometry = info.frameGeometry();
+
+    // WARNING: Until now, "KWindowInfo::frameGeometry" does not consider the screens's
+    // device pixel ratio. So, the frame geometry should be transformed.
+    qreal pixelRatio = screen->devicePixelRatio();
+    geometry.setTopLeft(QPointF(geometry.topLeft() / pixelRatio).toPoint());
+    geometry.setBottomRight(QPointF(geometry.bottomRight() / pixelRatio).toPoint());
+
+    // The offscreen part of the window will appear as a black area in the screenshot.
+    // Until a better method is found, the offscreen area is ignored here.
+    QRect r = screen->virtualGeometry().intersected(geometry);
+
+    // the window positon should be calculated relative to the screen
+    *_pixelMap = screen->grabWindow(0,
+                                    r.x() - screen->geometry().x(),
+                                    r.y() - screen->geometry().y(),
+                                    r.width(),
+                                    r.height());
+
+    grabCursor(geometry.x(), geometry.y());
+}
+
+void Core::grabCursor(int offsetX, int offsetY)
+{
+#ifdef XCB_XFOXES_FOUND
+    if (_conf->getIncludeCursor())
+        X11Utils::compositePointer(offsetX, offsetY, _pixelMap);
+#else
+    Q_UNUSED(offsetx);
+    Q_UNUSED(offsety);
+#endif
+
+
+}
+
+void Core::sendSystemNotify(const StateNotifyMessage& /*notify*/)
+{
+    qDebug() << "Send system notification";
+}
+
+QString Core::getSaveFilePath(const QString &format)
+{
+    QString initPath;
+
+    do
+    {
+        QDir dir(_conf->getSaveDir());
+        const QString filePath = dir.filePath(_conf->getSaveFileName());
+        if (_conf->getDateTimeInFilename())
+            initPath = filePath + QStringLiteral("-") + getDateTimeFileName() + QStringLiteral(".") + format;
+        else
+        {
+            if (_conf->getScrNum() != 0)
+                initPath = filePath + _conf->getScrNumStr() + QStringLiteral(".") + format;
+            else
+                initPath = filePath + QStringLiteral(".") + format;
+        }
+    } while (checkExsistFile(initPath));
+
+    return initPath;
+}
+
+bool Core::checkExsistFile(const QString &path)
+{
+    bool exist = QFile::exists(path);
+
+    if (exist)
+        _conf->increaseScrNum();
+
+    return exist;
+}
+
+QString Core::getDateTimeFileName()
+{
+    QString currentDateTime = QDateTime::currentDateTime().toString(_conf->getDateTimeTpl());
+
+    if (currentDateTime == _conf->getLastSaveDate().toString(_conf->getDateTimeTpl()) && _conf->getScrNum() != 0)
+        currentDateTime += QStringLiteral("-") + _conf->getScrNumStr();
+    else
+        _conf->resetScrNum();
+
+    return currentDateTime;
+}
+
+Config *Core::config()
+{
+    return _conf;
+}
+
+void Core::updatePixmap()
+{
+    if (QFile::exists(_tempFilename))
+    {
+        _pixelMap->load(_tempFilename, "png");
+        _wnd->updatePixmap(_pixelMap);
+    }
+}
+
+QString Core::getTempFilename(const QString& format)
+{
+    if (_tempFilename.isEmpty())
+    {
+        _tempFilename = QUuid::createUuid().toString();
+        int size = _tempFilename.size() - 2;
+        _tempFilename = _tempFilename.mid(1, size).left(8);
+        _tempFilename = QDir::tempPath() + QDir::separator()
+                        + QStringLiteral("screenshot-") + _tempFilename
+                        + QStringLiteral(".") + format;
+    }
+    return _tempFilename;
+}
+
+void Core::killTempFile()
+{
+    if (QFile::exists(_tempFilename))
+        QFile::remove(_tempFilename);
+    _tempFilename.clear();
+}
+
+bool Core::writeScreen(QString& fileName, QString& format, bool tmpScreen)
+{
+    // adding extension format
+    if (!fileName.contains(QStringLiteral(".") + format))
+        fileName.append(QStringLiteral(".") + format);
+
+    // saving temp file
+    if (tmpScreen)
+    {
+        if (!fileName.isEmpty())
+            return _pixelMap->save(fileName, format.toLatin1().constData(), _conf->getImageQuality());
+        else
+            return false;
+    }
+
+    // writing file
+    bool saved = false;
+    if (!fileName.isEmpty())
+    {
+        if (format == QLatin1String("jpg"))
+            saved = _pixelMap->save(fileName,format.toLatin1().constData(), _conf->getImageQuality());
+        else
+            saved = _pixelMap->save(fileName,format.toLatin1().constData(), -1);
+
+        if (saved)
+        {
+            StateNotifyMessage message(tr("Saved"), tr("Saved to ") + fileName);
+
+            message.message = message.message + copyFileNameToCliipboard(fileName);
+            _conf->updateLastSaveDate();
+            sendNotify(message);
+        }
+        else
+            qWarning() << "Error saving file " << fileName;
+    }
+
+    return saved;
+}
+
+QString Core::copyFileNameToCliipboard(QString file)
+{
+    QString retString = QLatin1String("");
+    switch (_conf->getAutoCopyFilenameOnSaving())
+    {
+    case Config::nameToClipboardFile:
+    {
+        file = file.section(QLatin1Char('/'), -1);
+        QApplication::clipboard()->setText(file);
+        retString = QChar(QChar::LineSeparator) + tr("Name of saved file is copied to the clipboard");
+        break;
+    }
+    case Config::nameToClipboardPath:
+    {
+        QApplication::clipboard()->setText(file);
+        retString = QChar(QChar::LineSeparator) + tr("Path to saved file is copied to the clipboard");
+        break;
+    }
+    default:
+        break;
+    }
+    return retString;
+}
+
+void Core::sendNotify(const StateNotifyMessage &message)
+{
+#ifdef SG_DBUS_NOTIFY
+    DBusNotifier *notifier = new DBusNotifier();
+    notifier->displayNotify(message);
+#else
+    _wnd->showTrayMessage(message.header, message.message);
+#endif
+}
+
+void Core::copyScreen()
+{
+    QApplication::clipboard()->setPixmap(*_pixelMap, QClipboard::Clipboard);
+    StateNotifyMessage message(tr("Copied"), tr("Screenshot is copied to clipboard"));
+    sendNotify(message);
+}
+
+void Core::openInExtViewer()
+{
+    if (_conf->getEnableExtView())
+    {
+        QString format = _conf->getSaveFormat();
+        if (format.isEmpty())
+            format = QLatin1String("png");
+
+        QString tempFileName = getTempFilename(format);
+        writeScreen(tempFileName, format, true);
+
+        QMimeDatabase db;
+        XdgMimeApps mimeAppsDb;
+        QMimeType mt = db.mimeTypeForFile(tempFileName);
+        auto app = mimeAppsDb.defaultApp(mt.name());
+        if (app != nullptr)
+        {
+            QString exec;
+            exec = app->expandExecString().first();
+            delete app;
+            QStringList args;
+            args << tempFileName;
+
+            QProcess::startDetached(exec, args);
+        }
+    }
+}
+
+ModuleManager* Core::modules()
+{
+    return &_modules;
+}
+
+void Core::addCmdLineOption(const QCommandLineOption& option)
+{
+    _cmdLine.addOption(option);
+}
+
+bool Core::checkCmdLineOption(const QCommandLineOption& option)
+{
+    return _cmdLine.isSet(option);
+}
+
+bool Core::checkCmdLineOptions(const QStringList &options)
+{
+    for (int i = 0; i < options.count(); ++i)
+        if (_cmdLine.isSet(options.at(i)))
+            return true;
+    return false;
+}
+
+void Core::processCmdLineOpts(const QStringList& arguments)
+{
+    _cmdLine.process(arguments);
+
+    // Check commandline parameters and set screenshot type
+    for (int i=0; i < _screenTypeOpts.count(); ++i)
+        if (_cmdLine.isSet(_screenTypeOpts.at(i)))
+            _conf->setDefScreenshotType(i);
+
+    initWindow();
+}
+
+bool Core::runAsMinimized()
+{
+    return (_cmdLine.isSet(QStringLiteral("minimized")) || _cmdLine.isSet(QStringLiteral("m")));
+}
+
+void Core::autoSave()
+{
+    QString format = _conf->getSaveFormat();
+    QString fileName = getSaveFilePath(format);
+    writeScreen(fileName, format);
+}
+
+QString Core::getVersionPrintable()
+{
+    QString str = QStringLiteral("ScreenGrab: ") + qApp->applicationVersion() + QStringLiteral("\n");
+    str += QStringLiteral("Qt: ") + QString::fromLatin1(qVersion()) + QStringLiteral("\n");
+    return str;
+}
+
+QPixmap* Core::getPixmap()
+{
+    return _pixelMap;
+}
+
+QByteArray Core::getScreenData()
+{
+    QByteArray bytes;
+    QBuffer buffer(&bytes);
+    buffer.open(QIODevice::WriteOnly);
+    _pixelMap->save(&buffer, _conf->getSaveFormat().toLatin1().constData());
+    return bytes;
+}
+
+void Core::regionGrabbed(bool grabbed)
+{
+    if (grabbed)
+    {
+        *_pixelMap = _selector->getSelection();
+
+        int x = _selector->getSelectionStartPos().x();
+        int y = _selector->getSelectionStartPos().y();
+        int w = _pixelMap->rect().width() / _pixelMap->devicePixelRatio();
+        int h = _pixelMap->rect().height() / _pixelMap->devicePixelRatio();
+        _lastSelectedArea.setRect(x, y, w, h);
+
+        checkAutoSave();
+    }
+
+    _wnd->updatePixmap(_pixelMap);
+    _selector->deleteLater();
+}