Differential D18254 Diff 50696 libs/ui/canvas/kis_mirror_axis.cpp

Changeset View

Standalone View

View Options

libs/ui/canvas/kis_mirror_axis.cpp

Show All 21 Lines
22#include "KoConfig.h" 22​#include "KoConfig.h"
23 23​
24#include <QPainter> 24​#include <QPainter>
25#include <QToolButton> 25​#include <QToolButton>
26#include <QApplication> 26​#include <QApplication>
27#include <QPaintEngine> 27​#include <QPaintEngine>
28#include <QOpenGLContext> 28​#include <QOpenGLContext>
29#include <QOpenGLFunctions> 29​#include <QOpenGLFunctions>
30​#include <QAction>
30 31​
31#include <kis_icon.h> 32​#include <kis_icon.h>
32 33​
33#include "kis_canvas2.h" 34​#include "kis_canvas2.h"
34#include "kis_canvas_resource_provider.h" 35​#include "kis_canvas_resource_provider.h"
35#include "KisViewManager.h" 36​#include "KisViewManager.h"
36#include "KisView.h" 37​#include "KisView.h"
37#include "kis_image.h" 38​#include "kis_image.h"
38#include "canvas/kis_canvas_controller.h" 39​#include "canvas/kis_canvas_controller.h"
39#include "input/kis_input_manager.h" 40​#include "input/kis_input_manager.h"
40#include "kis_algebra_2d.h" 41​#include "kis_algebra_2d.h"
41 42​
43​#include <KisMirrorAxisConfig.h>
44​#include <kis_signals_blocker.h>
45​#include <kactioncollection.h>
46​
42class KisMirrorAxis::Private 47​class KisMirrorAxis::Private
43{ 48​{
44public: 49​public:
45 Private(KisMirrorAxis* qq) 50​ Private(KisMirrorAxis* qq)
46 : q(qq) 51​ : q(qq)
47 , resourceProvider(0) 52​ , resourceProvider(0)
48 , mirrorHorizontal(false) ​
49 , mirrorVertical(false) ​
50 , lockHorizontal(false) ​
51 , lockVertical(false) ​
52 , hideVerticalDecoration(false) ​
53 , hideHorizontalDecoration(false) ​
54 , handleSize(32.f) ​
55 , xActive(false) 53​ , xActive(false)
56 , yActive(false) 54​ , yActive(false)
57 , horizontalHandlePosition(64.f) ​
58 , verticalHandlePosition(64.f) ​
59 , sideMargin(10.f) 55​ , sideMargin(10.f)
60 , minHandlePosition(10.f + 32.f) 56​ , minHandlePosition(10.f + 32.f)
61 , horizontalContainsCursor(false) 57​ , horizontalContainsCursor(false)
62 , verticalContainsCursor(false) 58​ , verticalContainsCursor(false)
63 , horizontalAxis(QLineF()) 59​ , horizontalAxis(QLineF())
64 , verticalAxis(QLineF()) 60​ , verticalAxis(QLineF())
61​ , config(KisMirrorAxisConfig())
65 { } 62​ { }
66 63​
67 void setAxisPosition(float x, float y); 64​ void setAxisPosition(float x, float y);
68 void recomputeVisibleAxes(QRect viewport); 65​ void recomputeVisibleAxes(QRect viewport);
69 66​
70 KisMirrorAxis* q; 67​ KisMirrorAxis* q;
71 68​
72 KisCanvasResourceProvider* resourceProvider; 69​ KisCanvasResourceProvider* resourceProvider;
73 KisImageWSP image; 70​ KisImageWSP image;
74 bool mirrorHorizontal; ​
75 bool mirrorVertical; ​
76 ​
77 bool lockHorizontal; ​
78 bool lockVertical; ​
79 bool hideVerticalDecoration; ​
80 bool hideHorizontalDecoration; ​
81 ​
82 71​
83 ​
84 float handleSize; ​
85 QPixmap horizontalHandleIcon; 72​ QPixmap horizontalHandleIcon;
86 QPixmap verticalHandleIcon; 73​ QPixmap verticalHandleIcon;
87 QPixmap horizontalIcon; 74​ QPixmap horizontalIcon;
88 QPixmap verticalIcon; 75​ QPixmap verticalIcon;
89 QPointF axisPosition; 76​
90 QRectF horizontalHandle; 77​ QRectF horizontalHandle;
91 QRectF verticalHandle; 78​ QRectF verticalHandle;
92 bool xActive; 79​ bool xActive;
93 bool yActive; 80​ bool yActive;
94 float horizontalHandlePosition; 81​
95 float verticalHandlePosition; ​
96 float sideMargin; 82​ float sideMargin;
97 float minHandlePosition; 83​ float minHandlePosition;
98 bool horizontalContainsCursor; 84​ bool horizontalContainsCursor;
99 bool verticalContainsCursor; 85​ bool verticalContainsCursor;
100 86​
101 QLineF horizontalAxis; 87​ QLineF horizontalAxis;
102 QLineF verticalAxis; 88​ QLineF verticalAxis;
89​
90​ KisMirrorAxisConfig config;
103}; 91​};
104 92​
105KisMirrorAxis::KisMirrorAxis(KisCanvasResourceProvider* provider, QPointer<KisView>parent) 93​KisMirrorAxis::KisMirrorAxis(KisCanvasResourceProvider* provider, QPointer<KisView>parent)
106 : KisCanvasDecoration("mirror_axis", parent) 94​ : KisCanvasDecoration("mirror_axis", parent)
107 , d(new Private(this)) 95​ , d(new Private(this))
108{ 96​{
109 d->resourceProvider = provider; 97​ d->resourceProvider = provider;
110 connect(d->resourceProvider, SIGNAL(mirrorModeChanged()), SLOT(mirrorModeChanged())); 98​ connect(d->resourceProvider, SIGNAL(mirrorModeChanged()), SLOT(mirrorModeChanged()));
111 connect(d->resourceProvider, SIGNAL(moveMirrorVerticalCenter()), SLOT(moveVerticalAxisToCenter())); 99​ connect(d->resourceProvider, SIGNAL(moveMirrorVerticalCenter()), SLOT(moveVerticalAxisToCenter()));
112 connect(d->resourceProvider, SIGNAL(moveMirrorHorizontalCenter()), SLOT(moveHorizontalAxisToCenter())); 100​ connect(d->resourceProvider, SIGNAL(moveMirrorHorizontalCenter()), SLOT(moveHorizontalAxisToCenter()));
113 101​
114 d->mirrorHorizontal = d->resourceProvider->mirrorHorizontal(); 102​ d->config.setMirrorHorizontal(d->resourceProvider->mirrorHorizontal());
115 d->mirrorVertical = d->resourceProvider->mirrorVertical(); 103​ d->config.setMirrorVertical(d->resourceProvider->mirrorVertical());
116 d->horizontalIcon = KisIconUtils::loadIcon("mirrorAxis-HorizontalMove").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 104​ d->horizontalIcon = KisIconUtils::loadIcon("mirrorAxis-HorizontalMove").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
117 d->verticalIcon = KisIconUtils::loadIcon("mirrorAxis-VerticalMove").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 105​ d->verticalIcon = KisIconUtils::loadIcon("mirrorAxis-VerticalMove").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
118 d->horizontalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 106​ d->horizontalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
119 d->verticalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 107​ d->verticalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
120 setVisible(d->mirrorHorizontal || d->mirrorVertical); 108​ setVisible(d->config.mirrorHorizontal() || d->config.mirrorVertical());
121 ​
122 109​
123 d->image = parent->canvasBase()->image(); 110​ d->image = parent->canvasBase()->image();
124} 111​}
125 112​
126KisMirrorAxis::~KisMirrorAxis() 113​KisMirrorAxis::~KisMirrorAxis()
127{ 114​{
128 delete d; 115​ delete d;
129} 116​}
130 117​
131float KisMirrorAxis::handleSize() const 118​float KisMirrorAxis::handleSize() const
132{ 119​{
133 return d->handleSize; 120​ return d->config.handleSize();
134} 121​}
135 122​
136void KisMirrorAxis::setHandleSize(float newSize) 123​void KisMirrorAxis::setHandleSize(float newSize)
137{ 124​{
138 if(d->handleSize != newSize) { 125​ if(d->config.handleSize() != newSize) {
139 d->handleSize = newSize; 126​ d->config.setHandleSize(newSize);
140 d->horizontalIcon = KisIconUtils::loadIcon("symmetry-horyzontal").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 127​ d->horizontalIcon = KisIconUtils::loadIcon("symmetry-horyzontal").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
141 d->verticalIcon = KisIconUtils::loadIcon("symmetry-vertical").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 128​ d->verticalIcon = KisIconUtils::loadIcon("symmetry-vertical").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
142 d->horizontalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 129​ d->horizontalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
143 d->verticalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->handleSize, QIcon::Normal, QIcon::On); 130​ d->verticalHandleIcon = KisIconUtils::loadIcon("transform-move").pixmap(d->config.handleSize(), QIcon::Normal, QIcon::On);
144 d->minHandlePosition = d->sideMargin + newSize; 131​ d->minHandlePosition = d->sideMargin + newSize;
145 emit handleSizeChanged(); 132​ emit handleSizeChanged();
133​ emit sigConfigChanged();
146 } 134​ }
147} 135​}
148 136​
149void KisMirrorAxis::drawDecoration(QPainter& gc, const QRectF& updateArea, const KisCoordinatesConverter* converter, KisCanvas2* canvas) 137​void KisMirrorAxis::drawDecoration(QPainter& gc, const QRectF& updateArea, const KisCoordinatesConverter* converter, KisCanvas2* canvas)
150{ 138​{
151 Q_UNUSED(updateArea); 139​ Q_UNUSED(updateArea);
152 Q_UNUSED(converter); 140​ Q_UNUSED(converter);
153 Q_UNUSED(canvas); 141​ Q_UNUSED(canvas);
154 142​
143​ if (!view()->isCurrent()) {
144​ return;
145​ }
146​
155 gc.save(); 147​ gc.save();
156 gc.setPen(QPen(QColor(0, 0, 0, 128), 1)); 148​ gc.setPen(QPen(QColor(0, 0, 0, 128), 1));
157 gc.setBrush(Qt::white); 149​ gc.setBrush(Qt::white);
158 gc.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform); 150​ gc.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
159 151​
160 QOpenGLContext *ctx = QOpenGLContext::currentContext(); 152​ QOpenGLContext *ctx = QOpenGLContext::currentContext();
161 bool hasMultisample = ((gc.paintEngine()->type() == QPaintEngine::OpenGL2) && 153​ bool hasMultisample = ((gc.paintEngine()->type() == QPaintEngine::OpenGL2) &&
162 (ctx->hasExtension("GL_ARB_multisample"))); 154​ (ctx->hasExtension("GL_ARB_multisample")));
163 155​
164 // QPainter cannot anti-alias the edges of circles etc. when using OpenGL 156​ // QPainter cannot anti-alias the edges of circles etc. when using OpenGL
165 // So instead, use native OpenGL anti-aliasing when available. 157​ // So instead, use native OpenGL anti-aliasing when available.
166 if (hasMultisample) { 158​ if (hasMultisample) {
167 gc.beginNativePainting(); 159​ gc.beginNativePainting();
168 ctx->functions()->glEnable(GL_MULTISAMPLE); 160​ ctx->functions()->glEnable(GL_MULTISAMPLE);
169 gc.endNativePainting(); 161​ gc.endNativePainting();
170 } 162​ }
171 163​
172 float halfHandleSize = d->handleSize / 2; 164​ float halfHandleSize = d->config.handleSize() / 2;
173 165​
174 d->recomputeVisibleAxes(gc.viewport()); 166​ d->recomputeVisibleAxes(gc.viewport());
175 167​
176 if(d->mirrorHorizontal && !d->hideHorizontalDecoration) { 168​ if(d->config.mirrorHorizontal() && !d->config.hideHorizontalDecoration()) {
177 if (!d->horizontalAxis.isNull()) { 169​ if (!d->horizontalAxis.isNull()) {
178 // QPointF horizontalIndicatorCenter = d->horizontalAxis.unitVector().pointAt(15); 170​ // QPointF horizontalIndicatorCenter = d->horizontalAxis.unitVector().pointAt(15);
179 // QRectF horizontalIndicator = QRectF(horizontalIndicatorCenter.x() - halfHandleSize, horizontalIndicatorCenter.y() - halfHandleSize, d->handleSize, d->handleSize); 171​ // QRectF horizontalIndicator = QRectF(horizontalIndicatorCenter.x() - halfHandleSize, horizontalIndicatorCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
180 172​
181 float horizontalHandlePosition = qBound<float>(d->minHandlePosition, d->horizontalHandlePosition, d->horizontalAxis.length() - d->minHandlePosition); 173​ float horizontalHandlePosition = qBound<float>(d->minHandlePosition, d->config.horizontalHandlePosition(), d->horizontalAxis.length() - d->minHandlePosition);
182 QPointF horizontalHandleCenter = d->horizontalAxis.unitVector().pointAt(horizontalHandlePosition); 174​ QPointF horizontalHandleCenter = d->horizontalAxis.unitVector().pointAt(horizontalHandlePosition);
183 d->horizontalHandle = QRectF(horizontalHandleCenter.x() - halfHandleSize, horizontalHandleCenter.y() - halfHandleSize, d->handleSize, d->handleSize); 175​ d->horizontalHandle = QRectF(horizontalHandleCenter.x() - halfHandleSize, horizontalHandleCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
184 176​
185 gc.setPen(QPen(QColor(0, 0, 0, 64), 2, Qt::DashDotDotLine, Qt::RoundCap, Qt::RoundJoin)); 177​ gc.setPen(QPen(QColor(0, 0, 0, 64), 2, Qt::DashDotDotLine, Qt::RoundCap, Qt::RoundJoin));
186 gc.drawLine(d->horizontalAxis); 178​ gc.drawLine(d->horizontalAxis);
187 179​
188 // gc.drawEllipse(horizontalIndicator); 180​ // gc.drawEllipse(horizontalIndicator);
189 // gc.drawPixmap(horizontalIndicator.adjusted(5, 5, -5, -5).toRect(), d->horizontalIcon); 181​ // gc.drawPixmap(horizontalIndicator.adjusted(5, 5, -5, -5).toRect(), d->horizontalIcon);
190 182​
191 // don't draw the handles if we are locking the axis for movement 183​ // don't draw the handles if we are locking the axis for movement
192 if (!d->lockHorizontal) { 184​ if (!d->config.lockHorizontal()) {
193 gc.setPen(QPen(QColor(0, 0, 0, 128), 2)); 185​ gc.setPen(QPen(QColor(0, 0, 0, 128), 2));
194 gc.drawEllipse(d->horizontalHandle); 186​ gc.drawEllipse(d->horizontalHandle);
195 gc.drawPixmap(d->horizontalHandle.adjusted(5, 5, -5, -5).toRect(), d->horizontalIcon); 187​ gc.drawPixmap(d->horizontalHandle.adjusted(5, 5, -5, -5).toRect(), d->horizontalIcon);
196 } 188​ }
197 189​
198 } else { 190​ } else {
199 d->horizontalHandle = QRectF(); 191​ d->horizontalHandle = QRectF();
200 } 192​ }
201 } 193​ }
202 194​
203 if(d->mirrorVertical && !d->hideVerticalDecoration) { 195​ if(d->config.mirrorVertical() && !d->config.hideVerticalDecoration()) {
204 if (!d->verticalAxis.isNull()) { 196​ if (!d->verticalAxis.isNull()) {
205 197​
206 gc.setPen(QPen(QColor(0, 0, 0, 64), 2, Qt::DashDotDotLine, Qt::RoundCap, Qt::RoundJoin)); 198​ gc.setPen(QPen(QColor(0, 0, 0, 64), 2, Qt::DashDotDotLine, Qt::RoundCap, Qt::RoundJoin));
207 gc.drawLine(d->verticalAxis); 199​ gc.drawLine(d->verticalAxis);
208 200​
209 201​
210 // QPointF verticalIndicatorCenter = d->verticalAxis.unitVector().pointAt(15); 202​ // QPointF verticalIndicatorCenter = d->verticalAxis.unitVector().pointAt(15);
211 // QRectF verticalIndicator = QRectF(verticalIndicatorCenter.x() - halfHandleSize, verticalIndicatorCenter.y() - halfHandleSize, d->handleSize, d->handleSize); 203​ // QRectF verticalIndicator = QRectF(verticalIndicatorCenter.x() - halfHandleSize, verticalIndicatorCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
212 204​
213 float verticalHandlePosition = qBound<float>(d->minHandlePosition, d->verticalHandlePosition, d->verticalAxis.length() - d->minHandlePosition); 205​ float verticalHandlePosition = qBound<float>(d->minHandlePosition, d->config.verticalHandlePosition(), d->verticalAxis.length() - d->minHandlePosition);
214 QPointF verticalHandleCenter = d->verticalAxis.unitVector().pointAt(verticalHandlePosition); 206​ QPointF verticalHandleCenter = d->verticalAxis.unitVector().pointAt(verticalHandlePosition);
215 d->verticalHandle = QRectF(verticalHandleCenter.x() - halfHandleSize, verticalHandleCenter.y() - halfHandleSize, d->handleSize, d->handleSize); 207​ d->verticalHandle = QRectF(verticalHandleCenter.x() - halfHandleSize, verticalHandleCenter.y() - halfHandleSize, d->config.handleSize(), d->config.handleSize());
216 208​
217 // don't draw the handles if we are locking the axis for movement 209​ // don't draw the handles if we are locking the axis for movement
218 if (!d->lockVertical) { 210​ if (!d->config.lockVertical()) {
219 gc.setPen(QPen(QColor(0, 0, 0, 128), 2)); 211​ gc.setPen(QPen(QColor(0, 0, 0, 128), 2));
220 gc.drawEllipse(d->verticalHandle); 212​ gc.drawEllipse(d->verticalHandle);
221 gc.drawPixmap(d->verticalHandle.adjusted(5, 5, -5, -5).toRect(), d->verticalIcon); 213​ gc.drawPixmap(d->verticalHandle.adjusted(5, 5, -5, -5).toRect(), d->verticalIcon);
222 } 214​ }
223 215​
224 } else { 216​ } else {
225 d->verticalHandle = QRectF(); 217​ d->verticalHandle = QRectF();
226 } 218​ }
Show All 18 Lines232{
245 237​
246 if (!expectedCanvasWidget || target != expectedCanvasWidget) return false; 238​ if (!expectedCanvasWidget || target != expectedCanvasWidget) return false;
247 239​
248 if(event->type() == QEvent::MouseButtonPress || event->type() == QEvent::TabletPress) { 240​ if(event->type() == QEvent::MouseButtonPress || event->type() == QEvent::TabletPress) {
249 QMouseEvent *me = dynamic_cast<QMouseEvent*>(event); 241​ QMouseEvent *me = dynamic_cast<QMouseEvent*>(event);
250 QTabletEvent *te = dynamic_cast<QTabletEvent*>(event); 242​ QTabletEvent *te = dynamic_cast<QTabletEvent*>(event);
251 QPoint pos = me ? me->pos() : (te ? te->pos() : QPoint(77,77)); 243​ QPoint pos = me ? me->pos() : (te ? te->pos() : QPoint(77,77));
252 244​
253 245​ if(d->config.mirrorHorizontal() && d->horizontalHandle.contains(pos) && !d->config.lockHorizontal() && !d->config.hideHorizontalDecoration() ) {
254 ​
255 ​
256 if(d->mirrorHorizontal && d->horizontalHandle.contains(pos) && !d->lockHorizontal && !d->hideHorizontalDecoration ) { ​
257 d->xActive = true; 246​ d->xActive = true;
258 QApplication::setOverrideCursor(Qt::ClosedHandCursor); 247​ QApplication::setOverrideCursor(Qt::ClosedHandCursor);
259 event->accept(); 248​ event->accept();
260 return true; 249​ return true;
261 } 250​ }
262 251​
263 if(d->mirrorVertical && d->verticalHandle.contains(pos) && !d->lockVertical && !d->hideVerticalDecoration) { 252​ if(d->config.mirrorVertical() && d->verticalHandle.contains(pos) && !d->config.lockVertical() && !d->config.hideVerticalDecoration()) {
264 d->yActive = true; 253​ d->yActive = true;
265 QApplication::setOverrideCursor(Qt::ClosedHandCursor); 254​ QApplication::setOverrideCursor(Qt::ClosedHandCursor);
266 event->accept(); 255​ event->accept();
267 return true; 256​ return true;
268 } 257​ }
269 } 258​ }
270 if(event->type() == QEvent::MouseMove || event->type() == QEvent::TabletMove) { 259​ if(event->type() == QEvent::MouseMove || event->type() == QEvent::TabletMove) {
271 QMouseEvent *me = dynamic_cast<QMouseEvent*>(event); 260​ QMouseEvent *me = dynamic_cast<QMouseEvent*>(event);
272 QTabletEvent *te = dynamic_cast<QTabletEvent*>(event); 261​ QTabletEvent *te = dynamic_cast<QTabletEvent*>(event);
273 262​
274 QPoint pos = me ? me->pos() : (te ? te->pos() : QPoint(77,77)); 263​ QPoint pos = me ? me->pos() : (te ? te->pos() : QPoint(77,77));
275 264​
276 if(d->xActive) { 265​ if(d->xActive) {
277 float axisX = view()->viewConverter()->widgetToImage<QPoint>(pos).x(); 266​ float axisX = view()->viewConverter()->widgetToImage<QPoint>(pos).x();
278 267​
279 d->setAxisPosition(axisX, d->axisPosition.y()); 268​ d->setAxisPosition(axisX, d->config.axisPosition().y());
280 d->horizontalHandlePosition = KisAlgebra2D::dotProduct<QPointF>(pos - d->horizontalAxis.p1(), d->horizontalAxis.unitVector().p2() - d->horizontalAxis.p1()); 269​ d->config.setHorizontalHandlePosition(KisAlgebra2D::dotProduct<QPointF>(pos - d->horizontalAxis.p1(), d->horizontalAxis.unitVector().p2() - d->horizontalAxis.p1()));
270​ emit sigConfigChanged();
281 271​
282 event->accept(); 272​ event->accept();
283 return true; 273​ return true;
284 } 274​ }
285 if(d->yActive) { 275​ if(d->yActive) {
286 float axisY = view()->viewConverter()->widgetToImage<QPoint>(pos).y(); 276​ float axisY = view()->viewConverter()->widgetToImage<QPoint>(pos).y();
287 277​
288 d->setAxisPosition(d->axisPosition.x(), axisY); 278​ d->setAxisPosition(d->config.axisPosition().x(), axisY);
289 d->verticalHandlePosition = KisAlgebra2D::dotProduct<QPointF>(pos - d->verticalAxis.p1(), d->verticalAxis.unitVector().p2() - d->verticalAxis.p1()); 279​ d->config.setVerticalHandlePosition(KisAlgebra2D::dotProduct<QPointF>(pos - d->verticalAxis.p1(), d->verticalAxis.unitVector().p2() - d->verticalAxis.p1()));
280​ emit sigConfigChanged();
290 281​
291 event->accept(); 282​ event->accept();
292 return true; 283​ return true;
293 } 284​ }
294 if(d->mirrorHorizontal && !d->hideHorizontalDecoration) { 285​ if(d->config.mirrorHorizontal() && !d->config.hideHorizontalDecoration()) {
295 if(d->horizontalHandle.contains(pos) && !d->lockHorizontal) { 286​ if(d->horizontalHandle.contains(pos) && !d->config.lockHorizontal()) {
296 if(!d->horizontalContainsCursor) { 287​ if(!d->horizontalContainsCursor) {
297 QApplication::setOverrideCursor(Qt::OpenHandCursor); 288​ QApplication::setOverrideCursor(Qt::OpenHandCursor);
298 d->horizontalContainsCursor = true; 289​ d->horizontalContainsCursor = true;
299 } 290​ }
300 } else if(d->horizontalContainsCursor) { 291​ } else if(d->horizontalContainsCursor) {
301 QApplication::restoreOverrideCursor(); 292​ QApplication::restoreOverrideCursor();
302 d->horizontalContainsCursor = false; 293​ d->horizontalContainsCursor = false;
303 } 294​ }
304 } 295​ }
305 if(d->mirrorVertical && !d->hideVerticalDecoration) { 296​ if(d->config.mirrorVertical() && !d->config.hideVerticalDecoration()) {
306 if(d->verticalHandle.contains(pos) && !d->lockVertical) { 297​ if(d->verticalHandle.contains(pos) && !d->config.lockVertical()) {
307 if(!d->verticalContainsCursor) { 298​ if(!d->verticalContainsCursor) {
308 QApplication::setOverrideCursor(Qt::OpenHandCursor); 299​ QApplication::setOverrideCursor(Qt::OpenHandCursor);
309 d->verticalContainsCursor = true; 300​ d->verticalContainsCursor = true;
310 } 301​ }
311 } else if(d->verticalContainsCursor) { 302​ } else if(d->verticalContainsCursor) {
312 QApplication::restoreOverrideCursor(); 303​ QApplication::restoreOverrideCursor();
313 d->verticalContainsCursor = false; 304​ d->verticalContainsCursor = false;
314 } 305​ }
Show All 15 Lines308 if(event->type() == QEvent::MouseButtonRelease || event->type() == QEvent::TabletRelease) {
330 } 321​ }
331 } 322​ }
332 323​
333 return QObject::eventFilter(target, event); 324​ return QObject::eventFilter(target, event);
334} 325​}
335 326​
336void KisMirrorAxis::mirrorModeChanged() 327​void KisMirrorAxis::mirrorModeChanged()
337{ 328​{
338 d->mirrorHorizontal = d->resourceProvider->mirrorHorizontal(); 329​ if (!view()->isCurrent()) {
339 d->mirrorVertical = d->resourceProvider->mirrorVertical(); 330​ return;
331​ }
332​
333​ d->config.setMirrorHorizontal(d->resourceProvider->mirrorHorizontal());
334​ d->config.setMirrorVertical(d->resourceProvider->mirrorVertical());
340 335​
341 d->lockHorizontal = d->resourceProvider->mirrorHorizontalLock(); 336​ d->config.setLockHorizontal(d->resourceProvider->mirrorHorizontalLock());
342 d->lockVertical = d->resourceProvider->mirrorVerticalLock(); 337​ d->config.setLockVertical(d->resourceProvider->mirrorVerticalLock());
343 338​
344 d->hideHorizontalDecoration = d->resourceProvider->mirrorHorizontalHideDecorations(); 339​ d->config.setHideHorizontalDecoration(d->resourceProvider->mirrorHorizontalHideDecorations());
345 d->hideVerticalDecoration = d->resourceProvider->mirrorVerticalHideDecorations(); 340​ d->config.setHideVerticalDecoration(d->resourceProvider->mirrorVerticalHideDecorations());
346 341​
347 setVisible(d->mirrorHorizontal || d->mirrorVertical); 342​ setVisible(d->config.mirrorHorizontal() || d->config.mirrorVertical());
348 343​
344​ emit sigConfigChanged();
349} 345​}
350 346​
351void KisMirrorAxis::setVisible(bool v) 347​void KisMirrorAxis::setVisible(bool v)
352{ 348​{
353 KisCanvasDecoration::setVisible(v); 349​ KisCanvasDecoration::setVisible(v);
354 350​
355 351​
356 KisInputManager *inputManager = view() ? view()->canvasBase()->globalInputManager() : 0; 352​ KisInputManager *inputManager = view() ? view()->canvasBase()->globalInputManager() : 0;
357 if (!inputManager) return; 353​ if (!inputManager) return;
358 354​
359 if (v) { 355​ if (v) {
360 inputManager->attachPriorityEventFilter(this); 356​ inputManager->attachPriorityEventFilter(this);
361 } else { 357​ } else {
362 inputManager->detachPriorityEventFilter(this); 358​ inputManager->detachPriorityEventFilter(this);
363 } 359​ }
364} 360​}
365 361​
362​void KisMirrorAxis::setMirrorAxisConfig(const KisMirrorAxisConfig &config)
363​{
364​ if (config == d->config) {
365​ return;
366​ }
367​
368​ KisSignalsBlocker blocker(d->resourceProvider);
369​
370​ d->config = config;
371​
372​ d->setAxisPosition(d->config.axisPosition().x(), d->config.axisPosition().y());
373​
374​ d->resourceProvider->setMirrorHorizontal(d->config.mirrorHorizontal());
375​ d->resourceProvider->setMirrorVertical(d->config.mirrorVertical());
376​
377​ d->resourceProvider->setMirrorHorizontalLock(d->config.lockHorizontal());
378​ d->resourceProvider->setMirrorVerticalLock(d->config.lockVertical());
379​
380​ d->resourceProvider->setMirrorHorizontal(d->config.mirrorHorizontal());
381​ d->resourceProvider->setMirrorVertical(d->config.mirrorVertical());
382​
383​ d->resourceProvider->setMirrorHorizontalHideDecorations(d->config.hideHorizontalDecoration());
384​ d->resourceProvider->setMirrorVerticalHideDecorations(d->config.hideVerticalDecoration());
385​
386​
387​ KActionCollection* collection = view()->viewManager()->actionCollection();
388​ collection->action("hmirror_action")->setChecked(d->config.mirrorHorizontal());
389​ collection->action("vmirror_action")->setChecked(d->config.mirrorVertical());
390​
391​ collection->action("mirrorX-lock")->setChecked(d->config.lockHorizontal());
392​ collection->action("mirrorY-lock")->setChecked(d->config.lockVertical());
393​
394​ collection->action("mirrorX-hideDecorations")->setChecked(d->config.hideHorizontalDecoration());
395​ collection->action("mirrorY-hideDecorations")->setChecked(d->config.hideVerticalDecoration());
396​
397​
398​ setVisible(d->config.mirrorHorizontal() || d->config.mirrorVertical());
399​}
400​
401​const KisMirrorAxisConfig &KisMirrorAxis::mirrorAxisConfig() const
402​{
403​ return d->config;
404​}
405​
366void KisMirrorAxis::moveHorizontalAxisToCenter() 406​void KisMirrorAxis::moveHorizontalAxisToCenter()
367{ 407​{
368 d->setAxisPosition(d->image->width()/2, d->axisPosition.y()); 408​ if (!view()->isCurrent()) {
409​ return;
410​ }
411​
412​ d->setAxisPosition(d->image->width()/2, d->config.axisPosition().y());
413​ emit sigConfigChanged();
369} 414​}
370 415​
371void KisMirrorAxis::moveVerticalAxisToCenter() 416​void KisMirrorAxis::moveVerticalAxisToCenter()
372{ 417​{
373 d->setAxisPosition(d->axisPosition.x(), d->image->height()/2 ); 418​ if (!view()->isCurrent()) {
419​ return;
420​ }
421​
422​ d->setAxisPosition(d->config.axisPosition().x(), d->image->height()/2 );
423​ emit sigConfigChanged();
374} 424​}
375 425​
376 426​
377void KisMirrorAxis::Private::setAxisPosition(float x, float y) 427​void KisMirrorAxis::Private::setAxisPosition(float x, float y)
378{ 428​{
379 QPointF newPosition = QPointF(x, y); 429​ QPointF newPosition = QPointF(x, y);
380 430​
431​ config.setAxisPosition(newPosition);
432​
381 const QPointF relativePosition = KisAlgebra2D::absoluteToRelative(newPosition, image->bounds()); 433​ const QPointF relativePosition = KisAlgebra2D::absoluteToRelative(newPosition, image->bounds());
382 image->setMirrorAxesCenter(relativePosition); 434​ image->setMirrorAxesCenter(relativePosition);
383 435​
384 q->view()->canvasBase()->updateCanvas(); 436​ q->view()->canvasBase()->updateCanvas();
385} 437​}
386 438​
387 439​
388void KisMirrorAxis::Private::recomputeVisibleAxes(QRect viewport) 440​void KisMirrorAxis::Private::recomputeVisibleAxes(QRect viewport)
389{ 441​{
390 KisCoordinatesConverter *converter = q->view()->viewConverter(); 442​ KisCoordinatesConverter *converter = q->view()->viewConverter();
391 443​
392 axisPosition = KisAlgebra2D::relativeToAbsolute(image->mirrorAxesCenter(), image->bounds()); 444​ config.setAxisPosition(KisAlgebra2D::relativeToAbsolute(image->mirrorAxesCenter(), image->bounds()));
393 445​
394 QPointF samplePt1 = converter->imageToWidget<QPointF>(axisPosition); 446​ QPointF samplePt1 = converter->imageToWidget<QPointF>(config.axisPosition());
395 QPointF samplePt2 = converter->imageToWidget<QPointF>(QPointF(axisPosition.x(), axisPosition.y() - 100)); 447​ QPointF samplePt2 = converter->imageToWidget<QPointF>(QPointF(config.axisPosition().x(), config.axisPosition().y() - 100));
396 448​
397 horizontalAxis = QLineF(samplePt1, samplePt2); 449​ horizontalAxis = QLineF(samplePt1, samplePt2);
398 if (!KisAlgebra2D::intersectLineRect(horizontalAxis, viewport)) horizontalAxis = QLineF(); 450​ if (!KisAlgebra2D::intersectLineRect(horizontalAxis, viewport)) horizontalAxis = QLineF();
399 451​
400 samplePt2 = converter->imageToWidget<QPointF>(QPointF(axisPosition.x() - 100, axisPosition.y())); 452​ samplePt2 = converter->imageToWidget<QPointF>(QPointF(config.axisPosition().x() - 100, config.axisPosition().y()));
401 verticalAxis = QLineF(samplePt1, samplePt2); 453​ verticalAxis = QLineF(samplePt1, samplePt2);
402 if (!KisAlgebra2D::intersectLineRect(verticalAxis, viewport)) verticalAxis = QLineF(); 454​ if (!KisAlgebra2D::intersectLineRect(verticalAxis, viewport)) verticalAxis = QLineF();
403} 455​}
404 456​