Subversion Repositories Scribus

Rev

Rev 18114 | Rev 18181 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
14371 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
#include "canvasmode_nodeedit.h"
17
 
18
#include <QMenu>
19
#include <QMouseEvent>
16546 jghali 20
#include <QPainter>
14371 jghali 21
 
22
#include "canvas.h"
17668 jghali 23
#include "canvasgesture_pan.h"
14371 jghali 24
#include "canvasgesture_rectselect.h"
25
#include "fpoint.h"
26
#include "pageitem.h"
16976 fschmid 27
#include "scraction.h"
14371 jghali 28
#include "scribus.h"
29
#include "scribusdoc.h"
30
#include "scribusview.h"
31
#include "scribusXml.h"
32
#include "selection.h"
33
#include "undomanager.h"
34
#include "util_icon.h"
35
#include "util_math.h"
36
#include "ui/pageselector.h"
16976 fschmid 37
#include "ui/propertiespalette.h"
14371 jghali 38
#include "ui/scrspinbox.h"
39
 
40
 
41
CanvasMode_NodeEdit::CanvasMode_NodeEdit(ScribusView* view) : CanvasMode(view), m_rectangleSelect(NULL)
42
{
43
        Mxp = -1;  // last mouse position
44
        Myp = -1;
45
        Dxp = -1;  // last mouse press position for rectangle select
46
        Dyp = -1;
47
        GxM = -1;  // guide position
48
        GyM = -1;
49
        MoveGX = MoveGY = false;
50
        m_ScMW = m_view->m_ScMW;
51
}
52
 
53
void CanvasMode_NodeEdit::drawControls(QPainter* p)
54
{
55
        double x, y;
56
        if (m_doc->m_Selection->count() == 0)
57
                return;
58
        PageItem* currItem = m_doc->m_Selection->itemAt(0);
59
        FPointArray cli;
60
 
61
        p->save();
62
        p->scale(m_canvas->scale(), m_canvas->scale());
63
        p->translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y());
16976 fschmid 64
        p->setTransform(currItem->getTransform(), true);
14371 jghali 65
        p->setPen(QPen(Qt::blue, 1 / m_canvas->m_viewMode.scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
66
        p->setBrush(Qt::NoBrush);
67
 
68
        if ((m_doc->nodeEdit.isContourLine) && (currItem->ContourLine.size() != 0))
69
                cli = currItem->ContourLine;
70
        else
17061 fschmid 71
        {
14371 jghali 72
                cli = currItem->PoLine;
17061 fschmid 73
                if (currItem->isSymbol() || currItem->isGroup())
74
                {
75
                        if (currItem->imageFlippedH())
76
                        {
77
                                p->translate(currItem->width(), 0);
78
                                p->scale(-1, 1);
79
                        }
80
                        if (currItem->imageFlippedV())
81
                        {
82
                                p->translate(0, currItem->height());
83
                                p->scale(1, -1);
84
                        }
85
                }
86
        }
14371 jghali 87
        // draw curve
88
        const double scale = m_canvas->m_viewMode.scale;
89
        const double onePerScale = 1 / scale;
90
        if (cli.size() > 3)
91
        {
18114 jghali 92
                for (int poi=0; poi<cli.size()-3; poi += 4)
14371 jghali 93
                {
94
                        if (cli.point(poi).x() > 900000)
95
                                continue;
96
                        p->setPen(QPen(Qt::blue, onePerScale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
97
                        FPoint a1 = cli.point(poi);
98
                        FPoint a2 = cli.point(poi+1);
99
                        FPoint a3 = cli.point(poi+3);
100
                        FPoint a4 =     cli.point(poi+2);
101
                        QPainterPath Bez;
102
                        Bez.moveTo(a1.x(), a1.y());
103
                        Bez.cubicTo(a2.x(), a2.y(), a3.x(), a3.y(), a4.x(), a4.y());
104
                        p->drawPath(Bez);
105
                        p->setPen(QPen(Qt::blue, onePerScale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
106
                        p->drawLine(QPointF(a1.x(), a1.y()), QPointF(a2.x(), a2.y()));
107
                        p->drawLine(QPointF(a3.x(), a3.y()), QPointF(a4.x(), a4.y()));
108
                }
109
        }
110
        // draw points
18114 jghali 111
        for (int a = 0; a < cli.size()-1; a += 2)
14371 jghali 112
        {
113
                if (cli.point(a).x() > 900000)
114
                        continue;
115
                if (m_doc->nodeEdit.EdPoints)
116
                {
117
                        if (m_doc->nodeEdit.ClRe == static_cast<int>(a+1))
118
                                p->setPen(QPen(Qt::red, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
119
                        else
120
                                p->setPen(QPen(Qt::magenta, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
121
                        cli.point(a+1, &x, &y);
122
                        p->drawPoint(QPointF(x, y));
123
                        if (m_doc->nodeEdit.ClRe == static_cast<int>(a))
124
                                p->setPen(QPen(Qt::red, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
125
                        else
126
                                p->setPen(QPen(Qt::blue, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
127
                        cli.point(a, &x, &y);
128
                        p->drawPoint(QPointF(x, y));
129
                }
130
                else
131
                {
132
                        if (m_doc->nodeEdit.ClRe == static_cast<int>(a))
133
                                p->setPen(QPen(Qt::red, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
134
                        else
135
                                p->setPen(QPen(Qt::blue, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
136
                        cli.point(a, &x, &y);
137
                        p->drawPoint(QPointF(x, y));
138
                        if (m_doc->nodeEdit.ClRe == static_cast<int>(a+1))
139
                                p->setPen(QPen(Qt::red, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
140
                        else
141
                                p->setPen(QPen(Qt::magenta, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
142
                        cli.point(a+1, &x, &y);
143
                        p->drawPoint(QPointF(x, y));
144
                }
145
        }
146
 
147
        if (m_doc->nodeEdit.ClRe != -1)
148
        {
149
                p->setPen(QPen(Qt::red, 8 / scale, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
150
                cli.point(m_doc->nodeEdit.ClRe, &x, &y);
151
                p->drawPoint(QPointF(x, y));
152
                QList<int>::Iterator itm;
153
                for (itm = m_doc->nodeEdit.SelNode.begin(); itm != m_doc->nodeEdit.SelNode.end(); ++itm)
154
                {
155
                        cli.point((*itm), &x, &y);
156
                        p->drawPoint(QPointF(x, y));
157
                }
158
                emit m_view->HavePoint(true, m_doc->nodeEdit.MoveSym);
159
                cli.point(m_doc->nodeEdit.ClRe, &x, &y);
160
                emit m_view->ClipPo(x, y);
161
        }
162
        else
163
                emit m_view->HavePoint(false, m_doc->nodeEdit.MoveSym);
164
        p->restore();
165
}
166
 
167
 
168
void CanvasMode_NodeEdit::activate(bool fromGesture)
169
{
170
        if (fromGesture && m_rectangleSelect)
171
        {
172
                m_canvas->m_viewMode.m_MouseButtonPressed = false;
173
                // handle rectangle select
174
                PageItem* currItem = m_doc->m_Selection->itemAt(0);
175
                m_doc->nodeEdit.SelNode.clear();
16976 fschmid 176
                QRectF Sele = m_rectangleSelect->result();
14371 jghali 177
                FPointArray Clip;
178
                bool firstPoint = false;
17061 fschmid 179
                QTransform pm2 = currItem->getTransform();
14371 jghali 180
                if (m_doc->nodeEdit.isContourLine)
181
                        Clip = currItem->ContourLine;
182
                else
17061 fschmid 183
                {
14371 jghali 184
                        Clip = currItem->PoLine;
17061 fschmid 185
                        if (currItem->isSymbol() || currItem->isGroup())
16974 fschmid 186
                        {
17061 fschmid 187
                                if (currItem->imageFlippedH())
188
                                {
189
                                        pm2.translate(currItem->width(), 0);
190
                                        pm2.scale(-1, 1);
191
                                }
192
                                if (currItem->imageFlippedV())
193
                                {
194
                                        pm2.translate(0, currItem->height());
195
                                        pm2.scale(1, -1);
196
                                }
16974 fschmid 197
                        }
198
                }
18114 jghali 199
                for (int a = 0; a < Clip.size(); ++a)
14371 jghali 200
                {
201
                        if (Clip.point(a).x() > 900000)
202
                                continue;
203
                        FPoint np = Clip.point(a);
16974 fschmid 204
                        FPoint npf2 = np.transformPoint(pm2, false);
14371 jghali 205
                        if ((Sele.contains(npf2.x(), npf2.y())) && ((a == 0) || (((a-2) % 4) == 0)))
206
                        {
207
                                if (a == 0)
208
                                        firstPoint = true;
209
                                if ((firstPoint) && (a == Clip.size() - 2) && (!currItem->asPolyLine()))
210
                                        continue;
211
                                m_doc->nodeEdit.ClRe = a;
212
                                m_doc->nodeEdit.SelNode.append(a);
213
                                m_doc->nodeEdit.update(Clip.pointQF(a));
214
                        }
215
                }
216
                currItem->update();
217
                m_doc->nodeEdit.finishTransaction(currItem);
218
                delete m_rectangleSelect;
219
                m_rectangleSelect = NULL;
220
        }
221
        else
222
        {
223
                Mxp = -1;  // last mouse position
224
                Myp = -1;
225
                Dxp = -1;  // last mouse press position for rectangle select
226
                Dyp = -1;
227
                GxM = -1;  // guide position
228
                GyM = -1;
229
                MoveGX = MoveGY = false;
16976 fschmid 230
        }
14371 jghali 231
}
232
 
233
 
234
void CanvasMode_NodeEdit::deactivate(bool forGesture)
235
{
236
        if (!forGesture && m_rectangleSelect)
237
        {
238
                m_rectangleSelect->clear();
239
                delete m_rectangleSelect;
240
                m_rectangleSelect = NULL;
241
        }
242
}
243
 
244
 
245
inline bool CanvasMode_NodeEdit::GetItem(PageItem** pi)
246
{
247
        *pi = m_doc->m_Selection->itemAt(0);
248
        return (*pi) != NULL;
249
}
250
 
251
 
252
 
253
void CanvasMode_NodeEdit::enterEvent(QEvent *)
254
{
255
        if (!m_canvas->m_viewMode.m_MouseButtonPressed)
256
        {
257
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
258
        }
259
}
260
 
261
 
262
void CanvasMode_NodeEdit::leaveEvent(QEvent *e)
263
{
264
        if (!m_canvas->m_viewMode.m_MouseButtonPressed)
265
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
266
}
267
 
268
 
269
 
270
void CanvasMode_NodeEdit::mouseDoubleClickEvent(QMouseEvent *m)
271
{
272
        m->accept();
273
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
274
        m_canvas->resetRenderMode();
275
        m_view->requestMode(submodeEndNodeEdit);
276
}
277
 
278
 
279
void CanvasMode_NodeEdit::mouseMoveEvent(QMouseEvent *m)
280
{
281
        PageItem *currItem;
16976 fschmid 282
        FPoint npf;
14371 jghali 283
        double sc = m_canvas->scale();
284
        m->accept();
285
        npf = m_canvas->globalToCanvas(m->globalPos());
286
        if (GetItem(&currItem))
287
        {
288
                if (m_doc->DragP)
289
                        return;
290
                //Operations run here:
291
                //Item resize, esp after creating a new one
292
                if (m_view->moveTimerElapsed() && m_canvas->m_viewMode.m_MouseButtonPressed
293
                        && (m->buttons() & Qt::LeftButton) &&  (!currItem->locked()))
294
                {
295
                        handleNodeEditDrag(m, currItem);
296
                }
297
                else if (!m_canvas->m_viewMode.m_MouseButtonPressed)
298
                {
299
                        if (!currItem->locked())
300
                        {
16976 fschmid 301
                                QTransform p;
302
                                QRect mpo;
14371 jghali 303
                                handleNodeEditMove(m, mpo, currItem, p);
304
                        }
305
                }
306
 
307
        }
308
        else // shouldnt be in nodeedit mode now, should it??
309
        {
310
                npf = m_canvas->globalToCanvas(m->globalPos());
311
                if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton) && (GyM == -1) && (GxM == -1))
312
                {
313
                        if (!m_rectangleSelect)
314
                        {
315
                                m_rectangleSelect = new RectSelect(this);
316
                        }
317
                        m_rectangleSelect->prepare(m->globalPos());
318
                        m_view->startGesture(m_rectangleSelect);
319
                        return;
320
                }
14932 cbradney 321
                if ((m_doc->guidesPrefs().guidesShown) && (!m_doc->GuideLock)
14371 jghali 322
                        && (m_doc->OnPage(npf.x(), npf.y()) != -1))
323
                {
324
                        Guides::iterator it;
325
                        Guides tmpGuides = m_doc->currentPage()->guides.horizontals(GuideManagerCore::Standard);
326
                        for (it = tmpGuides.begin(); it != tmpGuides.end(); ++it)
327
                        {
14932 cbradney 328
                                if ( (*it) + m_doc->currentPage()->yOffset() < npf.y() + m_doc->guidesPrefs().grabRadius * sc &&
329
                                         (*it) + m_doc->currentPage()->yOffset() > npf.y() - m_doc->guidesPrefs().grabRadius * sc )
14371 jghali 330
                                {
331
                                        if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (GyM != -1))
332
                                                MoveGY = true;
333
                                        if (npf.x() < m_doc->currentPage()->xOffset() ||
334
                                                npf.x() >= m_doc->currentPage()->xOffset() + m_doc->currentPage()->width() - 1)
335
                                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
336
                                        else
337
                                                qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
338
                                        return;
339
                                }
340
                        }
341
                        tmpGuides = m_doc->currentPage()->guides.verticals(GuideManagerCore::Standard);
342
                        for (it = tmpGuides.begin(); it!= tmpGuides.end(); ++it)
343
                        {
14932 cbradney 344
                                if ( (*it) + m_doc->currentPage()->xOffset() < npf.x() + m_doc->guidesPrefs().grabRadius * sc &&
345
                                         (*it) + m_doc->currentPage()->xOffset() > npf.x() - m_doc->guidesPrefs().grabRadius * sc)
14371 jghali 346
                                {
347
                                        if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (GxM != -1))
348
                                                MoveGX = true;
349
                                        if (npf.y() < m_doc->currentPage()->yOffset() ||
350
                                                npf.y() >= m_doc->currentPage()->yOffset() + m_doc->currentPage()->height() - 1)
351
                                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
352
                                        else
353
                                                qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
354
                                        return;
355
                                }
356
                        }
357
                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
358
                }
359
        }
360
}
361
 
362
void CanvasMode_NodeEdit::mousePressEvent(QMouseEvent *m)
363
{
364
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
365
        m_canvas->m_viewMode.operItemMoving = false;
366
        m_doc->DragP = false;
367
        m_doc->leaveDrag = false;
368
        MoveGX = MoveGY = false;
369
        m->accept();
370
        m_view->registerMousePress(m->globalPos());
16976 fschmid 371
        QRect mpo;
14371 jghali 372
        Mxp = m->x();
373
        Myp = m->y();
17668 jghali 374
 
17709 craig 375
        if (((m->buttons() & Qt::RightButton) && (m->modifiers() & Qt::ControlModifier)) || ((!(m->modifiers() & Qt::ControlModifier)) && (m->buttons() & Qt::MidButton)))
376
        {
377
                if (!m_panGesture)
378
                {
379
                        m_panGesture = new PanGesture(this);
380
                }
381
                m_view->startGesture(m_panGesture);
382
                m_panGesture->mousePressEvent(m); // Not an error, this is used to register current canvas point
383
                return;
17668 jghali 384
        }
14371 jghali 385
 
386
        if (m_doc->m_Selection->count() != 0)
387
        {
388
                handleNodeEditPress(m, mpo);
389
        }                      
390
        if ((m_doc->m_Selection->count() != 0) && (m->button() == Qt::RightButton))
391
        {
392
                m_canvas->m_viewMode.m_MouseButtonPressed = true;
393
                Dxp = Mxp;
394
                Dyp = Myp;
395
        }
396
}
397
 
398
 
399
 
400
void CanvasMode_NodeEdit::mouseReleaseEvent(QMouseEvent *m)
401
{
402
        PageItem *currItem;
403
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
404
        m_canvas->resetRenderMode();
405
        m->accept();
406
        if (m_view->moveTimerElapsed())
407
        {
408
                if (m_doc->nodeEdit.SegP1 != -1 && m_doc->nodeEdit.SegP2 != -1)
409
                {
410
                        m_doc->nodeEdit.deselect();
411
                        m_doc->nodeEdit.SegP1 = -1;
412
                        m_doc->nodeEdit.SegP2 = -1;
413
                }
414
                currItem = m_doc->m_Selection->itemAt(0);
415
                m_canvas->m_viewMode.operItemMoving = false;
416
                double xposOrig = currItem->xPos();
417
                double yposOrig = currItem->yPos();
418
 
16729 fschmid 419
                ScItemState<QPair<FPointArray, FPointArray> > *state = NULL;
14371 jghali 420
                state = m_doc->nodeEdit.finishTransaction1(currItem);
421
                if (m_doc->nodeEdit.hasNodeSelected() && (m_doc->nodeEdit.SelNode.count() == 1))
422
                {
423
                        //FIXME:av
424
                        FPoint newP = m_canvas->globalToCanvas(m->globalPos());
425
                        currItem->OldB2 = currItem->width();
426
                        currItem->OldH2 = currItem->height();
427
                        FPointArray Clip;
428
                        FPoint npf;
429
                        double nx = newP.x();
430
                        double ny = newP.y();
17744 craig 431
                        if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
14371 jghali 432
                                npf = m_doc->ApplyGridF(FPoint(nx, ny));
433
                        else
434
                                npf = FPoint(nx, ny);
16976 fschmid 435
                        QTransform pp = currItem->getTransform();
436
                        npf = npf.transformPoint(pp, true);
17061 fschmid 437
                        if (m_doc->nodeEdit.isContourLine)
438
                                Clip = currItem->ContourLine;
439
                        else
16971 fschmid 440
                        {
17061 fschmid 441
                                Clip = currItem->PoLine;
442
                                if (currItem->isSymbol() || currItem->isGroup())
16972 fschmid 443
                                {
17061 fschmid 444
                                        if (currItem->imageFlippedH())
445
                                        {
446
                                                QTransform p;
447
                                                p.translate(currItem->width(), 0);
448
                                                p.scale(-1, 1);
449
                                                npf = npf.transformPoint(p, false);
450
                                        }
451
                                        if (currItem->imageFlippedV())
452
                                        {
453
                                                QTransform p;
454
                                                p.translate(0, currItem->height());
455
                                                p.scale(1, -1);
456
                                                npf = npf.transformPoint(p, false);
457
                                        }
16972 fschmid 458
                                }
16971 fschmid 459
                        }
14371 jghali 460
                        m_doc->nodeEdit.moveClipPoint(currItem, npf);
461
                }
16972 fschmid 462
                m_doc->AdjustItemSize(currItem, true, true);
14371 jghali 463
                if (!m_doc->nodeEdit.isContourLine)
464
                        currItem->ContourLine.translate(xposOrig - currItem->xPos(), yposOrig - currItem->yPos());
465
                m_doc->regionsChanged()->update(QRectF());
466
                if (state)
467
                {
468
                        m_doc->nodeEdit.finishTransaction2(currItem, state);
469
                }
470
                return;
471
        }
472
 
473
        m_canvas->setRenderModeUseBuffer(false);
474
        m_doc->DragP = false;
475
        m_doc->leaveDrag = false;
476
        m_canvas->m_viewMode.operItemMoving = false;
477
        m_canvas->m_viewMode.operItemResizing = false;
478
        m_view->MidButt = false;
479
        if (m_view->groupTransactionStarted())
480
        {
481
                for (int i = 0; i < m_doc->m_Selection->count(); ++i)
482
                        m_doc->m_Selection->itemAt(i)->checkChanges(true);
483
                m_view->endGroupTransaction();
484
        }
485
        //Commit drag created items to undo manager.
486
        if (m_doc->m_Selection->itemAt(0)!=NULL)
487
        {
16943 fschmid 488
                m_doc->itemAddCommit(m_doc->m_Selection->itemAt(0));
14371 jghali 489
        }
490
        //Make sure the Zoom spinbox and page selector dont have focus if we click on the canvas
491
        m_view->zoomSpinBox->clearFocus();
492
        m_view->pageSelector->clearFocus();
493
        if (m_doc->m_Selection->itemAt(0) != 0) // is there the old clip stored for the undo action
494
        {
495
                currItem = m_doc->m_Selection->itemAt(0);
496
                m_doc->nodeEdit.finishTransaction(currItem);
497
        }
498
}
499
 
14340 jghali 500
void CanvasMode_NodeEdit::keyPressEvent(QKeyEvent *e)
501
{
502
        commonkeyPressEvent_NormalNodeEdit(e);
503
}
504
 
505
void CanvasMode_NodeEdit::keyReleaseEvent(QKeyEvent *e)
506
{
507
        commonkeyReleaseEvent(e);
14371 jghali 508
}
509
 
510
void CanvasMode_NodeEdit::handleNodeEditPress(QMouseEvent* m, QRect)
511
{
512
        FPoint npf2;
513
 
514
        PageItem* currItem = m_doc->m_Selection->itemAt(0);
515
        FPointArray Clip = m_doc->nodeEdit.beginTransaction(currItem);
516
        bool edited = false;
517
        bool pfound = false;
518
        QTransform pm2 = currItem->getTransform();
16976 fschmid 519
        npf2 = m_canvas->globalToCanvas(m->globalPos()).transformPoint(pm2, true);
17061 fschmid 520
        if ((currItem->isSymbol() || currItem->isGroup()) && (!m_doc->nodeEdit.isContourLine))
16412 fschmid 521
        {
522
                if (currItem->imageFlippedH())
523
                {
524
                        pm2.translate(currItem->width(), 0);
525
                        pm2.scale(-1, 1);
526
                }
527
                if (currItem->imageFlippedV())
528
                {
529
                        pm2.translate(0, currItem->height());
530
                        pm2.scale(1, -1);
531
                }
532
        }
14371 jghali 533
        for (int a=0; a < signed(Clip.size()); ++a)
534
        {
535
                if (((m_doc->nodeEdit.EdPoints) && (a % 2 != 0)) || ((!m_doc->nodeEdit.EdPoints) && (a % 2 == 0)))
536
                                continue;
537
                QPointF npf = pm2.map(Clip.pointQF(a));
538
                if (m_canvas->hitsCanvasPoint(m->globalPos(), npf))
539
                {
540
                        m_doc->nodeEdit.ClRe = a;
541
                        if ((m_doc->nodeEdit.EdPoints) && (m_doc->nodeEdit.SelNode.contains(a) == 0))
542
                        {
543
                                if (m->modifiers() == Qt::ShiftModifier)
544
                                        m_doc->nodeEdit.SelNode.append(a);
545
                                else
546
                                {
547
                                        m_doc->nodeEdit.SelNode.clear();
548
                                        m_doc->nodeEdit.SelNode.append(a);
549
                                }
550
                        }
551
                        m_doc->nodeEdit.update(Clip.pointQF(a));
552
                        pfound = true;
553
                        edited = true;
554
                        break;
555
                }
556
        }
557
        if ((!pfound) || (!m_doc->nodeEdit.EdPoints))
558
                m_doc->nodeEdit.SelNode.clear();
559
 
560
        if ((m_doc->nodeEdit.submode == NodeEditContext::MOVE_POINT) && (m_doc->nodeEdit.ClRe2 != -1) && !m_doc->nodeEdit.hasNodeSelected())
561
        {
562
                m_doc->nodeEdit.SegP1 = m_doc->nodeEdit.ClRe2;
563
                m_doc->nodeEdit.SegP2 = m_doc->nodeEdit.ClRe2+2;
564
                m_doc->nodeEdit.ClRe = m_doc->nodeEdit.ClRe2;
565
        }
566
        FPointArray cli;
567
        uint EndInd = Clip.size();
568
        uint StartInd = 0;
18151 jghali 569
        if (m_doc->nodeEdit.ClRe > 0)
14371 jghali 570
        {
18151 jghali 571
                for (int n = m_doc->nodeEdit.ClRe; n < Clip.size(); ++n)
14371 jghali 572
                {
18151 jghali 573
                        if (Clip.point(n).x() > 900000)
574
                        {
575
                                EndInd = n;
576
                                break;
577
                        }
14371 jghali 578
                }
579
                for (uint n2 = m_doc->nodeEdit.ClRe; n2 > 0; n2--)
580
                {
581
                        if (n2 == 0)
582
                                break;
583
                        if (Clip.point(n2).x() > 900000)
584
                        {
585
                                StartInd = n2 + 1;
586
                                break;
587
                        }
588
                }
589
        }
590
        if (m_doc->nodeEdit.submode == NodeEditContext::SPLIT_PATH)
591
        {
592
                if (!m_doc->nodeEdit.EdPoints)
593
                        return;
594
                if (!m_doc->nodeEdit.hasNodeSelected()) // We don't have a Point, try to add one onto the current curve segment
595
                {
596
                        bool foundP = false;
597
                        uint seg = 0;
598
                        double absDist = 9999999999.9;
599
                        FPoint point = FPoint(0, 0);
600
                        FPoint normal = FPoint(0, 0);
601
                        FPoint tangent = FPoint(0, 0);
602
                        FPoint nearPoint = FPoint(0, 0);
603
                        double nearT = 0.0;
14932 cbradney 604
                        QRect mpo2(0, 0, m_doc->guidesPrefs().grabRadius*3, m_doc->guidesPrefs().grabRadius*3);
14371 jghali 605
                        mpo2.moveCenter(QPoint(qRound(npf2.x()), qRound(npf2.y())));
18114 jghali 606
                        for (int poi=0; poi<Clip.size()-3; poi += 4)
14371 jghali 607
                        {
608
                                FPoint a1 = Clip.point(poi);
609
                                FPoint a2 = Clip.point(poi+1);
610
                                FPoint a3 = Clip.point(poi+3);
611
                                FPoint a4 = Clip.point(poi+2);
612
                                QPainterPath Bez;
613
                                Bez.moveTo(a1.x(), a1.y());
614
                                Bez.cubicTo(a2.x(), a2.y(), a3.x(), a3.y(), a4.x(), a4.y());
615
                                QPolygon cli2 = Bez.toFillPolygon().toPolygon();
616
                                for (int clp = 0; clp < cli2.size()-1; ++clp)
617
                                {
618
                                        if (m_view->PointOnLine(cli2.point(clp), cli2.point(clp+1), mpo2))
619
                                        {
620
                                                seg = poi;
621
                                                double sp = 0.0;
622
                                                double spadd = 1.0 / (Clip.lenPathSeg(seg) * m_canvas->scale());
623
                                                while (sp < 1.0)
624
                                                {
625
                                                        Clip.pointTangentNormalAt(seg, sp, &point, &tangent, &normal );
626
                                                        double d1 = fabs(sqrt(pow(point.x() - npf2.x(), 2) + pow(point.y() - npf2.y() ,2)));
627
                                                        if (d1 < absDist)
628
                                                        {
629
                                                                foundP = true;
630
                                                                nearPoint = point;
631
                                                                nearT = sp;
632
                                                                absDist = d1;
633
                                                        }
634
                                                        sp += spadd;
635
                                                }
636
                                        }
637
                                }
638
                        }
639
                        cli.putPoints(0, m_doc->nodeEdit.ClRe2+2, Clip);
640
                        if (foundP)
641
                        {
642
                                npf2 = nearPoint;
643
                                FPoint base = cli.point(cli.size()-2);
644
                                FPoint c1 = cli.point(cli.size()-1);
645
                                FPoint base2 =  Clip.point(m_doc->nodeEdit.ClRe2+2);
646
                                FPoint c2 = Clip.point(m_doc->nodeEdit.ClRe2+3);
647
                                if ((base == c1) && (base2 == c2))
648
                                {
649
                                        cli.resize(cli.size()+4);
650
                                        cli.putPoints(cli.size()-4, 4, npf2.x(), npf2.y(), npf2.x(), npf2.y(), npf2.x(), npf2.y(), npf2.x(), npf2.y());
651
                                        cli.putPoints(cli.size(), Clip.size()-(m_doc->nodeEdit.ClRe2 + 2), Clip, m_doc->nodeEdit.ClRe2+2);
652
                                }
653
                                else
654
                                {
655
                                        FPoint cn1 = (1.0 - nearT) * base + nearT * c1;
656
                                        FPoint cn2 = (1.0 - nearT) * cn1 + nearT * ((1.0 - nearT) * c1 + nearT * c2);
657
                                        FPoint cn3 = (1.0 - nearT) * ((1.0 - nearT) * c1 + nearT * c2) + nearT * ((1.0 - nearT) * c2 + nearT * base2);
658
                                        FPoint cn4 = (1.0 - nearT) * c2 + nearT * base2;
659
                                        cli.setPoint(cli.size()-1, cn1);
660
                                        cli.resize(cli.size()+4);
661
                                        uint basind = cli.size()+1;
662
                                        cli.putPoints(cli.size()-4, 4, npf2.x(), npf2.y(), cn2.x(), cn2.y(), npf2.x(), npf2.y(), cn3.x(), cn3.y());
663
                                        cli.putPoints(cli.size(), Clip.size()-(m_doc->nodeEdit.ClRe2 + 2), Clip, m_doc->nodeEdit.ClRe2+2);
664
                                        cli.setPoint(basind, cn4);
665
                                }
666
                                Clip = cli.copy();
667
                                cli.resize(0);
668
                                m_doc->nodeEdit.ClRe = m_doc->nodeEdit.ClRe2+2;
669
                                m_doc->nodeEdit.ClRe2 = -1;
670
                                EndInd = Clip.size();
671
                                StartInd = 0;
18114 jghali 672
                                for (int n = m_doc->nodeEdit.ClRe; n < Clip.size(); ++n)
14371 jghali 673
                                {
674
                                        if (Clip.point(n).x() > 900000)
675
                                        {
676
                                                EndInd = n;
677
                                                break;
678
                                        }
679
                                }
680
                                if (m_doc->nodeEdit.ClRe > 0)
681
                                {
682
                                        for (uint n2 = m_doc->nodeEdit.ClRe; n2 > 0; n2--)
683
                                        {
684
                                                if (n2 == 0)
685
                                                        break;
686
                                                if (Clip.point(n2).x() > 900000)
687
                                                {
688
                                                        StartInd = n2 + 1;
689
                                                        break;
690
                                                }
691
                                        }
692
                                }
693
                        }
694
                        else
695
                                m_doc->nodeEdit.deselect();
696
                }
697
                if (m_doc->nodeEdit.hasNodeSelected())
698
                {
699
                        if (currItem->asPolygon())
700
                        {
701
                                if ((m_doc->nodeEdit.ClRe != 0) && (m_doc->nodeEdit.ClRe != static_cast<int>(EndInd-2)))
702
                                {
703
                                        if (currItem->Segments.count() == 0)
704
                                        {
705
                                                cli.putPoints(0, EndInd-(m_doc->nodeEdit.ClRe+2), Clip, m_doc->nodeEdit.ClRe+2);
706
                                                cli.putPoints(cli.size(), m_doc->nodeEdit.ClRe+2, Clip);
707
                                        }
708
                                        else
709
                                        {
710
                                                cli.putPoints(0, EndInd-StartInd, Clip, StartInd);
711
                                                int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, currItem->xPos(), currItem->yPos(), currItem->width(), currItem->height(), currItem->lineWidth(), currItem->fillColor(), currItem->lineColor(), true);
16943 fschmid 712
                                                PageItem* bb = m_doc->Items->takeAt(z);
14371 jghali 713
                                                if (m_doc->nodeEdit.isContourLine)
714
                                                        bb->ContourLine.resize(0);
715
                                                else
716
                                                        bb->PoLine.resize(0);
717
                                                if (StartInd != 0)
718
                                                {
719
                                                        if (m_doc->nodeEdit.isContourLine)
720
                                                        {
721
                                                                bb->ContourLine.putPoints(0, StartInd - 4, Clip);
722
                                                                bb->ContourLine.putPoints(bb->ContourLine.size(), Clip.size()-EndInd, Clip, EndInd);
723
                                                        }
724
                                                        else
725
                                                        {
726
                                                                bb->PoLine.putPoints(0, StartInd - 4, Clip);
727
                                                                bb->PoLine.putPoints(bb->PoLine.size(), Clip.size()-EndInd, Clip, EndInd);
728
                                                        }
729
                                                }
730
                                                else
731
                                                {
732
                                                        if (m_doc->nodeEdit.isContourLine)
733
                                                                bb->ContourLine.putPoints(0, Clip.size()-EndInd-4, Clip, EndInd+4);
734
                                                        else
735
                                                                bb->PoLine.putPoints(0, Clip.size()-EndInd-4, Clip, EndInd+4);
736
                                                }
737
                                                bb->setRotation(currItem->rotation());
16943 fschmid 738
                                                bb->ClipEdited = true;
739
                                                m_doc->Items->insert(m_doc->Items->indexOf(currItem), bb);
16972 fschmid 740
                                                m_doc->AdjustItemSize(bb, true, true);
14371 jghali 741
                                        }
742
                                        currItem->PoLine = cli.copy();
743
                                }
744
                                m_doc->nodeEdit.deselect();
745
                                currItem->ClipEdited = true;
746
                                edited = true;
747
                                m_doc->nodeEdit.submode = NodeEditContext::MOVE_POINT;
748
                                PageItem* newItem=m_doc->convertItemTo(currItem, PageItem::PolyLine);
749
                                currItem=newItem;
750
                                m_doc->m_Selection->clear();
751
                                m_doc->m_Selection->addItem(currItem);
752
                                emit m_view->PolyOpen();
753
                        }
754
                        else
755
                        {
756
                                if ((currItem->asPolyLine()) || (currItem->asPathText()))
757
                                {
758
                                        if ((m_doc->nodeEdit.ClRe > 1) && (m_doc->nodeEdit.ClRe < static_cast<int>(Clip.size()-2)))
759
                                        {
760
                                                int z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, currItem->xPos(), currItem->yPos(), currItem->width(), currItem->height(), currItem->lineWidth(), currItem->fillColor(), currItem->lineColor(), true);
761
                                                PageItem* bb = m_doc->Items->at(z);
762
                                                if (m_doc->nodeEdit.isContourLine)
763
                                                        bb->ContourLine.putPoints(0, Clip.size()-(m_doc->nodeEdit.ClRe+2), Clip, m_doc->nodeEdit.ClRe+2);
764
                                                else
765
                                                        bb->PoLine.putPoints(0, Clip.size()-(m_doc->nodeEdit.ClRe+2), Clip, m_doc->nodeEdit.ClRe+2);
766
                                                bb->setRotation(currItem->rotation());
16972 fschmid 767
                                                m_doc->AdjustItemSize(bb, true, true);
14371 jghali 768
                                                bb->ClipEdited = true;
769
                                                bb->setFrameType(currItem->frameType());
770
                                                cli.resize(0);
771
                                                cli.putPoints(0, m_doc->nodeEdit.ClRe+2, Clip);
772
                                                currItem->PoLine = cli.copy();
773
                                                m_doc->m_Selection->clear();
774
                                                m_doc->m_Selection->addItem(currItem);
775
                                        }
776
                                        m_doc->nodeEdit.deselect();
777
                                        currItem->ClipEdited = true;
778
                                        edited = true;
779
                                        m_doc->nodeEdit.submode = NodeEditContext::MOVE_POINT;
780
                                        currItem->setPolyClip(qRound(qMax(currItem->lineWidth() / 2.0, 1.0)));
781
                                        emit m_view->PolyOpen();
782
                                }
783
                        }
784
                }
785
        }
786
        if ((m_doc->nodeEdit.submode == NodeEditContext::DEL_POINT) && m_doc->nodeEdit.hasNodeSelected())
787
        {
788
                if (!m_doc->nodeEdit.EdPoints)
789
                        return;
16294 fschmid 790
                if (!(currItem->isLine() || currItem->isPathText() || currItem->isPolyLine()))
14371 jghali 791
                {
792
                        if ((currItem->Segments.count() == 0) && (Clip.size() <= 12))  // min. 3 points
16294 fschmid 793
                        {
794
                                m_doc->nodeEdit.deselect();
14371 jghali 795
                                return;
16294 fschmid 796
                        }
14371 jghali 797
                }
798
                else
799
                {
800
                        if (Clip.size() <= 4)
16294 fschmid 801
                        {
802
                                m_doc->nodeEdit.deselect();
14371 jghali 803
                                return;
16294 fschmid 804
                        }
14371 jghali 805
                }
806
                if ((currItem->Segments.count() != 0) && ((EndInd - StartInd) <= 12))
807
                {
808
                        if (StartInd != 0)
809
                                cli.putPoints(0, StartInd-4, Clip);
810
                        cli.putPoints(cli.size(), Clip.size() - EndInd, Clip, EndInd);
811
                }
812
                else
813
                {
814
                        if (m_doc->nodeEdit.ClRe == static_cast<int>(StartInd))
815
                        {
16294 fschmid 816
                                if (!(currItem->isLine() || currItem->isPathText() || currItem->isPolyLine()))
14371 jghali 817
                                {
818
                                        FPoint kp(Clip.point(EndInd-3));
819
                                        cli.putPoints(0, StartInd, Clip);
820
                                        cli.putPoints(cli.size(), EndInd - StartInd - 4, Clip, StartInd);
821
                                        cli.setPoint(StartInd, cli.point(cli.size()-2));
822
                                        cli.setPoint(StartInd + 1, kp);
823
                                        cli.putPoints(cli.size(), Clip.size() - EndInd, Clip, EndInd);
824
                                }
825
                                else
826
                                {
827
                                        cli.putPoints(0, StartInd, Clip);
828
                                        cli.putPoints(cli.size(), EndInd - StartInd - 4, Clip, StartInd+4);
829
                                        cli.putPoints(cli.size(), Clip.size() - EndInd, Clip, EndInd);
830
                                }
831
                        }
832
                        else
833
                        {
834
                                if (m_doc->nodeEdit.ClRe != 0)
835
                                        cli.putPoints(0, m_doc->nodeEdit.ClRe, Clip);
836
                                cli.putPoints(cli.size(), Clip.size()-(m_doc->nodeEdit.ClRe + 4), Clip, m_doc->nodeEdit.ClRe+4);
837
                        }
838
                }
839
                if (m_doc->nodeEdit.isContourLine)
840
                        currItem->ContourLine = cli.copy();
841
                else
842
                        currItem->PoLine = cli.copy();
843
                m_doc->nodeEdit.deselect();
844
                currItem->ClipEdited = true;
845
                edited = true;
846
        }
847
        if ((m_doc->nodeEdit.submode == NodeEditContext::ADD_POINT) && (m_doc->nodeEdit.ClRe2 != -1))
848
        {
849
                bool foundP = false;
850
                uint seg = 0;
851
                double absDist = 9999999999.9;
852
                FPoint point = FPoint(0, 0);
853
                FPoint normal = FPoint(0, 0);
854
                FPoint tangent = FPoint(0, 0);
855
                FPoint nearPoint = FPoint(0, 0);
856
                double nearT = 0.0;
14932 cbradney 857
                QRect mpo2(0, 0, m_doc->guidesPrefs().grabRadius*3, m_doc->guidesPrefs().grabRadius*3);
14371 jghali 858
                mpo2.moveCenter(QPoint(qRound(npf2.x()), qRound(npf2.y())));
18114 jghali 859
                for (int poi = 0; poi < Clip.size()-3; poi += 4)
14371 jghali 860
                {
861
                        FPoint a1 = Clip.point(poi);
862
                        FPoint a2 = Clip.point(poi+1);
863
                        FPoint a3 = Clip.point(poi+3);
864
                        FPoint a4 = Clip.point(poi+2);
865
                        QPainterPath Bez;
866
                        Bez.moveTo(a1.x(), a1.y());
867
                        Bez.cubicTo(a2.x(), a2.y(), a3.x(), a3.y(), a4.x(), a4.y());
868
                        QPolygon cli2 = Bez.toFillPolygon().toPolygon();
869
                        for (int clp = 0; clp < cli2.size()-1; ++clp)
870
                        {
871
                                if (m_view->PointOnLine(cli2.point(clp), cli2.point(clp+1), mpo2))
872
                                {
873
                                        seg = poi;
874
                                        double sp = 0.0;
875
                                        double spadd = 1.0 / (Clip.lenPathSeg(seg) * m_canvas->scale());
876
                                        while (sp < 1.0)
877
                                        {
878
                                                Clip.pointTangentNormalAt(seg, sp, &point, &tangent, &normal );
879
                                                double d1 = fabs(sqrt(pow(point.x() - npf2.x(), 2) + pow(point.y() - npf2.y() ,2)));
880
                                                if (d1 < absDist)
881
                                                {
882
                                                        foundP = true;
883
                                                        nearPoint = point;
884
                                                        nearT = sp;
885
                                                        absDist = d1;
886
                                                }
887
                                                sp += spadd;
888
                                        }
889
                                }
890
                        }
891
                }
892
                cli.putPoints(0, m_doc->nodeEdit.ClRe2+2, Clip);
893
                if (foundP)
894
                {
895
                        npf2 = nearPoint;
896
                        FPoint base = cli.point(cli.size()-2);
897
                        FPoint c1 = cli.point(cli.size()-1);
898
                        FPoint base2 =  Clip.point(m_doc->nodeEdit.ClRe2+2);
899
                        FPoint c2 = Clip.point(m_doc->nodeEdit.ClRe2+3);
900
                        if ((base == c1) && (base2 == c2))
901
                        {
902
                                cli.resize(cli.size()+4);
903
                                cli.putPoints(cli.size()-4, 4, npf2.x(), npf2.y(), npf2.x(), npf2.y(), npf2.x(), npf2.y(), npf2.x(), npf2.y());
904
                                                cli.putPoints(cli.size(), Clip.size()-(m_doc->nodeEdit.ClRe2 + 2), Clip, m_doc->nodeEdit.ClRe2+2);
905
                        }
906
                        else
907
                        {
908
                                FPoint cn1 = (1.0 - nearT) * base + nearT * c1;
909
                                FPoint cn2 = (1.0 - nearT) * cn1 + nearT * ((1.0 - nearT) * c1 + nearT * c2);
910
                                FPoint cn3 = (1.0 - nearT) * ((1.0 - nearT) * c1 + nearT * c2) + nearT * ((1.0 - nearT) * c2 + nearT * base2);
911
                                FPoint cn4 = (1.0 - nearT) * c2 + nearT * base2;
912
                                cli.setPoint(cli.size()-1, cn1);
913
                                cli.resize(cli.size()+4);
914
                                uint basind = cli.size()+1;
915
                                cli.putPoints(cli.size()-4, 4, npf2.x(), npf2.y(), cn2.x(), cn2.y(), npf2.x(), npf2.y(), cn3.x(), cn3.y());
916
                                cli.putPoints(cli.size(), Clip.size()-(m_doc->nodeEdit.ClRe2 + 2), Clip, m_doc->nodeEdit.ClRe2+2);
917
                                cli.setPoint(basind, cn4);
918
                        }
919
                }
920
                else
921
                {
922
                        cli.resize(cli.size()+4);
923
                        cli.putPoints(cli.size()-4, 4, npf2.x(), npf2.y(), npf2.x(), npf2.y(), npf2.x(), npf2.y(), npf2.x(), npf2.y());
924
                        cli.putPoints(cli.size(), Clip.size()-(m_doc->nodeEdit.ClRe2 + 2), Clip, m_doc->nodeEdit.ClRe2+2);
925
                }
926
                if (m_doc->nodeEdit.isContourLine)
927
                        currItem->ContourLine = cli.copy();
928
                else
929
                        currItem->PoLine = cli.copy();
930
                m_doc->nodeEdit.ClRe2 = -1;
931
                currItem->ClipEdited = true;
932
                edited = true;
933
        }
934
        if (edited)
935
        {
936
                currItem->FrameType = 3;
16321 fschmid 937
                double xp, yp, w, h, xp2, yp2, w2, h2;
938
                xp = currItem->xPos();
939
                yp = currItem->yPos();
940
                w = currItem->width();
941
                h = currItem->height();
16972 fschmid 942
                m_doc->AdjustItemSize(currItem, true, true);
16321 fschmid 943
                xp2 = currItem->xPos();
944
                yp2 = currItem->yPos();
945
                w2 = currItem->width();
946
                h2 = currItem->height();
14371 jghali 947
                currItem->update();
16321 fschmid 948
                if ((xp != xp2) || (yp != yp2) || (w != w2) || (h != h2))
949
                        m_view->DrawNew();
14371 jghali 950
        }
16972 fschmid 951
        else
952
        {
953
                currItem->update();
954
                m_view->DrawNew();
955
        }
14371 jghali 956
        if ((m_doc->nodeEdit.SelNode.count() != 0) || ((m_doc->nodeEdit.SegP1 != -1) && (m_doc->nodeEdit.SegP2 != -1)) || (m_doc->nodeEdit.hasNodeSelected() && (!m_doc->nodeEdit.EdPoints)))
957
        {
958
                Mxp = m->x();
959
                Myp = m->y();
960
                m_canvas->setRenderModeFillBuffer();
961
        }
962
        else
963
        {
964
                Mxp = m->x();
965
                Myp = m->y();
966
                Dxp = qRound(m->x()/m_canvas->scale());  // + m_doc->minCanvasCoordinate.x());
967
                Dyp = qRound(m->y()/m_canvas->scale());  // + m_doc->minCanvasCoordinate.y());
968
                if (!m_rectangleSelect)
969
                        m_rectangleSelect = new RectSelect(this);
970
                m_rectangleSelect->prepare(m->globalPos());
971
                m_view->startGesture(m_rectangleSelect);
972
        }
973
 
974
}
975
 
976
 
977
 
978
bool CanvasMode_NodeEdit::handleNodeEditMove(QMouseEvent* m, QRect, PageItem* currItem, QTransform)
979
{
980
        QTransform itemPos = currItem->getTransform();
17061 fschmid 981
        if ((currItem->isSymbol() || currItem->isGroup()) && (!m_doc->nodeEdit.isContourLine))
16972 fschmid 982
        {
983
                if (currItem->imageFlippedH())
984
                {
985
                        itemPos.translate(currItem->width(), 0);
986
                        itemPos.scale(-1, 1);
987
                }
988
                if (currItem->imageFlippedV())
989
                {
990
                        itemPos.translate(0, currItem->height());
991
                        itemPos.scale(1, -1);
992
                }
993
        }
14371 jghali 994
        FPointArray Clip;
995
        m_doc->nodeEdit.ClRe2 = -1;
996
        m_doc->nodeEdit.SegP1 = -1;
997
        m_doc->nodeEdit.SegP2 = -1;
998
        if (m_doc->nodeEdit.isContourLine)
999
                Clip = currItem->ContourLine;
1000
        else
1001
                Clip = currItem->PoLine;
1002
        if ((m_doc->nodeEdit.submode == NodeEditContext::DEL_POINT) ||
1003
                (m_doc->nodeEdit.submode == NodeEditContext::MOVE_POINT) ||
1004
                (m_doc->nodeEdit.submode == NodeEditContext::SPLIT_PATH))
1005
        {
1006
                for (int a=0; a < signed(Clip.size()); ++a)
1007
                {
1008
                        if (((m_doc->nodeEdit.EdPoints) && (a % 2 != 0)) || ((!m_doc->nodeEdit.EdPoints) && (a % 2 == 0)))
1009
                                continue;
1010
                        QPointF point = Clip.pointQF(a);
1011
                        if (m_canvas->hitsCanvasPoint(m->globalPos(), itemPos.map(point)))
1012
                        {
1013
                                if (m_doc->nodeEdit.submode == NodeEditContext::MOVE_POINT)
1014
                                        qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1015
                                if (m_doc->nodeEdit.submode == NodeEditContext::DEL_POINT)
1016
                                        qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png"), 1, 1));
1017
                                if (m_doc->nodeEdit.submode == NodeEditContext::SPLIT_PATH)
1018
                                        qApp->changeOverrideCursor(QCursor(loadIcon("Split.png"), 1, 1));
1019
                                return true;
1020
                        }
1021
                }
1022
        }
1023
        if ((m_doc->nodeEdit.submode == NodeEditContext::ADD_POINT) ||
1024
                (m_doc->nodeEdit.submode == NodeEditContext::MOVE_POINT) ||
1025
                (m_doc->nodeEdit.submode == NodeEditContext::SPLIT_PATH && m_doc->nodeEdit.EdPoints))
1026
        {
18114 jghali 1027
                for (int poi = 0; poi < Clip.size()-3; poi += 4)
14371 jghali 1028
                {
1029
                        // create bezier curve in canvas coords
1030
                        QPointF a1 = itemPos.map(Clip.pointQF(poi));
1031
                        QPointF a2 = itemPos.map(Clip.pointQF(poi+1));
1032
                        QPointF a3 = itemPos.map(Clip.pointQF(poi+3));
1033
                        QPointF a4 = itemPos.map(Clip.pointQF(poi+2));
1034
                        QPainterPath Bez;
1035
                        Bez.moveTo(a1);
1036
                        Bez.cubicTo(a2, a3, a4);
1037
                        double len = Bez.length();
1038
                        if (len > 0.0)
1039
                        {
1040
                                double delta = 2.0 / len;
1041
                                for (double d = 0.0; d <= 1.0; d += delta)
1042
                                {
1043
                                        QPointF pl = Bez.pointAtPercent(d);
1044
                                        if (m_canvas->hitsCanvasPoint(m->globalPos(), FPoint(pl.x(), pl.y())))
1045
                                        {
1046
                                                if (m_doc->nodeEdit.submode == NodeEditContext::MOVE_POINT)
1047
                                                        qApp->changeOverrideCursor(QCursor(loadIcon("HandC.xpm")));
1048
                                                else if (m_doc->nodeEdit.submode == NodeEditContext::ADD_POINT)
1049
                                                        qApp->changeOverrideCursor(QCursor(loadIcon("AddPoint.png"), 1, 1));
1050
                                                else if (m_doc->nodeEdit.submode == NodeEditContext::SPLIT_PATH)
1051
                                                        qApp->changeOverrideCursor(QCursor(loadIcon("Split.png"), 1, 1));
1052
                                                else
1053
                                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1054
                                                m_doc->nodeEdit.ClRe2 = poi;
1055
                                                return true;
1056
                                        }
1057
                                }
1058
                        }
1059
                }
1060
        }
1061
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1062
        return false;
1063
}
1064
 
1065
void CanvasMode_NodeEdit::handleNodeEditDrag(QMouseEvent* m, PageItem* currItem)
1066
{
1067
        FPoint npf;
1068
        if ((m_canvas->m_viewMode.m_MouseButtonPressed) && !m_doc->nodeEdit.hasNodeSelected() && (m_doc->nodeEdit.SegP1 == -1) && (m_doc->nodeEdit.SegP2 == -1))
1069
        {
1070
                if (!m_rectangleSelect)
1071
                {
1072
                        m_rectangleSelect = new RectSelect(this);
1073
                }
1074
                m_rectangleSelect->prepare(m->globalPos());
1075
                m_view->startGesture(m_rectangleSelect);
1076
                return;
1077
        }
1078
        int newX = m->x();
1079
        int newY = m->y();
16412 fschmid 1080
        FPoint np(newX - Mxp, newY - Myp, 0, 0, currItem->rotation(), 1, 1, true);
14371 jghali 1081
        np = np * (1.0 / m_canvas->scale());
1082
        m_canvas->m_viewMode.operItemMoving = true;
1083
        currItem = m_doc->m_Selection->itemAt(0);
1084
        if ((m_doc->nodeEdit.SegP1 != -1) && (m_doc->nodeEdit.SegP2 != -1))
1085
        {
17061 fschmid 1086
                if ((currItem->isSymbol() || currItem->isGroup()) && (!m_doc->nodeEdit.isContourLine))
16972 fschmid 1087
                {
1088
                        if (currItem->imageFlippedH())
1089
                                np.setX(np.x() * -1);
1090
                        if (currItem->imageFlippedV())
1091
                                np.setY(np.y() * -1);
1092
                }
14371 jghali 1093
                if (m_doc->nodeEdit.isContourLine)
1094
                        npf = currItem->ContourLine.point(m_doc->nodeEdit.SegP2) + np;
1095
                else
1096
                        npf = currItem->PoLine.point(m_doc->nodeEdit.SegP2) + np;
1097
                m_doc->nodeEdit.ClRe = m_doc->nodeEdit.SegP2;
1098
                m_doc->nodeEdit.moveClipPoint(currItem, npf);
1099
                if (m_doc->nodeEdit.isContourLine)
1100
                        npf = currItem->ContourLine.point(m_doc->nodeEdit.SegP1) + np;
1101
                else
1102
                        npf = currItem->PoLine.point(m_doc->nodeEdit.SegP1) + np;
1103
                m_doc->nodeEdit.ClRe = m_doc->nodeEdit.SegP1;
1104
                m_doc->nodeEdit.moveClipPoint(currItem, npf);
1105
                Mxp = newX;
1106
                Myp = newY;
1107
        }
1108
        else
1109
        {
1110
                if ((m_doc->nodeEdit.SelNode.count() != 0) && (m_doc->nodeEdit.EdPoints))
1111
                {
1112
                        int storedClRe = m_doc->nodeEdit.ClRe;
1113
                        if (m_doc->nodeEdit.SelNode.count() == 1)
1114
                        {
1115
                                npf = m_canvas->globalToCanvas(m->globalPos());
1116
                                double nx = npf.x();
1117
                                double ny = npf.y();
17744 craig 1118
                                if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
14371 jghali 1119
                                        npf = m_doc->ApplyGridF(FPoint(nx, ny));
1120
                                else
1121
                                        npf = FPoint(nx, ny);
16976 fschmid 1122
                                QTransform pp = currItem->getTransform();
1123
                                npf = npf.transformPoint(pp, true);
17061 fschmid 1124
                                if ((currItem->isSymbol() || currItem->isGroup()) && (!m_doc->nodeEdit.isContourLine))
16971 fschmid 1125
                                {
16972 fschmid 1126
                                        if (currItem->imageFlippedH())
1127
                                        {
1128
                                                QTransform p;
1129
                                                p.translate(currItem->width(), 0);
1130
                                                p.scale(-1, 1);
1131
                                                npf = npf.transformPoint(p, false);
1132
                                        }
1133
                                        if (currItem->imageFlippedV())
1134
                                        {
1135
                                                QTransform p;
1136
                                                p.translate(0, currItem->height());
1137
                                                p.scale(1, -1);
1138
                                                npf = npf.transformPoint(p, false);
1139
                                        }
16971 fschmid 1140
                                }
17640 craig 1141
 
1142
                                //Control Modifier to have parallele shape
1143
                                if (m->modifiers() == Qt::ControlModifier){
1144
                                        FPointArray cli;
1145
                                        if (m_doc->nodeEdit.isContourLine)
1146
                                                cli = currItem->ContourLine;
1147
                                        else
1148
                                                cli = currItem->PoLine;
1149
                                        FPoint npf1(npf);
1150
                                        int tmpNode;
1151
                                        int curr = (m_doc->nodeEdit.ClRe==0)?cli.size()-2:m_doc->nodeEdit.ClRe;
1152
                                        int prev = (curr+cli.size()-4)%cli.size();
1153
                                        int next = (curr+4)%cli.size();
1154
 
1155
                                        if(abs(cli.point(prev).x()-cli.point(curr).x())<abs(cli.point(next).x()-cli.point(curr).x()))
1156
                                                tmpNode=next;
1157
                                        else if(abs(cli.point(prev).x()-cli.point(curr).x())==abs(cli.point(next).x()-cli.point(curr).x())){
1158
                                                if(cli.point(prev).y()!=cli.point(curr).y())
1159
                                                        tmpNode=next;
1160
                                                else
1161
                                                        tmpNode=prev;
1162
                                        }
1163
                                        else
1164
                                                tmpNode=prev;
1165
 
1166
                                        m_doc->nodeEdit.moveClipPoint(currItem, npf);
1167
 
1168
                                        m_doc->nodeEdit.ClRe=tmpNode;
1169
 
1170
                                        if (m_doc->nodeEdit.isContourLine)
1171
                                                npf1.setX(currItem->ContourLine.point(m_doc->nodeEdit.ClRe).x());
1172
                                        else
1173
                                                npf1.setX(currItem->PoLine.point(m_doc->nodeEdit.ClRe).x());
1174
 
1175
                                        m_doc->nodeEdit.moveClipPoint(currItem, npf1);
1176
 
1177
                                        if(m_doc->nodeEdit.ClRe==prev)
1178
                                                m_doc->nodeEdit.ClRe=next;
1179
                                        else
1180
                                                m_doc->nodeEdit.ClRe=prev;
1181
 
1182
                                        if (m_doc->nodeEdit.isContourLine)
1183
                                                npf.setY(currItem->ContourLine.point(m_doc->nodeEdit.ClRe).y());
1184
                                        else
1185
                                                npf.setY(currItem->PoLine.point(m_doc->nodeEdit.ClRe).y());
1186
 
1187
 
1188
                                }
14371 jghali 1189
                                m_doc->nodeEdit.moveClipPoint(currItem, npf);
17640 craig 1190
 
14371 jghali 1191
                                m_canvas->displayXYHUD(m->globalPos(), npf.x(), npf.y());
1192
                        }
1193
                        else
1194
                        {
17061 fschmid 1195
                                if ((currItem->isSymbol() || currItem->isGroup()) && (!m_doc->nodeEdit.isContourLine))
16976 fschmid 1196
                                {
1197
                                        if (currItem->imageFlippedH())
1198
                                                np.setX(np.x() * -1);
1199
                                        if (currItem->imageFlippedV())
1200
                                                np.setY(np.y() * -1);
1201
                                }
14371 jghali 1202
                                for (int itm = 0; itm < m_doc->nodeEdit.SelNode.count(); ++itm)
1203
                                {
1204
                                        m_doc->nodeEdit.ClRe = m_doc->nodeEdit.SelNode.at(itm);
1205
                                        if (m_doc->nodeEdit.isContourLine)
1206
                                                npf = currItem->ContourLine.point(m_doc->nodeEdit.ClRe) + np;
1207
                                        else
1208
                                                npf = currItem->PoLine.point(m_doc->nodeEdit.ClRe) + np;
1209
                                        m_doc->nodeEdit.moveClipPoint(currItem, npf);
1210
                                }
1211
                        }
1212
                        m_doc->nodeEdit.ClRe = storedClRe;
1213
                }
1214
                else
1215
                {
1216
                        npf = m_canvas->globalToCanvas(m->globalPos());
1217
                        double nx = npf.x();
1218
                        double ny = npf.y();
17744 craig 1219
                        if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
14371 jghali 1220
                                npf = m_doc->ApplyGridF(FPoint(nx, ny));
1221
                        else
1222
                                npf = FPoint(nx, ny);
16976 fschmid 1223
                        QTransform pp = currItem->getTransform();
1224
                        npf = npf.transformPoint(pp, true);
17061 fschmid 1225
                        if ((currItem->isSymbol() || currItem->isGroup()) && (!m_doc->nodeEdit.isContourLine))
16976 fschmid 1226
                        {
1227
                                if (currItem->imageFlippedH())
1228
                                {
1229
                                        QTransform p;
1230
                                        p.translate(currItem->width(), 0);
1231
                                        p.scale(-1, 1);
1232
                                        npf = npf.transformPoint(p, false);
1233
                                }
1234
                                if (currItem->imageFlippedV())
1235
                                {
1236
                                        QTransform p;
1237
                                        p.translate(0, currItem->height());
1238
                                        p.scale(1, -1);
1239
                                        npf = npf.transformPoint(p, false);
1240
                                }
1241
                        }
14371 jghali 1242
                        m_doc->nodeEdit.moveClipPoint(currItem, npf);
1243
                        m_canvas->displayXYHUD(m->globalPos(), npf.x(), npf.y());
1244
                }
1245
                Mxp = newX;
1246
                Myp = newY;
1247
        }
1248
        m_canvas->m_viewMode.operItemMoving = false;
1249
        m_doc->regionsChanged()->update(QRectF());
1250
}