Differential D13720 Diff 36692 effects/diminactive/diminactive.cpp

Changeset View

Standalone View

View Options

effects/diminactive/diminactive.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) 2007 Christian Nitschkowski <christian.nitschkowski@kdemail.net> 6​Copyright (C) 2007 Christian Nitschkowski <christian.nitschkowski@kdemail.net>
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​// own
22#include "diminactive.h" 24​#include "diminactive.h"
25​
23// KConfigSkeleton 26​// KConfigSkeleton
24#include "diminactiveconfig.h" 27​#include "diminactiveconfig.h"
25 28​
26#include <kconfiggroup.h> ​
27 ​
28namespace KWin 29​namespace KWin
29{ 30​{
30 31​
32​/**
33​ * Checks if two windows belong to the same window group
34​ *
35​ * One possible example of a window group is an app window and app
36​ * preferences window(e.g. Dolphin window and Dolphin Preferences window).
37​ *
38​ * @param w1 The first window
39​ * @param w2 The second window
40​ * @returns @c true if both windows belong to the same window group, @c false otherwise
41​ **/
42​static inline bool belongToSameGroup(const EffectWindow *w1, const EffectWindow *w2)
43​{
44​ return w1 && w2 && w1->group() && w1->group() == w2->group();
45​}
46​
31DimInactiveEffect::DimInactiveEffect() 47​DimInactiveEffect::DimInactiveEffect()
32{ 48​{
49​ m_activeWindow = nullptr;
50​
51​ m_fullScreenTransition.active = false;
52​ m_fullScreenTransition.timeLine.setDirection(TimeLine::Forward);
53​ m_fullScreenTransition.timeLine.setDuration(animationTime(250));
54​ m_fullScreenTransition.timeLine.setEasingCurve(QEasingCurve::InOutQuad);
55​
33 initConfig<DimInactiveConfig>(); 56​ initConfig<DimInactiveConfig>();
34 reconfigure(ReconfigureAll); 57​ reconfigure(ReconfigureAll);
35 timeline.setDuration(animationTime(250)); 58​
36 previousActiveTimeline.setDuration(animationTime(250)); 59​ connect(effects, &EffectsHandler::windowActivated,
37 active = effects->activeWindow(); 60​ this, &DimInactiveEffect::windowActivated);
38 previousActive = NULL; 61​ connect(effects, &EffectsHandler::windowClosed,
39 connect(effects, SIGNAL(windowActivated(KWin::EffectWindow*)), this, SLOT(slotWindowActivated(KWin::EffectWindow*))); 62​ this, &DimInactiveEffect::windowClosed);
40 connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), this, SLOT(slotWindowDeleted(KWin::EffectWindow*))); 63​ connect(effects, &EffectsHandler::windowDeleted,
64​ this, &DimInactiveEffect::windowDeleted);
65​ connect(effects, &EffectsHandler::activeFullScreenEffectChanged,
66​ this, &DimInactiveEffect::activeFullScreenEffectChanged);
67​}
68​
69​DimInactiveEffect::~DimInactiveEffect()
70​{
41} 71​}
42 72​
43void DimInactiveEffect::reconfigure(ReconfigureFlags) 73​void DimInactiveEffect::reconfigure(ReconfigureFlags flags)
44{ 74​{
75​ Q_UNUSED(flags)
76​
45 DimInactiveConfig::self()->read(); 77​ DimInactiveConfig::self()->read();
46 dim_panels = DimInactiveConfig::dimPanels(); 78​ m_dimStrength = DimInactiveConfig::strength() / 100.0;
47 dim_desktop = DimInactiveConfig::dimDesktop(); 79​ m_dimPanels = DimInactiveConfig::dimPanels();
48 dim_keepabove = DimInactiveConfig::dimKeepAbove(); 80​ m_dimDesktop = DimInactiveConfig::dimDesktop();
49 dim_by_group = DimInactiveConfig::dimByGroup(); 81​ m_dimKeepAbove = DimInactiveConfig::dimKeepAbove();
50 dim_strength = DimInactiveConfig::strength(); 82​ m_dimByGroup = DimInactiveConfig::dimByGroup();
83​
84​ EffectWindow *activeWindow = effects->activeWindow();
85​ m_activeWindow = (activeWindow && canDimWindow(activeWindow))
86​ ? activeWindow
87​ : nullptr;
88​
89​ m_activeWindowGroup = (m_dimByGroup && m_activeWindow)
90​ ? m_activeWindow->group()
91​ : nullptr;
92​
93​ m_fullScreenTransition.timeLine.setDuration(animationTime(250));
94​
51 effects->addRepaintFull(); 95​ effects->addRepaintFull();
52} 96​}
53 97​
54void DimInactiveEffect::prePaintScreen(ScreenPrePaintData& data, int time) 98​void DimInactiveEffect::prePaintScreen(ScreenPrePaintData &data, int time)
55{ 99​{
56 double oldValue = timeline.currentValue(); 100​ if (m_fullScreenTransition.active) {
57 if (effects->activeFullScreenEffect()) 101​ m_fullScreenTransition.timeLine.update(time);
58 timeline.setCurrentTime(timeline.currentTime() - time); 102​ }
59 else 103​
60 timeline.setCurrentTime(timeline.currentTime() + time); 104​ auto transitionIt = m_transitions.begin();
61 if (oldValue != timeline.currentValue()) 105​ while (transitionIt != m_transitions.end()) {
davidedmundsonUnsubmitted
Done

constBegin/constEnd

davidedmundson: constBegin/constEnd
zzagAuthorUnsubmitted
Done

It won't be compiled:

(*transitionIt) would return const T &, where T = TimeLine. It would work with pointers because what iterator returns is a const reference to a pointer, e.g.

const (TimeLine *) &
zzag: It won't be compiled: `(*transitionIt)` would return `const T &`, where `T = TimeLine`. It…
62 effects->addRepaintFull(); 106​ (*transitionIt).update(time);
63 if (previousActive) { 107​ ++transitionIt;
64 // We are fading out the previous window ​
65 previousActive->addRepaintFull(); ​
66 previousActiveTimeline.setCurrentTime(previousActiveTimeline.currentTime() + time); ​
67 } 108​ }
109​
68 effects->prePaintScreen(data, time); 110​ effects->prePaintScreen(data, time);
69} 111​}
70 112​
71void DimInactiveEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) 113​void DimInactiveEffect::paintWindow(EffectWindow *w, int mask, QRegion region, WindowPaintData &data)
72{ 114​{
73 if (dimWindow(w) || w == previousActive) { 115​ auto forceIt = m_forceDim.constFind(w);
74 double previous = 1.0; 116​ if (forceIt != m_forceDim.constEnd()) {
75 if (w == previousActive) 117​ const qreal forcedStrength = *forceIt;
76 previous = previousActiveTimeline.currentValue(); 118​ dimWindow(w, data, forcedStrength);
77 if (previousActiveTimeline.currentValue() == 1.0) 119​ effects->paintWindow(w, mask, region, data);
78 previousActive = NULL; 120​ return;
79 data.multiplyBrightness((1.0 - (dim_strength / 100.0) * timeline.currentValue() * previous)); ​
80 data.multiplySaturation((1.0 - (dim_strength / 100.0) * timeline.currentValue() * previous)); ​
81 } 121​ }
122​
123​ auto transitionIt = m_transitions.constFind(w);
124​ if (transitionIt != m_transitions.constEnd()) {
125​ const qreal transitionProgress = (*transitionIt).value();
126​ dimWindow(w, data, m_dimStrength * transitionProgress);
82 effects->paintWindow(w, mask, region, data); 127​ effects->paintWindow(w, mask, region, data);
128​ return;
83} 129​ }
84 130​
85bool DimInactiveEffect::dimWindow(const EffectWindow* w) const 131​ if (canDimWindow(w)) {
132​ dimWindow(w, data, m_dimStrength);
133​ }
134​
135​ effects->paintWindow(w, mask, region, data);
136​}
137​
138​void DimInactiveEffect::postPaintScreen()
86{ 139​{
87 if (effects->activeWindow() == w) 140​ if (m_fullScreenTransition.active) {
88 return false; // never dim active window 141​ if (m_fullScreenTransition.timeLine.done()) {
89 if (active && dim_by_group && active->group() == w->group()) 142​ m_fullScreenTransition.active = false;
90 return false; // don't dim in active group if configured so 143​ }
91 if (w->isDock() && !dim_panels) 144​ effects->addRepaintFull();
92 return false; // don't dim panels if configured so 145​ }
93 if (w->isDesktop() && !dim_desktop) 146​
94 return false; // don't dim the desktop if configured so 147​ auto transitionIt = m_transitions.begin();
95 if (w->keepAbove() && !dim_keepabove) 148​ while (transitionIt != m_transitions.end()) {
96 return false; // don't dim keep-above windows if configured so 149​ EffectWindow *w = transitionIt.key();
97 if (!w->isNormalWindow() && !w->isDialog() && !w->isDock() && !w->isDesktop()) 150​ const TimeLine &timeLine = transitionIt.value();
98 return false; // don't dim more special window types 151​ if (timeLine.done()) {
99 // don't dim unmanaged windows, grouping doesn't work for them and maybe dimming 152​ transitionIt = m_transitions.erase(transitionIt);
100 // them doesn't make sense in general (they should be short-lived anyway) 153​ } else {
101 if (!w->isManaged()) 154​ ++transitionIt;
155​ }
156​ w->addRepaintFull();
157​ }
158​
159​ effects->postPaintScreen();
160​}
161​
162​void DimInactiveEffect::dimWindow(EffectWindow *w, WindowPaintData &data, qreal strength)
163​{
164​ qreal dimFactor = 1.0;
165​ if (m_fullScreenTransition.active) {
166​ dimFactor = 1.0 - m_fullScreenTransition.timeLine.value();
167​ } else if (effects->activeFullScreenEffect()) {
168​ dimFactor = 0.0;
169​ }
170​
171​ data.multiplyBrightness(1.0 - strength * dimFactor);
172​ data.multiplySaturation(1.0 - strength * dimFactor);
173​}
174​
175​bool DimInactiveEffect::canDimWindow(const EffectWindow *w) const
176​{
177​ if (m_activeWindow == w) {
178​ return false;
179​ }
180​
181​ if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
182​ return false;
183​ }
184​
185​ if (w->isDock() && !m_dimPanels) {
186​ return false;
187​ }
188​
189​ if (w->isDesktop() && !m_dimDesktop) {
190​ return false;
191​ }
192​
193​ if (w->keepAbove() && !m_dimKeepAbove) {
194​ return false;
195​ }
196​
197​ if (!w->isManaged()) {
102 return false; 198​ return false;
103 return true; // dim the rest ​
104} 199​ }
105 200​
106void DimInactiveEffect::slotWindowDeleted(EffectWindow* w) 201​ return w->isNormalWindow()
202​ || w->isDialog()
203​ || w->isUtility()
204​ || w->isDock()
205​ || w->isDesktop();
206​}
207​
208​void DimInactiveEffect::scheduleInTransition(EffectWindow *w)
107{ 209​{
108 if (w == previousActive) 210​ TimeLine &timeLine = m_transitions[w];
109 previousActive = NULL; 211​ timeLine.reset();
212​ timeLine.setDuration(animationTime(160));
213​ timeLine.setDirection(TimeLine::Backward);
214​ timeLine.setEasingCurve(QEasingCurve::InCurve);
110} 215​}
111 216​
112void DimInactiveEffect::slotWindowActivated(EffectWindow* w) 217​void DimInactiveEffect::scheduleGroupInTransition(EffectWindow *w)
113{ 218​{
114 if (active != NULL) { 219​ if (!m_dimByGroup) {
115 previousActive = active; 220​ scheduleInTransition(w);
116 previousActiveTimeline.setCurrentTime(0); 221​ return;
117 if (!dimWindow(previousActive)) 222​ }
118 previousActive = NULL; 223​
224​ if (!w->group()) {
225​ scheduleInTransition(w);
226​ return;
227​ }
119 228​
120 if (dim_by_group) { 229​ const auto members = w->group()->members();
121 if ((w == NULL || w->group() != active->group()) && active->group() != NULL) { 230​ for (EffectWindow *member : members) {
122 // repaint windows that are no longer in the active group 231​ scheduleInTransition(member);
davidedmundsonUnsubmitted
Done

why the reset?

won't that flicker if you

inactive -> active -> inactive

really really quickly.

davidedmundson: why the reset? won't that flicker if you inactive -> active -> inactive really really…
zzagAuthorUnsubmitted
Done

Good question. The In and the Out animations are different so that's fine to reset them.

really really quickly

It will be noticeable only when animation time factor is 4x+.

On the other hand, TimeLine tries its best to smooth "transition" from old duration to new duration. The problem is when we're truncating duration(e.g. 250ms -> 160ms). But that's easy to fix:

timeLine.setDuration(smallerDuration);
if (timeLine.done()) {
    timeLine.reset();
}

I'll change it.

zzag: Good question. The In and the Out animations are different so that's fine to reset them. >…
zzagAuthorUnsubmitted
Done

I'll also have to change easing curves. (to InOut curve)

zzag: I'll also have to change easing curves. (to InOut curve)
123 foreach (EffectWindow * tmp, active->group()->members()) ​
124 tmp->addRepaintFull(); ​
125 } 232​ }
126 } else ​
127 active->addRepaintFull(); ​
128 } 233​}
129 active = w; 234​
130 if (active != NULL) { 235​void DimInactiveEffect::scheduleOutTransition(EffectWindow *w)
131 if (dim_by_group) { 236​{
132 if (active->group() != NULL) { 237​ TimeLine &timeLine = m_transitions[w];
133 // repaint newly active windows 238​ timeLine.reset();
134 foreach (EffectWindow * tmp, active->group()->members()) 239​ timeLine.setDuration(animationTime(250));
135 tmp->addRepaintFull(); 240​ timeLine.setDirection(TimeLine::Forward);
241​ timeLine.setEasingCurve(QEasingCurve::OutCurve);
242​}
243​
244​void DimInactiveEffect::scheduleGroupOutTransition(EffectWindow *w)
245​{
246​ if (!m_dimByGroup) {
247​ scheduleOutTransition(w);
248​ return;
249​ }
250​
251​ if (!w->group()) {
252​ scheduleOutTransition(w);
253​ return;
136 } 254​ }
137 } else 255​
138 active->addRepaintFull(); 256​ const auto members = w->group()->members();
257​ for (EffectWindow *member : members) {
258​ scheduleOutTransition(member);
259​ }
260​}
261​
262​void DimInactiveEffect::scheduleRepaint(EffectWindow *w)
263​{
264​ if (!m_dimByGroup) {
265​ w->addRepaintFull();
266​ return;
267​ }
268​
269​ if (!w->group()) {
270​ w->addRepaintFull();
271​ return;
272​ }
273​
274​ const auto members = w->group()->members();
275​ for (EffectWindow *member : members) {
276​ member->addRepaintFull();
277​ }
278​}
279​
280​void DimInactiveEffect::windowActivated(EffectWindow *w)
281​{
282​ if (!w) {
283​ return;
139 } 284​ }
285​
286​ if (m_activeWindow == w) {
287​ return;
288​ }
289​
290​ if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
291​ m_activeWindow = w;
292​ return;
293​ }
294​
295​ // WORKAROUND: Deleted windows do not belong to any of window groups.
296​ // So, if one of windows in a window group is closed, the In transition
297​ // will be false-triggered for the rest of the window group. In addition
298​ // to the active window, keep track of active window group so we can
299​ // tell whether "focus" moved from a closed window to some other window
300​ // in a window group.
301​ if (m_dimByGroup && w->group() && w->group() == m_activeWindowGroup) {
302​ m_activeWindow = w;
303​ return;
304​ }
305​
306​ EffectWindow *previousActiveWindow = m_activeWindow;
307​ m_activeWindow = canDimWindow(w) ? w : nullptr;
308​
309​ m_activeWindowGroup = (m_dimByGroup && m_activeWindow)
310​ ? m_activeWindow->group()
311​ : nullptr;
312​
313​ if (previousActiveWindow) {
314​ scheduleGroupOutTransition(previousActiveWindow);
315​ scheduleRepaint(previousActiveWindow);
316​ }
317​
318​ if (m_activeWindow) {
319​ scheduleGroupInTransition(m_activeWindow);
320​ scheduleRepaint(m_activeWindow);
321​ }
322​}
323​
324​void DimInactiveEffect::windowClosed(EffectWindow *w)
325​{
326​ // When a window is closed, we should force current dim strength that
327​ // is applied to it to avoid flickering when some effect animates
328​ // the disappearing of the window. If there is no such effect then
329​ // it won't be dimmed.
330​ qreal forcedStrength = 0.0;
331​ bool shouldForceDim = false;
332​
333​ auto transitionIt = m_transitions.find(w);
334​ if (transitionIt != m_transitions.end()) {
335​ forcedStrength = m_dimStrength * (*transitionIt).value();
336​ shouldForceDim = true;
337​ m_transitions.erase(transitionIt);
338​ } else if (m_activeWindow == w) {
339​ forcedStrength = 0.0;
340​ shouldForceDim = true;
341​ } else if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
342​ forcedStrength = 0.0;
343​ shouldForceDim = true;
344​ } else if (canDimWindow(w)) {
345​ forcedStrength = m_dimStrength;
346​ shouldForceDim = true;
347​ }
348​
349​ if (shouldForceDim) {
350​ m_forceDim.insert(w, forcedStrength);
351​ }
352​
353​ if (m_activeWindow == w) {
354​ m_activeWindow = nullptr;
355​ }
356​}
357​
358​void DimInactiveEffect::windowDeleted(EffectWindow *w)
359​{
360​ m_forceDim.remove(w);
361​}
362​
363​void DimInactiveEffect::activeFullScreenEffectChanged()
364​{
365​ m_fullScreenTransition.active = true;
366​ if (m_fullScreenTransition.timeLine.done()) {
367​ m_fullScreenTransition.timeLine.reset();
368​ }
369​ m_fullScreenTransition.timeLine.setDirection(
370​ effects->activeFullScreenEffect()
371​ ? TimeLine::Forward
372​ : TimeLine::Backward
373​ );
374​
375​ effects->addRepaintFull();
140} 376​}
141 377​
142} // namespace 378​} // namespace KWin