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