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