Differential D13762 Diff 36771 effects/magiclamp/magiclamp.cpp

Changeset View

Standalone View

View Options

effects/magiclamp/magiclamp.cpp

Show All 18 Lines
19*********************************************************************/ 19​*********************************************************************/
20 20​
21// based on minimize animation by Rivo Laks <rivolaks@hot.ee> 21​// based on minimize animation by Rivo Laks <rivolaks@hot.ee>
22 22​
23#include "magiclamp.h" 23​#include "magiclamp.h"
24// KConfigSkeleton 24​// KConfigSkeleton
25#include "magiclampconfig.h" 25​#include "magiclampconfig.h"
26 26​
27#include <kwinconfig.h> ​
28#include <kconfiggroup.h> ​
29#include <QTimeLine> ​
30#include <QtDebug> ​
31 ​
32namespace KWin 27​namespace KWin
33{ 28​{
34 29​
35MagicLampEffect::MagicLampEffect() 30​MagicLampEffect::MagicLampEffect()
36{ 31​{
37 initConfig<MagicLampConfig>(); 32​ initConfig<MagicLampConfig>();
38 mActiveAnimations = 0; ​
39 reconfigure(ReconfigureAll); 33​ reconfigure(ReconfigureAll);
40 connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), this, SLOT(slotWindowDeleted(KWin::EffectWindow*))); 34​ connect(effects, SIGNAL(windowDeleted(KWin::EffectWindow*)), this, SLOT(slotWindowDeleted(KWin::EffectWindow*)));
41 connect(effects, SIGNAL(windowMinimized(KWin::EffectWindow*)), this, SLOT(slotWindowMinimized(KWin::EffectWindow*))); 35​ connect(effects, SIGNAL(windowMinimized(KWin::EffectWindow*)), this, SLOT(slotWindowMinimized(KWin::EffectWindow*)));
42 connect(effects, SIGNAL(windowUnminimized(KWin::EffectWindow*)), this, SLOT(slotWindowUnminimized(KWin::EffectWindow*))); 36​ connect(effects, SIGNAL(windowUnminimized(KWin::EffectWindow*)), this, SLOT(slotWindowUnminimized(KWin::EffectWindow*)));
43} 37​}
44 38​
45bool MagicLampEffect::supported() 39​bool MagicLampEffect::supported()
46{ 40​{
47 return effects->isOpenGLCompositing() && effects->animationsSupported(); 41​ return effects->isOpenGLCompositing() && effects->animationsSupported();
48} 42​}
49 43​
50void MagicLampEffect::reconfigure(ReconfigureFlags) 44​void MagicLampEffect::reconfigure(ReconfigureFlags)
51{ 45​{
52 MagicLampConfig::self()->read(); 46​ MagicLampConfig::self()->read();
53 // TODO: rename animationDuration to duration 47​
54 mAnimationDuration = animationTime(MagicLampConfig::animationDuration() != 0 ? MagicLampConfig::animationDuration() : 250); 48​ // TODO: Rename animationDuration to duration so we can use
49​ // animationTime<MagicLampConfig>(250).
50​ const int d = MagicLampConfig::animationDuration() != 0
51​ ? MagicLampConfig::animationDuration()
52​ : 250;
53​ m_duration = std::chrono::milliseconds(static_cast<int>(animationTime(d)));
55} 54​}
56 55​
57void MagicLampEffect::prePaintScreen(ScreenPrePaintData& data, int time) 56​void MagicLampEffect::prePaintScreen(ScreenPrePaintData& data, int time)
58{ 57​{
58​ const std::chrono::milliseconds delta(time);
59 59​
60 QHash< EffectWindow*, QTimeLine* >::iterator entry = mTimeLineWindows.begin(); 60​ auto animationIt = m_animations.begin();
61 bool erase = false; 61​ while (animationIt != m_animations.end()) {
62 while (entry != mTimeLineWindows.end()) { 62​ (*animationIt).update(delta);
63 QTimeLine *timeline = entry.value(); 63​ ++animationIt;
64 if (entry.key()->isMinimized()) { ​
65 timeline->setCurrentTime(timeline->currentTime() + time); ​
66 erase = (timeline->currentValue() >= 1.0f); ​
67 } else { ​
68 timeline->setCurrentTime(timeline->currentTime() - time); ​
69 erase = (timeline->currentValue() <= 0.0f); ​
70 } ​
71 if (erase) { ​
72 delete timeline; ​
73 entry = mTimeLineWindows.erase(entry); ​
74 } else ​
75 ++entry; ​
76 } 64​ }
77 65​
78 mActiveAnimations = mTimeLineWindows.count(); ​
79 if (mActiveAnimations > 0) ​
80 // We need to mark the screen windows as transformed. Otherwise the 66​ // We need to mark the screen windows as transformed. Otherwise the
81 // whole screen won't be repainted, resulting in artefacts 67​ // whole screen won't be repainted, resulting in artefacts.
82 data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS; 68​ data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
83 69​
84 effects->prePaintScreen(data, time); 70​ effects->prePaintScreen(data, time);
85} 71​}
86 72​
87void MagicLampEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) 73​void MagicLampEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
88{ 74​{
89 // Schedule window for transformation if the animation is still in 75​ // Schedule window for transformation if the animation is still in
90 // progress 76​ // progress
91 if (mTimeLineWindows.contains(w)) { 77​ if (m_animations.contains(w)) {
92 // We'll transform this window 78​ // We'll transform this window
93 data.setTransformed(); 79​ data.setTransformed();
94 data.quads = data.quads.makeGrid(40); 80​ data.quads = data.quads.makeGrid(40);
95 w->enablePainting(EffectWindow::PAINT_DISABLED_BY_MINIMIZE); 81​ w->enablePainting(EffectWindow::PAINT_DISABLED_BY_MINIMIZE);
96 } 82​ }
97 83​
98 effects->prePaintWindow(w, data, time); 84​ effects->prePaintWindow(w, data, time);
99} 85​}
100 86​
101void MagicLampEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) 87​void MagicLampEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
102{ 88​{
103 if (mTimeLineWindows.contains(w)) { 89​ auto animationIt = m_animations.constFind(w);
90​ if (animationIt != m_animations.constEnd()) {
104 // 0 = not minimized, 1 = fully minimized 91​ // 0 = not minimized, 1 = fully minimized
105 float progress = mTimeLineWindows[w]->currentValue(); 92​ const qreal progress = (*animationIt).value();
106 93​
107 QRect geo = w->geometry(); 94​ QRect geo = w->geometry();
108 QRect icon = w->iconGeometry(); 95​ QRect icon = w->iconGeometry();
109 IconPosition position = Top; 96​ IconPosition position = Top;
110 // If there's no icon geometry, minimize to the center of the screen 97​ // If there's no icon geometry, minimize to the center of the screen
111 if (!icon.isValid()) { 98​ if (!icon.isValid()) {
112 QRect extG = geo; 99​ QRect extG = geo;
113 QPoint pt = cursorPos(); 100​ QPoint pt = cursorPos();
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Line(s)190#define SET_QUADS(_SET_A_, _A_, _DA_, _SET_B_, _B_, _O0_, _O1_, _O2_, _O3_) quad[0]._SET_A_((icon._A_() + icon._DA_()*(quad[0]._A_() / geo._DA_()) - (quad[0]._A_() + geo._A_()))*p_progress[_O0_] + quad[0]._A_());\
317 } 304​ }
318 305​
319 // Call the next effect. 306​ // Call the next effect.
320 effects->paintWindow(w, mask, region, data); 307​ effects->paintWindow(w, mask, region, data);
321} 308​}
322 309​
323void MagicLampEffect::postPaintScreen() 310​void MagicLampEffect::postPaintScreen()
324{ 311​{
325 if (mActiveAnimations > 0) 312​ if (!m_animations.isEmpty()) {
326 // Repaint the workspace so that everything would be repainted next time ​
327 effects->addRepaintFull(); 313​ effects->addRepaintFull();
328 mActiveAnimations = mTimeLineWindows.count(); 314​ }
315​
316​ auto animationIt = m_animations.begin();
317​ while (animationIt != m_animations.end()) {
318​ if ((*animationIt).done()) {
319​ animationIt = m_animations.erase(animationIt);
320​ } else {
321​ ++animationIt;
322​ }
323​ }
329 324​
330 // Call the next effect. 325​ // Call the next effect.
331 effects->postPaintScreen(); 326​ effects->postPaintScreen();
332} 327​}
333 328​
334void MagicLampEffect::slotWindowDeleted(EffectWindow* w) 329​void MagicLampEffect::slotWindowDeleted(EffectWindow* w)
335{ 330​{
336 delete mTimeLineWindows.take(w); 331​ m_animations.remove(w);
337} 332​}
338 333​
339void MagicLampEffect::slotWindowMinimized(EffectWindow* w) 334​void MagicLampEffect::slotWindowMinimized(EffectWindow* w)
340{ 335​{
341 if (effects->activeFullScreenEffect()) 336​ if (effects->activeFullScreenEffect())
342 return; 337​ return;
343 if (!mTimeLineWindows.contains(w)) { 338​
344 mTimeLineWindows.insert(w, new QTimeLine(mAnimationDuration, this)); 339​ TimeLine &timeLine = m_animations[w];
345 mTimeLineWindows[w]->setCurrentTime(0); 340​
346 mTimeLineWindows[w]->setCurveShape(QTimeLine::LinearCurve); 341​ if (timeLine.running()) {
342​ timeLine.toggleDirection();
343​ } else {
344​ timeLine.setDirection(TimeLine::Forward);
345​ timeLine.setDuration(m_duration);
346​ timeLine.setEasingCurve(QEasingCurve::Linear);
347 } 347​ }
348​
349​ effects->addRepaintFull();
348} 350​}
349 351​
350void MagicLampEffect::slotWindowUnminimized(EffectWindow* w) 352​void MagicLampEffect::slotWindowUnminimized(EffectWindow* w)
351{ 353​{
352 if (effects->activeFullScreenEffect()) 354​ if (effects->activeFullScreenEffect())
353 return; 355​ return;
354 if (!mTimeLineWindows.contains(w)) { 356​
355 mTimeLineWindows.insert(w, new QTimeLine(mAnimationDuration, this)); 357​ TimeLine &timeLine = m_animations[w];
356 mTimeLineWindows[w]->setCurrentTime(mAnimationDuration); 358​
357 mTimeLineWindows[w]->setCurveShape(QTimeLine::LinearCurve); 359​ if (timeLine.running()) {
360​ timeLine.toggleDirection();
361​ } else {
362​ timeLine.setDirection(TimeLine::Backward);
363​ timeLine.setDuration(m_duration);
364​ timeLine.setEasingCurve(QEasingCurve::Linear);
358 } 365​ }
366​
367​ effects->addRepaintFull();
359} 368​}
360 369​
361bool MagicLampEffect::isActive() const 370​bool MagicLampEffect::isActive() const
362{ 371​{
363 return !mTimeLineWindows.isEmpty(); 372​ return !m_animations.isEmpty();
364} 373​}
365 374​
366} // namespace 375​} // namespace