diff options
Diffstat (limited to 'user/screengrab')
| -rw-r--r-- | user/screengrab/APKBUILD | 11 | ||||
| -rw-r--r-- | user/screengrab/revert-kwindowsystem-bump.patch | 899 |
2 files changed, 906 insertions, 4 deletions
diff --git a/user/screengrab/APKBUILD b/user/screengrab/APKBUILD index 5cb1a06b5..5bf829f5b 100644 --- a/user/screengrab/APKBUILD +++ b/user/screengrab/APKBUILD @@ -1,7 +1,8 @@ # Contributor: Síle Ekaterin Liszka <sheila@vulpine.house> # Maintainer: Síle Ekaterin Liszka <sheila@vulpine.house> pkgname=screengrab -pkgver=2.6.0 +pkgver=2.7.0 +_qtxdg=3.12 pkgrel=0 pkgdesc="Cross-platform Qt-based software for taking screenshots" url="https://github.com/lxqt/screengrab" @@ -10,9 +11,10 @@ options="!check" # No test suite. license="GPL-2.0+" depends="" makedepends="cmake extra-cmake-modules qt5-qtbase-dev qt5-qttools-dev - kwindowsystem-dev libqtxdg-dev>=3.7" + kwindowsystem-dev libqtxdg-dev>=$_qtxdg" subpackages="$pkgname-doc" -source="https://github.com/lxqt/screengrab/releases/download/$pkgver/screengrab-$pkgver.tar.xz" +source="https://github.com/lxqt/screengrab/releases/download/$pkgver/screengrab-$pkgver.tar.xz + revert-kwindowsystem-bump.patch" build() { if [ "$CBUILD" != "$CHOST" ]; then @@ -37,4 +39,5 @@ package() { make DESTDIR="$pkgdir" -C build install } -sha512sums="622bd9fa4548dbbd2b965f2a38446d6b6002786ff2154f9efe86a4970ac464174d1d7e34b8fdc61761f935c97bf4ac8bb2e8ffd166b859cddd3183bd76380b88 screengrab-2.6.0.tar.xz" +sha512sums="0becd8972408a788b56affc9091cdc9ce1fe79160bba27ae29c5f1bf48ed0b73bafdabf3aeaac1eafe646aeaa4e162c0302b7ba1ee4f07785010e50a7d8131a1 screengrab-2.7.0.tar.xz +6f9d5029ea45f22341861d10acabb6134f314cf7841dab6141995c792d25cb5c6055afae3d50e6032dc1c053445e8e6ea1178851d6bdda72009631b5c76c47df revert-kwindowsystem-bump.patch" diff --git a/user/screengrab/revert-kwindowsystem-bump.patch b/user/screengrab/revert-kwindowsystem-bump.patch new file mode 100644 index 000000000..4ce6967ec --- /dev/null +++ b/user/screengrab/revert-kwindowsystem-bump.patch @@ -0,0 +1,899 @@ +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(); ++} |