Differential D9638 Diff 27317 effects/slide/slide.cpp

Changeset View

Standalone View

effects/slide/slide.cpp

1	/********************************************************************	1		/********************************************************************
2	KWin - the KDE window manager	2		KWin - the KDE window manager
3	This file is part of the KDE project.	3		This file is part of the KDE project.
4		4
5	Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org>	5		Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org>
6	Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>	6		Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
		7		Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
7		8
8	This program is free software; you can redistribute it and/or modify	9		This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by	10		it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 2 of the License, or	11		the Free Software Foundation; either version 2 of the License, or
11	(at your option) any later version.	12		(at your option) any later version.
12		13
13	This program is distributed in the hope that it will be useful,	14		This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of	15		but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	16		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.	17		GNU General Public License for more details.
17		18
18	You should have received a copy of the GNU General Public License	19		You should have received a copy of the GNU General Public License
19	along with this program. If not, see <http://www.gnu.org/licenses/>.	20		along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*********************************************************************/	21		*********************************************************************/
21		22
		23		// Qt
		24		#include <QEasingCurve>
		25
		26		// KWayland
		27		#include <KWayland/Server/surface_interface.h>
		28		#include <KWayland/Server/blur_interface.h>
		29		#include <KWayland/Server/contrast_interface.h>
		30
22	#include "slide.h"	31		#include "slide.h"
23	// KConfigSkeleton	32		// KConfigSkeleton
24	#include "slideconfig.h"	33		#include "slideconfig.h"
25		34
26	#include <math.h>
27
28	namespace KWin	35		namespace KWin
29	{	36		{
30		37
31	SlideEffect::SlideEffect()	38		SlideEffect::SlideEffect()
32	: slide(false)
33	{	39		{
34	initConfig<SlideConfig>();	40		initConfig<SlideConfig>();
35	connect(effects, SIGNAL(desktopChanged(int,int,KWin::EffectWindow*)),
36	this, SLOT(slotDesktopChanged(int,int,KWin::EffectWindow*)));
37	connect(effects, &EffectsHandler::windowAdded, this, &SlideEffect::windowAdded);
38	connect(effects, &EffectsHandler::windowDeleted, this, &SlideEffect::windowDeleted);
39	mTimeLine.setCurveShape(QTimeLine::EaseInOutCurve);
40	reconfigure(ReconfigureAll);	41		reconfigure(ReconfigureAll);
		42
		43		QEasingCurve curve(QEasingCurve::OutCubic);
		44		m_timeline.setEasingCurve(curve);
		45
		46		connect(effects, static_cast<void (EffectsHandler::)(int,int,EffectWindow)>(&EffectsHandler::desktopChanged),
		47		this, &SlideEffect::desktopChanged);
		48		connect(effects, &EffectsHandler::windowAdded,
		49		this, &SlideEffect::windowAdded);
		50		connect(effects, &EffectsHandler::windowDeleted,
		51		this, &SlideEffect::windowDeleted);
		52		connect(effects, &EffectsHandler::numberDesktopsChanged,
		53		this, &SlideEffect::numberDesktopsChanged);
		54		connect(effects, &EffectsHandler::numberScreensChanged,
		55		this, &SlideEffect::numberScreensChanged);
41	}	56		}
42		57
43	bool SlideEffect::supported()	58		bool SlideEffect::supported()
44	{	59		{
45	return effects->animationsSupported();	60		return effects->animationsSupported();
46	}	61		}
47		62
48	void SlideEffect::reconfigure(ReconfigureFlags)	63		void SlideEffect::reconfigure(ReconfigureFlags)
49	{	64		{
50	SlideConfig::self()->read();	65		SlideConfig::self()->read();
51		66
52	const auto d = animationTime(	67		const int d = animationTime(
53	SlideConfig::duration() != 0 ? SlideConfig::duration() : 250);	68		SlideConfig::duration() > 0 ? SlideConfig::duration() : 500);
54	mTimeLine.setDuration(d);	69		m_timeline.setDuration(d);
		70
		71		m_hGap = SlideConfig::horizontalGap();
		72		m_vGap = SlideConfig::verticalGap();
		73		m_slideDocks = SlideConfig::slideDocks();
			graesslinUnsubmitted Done So far the interpretation of the config values was: 0 means default settings, anything else means taken from the config. As we have old configs this change would basically disable the animation for everybody with default settings. Given that I suggest to keep the approach as in the old variant. graesslin: So far the interpretation of the config values was: 0 means default settings, anything else…
55	}	74		}
56		75
57	void SlideEffect::prePaintScreen(ScreenPrePaintData& data, int time)	76		void SlideEffect::prePaintScreen(ScreenPrePaintData& data, int time)
58	{	77		{
59	if (slide) {	78		if (m_active) {
60	mTimeLine.setCurrentTime(mTimeLine.currentTime() + time);	79		m_timeline.setCurrentTime(m_timeline.currentTime() + time);
61		80		data.mask \|= PAINT_SCREEN_TRANSFORMED
62	// PAINT_SCREEN_BACKGROUND_FIRST is needed because screen will be actually painted more than once,	81		\| PAINT_SCREEN_BACKGROUND_FIRST;
63	// so with normal screen painting second screen paint would erase parts of the first paint
64	if (mTimeLine.currentValue() != 1)
65	data.mask \|= PAINT_SCREEN_TRANSFORMED \| PAINT_SCREEN_BACKGROUND_FIRST;
66	else {
67	foreach (EffectWindow * w, effects->stackingOrder()) {
68	w->setData(WindowForceBlurRole, QVariant(false));
69	if (m_backgroundContrastForcedBefore.contains(w)) {
70	w->setData(WindowForceBackgroundContrastRole, QVariant());
71	}
72	}
73	m_backgroundContrastForcedBefore.clear();
74	m_movingWindow = nullptr;
75	slide = false;
76	mTimeLine.setCurrentTime(0);
77	effects->setActiveFullScreenEffect(NULL);
78	}
79	}	82		}
		83
80	effects->prePaintScreen(data, time);	84		effects->prePaintScreen(data, time);
81	}	85		}
82		86
83	void SlideEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)	87		/**
		88		* Wrap vector @p diff around grid @p w x @p h.
		89		*
		90		* Wrapping is done in such a way that magnitude of x and y component of vector
		91		* @p diff is less than half of @p w and half of @p h, respectively. This will
		92		* result in having the "shortest" path between two points.
		93		*
		94		* @param diff Vector between two points
		95		* @param w Width of the desktop grid
		96		* @param h Height of the desktop grid
		97		*/
		98		inline void wrapDiff(QPoint& diff, int w, int h)
84	{	99		{
85	if (slide && w != m_movingWindow) {	100		if (diff.x() > w/2) {
86	if (w->isOnAllDesktops()) {	101		diff.setX(diff.x() - w);
87	bool keep_above = w->keepAbove() \|\| w->isDock();	102		} else if (diff.x() < -w/2) {
88	if ((!slide_painting_sticky \|\| keep_above) &&	103		diff.setX(diff.x() + w);
89	(!keep_above \|\| !slide_painting_keep_above)) {
90	w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
91	}	104		}
92	} else if (w->isOnDesktop(painting_desktop)) {	105
93	data.setTransformed();	106		if (diff.y() > h/2) {
94	w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);	107		diff.setY(diff.y() - h);
95	} else {	108		} else if (diff.y() < -h/2) {
96	w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);	109		diff.setY(diff.y() + h);
97	}	110		}
98	}	111		}
99	effects->prePaintWindow(w, data, time);	112
		113		inline QRegion buildClipRegion(QPoint pos, int w, int h)
		114		{
		115		const QSize screenSize = effects->virtualScreenSize();
		116		QRegion r = QRect(pos, screenSize);
		117		if (effects->optionRollOverDesktops()) {
		118		r \|= (r & QRect(-w, 0, w, h)).translated(w, 0); // W
		119		r \|= (r & QRect(w, 0, w, h)).translated(-w, 0); // E
		120
		121		r \|= (r & QRect(0, -h, w, h)).translated(0, h); // N
		122		r \|= (r & QRect(0, h, w, h)).translated(0, -h); // S
		123
		124		r \|= (r & QRect(-w, -h, w, h)).translated(w, h); // NW
		125		r \|= (r & QRect(w, -h, w, h)).translated(-w, h); // NE
		126		r \|= (r & QRect(w, h, w, h)).translated(-w, -h); // SE
		127		r \|= (r & QRect(-w, h, w, h)).translated(w, -h); // SW
		128		}
		129		return r;
100	}	130		}
101		131
102	void SlideEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)	132		void SlideEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
103	{	133		{
104	if (mTimeLine.currentValue() == 0) {	134		if (! m_active) {
105	effects->paintScreen(mask, region, data);	135		effects->paintScreen(mask, region, data);
106	return;	136		return;
107	}	137		}
108		138
109	/*	139		const bool wrap = effects->optionRollOverDesktops();
110	Transformations are done by remembering starting position of the change and the progress	140		const int w = workspaceWidth();
111	of it, the destination is computed from the current desktop. Positions of desktops	141		const int h = workspaceHeight();
112	are done using their topleft corner.	142
113	*/	143		QPoint currentPos = m_startPos + m_diff * m_timeline.currentValue();
114	QPoint destPos = desktopRect(effects->currentDesktop()).topLeft();	144
115	QPoint diffPos = destPos - slide_start_pos;	145		// When "Desktop navigation wraps around" checkbox is checked, currentPos
116	int w = 0;	146		// can be outside the rectangle Rect{x:-w, y:-h, width:2w, height: 2h},
117	int h = 0;	147		// so we map currentPos back to the rect.
118	if (effects->optionRollOverDesktops()) {	148		if (wrap) {
119	w = effects->workspaceWidth();	149		currentPos.setX(currentPos.x() % w);
120	h = effects->workspaceHeight();	150		currentPos.setY(currentPos.y() % h);
121	// wrap around if shorter	151		}
122	if (diffPos.x() > 0 && diffPos.x() > w / 2)	152
123	diffPos.setX(diffPos.x() - w);	153		QVector<int> visibleDesktops;
124	if (diffPos.x() < 0 && abs(diffPos.x()) > w / 2)	154		visibleDesktops.reserve(4); // 4 - maximum number of visible desktops
125	diffPos.setX(diffPos.x() + w);	155		QRegion clipRegion = buildClipRegion(currentPos, w, h);
126	if (diffPos.y() > 0 && diffPos.y() > h / 2)	156		for (int i = 1; i <= effects->numberOfDesktops(); i++) {
127	diffPos.setY(diffPos.y() - h);	157		QRect desktopGeo = desktopGeometry(i);
128	if (diffPos.y() < 0 && abs(diffPos.y()) > h / 2)	158		if (! clipRegion.contains(desktopGeo)) {
129	diffPos.setY(diffPos.y() + h);	159		continue;
		160		}
		161		visibleDesktops << i;
		162		}
		163
		164		// When we enter a virtual desktop that has a window in fullscreen mode,
		165		// stacking order is fine. When we leave a virtual desktop that has
		166		// a window in fullscreen mode, stacking order is no longer valid
		167		// because panels are raised above the fullscreen window. Construct
		168		// a list of fullscreen windows, so we can decide later whether
		169		// docks should be visible on different virtual desktops.
		170		if (m_slideDocks) {
		171		const auto windows = effects->stackingOrder();
		172		m_paintCtx.fullscreenWindows.clear();
		173		for (EffectWindow* w : windows) {
		174		if (! w->isFullScreen()) {
		175		continue;
		176		}
		177		m_paintCtx.fullscreenWindows << w;
130	}	178		}
131	QPoint currentPos = slide_start_pos + mTimeLine.currentValue() * diffPos;
132	QRegion currentRegion = QRect(currentPos, effects->virtualScreenSize());
133	if (effects->optionRollOverDesktops()) {
134	currentRegion \|= (currentRegion & QRect(-w, 0, w, h)).translated(w, 0);
135	currentRegion \|= (currentRegion & QRect(0, -h, w, h)).translated(0, h);
136	currentRegion \|= (currentRegion & QRect(w, 0, w, h)).translated(-w, 0);
137	currentRegion \|= (currentRegion & QRect(0, h, w, h)).translated(0, -h);
138	}
139	bool do_sticky = true;
140	// Assure that the windows that are on all desktops and always on top
141	// are painted with the last screen (e.g. plasma's tooltips). All other windows
142	// that are on all desktops (e.g. the background window) are painted together
143	// with the first screen.
144	int last_desktop = 0;
145	QList<QRect> desktop_rects;
146	for (int desktop = 1;
147	desktop <= effects->numberOfDesktops();
148	++desktop) {
149	QRect rect = desktopRect(desktop);
150	desktop_rects << rect;
151	if (currentRegion.contains(rect)) {
152	last_desktop = desktop;
153	}
154	}
155	for (int desktop = 1;
156	desktop <= effects->numberOfDesktops();
157	++desktop) {
158	QRect rect = desktop_rects[desktop-1];
159	if (currentRegion.contains(rect)) { // part of the desktop needs painting
160	painting_desktop = desktop;
161	slide_painting_sticky = do_sticky;
162	slide_painting_keep_above = (last_desktop == desktop);
163	slide_painting_diff = rect.topLeft() - currentPos;
164	const QSize screenSize = effects->virtualScreenSize();
165	if (effects->optionRollOverDesktops()) {
166	if (slide_painting_diff.x() > screenSize.width())
167	slide_painting_diff.setX(slide_painting_diff.x() - w);
168	if (slide_painting_diff.x() < -screenSize.width())
169	slide_painting_diff.setX(slide_painting_diff.x() + w);
170	if (slide_painting_diff.y() > screenSize.height())
171	slide_painting_diff.setY(slide_painting_diff.y() - h);
172	if (slide_painting_diff.y() < -screenSize.height())
173	slide_painting_diff.setY(slide_painting_diff.y() + h);
174	}	179		}
175	do_sticky = false; // paint on-all-desktop windows only once	180
176	// TODO mask parts that are not visible?	181		// If screen is painted with either PAINT_SCREEN_TRANSFORMED or
		182		// PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS there is no clipping!!
		183		// Push the screen geometry to the paint clipper so everything outside
		184		// of the screen geometry is clipped.
		185		PaintClipper pc(QRegion(effects->virtualScreenGeometry()));
		186
		187		// Screen is painted in several passes. Each painting pass paints
		188		// a single virtual desktop. There could be either 2 or 4 painting
		189		// passes, depending how an user moves between virtual desktops.
		190		// Windows, such as docks or keep-above windows, are painted in
		191		// the last pass so they are above other windows.
		192		const int lastDesktop = visibleDesktops.last();
		193		for (int desktop : qAsConst(visibleDesktops)) {
		194		m_paintCtx.desktop = desktop;
		195		m_paintCtx.lastPass = (lastDesktop == desktop);
		196		m_paintCtx.translation = desktopCoords(desktop) - currentPos;
		197		if (wrap) {
		198		wrapDiff(m_paintCtx.translation, w, h);
		199		}
177	effects->paintScreen(mask, region, data);	200		effects->paintScreen(mask, region, data);
178	}	201		}
179	}	202		}
		203
		204		/**
		205		* Decide whether given window @p w should be transformed/translated.
		206		* @returns @c true if given window @p w should be transformed, otherwise @c false
		207		*/
		208		bool SlideEffect::isTranslated(const EffectWindow* w) const
		209		{
		210		if (w->isOnAllDesktops()) {
		211		if (w->isDock()) {
		212		return m_slideDocks;
		213		}
		214		return w->isDesktop();
		215		} else if (w == m_movingWindow) {
		216		return false;
		217		} else if (w->isOnDesktop(m_paintCtx.desktop)) {
		218		return true;
		219		}
		220		return false;
180	}	221		}
181		222
182	void SlideEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)	223		/**
		224		* Decide whether given window @p w should be painted.
		225		* @returns @c true if given window @p w should be painted, otherwise @c false
		226		*/
		227		bool SlideEffect::isPainted(const EffectWindow* w) const
		228		{
		229		if (w->isOnAllDesktops()) {
		230		if (w->isDock()) {
		231		if (! m_slideDocks) {
		232		return m_paintCtx.lastPass;
		233		}
		234		for (const EffectWindow* fw : qAsConst(m_paintCtx.fullscreenWindows)) {
		235		if (fw->isOnDesktop(m_paintCtx.desktop)
		236		&& fw->screen() == w->screen()) {
		237		return false;
		238		}
		239		}
		240		return true;
		241		}
		242		// In order to make sure that 'keep above' windows are above
		243		// other windows during transition to another virtual desktop,
		244		// they should be painted in the last pass.
		245		if (w->keepAbove()) {
		246		return m_paintCtx.lastPass;
		247		}
		248		return true;
		249		} else if (w == m_movingWindow) {
		250		return m_paintCtx.lastPass;
		251		} else if (w->isOnDesktop(m_paintCtx.desktop)) {
		252		return true;
		253		}
		254		return false;
		255		}
		256
		257		void SlideEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
183	{	258		{
184	if (slide) {	259		if (m_active) {
185	// Do not move a window if it is on all desktops or being moved to another desktop.	260		const bool painted = isPainted(w);
186	if (!w->isOnAllDesktops() && w != m_movingWindow) {	261		if (painted) {
187	data += slide_painting_diff;	262		w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
		263		} else {
		264		w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
		265		}
		266		if (painted && isTranslated(w)) {
		267		data.setTransformed();
		268		}
188	}	269		}
		270		effects->prePaintWindow(w, data, time);
		271		}
		272
		273		void SlideEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
		274		{
		275		if (m_active && isTranslated(w)) {
		276		data += m_paintCtx.translation;
189	}	277		}
190	effects->paintWindow(w, mask, region, data);	278		effects->paintWindow(w, mask, region, data);
191	}	279		}
192		280
193	void SlideEffect::postPaintScreen()	281		void SlideEffect::postPaintScreen()
194	{	282		{
195	if (slide)	283		if (m_active) {
		284		if (m_timeline.currentValue() == 1) {
		285		stop();
		286		}
196	effects->addRepaintFull();	287		effects->addRepaintFull();
		288		}
197	effects->postPaintScreen();	289		effects->postPaintScreen();
198	}	290		}
199		291
200	// Gives a position of the given desktop when all desktops are arranged in a grid	292		/**
201	QRect SlideEffect::desktopRect(int desktop) const	293		* Get position of the top-left corner of desktop @p id within desktop grid with gaps.
		294		* @param id ID of a virtual desktop
		295		*/
		296		QPoint SlideEffect::desktopCoords(int id) const
202	{	297		{
203	QRect rect = effects->virtualScreenGeometry();	298		QPoint c = effects->desktopCoords(id);
204	rect.translate(effects->desktopCoords(desktop));	299		QPoint gridPos = effects->desktopGridCoords(id);
205	return rect;	300		c.setX(c.x() + m_hGap * gridPos.x());
		301		c.setY(c.y() + m_vGap * gridPos.y());
		302		return c;
206	}	303		}
207		304
208	void SlideEffect::slotDesktopChanged(int old, int current, EffectWindow* with)	305		/**
		306		* Get geometry of desktop @p id within desktop grid with gaps.
		307		* @param id ID of a virtual desktop
		308		*/
		309		QRect SlideEffect::desktopGeometry(int id) const
209	{	310		{
210	if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)	311		QRect g = effects->virtualScreenGeometry();
211	return;	312		g.translate(desktopCoords(id));
		313		return g;
		314		}
212		315
213	if (slide) { // old slide still in progress	316		/**
214	QPoint diffPos = desktopRect(old).topLeft() - slide_start_pos;	317		* Get width of a virtual desktop grid.
215	int w = 0;	318		*/
216	int h = 0;	319		int SlideEffect::workspaceWidth() const
217	if (effects->optionRollOverDesktops()) {	320		{
218	w = effects->workspaceWidth();	321		int w = effects->workspaceWidth();
219	h = effects->workspaceHeight();	322		w += m_hGap * effects->desktopGridWidth();
220	// wrap around if shorter	323		return w;
221	if (diffPos.x() > 0 && diffPos.x() > w / 2)
222	diffPos.setX(diffPos.x() - w);
223	if (diffPos.x() < 0 && abs(diffPos.x()) > w / 2)
224	diffPos.setX(diffPos.x() + w);
225	if (diffPos.y() > 0 && diffPos.y() > h / 2)
226	diffPos.setY(diffPos.y() - h);
227	if (diffPos.y() < 0 && abs(diffPos.y()) > h / 2)
228	diffPos.setY(diffPos.y() + h);
229	}	324		}
230	QPoint currentPos = slide_start_pos + mTimeLine.currentValue() * diffPos;	325
231	const QSize screenSize = effects->virtualScreenSize();	326		/**
232	QRegion currentRegion = QRect(currentPos, screenSize);	327		* Get height of a virtual desktop grid.
233	if (effects->optionRollOverDesktops()) {	328		*/
234	currentRegion \|= (currentRegion & QRect(-w, 0, w, h)).translated(w, 0);	329		int SlideEffect::workspaceHeight() const
235	currentRegion \|= (currentRegion & QRect(0, -h, w, h)).translated(0, h);	330		{
236	currentRegion \|= (currentRegion & QRect(w, 0, w, h)).translated(-w, 0);	331		int h = effects->workspaceHeight();
237	currentRegion \|= (currentRegion & QRect(0, h, w, h)).translated(0, -h);	332		h += m_vGap * effects->desktopGridHeight();
238	}	333		return h;
239	QRect rect = desktopRect(current);
240	if (currentRegion.contains(rect)) {
241	// current position is in new current desktop (e.g. quickly changing back),
242	// don't do full progress
243	if (abs(currentPos.x() - rect.x()) > abs(currentPos.y() - rect.y()))
244	mTimeLine.setCurrentTime((1.0 - abs(currentPos.x() - rect.x()) / double(screenSize.width()))*(qreal)mTimeLine.currentValue());
245	else
246	mTimeLine.setCurrentTime((1.0 - abs(currentPos.y() - rect.y()) / double(screenSize.height()))*(qreal)mTimeLine.currentValue());
247	} else // current position is not on current desktop, do full progress
248	mTimeLine.setCurrentTime(0);
249	diffPos = rect.topLeft() - currentPos;
250	if (mTimeLine.currentValue() <= 0) {
251	// Compute starting point for this new move (given current and end positions)
252	slide_start_pos = rect.topLeft() - diffPos * 1 / (1 - mTimeLine.currentValue());
253	} else {
254	// at the end, stop
255	foreach (EffectWindow * w, m_backgroundContrastForcedBefore) {
256	w->setData(WindowForceBackgroundContrastRole, QVariant());
257	}
258	m_backgroundContrastForcedBefore.clear();
259	slide = false;
260	mTimeLine.setCurrentTime(0);
261	effects->setActiveFullScreenEffect(NULL);
262	}	334		}
263	} else {	335
264	if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)	336		bool SlideEffect::shouldForceBlur(const EffectWindow* w) const
		337		{
		338		// While there is an active fullscreen effect, the blur effect
		339		// tends to do nothing, i.e. it doesn't blur behind windows.
		340		// So, we should force the blur effect to blur by setting
		341		// WindowForceBlurRole.
		342
		343		if (w->data(WindowForceBlurRole).toBool()) {
		344		return false;
		345		}
		346
		347		if (w->data(WindowBlurBehindRole).isValid()) {
		348		return true;
		349		}
		350
		351		if (w->decorationHasAlpha() && effects->decorationSupportsBlurBehind()) {
		352		return true;
		353		}
		354
		355		// FIXME: it should be something like this:
		356		// if (surf) {
		357		// return !surf->blur().isNull();
		358		// }
		359		KWayland::Server::SurfaceInterface* surf = w->surface();
		360		if (surf && surf->blur()) {
		361		return true;
		362		}
		363
		364		// TODO: make it X11-specific(check _KDE_NET_WM_BLUR_BEHIND_REGION)
		365		// or delete it in the future
		366		return w->hasAlpha();
		367		}
		368
		369		bool SlideEffect::shouldForceBackgroundContrast(const EffectWindow* w) const
		370		{
		371		// While there is an active fullscreen effect, the background
		372		// contrast effect tends to do nothing, i.e. it doesn't change
		373		// contrast. So, we should force the background contrast effect
		374		// to change contrast by setting WindowForceBackgroundContrastRole.
		375
		376		if (w->data(WindowForceBackgroundContrastRole).toBool()) {
		377		return false;
		378		}
		379
		380		if (w->data(WindowBackgroundContrastRole).isValid()) {
		381		return true;
		382		}
		383
		384		// FIXME: it should be something like this:
		385		// if (surf) {
		386		// return !surf->contrast().isNull();
		387		// }
		388		KWayland::Server::SurfaceInterface* surf = w->surface();
		389		if (surf && surf->contrast()) {
		390		return true;
		391		}
		392
		393		// TODO: make it X11-specific(check _KDE_NET_WM_BACKGROUND_CONTRAST_REGION)
		394		// or delete it in the future
		395		return w->hasAlpha()
		396		&& w->isOnAllDesktops()
		397		&& (w->isDock() \|\| w->keepAbove());
		398		}
		399
		400		bool SlideEffect::shouldElevate(const EffectWindow* w) const
		401		{
		402		// Static docks(i.e. this effect doesn't slide docks) should be elevated
		403		// so they can properly animate themselves when an user enters or leaves
		404		// a virtual desktop with a window in fullscreen mode.
		405		return w->isDock() && !m_slideDocks;
		406		}
		407
		408		void SlideEffect::start(int old, int current, EffectWindow* movingWindow)
		409		{
		410		m_movingWindow = movingWindow;
		411
		412		const bool wrap = effects->optionRollOverDesktops();
		413		const int w = workspaceWidth();
		414		const int h = workspaceHeight();
		415
		416		if (m_active) {
		417		QPoint passed = m_diff * m_timeline.currentValue();
		418		QPoint currentPos = m_startPos + passed;
		419		QPoint delta = desktopCoords(current) - desktopCoords(old);
		420		if (wrap) {
		421		wrapDiff(delta, w, h);
		422		}
		423		m_diff += delta - passed;
		424		m_startPos = currentPos;
		425		m_timeline.setCurrentTime(0);
265	return;	426		return;
266	mTimeLine.setCurrentTime(0);	427		}
267	slide_start_pos = desktopRect(old).topLeft();	428
268	slide = true;	429		const auto windows = effects->stackingOrder();
269	foreach (EffectWindow * w, effects->stackingOrder()) {	430		for (EffectWindow* w : windows) {
		431		if (shouldForceBlur(w)) {
270	w->setData(WindowForceBlurRole, QVariant(true));	432		w->setData(WindowForceBlurRole, QVariant(true));
		433		m_forcedRoles.blur << w;
		434		}
271	if (shouldForceBackgroundContrast(w)) {	435		if (shouldForceBackgroundContrast(w)) {
272	m_backgroundContrastForcedBefore.append(w);
273	w->setData(WindowForceBackgroundContrastRole, QVariant(true));	436		w->setData(WindowForceBackgroundContrastRole, QVariant(true));
		437		m_forcedRoles.backgroundContrast << w;
274	}	438		}
		439		if (shouldElevate(w)) {
		440		effects->setElevatedWindow(w, true);
		441		m_elevatedWindows << w;
275	}	442		}
		443		}
		444
		445		m_diff = desktopCoords(current) - desktopCoords(old);
		446		if (wrap) {
		447		wrapDiff(m_diff, w, h);
		448		}
		449		m_startPos = desktopCoords(old);
		450		m_timeline.setCurrentTime(0);
		451		m_active = true;
276	effects->setActiveFullScreenEffect(this);	452		effects->setActiveFullScreenEffect(this);
		453		effects->addRepaintFull();
		454		}
		455
		456		void SlideEffect::stop()
		457		{
		458		for (EffectWindow* w : m_forcedRoles.blur) {
		459		w->setData(WindowForceBlurRole, QVariant(false));
277	}	460		}
		461		m_forcedRoles.blur.clear();
278		462
279	m_movingWindow = with;	463		for (EffectWindow* w : m_forcedRoles.backgroundContrast) {
		464		w->setData(WindowForceBackgroundContrastRole, QVariant(false));
		465		}
		466		m_forcedRoles.backgroundContrast.clear();
280		467
281	effects->addRepaintFull();	468		for (EffectWindow* w : m_elevatedWindows) {
		469		effects->setElevatedWindow(w, false);
		470		}
		471		m_elevatedWindows.clear();
		472
		473		m_paintCtx.fullscreenWindows.clear();
		474		m_timeline.setCurrentTime(0);
		475		m_movingWindow = nullptr;
		476		m_active = false;
		477		effects->setActiveFullScreenEffect(nullptr);
		478		}
		479
		480		void SlideEffect::desktopChanged(int old, int current, EffectWindow* with)
		481		{
		482		if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this) {
		483		return;
		484		}
		485		start(old, current, with);
282	}	486		}
283		487
284	void SlideEffect::windowAdded(EffectWindow *w)	488		void SlideEffect::windowAdded(EffectWindow *w)
285	{	489		{
286	if (slide && shouldForceBackgroundContrast(w)) {	490		if (! m_active) {
287	m_backgroundContrastForcedBefore.append(w);	491		return;
		492		}
		493		if (shouldForceBlur(w)) {
		494		w->setData(WindowForceBlurRole, QVariant(true));
		495		m_forcedRoles.blur << w;
		496		}
		497		if (shouldForceBackgroundContrast(w)) {
288	w->setData(WindowForceBackgroundContrastRole, QVariant(true));	498		w->setData(WindowForceBackgroundContrastRole, QVariant(true));
		499		m_forcedRoles.backgroundContrast << w;
		500		}
		501		if (shouldElevate(w)) {
		502		effects->setElevatedWindow(w, true);
		503		m_elevatedWindows << w;
289	}	504		}
290	}	505		}
291		506
292	void SlideEffect::windowDeleted(EffectWindow *w)	507		void SlideEffect::windowDeleted(EffectWindow *w)
293	{	508		{
294	m_backgroundContrastForcedBefore.removeAll(w);	509		if (! m_active) {
295	if (w == m_movingWindow)	510		return;
		511		}
		512		if (w == m_movingWindow) {
296	m_movingWindow = nullptr;	513		m_movingWindow = nullptr;
297	}	514		}
		515		m_forcedRoles.blur.removeAll(w);
		516		m_forcedRoles.backgroundContrast.removeAll(w);
		517		m_elevatedWindows.removeAll(w);
		518		m_paintCtx.fullscreenWindows.removeAll(w);
		519		}
298		520
299	bool SlideEffect::shouldForceBackgroundContrast(const EffectWindow *w) const	521		void SlideEffect::numberDesktopsChanged(uint)
300	{	522		{
301	// Windows that are docks, kept above (such as panel popups), and do not	523		if (! m_active) {
302	// have the background contrast explicitely disabled should be forced on	524		return;
303	// during the slide animation	525		}
304	const bool bgWindow = (w->hasAlpha() && w->isOnAllDesktops() && (w->isDock() \|\| w->keepAbove()));	526		stop();
305	return bgWindow && (!w->data(WindowForceBackgroundContrastRole).isValid());
306	}	527		}
307		528
308	bool SlideEffect::isActive() const	529		void SlideEffect::numberScreensChanged()
309	{	530		{
310	return slide;	531		if (! m_active) {
		532		return;
		533		}
		534		stop();
311	}	535		}
312		536
313	} // namespace	537		} // namespace
314