Differential D15695 Diff 44910 effects/snaphelper/snaphelper.cpp

Changeset View

Standalone View

View Options

effects/snaphelper/snaphelper.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) 2009 Lucas Murray <lmurray@undefinedfire.com> 5​Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
6​Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
6 7​
7This program is free software; you can redistribute it and/or modify 8​This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by 9​it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or 10​the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version. 11​(at your option) any later version.
11 12​
12This program is distributed in the hope that it will be useful, 13​This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of 14​but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details. 16​GNU General Public License for more details.
16 17​
17You should have received a copy of the GNU General Public License 18​You should have received a copy of the GNU General Public License
18along with this program. If not, see <http://www.gnu.org/licenses/>. 19​along with this program. If not, see <http://www.gnu.org/licenses/>.
19*********************************************************************/ 20​*********************************************************************/
20 21​
21#include "snaphelper.h" 22​#include "snaphelper.h"
22 23​
23#include <kwinglutils.h> 24​#include <kwinglutils.h>
25​
24#ifdef KWIN_HAVE_XRENDER_COMPOSITING 26​#ifdef KWIN_HAVE_XRENDER_COMPOSITING
25#include <kwinxrenderutils.h> 27​#include <kwinxrenderutils.h>
26#include <xcb/render.h> 28​#include <xcb/render.h>
27#endif 29​#endif
30​
28#include <QPainter> 31​#include <QPainter>
29 32​
30namespace KWin 33​namespace KWin
31{ 34​{
32 35​
36​static const int s_lineWidth = 4;
37​static const QColor s_lineColor = QColor(128, 128, 128, 128);
38​
39​static QRegion computeDirtyRegion(const QRect &windowRect)
40​{
41​ const QMargins outlineMargins(
42​ s_lineWidth / 2,
43​ s_lineWidth / 2,
44​ s_lineWidth / 2,
45​ s_lineWidth / 2
46​ );
47​
48​ QRegion dirtyRegion;
49​ for (int i = 0; i < effects->numScreens(); ++i) {
50​ const QRect screenRect = effects->clientArea(ScreenArea, i, 0);
51​
52​ QRect screenWindowRect = windowRect;
53​ screenWindowRect.moveCenter(screenRect.center());
54​
55​ QRect verticalBarRect(0, 0, s_lineWidth, screenRect.height());
56​ verticalBarRect.moveCenter(screenRect.center());
57​ verticalBarRect.adjust(-1, -1, 1, 1);
58​ dirtyRegion += verticalBarRect;
59​
60​ QRect horizontalBarRect(0, 0, screenRect.width(), s_lineWidth);
61​ horizontalBarRect.moveCenter(screenRect.center());
62​ horizontalBarRect.adjust(-1, -1, 1, 1);
63​ dirtyRegion += horizontalBarRect;
64​
65​ const QRect outlineOuterRect = screenWindowRect
66​ .marginsAdded(outlineMargins)
67​ .adjusted(-1, -1, 1, 1);
68​ const QRect outlineInnerRect = screenWindowRect
69​ .marginsRemoved(outlineMargins)
70​ .adjusted(1, 1, -1, -1);
71​ dirtyRegion += QRegion(outlineOuterRect) - QRegion(outlineInnerRect);
72​ }
73​
74​ return dirtyRegion;
75​}
76​
33SnapHelperEffect::SnapHelperEffect() 77​SnapHelperEffect::SnapHelperEffect()
34 : m_active(false) ​
35 , m_window(NULL) ​
36{ 78​{
37 m_timeline.setCurveShape(QTimeLine::LinearCurve); ​
38 reconfigure(ReconfigureAll); 79​ reconfigure(ReconfigureAll);
39 connect(effects, SIGNAL(windowClosed(KWin::EffectWindow*)), this, SLOT(slotWindowClosed(KWin::EffectWindow*))); 80​
40 connect(effects, SIGNAL(windowStartUserMovedResized(KWin::EffectWindow*)), this, SLOT(slotWindowStartUserMovedResized(KWin::EffectWindow*))); 81​ connect(effects, &EffectsHandler::windowClosed, this, &SnapHelperEffect::slotWindowClosed);
41 connect(effects, SIGNAL(windowFinishUserMovedResized(KWin::EffectWindow*)), this, SLOT(slotWindowFinishUserMovedResized(KWin::EffectWindow*))); 82​ connect(effects, &EffectsHandler::windowStartUserMovedResized, this, &SnapHelperEffect::slotWindowStartUserMovedResized);
42 connect(effects, SIGNAL(windowGeometryShapeChanged(KWin::EffectWindow*,QRect)), this, SLOT(slotWindowResized(KWin::EffectWindow*,QRect))); 83​ connect(effects, &EffectsHandler::windowFinishUserMovedResized, this, &SnapHelperEffect::slotWindowFinishUserMovedResized);
84​ connect(effects, &EffectsHandler::windowGeometryShapeChanged, this, &SnapHelperEffect::slotWindowGeometryShapeChanged);
43} 85​}
44 86​
45SnapHelperEffect::~SnapHelperEffect() 87​SnapHelperEffect::~SnapHelperEffect()
46{ 88​{
47} 89​}
48 90​
49void SnapHelperEffect::reconfigure(ReconfigureFlags) 91​void SnapHelperEffect::reconfigure(ReconfigureFlags flags)
50{ 92​{
51 m_timeline.setDuration(animationTime(250)); 93​ Q_UNUSED(flags)
94​
95​ m_animation.timeLine.setDuration(
96​ std::chrono::milliseconds(static_cast<int>(animationTime(250))));
52} 97​}
romanggUnsubmitted
Not Done

Not linear anymore? Then mention in commit message.

romangg: Not linear anymore? Then mention in commit message.
53 98​
54void SnapHelperEffect::prePaintScreen(ScreenPrePaintData &data, int time) 99​void SnapHelperEffect::prePaintScreen(ScreenPrePaintData &data, int time)
55{ 100​{
56 double oldValue = m_timeline.currentValue(); 101​ if (m_animation.active) {
57 if (m_active) 102​ m_animation.timeLine.update(std::chrono::milliseconds(time));
58 m_timeline.setCurrentTime(m_timeline.currentTime() + time); 103​ }
59 else 104​
60 m_timeline.setCurrentTime(m_timeline.currentTime() - time); ​
61 if (oldValue != m_timeline.currentValue()) ​
62 effects->addRepaintFull(); ​
63 effects->prePaintScreen(data, time); 105​ effects->prePaintScreen(data, time);
64} 106​}
65 107​
66void SnapHelperEffect::paintScreen(int mask, QRegion region, ScreenPaintData &data) 108​void SnapHelperEffect::paintScreen(int mask, QRegion region, ScreenPaintData &data)
67{ 109​{
68 effects->paintScreen(mask, region, data); 110​ effects->paintScreen(mask, region, data);
69 if (m_timeline.currentValue() != 0.0) { 111​
112​ const qreal opacityFactor = m_animation.active
113​ ? m_animation.timeLine.value()
114​ : 1.0;
115​
70 // Display the guide 116​ // Display the guide
71 if (effects->isOpenGLCompositing()) { 117​ if (effects->isOpenGLCompositing()) {
72 GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer(); 118​ GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
73 vbo->reset(); 119​ vbo->reset();
74 vbo->setUseColor(true); 120​ vbo->setUseColor(true);
75 ShaderBinder binder(ShaderTrait::UniformColor); 121​ ShaderBinder binder(ShaderTrait::UniformColor);
76 binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, data.projectionMatrix()); 122​ binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, data.projectionMatrix());
77 glEnable(GL_BLEND); 123​ glEnable(GL_BLEND);
78 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 124​ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
79 125​
80 QColor color; 126​ QColor color = s_lineColor;
81 color.setRedF(0.5); 127​ color.setAlphaF(color.alphaF() * opacityFactor);
82 color.setGreenF(0.5); ​
83 color.setBlueF(0.5); ​
84 color.setAlphaF(m_timeline.currentValue() * 0.5); ​
85 vbo->setColor(color); 128​ vbo->setColor(color);
86 glLineWidth(4.0); 129​
130​ glLineWidth(s_lineWidth);
87 QVector<float> verts; 131​ QVector<float> verts;
88 verts.reserve(effects->numScreens() * 24); 132​ verts.reserve(effects->numScreens() * 24);
89 for (int i = 0; i < effects->numScreens(); ++i) { 133​ for (int i = 0; i < effects->numScreens(); ++i) {
90 const QRect& rect = effects->clientArea(ScreenArea, i, 0); 134​ const QRect rect = effects->clientArea(ScreenArea, i, 0);
91 int midX = rect.x() + rect.width() / 2; 135​ const int midX = rect.x() + rect.width() / 2;
92 int midY = rect.y() + rect.height() / 2 ; 136​ const int midY = rect.y() + rect.height() / 2 ;
93 int halfWidth = m_window->width() / 2; 137​ const int halfWidth = m_geometry.width() / 2;
94 int halfHeight = m_window->height() / 2; 138​ const int halfHeight = m_geometry.height() / 2;
95 139​
96 // Center lines 140​ // Center vertical line.
97 verts << rect.x() + rect.width() / 2 << rect.y(); 141​ verts << rect.x() + rect.width() / 2 << rect.y();
98 verts << rect.x() + rect.width() / 2 << rect.y() + rect.height(); 142​ verts << rect.x() + rect.width() / 2 << rect.y() + rect.height();
143​
144​ // Center horizontal line.
99 verts << rect.x() << rect.y() + rect.height() / 2; 145​ verts << rect.x() << rect.y() + rect.height() / 2;
100 verts << rect.x() + rect.width() << rect.y() + rect.height() / 2; 146​ verts << rect.x() + rect.width() << rect.y() + rect.height() / 2;
101 147​
102 // Window outline 148​ // Top edge of the window outline.
103 // The +/- 2 is to prevent line overlap 149​ verts << midX - halfWidth - s_lineWidth / 2 << midY - halfHeight;
104 verts << midX - halfWidth + 2 << midY - halfHeight; 150​ verts << midX + halfWidth + s_lineWidth / 2 << midY - halfHeight;
105 verts << midX + halfWidth + 2 << midY - halfHeight; 151​
106 verts << midX + halfWidth << midY - halfHeight + 2; 152​ // Right edge of the window outline.
107 verts << midX + halfWidth << midY + halfHeight + 2; 153​ verts << midX + halfWidth << midY - halfHeight + s_lineWidth / 2;
108 verts << midX + halfWidth - 2 << midY + halfHeight; 154​ verts << midX + halfWidth << midY + halfHeight - s_lineWidth / 2;
109 verts << midX - halfWidth - 2 << midY + halfHeight; 155​
110 verts << midX - halfWidth << midY + halfHeight - 2; 156​ // Bottom edge of the window outline.
111 verts << midX - halfWidth << midY - halfHeight - 2; 157​ verts << midX + halfWidth + s_lineWidth / 2 << midY + halfHeight;
158​ verts << midX - halfWidth - s_lineWidth / 2 << midY + halfHeight;
159​
160​ // Left edge of the window outline.
161​ verts << midX - halfWidth << midY + halfHeight - s_lineWidth / 2;
162​ verts << midX - halfWidth << midY - halfHeight + s_lineWidth / 2;
112 } 163​ }
113 vbo->setData(verts.count() / 2, 2, verts.data(), NULL); 164​ vbo->setData(verts.count() / 2, 2, verts.data(), nullptr);
114 vbo->render(GL_LINES); 165​ vbo->render(GL_LINES);
115 166​
116 glDisable(GL_BLEND); 167​ glDisable(GL_BLEND);
117 glLineWidth(1.0); 168​ glLineWidth(1.0);
118 } 169​ }
119 if ( effects->compositingType() == XRenderCompositing ) { 170​ if (effects->compositingType() == XRenderCompositing) {
120#ifdef KWIN_HAVE_XRENDER_COMPOSITING 171​#ifdef KWIN_HAVE_XRENDER_COMPOSITING
121 for (int i = 0; i < effects->numScreens(); ++i) { 172​ for (int i = 0; i < effects->numScreens(); ++i) {
122 const QRect& rect = effects->clientArea( ScreenArea, i, 0 ); 173​ const QRect rect = effects->clientArea(ScreenArea, i, 0);
123 int midX = rect.x() + rect.width() / 2; 174​ const int midX = rect.x() + rect.width() / 2;
124 int midY = rect.y() + rect.height() / 2 ; 175​ const int midY = rect.y() + rect.height() / 2 ;
125 int halfWidth = m_window->width() / 2; 176​ const int halfWidth = m_geometry.width() / 2;
126 int halfHeight = m_window->height() / 2; 177​ const int halfHeight = m_geometry.height() / 2;
127 178​
128 xcb_rectangle_t rects[6]; 179​ xcb_rectangle_t rects[6];
129 // Center lines 180​
130 rects[0].x = rect.x() + rect.width() / 2 - 2; 181​ // Center vertical line.
182​ rects[0].x = rect.x() + rect.width() / 2 - s_lineWidth / 2;
131 rects[0].y = rect.y(); 183​ rects[0].y = rect.y();
132 rects[0].width = 4; 184​ rects[0].width = s_lineWidth;
133 rects[0].height = rect.height(); 185​ rects[0].height = rect.height();
186​
187​ // Center horizontal line.
134 rects[1].x = rect.x(); 188​ rects[1].x = rect.x();
135 rects[1].y = rect.y() + rect.height() / 2 - 2; 189​ rects[1].y = rect.y() + rect.height() / 2 - s_lineWidth / 2;
136 rects[1].width = rect.width(); 190​ rects[1].width = rect.width();
137 rects[1].height = 4; 191​ rects[1].height = s_lineWidth;
192​
193​ // Top edge of the window outline.
194​ rects[2].x = midX - halfWidth - s_lineWidth / 2;
195​ rects[2].y = midY - halfHeight - s_lineWidth / 2;
196​ rects[2].width = 2 * halfWidth + s_lineWidth;
197​ rects[2].height = s_lineWidth;
198​
199​ // Right edge of the window outline.
200​ rects[3].x = midX + halfWidth - s_lineWidth / 2;
201​ rects[3].y = midY - halfHeight + s_lineWidth / 2;
202​ rects[3].width = s_lineWidth;
203​ rects[3].height = 2 * halfHeight - s_lineWidth;
204​
205​ // Bottom edge of the window outline.
206​ rects[4].x = midX - halfWidth - s_lineWidth / 2;
207​ rects[4].y = midY + halfHeight - s_lineWidth / 2;
208​ rects[4].width = 2 * halfWidth + s_lineWidth;
209​ rects[4].height = s_lineWidth;
210​
211​ // Left edge of the window outline.
212​ rects[5].x = midX - halfWidth - s_lineWidth / 2;
213​ rects[5].y = midY - halfHeight + s_lineWidth / 2;
214​ rects[5].width = s_lineWidth;
215​ rects[5].height = 2 * halfHeight - s_lineWidth;
138 216​
139 // Window outline 217​ QColor color = s_lineColor;
140 // The +/- 4 is to prevent line overlap 218​ color.setAlphaF(color.alphaF() * opacityFactor);
141 rects[2].x = midX - halfWidth + 4; ​
142 rects[2].y = midY - halfHeight; ​
143 rects[2].width = 2*halfWidth - 4; ​
144 rects[2].height = 4; ​
145 rects[3].x = midX + halfWidth - 4; ​
146 rects[3].y = midY - halfHeight + 4; ​
147 rects[3].width = 4; ​
148 rects[3].height = 2*halfHeight - 4; ​
149 rects[4].x = midX - halfWidth; ​
150 rects[4].y = midY + halfHeight - 4; ​
151 rects[4].width = 2*halfWidth - 4; ​
152 rects[4].height = 4; ​
153 rects[5].x = midX - halfWidth; ​
154 rects[5].y = midY - halfHeight; ​
155 rects[5].width = 4; ​
156 rects[5].height = 2*halfHeight - 4; ​
157 219​
158 xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_OVER, effects->xrenderBufferPicture(), 220​ xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_OVER, effects->xrenderBufferPicture(),
159 preMultiply(QColor(128, 128, 128, m_timeline.currentValue()*128)), 6, rects); 221​ preMultiply(color), 6, rects);
160 } 222​ }
161#endif 223​#endif
162 } 224​ }
163 if (effects->compositingType() == QPainterCompositing) { 225​ if (effects->compositingType() == QPainterCompositing) {
164 QPainter *painter = effects->scenePainter(); 226​ QPainter *painter = effects->scenePainter();
165 painter->save(); 227​ painter->save();
166 QColor color; 228​ QColor color = s_lineColor;
167 color.setRedF(0.5); 229​ color.setAlphaF(color.alphaF() * opacityFactor);
168 color.setGreenF(0.5); ​
169 color.setBlueF(0.5); ​
170 color.setAlphaF(m_timeline.currentValue() * 0.5); ​
171 QPen pen(color); 230​ QPen pen(color);
172 pen.setWidth(4); 231​ pen.setWidth(s_lineWidth);
173 painter->setPen(pen); 232​ painter->setPen(pen);
174 painter->setBrush(Qt::NoBrush); 233​ painter->setBrush(Qt::NoBrush);
175 234​
176 for (int i = 0; i < effects->numScreens(); ++i) { 235​ for (int i = 0; i < effects->numScreens(); ++i) {
177 const QRect &rect = effects->clientArea(ScreenArea, i, 0); 236​ const QRect rect = effects->clientArea(ScreenArea, i, 0);
178 // Center lines 237​ // Center lines.
179 painter->drawLine(rect.center().x(), rect.y(), rect.center().x(), rect.y() + rect.height()); 238​ painter->drawLine(rect.center().x(), rect.y(), rect.center().x(), rect.y() + rect.height());
180 painter->drawLine(rect.x(), rect.center().y(), rect.x() + rect.width(), rect.center().y()); 239​ painter->drawLine(rect.x(), rect.center().y(), rect.x() + rect.width(), rect.center().y());
181 240​
182 // window outline 241​ // Window outline.
183 QRect windowRect(rect.center(), m_window->geometry().size()); 242​ QRect outlineRect(0, 0, m_geometry.width(), m_geometry.height());
184 painter->drawRect(windowRect.translated(-windowRect.width()/2, -windowRect.height()/2)); 243​ outlineRect.moveCenter(rect.center());
244​ painter->drawRect(outlineRect);
185 } 245​ }
186 painter->restore(); 246​ painter->restore();
187 } 247​ }
188 } else if (m_window && !m_active) { ​
189 if (m_window->isDeleted()) ​
190 m_window->unrefWindow(); ​
191 m_window = NULL; ​
192 } 248​}
249​
250​void SnapHelperEffect::postPaintScreen()
251​{
252​ if (m_animation.active) {
253​ effects->addRepaint(computeDirtyRegion(m_geometry));
254​ }
255​
256​ if (m_animation.timeLine.done()) {
257​ m_animation.active = false;
258​ }
259​
260​ effects->postPaintScreen();
193} 261​}
194 262​
195void SnapHelperEffect::slotWindowClosed(EffectWindow* w) 263​void SnapHelperEffect::slotWindowClosed(EffectWindow *w)
196{ 264​{
197 if (m_window == w) { 265​ if (w != m_window) {
198 m_window->refWindow(); 266​ return;
199 m_active = false; 267​ }
268​
269​ m_window = nullptr;
270​
271​ m_animation.active = true;
272​ m_animation.timeLine.setDirection(TimeLine::Backward);
273​
274​ if (m_animation.timeLine.done()) {
275​ m_animation.timeLine.reset();
200 } 276​ }
277​
278​ effects->addRepaint(computeDirtyRegion(m_geometry));
201} 279​}
202 280​
203void SnapHelperEffect::slotWindowStartUserMovedResized(EffectWindow *w) 281​void SnapHelperEffect::slotWindowStartUserMovedResized(EffectWindow *w)
204{ 282​{
205 if (w->isMovable()) { 283​ if (!w->isMovable()) {
206 m_active = true; 284​ return;
285​ }
286​
207 m_window = w; 287​ m_window = w;
208 effects->addRepaintFull(); 288​ m_geometry = w->geometry();
289​
290​ m_animation.active = true;
291​ m_animation.timeLine.setDirection(TimeLine::Forward);
292​
293​ if (m_animation.timeLine.done()) {
294​ m_animation.timeLine.reset();
209 } 295​ }
296​
297​ effects->addRepaint(computeDirtyRegion(m_geometry));
210} 298​}
211 299​
212void SnapHelperEffect::slotWindowFinishUserMovedResized(EffectWindow *w) 300​void SnapHelperEffect::slotWindowFinishUserMovedResized(EffectWindow *w)
213{ 301​{
214 Q_UNUSED(w) 302​ if (w != m_window) {
215 if (m_active) { 303​ return;
216 m_active = false; 304​ }
217 effects->addRepaintFull(); 305​
306​ m_window = nullptr;
307​ m_geometry = w->geometry();
308​
309​ m_animation.active = true;
310​ m_animation.timeLine.setDirection(TimeLine::Backward);
311​
312​ if (m_animation.timeLine.done()) {
313​ m_animation.timeLine.reset();
218 } 314​ }
315​
316​ effects->addRepaint(computeDirtyRegion(m_geometry));
219} 317​}
220 318​
221void SnapHelperEffect::slotWindowResized(KWin::EffectWindow *w, const QRect &oldRect) 319​void SnapHelperEffect::slotWindowGeometryShapeChanged(EffectWindow *w, const QRect &old)
222{ 320​{
223 if (w == m_window) { 321​ if (w != m_window) {
224 QRect r(oldRect); 322​ return;
225 for (int i = 0; i < effects->numScreens(); ++i) { ​
226 r.moveCenter(effects->clientArea( ScreenArea, i, 0 ).center()); ​
227 effects->addRepaint(r); ​
228 } ​
229 } 323​ }
324​
325​ m_geometry = w->geometry();
326​
327​ effects->addRepaint(computeDirtyRegion(old));
230} 328​}
231 329​
232bool SnapHelperEffect::isActive() const 330​bool SnapHelperEffect::isActive() const
233{ 331​{
234 return m_active || m_timeline.currentValue() != 0.0; 332​ return m_window != nullptr || m_animation.active;
235} 333​}
236 334​
237} // namespace 335​} // namespace KWin