Differential D13720 Diff 37910 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: Turn the Strength param into double.
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)); ​
80 data.multiplySaturation((1.0 - (dim_strength / 100.0) * timeline.currentValue() * previous)); ​
81 } 121​ }
122​
123​ auto forceIt = m_forceDim.constFind(w);
124​ if (forceIt != m_forceDim.constEnd()) {
125​ const qreal forcedStrength = *forceIt;
126​ dimWindow(data, forcedStrength);
82 effects->paintWindow(w, mask, region, data); 127​ effects->paintWindow(w, mask, region, data);
128​ return;
129​ }
130​
131​ if (canDimWindow(w)) {
132​ dimWindow(data, m_dimStrength);
133​ }
134​
135​ effects->paintWindow(w, mask, region, data);
136​}
137​
138​void DimInactiveEffect::postPaintScreen()
139​{
140​ if (m_fullScreenTransition.active) {
141​ if (m_fullScreenTransition.timeLine.done()) {
142​ m_fullScreenTransition.active = false;
143​ }
144​ effects->addRepaintFull();
145​ }
146​
147​ auto transitionIt = m_transitions.begin();
148​ while (transitionIt != m_transitions.end()) {
149​ EffectWindow *w = transitionIt.key();
150​ if ((*transitionIt).done()) {
151​ transitionIt = m_transitions.erase(transitionIt);
152​ } else {
153​ ++transitionIt;
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);
83} 174​}
84 175​
85bool DimInactiveEffect::dimWindow(const EffectWindow* w) const 176​bool DimInactiveEffect::canDimWindow(const EffectWindow *w) const
86{ 177​{
87 if (effects->activeWindow() == w) 178​ if (m_activeWindow == w) {
88 return false; // never dim active window 179​ return false;
89 if (active && dim_by_group && active->group() == w->group()) 180​ }
90 return false; // don't dim in active group if configured so 181​
91 if (w->isDock() && !dim_panels) 182​ if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
92 return false; // don't dim panels if configured so 183​ return false;
93 if (w->isDesktop() && !dim_desktop) 184​ }
94 return false; // don't dim the desktop if configured so 185​
95 if (w->keepAbove() && !dim_keepabove) 186​ if (w->isDock() && !m_dimPanels) {
96 return false; // don't dim keep-above windows if configured so 187​ return false;
97 if (!w->isNormalWindow() && !w->isDialog() && !w->isDock() && !w->isDesktop()) 188​ }
98 return false; // don't dim more special window types 189​
99 // don't dim unmanaged windows, grouping doesn't work for them and maybe dimming 190​ if (w->isDesktop() && !m_dimDesktop) {
100 // them doesn't make sense in general (they should be short-lived anyway) 191​ return false;
101 if (!w->isManaged()) 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.reset();
213​ timeLine.setDuration(
214​ std::chrono::milliseconds(static_cast<int>(animationTime(160))));
215​ timeLine.setDirection(TimeLine::Backward);
216​ timeLine.setEasingCurve(QEasingCurve::InCurve);
217​}
218​
219​void DimInactiveEffect::scheduleGroupInTransition(EffectWindow *w)
220​{
221​ if (!m_dimByGroup) {
222​ scheduleInTransition(w);
223​ return;
224​ }
225​
226​ if (!w->group()) {
227​ scheduleInTransition(w);
228​ return;
229​ }
230​
231​ const auto members = w->group()->members();
232​ for (EffectWindow *member : members) {
233​ scheduleInTransition(member);
234​ }
235​}
236​
237​void DimInactiveEffect::scheduleOutTransition(EffectWindow *w)
238​{
239​ TimeLine &timeLine = m_transitions[w];
240​ timeLine.reset();
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)
241​ timeLine.setDuration(
242​ std::chrono::milliseconds(static_cast<int>(animationTime(250))));
243​ timeLine.setDirection(TimeLine::Forward);
244​ timeLine.setEasingCurve(QEasingCurve::OutCurve);
245​}
246​
247​void DimInactiveEffect::scheduleGroupOutTransition(EffectWindow *w)
248​{
249​ if (!m_dimByGroup) {
250​ scheduleOutTransition(w);
251​ return;
252​ }
253​
254​ if (!w->group()) {
255​ scheduleOutTransition(w);
256​ return;
257​ }
258​
259​ const auto members = w->group()->members();
260​ for (EffectWindow *member : members) {
261​ scheduleOutTransition(member);
262​ }
263​}
264​
265​void DimInactiveEffect::scheduleRepaint(EffectWindow *w)
266​{
267​ if (!m_dimByGroup) {
268​ w->addRepaintFull();
269​ return;
270​ }
271​
272​ if (!w->group()) {
273​ w->addRepaintFull();
274​ return;
275​ }
276​
277​ const auto members = w->group()->members();
278​ for (EffectWindow *member : members) {
279​ member->addRepaintFull();
280​ }
281​}
282​
283​void DimInactiveEffect::windowActivated(EffectWindow *w)
107{ 284​{
108 if (w == previousActive) 285​ if (!w) {
109 previousActive = NULL; 286​ return;
110} 287​ }
111 288​
112void DimInactiveEffect::slotWindowActivated(EffectWindow* w) 289​ if (m_activeWindow == w) {
290​ return;
291​ }
292​
293​ if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
294​ m_activeWindow = w;
295​ return;
296​ }
297​
298​ // WORKAROUND: Deleted windows do not belong to any of window groups.
299​ // So, if one of windows in a window group is closed, the In transition
300​ // will be false-triggered for the rest of the window group. In addition
301​ // to the active window, keep track of active window group so we can
302​ // tell whether "focus" moved from a closed window to some other window
303​ // in a window group.
304​ if (m_dimByGroup && w->group() && w->group() == m_activeWindowGroup) {
305​ m_activeWindow = w;
306​ return;
307​ }
308​
309​ EffectWindow *previousActiveWindow = m_activeWindow;
310​ m_activeWindow = canDimWindow(w) ? w : nullptr;
311​
312​ m_activeWindowGroup = (m_dimByGroup && m_activeWindow)
313​ ? m_activeWindow->group()
314​ : nullptr;
315​
316​ if (previousActiveWindow) {
317​ scheduleGroupOutTransition(previousActiveWindow);
318​ scheduleRepaint(previousActiveWindow);
319​ }
320​
321​ if (m_activeWindow) {
322​ scheduleGroupInTransition(m_activeWindow);
323​ scheduleRepaint(m_activeWindow);
324​ }
325​}
326​
327​void DimInactiveEffect::windowClosed(EffectWindow *w)
113{ 328​{
114 if (active != NULL) { 329​ // When a window is closed, we should force current dim strength that
115 previousActive = active; 330​ // is applied to it to avoid flickering when some effect animates
116 previousActiveTimeline.setCurrentTime(0); 331​ // the disappearing of the window. If there is no such effect then
117 if (!dimWindow(previousActive)) 332​ // it won't be dimmed.
118 previousActive = NULL; 333​ qreal forcedStrength = 0.0;
334​ bool shouldForceDim = false;
335​
336​ auto transitionIt = m_transitions.find(w);
337​ if (transitionIt != m_transitions.end()) {
338​ forcedStrength = m_dimStrength * (*transitionIt).value();
339​ shouldForceDim = true;
340​ m_transitions.erase(transitionIt);
341​ } else if (m_activeWindow == w) {
342​ forcedStrength = 0.0;
343​ shouldForceDim = true;
344​ } else if (m_dimByGroup && belongToSameGroup(m_activeWindow, w)) {
345​ forcedStrength = 0.0;
346​ shouldForceDim = true;
347​ } else if (canDimWindow(w)) {
348​ forcedStrength = m_dimStrength;
349​ shouldForceDim = true;
350​ }
351​
352​ if (shouldForceDim) {
353​ m_forceDim.insert(w, forcedStrength);
354​ }
119 355​
120 if (dim_by_group) { 356​ if (m_activeWindow == w) {
121 if ((w == NULL || w->group() != active->group()) && active->group() != NULL) { 357​ m_activeWindow = nullptr;
122 // repaint windows that are no longer in the active group ​
123 foreach (EffectWindow * tmp, active->group()->members()) ​
124 tmp->addRepaintFull(); ​
125 } 358​ }
126 } else ​
127 active->addRepaintFull(); ​
128 } 359​}
129 active = w; 360​
130 if (active != NULL) { 361​void DimInactiveEffect::windowDeleted(EffectWindow *w)
131 if (dim_by_group) { 362​{
132 if (active->group() != NULL) { 363​ m_forceDim.remove(w);
133 // repaint newly active windows ​
134 foreach (EffectWindow * tmp, active->group()->members()) ​
135 tmp->addRepaintFull(); ​
136 } 364​}
137 } else 365​
138 active->addRepaintFull(); 366​void DimInactiveEffect::activeFullScreenEffectChanged()
367​{
368​ if (m_fullScreenTransition.timeLine.done()) {
369​ m_fullScreenTransition.timeLine.reset();
139 } 370​ }
371​ m_fullScreenTransition.timeLine.setDirection(
372​ effects->activeFullScreenEffect()
373​ ? TimeLine::Forward
374​ : TimeLine::Backward
375​ );
376​ m_fullScreenTransition.active = true;
377​
378​ effects->addRepaintFull();
140} 379​}
141 380​
142} // namespace 381​} // namespace KWin