Subversion Repositories Scribus

Rev

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