Subversion Repositories Scribus

Rev

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