Subversion Repositories Scribus

Rev

Rev 18921 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
10532 avox 1
/*
2
 For general Scribus (>=1.3.2) copyright and licensing information please refer
3
 to the COPYING file provided with the program. Following this notice may exist
4
 a copyright and/or license notice that predates the release of Scribus 1.3.2
5
 for which a new license (GPL+exception) is in place.
6
 */
7
/***************************************************************************
8
*                                                                         *
9
*   This program is free software; you can redistribute it and/or modify  *
10
*   it under the terms of the GNU General Public License as published by  *
11
*   the Free Software Foundation; either version 2 of the License, or     *
12
*   (at your option) any later version.                                   *
13
*                                                                         *
14
***************************************************************************/
15
 
16
 
17
#include "canvasmode.h"
18
 
19
#include "canvas.h"
13184 jghali 20
#include "canvasgesture_pan.h"
12844 jghali 21
#include "canvasmode_copyproperties.h"
10978 avox 22
#include "canvasmode_create.h"
23
#include "canvasmode_drawbezier.h"
12633 jghali 24
#include "canvasmode_drawfreehand.h"
12775 jghali 25
#include "canvasmode_edit.h"
12770 jghali 26
#include "canvasmode_editgradient.h"
13229 jghali 27
#include "canvasmode_eyedropper.h"
12824 jghali 28
#include "canvasmode_framelinks.h"
10532 avox 29
#include "canvasmode_legacy.h"
12824 jghali 30
#include "canvasmode_magnifier.h"
11190 avox 31
#include "canvasmode_measurements.h"
10532 avox 32
#include "canvasmode_nodeedit.h"
12765 jghali 33
#include "canvasmode_normal.h"
13184 jghali 34
#include "canvasmode_objimport.h"
35
#include "canvasmode_panning.h"
12633 jghali 36
#include "canvasmode_rotate.h"
13034 pierre 37
#ifdef GESTURE_FRAME_PREVIEW
38
#include "pageitempreview.h"
39
#endif
19084 jghali 40
#include "prefsmanager.h"
10532 avox 41
#include "selection.h"
13034 pierre 42
#include "scpainter.h"
12799 pierre 43
#include "scresizecursor.h"
13124 fschmid 44
#include "scribus.h"
10601 mrdocs 45
#include "scribusview.h"
10978 avox 46
#include "util_icon.h"
10532 avox 47
 
10601 mrdocs 48
#include <QPainter>
10532 avox 49
 
10601 mrdocs 50
 
10532 avox 51
CanvasMode::CanvasMode (ScribusView* view) :
12581 pierre 52
        QObject(),
10532 avox 53
        m_view(view),
54
        m_canvas(view->m_canvas),
13184 jghali 55
        m_doc(view->Doc),
56
        m_panGesture(NULL)
10532 avox 57
{
12453 pierre 58
        m_pen["outline"]        = QPen(Qt::gray, 1.0 , Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
59
        m_pen["outline"].setCosmetic(true);
19084 jghali 60
        m_pen["selection"]      = QPen(PrefsManager::instance()->appPrefs.DFrameColor, 1.0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
12453 pierre 61
        m_pen["selection"].setCosmetic(true);
12455 pierre 62
        m_pen["selection-group"] = QPen(Qt::red, 1.0 , Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
63
        m_pen["selection-group"].setCosmetic(true);
19084 jghali 64
        m_pen["selection-group-inside"] = QPen(PrefsManager::instance()->appPrefs.DFrameGroupColor, 1.0 , Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
13039 pierre 65
        m_pen["selection-group-inside"].setCosmetic(true);
19084 jghali 66
        m_pen["handle"]         = QPen(PrefsManager::instance()->appPrefs.DFrameColor, 1.0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
12453 pierre 67
        m_pen["handle"].setCosmetic(true);
68
 
69
        m_brush["outline"]      = Qt::NoBrush;
70
        m_brush["selection"]    = Qt::NoBrush;
13039 pierre 71
        m_brush["selection-group"] = QColor(255,0,0,10);
13040 pierre 72
        m_brush["selection-group-inside"] = Qt::NoBrush;
19084 jghali 73
        m_brush["handle"]       = PrefsManager::instance()->appPrefs.DFrameColor;
10532 avox 74
}
75
 
13184 jghali 76
CanvasMode::~CanvasMode()
77
{
78
        if (m_panGesture)
79
                delete m_panGesture;
80
}
10532 avox 81
 
82
CanvasMode* CanvasMode::createForAppMode(ScribusView* view, int appMode)
83
{
84
        CanvasMode* result;
85
 
86
        switch (appMode)
87
        {
12765 jghali 88
                case modeNormal:
14377 jghali 89
                case modeStoryEditor:
12765 jghali 90
                        result = new CanvasMode_Normal(view);
91
                        break;
12844 jghali 92
                case modeCopyProperties:
93
                        result = new CanvasMode_CopyProperties(view);
94
                        break;
12775 jghali 95
                case modeEdit:
96
                        result = new CanvasMode_Edit(view);
97
                        break;
10532 avox 98
                case modeEditClip:
99
                        result = new CanvasMode_NodeEdit(view);
100
                        break;
12770 jghali 101
                case modeEditGradientVectors:
102
                        result = new CanvasMode_EditGradient(view);
103
                        break;
10978 avox 104
                case modeDrawBezierLine:
105
                        result = new BezierMode(view);
106
                        break;
107
                case modeDrawFreehandLine:
11041 fschmid 108
                        result = new FreehandMode(view);
10978 avox 109
                        break;
110
                case modeDrawLine:
111
                case modeDrawShapes:
11298 cbradney 112
                case modeDrawImage:
10978 avox 113
                case modeDrawLatex:
114
                case modeDrawText:
115
                case modeDrawTable:
116
                case modeDrawRegularPolygon:
117
                case modeInsertPDFButton:
118
                case modeInsertPDFTextfield:
119
                case modeInsertPDFCheckbox:
120
                case modeInsertPDFCombobox:
121
                case modeInsertPDFListbox:
122
                case modeInsertPDFTextAnnotation:
123
                case modeInsertPDFLinkAnnotation:
124
                        result = new CreateMode(view);
125
                        break;
13229 jghali 126
                case modeEyeDropper:
127
                        result = new CanvasMode_EyeDropper(view);
128
                        break;
129
                case modeImportObject:
130
                        result = new CanvasMode_ObjImport(view);
131
                        break;
12824 jghali 132
                case modeLinkFrames:
133
                case modeUnlinkFrames:
134
                        result = new CanvasMode_FrameLinks(view);
135
                        break;
136
                case modeMagnifier:
137
                        result = new CanvasMode_Magnifier(view);
138
                        break;
11190 avox 139
                case modeMeasurementTool:
140
                        result = new MeasurementsMode(view);
141
                        break;
13184 jghali 142
                case modePanning:
143
                        result = new CanvasMode_Panning(view);
144
                        break;
12633 jghali 145
                case modeRotation:
146
                        result = new CanvasMode_Rotate(view);
147
                        break;
10532 avox 148
                        // more modes as they are defined...
149
 
150
                default:
151
                        result = new LegacyMode(view);
152
                        break;
153
        }
154
        return result;
155
}
156
 
157
 
158
void CanvasMode::updateViewMode(CanvasViewMode* viewmode)
159
{
160
        viewmode->drawSelectedItemsWithControls = false;
161
        viewmode->drawFramelinksWithContents = false;  
162
}
163
 
164
 
14372 jghali 165
void CanvasMode::drawSelection(QPainter* psx, bool drawHandles)
10532 avox 166
{
14519 jghali 167
//      QTime t;
168
//      t.start();
169
//      QTime tt;
170
//      int tg(0);
171
//      QStringList tu;
12451 pierre 172
        QString ds;
10701 avox 173
        psx->scale(m_canvas->scale(), m_canvas->scale());
12451 pierre 174
        psx->translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y());
11076 avox 175
 
12451 pierre 176
        psx->setClipping(true);
177
        psx->setClipRegion(QRegion ( m_canvas->exposedRect() ) );
14372 jghali 178
 
12453 pierre 179
        if (m_doc->m_Selection->isMultipleSelection())
10532 avox 180
        {
12463 pierre 181
                PageItem *curItem(0);
12455 pierre 182
                for(int a=0; a<m_doc->m_Selection->count(); ++a)
12454 pierre 183
                {
12463 pierre 184
                        curItem = m_doc->m_Selection->itemAt(a);
185
 
186
                        if(drawHandles)
187
                                drawHandles = !curItem->locked();
12454 pierre 188
                }
189
 
12453 pierre 190
                psx->save();
12525 pierre 191
                psx->setPen(m_pen["selection-group"]);
192
                psx->setBrush(m_brush["selection-group"]);
193
                double lineAdjust(psx->pen().width()/m_canvas->scale());
12453 pierre 194
                double x, y, w, h;
12467 pierre 195
                m_doc->m_Selection->setGroupRect();
196
                m_doc->m_Selection->getVisualGroupRect(&x, &y, &w, &h);
12455 pierre 197
                const double markWidth = 4 / m_canvas->scale();
198
                const double halfMarkWidth = 2 / m_canvas->scale();
12453 pierre 199
 
200
                psx->translate(x,y);
12525 pierre 201
                x = -lineAdjust;
202
                y = -lineAdjust;
12453 pierre 203
 
14519 jghali 204
//              tt.start();
12453 pierre 205
                psx->drawRect(QRectF(x, y, w, h));
12454 pierre 206
                if(drawHandles)
207
                {
208
                        psx->setBrush(m_brush["handle"]);
209
                        psx->setPen(m_pen["handle"]);
210
                        psx->drawRect(QRectF(x+w-markWidth, y+h-markWidth, markWidth, markWidth));
211
                        psx->drawRect(QRectF(x+w/2 - halfMarkWidth, y+h-markWidth, markWidth, markWidth));
212
                        psx->drawRect(QRectF(x+w/2 - halfMarkWidth, y, markWidth, markWidth));
213
                        psx->drawRect(QRectF(x+w-markWidth, y+h/2 - halfMarkWidth, markWidth, markWidth));
214
                        psx->drawRect(QRectF(x+w-markWidth, y, markWidth, markWidth));
215
                        psx->drawRect(QRectF(x, y, markWidth, markWidth));
216
                        psx->drawRect(QRectF(x, y+h/2 - halfMarkWidth, markWidth, markWidth));
217
                        psx->drawRect(QRectF(x, y+h-markWidth, markWidth, markWidth));
218
                }
14519 jghali 219
//              tg=tt.elapsed();
12453 pierre 220
                psx->restore();
13039 pierre 221
 
222
                // items inside a a multi
223
                if (m_doc->m_Selection->count() > 1)
224
                {
14372 jghali 225
                        uint docSelectionCount = m_doc->m_Selection->count();
226
                        PageItem *currItem;
227
                        for (uint a=0; a<docSelectionCount; ++a)
228
                        {
229
                                currItem = m_doc->m_Selection->itemAt(a);
230
                                if( currItem->Groups.count() > 0)
13040 pierre 231
                                {
232
                                        if(! currItem->controlsGroup() )
233
                                                continue;
234
                                        else
235
                                        {
236
                                                if(currItem->Groups.count() > 1)
237
                                                        continue;
238
                                        }
239
                                }
14372 jghali 240
                                psx->save();
241
                                psx->setPen(m_pen["selection-group-inside"]);
242
                                psx->setBrush(m_brush["selection-group-inside"]);
243
                                double lineAdjust(psx->pen().width()/m_canvas->scale());
244
                                double x, y, w, h;
14517 jghali 245
                                w = currItem->visualWidth() ;
246
                                h = currItem->visualHeight() ;
14372 jghali 247
                                if (currItem->rotation() != 0)
248
                                {
249
                                        psx->setRenderHint(QPainter::Antialiasing);
250
                                        psx->translate(currItem->xPos(), currItem->yPos());
251
                                        psx->rotate(currItem->rotation());
18455 jghali 252
                                        x = currItem->asLine() ? 0 : (currItem->visualXPos() - currItem->xPos() - lineAdjust);
253
                                        y = currItem->asLine() ? (h / -2.0) : (currItem->visualYPos() - currItem->yPos() - lineAdjust);
14372 jghali 254
                                }
255
                                else
256
                                {
257
                                        psx->translate(currItem->visualXPos(), currItem->visualYPos());
14517 jghali 258
                                        x = currItem->asLine() ? 0 : -lineAdjust;
259
                                        y = currItem->asLine() ? 0 : -lineAdjust;
14372 jghali 260
                                }
13039 pierre 261
 
14372 jghali 262
                                psx->drawRect(QRectF(x, y, w, h));
13040 pierre 263
 
14372 jghali 264
                                psx->restore();
265
                        }
13039 pierre 266
                }
12453 pierre 267
        }
268
        else if (m_doc->m_Selection->count() != 0)
269
        {
12451 pierre 270
//              ds = "S" + QString::number(m_doc->m_Selection->count())+" ";
12455 pierre 271
                const double markWidth = 4 / m_canvas->scale();
272
                const double halfMarkWidth = 2 / m_canvas->scale();
12451 pierre 273
 
10532 avox 274
                uint docSelectionCount = m_doc->m_Selection->count();
275
                PageItem *currItem;
12451 pierre 276
 
277
                // FIXME when more than 1 item is selected, first Rect is drew normally (<10ms here)
278
                // but followings are damn long - pm 
10532 avox 279
                for (uint a=0; a<docSelectionCount; ++a)
280
                {
281
                        currItem = m_doc->m_Selection->itemAt(a);
12451 pierre 282
//                      qDebug()<<"It"<<currItem->xPos()<< currItem->yPos();
283
 
10532 avox 284
                        psx->save();
12524 pierre 285
                        psx->setPen(m_pen["selection"]);
286
                        psx->setBrush(m_brush["selection"]);
287
                        double lineAdjust(psx->pen().width()/m_canvas->scale());
12467 pierre 288
                        double x, y, w, h;
14517 jghali 289
                        w = currItem->visualWidth();
290
                        h = currItem->visualHeight();
11116 avox 291
                        if (currItem->rotation() != 0)
292
                        {
293
                                psx->setRenderHint(QPainter::Antialiasing);
12467 pierre 294
                                psx->translate(currItem->xPos(), currItem->yPos());
11116 avox 295
                                psx->rotate(currItem->rotation());
18455 jghali 296
                                x = currItem->asLine() ? 0 : (currItem->visualXPos() - currItem->xPos() - lineAdjust);
297
                                y = currItem->asLine() ? (h / -2.0) : (currItem->visualYPos() - currItem->yPos() - lineAdjust);
11300 fschmid 298
                        }
12467 pierre 299
                        else
300
                        {
301
                                psx->translate(currItem->visualXPos(), currItem->visualYPos());
14517 jghali 302
                                x = currItem->asLine() ? 0 : -lineAdjust;
303
                                y = currItem->asLine() ? 0 : -lineAdjust;
12467 pierre 304
                        }
12523 pierre 305
 
14519 jghali 306
//                      tt.start();
12451 pierre 307
                        psx->drawRect(QRectF(x, y, w, h));
14519 jghali 308
//                      tu << QString::number(tt.elapsed());
14372 jghali 309
                        if(drawHandles && !currItem->locked())
12454 pierre 310
                        {
311
                                psx->setBrush(m_brush["handle"]);
312
                                psx->setPen(m_pen["handle"]);
12858 pierre 313
                                if(currItem->asLine())
314
                                {
315
                                        psx->setRenderHint(QPainter::Antialiasing);
14517 jghali 316
                                        psx->drawEllipse(QRectF(x+w-markWidth, y+h/2.0-markWidth, 2* markWidth,2* markWidth));
12858 pierre 317
//                                      psx->setBrush(Qt::blue); // sometimes we forget which is what :)
14517 jghali 318
                                        psx->drawEllipse(QRectF(x-markWidth, y+h/2.0-markWidth, 2* markWidth, 2* markWidth));
12858 pierre 319
                                }
320
                                else
321
                                {
322
                                        psx->drawRect(QRectF(x+w-markWidth, y+h-markWidth, markWidth, markWidth));
323
                                        psx->drawRect(QRectF(x+w/2 - halfMarkWidth, y+h-markWidth, markWidth, markWidth));
324
                                        psx->drawRect(QRectF(x+w/2 - halfMarkWidth, y, markWidth, markWidth));
325
                                        psx->drawRect(QRectF(x+w-markWidth, y+h/2 - halfMarkWidth, markWidth, markWidth));
326
                                        psx->drawRect(QRectF(x+w-markWidth, y, markWidth, markWidth));
327
                                        psx->drawRect(QRectF(x, y, markWidth, markWidth));
328
                                        psx->drawRect(QRectF(x, y+h/2 - halfMarkWidth, markWidth, markWidth));
329
                                        psx->drawRect(QRectF(x, y+h-markWidth, markWidth, markWidth));
330
                                }
12454 pierre 331
                        }
12451 pierre 332
 
10532 avox 333
                        psx->restore();
334
                }
12451 pierre 335
 
10532 avox 336
        }
12451 pierre 337
 
11076 avox 338
 
12451 pierre 339
//      qDebug()<<ds<< t.elapsed() <<"U"<<tu.join(",")<<"G"<<tg;
10532 avox 340
}
341
 
11328 avox 342
 
343
void CanvasMode::drawOutline(QPainter* p, double scalex, double scaley, double deltax, double deltay)
344
{
345
        p->save();
346
        p->scale(m_canvas->scale(), m_canvas->scale());
347
        p->translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y());
12440 avox 348
 
12453 pierre 349
 
11388 avox 350
        if (m_doc->m_Selection->count() == 1)
11328 avox 351
        {
11388 avox 352
                PageItem *currItem = m_doc->m_Selection->itemAt(0);
12451 pierre 353
 
354
                if((scalex != 1.0) || (scaley != 1.0)) // changing size of page item
11388 avox 355
                {
12453 pierre 356
                        p->setBrush(m_brush["outline"]);
357
                        p->setPen(m_pen["outline"]);
12451 pierre 358
                        p->translate(currItem->xPos(), currItem->yPos());
359
                        p->translate(deltax, deltay);
360
                        if (currItem->rotation() != 0)
361
                        {
362
                                p->setRenderHint(QPainter::Antialiasing);
363
                                p->rotate(currItem->rotation());
364
                        }
365
                        p->scale(scalex, scaley);
366
                        currItem->DrawPolyL(p, currItem->Clip);
11388 avox 367
                }
12451 pierre 368
                else // moving page item
369
                {
13336 jghali 370
                        QRectF br(currItem->getVisualBoundingRect());
13034 pierre 371
#ifdef GESTURE_FRAME_PREVIEW
372
                        QImage *pixItem(0);
13336 jghali 373
                        if( m_pixmapCache.contains(currItem) )
374
                        {
375
                                if( m_pixmapCache.value(currItem)->isReady() )
376
                                        pixItem = m_pixmapCache.value(currItem)->getImage();
377
                        }
378
                        else
379
                        {
380
                                m_pixmapCache[currItem] = new PageItemPreview(currItem);
381
                        }
12453 pierre 382
 
13336 jghali 383
                        if(pixItem)
384
                        {
385
                                p->save();
386
                                p->translate(br.x(),br.y());
387
                                p->translate(deltax, deltay);
388
                                p->drawImage( br.toRect(), *pixItem, pixItem->rect() );
389
                                p->restore();
390
                        }
13034 pierre 391
#endif // GESTURE_FRAME_PREVIEW
12451 pierre 392
                        {
13034 pierre 393
//                              QRect vr(m_canvas->exposedRect());
394
//                              QImage img(vr.width(), vr.height(), QImage::Format_ARGB32);
395
//                              ScPainter scp(&img,vr. width(), vr.height());
396
//                              scp.translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y());
13336 jghali 397
////                            scp.translate(currItem->xPos(), currItem->yPos());
398
////                            scp.translate(deltax, deltay);
399
////                            scp.scale(scalex, scaley);
400
////                            scp.scale(m_canvas->scale(), m_canvas->scale());
13034 pierre 401
//                              currItem->invalid = false;
402
//                              currItem->DrawObj(&scp, vr);
403
//                              p->drawImage(vr, img, img.rect() );
12451 pierre 404
 
12453 pierre 405
                                p->save();
406
                                p->setBrush(m_brush["outline"]);
407
                                p->setPen(m_pen["outline"]);
408
                                p->translate(currItem->xPos(), currItem->yPos());
409
                                p->translate(deltax, deltay);
410
                                if (currItem->rotation() != 0)
411
                                {
412
                                        p->setRenderHint(QPainter::Antialiasing);
413
                                        p->rotate(currItem->rotation());
414
                                }
415
                                p->scale(scalex, scaley);
416
                                currItem->DrawPolyL(p, currItem->Clip);
417
                                p->restore();
418
                        }
12451 pierre 419
                }      
11388 avox 420
        }
421
        else if (m_doc->m_Selection->count() > 1)
422
        {
11487 fschmid 423
                double x, y, w, h;
424
                m_doc->m_Selection->setGroupRect();
425
                m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
11328 avox 426
                uint docSelectionCount = m_doc->m_Selection->count();
427
                if (docSelectionCount < m_canvas->moveWithBoxesOnlyThreshold)
428
                {
429
                        PageItem *currItem;
12453 pierre 430
//                      p->translate(x, y);
11328 avox 431
                        for (uint a=0; a<docSelectionCount; ++a)
432
                        {
433
                                currItem = m_doc->m_Selection->itemAt(a);
12451 pierre 434
 
435
                                //Try to detect if the pageitem is a top level item.
436
                                if( currItem->Groups.count() > 0)
437
                                {
438
                                        if(! currItem->controlsGroup() )
439
                                                continue;
440
                                        else
441
                                        {
442
                                                if(currItem->Groups.count() > 1)
443
                                                        continue;
444
                                        }
445
                                }
11328 avox 446
                                p->save();
12451 pierre 447
                                if (docSelectionCount < m_canvas->moveWithFullOutlinesThreshold /*&& currItem->rotation() == 0*/)
11328 avox 448
                                {
12451 pierre 449
                                        if((scalex != 1.0) || (scaley != 1.0))
450
                                        {
12453 pierre 451
                                                p->setBrush(m_brush["outline"]);
452
                                                p->setPen(m_pen["outline"]);
12451 pierre 453
                                                p->translate(deltax, deltay);
12453 pierre 454
                                                p->translate(currItem->xPos() /*- x*/, currItem->yPos() /*- y*/);
12451 pierre 455
                                                p->scale(scalex, scaley);
456
                                                if (currItem->rotation() != 0)
457
                                                {
458
                                                        p->setRenderHint(QPainter::Antialiasing);
459
                                                        p->rotate(currItem->rotation());
460
                                                }
461
                                                currItem->DrawPolyL(p, currItem->Clip);
462
                                        }
463
                                        else
13336 jghali 464
                                        {
465
                                                QRectF br(currItem->getVisualBoundingRect());
13034 pierre 466
#ifdef GESTURE_FRAME_PREVIEW
12451 pierre 467
                                                QImage *pixItem(0);
468
                                                if( m_pixmapCache.contains(currItem) )
13034 pierre 469
                                                {
470
                                                        if( m_pixmapCache.value(currItem)->isReady() )
471
                                                                pixItem = m_pixmapCache.value(currItem)->getImage();
472
                                                }
12451 pierre 473
                                                else
474
                                                {
13034 pierre 475
                                                        m_pixmapCache[currItem] = new PageItemPreview(currItem);
12451 pierre 476
                                                }
13034 pierre 477
 
478
 
479
                                                if(pixItem)
12453 pierre 480
                                                {
481
                                                        p->save();
13336 jghali 482
//                                                      p->translate(br.x() /*- x*/, br.y() /*- y*/);
13034 pierre 483
                                                        p->drawImage( br.toRect(), *pixItem, pixItem->rect() );
12453 pierre 484
                                                        p->restore();
485
                                                }
13034 pierre 486
#endif  // GESTURE_FRAME_PREVIEW
12453 pierre 487
                                                {
488
                                                        p->save();
489
                                                        p->setBrush(m_brush["outline"]);
490
                                                        p->setPen(m_pen["outline"]);
491
                                                        p->translate(currItem->xPos(), currItem->yPos());
492
                                                        p->translate(deltax, deltay);
493
                                                        if (currItem->rotation() != 0)
494
                                                        {
495
                                                                p->setRenderHint(QPainter::Antialiasing);
496
                                                                p->rotate(currItem->rotation());
497
                                                        }
498
                                                        p->scale(scalex, scaley);
499
                                                        currItem->DrawPolyL(p, currItem->Clip);
500
                                                        p->restore();
501
                                                }
12451 pierre 502
                                        }
11328 avox 503
                                }
504
                                else
12451 pierre 505
                                {
12453 pierre 506
                                        p->setBrush(m_brush["outline"]);
507
                                        p->setPen(m_pen["outline"]);
12451 pierre 508
                                        p->translate(deltax, deltay);
12563 fschmid 509
                                        p->translate(x, y);
12451 pierre 510
                                        if (currItem->rotation() != 0)
511
                                        {
512
                                                p->setRenderHint(QPainter::Antialiasing);
513
                                                p->rotate(currItem->rotation());
514
                                        }
11328 avox 515
                                        p->drawRect(QRectF(0.0, 0.0, currItem->width()+1.0, currItem->height()+1.0));
12451 pierre 516
                                }
11328 avox 517
                                p->restore();
518
                        }
519
                }
520
                else
521
                {
12453 pierre 522
                        p->setBrush(m_brush["outline"]);
523
                        p->setPen(m_pen["outline"]);
12451 pierre 524
                        p->translate(deltax, deltay);
11553 fschmid 525
                        p->translate(x, y);
11485 fschmid 526
                        p->scale(scalex, scaley);
11553 fschmid 527
                        p->drawRect(QRectF(0, 0, w, h));
11328 avox 528
                }
529
        }
530
        p->restore();
531
}
532
 
17937 jghali 533
QCursor CanvasMode::modeCursor()
10978 avox 534
{
17937 jghali 535
        QCursor cursor;
10978 avox 536
        switch (m_doc->appMode)
537
        {
538
                case modeDrawShapes:
17937 jghali 539
                        cursor = QCursor(loadIcon("DrawFrame.xpm"));
10978 avox 540
                        break;
11298 cbradney 541
                case modeDrawImage:
17937 jghali 542
                        cursor =  QCursor(loadIcon("DrawImageFrame.xpm"));
10978 avox 543
                        break;
544
                case modeDrawLatex:
17937 jghali 545
                        cursor = QCursor(loadIcon("DrawLatexFrame.xpm"));
10978 avox 546
                        break;
547
                case modeDrawText:
17937 jghali 548
                        cursor = QCursor(loadIcon("DrawTextFrame.xpm"));
10978 avox 549
                        break;
550
                case modeDrawTable:
17937 jghali 551
                        cursor = QCursor(loadIcon("DrawTable.xpm"));
10978 avox 552
                        break;
553
                case modeDrawRegularPolygon:
17937 jghali 554
                        cursor = QCursor(loadIcon("DrawPolylineFrame.xpm"));
10978 avox 555
                        break;
556
                case modeDrawLine:
557
                case modeDrawBezierLine:
17937 jghali 558
                        cursor = QCursor(Qt::CrossCursor);
10978 avox 559
                        break;
560
                case modeDrawFreehandLine:
17937 jghali 561
                        cursor = QCursor(loadIcon("DrawFreeLine.png"), 0, 32);
10978 avox 562
                        break;
12971 jghali 563
                case modeImportObject:
17937 jghali 564
                        cursor = QCursor(loadIcon("DragPix.xpm"));
12971 jghali 565
                        break;
10978 avox 566
                case modeMagnifier:
567
                        if (m_view->Magnify)
17937 jghali 568
                                cursor = QCursor(loadIcon("LupeZ.xpm"));
10978 avox 569
                        else
17937 jghali 570
                                cursor = QCursor(loadIcon("LupeZm.xpm"));
10978 avox 571
                        break;
572
                case modePanning:
17937 jghali 573
                        cursor = QCursor(loadIcon("HandC.xpm"));
10978 avox 574
                        break;
575
                case modeEyeDropper:
17937 jghali 576
                        cursor = QCursor(loadIcon("colorpickercursor.png"), 0, 32);
10978 avox 577
                        break;
18921 jghali 578
                case modeLinkFrames:
579
                        cursor = QCursor(loadIcon("LinkTextFrame.png"), 0, 31);
580
                        break;
10978 avox 581
                case modeMeasurementTool:
582
                case modeEditGradientVectors:
583
                case modeInsertPDFButton:
584
                case modeInsertPDFTextfield:
585
                case modeInsertPDFCheckbox:
586
                case modeInsertPDFCombobox:
587
                case modeInsertPDFListbox:
588
                case modeInsertPDFTextAnnotation:
589
                case modeInsertPDFLinkAnnotation:
17937 jghali 590
                        cursor = QCursor(Qt::CrossCursor);
10978 avox 591
                        break;
592
                default:
17937 jghali 593
                        cursor = QCursor(Qt::ArrowCursor);
10978 avox 594
                        break;
595
        }
17937 jghali 596
        return cursor;
10978 avox 597
}
10532 avox 598
 
17937 jghali 599
void CanvasMode::setModeCursor()
600
{
601
        QCursor cursor = modeCursor();
18921 jghali 602
        m_view->setCursor(cursor);
17937 jghali 603
}
604
 
13034 pierre 605
#ifdef GESTURE_FRAME_PREVIEW
12451 pierre 606
void CanvasMode::clearPixmapCache()
607
{
608
        if(m_pixmapCache.count())
609
        {
13034 pierre 610
                foreach(PageItemPreview* ip, m_pixmapCache)
12451 pierre 611
                {
612
                        if(ip)
613
                                delete ip;
614
                }
615
                m_pixmapCache.clear();
616
        }
617
}
13034 pierre 618
#endif // GESTURE_FRAME_PREVIEW
10978 avox 619
 
12451 pierre 620
 
12799 pierre 621
 
622
void CanvasMode::setResizeCursor(int how, double rot)
623
{
624
        switch (how)
625
        {
626
                case 1:
627
                case 2:
18921 jghali 628
                        m_view->setCursor(ScResizeCursor(135 + rot));// Qt::SizeFDiagCursor
12799 pierre 629
                        break;
630
                case 3:
631
                case 4:
18921 jghali 632
                        m_view->setCursor(ScResizeCursor(45 + rot));// Qt::SizeBDiagCursor
12799 pierre 633
                        break;
634
                case 5:
635
                case 8:
18921 jghali 636
                        m_view->setCursor(ScResizeCursor(0 + rot));// Qt::SizeVerCursor
12799 pierre 637
                        break;
638
                case 6:
639
                case 7:
18921 jghali 640
                        m_view->setCursor(ScResizeCursor(90 + rot));// Qt::SizeHorCursor
12799 pierre 641
                        break;
642
                default:
18921 jghali 643
                        m_view->setCursor(QCursor(Qt::SizeAllCursor));
12799 pierre 644
                        break;
645
        }
646
}
13124 fschmid 647
 
13128 jghali 648
bool CanvasMode::commonMouseMove(QMouseEvent *m)
13124 fschmid 649
{
650
        if ((m_canvas->m_viewMode.m_MouseButtonPressed && (m->buttons() & Qt::RightButton) && (m->modifiers() & Qt::ControlModifier)) || ((!(m->modifiers() & Qt::ControlModifier)) && (m->buttons() & Qt::MidButton)))
651
        {
13184 jghali 652
                if (!m_panGesture)
13175 jghali 653
                {
13184 jghali 654
                        m_panGesture = new PanGesture(this);
13175 jghali 655
                }
13184 jghali 656
                m_view->startGesture(m_panGesture);
657
                m_panGesture->mousePressEvent(m); // Not an error, this is used to register current canvas point
13128 jghali 658
                return true;
13124 fschmid 659
        }
13128 jghali 660
        return false;
13124 fschmid 661
}
662
 
14372 jghali 663
void CanvasMode::commonDrawControls(QPainter* p, bool drawHandles)
13124 fschmid 664
{
665
        if (m_canvas->m_viewMode.operItemMoving)
666
                drawOutline(p);
667
        else
14372 jghali 668
                drawSelection(p, drawHandles);
13124 fschmid 669
}