Subversion Repositories Scribus

Rev

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
}