Differential D9638 Diff 25915 effects/slide/slide.cpp

Changeset View

Standalone View

View Options

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​
5Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org> 5​Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org>
6Copyright (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​
8This program is free software; you can redistribute it and/or modify 9​This program is free software; you can redistribute it and/or modify
9it 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
10the 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​
13This program is distributed in the hope that it will be useful, 14​This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of 15​but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details. 17​GNU General Public License for more details.
17 18​
18You should have received a copy of the GNU General Public License 19​You should have received a copy of the GNU General Public License
19along 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​
22#include "slide.h" 26​#include "slide.h"
23// KConfigSkeleton 27​// KConfigSkeleton
24#include "slideconfig.h" 28​#include "slideconfig.h"
25 29​
26#include <math.h> ​
27 ​
28namespace KWin 30​namespace KWin
29{ 31​{
30 32​
31SlideEffect::SlideEffect() 33​SlideEffect::SlideEffect()
32 : slide(false) ​
33{ 34​{
34 initConfig<SlideConfig>(); 35​ 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); 36​ reconfigure(ReconfigureAll);
37​
38​ QEasingCurve curve(QEasingCurve::OutCubic);
39​ m_timeline.setEasingCurve(curve);
40​
41​ connect(effects, static_cast<void (EffectsHandler::*)(int,int,EffectWindow*)>(&EffectsHandler::desktopChanged),
42​ this, &SlideEffect::desktopChanged);
43​ connect(effects, &EffectsHandler::windowAdded,
44​ this, &SlideEffect::windowAdded);
45​ connect(effects, &EffectsHandler::windowDeleted,
46​ this, &SlideEffect::windowDeleted);
47​ connect(effects, &EffectsHandler::numberDesktopsChanged,
48​ this, &SlideEffect::numberDesktopsChanged);
49​ connect(effects, &EffectsHandler::numberScreensChanged,
50​ this, &SlideEffect::numberScreensChanged);
41} 51​}
42 52​
43bool SlideEffect::supported() 53​bool SlideEffect::supported()
44{ 54​{
45 return effects->animationsSupported(); 55​ return effects->animationsSupported();
46} 56​}
47 57​
48void SlideEffect::reconfigure(ReconfigureFlags) 58​void SlideEffect::reconfigure(ReconfigureFlags)
49{ 59​{
50 SlideConfig::self()->read(); 60​ SlideConfig::self()->read();
51 61​
52 const auto d = animationTime( 62​ const int d = animationTime(
53 SlideConfig::duration() != 0 ? SlideConfig::duration() : 250); 63​ SlideConfig::duration() > 0 ? SlideConfig::duration() : 500);
54 mTimeLine.setDuration(d); 64​ m_timeline.setDuration(d);
65​
66​ m_hGap = SlideConfig::horizontalGap();
67​ m_vGap = SlideConfig::verticalGap();
68​ 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} 69​}
56 70​
57void SlideEffect::prePaintScreen(ScreenPrePaintData& data, int time) 71​void SlideEffect::prePaintScreen(ScreenPrePaintData& data, int time)
58{ 72​{
59 if (slide) { 73​ if (m_active) {
60 mTimeLine.setCurrentTime(mTimeLine.currentTime() + time); 74​ m_timeline.setCurrentTime(m_timeline.currentTime() + time);
61 75​ data.mask |= PAINT_SCREEN_TRANSFORMED
62 // PAINT_SCREEN_BACKGROUND_FIRST is needed because screen will be actually painted more than once, 76​ | 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 } 77​ }
78​
80 effects->prePaintScreen(data, time); 79​ effects->prePaintScreen(data, time);
81} 80​}
82 81​
83void SlideEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) 82​/**
83​ * Wrap vector @p diff around grid @p w x @p h.
84​ *
85​ * Wrapping is done in such a way that magnitude of x and y component of vector
86​ * @p diff is less than half of @p w and half of @p h, respectively. This will
87​ * result in having the "shortest" path between two points.
88​ *
89​ * @param diff Vector between two points
90​ * @param w Width of the desktop grid
91​ * @param h Height of the desktop grid
92​ */
93​inline void wrapDiff(QPoint& diff, int w, int h)
84{ 94​{
85 if (slide && w != m_movingWindow) { 95​ if (diff.x() > w/2) {
86 if (w->isOnAllDesktops()) { 96​ diff.setX(diff.x() - w);
87 bool keep_above = w->keepAbove() || w->isDock(); 97​ } else if (diff.x() < -w/2) {
88 if ((!slide_painting_sticky || keep_above) && 98​ diff.setX(diff.x() + w);
89 (!keep_above || !slide_painting_keep_above)) { ​
90 w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP); ​
91 } 99​ }
92 } else if (w->isOnDesktop(painting_desktop)) { 100​
93 data.setTransformed(); 101​ if (diff.y() > h/2) {
94 w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP); 102​ diff.setY(diff.y() - h);
95 } else { 103​ } else if (diff.y() < -h/2) {
96 w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP); 104​ diff.setY(diff.y() + h);
97 } 105​ }
98 } 106​}
99 effects->prePaintWindow(w, data, time); 107​
108​inline QRegion buildClipRegion(QPoint pos, int w, int h)
109​{
110​ const QSize screenSize = effects->virtualScreenSize();
111​ QRegion r = QRect(pos, screenSize);
112​ if (effects->optionRollOverDesktops()) {
113​ r |= (r & QRect(-w, 0, w, h)).translated(w, 0); // W
114​ r |= (r & QRect(w, 0, w, h)).translated(-w, 0); // E
115​
116​ r |= (r & QRect(0, -h, w, h)).translated(0, h); // N
117​ r |= (r & QRect(0, h, w, h)).translated(0, -h); // S
118​
119​ r |= (r & QRect(-w, -h, w, h)).translated(w, h); // NW
120​ r |= (r & QRect(w, -h, w, h)).translated(-w, h); // NE
121​ r |= (r & QRect(w, h, w, h)).translated(-w, -h); // SE
122​ r |= (r & QRect(-w, h, w, h)).translated(w, -h); // SW
123​ }
124​ return r;
100} 125​}
101 126​
102void SlideEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data) 127​void SlideEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
103{ 128​{
104 if (mTimeLine.currentValue() == 0) { 129​ if (! m_active) {
105 effects->paintScreen(mask, region, data); 130​ effects->paintScreen(mask, region, data);
106 return; 131​ return;
107 } 132​ }
108 133​
109 /* 134​ const bool wrap = effects->optionRollOverDesktops();
110 Transformations are done by remembering starting position of the change and the progress 135​ const int w = workspaceWidth();
111 of it, the destination is computed from the current desktop. Positions of desktops 136​ const int h = workspaceHeight();
112 are done using their topleft corner. 137​
113 */ 138​ QPoint currentPos = m_startPos + m_diff * m_timeline.currentValue();
114 QPoint destPos = desktopRect(effects->currentDesktop()).topLeft(); 139​
115 QPoint diffPos = destPos - slide_start_pos; 140​ // When "Desktop navigation wraps around" checkbox is checked, currentPos
116 int w = 0; 141​ // can be outside the rectangle Rect{x:-w, y:-h, width:2*w, height: 2*h},
117 int h = 0; 142​ // so we map currentPos back to the rect.
118 if (effects->optionRollOverDesktops()) { 143​ if (wrap) {
119 w = effects->workspaceWidth(); 144​ currentPos.setX(currentPos.x() % w);
120 h = effects->workspaceHeight(); 145​ currentPos.setY(currentPos.y() % h);
121 // wrap around if shorter 146​ }
122 if (diffPos.x() > 0 && diffPos.x() > w / 2) 147​
123 diffPos.setX(diffPos.x() - w); 148​ QRegion clipRegion = buildClipRegion(currentPos, w, h);
124 if (diffPos.x() < 0 && abs(diffPos.x()) > w / 2) 149​ QVector<int> visibleDesktops;
125 diffPos.setX(diffPos.x() + w); 150​ for (int i = 1; i <= effects->numberOfDesktops(); i++) {
126 if (diffPos.y() > 0 && diffPos.y() > h / 2) 151​ QRect desktopGeo = desktopGeometry(i);
127 diffPos.setY(diffPos.y() - h); 152​ if (! clipRegion.contains(desktopGeo)) {
128 if (diffPos.y() < 0 && abs(diffPos.y()) > h / 2) 153​ continue;
129 diffPos.setY(diffPos.y() + h); 154​ }
155​ visibleDesktops << i;
156​ }
157​
158​ // When we enter a virtual desktop that has a window in fullscreen mode,
159​ // stacking order is fine. When we leave a virtual desktop that has
160​ // a window in fullscreen mode, stacking order is no longer valid
161​ // because panels are raised above the fullscreen window. Construct
162​ // a list of fullscreen windows, so we can decide later whether
163​ // docks should be visible on different virtual desktops.
164​ const auto windows = effects->stackingOrder();
165​ if (m_slideDocks) {
166​ m_paintCtx.fullscreenWindows.clear();
167​ for (EffectWindow* w : windows) {
168​ if (! w->isFullScreen()) {
169​ continue;
170​ }
171​ m_paintCtx.fullscreenWindows << w;
130 } 172​ }
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 } 173​ }
175 do_sticky = false; // paint on-all-desktop windows only once 174​
176 // TODO mask parts that are not visible? 175​ const int lastDesktop = visibleDesktops.last();
176​ for (int desktop : qAsConst(visibleDesktops)) {
177​ m_paintCtx.desktop = desktop;
178​ m_paintCtx.lastPass = (lastDesktop == desktop);
179​ m_paintCtx.translation = desktopCoords(desktop) - currentPos;
180​ if (wrap) {
181​ wrapDiff(m_paintCtx.translation, w, h);
182​ }
177 effects->paintScreen(mask, region, data); 183​ effects->paintScreen(mask, region, data);
178 } 184​ }
185​
186​ if (m_slideDocks) {
187​ return;
188​ }
189​
190​ for (EffectWindow* w : windows) {
191​ if (! w->isDock()) {
192​ continue;
193​ }
194​ WindowPaintData dockData(w);
195​ int dockMask = mask
196​ | (w->hasAlpha() ? PAINT_WINDOW_TRANSLUCENT
197​ : PAINT_WINDOW_OPAQUE);
198​ effects->drawWindow(w, dockMask, infiniteRegion(), dockData);
179 } 199​ }
180} 200​}
181 201​
182void SlideEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) 202​/**
203​ * Decide whether given window @p w should be transformed/translated.
204​ * @returns @c true if given window @p w should be transformed, otherwise @c false
205​ */
206​bool SlideEffect::isTranslated(const EffectWindow* w) const
183{ 207​{
184 if (slide) { 208​ if (w->isOnAllDesktops()) {
185 // Do not move a window if it is on all desktops or being moved to another desktop. 209​ return (w->isDock() || w->isDesktop());
186 if (!w->isOnAllDesktops() && w != m_movingWindow) { 210​ } else if (w == m_movingWindow) {
187 data += slide_painting_diff; 211​ return false;
212​ } else if (w->isOnDesktop(m_paintCtx.desktop)) {
213​ return true;
214​ }
215​ return false;
188 } 216​}
217​
218​/**
219​ * Decide whether given window @p w should be painted.
220​ * @returns @c true if given window @p w should be painted, otherwise @c false
221​ */
222​bool SlideEffect::isPainted(const EffectWindow* w) const
223​{
224​ if (w->isOnAllDesktops()) {
225​ if (w->isDock()) {
226​ if (! m_slideDocks) {
227​ return false;
228​ }
229​ for (const EffectWindow* fw : qAsConst(m_paintCtx.fullscreenWindows)) {
230​ if (fw->isOnDesktop(m_paintCtx.desktop)
231​ && fw->screen() == w->screen()) {
232​ return false;
233​ }
234​ }
235​ return true;
236​ }
237​ // In order to make sure that 'keep above' windows are above
238​ // other windows during transition to another virtual desktop,
239​ // they should be painted in the last pass.
240​ if (w->keepAbove()) {
241​ return m_paintCtx.lastPass;
242​ }
243​ return true;
244​ } else if (w == m_movingWindow) {
245​ return m_paintCtx.lastPass;
246​ } else if (w->isOnDesktop(m_paintCtx.desktop)) {
247​ return true;
248​ }
249​ return false;
250​}
251​
252​void SlideEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
253​{
254​ if (m_active) {
255​ const bool painted = isPainted(w);
256​ if (painted) {
257​ w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
258​ } else {
259​ w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
260​ }
261​ if (painted && isTranslated(w)) {
262​ data.setTransformed();
263​ }
264​ }
265​ effects->prePaintWindow(w, data, time);
266​}
267​
268​void SlideEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
269​{
270​ if (m_active && isTranslated(w)) {
271​ data += m_paintCtx.translation;
189 } 272​ }
190 effects->paintWindow(w, mask, region, data); 273​ effects->paintWindow(w, mask, region, data);
191} 274​}
192 275​
193void SlideEffect::postPaintScreen() 276​void SlideEffect::postPaintScreen()
194{ 277​{
195 if (slide) 278​ if (m_active) {
279​ if (m_timeline.currentValue() == 1) {
280​ stop();
281​ }
196 effects->addRepaintFull(); 282​ effects->addRepaintFull();
283​ }
197 effects->postPaintScreen(); 284​ effects->postPaintScreen();
198} 285​}
199 286​
200// Gives a position of the given desktop when all desktops are arranged in a grid 287​/**
201QRect SlideEffect::desktopRect(int desktop) const 288​ * Get position of the top-left corner of desktop @p id within desktop grid with gaps.
289​ * @param id ID of a virtual desktop
290​ */
291​QPoint SlideEffect::desktopCoords(int id) const
202{ 292​{
203 QRect rect = effects->virtualScreenGeometry(); 293​ QPoint c = effects->desktopCoords(id);
204 rect.translate(effects->desktopCoords(desktop)); 294​ QPoint gridPos = effects->desktopGridCoords(id);
205 return rect; 295​ c.setX(c.x() + m_hGap * gridPos.x());
296​ c.setY(c.y() + m_vGap * gridPos.y());
297​ return c;
206} 298​}
207 299​
208void SlideEffect::slotDesktopChanged(int old, int current, EffectWindow* with) 300​/**
301​ * Get geometry of desktop @p id within desktop grid with gaps.
302​ * @param id ID of a virtual desktop
303​ */
304​QRect SlideEffect::desktopGeometry(int id) const
209{ 305​{
210 if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this) 306​ QRect g = effects->virtualScreenGeometry();
211 return; 307​ g.translate(desktopCoords(id));
308​ return g;
309​}
212 310​
213 if (slide) { // old slide still in progress 311​/**
214 QPoint diffPos = desktopRect(old).topLeft() - slide_start_pos; 312​ * Get width of a virtual desktop grid.
215 int w = 0; 313​ */
216 int h = 0; 314​int SlideEffect::workspaceWidth() const
217 if (effects->optionRollOverDesktops()) { 315​{
218 w = effects->workspaceWidth(); 316​ int w = effects->workspaceWidth();
219 h = effects->workspaceHeight(); 317​ w += m_hGap * effects->desktopGridWidth();
220 // wrap around if shorter 318​ 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 } 319​}
230 QPoint currentPos = slide_start_pos + mTimeLine.currentValue() * diffPos; 320​
231 const QSize screenSize = effects->virtualScreenSize(); 321​/**
232 QRegion currentRegion = QRect(currentPos, screenSize); 322​ * Get height of a virtual desktop grid.
233 if (effects->optionRollOverDesktops()) { 323​ */
234 currentRegion |= (currentRegion & QRect(-w, 0, w, h)).translated(w, 0); 324​int SlideEffect::workspaceHeight() const
235 currentRegion |= (currentRegion & QRect(0, -h, w, h)).translated(0, h); 325​{
236 currentRegion |= (currentRegion & QRect(w, 0, w, h)).translated(-w, 0); 326​ int h = effects->workspaceHeight();
237 currentRegion |= (currentRegion & QRect(0, h, w, h)).translated(0, -h); 327​ h += m_vGap * effects->desktopGridHeight();
238 } 328​ 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 } 329​}
258 m_backgroundContrastForcedBefore.clear(); 330​
259 slide = false; 331​inline bool shouldForceBackgroundContrast(const EffectWindow *w)
260 mTimeLine.setCurrentTime(0); 332​{
261 effects->setActiveFullScreenEffect(NULL); 333​ if (w->data(WindowForceBackgroundContrastRole).isValid()) {
334​ return false;
262 } 335​ }
263 } else { 336​ return w->hasAlpha()
264 if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this) 337​ && w->isOnAllDesktops()
338​ && (w->isDock() || w->keepAbove());
339​}
340​
341​void SlideEffect::start(int old, int current, EffectWindow* movingWindow)
342​{
343​ m_movingWindow = movingWindow;
344​
345​ const bool wrap = effects->optionRollOverDesktops();
346​ const int w = workspaceWidth();
347​ const int h = workspaceHeight();
348​
349​ if (m_active) {
350​ QPoint passed = m_diff * m_timeline.currentValue();
351​ QPoint currentPos = m_startPos + passed;
352​ QPoint delta = desktopCoords(current) - desktopCoords(old);
353​ if (wrap) {
354​ wrapDiff(delta, w, h);
355​ }
356​ m_diff += delta - passed;
357​ m_startPos = currentPos;
358​ m_timeline.setCurrentTime(0);
265 return; 359​ return;
266 mTimeLine.setCurrentTime(0); 360​ }
267 slide_start_pos = desktopRect(old).topLeft(); 361​
268 slide = true; 362​ const auto windows = effects->stackingOrder();
269 foreach (EffectWindow * w, effects->stackingOrder()) { 363​ for (EffectWindow* w : windows) {
270 w->setData(WindowForceBlurRole, QVariant(true)); 364​ w->setData(WindowForceBlurRole, QVariant(true));
271 if (shouldForceBackgroundContrast(w)) { 365​ if (shouldForceBackgroundContrast(w)) {
272 m_backgroundContrastForcedBefore.append(w); ​
273 w->setData(WindowForceBackgroundContrastRole, QVariant(true)); 366​ w->setData(WindowForceBackgroundContrastRole, QVariant(true));
367​ m_backgroundContrastForcedBefore << w;
274 } 368​ }
275 } 369​ }
370​
371​ m_diff = desktopCoords(current) - desktopCoords(old);
372​ if (wrap) {
373​ wrapDiff(m_diff, w, h);
374​ }
375​ m_startPos = desktopCoords(old);
376​ m_timeline.setCurrentTime(0);
377​ m_active = true;
276 effects->setActiveFullScreenEffect(this); 378​ effects->setActiveFullScreenEffect(this);
379​ effects->addRepaintFull();
277 } 380​}
278 381​
279 m_movingWindow = with; 382​void SlideEffect::stop()
383​{
384​ const auto windows = effects->stackingOrder();
385​ for (EffectWindow* w : windows) {
386​ w->setData(WindowForceBlurRole, QVariant(false));
387​ if (m_backgroundContrastForcedBefore.contains(w)) {
388​ w->setData(WindowForceBackgroundContrastRole, QVariant());
389​ }
390​ }
391​ m_backgroundContrastForcedBefore.clear();
392​ m_paintCtx.fullscreenWindows.clear();
393​ m_timeline.setCurrentTime(0);
394​ m_movingWindow = nullptr;
395​ m_active = false;
396​ effects->setActiveFullScreenEffect(nullptr);
397​}
280 398​
281 effects->addRepaintFull(); 399​void SlideEffect::desktopChanged(int old, int current, EffectWindow* with)
400​{
401​ if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this) {
402​ return;
403​ }
404​ start(old, current, with);
282} 405​}
283 406​
284void SlideEffect::windowAdded(EffectWindow *w) 407​void SlideEffect::windowAdded(EffectWindow *w)
285{ 408​{
286 if (slide && shouldForceBackgroundContrast(w)) { 409​ if (! m_active) {
287 m_backgroundContrastForcedBefore.append(w); 410​ return;
411​ }
412​ w->setData(WindowForceBlurRole, QVariant(true));
413​ if (shouldForceBackgroundContrast(w)) {
288 w->setData(WindowForceBackgroundContrastRole, QVariant(true)); 414​ w->setData(WindowForceBackgroundContrastRole, QVariant(true));
415​ m_backgroundContrastForcedBefore << w;
289 } 416​ }
290} 417​}
291 418​
292void SlideEffect::windowDeleted(EffectWindow *w) 419​void SlideEffect::windowDeleted(EffectWindow *w)
293{ 420​{
421​ if (! m_active) {
422​ return;
423​ }
294 m_backgroundContrastForcedBefore.removeAll(w); 424​ m_backgroundContrastForcedBefore.removeAll(w);
295 if (w == m_movingWindow) 425​ m_paintCtx.fullscreenWindows.removeAll(w);
426​ if (w == m_movingWindow) {
296 m_movingWindow = nullptr; 427​ m_movingWindow = nullptr;
297} 428​ }
429​}
298 430​
299bool SlideEffect::shouldForceBackgroundContrast(const EffectWindow *w) const 431​void SlideEffect::numberDesktopsChanged(uint)
300{ 432​{
301 // Windows that are docks, kept above (such as panel popups), and do not 433​ if (! m_active) {
302 // have the background contrast explicitely disabled should be forced on 434​ return;
303 // during the slide animation 435​ }
304 const bool bgWindow = (w->hasAlpha() && w->isOnAllDesktops() && (w->isDock() || w->keepAbove())); 436​ stop();
305 return bgWindow && (!w->data(WindowForceBackgroundContrastRole).isValid()); ​
306} 437​}
307 438​
308bool SlideEffect::isActive() const 439​void SlideEffect::numberScreensChanged()
309{ 440​{
310 return slide; 441​ if (! m_active) {
442​ return;
443​ }
444​ stop();
311} 445​}
312 446​
313} // namespace 447​} // namespace
314 ​