Subversion Repositories Scribus

Rev

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