Subversion Repositories Scribus

Rev

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