Subversion Repositories Scribus

Rev

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

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