Subversion Repositories Scribus

Rev

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

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