Differential D13720 Diff 40125 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​
33 initConfig<DimInactiveConfig>(); 51​ initConfig<DimInactiveConfig>();
34 reconfigure(ReconfigureAll); 52​ reconfigure(ReconfigureAll);
35 timeline.setDuration(animationTime(250)); 53​
36 previousActiveTimeline.setDuration(animationTime(250)); 54​ connect(effects, &EffectsHandler::windowActivated,
37 active = effects->activeWindow(); 55​ this, &DimInactiveEffect::windowActivated);
38 previousActive = NULL; 56​ connect(effects, &EffectsHandler::windowClosed,
39 connect(effects, SIGNAL(windowActivated(KWin::EffectWindow*)), this, SLOT(slotWindowActivated(KWin::EffectWindow*))); 57​ this, &DimInactiveEffect::windowClosed);
40 connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), this, SLOT(slotWindowDeleted(KWin::EffectWindow*))); 58​ connect(effects, &EffectsHandler::windowDeleted,
59​ this, &DimInactiveEffect::windowDeleted);
60​ connect(effects, &EffectsHandler::activeFullScreenEffectChanged,
61​ this, &DimInactiveEffect::activeFullScreenEffectChanged);
41} 62​}
42 63​
43void DimInactiveEffect::reconfigure(ReconfigureFlags) 64​DimInactiveEffect::~DimInactiveEffect()
44{ 65​{
66​}
67​
68​void DimInactiveEffect::reconfigure(ReconfigureFlags flags)
69​{
70​ Q_UNUSED(flags)
71​
45 DimInactiveConfig::self()->read(); 72​ DimInactiveConfig::self()->read();
46 dim_panels = DimInactiveConfig::dimPanels(); 73​
47 dim_desktop = DimInactiveConfig::dimDesktop(); 74​ // TODO: Use normalized strength param.
48 dim_keepabove = DimInactiveConfig::dimKeepAbove(); 75​ m_dimStrength = DimInactiveConfig::strength() / 100.0;
49 dim_by_group = DimInactiveConfig::dimByGroup(); 76​ m_dimPanels = DimInactiveConfig::dimPanels();
50 dim_strength = DimInactiveConfig::strength(); 77​ m_dimDesktop = DimInactiveConfig::dimDesktop();
78​ m_dimKeepAbove = DimInactiveConfig::dimKeepAbove();
79​ m_dimByGroup = DimInactiveConfig::dimByGroup();
80​
81​ EffectWindow *activeWindow = effects->activeWindow();
82​ m_activeWindow = (activeWindow && canDimWindow(activeWindow))
83​ ? activeWindow
84​ : nullptr;
85​
86​ m_activeWindowGroup = (m_dimByGroup && m_activeWindow)
87​ ? m_activeWindow->group()
88​ : nullptr;
89​
90​ m_fullScreenTransition.timeLine.setDuration(
91​ std::chrono::milliseconds(static_cast<int>(animationTime(250))));
92​
51 effects->addRepaintFull(); 93​ effects->addRepaintFull();
52} 94​}
53 95​
54void DimInactiveEffect::prePaintScreen(ScreenPrePaintData& data, int time) 96​void DimInactiveEffect::prePaintScreen(ScreenPrePaintData &data, int time)
55{ 97​{
56 double oldValue = timeline.currentValue(); 98​ const std::chrono::milliseconds delta(time);
57 if (effects->activeFullScreenEffect()) 99​
58 timeline.setCurrentTime(timeline.currentTime() - time); 100​ if (m_fullScreenTransition.active) {
59 else 101​ m_fullScreenTransition.timeLine.update(delta);
60 timeline.setCurrentTime(timeline.currentTime() + time); 102​ }
61 if (oldValue != timeline.currentValue()) 103​
62 effects->addRepaintFull(); 104​ auto transitionIt = m_transitions.begin();
63 if (previousActive) { 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…
64 // We are fading out the previous window 106​ (*transitionIt).update(delta);
65 previousActive->addRepaintFull(); 107​ ++transitionIt;
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 transitionIt = m_transitions.constFind(w);
74 double previous = 1.0; 116​ if (transitionIt != m_transitions.constEnd()) {
75 if (w == previousActive) 117​ const qreal transitionProgress = (*transitionIt).value();
76 previous = previousActiveTimeline.currentValue(); 118​ dimWindow(data, m_dimStrength * transitionProgress);
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)); 121​ }
80 data.multiplySaturation((1.0 - (dim_strength / 100.0) * timeline.currentValue() * previous)); 122​
123​ auto forceIt = m_forceDim.constFind(w);
124​ if (forceIt != m_forceDim.constEnd()) {
125​ const qreal forcedStrength = *forceIt;
126​ dimWindow(data, forcedStrength);
127​ effects->paintWindow(w, mask, region, data);
128​ return;
129​ }
130​
131​ if (canDimWindow(w)) {
132​ dimWindow(data, m_dimStrength);
81 } 133​ }
134​
82 effects->paintWindow(w, mask, region, data); 135​ effects->paintWindow(w, mask, region, data);
83} 136​}
84 137​
85bool DimInactiveEffect::dimWindow(const EffectWindow* w) const 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​ if ((*transitionIt).done()) {
98 return false; // don't dim more special window types 151​ transitionIt = m_transitions.erase(transitionIt);
99 // don't dim unmanaged windows, grouping doesn't work for them and maybe dimming 152​ } else {
100 // them doesn't make sense in general (they should be short-lived anyway) 153​ ++transitionIt;
101 if (!w->isManaged()) 154​ }
155​ w->addRepaintFull();
156​ }
157​
158​ effects->postPaintScreen();
159​}
160​
161​void DimInactiveEffect::dimWindow(WindowPaintData &data, qreal strength)
162​{
163​ qreal dimFactor;
164​ if (m_fullScreenTransition.active) {
165​ dimFactor = 1.0 - m_fullScreenTransition.timeLine.value();
166​ } else if (effects->activeFullScreenEffect()) {
167​ dimFactor = 0.0;
168​ } else {
169​ dimFactor = 1.0;
170​ }
171​
172​ data.multiplyBrightness(1.0 - strength * dimFactor);
173​ data.multiplySaturation(1.0 - strength * dimFactor);
174​}
175​
176​bool DimInactiveEffect::canDimWindow(const EffectWindow *w) const
177​{
178​ if (m_activeWindow == w) {
179​ return false;
180​ }
181​
182​ if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
183​ return false;
184​ }
185​
186​ if (w->isDock() && !m_dimPanels) {
187​ return false;
188​ }
189​
190​ if (w->isDesktop() && !m_dimDesktop) {
191​ return false;
192​ }
193​
194​ if (w->keepAbove() && !m_dimKeepAbove) {
195​ return false;
196​ }
197​
198​ if (!w->isManaged()) {
102 return false; 199​ return false;
103 return true; // dim the rest ​
104} 200​ }
105 201​
106void DimInactiveEffect::slotWindowDeleted(EffectWindow* w) 202​ return w->isNormalWindow()
203​ || w->isDialog()
204​ || w->isUtility()
205​ || w->isDock()
206​ || w->isDesktop();
207​}
208​
209​void DimInactiveEffect::scheduleInTransition(EffectWindow *w)
210​{
211​ TimeLine &timeLine = m_transitions[w];
212​ timeLine.setDuration(
213​ std::chrono::milliseconds(static_cast<int>(animationTime(160))));
214​ if (timeLine.done()) {
215​ // If the Out animation is still active, then we're trucating
216​ // duration of the timeline(from 250ms to 160ms). If the timeline
217​ // is about to be finished with the old duration, then after
218​ // changing duration it will be in the "done" state. Thus, we
219​ // have to reset the timeline, otherwise it won't update progress.
220​ timeLine.reset();
221​ }
222​ timeLine.setDirection(TimeLine::Backward);
223​ timeLine.setEasingCurve(QEasingCurve::InOutSine);
224​}
225​
226​void DimInactiveEffect::scheduleGroupInTransition(EffectWindow *w)
227​{
228​ if (!m_dimByGroup) {
229​ scheduleInTransition(w);
230​ return;
231​ }
232​
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)
233​ if (!w->group()) {
234​ scheduleInTransition(w);
235​ return;
236​ }
237​
238​ const auto members = w->group()->members();
239​ for (EffectWindow *member : members) {
240​ scheduleInTransition(member);
241​ }
242​}
243​
244​void DimInactiveEffect::scheduleOutTransition(EffectWindow *w)
107{ 245​{
108 if (w == previousActive) 246​ TimeLine &timeLine = m_transitions[w];
109 previousActive = NULL; 247​ timeLine.setDuration(
248​ std::chrono::milliseconds(static_cast<int>(animationTime(250))));
249​ if (timeLine.done()) {
250​ timeLine.reset();
251​ }
252​ timeLine.setDirection(TimeLine::Forward);
253​ timeLine.setEasingCurve(QEasingCurve::InOutSine);
254​}
255​
256​void DimInactiveEffect::scheduleGroupOutTransition(EffectWindow *w)
257​{
258​ if (!m_dimByGroup) {
259​ scheduleOutTransition(w);
260​ return;
261​ }
262​
263​ if (!w->group()) {
264​ scheduleOutTransition(w);
265​ return;
110} 266​ }
111 267​
112void DimInactiveEffect::slotWindowActivated(EffectWindow* w) 268​ const auto members = w->group()->members();
269​ for (EffectWindow *member : members) {
270​ scheduleOutTransition(member);
271​ }
272​}
273​
274​void DimInactiveEffect::scheduleRepaint(EffectWindow *w)
113{ 275​{
114 if (active != NULL) { 276​ if (!m_dimByGroup) {
115 previousActive = active; 277​ w->addRepaintFull();
116 previousActiveTimeline.setCurrentTime(0); 278​ return;
117 if (!dimWindow(previousActive)) 279​ }
118 previousActive = NULL; ​
119 280​
120 if (dim_by_group) { 281​ if (!w->group()) {
121 if ((w == NULL || w->group() != active->group()) && active->group() != NULL) { 282​ w->addRepaintFull();
122 // repaint windows that are no longer in the active group 283​ return;
123 foreach (EffectWindow * tmp, active->group()->members()) ​
124 tmp->addRepaintFull(); ​
125 } 284​ }
126 } else 285​
127 active->addRepaintFull(); 286​ const auto members = w->group()->members();
287​ for (EffectWindow *member : members) {
288​ member->addRepaintFull();
128 } 289​ }
129 active = w; ​
130 if (active != NULL) { ​
131 if (dim_by_group) { ​
132 if (active->group() != NULL) { ​
133 // repaint newly active windows ​
134 foreach (EffectWindow * tmp, active->group()->members()) ​
135 tmp->addRepaintFull(); ​
136 } 290​}
137 } else 291​
138 active->addRepaintFull(); 292​void DimInactiveEffect::windowActivated(EffectWindow *w)
293​{
294​ if (!w) {
295​ return;
139 } 296​ }
297​
298​ if (m_activeWindow == w) {
299​ return;
300​ }
301​
302​ if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
303​ m_activeWindow = w;
304​ return;
305​ }
306​
307​ // WORKAROUND: Deleted windows do not belong to any of window groups.
308​ // So, if one of windows in a window group is closed, the In transition
309​ // will be false-triggered for the rest of the window group. In addition
310​ // to the active window, keep track of active window group so we can
311​ // tell whether "focus" moved from a closed window to some other window
312​ // in a window group.
313​ if (m_dimByGroup && w->group() && w->group() == m_activeWindowGroup) {
314​ m_activeWindow = w;
315​ return;
316​ }
317​
318​ EffectWindow *previousActiveWindow = m_activeWindow;
319​ m_activeWindow = canDimWindow(w) ? w : nullptr;
320​
321​ m_activeWindowGroup = (m_dimByGroup && m_activeWindow)
322​ ? m_activeWindow->group()
323​ : nullptr;
324​
325​ if (previousActiveWindow) {
326​ scheduleGroupOutTransition(previousActiveWindow);
327​ scheduleRepaint(previousActiveWindow);
328​ }
329​
330​ if (m_activeWindow) {
331​ scheduleGroupInTransition(m_activeWindow);
332​ scheduleRepaint(m_activeWindow);
333​ }
334​}
335​
336​void DimInactiveEffect::windowClosed(EffectWindow *w)
337​{
338​ // When a window is closed, we should force current dim strength that
339​ // is applied to it to avoid flickering when some effect animates
340​ // the disappearing of the window. If there is no such effect then
341​ // it won't be dimmed.
342​ qreal forcedStrength = 0.0;
343​ bool shouldForceDim = false;
344​
345​ auto transitionIt = m_transitions.find(w);
346​ if (transitionIt != m_transitions.end()) {
347​ forcedStrength = m_dimStrength * (*transitionIt).value();
348​ shouldForceDim = true;
349​ m_transitions.erase(transitionIt);
350​ } else if (m_activeWindow == w) {
351​ forcedStrength = 0.0;
352​ shouldForceDim = true;
353​ } else if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
354​ forcedStrength = 0.0;
355​ shouldForceDim = true;
356​ } else if (canDimWindow(w)) {
357​ forcedStrength = m_dimStrength;
358​ shouldForceDim = true;
359​ }
360​
361​ if (shouldForceDim) {
362​ m_forceDim.insert(w, forcedStrength);
363​ }
364​
365​ if (m_activeWindow == w) {
366​ m_activeWindow = nullptr;
367​ }
368​}
369​
370​void DimInactiveEffect::windowDeleted(EffectWindow *w)
371​{
372​ m_forceDim.remove(w);
373​}
374​
375​void DimInactiveEffect::activeFullScreenEffectChanged()
376​{
377​ if (m_fullScreenTransition.timeLine.done()) {
378​ m_fullScreenTransition.timeLine.reset();
379​ }
380​ m_fullScreenTransition.timeLine.setDirection(
381​ effects->activeFullScreenEffect()
382​ ? TimeLine::Forward
383​ : TimeLine::Backward
384​ );
385​ m_fullScreenTransition.active = true;
386​
387​ effects->addRepaintFull();
140} 388​}
141 389​
142} // namespace 390​} // namespace KWin