Rev 24003 | Rev 25014 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
20593 | jghali | 1 | /* |
2 | For general Scribus (>=1.3.2) copyright and licensing information please refer |
||
3 | to the COPYING file provided with the program. Following this notice may exist |
||
4 | a copyright and/or license notice that predates the release of Scribus 1.3.2 |
||
5 | for which a new license (GPL+exception) is in place. |
||
6 | */ |
||
7 | /*************************************************************************** |
||
8 | * * |
||
9 | * This program is free software; you can redistribute it and/or modify * |
||
10 | * it under the terms of the GNU General Public License as published by * |
||
11 | * the Free Software Foundation; either version 2 of the License, or * |
||
12 | * (at your option) any later version. * |
||
13 | * * |
||
14 | ***************************************************************************/ |
||
15 | |||
16 | |||
17 | #include "canvasmode_editgradient.h" |
||
18 | |||
19 | #include <QApplication> |
||
20 | #include <QButtonGroup> |
||
21 | #include <QCheckBox> |
||
22 | #include <QCursor> |
||
23 | #include <QEvent> |
||
24 | #include <QMessageBox> |
||
25 | #include <QMouseEvent> |
||
26 | #include <QPainterPath> |
||
27 | #include <QPoint> |
||
28 | #include <QRect> |
||
29 | #include <QTimer> |
||
30 | #include <QWidgetAction> |
||
31 | #include <QDebug> |
||
32 | |||
33 | #include "appmodes.h" |
||
34 | #include "canvas.h" |
||
35 | #include "fpoint.h" |
||
36 | #include "fpointarray.h" |
||
37 | #include "hyphenator.h" |
||
38 | #include "pageitem_textframe.h" |
||
39 | #include "prefscontext.h" |
||
40 | #include "prefsfile.h" |
||
41 | #include "prefsmanager.h" |
||
42 | #include "scribus.h" |
||
43 | #include "scribusXml.h" |
||
44 | #include "scribusdoc.h" |
||
45 | #include "scribusview.h" |
||
46 | #include "selection.h" |
||
47 | #include "ui/aligndistribute.h" |
||
48 | #include "ui/contextmenu.h" |
||
49 | #include "ui/pageselector.h" |
||
50 | #include "ui/propertiespalette.h" |
||
51 | #include "undomanager.h" |
||
52 | #include "units.h" |
||
53 | #include "util.h" |
||
54 | #include "util_math.h" |
||
55 | |||
56 | |||
57 | CanvasMode_EditGradient::CanvasMode_EditGradient(ScribusView* view) : CanvasMode(view), m_ScMW(view->m_ScMW) |
||
58 | { |
||
23612 | craig | 59 | |
20593 | jghali | 60 | } |
61 | |||
62 | inline bool CanvasMode_EditGradient::GetItem(PageItem** pi) |
||
63 | { |
||
64 | *pi = m_doc->m_Selection->itemAt(0); |
||
22528 | craig | 65 | return (*pi) != nullptr; |
20593 | jghali | 66 | } |
67 | |||
68 | void CanvasMode_EditGradient::drawControls(QPainter* p) |
||
69 | { |
||
70 | if (m_canvas->m_viewMode.operItemMoving) |
||
71 | { |
||
72 | drawOutline(p); |
||
73 | } |
||
74 | else |
||
75 | { |
||
76 | drawSelection(p, false); |
||
77 | } |
||
78 | if (m_doc->appMode == modeEditGradientVectors) |
||
79 | { |
||
80 | drawControlsGradientVectors(p, m_doc->m_Selection->itemAt(0)); |
||
81 | } |
||
82 | } |
||
83 | |||
84 | void CanvasMode_EditGradient::drawControlsGradientVectors(QPainter* psx, PageItem *currItem) |
||
85 | { |
||
86 | psx->setTransform(currItem->getTransform(), true); |
||
87 | psx->setPen(QPen(Qt::blue, 1.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); |
||
88 | psx->setBrush(Qt::NoBrush); |
||
89 | if (m_view->editStrokeGradient == 1) |
||
90 | { |
||
91 | psx->drawLine(QPointF(currItem->GrStrokeStartX, currItem->GrStrokeStartY), QPointF(currItem->GrStrokeEndX, currItem->GrStrokeEndY)); |
||
92 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
93 | psx->drawPoint(QPointF(currItem->GrStrokeStartX, currItem->GrStrokeStartY)); |
||
94 | psx->drawPoint(QPointF(currItem->GrStrokeEndX, currItem->GrStrokeEndY)); |
||
95 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
96 | double rotEnd = xy2Deg(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
97 | QTransform qmatrix; |
||
98 | qmatrix.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
99 | qmatrix.rotate(rotEnd); |
||
100 | double mask_gradientSkew = 0.0; |
||
101 | if (currItem->GrStrokeSkew == 90) |
||
102 | mask_gradientSkew = 1; |
||
103 | else if (currItem->GrStrokeSkew == 180) |
||
104 | mask_gradientSkew = 0; |
||
105 | else if (currItem->GrStrokeSkew == 270) |
||
106 | mask_gradientSkew = -1; |
||
107 | else if (currItem->GrStrokeSkew == 390) |
||
108 | mask_gradientSkew = 0; |
||
109 | else |
||
110 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrStrokeSkew); |
||
111 | qmatrix.shear(mask_gradientSkew, 0); |
||
112 | qmatrix.translate(0, currItem->GrStrokeStartY * (1.0 - currItem->GrStrokeScale)); |
||
113 | qmatrix.translate(-currItem->GrStrokeStartX, -currItem->GrStrokeStartY); |
||
114 | qmatrix.scale(1, currItem->GrStrokeScale); |
||
23904 | jghali | 115 | if (currItem->GrTypeStroke == Gradient_Radial) |
20593 | jghali | 116 | psx->drawPoint(qmatrix.map(QPointF(currItem->GrStrokeFocalX, currItem->GrStrokeFocalY))); |
117 | QTransform m; |
||
118 | m.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
119 | m.rotate(rotEnd); |
||
120 | m.rotate(-90); |
||
121 | m.rotate(currItem->GrStrokeSkew); |
||
122 | m.translate(radEnd * currItem->GrStrokeScale, 0); |
||
123 | QPointF shP = m.map(QPointF(0,0)); |
||
124 | psx->setPen(QPen(Qt::blue, 1.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); |
||
125 | psx->drawLine(QPointF(currItem->GrStrokeStartX, currItem->GrStrokeStartY), shP); |
||
126 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
127 | psx->drawPoint(shP); |
||
128 | } |
||
129 | else if (m_view->editStrokeGradient == 2) |
||
130 | { |
||
131 | psx->drawLine(QPointF(currItem->GrMaskStartX, currItem->GrMaskStartY), QPointF(currItem->GrMaskEndX, currItem->GrMaskEndY)); |
||
132 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
133 | psx->drawPoint(QPointF(currItem->GrMaskStartX, currItem->GrMaskStartY)); |
||
134 | psx->drawPoint(QPointF(currItem->GrMaskEndX, currItem->GrMaskEndY)); |
||
135 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
136 | double rotEnd = xy2Deg(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
137 | QTransform qmatrix; |
||
138 | qmatrix.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
139 | qmatrix.rotate(rotEnd); |
||
140 | double mask_gradientSkew = 0.0; |
||
141 | if (currItem->GrMaskSkew == 90) |
||
142 | mask_gradientSkew = 1; |
||
143 | else if (currItem->GrMaskSkew == 180) |
||
144 | mask_gradientSkew = 0; |
||
145 | else if (currItem->GrMaskSkew == 270) |
||
146 | mask_gradientSkew = -1; |
||
147 | else if (currItem->GrMaskSkew == 390) |
||
148 | mask_gradientSkew = 0; |
||
149 | else |
||
150 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrMaskSkew); |
||
151 | qmatrix.shear(mask_gradientSkew, 0); |
||
152 | qmatrix.translate(0, currItem->GrMaskStartY * (1.0 - currItem->GrMaskScale)); |
||
153 | qmatrix.translate(-currItem->GrMaskStartX, -currItem->GrMaskStartY); |
||
154 | qmatrix.scale(1, currItem->GrMaskScale); |
||
23907 | jghali | 155 | if ((currItem->GrMask == GradMask_Radial) || (currItem->GrMask == GradMask_RadialLumAlpha)) |
20593 | jghali | 156 | psx->drawPoint(qmatrix.map(QPointF(currItem->GrMaskFocalX, currItem->GrMaskFocalY))); |
157 | QTransform m; |
||
158 | m.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
159 | m.rotate(rotEnd); |
||
160 | m.rotate(-90); |
||
161 | m.rotate(currItem->GrMaskSkew); |
||
162 | m.translate(radEnd * currItem->GrMaskScale, 0); |
||
163 | QPointF shP = m.map(QPointF(0,0)); |
||
164 | psx->setPen(QPen(Qt::blue, 1.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); |
||
165 | psx->drawLine(QPointF(currItem->GrMaskStartX, currItem->GrMaskStartY), shP); |
||
166 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
167 | psx->drawPoint(shP); |
||
168 | } |
||
169 | else if (m_view->editStrokeGradient == 0) |
||
170 | { |
||
171 | psx->drawLine(QPointF(currItem->GrStartX, currItem->GrStartY), QPointF(currItem->GrEndX, currItem->GrEndY)); |
||
172 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
173 | psx->drawPoint(QPointF(currItem->GrStartX, currItem->GrStartY)); |
||
174 | psx->drawPoint(QPointF(currItem->GrEndX, currItem->GrEndY)); |
||
175 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
176 | double rotEnd = xy2Deg(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
177 | QTransform qmatrix; |
||
178 | qmatrix.translate(currItem->GrStartX, currItem->GrStartY); |
||
179 | qmatrix.rotate(rotEnd); |
||
23904 | jghali | 180 | if (currItem->GrType != Gradient_Conical) |
20593 | jghali | 181 | { |
182 | double mask_gradientSkew = 0.0; |
||
183 | if (currItem->GrSkew == 90) |
||
184 | mask_gradientSkew = 1; |
||
185 | else if (currItem->GrSkew == 180) |
||
186 | mask_gradientSkew = 0; |
||
187 | else if (currItem->GrSkew == 270) |
||
188 | mask_gradientSkew = -1; |
||
189 | else if (currItem->GrSkew == 390) |
||
190 | mask_gradientSkew = 0; |
||
191 | else |
||
192 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrSkew); |
||
193 | qmatrix.shear(mask_gradientSkew, 0); |
||
194 | } |
||
195 | qmatrix.translate(0, currItem->GrStartY * (1.0 - currItem->GrScale)); |
||
196 | qmatrix.translate(-currItem->GrStartX, -currItem->GrStartY); |
||
197 | qmatrix.scale(1, currItem->GrScale); |
||
23904 | jghali | 198 | if ((currItem->GrType == Gradient_Radial) || (currItem->GrType == Gradient_Conical)) |
20593 | jghali | 199 | psx->drawPoint(qmatrix.map(QPointF(currItem->GrFocalX, currItem->GrFocalY))); |
200 | QTransform m; |
||
201 | m.translate(currItem->GrStartX, currItem->GrStartY); |
||
202 | m.rotate(rotEnd); |
||
203 | m.rotate(-90); |
||
204 | m.rotate(currItem->GrSkew); |
||
205 | m.translate(radEnd * currItem->GrScale, 0); |
||
206 | QPointF shP = m.map(QPointF(0,0)); |
||
207 | psx->setPen(QPen(Qt::blue, 1.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); |
||
208 | psx->drawLine(QPointF(currItem->GrStartX, currItem->GrStartY), shP); |
||
209 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
210 | psx->drawPoint(shP); |
||
211 | } |
||
212 | else if (m_view->editStrokeGradient == 3) |
||
213 | { |
||
214 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
215 | psx->drawPoint(QPointF(currItem->GrControl1.x(), currItem->GrControl1.y())); |
||
216 | psx->drawPoint(QPointF(currItem->GrControl2.x(), currItem->GrControl2.y())); |
||
217 | psx->drawPoint(QPointF(currItem->GrControl3.x(), currItem->GrControl3.y())); |
||
218 | psx->drawPoint(QPointF(currItem->GrControl4.x(), currItem->GrControl4.y())); |
||
219 | } |
||
220 | else if (m_view->editStrokeGradient == 4) |
||
221 | { |
||
222 | psx->setPen(QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin)); |
||
223 | psx->drawPoint(QPointF(currItem->GrControl1.x(), currItem->GrControl1.y())); |
||
224 | psx->drawPoint(QPointF(currItem->GrControl2.x(), currItem->GrControl2.y())); |
||
225 | psx->drawPoint(QPointF(currItem->GrControl3.x(), currItem->GrControl3.y())); |
||
226 | psx->drawPoint(QPointF(currItem->GrControl4.x(), currItem->GrControl4.y())); |
||
227 | psx->drawPoint(QPointF(currItem->GrControl5.x(), currItem->GrControl5.y())); |
||
228 | } |
||
229 | } |
||
230 | |||
23763 | jghali | 231 | void CanvasMode_EditGradient::enterEvent(QEvent* /*e*/) |
20593 | jghali | 232 | { |
233 | if (!m_canvas->m_viewMode.m_MouseButtonPressed) |
||
234 | { |
||
235 | setModeCursor(); |
||
236 | } |
||
237 | } |
||
238 | |||
23763 | jghali | 239 | void CanvasMode_EditGradient::leaveEvent(QEvent* /*e*/) |
20593 | jghali | 240 | { |
241 | } |
||
242 | |||
243 | |||
244 | void CanvasMode_EditGradient::activate(bool fromGesture) |
||
245 | { |
||
246 | // qDebug() << "CanvasMode_EditGradient::activate" << fromGesture; |
||
23613 | jghali | 247 | CanvasMode::activate(fromGesture); |
248 | |||
20593 | jghali | 249 | m_canvas->m_viewMode.m_MouseButtonPressed = false; |
250 | m_canvas->resetRenderMode(); |
||
251 | m_doc->DragP = false; |
||
252 | m_doc->leaveDrag = false; |
||
253 | m_canvas->m_viewMode.operItemMoving = false; |
||
254 | m_canvas->m_viewMode.operItemResizing = false; |
||
255 | m_view->MidButt = false; |
||
256 | m_Mxp = m_Myp = -1; |
||
257 | setModeCursor(); |
||
258 | if (fromGesture) |
||
259 | { |
||
260 | m_view->update(); |
||
261 | } |
||
262 | } |
||
263 | |||
264 | void CanvasMode_EditGradient::deactivate(bool forGesture) |
||
265 | { |
||
266 | // qDebug() << "CanvasMode_EditGradient::deactivate" << forGesture; |
||
267 | m_view->setRedrawMarkerShown(false); |
||
23613 | jghali | 268 | CanvasMode::deactivate(forGesture); |
20593 | jghali | 269 | } |
270 | |||
24003 | jghali | 271 | void CanvasMode_EditGradient::keyPressEvent(QKeyEvent *e) |
272 | { |
||
273 | commonkeyPressEvent_Default(e); |
||
274 | } |
||
275 | |||
276 | void CanvasMode_EditGradient::keyReleaseEvent(QKeyEvent *e) |
||
277 | { |
||
278 | commonkeyReleaseEvent(e); |
||
279 | } |
||
280 | |||
20593 | jghali | 281 | void CanvasMode_EditGradient::mouseDoubleClickEvent(QMouseEvent *m) |
282 | { |
||
283 | m->accept(); |
||
284 | m_canvas->m_viewMode.m_MouseButtonPressed = false; |
||
285 | m_canvas->resetRenderMode(); |
||
286 | // m_view->stopDragTimer(); |
||
22599 | craig | 287 | PageItem *currItem = nullptr; |
20593 | jghali | 288 | if ((m_doc->m_Selection->isMultipleSelection()) || (m_doc->appMode != modeNormal)) |
289 | { |
||
290 | if ((m_doc->m_Selection->isMultipleSelection()) && (m_doc->appMode == modeNormal)) |
||
291 | { |
||
292 | if (GetItem(&currItem)) |
||
293 | { |
||
294 | /* CB: old code, removing this as shift-alt select on an unselected table selects a cell now. |
||
295 | //#6789 is closed by sorting this. |
||
296 | if (currItem->isTableItem) |
||
297 | { |
||
298 | m_view->Deselect(false); |
||
299 | m_doc->m_Selection->addItem(currItem); |
||
300 | currItem->isSingleSel = true; |
||
21026 | craig | 301 | //CB FIXME don't call this if the added item is item 0 |
20593 | jghali | 302 | if (!m_doc->m_Selection->primarySelectionIs(currItem)) |
303 | currItem->emitAllToGUI(); |
||
304 | m_view->updateContents(currItem->getRedrawBounding(m_canvas->scale())); |
||
305 | }*/ |
||
306 | } |
||
307 | return; |
||
308 | } |
||
23797 | jghali | 309 | if (!(GetItem(&currItem) && (m_doc->appMode == modeEdit) && currItem->isTextFrame())) |
20593 | jghali | 310 | { |
22638 | craig | 311 | mousePressEvent(m); |
312 | return; |
||
20593 | jghali | 313 | } |
314 | } |
||
315 | } |
||
316 | |||
317 | void CanvasMode_EditGradient::mouseMoveEvent(QMouseEvent *m) |
||
318 | { |
||
319 | const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos()); |
||
320 | m->accept(); |
||
321 | if (m_gradientPoint == noPointDefined) |
||
322 | return; |
||
323 | |||
324 | if (m_canvas->m_viewMode.m_MouseButtonPressed) |
||
325 | { |
||
326 | PageItem *currItem = m_doc->m_Selection->itemAt(0); |
||
327 | double newX = mousePointDoc.x(); //m->x(); |
||
328 | double newY = mousePointDoc.y(); //m->y(); |
||
329 | FPoint npx(m_Mxp - newX, m_Myp - newY, 0, 0, currItem->rotation(), 1, 1, true); |
||
330 | QPointF np = QPointF(npx.x(), npx.y()); |
||
331 | if (m_view->editStrokeGradient == 1) |
||
332 | { |
||
333 | if (m_gradientPoint == useGradientStart) |
||
334 | { |
||
335 | currItem->GrStrokeStartX -= np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
336 | currItem->GrStrokeStartY -= np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
337 | currItem->GrStrokeFocalX -= np.x(); |
||
338 | currItem->GrStrokeFocalY -= np.y(); |
||
339 | if (currItem->strokeGradientType() == 7) |
||
340 | { |
||
341 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
342 | double radFoc = distance(currItem->GrStrokeFocalX - currItem->GrStrokeStartX, currItem->GrStrokeFocalY - currItem->GrStrokeStartY); |
||
343 | if (radFoc >= radEnd) |
||
344 | { |
||
345 | currItem->GrStrokeStartX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
346 | currItem->GrStrokeStartY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
347 | currItem->GrStrokeFocalX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
348 | currItem->GrStrokeFocalY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
349 | } |
||
350 | } |
||
351 | } |
||
352 | if (m_gradientPoint == useGradientFocal) |
||
353 | { |
||
354 | double rotEnd = xy2Deg(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
355 | QTransform qmatrix; |
||
356 | qmatrix.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
357 | qmatrix.rotate(rotEnd); |
||
358 | double mask_gradientSkew = 0.0; |
||
359 | if (currItem->GrStrokeSkew == 90) |
||
360 | mask_gradientSkew = 1; |
||
361 | else if (currItem->GrStrokeSkew == 180) |
||
362 | mask_gradientSkew = 0; |
||
363 | else if (currItem->GrStrokeSkew == 270) |
||
364 | mask_gradientSkew = -1; |
||
365 | else if (currItem->GrStrokeSkew == 390) |
||
366 | mask_gradientSkew = 0; |
||
367 | else |
||
368 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrStrokeSkew); |
||
369 | qmatrix.shear(mask_gradientSkew, 0); |
||
370 | qmatrix.translate(0, currItem->GrStrokeStartY * (1.0 - currItem->GrStrokeScale)); |
||
371 | qmatrix.translate(-currItem->GrStrokeStartX, -currItem->GrStrokeStartY); |
||
372 | qmatrix.scale(1, currItem->GrStrokeScale); |
||
373 | QTransform m = qmatrix.inverted(); |
||
374 | QPointF shR = qmatrix.map(QPointF(currItem->GrStrokeFocalX, currItem->GrStrokeFocalY)); |
||
375 | QPointF shRe = m.map(shR - np); |
||
376 | currItem->GrStrokeFocalX = shRe.x(); |
||
377 | currItem->GrStrokeFocalY = shRe.y(); |
||
378 | if (currItem->strokeGradientType() == 7) |
||
379 | { |
||
380 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
381 | double radFoc = distance(currItem->GrStrokeFocalX - currItem->GrStrokeStartX, currItem->GrStrokeFocalY - currItem->GrStrokeStartY); |
||
382 | if (radFoc >= radEnd) |
||
383 | { |
||
384 | QPointF shR = qmatrix.map(QPointF(currItem->GrStrokeFocalX, currItem->GrStrokeFocalY)); |
||
385 | QPointF shRe = m.map(shR + np); |
||
386 | currItem->GrStrokeFocalX = shRe.x(); |
||
387 | currItem->GrStrokeFocalY = shRe.y(); |
||
388 | } |
||
389 | } |
||
390 | } |
||
391 | if (m_gradientPoint == useGradientSkew) |
||
392 | { |
||
393 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
394 | double rotEnd = xy2Deg(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
395 | QTransform m; |
||
396 | m.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
397 | m.rotate(rotEnd); |
||
398 | m.rotate(-90); |
||
399 | m.rotate(currItem->GrStrokeSkew); |
||
400 | m.translate(radEnd * currItem->GrStrokeScale, 0); |
||
401 | QPointF shP = m.map(QPointF(0,0)); |
||
402 | QPointF shR = QPointF(shP.x() -np.x(), shP.y() - np.y()); |
||
403 | double radNew = distance(shR.x() - currItem->GrStrokeStartX, shR.y() - currItem->GrStrokeStartY); |
||
404 | double rotNew = xy2Deg(shR.x() - currItem->GrStrokeStartX, shR.y() - currItem->GrStrokeStartY) + 90; |
||
405 | currItem->GrStrokeSkew = rotNew - rotEnd; |
||
406 | double newScale = radNew / radEnd; |
||
407 | if ((newScale > 0) && (newScale <= 1)) |
||
408 | currItem->GrStrokeScale = newScale; |
||
409 | } |
||
410 | if (m_gradientPoint == useGradientEnd) |
||
411 | { |
||
412 | currItem->GrStrokeEndX -= np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
413 | currItem->GrStrokeEndY -= np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
414 | if (currItem->strokeGradientType() == 7) |
||
415 | { |
||
416 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
417 | double radFoc = distance(currItem->GrStrokeFocalX - currItem->GrStrokeStartX, currItem->GrStrokeFocalY - currItem->GrStrokeStartY); |
||
418 | if (radFoc >= radEnd) |
||
419 | { |
||
420 | currItem->GrStrokeEndX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
421 | currItem->GrStrokeEndY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
422 | } |
||
423 | } |
||
424 | } |
||
425 | } |
||
426 | else if (m_view->editStrokeGradient == 2) |
||
427 | { |
||
428 | if (m_gradientPoint == useGradientStart) |
||
429 | { |
||
430 | currItem->GrMaskStartX -= np.x(); |
||
431 | currItem->GrMaskStartY -= np.y(); |
||
432 | currItem->GrMaskFocalX -= np.x(); |
||
433 | currItem->GrMaskFocalY -= np.y(); |
||
23907 | jghali | 434 | if ((currItem->GrMask == GradMask_Radial) || (currItem->GrMask == GradMask_RadialLumAlpha)) |
20593 | jghali | 435 | { |
436 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
437 | double radFoc = distance(currItem->GrMaskFocalX - currItem->GrMaskStartX, currItem->GrMaskFocalY - currItem->GrMaskStartY); |
||
438 | if (radFoc >= radEnd) |
||
439 | { |
||
440 | currItem->GrMaskStartX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
441 | currItem->GrMaskStartY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
442 | currItem->GrMaskFocalX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
443 | currItem->GrMaskFocalY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
444 | } |
||
445 | } |
||
446 | } |
||
447 | if (m_gradientPoint == useGradientFocal) |
||
448 | { |
||
449 | double rotEnd = xy2Deg(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
450 | QTransform qmatrix; |
||
451 | qmatrix.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
452 | qmatrix.rotate(rotEnd); |
||
453 | double mask_gradientSkew = 0.0; |
||
454 | if (currItem->GrMaskSkew == 90) |
||
455 | mask_gradientSkew = 1; |
||
456 | else if (currItem->GrMaskSkew == 180) |
||
457 | mask_gradientSkew = 0; |
||
458 | else if (currItem->GrMaskSkew == 270) |
||
459 | mask_gradientSkew = -1; |
||
460 | else if (currItem->GrMaskSkew == 390) |
||
461 | mask_gradientSkew = 0; |
||
462 | else |
||
463 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrMaskSkew); |
||
464 | qmatrix.shear(mask_gradientSkew, 0); |
||
465 | qmatrix.translate(0, currItem->GrMaskStartY * (1.0 - currItem->GrMaskScale)); |
||
466 | qmatrix.translate(-currItem->GrMaskStartX, -currItem->GrMaskStartY); |
||
467 | qmatrix.scale(1, currItem->GrMaskScale); |
||
468 | QTransform m = qmatrix.inverted(); |
||
469 | QPointF shR = qmatrix.map(QPointF(currItem->GrMaskFocalX, currItem->GrMaskFocalY)); |
||
470 | QPointF shRe = m.map(shR - np); |
||
471 | currItem->GrMaskFocalX = shRe.x(); |
||
472 | currItem->GrMaskFocalY = shRe.y(); |
||
23907 | jghali | 473 | if ((currItem->GrMask == GradMask_Radial) || (currItem->GrMask == GradMask_RadialLumAlpha)) |
20593 | jghali | 474 | { |
475 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
476 | double radFoc = distance(currItem->GrMaskFocalX - currItem->GrMaskStartX, currItem->GrMaskFocalY - currItem->GrMaskStartY); |
||
477 | if (radFoc >= radEnd) |
||
478 | { |
||
479 | QPointF shR = qmatrix.map(QPointF(currItem->GrMaskFocalX, currItem->GrMaskFocalY)); |
||
480 | QPointF shRe = m.map(shR + np); |
||
481 | currItem->GrMaskFocalX = shRe.x(); |
||
482 | currItem->GrMaskFocalY = shRe.y(); |
||
483 | } |
||
484 | } |
||
485 | } |
||
486 | if (m_gradientPoint == useGradientSkew) |
||
487 | { |
||
488 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
489 | double rotEnd = xy2Deg(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
490 | QTransform m; |
||
491 | m.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
492 | m.rotate(rotEnd); |
||
493 | m.rotate(-90); |
||
494 | m.rotate(currItem->GrMaskSkew); |
||
495 | m.translate(radEnd * currItem->GrMaskScale, 0); |
||
496 | QPointF shP = m.map(QPointF(0,0)); |
||
497 | QPointF shR = QPointF(shP.x() -np.x(), shP.y() - np.y()); |
||
498 | double radNew = distance(shR.x() - currItem->GrMaskStartX, shR.y() - currItem->GrMaskStartY); |
||
499 | double rotNew = xy2Deg(shR.x() - currItem->GrMaskStartX, shR.y() - currItem->GrMaskStartY) + 90; |
||
500 | currItem->GrMaskSkew = rotNew - rotEnd; |
||
501 | double newScale = radNew / radEnd; |
||
502 | if ((newScale > 0) && (newScale <= 1)) |
||
503 | currItem->GrMaskScale = newScale; |
||
504 | } |
||
505 | if (m_gradientPoint == useGradientEnd) |
||
506 | { |
||
507 | currItem->GrMaskEndX -= np.x(); |
||
508 | currItem->GrMaskEndY -= np.y(); |
||
23907 | jghali | 509 | if ((currItem->GrMask == GradMask_Radial) || (currItem->GrMask == GradMask_RadialLumAlpha)) |
20593 | jghali | 510 | { |
511 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
512 | double radFoc = distance(currItem->GrMaskFocalX - currItem->GrMaskStartX, currItem->GrMaskFocalY - currItem->GrMaskStartY); |
||
513 | if (radFoc >= radEnd) |
||
514 | { |
||
515 | currItem->GrMaskEndX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
516 | currItem->GrMaskEndY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
517 | } |
||
518 | } |
||
519 | } |
||
520 | } |
||
521 | else if (m_view->editStrokeGradient == 0) |
||
522 | { |
||
523 | if (m_gradientPoint == useGradientStart) |
||
524 | { |
||
525 | currItem->GrStartX -= np.x(); |
||
526 | currItem->GrStartY -= np.y(); |
||
527 | currItem->GrFocalX -= np.x(); |
||
528 | currItem->GrFocalY -= np.y(); |
||
529 | if ((currItem->gradientType() == 7) || (currItem->gradientType() == 13)) |
||
530 | { |
||
531 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
532 | double radFoc = distance(currItem->GrFocalX - currItem->GrStartX, currItem->GrFocalY - currItem->GrStartY); |
||
533 | if (radFoc >= radEnd) |
||
534 | { |
||
535 | currItem->GrStartX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
536 | currItem->GrStartY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
537 | currItem->GrFocalX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
538 | currItem->GrFocalY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
539 | } |
||
540 | } |
||
541 | } |
||
542 | if (m_gradientPoint == useGradientFocal) |
||
543 | { |
||
544 | double rotEnd = xy2Deg(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
545 | QTransform qmatrix; |
||
546 | qmatrix.translate(currItem->GrStartX, currItem->GrStartY); |
||
547 | qmatrix.rotate(rotEnd); |
||
23904 | jghali | 548 | if (currItem->GrType != Gradient_Conical) |
20593 | jghali | 549 | { |
550 | double mask_gradientSkew = 0.0; |
||
551 | if (currItem->GrSkew == 90) |
||
552 | mask_gradientSkew = 1; |
||
553 | else if (currItem->GrSkew == 180) |
||
554 | mask_gradientSkew = 0; |
||
555 | else if (currItem->GrSkew == 270) |
||
556 | mask_gradientSkew = -1; |
||
557 | else if (currItem->GrSkew == 390) |
||
558 | mask_gradientSkew = 0; |
||
559 | else |
||
560 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrSkew); |
||
561 | qmatrix.shear(mask_gradientSkew, 0); |
||
562 | } |
||
563 | qmatrix.translate(0, currItem->GrStartY * (1.0 - currItem->GrScale)); |
||
564 | qmatrix.translate(-currItem->GrStartX, -currItem->GrStartY); |
||
565 | qmatrix.scale(1, currItem->GrScale); |
||
566 | QTransform m = qmatrix.inverted(); |
||
567 | QPointF shR = qmatrix.map(QPointF(currItem->GrFocalX, currItem->GrFocalY)); |
||
568 | QPointF shRe = m.map(shR - np); |
||
569 | currItem->GrFocalX = shRe.x(); |
||
570 | currItem->GrFocalY = shRe.y(); |
||
23904 | jghali | 571 | if ((currItem->GrType == Gradient_Radial) || (currItem->GrType == Gradient_Conical)) |
20593 | jghali | 572 | { |
573 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
574 | double radFoc = distance(currItem->GrFocalX - currItem->GrStartX, currItem->GrFocalY - currItem->GrStartY); |
||
575 | if (radFoc >= radEnd) |
||
576 | { |
||
577 | QPointF shR = qmatrix.map(QPointF(currItem->GrFocalX, currItem->GrFocalY)); |
||
578 | QPointF shRe = m.map(shR + np); |
||
579 | currItem->GrFocalX = shRe.x(); |
||
580 | currItem->GrFocalY = shRe.y(); |
||
581 | } |
||
582 | } |
||
583 | } |
||
584 | if (m_gradientPoint == useGradientSkew) |
||
585 | { |
||
586 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
587 | double rotEnd = xy2Deg(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
588 | QTransform m; |
||
589 | m.translate(currItem->GrStartX, currItem->GrStartY); |
||
590 | m.rotate(rotEnd); |
||
591 | m.rotate(-90); |
||
23904 | jghali | 592 | if (currItem->GrType != Gradient_Conical) |
20593 | jghali | 593 | m.rotate(currItem->GrSkew); |
594 | m.translate(radEnd * currItem->GrScale, 0); |
||
595 | QPointF shP = m.map(QPointF(0,0)); |
||
596 | QPointF shR = QPointF(shP.x() -np.x(), shP.y() - np.y()); |
||
597 | double radNew = distance(shR.x() - currItem->GrStartX, shR.y() - currItem->GrStartY); |
||
598 | double rotNew = xy2Deg(shR.x() - currItem->GrStartX, shR.y() - currItem->GrStartY) + 90; |
||
23904 | jghali | 599 | if (currItem->GrType != Gradient_Conical) |
20593 | jghali | 600 | currItem->GrSkew = rotNew - rotEnd; |
601 | else |
||
602 | currItem->GrSkew = 0; |
||
603 | double newScale = radNew / radEnd; |
||
604 | if ((newScale > 0) && (newScale <= 1)) |
||
605 | currItem->GrScale = newScale; |
||
606 | } |
||
607 | if (m_gradientPoint == useGradientEnd) |
||
608 | { |
||
609 | currItem->GrEndX -= np.x(); |
||
610 | currItem->GrEndY -= np.y(); |
||
23904 | jghali | 611 | if ((currItem->GrType == Gradient_Radial) || (currItem->GrType == Gradient_Conical)) |
20593 | jghali | 612 | { |
613 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
614 | double radFoc = distance(currItem->GrFocalX - currItem->GrStartX, currItem->GrFocalY - currItem->GrStartY); |
||
615 | if (radFoc >= radEnd) |
||
616 | { |
||
617 | currItem->GrEndX += np.x(); // (Mxp - newX); // / m_canvas->scale(); |
||
618 | currItem->GrEndY += np.y(); // (Myp - newY); // / m_canvas->scale(); |
||
619 | } |
||
620 | } |
||
621 | } |
||
622 | } |
||
623 | else if (m_view->editStrokeGradient == 3) |
||
624 | { |
||
625 | if (m_gradientPoint == useControl1) |
||
626 | currItem->GrControl1 -= npx; |
||
627 | else if (m_gradientPoint == useControl2) |
||
628 | currItem->GrControl2 -= npx; |
||
629 | else if (m_gradientPoint == useControl3) |
||
630 | currItem->GrControl3 -= npx; |
||
631 | else if (m_gradientPoint == useControl4) |
||
632 | currItem->GrControl4 -= npx; |
||
633 | } |
||
634 | else if (m_view->editStrokeGradient == 4) |
||
635 | { |
||
636 | if (m_gradientPoint == useControl1) |
||
637 | currItem->GrControl1 -= npx; |
||
638 | else if (m_gradientPoint == useControl2) |
||
639 | currItem->GrControl2 -= npx; |
||
640 | else if (m_gradientPoint == useControl3) |
||
641 | currItem->GrControl3 -= npx; |
||
642 | else if (m_gradientPoint == useControl4) |
||
643 | currItem->GrControl4 -= npx; |
||
644 | else if (m_gradientPoint == useControl5) |
||
645 | currItem->GrControl5 -= npx; |
||
646 | } |
||
647 | m_Mxp = newX; |
||
648 | m_Myp = newY; |
||
649 | // m_view->RefreshGradient(currItem, dx * m_canvas->scale(), dy * m_canvas->scale()); |
||
650 | m_ScMW->propertiesPalette->updateColorSpecialGradient(); |
||
651 | currItem->update(); |
||
21249 | fschmid | 652 | /* QRectF upRect; |
20593 | jghali | 653 | if (m_view->editStrokeGradient == 1) |
654 | { |
||
655 | upRect = QRectF(QPointF(currItem->GrStrokeStartX, currItem->GrStrokeStartY), QPointF(currItem->GrStrokeEndX, currItem->GrStrokeEndY)); |
||
656 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
657 | double rotEnd = xy2Deg(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
658 | QTransform m; |
||
659 | m.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
660 | m.rotate(rotEnd); |
||
661 | m.rotate(-90); |
||
662 | m.rotate(currItem->GrStrokeSkew); |
||
663 | m.translate(radEnd * currItem->GrStrokeScale, 0); |
||
664 | QPointF shP = m.map(QPointF(0,0)); |
||
665 | upRect |= upRect.united(QRectF(shP, QPointF(currItem->GrStrokeEndX, currItem->GrStrokeEndY)).normalized()); |
||
666 | upRect |= upRect.united(QRectF(shP, QPointF(currItem->GrStrokeStartX, currItem->GrStrokeStartY)).normalized()); |
||
667 | upRect |= QRectF(shP, QPointF(0, 0)).normalized(); |
||
668 | upRect |= QRectF(shP, QPointF(currItem->width(), currItem->height())).normalized(); |
||
669 | } |
||
670 | else if (m_view->editStrokeGradient == 2) |
||
671 | { |
||
672 | upRect = QRectF(QPointF(currItem->GrMaskStartX, currItem->GrMaskStartY), QPointF(currItem->GrMaskEndX, currItem->GrMaskEndY)); |
||
673 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
674 | double rotEnd = xy2Deg(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
675 | QTransform m; |
||
676 | m.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
677 | m.rotate(rotEnd); |
||
678 | m.rotate(-90); |
||
679 | m.rotate(currItem->GrMaskSkew); |
||
680 | m.translate(radEnd * currItem->GrMaskScale, 0); |
||
681 | QPointF shP = m.map(QPointF(0,0)); |
||
682 | upRect |= upRect.united(QRectF(shP, QPointF(currItem->GrMaskEndX, currItem->GrMaskEndY)).normalized()); |
||
683 | upRect |= upRect.united(QRectF(shP, QPointF(currItem->GrMaskStartX, currItem->GrMaskStartY)).normalized()); |
||
684 | upRect |= QRectF(shP, QPointF(0, 0)).normalized(); |
||
685 | upRect |= QRectF(shP, QPointF(currItem->width(), currItem->height())).normalized(); |
||
686 | } |
||
687 | else if (m_view->editStrokeGradient == 0) |
||
688 | { |
||
689 | upRect = QRectF(QPointF(currItem->GrStartX, currItem->GrStartY), QPointF(currItem->GrEndX, currItem->GrEndY)); |
||
690 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
691 | double rotEnd = xy2Deg(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
692 | QTransform m; |
||
693 | m.translate(currItem->GrStartX, currItem->GrStartY); |
||
694 | m.rotate(rotEnd); |
||
695 | m.rotate(-90); |
||
696 | m.rotate(currItem->GrSkew); |
||
697 | m.translate(radEnd * currItem->GrScale, 0); |
||
698 | QPointF shP = m.map(QPointF(0,0)); |
||
699 | upRect |= QRectF(shP, QPointF(currItem->GrEndX, currItem->GrEndY)).normalized(); |
||
700 | upRect |= QRectF(shP, QPointF(currItem->GrStartX, currItem->GrStartY)).normalized(); |
||
701 | upRect |= QRectF(shP, QPointF(0, 0)).normalized(); |
||
702 | upRect |= QRectF(shP, QPointF(currItem->width(), currItem->height())).normalized(); |
||
703 | } |
||
704 | else if ((m_view->editStrokeGradient == 3) || (m_view->editStrokeGradient == 4)) |
||
705 | { |
||
706 | upRect = QRectF(QPointF(-currItem->width(), -currItem->height()), QPointF(currItem->width() * 2, currItem->height() * 2)).normalized(); |
||
707 | } |
||
708 | QTransform itemMatrix = currItem->getTransform(); |
||
709 | upRect = itemMatrix.mapRect(upRect); |
||
21249 | fschmid | 710 | m_doc->regionsChanged()->update(upRect.adjusted(-10.0, -10.0, 10.0, 10.0)); */ |
23904 | jghali | 711 | if (currItem->GrType == Gradient_Conical) |
20593 | jghali | 712 | currItem->createConicalMesh(); |
21249 | fschmid | 713 | m_doc->regionsChanged()->update(QRectF()); |
20593 | jghali | 714 | } |
715 | } |
||
716 | |||
717 | void CanvasMode_EditGradient::mousePressEvent(QMouseEvent *m) |
||
718 | { |
||
719 | const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos()); |
||
720 | |||
721 | m_canvas->PaintSizeRect(QRect()); |
||
722 | m_canvas->m_viewMode.m_MouseButtonPressed = true; |
||
723 | m_canvas->m_viewMode.operItemMoving = false; |
||
724 | m_view->HaveSelRect = false; |
||
725 | m_doc->DragP = false; |
||
726 | m_doc->leaveDrag = false; |
||
727 | m->accept(); |
||
728 | m_view->registerMousePress(m->globalPos()); |
||
729 | m_gradientPoint = noPointDefined; |
||
730 | m_Mxp = mousePointDoc.x(); //m->x(); |
||
731 | m_Myp = mousePointDoc.y(); //m->y(); |
||
24680 | craig | 732 | if (m->button() == Qt::MiddleButton) |
20593 | jghali | 733 | { |
734 | m_view->MidButt = true; |
||
735 | if (m->modifiers() & Qt::ControlModifier) |
||
736 | m_view->DrawNew(); |
||
737 | return; |
||
738 | } |
||
739 | PageItem *currItem = m_doc->m_Selection->itemAt(0); |
||
740 | QTransform itemMatrix = currItem->getTransform(); |
||
741 | QPointF gradientStart, gradientEnd, gradientFocal, gradientScale, gradientCenter; |
||
742 | if (m_view->editStrokeGradient == 1) |
||
743 | { |
||
744 | gradientStart = QPointF(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
745 | gradientEnd = QPointF(currItem->GrStrokeEndX, currItem->GrStrokeEndY); |
||
746 | double radEnd = distance(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
747 | double rotEnd = xy2Deg(currItem->GrStrokeEndX - currItem->GrStrokeStartX, currItem->GrStrokeEndY - currItem->GrStrokeStartY); |
||
748 | QTransform m; |
||
749 | m.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
750 | m.rotate(rotEnd); |
||
751 | m.rotate(-90); |
||
752 | m.rotate(currItem->GrStrokeSkew); |
||
753 | m.translate(radEnd * currItem->GrStrokeScale, 0); |
||
754 | gradientScale = m.map(QPointF(0,0)); |
||
755 | QTransform qmatrix; |
||
756 | qmatrix.translate(currItem->GrStrokeStartX, currItem->GrStrokeStartY); |
||
757 | qmatrix.rotate(rotEnd); |
||
758 | double mask_gradientSkew = 0.0; |
||
759 | if (currItem->GrStrokeSkew == 90) |
||
760 | mask_gradientSkew = 1; |
||
761 | else if (currItem->GrStrokeSkew == 180) |
||
762 | mask_gradientSkew = 0; |
||
763 | else if (currItem->GrStrokeSkew == 270) |
||
764 | mask_gradientSkew = -1; |
||
765 | else if (currItem->GrStrokeSkew == 390) |
||
766 | mask_gradientSkew = 0; |
||
767 | else |
||
768 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrStrokeSkew); |
||
769 | qmatrix.shear(mask_gradientSkew, 0); |
||
770 | qmatrix.translate(0, currItem->GrStrokeStartY * (1.0 - currItem->GrStrokeScale)); |
||
771 | qmatrix.translate(-currItem->GrStrokeStartX, -currItem->GrStrokeStartY); |
||
772 | qmatrix.scale(1, currItem->GrStrokeScale); |
||
773 | gradientFocal = qmatrix.map(QPointF(currItem->GrStrokeFocalX, currItem->GrStrokeFocalY)); |
||
774 | } |
||
775 | else if (m_view->editStrokeGradient == 2) |
||
776 | { |
||
777 | gradientStart = QPointF(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
778 | gradientEnd = QPointF(currItem->GrMaskEndX, currItem->GrMaskEndY); |
||
779 | double radEnd = distance(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
780 | double rotEnd = xy2Deg(currItem->GrMaskEndX - currItem->GrMaskStartX, currItem->GrMaskEndY - currItem->GrMaskStartY); |
||
781 | QTransform m; |
||
782 | m.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
783 | m.rotate(rotEnd); |
||
784 | m.rotate(-90); |
||
785 | m.rotate(currItem->GrMaskSkew); |
||
786 | m.translate(radEnd * currItem->GrMaskScale, 0); |
||
787 | gradientScale = m.map(QPointF(0,0)); |
||
788 | QTransform qmatrix; |
||
789 | qmatrix.translate(currItem->GrMaskStartX, currItem->GrMaskStartY); |
||
790 | qmatrix.rotate(rotEnd); |
||
791 | double mask_gradientSkew = 0.0; |
||
792 | if (currItem->GrMaskSkew == 90) |
||
793 | mask_gradientSkew = 1; |
||
794 | else if (currItem->GrMaskSkew == 180) |
||
795 | mask_gradientSkew = 0; |
||
796 | else if (currItem->GrMaskSkew == 270) |
||
797 | mask_gradientSkew = -1; |
||
798 | else if (currItem->GrMaskSkew == 390) |
||
799 | mask_gradientSkew = 0; |
||
800 | else |
||
801 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrMaskSkew); |
||
802 | qmatrix.shear(mask_gradientSkew, 0); |
||
803 | qmatrix.translate(0, currItem->GrMaskStartY * (1.0 - currItem->GrMaskScale)); |
||
804 | qmatrix.translate(-currItem->GrMaskStartX, -currItem->GrMaskStartY); |
||
805 | qmatrix.scale(1, currItem->GrMaskScale); |
||
806 | gradientFocal = qmatrix.map(QPointF(currItem->GrMaskFocalX, currItem->GrMaskFocalY)); |
||
807 | } |
||
808 | else if (m_view->editStrokeGradient == 0) |
||
809 | { |
||
810 | gradientStart = QPointF(currItem->GrStartX, currItem->GrStartY); |
||
811 | gradientEnd = QPointF(currItem->GrEndX, currItem->GrEndY); |
||
812 | double radEnd = distance(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
813 | double rotEnd = xy2Deg(currItem->GrEndX - currItem->GrStartX, currItem->GrEndY - currItem->GrStartY); |
||
814 | QTransform m; |
||
815 | m.translate(currItem->GrStartX, currItem->GrStartY); |
||
816 | m.rotate(rotEnd); |
||
817 | m.rotate(-90); |
||
818 | m.rotate(currItem->GrSkew); |
||
819 | m.translate(radEnd * currItem->GrScale, 0); |
||
820 | gradientScale = m.map(QPointF(0,0)); |
||
821 | QTransform qmatrix; |
||
822 | qmatrix.translate(currItem->GrStartX, currItem->GrStartY); |
||
823 | qmatrix.rotate(rotEnd); |
||
23904 | jghali | 824 | if (currItem->GrType != Gradient_Conical) |
20593 | jghali | 825 | { |
826 | double mask_gradientSkew = 0.0; |
||
827 | if (currItem->GrSkew == 90) |
||
828 | mask_gradientSkew = 1; |
||
829 | else if (currItem->GrSkew == 180) |
||
830 | mask_gradientSkew = 0; |
||
831 | else if (currItem->GrSkew == 270) |
||
832 | mask_gradientSkew = -1; |
||
833 | else if (currItem->GrSkew == 390) |
||
834 | mask_gradientSkew = 0; |
||
835 | else |
||
836 | mask_gradientSkew = tan(M_PI / 180.0 * currItem->GrSkew); |
||
837 | qmatrix.shear(mask_gradientSkew, 0); |
||
838 | } |
||
839 | qmatrix.translate(0, currItem->GrStartY * (1.0 - currItem->GrScale)); |
||
840 | qmatrix.translate(-currItem->GrStartX, -currItem->GrStartY); |
||
841 | qmatrix.scale(1, currItem->GrScale); |
||
842 | gradientFocal = qmatrix.map(QPointF(currItem->GrFocalX, currItem->GrFocalY)); |
||
843 | } |
||
844 | else if (m_view->editStrokeGradient == 3) |
||
845 | { |
||
846 | gradientStart = QPointF(currItem->GrControl1.x(), currItem->GrControl1.y()); |
||
847 | gradientEnd = QPointF(currItem->GrControl2.x(), currItem->GrControl2.y()); |
||
848 | gradientFocal = QPointF(currItem->GrControl3.x(), currItem->GrControl3.y()); |
||
849 | gradientScale = QPointF(currItem->GrControl4.x(), currItem->GrControl4.y()); |
||
850 | } |
||
851 | else if (m_view->editStrokeGradient == 4) |
||
852 | { |
||
853 | gradientStart = QPointF(currItem->GrControl1.x(), currItem->GrControl1.y()); |
||
854 | gradientEnd = QPointF(currItem->GrControl2.x(), currItem->GrControl2.y()); |
||
855 | gradientFocal = QPointF(currItem->GrControl3.x(), currItem->GrControl3.y()); |
||
856 | gradientScale = QPointF(currItem->GrControl4.x(), currItem->GrControl4.y()); |
||
857 | gradientCenter = QPointF(currItem->GrControl5.x(), currItem->GrControl5.y()); |
||
858 | } |
||
859 | gradientStart = itemMatrix.map(gradientStart); |
||
860 | gradientEnd = itemMatrix.map(gradientEnd); |
||
861 | gradientFocal = itemMatrix.map(gradientFocal); |
||
862 | gradientScale = itemMatrix.map(gradientScale); |
||
863 | gradientCenter = itemMatrix.map(gradientCenter); |
||
864 | if (m_view->editStrokeGradient == 3) |
||
865 | { |
||
866 | if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientStart)) |
||
867 | m_gradientPoint = useControl1; |
||
868 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientEnd)) |
||
869 | m_gradientPoint = useControl2; |
||
870 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientFocal)) |
||
871 | m_gradientPoint = useControl3; |
||
872 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientScale)) |
||
873 | m_gradientPoint = useControl4; |
||
874 | } |
||
875 | else if (m_view->editStrokeGradient == 4) |
||
876 | { |
||
877 | if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientStart)) |
||
878 | m_gradientPoint = useControl1; |
||
879 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientEnd)) |
||
880 | m_gradientPoint = useControl2; |
||
881 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientFocal)) |
||
882 | m_gradientPoint = useControl3; |
||
883 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientScale)) |
||
884 | m_gradientPoint = useControl4; |
||
885 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientCenter)) |
||
886 | m_gradientPoint = useControl5; |
||
887 | } |
||
888 | else |
||
889 | { |
||
890 | if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientStart)) |
||
891 | m_gradientPoint = useGradientStart; |
||
892 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientEnd)) |
||
893 | m_gradientPoint = useGradientEnd; |
||
894 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientFocal)) |
||
895 | m_gradientPoint = useGradientFocal; |
||
896 | else if (m_canvas->hitsCanvasPoint(m->globalPos(), gradientScale)) |
||
897 | m_gradientPoint = useGradientSkew; |
||
898 | } |
||
899 | m_canvas->m_viewMode.m_MouseButtonPressed = true; |
||
22721 | jghali | 900 | if (m_gradientPoint != noPointDefined){ |
20593 | jghali | 901 | OldGrStartX = currItem->gradientStartX(); |
902 | OldGrStartY = currItem->gradientStartY(); |
||
903 | OldGrEndX = currItem->gradientEndX(); |
||
904 | OldGrEndY = currItem->gradientEndY(); |
||
905 | OldGrFocalX = currItem->gradientFocalX(); |
||
906 | OldGrFocalY = currItem->gradientFocalY(); |
||
907 | OldGrScale = currItem->gradientScale(); |
||
908 | OldGrSkew = currItem->gradientSkew(); |
||
909 | OldGrControl1 = currItem->gradientControl1(); |
||
910 | OldGrControl2 = currItem->gradientControl2(); |
||
911 | OldGrControl3 = currItem->gradientControl3(); |
||
912 | OldGrControl4 = currItem->gradientControl4(); |
||
913 | OldGrControl5 = currItem->gradientControl5(); |
||
914 | OldGrStrokeStartX = currItem->gradientStrokeStartX(); |
||
915 | OldGrStrokeStartY = currItem->gradientStrokeStartY(); |
||
916 | OldGrStrokeEndX = currItem->gradientStrokeEndX(); |
||
917 | OldGrStrokeEndY = currItem->gradientStrokeEndY(); |
||
918 | OldGrStrokeFocalX = currItem->gradientStrokeFocalX(); |
||
919 | OldGrStrokeFocalY = currItem->gradientStrokeFocalY(); |
||
920 | OldGrStrokeScale = currItem->gradientStrokeScale(); |
||
921 | OldGrStrokeSkew = currItem->gradientStrokeSkew(); |
||
922 | OldGrMaskStartX = currItem->GrMaskStartX; |
||
923 | OldGrMaskStartY = currItem->GrMaskStartY; |
||
924 | OldGrMaskEndX = currItem->GrMaskEndX; |
||
925 | OldGrMaskEndY = currItem->GrMaskEndY; |
||
926 | OldGrMaskFocalX = currItem->GrMaskFocalX; |
||
927 | OldGrMaskFocalY = currItem->GrMaskFocalY; |
||
928 | OldGrMaskScale = currItem->GrMaskScale; |
||
929 | OldGrMaskSkew = currItem->GrMaskSkew; |
||
930 | } |
||
931 | m_view->setCursor(QCursor(Qt::CrossCursor)); |
||
932 | } |
||
933 | |||
934 | void CanvasMode_EditGradient::mouseReleaseEvent(QMouseEvent *m) |
||
935 | { |
||
936 | #ifdef GESTURE_FRAME_PREVIEW |
||
23323 | jghali | 937 | clearPixmapCache(); |
20593 | jghali | 938 | #endif // GESTURE_FRAME_PREVIEW |
939 | m_canvas->m_viewMode.m_MouseButtonPressed = false; |
||
940 | m_canvas->resetRenderMode(); |
||
941 | m->accept(); |
||
942 | PageItem* currItem = m_doc->m_Selection->itemAt(0); |
||
23107 | jghali | 943 | if (m_gradientPoint != noPointDefined && UndoManager::undoEnabled()) |
944 | { |
||
20593 | jghali | 945 | QList<FPoint> tmp; |
946 | ScItemState<QList<FPoint> > *is = new ScItemState<QList<FPoint> >(Um::GradPos + "i"); |
||
20799 | jghali | 947 | is->set("GRAD_POS"); |
23107 | jghali | 948 | is->set("OLDSTARTX", OldGrStartX); |
949 | is->set("STARTX", currItem->gradientStartX()); |
||
950 | is->set("OLDSTARTY", OldGrStartY); |
||
951 | is->set("STARTY", currItem->gradientStartY()); |
||
952 | is->set("OLDENDX", OldGrEndX); |
||
953 | is->set("ENDX", currItem->gradientEndX()); |
||
954 | is->set("OLDENDY", OldGrEndY); |
||
955 | is->set("ENDY", currItem->gradientEndY()); |
||
956 | is->set("OLDFOCALX", OldGrFocalX); |
||
957 | is->set("FOCALX", currItem->gradientFocalX()); |
||
958 | is->set("OLDFOCALY", OldGrFocalY); |
||
959 | is->set("FOCALY", currItem->gradientFocalY()); |
||
960 | is->set("OLDSCALE", OldGrScale); |
||
961 | is->set("SCALE", currItem->gradientScale()); |
||
962 | is->set("OLDSKEW", OldGrSkew); |
||
963 | is->set("SKEW", currItem->gradientSkew()); |
||
20593 | jghali | 964 | tmp.append(OldGrControl1); |
965 | tmp.append(currItem->gradientControl1()); |
||
966 | tmp.append(OldGrControl2); |
||
967 | tmp.append(currItem->gradientControl2()); |
||
968 | tmp.append(OldGrControl3); |
||
969 | tmp.append(currItem->gradientControl3()); |
||
970 | tmp.append(OldGrControl4); |
||
971 | tmp.append(currItem->gradientControl4()); |
||
972 | tmp.append(OldGrControl5); |
||
973 | tmp.append(currItem->gradientControl5()); |
||
974 | is->setItem(tmp); |
||
23107 | jghali | 975 | is->set("OLDSTROKESTARTX", OldGrStrokeStartX); |
976 | is->set("STROKESTARTX", currItem->gradientStrokeStartX()); |
||
977 | is->set("OLDSTROKESTARTY", OldGrStrokeStartY); |
||
978 | is->set("STROKESTARTY", currItem->gradientStrokeStartY()); |
||
979 | is->set("OLDSTROKEENDX", OldGrStrokeEndX); |
||
980 | is->set("STROKEENDX", currItem->gradientStrokeEndX()); |
||
981 | is->set("OLDSTROKEENDY", OldGrStrokeEndY); |
||
982 | is->set("STROKEENDY", currItem->gradientStrokeEndY()); |
||
983 | is->set("OLDSTROKEFOCALX", OldGrStrokeFocalX); |
||
984 | is->set("STROKEFOCALX", currItem->gradientStrokeFocalX()); |
||
985 | is->set("OLDSTROKEFOCALY", OldGrStrokeFocalY); |
||
986 | is->set("STROKEFOCALY", currItem->gradientStrokeFocalY()); |
||
987 | is->set("OLDSTROKESCALE", OldGrStrokeScale); |
||
988 | is->set("STROKESCALE", currItem->gradientStrokeScale()); |
||
989 | is->set("OLDSTROKESKEW", OldGrStrokeSkew); |
||
990 | is->set("STROKESKEW", currItem->gradientStrokeSkew()); |
||
991 | is->set("OLDMARKSTARTX", OldGrMaskStartX); |
||
992 | is->set("MARKSTARTX", currItem->GrMaskStartX); |
||
993 | is->set("OLDMARKSTARTY", OldGrMaskStartY); |
||
994 | is->set("MARKSTARTY", currItem->GrMaskStartY); |
||
995 | is->set("OLDMARKENDX", OldGrMaskEndX); |
||
996 | is->set("MARKENDX", currItem->GrMaskEndX); |
||
997 | is->set("OLDMARKENDY", OldGrMaskEndY); |
||
998 | is->set("MARKENDY", currItem->GrMaskEndY); |
||
999 | is->set("OLDMARKFOCALX", OldGrMaskFocalX); |
||
1000 | is->set("MARKFOCALX", currItem->GrMaskFocalX); |
||
1001 | is->set("OLDMARKFOCALY", OldGrMaskFocalY); |
||
1002 | is->set("MARKFOCALY", currItem->GrMaskFocalY); |
||
1003 | is->set("OLDMARKSCALE", OldGrMaskScale); |
||
1004 | is->set("MARKSCALE", currItem->GrMaskScale); |
||
1005 | is->set("OLDMARKSKEW", OldGrMaskSkew); |
||
1006 | is->set("MARKSKEW", currItem->GrMaskSkew); |
||
1007 | undoManager->action(currItem, is); |
||
20593 | jghali | 1008 | } |
1009 | m_gradientPoint = noPointDefined; |
||
1010 | // m_view->stopDragTimer(); |
||
1011 | } |