Subversion Repositories Scribus

Rev

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

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