Subversion Repositories Scribus

Rev

Rev 25063 | Details | Compare with Previous | Last modification | View Log | RSS feed

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