Subversion Repositories Scribus

Rev

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