Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
12610 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
 
17
#include "canvasmode_create.h"
18
 
19
#include <QApplication>
20
#include <QButtonGroup>
21
#include <QCheckBox>
22
#include <QCursor>
23
#include <QEvent>
24
#include <QMessageBox>
25
#include <QMouseEvent>
26
#include <QPainterPath>
27
#include <QPoint>
28
#include <QRect>
29
#include <QWidgetAction>
30
 
31
#include "canvas.h"
32
#include "fpoint.h"
33
#include "fpointarray.h"
34
#include "hruler.h"
35
#include "vruler.h"
36
#include "hyphenator.h"
37
#include "insertTable.h"
38
#include "oneclick.h"
39
#include "pageitem_textframe.h"
40
#include "pageselector.h"
41
#include "prefscontext.h"
42
#include "prefsfile.h"
43
#include "prefsmanager.h"
44
#include "propertiespalette.h"
45
#include "scraction.h"
46
#include "scrapbookpalette.h"
47
#include "scribus.h"
48
#include "scribusdoc.h"
49
#include "scribusview.h"
50
#include "scribusXml.h"
51
#include "selection.h"
52
#include "undomanager.h"
53
#include "units.h"
54
#include "util.h"
55
#include "util_icon.h"
56
#include "util_math.h"
57
 
58
 
59
 
60
CreateMode::CreateMode(ScribusView* view) : CanvasMode(view)
61
{
62
        canvasPressCoord.setXY(-1.0, -1.0);
63
        mouseGlobalCoord.setXY(-1.0, -1.0);
64
        inItemCreation = false;
65
        createObjectMode     = 0;
66
        createObjectSubMode  = 0;
67
        modifiers            = 0;
68
        m_MouseButtonPressed = false;
69
        m_createTransaction  = NULL;
70
}
71
 
72
 
73
void CreateMode::drawControls(QPainter* p)
74
{
75
        if (!inItemCreation) return;
76
 
77
        QPointF topLeft(createObjectPos.x(), createObjectPos.y());
78
        QPointF btRight(canvasCurrCoord.x(), canvasCurrCoord.y());
79
        QColor  drawColor = qApp->palette().color(QPalette::Active, QPalette::Highlight);
80
 
81
        if (createObjectMode != modeDrawLine)
82
        {
83
                QRectF  bounds = QRectF(topLeft, btRight).normalized();
84
                QRect   localRect = m_canvas->canvasToLocal(bounds);
85
 
86
                p->setRenderHint(QPainter::Antialiasing);
87
 
88
                p->save();
89
                p->setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
90
                drawColor.setAlpha(64);
91
                p->setBrush(drawColor);
92
                p->drawRect(localRect);
93
 
94
                drawColor.setAlpha(255);
95
                p->setBrush(Qt::NoBrush);
96
                p->setPen(QPen(drawColor, 1, Qt::DashLine, Qt::FlatCap, Qt::MiterJoin));
97
 
98
                int frameType = 0, itemType = 0;
99
                getFrameItemTypes(itemType, frameType);
100
                if (frameType == PageItem::Ellipse)
101
                {
102
                        p->drawEllipse(localRect);
103
                }
104
                else if (createObjectMode == modeDrawRegularPolygon)
105
                {
106
                        FPointArray cli = RegularPolygonF(localRect.width(), localRect.height(), m_doc->toolSettings.polyC, m_doc->toolSettings.polyS, m_doc->toolSettings.polyF, m_doc->toolSettings.polyR);
107
                        FPoint np(cli.point(0));
108
                        QPainterPath path;
109
                        path.moveTo(np.x(), np.y());
110
                        for (uint ax = 1; ax < cli.size(); ++ax)
111
                        {
112
                                np = FPoint(cli.point(ax));
113
                                path.lineTo(np.x(), np.y());
114
                        }
115
                        np = FPoint(cli.point(0));
116
                        path.lineTo(np.x(), np.y());
117
                        p->translate(localRect.left(), localRect.top());
118
                        p->drawPath(path);
119
                }
120
                else if ((createObjectMode == modeDrawShapes) && (createObjectSubMode > 1))
121
                {
122
                        FPointArray poly;
123
                        int valCount = m_doc->ValCount;
124
                        double *vals = m_doc->ShapeValues;
125
                        for (int a = 0; a < valCount-3; a += 4)
126
                        {
127
                                if (vals[a] < 0)
128
                                {
129
                                        poly.setMarker();
130
                                        continue;
131
                                }
132
                                double x1 = localRect.width()  * vals[a] / 100.0;
133
                                double y1 = localRect.height() * vals[a+1] / 100.0;
134
                                double x2 = localRect.width()  * vals[a+2] / 100.0;
135
                                double y2 = localRect.height() * vals[a+3] / 100.0;
136
                                poly.addPoint(x1, y1);
137
                                poly.addPoint(x2, y2);
138
                        }
139
                        QPainterPath path = poly.toQPainterPath(false);
140
                        p->translate(localRect.left(), localRect.top());
141
                        p->drawPath(path);
142
                }
143
                p->restore();
144
        }
145
        else
146
        {
147
                QPoint p1 = m_canvas->canvasToLocal(topLeft);
148
                QPoint p2 = m_canvas->canvasToLocal(btRight);
149
 
150
                p->save();
151
                p->setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
152
                p->setBrush(drawColor);
153
                p->drawLine(p1, p2);
154
                p->restore();
155
        }
156
}
157
 
158
inline bool CreateMode::GetItem(PageItem** pi)
159
{
160
        *pi = m_doc->m_Selection->itemAt(0);
161
        return (*pi) != NULL;
162
}
163
 
164
// the following code was moved from scribusview.cpp:
165
 
166
 
167
void CreateMode::enterEvent(QEvent *)
168
{
169
        if (!m_MouseButtonPressed)
170
        {
171
                setModeCursor();
172
        }
173
}
174
 
175
 
176
void CreateMode::leaveEvent(QEvent *e)
177
{
178
        if (!m_MouseButtonPressed)
179
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
180
}
181
 
182
 
183
void CreateMode::activate(bool fromGesture)
184
{
185
        PageItem* currItem;
186
//      qDebug() << "CreateMode::activate" << fromGesture;
187
        if (!fromGesture || !GetItem(&currItem) || !m_createTransaction)
188
        {
189
                if (m_createTransaction)
190
                {
191
//                      qDebug() << "canceling left over create Transaction";
192
                        m_createTransaction->cancel();
193
                        delete m_createTransaction;
194
                        m_createTransaction = NULL;
195
                }
196
                canvasPressCoord.setXY(-1.0, -1.0);
197
                mouseGlobalCoord.setXY(-1.0, -1.0);
198
                inItemCreation = false;
199
        }              
200
        setModeCursor();
201
}
202
 
203
void CreateMode::deactivate(bool forGesture)
204
{
205
//      qDebug() << "CreateMode::deactivate" << forGesture;
206
        if (!forGesture)
207
        {              
208
                if (m_createTransaction)
209
                {
210
//                      qDebug() << "CreateMode::deactivate: canceling left over create Transaction";
211
                        m_createTransaction->cancel();
212
                        delete m_createTransaction;
213
                        m_createTransaction = NULL;
214
                }
215
        }
216
}
217
 
218
void CreateMode::mouseDoubleClickEvent(QMouseEvent *m)
219
{
220
        m->accept();
221
        m_MouseButtonPressed = false;
222
        m_canvas->resetRenderMode();
223
}
224
 
225
 
226
void CreateMode::mouseMoveEvent(QMouseEvent *m)
227
{
228
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
229
 
230
        double newX, newY;
231
        PageItem *currItem;
232
        QPoint np, np2, mop;
233
        QPainter p;
234
        QRect tx;
235
        m->accept();
236
//      qDebug() << "legacy mode move:" << m->x() << m->y() << m_canvas->globalToCanvas(m->globalPos()).x() << m_canvas->globalToCanvas(m->globalPos()).y();
237
//      emit MousePos(m->x()/m_canvas->scale(),// + m_doc->minCanvasCoordinate.x(), 
238
//                                m->y()/m_canvas->scale()); // + m_doc->minCanvasCoordinate.y());
239
 
240
        if (m_MouseButtonPressed && (m->buttons() & Qt::RightButton) && (m->modifiers() & Qt::ControlModifier))
241
        {
242
                m_view->requestMode(modePanning);
243
        }
244
 
245
        if (GetItem(&currItem))
246
        {
247
                newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
248
                newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
249
 
250
                if (m_doc->DragP)
251
                        return;
252
        }
253
        else
254
        {
255
                if ((m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
256
                {
257
                        newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
258
                        if (m_doc->appMode == modeMagnifier)
259
                                newY = qRound(canvasPressCoord.y() + ((canvasCurrCoord.x() - canvasPressCoord.x()) * m_view->visibleHeight()) / m_view->visibleWidth());
260
                        else
261
                                newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
262
 
263
                        FPoint np2 = m_doc->ApplyGridF(FPoint(newX, newY));
264
                        double nx = np2.x();
265
                        double ny = np2.y();
266
                        m_doc->ApplyGuides(&nx, &ny);
267
                        newX = qRound(nx);
268
                        newY = qRound(ny);
269
                        canvasCurrCoord.setXY(newX, newY);
270
                        QPoint startP = m_canvas->canvasToGlobal(canvasPressCoord);
271
                        m_view->HaveSelRect = true;
272
 
273
                        // Necessary for drawControls to be called
274
                        m_canvas->repaint();
275
                }
276
        }
277
}
278
 
279
void CreateMode::mousePressEvent(QMouseEvent *m)
280
{
281
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
282
 
283
        double Rxp = 0, Ryp = 0;
284
        double Rxpd = 0,Rypd = 0;
285
        m_MouseButtonPressed = true;
286
        m_view->HaveSelRect = false;
287
        m_doc->DragP = false;
288
        m_doc->leaveDrag = false;
289
        inItemCreation = false;
290
//      oldClip = 0;
291
        m->accept();
292
        m_view->registerMousePress(m->globalPos());
293
        QRect mpo(m->x()-m_doc->guidesSettings.grabRad, m->y()-m_doc->guidesSettings.grabRad, m_doc->guidesSettings.grabRad*2, m_doc->guidesSettings.grabRad*2);
294
//      mpo.moveBy(qRound(m_doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(m_doc->minCanvasCoordinate.y() * m_canvas->scale()));
295
        canvasPressCoord = mousePointDoc;
296
        createObjectMode = m_doc->appMode;
297
        createObjectSubMode = m_doc->SubMode;
298
        createObjectPos  = m_doc->ApplyGridF(canvasPressCoord);
299
 
300
        Rxp  = m_doc->ApplyGridF(canvasPressCoord).x();
301
        Rxpd = canvasPressCoord.x() - Rxp;
302
        canvasPressCoord.setX(qRound(Rxp));
303
        Ryp  = m_doc->ApplyGridF(canvasPressCoord).y();
304
        Rypd = canvasPressCoord.y() - Ryp;
305
 
306
        canvasPressCoord.setXY(qRound(Rxp), qRound(Ryp));
307
        canvasCurrCoord = canvasPressCoord;
308
        createObjectPos.setXY(Rxp, Ryp);
309
        if (m->button() == Qt::MidButton)
310
        {
311
                m_view->MidButt = true;
312
                m_view->DrawNew();
313
                return;
314
        }
315
 
316
        if (m->button() == Qt::RightButton)
317
        {
318
                m_view->requestMode(modeNormal);
319
                return;
320
        }
321
        if (m->button() != Qt::LeftButton)
322
                return;
323
        selectPage(m);
324
 
325
        switch (m_doc->appMode)
326
        {
327
        case modeDrawTable:
328
                m_view->Deselect(false);
329
                break;
330
        }
331
 
332
        inItemCreation = true;
333
}
334
 
335
 
336
 
337
void CreateMode::mouseReleaseEvent(QMouseEvent *m)
338
{
339
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
340
 
341
        PageItem *currItem;
342
        m_MouseButtonPressed = false;
343
        m_canvas->resetRenderMode();
344
        m->accept();
345
        m_view->stopDragTimer();
346
 
347
        m_createTransaction = new UndoTransaction(Um::instance()->beginTransaction("creating"));
348
        currItem = doCreateNewObject();
349
        if (m_createTransaction && currItem)
350
        {
351
                m_view->resetMousePressed();
352
                currItem->checkChanges(true);
353
                QString targetName = Um::ScratchSpace;
354
                if (currItem->OwnPage > -1)
355
                        targetName = m_doc->Pages->at(currItem->OwnPage)->getUName();
356
                m_createTransaction->commit(targetName, currItem->getUPixmap(),
357
                                                                        Um::Create + " " + currItem->getUName(),  "", Um::ICreate);
358
                m_doc->changed();
359
                delete m_createTransaction;
360
                m_createTransaction = NULL;    
361
                /*currItem->update();
362
                currItem->emitAllToGUI();*/
363
        }
364
        else if (m_createTransaction)
365
        {
366
                m_createTransaction->cancel();
367
                delete m_createTransaction;
368
                m_createTransaction = NULL;
369
        }
370
        if (!PrefsManager::instance()->appPrefs.stickyTools)
371
        {
372
                m_view->requestMode(modeNormal);
373
        }
374
        else
375
        {
376
                m_view->updateCanvas();
377
                int appMode = m_doc->appMode;
378
                m_view->requestMode(appMode);
379
        }
380
        inItemCreation = false;
381
}
382
 
383
 
384
 
385
void CreateMode::selectPage(QMouseEvent *m)
386
{
387
        m_MouseButtonPressed = true;
388
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
389
        canvasPressCoord     = mousePointDoc;
390
        QRect mpo(m->x()-m_doc->guidesSettings.grabRad, m->y()-m_doc->guidesSettings.grabRad, m_doc->guidesSettings.grabRad*2, m_doc->guidesSettings.grabRad*2);
391
//      mpo.moveBy(qRound(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(m_doc->minCanvasCoordinate.y() * m_canvas->scale()));
392
        m_doc->nodeEdit.deselect();
393
        m_view->Deselect(false);
394
        if (!m_doc->masterPageMode())
395
        {
396
                int i = m_doc->OnPage(canvasPressCoord.x(), canvasPressCoord.y());
397
                if (i!=-1)
398
                {
399
                        uint docCurrPageNo=m_doc->currentPageNumber();
400
                        uint j=static_cast<uint>(i);
401
                        if (docCurrPageNo != j)
402
                        {
403
                                m_doc->setCurrentPage(m_doc->Pages->at(j));
404
                                m_view->setMenTxt(j);
405
                                m_view->DrawNew();
406
                        }
407
                }
408
/*              uint docPagesCount=m_doc->Pages->count();
409
                uint docCurrPageNo=m_doc->currentPageNumber();
410
                for (uint i = 0; i < docPagesCount; ++i)
411
                {
412
                        int x = static_cast<int>(m_doc->Pages->at(i)->xOffset() * m_canvas->scale());
413
                        int y = static_cast<int>(m_doc->Pages->at(i)->yOffset() * m_canvas->scale());
414
                        int w = static_cast<int>(m_doc->Pages->at(i)->width() * m_canvas->scale());
415
                        int h = static_cast<int>(m_doc->Pages->at(i)->height() * m_canvas->scale());
416
                        if (QRect(x, y, w, h).intersects(mpo))
417
                        {
418
                                if (docCurrPageNo != i)
419
                                {
420
                                        m_doc->setCurrentPage(m_doc->Pages->at(i));
421
                                        setMenTxt(i);
422
                                        DrawNew();
423
                                }
424
                                break;
425
                        }
426
                } */
427
 
428
                //FIXME m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
429
        }
430
}
431
 
432
void CreateMode::SetupDrawNoResize(int nr)
433
{
434
        PageItem* currItem = m_doc->Items->at(nr);
435
        //      currItem->setFont(Doc->toolSettings.defFont);
436
        //      currItem->setFontSize(Doc->toolSettings.defSize);
437
        m_doc->m_Selection->delaySignalsOn();
438
        m_doc->m_Selection->clear();
439
        m_doc->m_Selection->addItem(currItem);
440
        m_doc->m_Selection->delaySignalsOff();
441
//      emit DocChanged();
442
        currItem->Sizing =  false /*currItem->asLine() ? false : true*/;
443
        //#6456 m_view->resetMoveTimer();
444
}
445
 
446
void CreateMode::getFrameItemTypes(int& itemType, int& frameType)
447
{
448
        itemType  = (int) PageItem::Polygon;
449
        frameType = (int) PageItem::Rectangle;
450
        switch (createObjectMode)
451
        {
452
        case modeDrawShapes:
453
                switch (createObjectSubMode)
454
                {
455
                case 0:
456
                        itemType  = (int) PageItem::Polygon;
457
                        frameType = (int) PageItem::Rectangle;
458
                        break;
459
                case 1:
460
                        itemType  = (int) PageItem::Polygon;
461
                        frameType = (int) PageItem::Ellipse;
462
                        break;
463
                default:
464
                        itemType  = (int) PageItem::Polygon;
465
                        frameType = (int) PageItem::Unspecified;
466
                        break;
467
                }
468
                break;
469
        case modeDrawLine:
470
                itemType  = (int) PageItem::Line;
471
                frameType = (int) PageItem::Unspecified;
472
                break;
473
        case modeDrawLatex:
474
                itemType  = (int) PageItem::LatexFrame;
475
                frameType = (int) PageItem::Unspecified;
476
                break;
477
        case modeDrawImage:
478
                itemType  = (int) PageItem::ImageFrame;
479
                frameType = (int) PageItem::Unspecified;
480
                break;
481
        case modeDrawText:
482
                itemType  = (int) PageItem::TextFrame;
483
                frameType = (int) PageItem::Unspecified;
484
                break;
485
        case modeDrawRegularPolygon:
486
                itemType  = (int) PageItem::Polygon;
487
                frameType = (int) PageItem::Unspecified;
488
                break;
489
        case modeInsertPDFButton:
490
        case modeInsertPDFTextfield:
491
        case modeInsertPDFCheckbox:
492
        case modeInsertPDFCombobox:
493
        case modeInsertPDFListbox:
494
        case modeInsertPDFTextAnnotation:
495
        case modeInsertPDFLinkAnnotation:
496
                itemType  = (int) PageItem::TextFrame;
497
                frameType = (int) PageItem::Unspecified;
498
                break;
499
        case modeDrawTable:
500
                itemType  = (int) PageItem::TextFrame;
501
                frameType = (int) PageItem::Unspecified;
502
                break;
503
        }
504
}
505
 
506
PageItem* CreateMode::doCreateNewObject(void)
507
{
508
        int z = -1;
509
        double rot, len;
510
 
511
        double wSize = canvasCurrCoord.x() - createObjectPos.x();
512
        double hSize = canvasCurrCoord.y() - createObjectPos.y();
513
        if ((!m_view->moveTimerElapsed()) || ((fabs(wSize) < 2.0) && (fabs(hSize) < 2.0)))
514
        {
515
                if (!doOneClick(createObjectPos, canvasCurrCoord))
516
                {
517
                        return NULL;
518
                }
519
        }
520
 
521
        wSize = canvasCurrCoord.x() - createObjectPos.x();
522
        hSize = canvasCurrCoord.y() - createObjectPos.y();
523
        PageItem *newObject = NULL, *currItem = NULL;
524
        // FIXME for modeDrawLine
525
        QRectF createObjectRect(createObjectPos.x(), createObjectPos.y(), wSize, hSize);
526
        if (createObjectMode != modeDrawLine)
527
                createObjectRect = createObjectRect.normalized();
528
        double Rxp  = createObjectRect.x();
529
        double Ryp  = createObjectRect.y();
530
        double Rxpd = createObjectRect.width();
531
        double Rypd = createObjectRect.height();
532
 
533
        switch (createObjectMode)
534
        {
535
        case modeDrawShapes:
536
                switch (createObjectSubMode)
537
                {
538
                case 0:
539
                        if (modifiers == Qt::ShiftModifier)
540
                        {
541
                                z = m_doc->itemAddArea(PageItem::Polygon, PageItem::Rectangle, Rxp, Ryp, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
542
                                m_doc->Items->at(z)->FrameType = 0;
543
                        }
544
                        else
545
                        {
546
                                m_doc->ApplyGuides(&Rxp, &Ryp);
547
                                z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
548
                                m_doc->Items->at(z)->FrameType = 0;
549
                        }
550
                        break;
551
                case 1:
552
                        if (modifiers == Qt::ShiftModifier)
553
                        {
554
                                z = m_doc->itemAddArea(PageItem::Polygon, PageItem::Ellipse, Rxp, Ryp, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
555
                                m_doc->Items->at(z)->FrameType = 1;
556
                        }
557
                        else
558
                        {
559
                                m_doc->ApplyGuides(&Rxp, &Ryp);
560
                                z = m_doc->itemAdd(PageItem::Polygon, PageItem::Ellipse, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
561
                                m_doc->Items->at(z)->FrameType = 1;
562
                        }
563
                        break;
564
                default:
565
                        if (modifiers == Qt::ShiftModifier)
566
                        {
567
                                z = m_doc->itemAddArea(PageItem::Polygon, PageItem::Unspecified, Rxp, Ryp, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
568
                                m_doc->Items->at(z)->SetFrameShape(m_doc->ValCount, m_doc->ShapeValues);
569
                                m_doc->setRedrawBounding(m_doc->Items->at(z));
570
                                m_doc->Items->at(z)->FrameType = createObjectSubMode + 2;
571
                        }
572
                        else
573
                        {
574
                                m_doc->ApplyGuides(&Rxp, &Ryp);
575
                                z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
576
                                m_doc->Items->at(z)->SetFrameShape(m_doc->ValCount, m_doc->ShapeValues);
577
                                m_doc->setRedrawBounding(m_doc->Items->at(z));
578
                                m_doc->Items->at(z)->FrameType = createObjectSubMode + 2;
579
                        }
580
                        break;
581
                }
582
                break;
583
        case modeDrawLine:
584
                Rxp = createObjectPos.x();
585
                Ryp = createObjectPos.y();
586
                m_doc->ApplyGuides(&Rxp, &Ryp);
587
                rot = xy2Deg(Rxpd, Rypd);
588
                if (rot < 0.0)
589
                        rot += 360;
590
                len = qMax(0.01, distance(Rxpd, Rypd));
591
                z = m_doc->itemAdd(PageItem::Line, PageItem::Unspecified, Rxp, Ryp, len, 1, m_doc->toolSettings.dWidthLine, CommonStrings::None, m_doc->toolSettings.dPenLine, true);
592
                m_doc->Items->at(z)->setRotation(rot);
593
                break;
594
        case modeDrawLatex:
595
                if (modifiers == Qt::ShiftModifier)
596
                {
597
                        z = m_doc->itemAddArea(PageItem::LatexFrame, PageItem::Unspecified, Rxp, Ryp, 1, m_doc->toolSettings.dBrushPict, CommonStrings::None, true);
598
                }
599
                else
600
                {
601
                        m_doc->ApplyGuides(&Rxp, &Ryp);
602
                        z = m_doc->itemAdd(PageItem::LatexFrame, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, 1, m_doc->toolSettings.dBrushPict, CommonStrings::None, true);
603
                }
604
                break;
605
        case modeDrawImage:
606
                if (modifiers == Qt::ShiftModifier)
607
                {
608
                        z = m_doc->itemAddArea(PageItem::ImageFrame, PageItem::Unspecified, Rxp, Ryp, 1, m_doc->toolSettings.dBrushPict, CommonStrings::None, true);
609
                }
610
                else
611
                {
612
                        m_doc->ApplyGuides(&Rxp, &Ryp);
613
                        z = m_doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, 1, m_doc->toolSettings.dBrushPict, CommonStrings::None, true);
614
                }
615
                break;
616
        case modeDrawText:
617
                if (modifiers == Qt::ShiftModifier)
618
                {
619
                        z = m_doc->itemAddArea(PageItem::TextFrame, PageItem::Unspecified, Rxp, Ryp, m_doc->toolSettings.dWidth, CommonStrings::None, m_doc->toolSettings.dPenText, true);
620
                }      
621
                else
622
                {
623
                        m_doc->ApplyGuides(&Rxp, &Ryp);
624
                        z = m_doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->toolSettings.dWidth, CommonStrings::None, m_doc->toolSettings.dPenText, true);
625
                }
626
                break;
627
        case modeDrawRegularPolygon:
628
                {
629
                        if (modifiers == Qt::ShiftModifier)
630
                                z = m_doc->itemAddArea(PageItem::Polygon, PageItem::Unspecified, Rxp, Ryp, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
631
                        else
632
                        {
633
                                m_doc->ApplyGuides(&Rxp, &Ryp);
634
                                z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->toolSettings.dWidth, m_doc->toolSettings.dBrush, m_doc->toolSettings.dPen, true);
635
                        }
636
                        currItem = m_doc->Items->at(z);
637
                        FPointArray cli = RegularPolygonF(currItem->width(), currItem->height(), m_doc->toolSettings.polyC, m_doc->toolSettings.polyS, m_doc->toolSettings.polyF, m_doc->toolSettings.polyR);
638
                        FPoint np(cli.point(0));
639
                        currItem->PoLine.resize(2);
640
                        currItem->PoLine.setPoint(0, np);
641
                        currItem->PoLine.setPoint(1, np);
642
                        for (uint ax = 1; ax < cli.size(); ++ax)
643
                        {
644
                                np = FPoint(cli.point(ax));
645
                                currItem->PoLine.putPoints(currItem->PoLine.size(), 4, np.x(), np.y(), np.x(), np.y(), np.x(), np.y(), np.x(), np.y());
646
                        }
647
                        np = FPoint(cli.point(0));
648
                        currItem->PoLine.putPoints(currItem->PoLine.size(), 2, np.x(), np.y(), np.x(), np.y());
649
                        currItem->Clip = FlattenPath(currItem->PoLine, currItem->Segments);
650
                        /*
651
                        qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
652
                        m_doc->m_Selection->clear();
653
                        m_doc->m_Selection->addItem(currItem);
654
                        currItem->update();
655
                        inItemCreation = true;
656
//FIXME:                                m_canvas->m_viewMode.operItemResizing = true;
657
                        if (m->modifiers() == Qt::ShiftModifier)
658
                        {
659
                                m_view->requestMode(modeNormal);
660
// itemAdd calls PageItem::update                                       emit DocChanged();
661
                                inItemCreation = false;
662
//                                      m_view->updateContents();
663
                        }
664
                        else
665
                        {
666
//FIXME:                                        m_canvas->m_viewMode.operItemMoving = true;
667
                                m_canvas->setRenderModeFillBuffer();
668
                        }*/
669
                        break;
670
                }
671
        case modeInsertPDFButton:
672
        case modeInsertPDFTextfield:
673
        case modeInsertPDFCheckbox:
674
        case modeInsertPDFCombobox:
675
        case modeInsertPDFListbox:
676
        case modeInsertPDFTextAnnotation:
677
        case modeInsertPDFLinkAnnotation:
678
                m_doc->ApplyGuides(&Rxp, &Ryp);
679
                z = m_doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, Rxp, Ryp, 1+Rxpd, 1+Rypd, m_doc->toolSettings.dWidth, CommonStrings::None, m_doc->toolSettings.dPenText, true);
680
                currItem = m_doc->Items->at(z);
681
                currItem->setIsAnnotation(true);
682
                currItem->AutoName = false;
683
                switch (m_doc->appMode)
684
                {
685
                case modeInsertPDFButton:
686
                        currItem->annotation().setType(2);
687
                        currItem->annotation().setFlag(65536);
688
                        break;
689
                case modeInsertPDFTextfield:
690
                        currItem->annotation().setType(3);
691
                        break;
692
                case modeInsertPDFCheckbox:
693
                        currItem->annotation().setType(4);
694
                        break;
695
                case modeInsertPDFCombobox:
696
                        currItem->annotation().setType(5);
697
                        currItem->annotation().setFlag(131072);
698
                        break;
699
                case modeInsertPDFListbox:
700
                        currItem->annotation().setType(6);
701
                        break;
702
                case modeInsertPDFTextAnnotation:
703
                        currItem->annotation().setType(10);
704
                        break;
705
                case modeInsertPDFLinkAnnotation:
706
                        currItem->annotation().setType(11);
707
                        currItem->annotation().setZiel(m_doc->currentPage()->pageNr());
708
                        currItem->annotation().setAction("0 0");
709
                        currItem->setTextFlowMode(PageItem::TextFlowDisabled);
710
                        break;
711
                }
712
                break;
713
        case modeDrawTable:
714
                /*m_view->Deselect(false);
715
                Rxp = mousePointDoc.x();
716
                Ryp = mousePointDoc.y();
717
                npf = m_doc->ApplyGridF(FPoint(Rxp, Ryp));
718
                Rxp = npf.x();
719
                Ryp = npf.y();
720
                m_doc->ApplyGuides(&Rxp, &Ryp);
721
                canvasPressCoord.setXY(qRound(Rxp), qRound(Ryp));
722
                canvasCurrCoord = canvasPressCoord;
723
                mouseGlobalCoord.setXY(m->globalPos().x(), m->globalPos().y());
724
                m_view->redrawMarker->setGeometry(m->globalPos().x(), m->globalPos().y(), 1, 1);
725
                m_view->redrawMarker->show();*/
726
 
727
                if ((m_doc->m_Selection->count() == 0) && (m_view->HaveSelRect) && (!m_view->MidButt))
728
                {
729
                        UndoTransaction * activeTransaction = NULL;
730
                        m_view->HaveSelRect = false;
731
                        double Tx, Ty, Tw, Th;
732
                        FPoint np2 = m_doc->ApplyGridF(canvasPressCoord);
733
                        Tx = np2.x();
734
                        Ty = np2.y();
735
                        m_doc->ApplyGuides(&Tx, &Ty);
736
                        canvasPressCoord.setXY(qRound(Tx), qRound(Ty));
737
                        np2 = m_doc->ApplyGridF(canvasCurrCoord);
738
                        Tw = np2.x();
739
                        Th = np2.y();
740
                        m_doc->ApplyGuides(&Tw, &Th);
741
                        canvasCurrCoord.setXY(qRound(Tw), qRound(Th));
742
                        Tw = Tw - Tx;
743
                        Th = Th - Ty;
744
                        int z;
745
                        int Cols, Rows;
746
                        double deltaX, deltaY, offX, offY;
747
                        if ((Th < 6) || (Tw < 6))
748
                        {
749
                                m_view->requestMode(submodePaintingDone);
750
                                break;
751
                        }
752
                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
753
                        InsertTable *dia = new InsertTable(m_view, static_cast<int>(Th / 6), static_cast<int>(Tw / 6));
754
                        if (!dia->exec())
755
                        {
756
                                m_view->requestMode(submodePaintingDone);
757
                                delete dia;
758
                                dia = NULL;
759
                                break;
760
                        }
761
                        Cols = dia->Cols->value();
762
                        Rows = dia->Rows->value();
763
                        delete dia;
764
                        dia=NULL;
765
                        deltaX = Tw / Cols;
766
                        deltaY = Th / Rows;
767
                        offX = 0.0;
768
                        offY = 0.0;
769
                        m_doc->m_Selection->clear();
770
                        if (UndoManager::undoEnabled())
771
                                activeTransaction = new UndoTransaction(m_view->undoManager->beginTransaction(m_doc->currentPage()->getUName(),
772
                                                                                                                                                                                  Um::ITable, Um::CreateTable,
773
                                                                                                                                                                                  QString(Um::RowsCols).arg(Rows).arg(Cols),
774
                                                                                                                                                                                  Um::ICreate));
775
                        m_doc->m_Selection->delaySignalsOn();
776
                        for (int rc = 0; rc < Rows; ++rc)
777
                        {
778
                                for (int cc = 0; cc < Cols; ++cc)
779
                                {
780
                                        z = m_doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, Tx + offX, Ty + offY, deltaX, deltaY, m_doc->toolSettings.dWidth, CommonStrings::None, m_doc->toolSettings.dPenText, true);
781
                                        currItem = m_doc->Items->at(z);
782
                                        currItem->isTableItem = true;
783
                                        currItem->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
784
                                        m_doc->m_Selection->addItem(currItem);
785
                                        offX += deltaX;
786
                                }
787
                                offY += deltaY;
788
                                offX = 0.0;
789
                        }
790
                        for (int rc = 0; rc < Rows; ++rc)
791
                        {
792
                                for (int cc = 0; cc < Cols; ++cc)
793
                                {
794
                                        currItem = m_doc->m_Selection->itemAt((rc * Cols) + cc);
795
                                        if (rc == 0)
796
                                                currItem->TopLink = 0;
797
                                        else
798
                                                currItem->TopLink = m_doc->m_Selection->itemAt(((rc-1)*Cols)+cc);
799
                                        if (rc == Rows-1)
800
                                                currItem->BottomLink = 0;
801
                                        else
802
                                                currItem->BottomLink = m_doc->m_Selection->itemAt(((rc+1)*Cols)+cc);
803
                                        if (cc == 0)
804
                                                currItem->LeftLink = 0;
805
                                        else
806
                                                currItem->LeftLink = m_doc->m_Selection->itemAt((rc*Cols)+cc-1);
807
                                        if (cc == Cols-1)
808
                                                currItem->RightLink = 0;
809
                                        else
810
                                                currItem->RightLink = m_doc->m_Selection->itemAt((rc*Cols)+cc+1);
811
                                }
812
                        }
813
                        m_doc->itemSelection_GroupObjects(false, false);
814
                        if (activeTransaction)
815
                        {
816
                                activeTransaction->commit();
817
                                delete activeTransaction;
818
                                activeTransaction = NULL;
819
                        }
820
                        m_doc->m_Selection->delaySignalsOff();
821
                }
822
                break;
823
        }
824
        if (z >= 0)
825
        {
826
                SetupDrawNoResize(z);
827
                newObject = m_doc->Items->at(z);
828
        }
829
        return newObject;
830
}
831
 
832
bool CreateMode::doOneClick(FPoint& startPoint, FPoint& endPoint)
833
{
834
        bool doCreate = false;
835
        double xSize, ySize;
836
        int  originPoint = 0;
837
 
838
        if (QApplication::keyboardModifiers() & Qt::ControlModifier)
839
                return true;
840
 
841
        PrefsContext* sizes = PrefsManager::instance()->prefsFile->getContext("ObjectSize");
842
        bool doRemember     = sizes->getBool("Remember", true);
843
 
844
        int lmode = (createObjectMode == modeDrawLine) ? 1 : 0;
845
        if (lmode == 0)
846
        {
847
                xSize = sizes->getDouble("defWidth", 100.0);
848
                ySize = sizes->getDouble("defHeight", 100.0);
849
                originPoint = sizes->getInt("Origin", 0);
850
        }
851
        else
852
        {
853
                xSize = sizes->getDouble("defLength", 100.0);
854
                ySize = sizes->getDouble("defAngle", 0.0);
855
                originPoint = sizes->getInt("OriginL", 0);
856
        }
857
 
858
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
859
        OneClick *dia = new OneClick(m_view, ScribusView::tr("Enter Object Size"), m_doc->unitIndex(), xSize, ySize, doRemember, originPoint, lmode);
860
        if (dia->exec())
861
        {
862
                doRemember = dia->checkRemember->isChecked();
863
                if (lmode == 0)
864
                {
865
                        xSize = dia->spinWidth->value() / unitGetRatioFromIndex(m_doc->unitIndex());
866
                        ySize = dia->spinHeight->value() / unitGetRatioFromIndex(m_doc->unitIndex());
867
                        originPoint = dia->RotationGroup->checkedId();
868
                        if (doRemember)
869
                        {
870
                                sizes->set("defWidth", xSize);
871
                                sizes->set("defHeight", ySize);
872
                                sizes->set("Origin", originPoint);
873
                        }
874
                        endPoint.setXY(startPoint.x() + xSize, startPoint.y() + ySize);
875
                        switch (originPoint)
876
                        {
877
                                case 0:
878
                                        break;
879
                                case 1:
880
                                        startPoint.setX(startPoint.x() - xSize);
881
                                        endPoint.setX(endPoint.x() - xSize);
882
                                        break;
883
                                case 2:
884
                                        startPoint.setXY(startPoint.x() - xSize / 2.0, startPoint.y() - ySize / 2.0);
885
                                        endPoint.setXY(endPoint.x() - xSize / 2.0, endPoint.y() - ySize / 2.0);
886
                                        break;
887
                                case 3:
888
                                        startPoint.setY(startPoint.y() - ySize);
889
                                        endPoint.setY(endPoint.y() - ySize);
890
                                        break;
891
                                case 4:
892
                                        startPoint.setXY(startPoint.x() - xSize, startPoint.y() - ySize);
893
                                        endPoint.setXY(endPoint.x() - xSize, endPoint.y() - ySize);
894
                                        break;
895
                        }
896
                }
897
                else
898
                {
899
                        FPoint oldStart = startPoint;
900
                        xSize = dia->spinWidth->value() / unitGetRatioFromIndex(m_doc->unitIndex());
901
                        ySize = dia->spinHeight->value();
902
                        originPoint = dia->RotationGroup->checkedId();
903
                        if (doRemember)
904
                        {
905
                                sizes->set("defLength", xSize);
906
                                sizes->set("defAngle", ySize);
907
                                sizes->set("OriginL", originPoint);
908
                        }
909
                        double angle = -ySize * M_PI / 180.0;
910
                        switch (originPoint)
911
                        {
912
                                case 0:
913
                                        endPoint = FPoint(startPoint.x() + xSize * cos(angle), startPoint.y() + xSize * sin(angle));
914
                                        break;
915
                                case 1:
916
                                        startPoint = FPoint(oldStart.x() - xSize * cos(angle), oldStart.y() - xSize * sin(angle));
917
                                        endPoint   = oldStart;
918
                                        break;
919
                                case 2:
920
                                        startPoint = FPoint(oldStart.x() - xSize / 2.0 * cos(angle), oldStart.y() - xSize / 2.0 * sin(angle));
921
                                        endPoint   = FPoint(oldStart.x() + xSize / 2.0 * cos(angle), oldStart.y() + xSize / 2.0 * sin(angle));
922
                                        break;
923
                        }
924
                }
925
                sizes->set("Remember", doRemember);
926
                doCreate = true;
927
        }
928
        delete dia;
929
        return doCreate;
930
}
931
 
932
void CreateMode::setResizeCursor(int how)
933
{
934
        switch (how)
935
        {
936
                case 1:
937
                case 2:
938
                        qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
939
                        break;
940
                case 3:
941
                case 4:
942
                        qApp->changeOverrideCursor(QCursor(Qt::SizeBDiagCursor));
943
                        break;
944
                case 5:
945
                case 8:
946
                        qApp->changeOverrideCursor(QCursor(Qt::SizeVerCursor));
947
                        break;
948
                case 6:
949
                case 7:
950
                        qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
951
                        break;
952
                default:
953
                        qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
954
                        break;
955
        }
956
}
957