Differential D21042 Diff 57657 src/Platforms/PlatformXcb.cpp

Changeset View

Standalone View

src/Platforms/PlatformXcb.cpp

This file was added.

1		/* This file is part of Spectacle, the KDE screenshot utility
2		* Copyright (C) 2019 Boudhayan Gupta <bgupta@kde.org>
3		*
4		* This program is free software; you can redistribute it and/or modify
5		* it under the terms of the GNU Lesser General Public License as published by
6		* the Free Software Foundation; either version 2 of the License, or
7		* (at your option) any later version.
8		*
9		* This program is distributed in the hope that it will be useful,
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12		* GNU General Public License for more details.
13		*
14		* You should have received a copy of the GNU Lesser General Public License
15		* along with this program; if not, write to the Free Software
16		* Foundation, Inc., 51 Franklin Street, Fifth Floor,
17		* Boston, MA 02110-1301, USA.
18		*
19		* SPDX-License-Identifier: LGPL-2.0-or-later
20		*/
21
22		#include "PlatformXcb.h"
23
24		#include <xcb/xfixes.h>
25		#include <xcb/xcb_cursor.h>
26		#include <xcb/xcb_util.h>
27
28		#include <X11/Xdefs.h>
29		#include <X11/Xatom.h>
30
31		#include <QtMath>
32		#include <QApplication>
33		#include <QStack>
34		#include <QSet>
35		#include <QDBusConnection>
36		#include <QDBusInterface>
37		#include <QDBusConnectionInterface>
38		#include <QAbstractNativeEventFilter>
39		#include <QX11Info>
40		#include <QTimer>
41		#include <QScreen>
42		#include <QPainter>
43		#include <QGraphicsScene>
44		#include <QGraphicsPixmapItem>
45		#include <QGraphicsDropShadowEffect>
46
47		#include <KWindowSystem>
48		#include <KWindowInfo>
49
50		#include <memory>
51
52		/* -- XCB Image Smart Pointer ------------------------------------------------------------------ */
53
54		struct XcbImagePtrDeleter
55		{
56		void operator()(xcb_image_t *theXcbImage) const
57		{
58		if (theXcbImage) {
59		xcb_image_destroy(theXcbImage);
60		}
61		}
62		};
63		using XcbImagePtr = std::unique_ptr<xcb_image_t, XcbImagePtrDeleter>;
64
65		/* -- On Click Native Event Filter ------------------------------------------------------------- */
66
67		class PlatformXcb::OnClickEventFilter: public QAbstractNativeEventFilter
68		{
69		public:
70
71		explicit OnClickEventFilter(PlatformXcb *thePlatformPtr) :
72		mPlatformPtr(thePlatformPtr)
73		{}
74
75		void setCaptureOptions(const Platform::GrabMode &theGrabMode, bool theIncludePointer, bool theIncludeDecorations)
76		{
77		mGrabMode = theGrabMode;
78		mIncludePointer = theIncludePointer;
79		mIncludeDecorations = theIncludeDecorations;
80		}
81
82		bool nativeEventFilter(const QByteArray &theEventType, void theMessage, long /* theResult */) override
83		{
84		if (theEventType == "xcb_generic_event_t") {
85		auto lFirstEvent = static_cast<xcb_generic_event_t *>(theMessage);
86
87		switch (lFirstEvent->response_type & ~0x80) {
88		case XCB_BUTTON_RELEASE: {
89		// uninstall the eventfilter and release the mouse
90		qApp->removeNativeEventFilter(this);
91		xcb_ungrab_pointer(QX11Info::connection(), XCB_TIME_CURRENT_TIME);
92
93		// decide whether to grab or abort. regrab the mouse on mouse-wheel events
94		{
95		auto lSecondEvent = static_cast<xcb_button_release_event_t *>(theMessage);
96		if (lSecondEvent->detail == 1) {
97		QTimer::singleShot(0, [this]() {
98		mPlatformPtr->doGrabNow(mGrabMode, mIncludePointer, mIncludeDecorations);
99		});
100		} else if (lSecondEvent->detail < 4) {
101		emit mPlatformPtr->newScreenshotFailed();
102		} else {
103		QTimer::singleShot(0, [this]() {
104		mPlatformPtr->doGrabOnClick(mGrabMode, mIncludePointer, mIncludeDecorations);
105		});
106		}
107		}
108		return true;
109		}
110		default:
111		return false;
112		}
113		}
114		return false;
115		}
116
117		private:
118
119		PlatformXcb *mPlatformPtr;
120		Platform::GrabMode mGrabMode { GrabMode::AllScreens };
121		bool mIncludePointer { true };
122		bool mIncludeDecorations { true };
123		};
124
125		/* -- General Plumbing ------------------------------------------------------------------------- */
126
127		PlatformXcb::PlatformXcb(QObject *theParent) :
128		Platform(theParent),
129		mNativeEventFilter(new OnClickEventFilter(this))
130		{}
131
132		PlatformXcb::~PlatformXcb()
133		{
134		delete mNativeEventFilter;
135		}
136
137		QString PlatformXcb::platformName() const
138		{
139		return QStringLiteral("Xcb");
140		}
141
142		Platform::GrabModes PlatformXcb::supportedGrabModes() const
143		{
144		Platform::GrabModes lSupportedModes({ GrabMode::AllScreens, GrabMode::ActiveWindow, GrabMode::WindowUnderCursor, GrabMode::TransientWithParent });
145		if (QApplication::screens().count() > 1) {
146		lSupportedModes \|= Platform::GrabMode::CurrentScreen;
147		}
148		return lSupportedModes;
149		}
150
151		Platform::ShutterModes PlatformXcb::supportedShutterModes() const
152		{
153		return { ShutterMode::Immediate \| ShutterMode::OnClick };
154		}
155
156		void PlatformXcb::doGrab(ShutterMode theShutterMode, GrabMode theGrabMode, bool theIncludePointer, bool theIncludeDecorations)
157		{
158		switch(theShutterMode) {
159		case ShutterMode::Immediate:
160		return doGrabNow(theGrabMode, theIncludePointer, theIncludeDecorations);
161		case ShutterMode::OnClick:
162		return doGrabOnClick(theGrabMode, theIncludePointer, theIncludeDecorations);
163		}
164		}
165
166		/* -- Platform Utilities ----------------------------------------------------------------------- */
167
168		void PlatformXcb::updateWindowTitle(xcb_window_t theWindow)
169		{
170		auto lTitle = KWindowSystem::readNameProperty(theWindow, XA_WM_NAME);
171		emit windowTitleChanged(lTitle);
172		}
173
174		bool PlatformXcb::isKWinAvailable()
175		{
176		if (QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.KWin"))) {
177		QDBusInterface lIface(QStringLiteral("org.kde.KWin"), QStringLiteral("/Effects"), QStringLiteral("org.kde.kwin.Effects"));
178		QDBusReply<bool> lReply = lIface.call(QStringLiteral("isEffectLoaded"), QStringLiteral("screenshot"));
179		return lReply.value();
180		}
181		return false;
182		}
183
184		/* -- XCB Utilities ---------------------------------------------------------------------------- */
185
186		QPoint PlatformXcb::getCursorPosition()
187		{
188		// QCursor::pos() is not used because it requires additional calculations.
189		// Its value is the offset to the origin of the current screen is in
190		// device-independent pixels while the origin itself uses native pixels.
191
192		auto lXcbConn = QX11Info::connection();
193		auto lPointerCookie = xcb_query_pointer_unchecked(lXcbConn, QX11Info::appRootWindow());
194		std::unique_ptr<xcb_query_pointer_reply_t> lPointerReply(xcb_query_pointer_reply(lXcbConn, lPointerCookie, nullptr));
195
196		return QPoint(lPointerReply->root_x, lPointerReply->root_y);
197		}
198
199		QRect PlatformXcb::getDrawableGeometry(xcb_drawable_t theDrawable)
200		{
201		auto lXcbConn = QX11Info::connection();
202		auto lGeoCookie = xcb_get_geometry_unchecked(lXcbConn, theDrawable);
203		std::unique_ptr<xcb_get_geometry_reply_t> lGeoReply(xcb_get_geometry_reply(lXcbConn, lGeoCookie, nullptr));
204		if (!lGeoReply) {
205		return QRect();
206		}
207		return QRect(lGeoReply->x, lGeoReply->y, lGeoReply->width, lGeoReply->height);
208		}
209
210		xcb_window_t PlatformXcb::getWindowUnderCursor()
211		{
212		auto lXcbConn = QX11Info::connection();
213		auto lAppWin = QX11Info::appRootWindow();
214
215		const QByteArray lAtomName("WM_STATE");
216		auto lAtomCookie = xcb_intern_atom_unchecked(lXcbConn, 0, lAtomName.length(), lAtomName.constData());
217		auto lPointerCookie = xcb_query_pointer_unchecked(lXcbConn, lAppWin);
218		std::unique_ptr<xcb_intern_atom_reply_t> lAtomReply(xcb_intern_atom_reply(lXcbConn, lAtomCookie, nullptr));
219		std::unique_ptr<xcb_query_pointer_reply_t> lPointerReply(xcb_query_pointer_reply(lXcbConn, lPointerCookie, nullptr));
220
221		if (lAtomReply->atom == XCB_ATOM_NONE) {
222		return QX11Info::appRootWindow();
223		}
224
225		// now start testing
226		QStack<xcb_window_t> lWindowStack;
227		lWindowStack.push(lPointerReply->child);
228
229		while (!lWindowStack.isEmpty()) {
230		lAppWin = lWindowStack.pop();
231
232		// next, check if our window has the WM_STATE property set on
233		// the window. if yes, return the window - we have found it
234		auto lPropCookie = xcb_get_property_unchecked(lXcbConn, 0, lAppWin, lAtomReply->atom, XCB_ATOM_ANY, 0, 0);
235		std::unique_ptr<xcb_get_property_reply_t> lPropReply(xcb_get_property_reply(lXcbConn, lPropCookie, nullptr));
236
237		if (lPropReply->type != XCB_ATOM_NONE) {
238		return lAppWin;
239		}
240
241		// if we're here, this means the window is not the real window
242		// we should start looking at its children
243		auto lTreeCookie = xcb_query_tree_unchecked(lXcbConn, lAppWin);
244		std::unique_ptr<xcb_query_tree_reply_t> lTreeReply(xcb_query_tree_reply(lXcbConn, lTreeCookie, nullptr));
245		auto lWindowChildren = xcb_query_tree_children(lTreeReply.get());
246		auto lWindowChildrenLength = xcb_query_tree_children_length(lTreeReply.get());
247
248		for (int iIdx = lWindowChildrenLength - 1; iIdx >= 0; iIdx--) {
249		lWindowStack.push(lWindowChildren[iIdx]);
250		}
251		}
252
253		// return the window. it has geometry information for a crop
254		return lPointerReply->child;
255		}
256
257		xcb_window_t PlatformXcb::getTransientWindowParent(xcb_window_t theChildWindow, QRect &theWindowRectOut, bool theIncludeDectorations)
258		{
259		NET::Properties lNetProp = theIncludeDectorations ? NET::WMFrameExtents : NET::WMGeometry;
260		KWindowInfo lWindowInfo(theChildWindow, lNetProp, NET::WM2TransientFor);
261
262		// add the current window to the image
263		if (theIncludeDectorations) {
264		theWindowRectOut = lWindowInfo.frameGeometry();
265		} else {
266		theWindowRectOut = lWindowInfo.geometry();
267		}
268		return lWindowInfo.transientFor();
269		}
270
271		/* -- Image Processing Utilities --------------------------------------------------------------- */
272
273		QPixmap PlatformXcb::convertFromNative(xcb_image_t *theXcbImage)
274		{
275		auto lImageFormat = QImage::Format_Invalid;
276		switch (theXcbImage->depth) {
277		case 1:
278		lImageFormat = QImage::Format_MonoLSB;
279		break;
280		case 16:
281		lImageFormat = QImage::Format_RGB16;
282		break;
283		case 24:
284		lImageFormat = QImage::Format_RGB32;
285		break;
286		case 30:
287		lImageFormat = QImage::Format_BGR30;
288		break;
289		case 32:
290		lImageFormat = QImage::Format_ARGB32_Premultiplied;
291		break;
292		default:
293		return QPixmap(); // we don't know
294		}
295
296		// the RGB32 format requires data format 0xffRRGGBB, ensure that this fourth byte really is 0xff
297		if (lImageFormat == QImage::Format_RGB32) {
298		auto lData = reinterpret_cast<quint32 *>(theXcbImage->data);
299		for (size_t iIter = 0; iIter < theXcbImage->width * theXcbImage->height; iIter++) {
300		lData[iIter] \|= 0xff000000;
301		}
302		}
303
304		QImage lImage(theXcbImage->data, theXcbImage->width, theXcbImage->height, lImageFormat);
305		if (lImage.isNull()) {
306		return QPixmap();
307		}
308
309		// work around an abort in QImage::color
310		if (lImage.format() == QImage::Format_MonoLSB) {
311		lImage.setColorCount(2);
312		lImage.setColor(0, QColor(Qt::white).rgb());
313		lImage.setColor(1, QColor(Qt::black).rgb());
314		}
315
316		// the image is ready. Since the backing data from xcbImage could be freed
317		// before the QPixmap goes away, a deep copy is necessary.
318		return QPixmap::fromImage(lImage).copy();
319		}
320
321		QPixmap PlatformXcb::blendCursorImage(QPixmap &thePixmap, const QRect theRect)
322		{
323		// If the cursor position lies outside the area, do not bother drawing a cursor.
324
325		auto lCursorPos = getCursorPosition();
326		if (!theRect.contains(lCursorPos)) {
327		return thePixmap;
328		}
329
330		// now we can get the image and start processing
331		auto lXcbConn = QX11Info::connection();
332
333		auto lCursorCookie = xcb_xfixes_get_cursor_image_unchecked(lXcbConn);
334		std::unique_ptr<xcb_xfixes_get_cursor_image_reply_t> lCursorReply(xcb_xfixes_get_cursor_image_reply(lXcbConn, lCursorCookie, nullptr));
335		if (!lCursorReply) {
336		return thePixmap;
337		}
338
339		// get the image and process it into a qimage
340		auto lPixelData = xcb_xfixes_get_cursor_image_cursor_image(lCursorReply.get());
341		if (!lPixelData) {
342		return thePixmap;
343		}
344		QImage lCursorImage(reinterpret_cast<quint8 *>(lPixelData), lCursorReply->width, lCursorReply->height, QImage::Format_ARGB32_Premultiplied);
345
346		// a small fix for the cursor position for fancier cursors
347		lCursorPos -= QPoint(lCursorReply->xhot, lCursorReply->yhot);
348
349		// now we translate the cursor point to our screen rectangle and do the painting
350		lCursorPos -= QPoint(theRect.x(), theRect.y());
351		QPainter lPainter(&thePixmap);
352		lPainter.drawImage(lCursorPos, lCursorImage);
353		return thePixmap;
354		}
355
356		QPixmap PlatformXcb::postProcessPixmap(QPixmap &thePixmap, QRect theRect, bool theBlendPointer)
357		{
358		if (!(theBlendPointer)) {
359		// note: this may be the null pixmap if an error occurred.
360		return thePixmap;
361		}
362		return blendCursorImage(thePixmap, theRect);
363		}
364
365		/* -- Capture Helpers -------------------------------------------------------------------------- */
366
367		QPixmap PlatformXcb::getPixmapFromDrawable(xcb_drawable_t theXcbDrawable, const QRect &theRect)
368		{
369		auto lXcbConn = QX11Info::connection();
370
371		// proceed to get an image based on the geometry (in device pixels)
372		XcbImagePtr lXcbImage(
373		xcb_image_get(
374		lXcbConn,
375		theXcbDrawable,
376		theRect.x(),
377		theRect.y(),
378		theRect.width(),
379		theRect.height(),
380		~0,
381		XCB_IMAGE_FORMAT_Z_PIXMAP
382		)
383		);
384
385		// too bad, the capture failed.
386		if (!lXcbImage) {
387		return QPixmap();
388		}
389
390		// now process the image
391		auto lPixmap = convertFromNative(lXcbImage.get());
392		return lPixmap;
393		}
394
395		QPixmap PlatformXcb::getToplevelPixmap(QRect theRect, bool theBlendPointer)
396		{
397		auto lRootWindow = QX11Info::appRootWindow();
398
399		// treat a null rect as an alias for capturing fullscreen
400		if (!theRect.isValid()) {
401		theRect = getDrawableGeometry(lRootWindow);
402		} else {
403		QRegion lScreenRegion;
404		for (auto lScreen: QGuiApplication::screens()) {
405		auto lScreenRect = lScreen->geometry();
406
407		// Do not use setSize() here, because QSize::operator*=()
408		// performs qRound() which can result in xcb_image_get() failing
409		const auto lPixelRatio = lScreen->devicePixelRatio();
410		lScreenRect.setHeight(qFloor(lScreenRect.height() * lPixelRatio));
411		lScreenRect.setWidth(qFloor(lScreenRect.width() * lPixelRatio));
412
413		lScreenRegion += lScreenRect;
414		}
415		theRect = (lScreenRegion & theRect).boundingRect();
416		}
417
418		auto lPixmap = getPixmapFromDrawable(lRootWindow, theRect);
419		return postProcessPixmap(lPixmap, theRect, theBlendPointer);
420		}
421
422		QPixmap PlatformXcb::getWindowPixmap(xcb_window_t theWindow, bool theBlendPointer)
423		{
424		auto lXcbConn = QX11Info::connection();
425
426		// first get geometry information for our window
427		auto lGeoCookie = xcb_get_geometry_unchecked(lXcbConn, theWindow);
428		std::unique_ptr<xcb_get_geometry_reply_t> lGeoReply(xcb_get_geometry_reply(lXcbConn, lGeoCookie, nullptr));
429		QRect lWindowRect(lGeoReply->x, lGeoReply->y, lGeoReply->width, lGeoReply->height);
430
431		// then proceed to get an image
432		auto lPixmap = getPixmapFromDrawable(theWindow, lWindowRect);
433
434		// translate window coordinates to global ones.
435		auto lRootGeoCookie = xcb_get_geometry_unchecked(lXcbConn, lGeoReply->root);
436		std::unique_ptr<xcb_get_geometry_reply_t> lRootGeoReply(xcb_get_geometry_reply(lXcbConn, lRootGeoCookie, nullptr));
437		auto lTranslateCookie = xcb_translate_coordinates_unchecked(lXcbConn, theWindow, lGeoReply->root, lRootGeoReply->x, lRootGeoReply->y);
438		std::unique_ptr<xcb_translate_coordinates_reply_t> lTranslateReply(xcb_translate_coordinates_reply(lXcbConn, lTranslateCookie, nullptr));
439
440		// adjust local to global coordinates.
441		lWindowRect.moveRight(lWindowRect.x() + lTranslateReply->dst_x);
442		lWindowRect.moveTop(lWindowRect.y() + lTranslateReply->dst_y);
443
444		// if the window capture failed, try to obtain one from the full screen.
445		if (lPixmap.isNull()) {
446		return getToplevelPixmap(lWindowRect, theBlendPointer);
447		}
448		return postProcessPixmap(lPixmap, lWindowRect, theBlendPointer);
449		}
450
451		void PlatformXcb::handleKWinScreenshotReply(quint64 theDrawable)
452		{
453		// obtain width and height and grab an image (x and y are always zero for pixmaps)
454		auto lDrawable = static_cast<xcb_drawable_t>(theDrawable);
455		auto lRect = getDrawableGeometry(lDrawable);
456		auto lPixmap = getPixmapFromDrawable(lDrawable, lRect);
457
458		if (!lPixmap.isNull()) {
459		emit newScreenshotTaken(lPixmap);
460		return;
461		}
462		emit newScreenshotFailed();
463		}
464
465		/* -- Grabber Methods -------------------------------------------------------------------------- */
466
467		void PlatformXcb::grabAllScreens(bool theIncludePointer)
468		{
469		auto lPixmap = getToplevelPixmap(QRect(), theIncludePointer);
470		emit newScreenshotTaken(lPixmap);
471		}
472
473		void PlatformXcb::grabCurrentScreen(bool theIncludePointer)
474		{
475		auto lCursorPosition = QCursor::pos();
476		for (auto lScreen: QGuiApplication::screens()) {
477		auto lScreenRect = lScreen->geometry();
478		if (!lScreenRect.contains(lCursorPosition)) {
479		continue;
480		}
481
482		// the screen origin is in native pixels, but the size is device-dependent.
483		// convert these also to native pixels.
484		QRect lNativeScreenRect(lScreenRect.topLeft(), lScreenRect.size() * lScreen->devicePixelRatio());
485		auto lPixmap = getToplevelPixmap(lNativeScreenRect, theIncludePointer);
486		emit newScreenshotTaken(lPixmap);
487		return;
488		}
489
490		// no screen found with our cursor, fallback to capturing all screens
491		grabAllScreens(theIncludePointer);
492		}
493
494		void PlatformXcb::grabApplicationWindow(xcb_window_t theWindow, bool theIncludePointer, bool theIncludeDecorations)
495		{
496		// if the user doesn't want decorations captured, we're in luck. This is
497		// the easiest bit
498
499		auto lPixmap = getWindowPixmap(theWindow, theIncludePointer);
500		if (!theIncludeDecorations \|\| theWindow == QX11Info::appRootWindow()) {
501		emit newScreenshotTaken(lPixmap);
502		return;
503		}
504
505		// if the user wants the window decorations, things get a little tricky.
506		// we can't simply get a handle to the window manager frame window and
507		// just grab it, because some compositing window managers (yes, kwin
508		// included) do not render the window onto the frame but keep it in a
509		// separate opengl buffer, so grabbing this window is going to simply
510		// give us a transparent image with the frame and titlebar.
511
512		// all is not lost. what we need to do is grab the image of the entire
513		// desktop, find the geometry of the window including its frame, and
514		// crop the root image accordingly.
515
516		KWindowInfo lWindowInfo(theWindow, NET::WMFrameExtents);
517		if (lWindowInfo.valid()) {
518		auto lFrameGeom = lWindowInfo.frameGeometry();
519		lPixmap = getToplevelPixmap(lFrameGeom, theIncludePointer);
520		}
521
522		// fallback is window without the frame
523		emit newScreenshotTaken(lPixmap);
524		}
525
526		void PlatformXcb::grabActiveWindow(bool theIncludePointer, bool theIncludeDecorations)
527		{
528		auto lActiveWindow = KWindowSystem::activeWindow();
529		updateWindowTitle(lActiveWindow);
530
531		// if KWin is available, use the KWin DBus interfaces
532		if (theIncludeDecorations && isKWinAvailable()) {
533		auto lBus = QDBusConnection::sessionBus();
534		lBus.connect(QStringLiteral("org.kde.KWin"),
535		QStringLiteral("/Screenshot"),
536		QStringLiteral("org.kde.kwin.Screenshot"),
537		QStringLiteral("screenshotCreated"),
538		this, SLOT(handleKWinScreenshotReply(quint64)));
539		QDBusInterface lIface(QStringLiteral("org.kde.KWin"), QStringLiteral("/Screenshot"), QStringLiteral("org.kde.kwin.Screenshot"));
540
541		int lOpMask = 1;
542		if (theIncludePointer) {
543		lOpMask \|= 1 << 1;
544		}
545		lIface.call(QStringLiteral("screenshotForWindow"), static_cast<quint64>(lActiveWindow), lOpMask);
546
547		return;
548		}
549
550		// otherwise, use the native functionality
551		grabApplicationWindow(lActiveWindow, theIncludePointer, theIncludeDecorations);
552		}
553
554		void PlatformXcb::grabWindowUnderCursor(bool theIncludePointer, bool theIncludeDecorations)
555		{
556		auto lWindow = getWindowUnderCursor();
557		updateWindowTitle(lWindow);
558
559		// if KWin is available, use the KWin DBus interfaces
560		if (theIncludeDecorations && isKWinAvailable()) {
561		auto lBus = QDBusConnection::sessionBus();
562		lBus.connect(QStringLiteral("org.kde.KWin"),
563		QStringLiteral("/Screenshot"),
564		QStringLiteral("org.kde.kwin.Screenshot"),
565		QStringLiteral("screenshotCreated"),
566		this, SLOT(handleKWinScreenshotReply(quint64)));
567		QDBusInterface lInterface(QStringLiteral("org.kde.KWin"), QStringLiteral("/Screenshot"), QStringLiteral("org.kde.kwin.Screenshot"));
568
569		int lOpMask = 1;
570		if (theIncludePointer) {
571		lOpMask \|= 1 << 1;
572		}
573		lInterface.call(QStringLiteral("screenshotWindowUnderCursor"), lOpMask);
574
575		return;
576		}
577
578		// otherwise, use the native functionality
579		grabApplicationWindow(lWindow, theIncludePointer, theIncludeDecorations);
580		}
581
582		void PlatformXcb::grabTransientWithParent(bool theIncludePointer, bool theIncludeDecorations)
583		{
584		auto lWindow = getWindowUnderCursor();
585		updateWindowTitle(lWindow);
586
587		// grab the image early
588		auto lPixmap = getToplevelPixmap(QRect(), false);
589
590		// now that we know we have a transient window, let's
591		// find other possible transient windows and the app window itself.
592		QRegion lClipRegion;
593		QSet<xcb_window_t> lTransientWindows;
594		auto lParentWindow = lWindow;
595		const QRect lDesktopRect(0, 0, 1, 1);
596		do {
597		// find parent window and add the window to the visible region
598		auto lWinId = lParentWindow;
599		QRect lWinRect;
600		lParentWindow = getTransientWindowParent(lWinId, lWinRect, theIncludeDecorations);
601		lTransientWindows << lWinId;
602
603		// Don't include the 1x1 pixel sized desktop window in the top left corner that is present
604		// if the window is a QDialog without a parent.
605		// BUG: 376350
606		if (lWinRect != lDesktopRect) {
607		lClipRegion += lWinRect;
608		}
609
610		// Continue walking only if this is a transient window (having a parent)
611		} while (lParentWindow != XCB_WINDOW_NONE && !lTransientWindows.contains(lParentWindow));
612
613
614		// All parents are known now, find other transient children.
615		// Assume that the lowest window is behind everything else, then if a new
616		// transient window is discovered, its children can then also be found.
617		auto lWinList = KWindowSystem::stackingOrder();
618		for (auto lWinId: lWinList) {
619		QRect lWinRect;
620		auto lParentWindow = getTransientWindowParent(lWinId, lWinRect, theIncludeDecorations);
621
622		// if the parent should be displayed, then show the child too
623		if (lTransientWindows.contains(lParentWindow)) {
624		if (!lTransientWindows.contains(lWinId)) {
625		lTransientWindows << lWinId;
626		lClipRegion += lWinRect;
627		}
628		}
629		}
630
631		// we can probably go ahead and generate the image now
632		QImage lImage(lPixmap.size(), QImage::Format_ARGB32);
633		lImage.fill(Qt::transparent);
634
635		QPainter lPainter(&lImage);
636		lPainter.setClipRegion(lClipRegion);
637		lPainter.drawPixmap(0, 0, lPixmap);
638		lPainter.end();
639		lPixmap = QPixmap::fromImage(lImage).copy(lClipRegion.boundingRect());
640
641		// why stop here, when we can render a 20px drop shadow all around it
642		auto lShadowEffect = new QGraphicsDropShadowEffect;
643		lShadowEffect->setOffset(0);
	ngrahamUnsubmitted Not Done JFYI in the future it would be nice to be able to make this (and including the window decoration shadows) optional. See https://bugs.kde.org/show_bug.cgi?id=372408 ngraham: JFYI in the future it would be nice to be able to make this (and including the window…
644		lShadowEffect->setBlurRadius(20);
645
646		auto lPixmapItem = new QGraphicsPixmapItem;
647		lPixmapItem->setPixmap(lPixmap);
648		lPixmapItem->setGraphicsEffect(lShadowEffect);
649
650		QImage lShadowImage(lPixmap.size() + QSize(40, 40), QImage::Format_ARGB32);
651		lShadowImage.fill(Qt::transparent);
652		QPainter lShadowPainter(&lShadowImage);
653
654		QGraphicsScene lGraphicsScene;
655		lGraphicsScene.addItem(lPixmapItem);
656		lGraphicsScene.render(&lShadowPainter, QRectF(), QRectF(-20, -20, lPixmap.width() + 40, lPixmap.height() + 40));
657		lShadowPainter.end();
658
659		// we can finish up now
660		lPixmap = QPixmap::fromImage(lShadowImage);
661		if (theIncludePointer) {
662		auto lTopLeft = lClipRegion.boundingRect().topLeft() - QPoint(20, 20);
663		lPixmap = blendCursorImage(lPixmap, QRect(lTopLeft, QSize(lPixmap.width(), lPixmap.height())));
664		}
665		emit newScreenshotTaken(lPixmap);
666		}
667
668		void PlatformXcb::doGrabNow(const GrabMode &theGrabMode, bool theIncludePointer, bool theIncludeDecorations)
669		{
670		switch(theGrabMode) {
671		case GrabMode::AllScreens:
672		grabAllScreens(theIncludePointer);
673		break;
674		case GrabMode::CurrentScreen:
675		grabCurrentScreen(theIncludePointer);
676		break;
677		case GrabMode::ActiveWindow:
678		grabActiveWindow(theIncludePointer, theIncludeDecorations);
679		break;
680		case GrabMode::WindowUnderCursor:
681		grabWindowUnderCursor(theIncludePointer, theIncludeDecorations);
682		break;
683		case GrabMode::TransientWithParent:
684		grabTransientWithParent(theIncludePointer, theIncludeDecorations);
685		break;
686		case GrabMode::InvalidChoice:
687		emit newScreenshotFailed();
688		}
689		}
690
691		void PlatformXcb::doGrabOnClick(const GrabMode &theGrabMode, bool theIncludePointer, bool theIncludeDecorations)
692		{
693		// get the cursor image
694		xcb_cursor_t lXcbCursor = XCB_CURSOR_NONE;
695		xcb_cursor_context_t *lXcbCursorCtx = nullptr;
696		xcb_screen_t *lXcbAppScreen = xcb_aux_get_screen(QX11Info::connection(), QX11Info::appScreen());
697
698		if (xcb_cursor_context_new(QX11Info::connection(), lXcbAppScreen, &lXcbCursorCtx) >= 0) {
699		QVector<QByteArray> lCursorNames = {
700		QByteArrayLiteral("cross"),
701		QByteArrayLiteral("crosshair"),
702		QByteArrayLiteral("diamond-cross"),
703		QByteArrayLiteral("cross-reverse")
704		};
705
706		for(const auto &lCursorName: lCursorNames) {
707		xcb_cursor_t lCursor = xcb_cursor_load_cursor(lXcbCursorCtx, lCursorName.constData());
708		if (lCursor != XCB_CURSOR_NONE) {
709		lXcbCursor = lCursor;
710		break;
711		}
712		}
713		}
714
715		// grab the cursor
716		xcb_grab_pointer_cookie_t grabPointerCookie = xcb_grab_pointer_unchecked(
717		QX11Info::connection(), // xcb connection
718		0, // deliver events to owner? nope
719		QX11Info::appRootWindow(), // window to grab pointer for (root)
720		XCB_EVENT_MASK_BUTTON_RELEASE, // which events do I want
721		XCB_GRAB_MODE_SYNC, // pointer grab mode
722		XCB_GRAB_MODE_ASYNC, // keyboard grab mode (why is this even here)
723		XCB_NONE, // confine pointer to which window (none)
724		lXcbCursor, // cursor to change to for the duration of grab
725		XCB_TIME_CURRENT_TIME // do this right now
726		);
727		std::unique_ptr<xcb_grab_pointer_reply_t> lGrabPointerReply(xcb_grab_pointer_reply(QX11Info::connection(), grabPointerCookie, nullptr));
728
729		// if the grab failed, take the screenshot right away
730		if (lGrabPointerReply->status != XCB_GRAB_STATUS_SUCCESS) {
731		doGrabNow(theGrabMode, theIncludePointer, theIncludeDecorations);
732		return;
733		}
734
735		// fix things if our pointer grab causes a lockup and install our event filter
736		mNativeEventFilter->setCaptureOptions(theGrabMode, theIncludePointer, theIncludeDecorations);
737		xcb_allow_events(QX11Info::connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);
738		qApp->installNativeEventFilter(mNativeEventFilter);
739
740		// done. clean stuff up
741		xcb_cursor_context_free(lXcbCursorCtx);
742		xcb_free_cursor(QX11Info::connection(), lXcbCursor);
743		}