Subversion Repositories Scribus

Rev

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

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