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