Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 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
*/
3 paul 7
/***************************************************************************
8
                          scribusview.cpp  -  description
9
                             -------------------
10
    begin                : Fre Apr  6 21:47:55 CEST 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
24
#include "scribusview.h"
25
#include "scribusview.moc"
128 Franz 26
 
2688 craig 27
#include "scconfig.h"
128 Franz 28
 
3 paul 29
#include <qcolor.h>
30
#include <qfont.h>
31
#include <qfontmetrics.h>
32
#include <qpixmap.h>
33
#include <qpointarray.h>
34
#include <qstringlist.h>
1525 cbradney 35
#include <qdragobject.h>
3 paul 36
#include <qimage.h>
37
#include <qcstring.h>
173 Franz 38
#include <qfileinfo.h>
456 fschmid 39
#include <qfile.h>
6451 fschmid 40
#include <qptrstack.h>
307 Franz 41
#include <cmath>
456 fschmid 42
#include <cstdio>
43
#include <cstdlib>
2702 craig 44
 
45
#ifdef HAVE_UNISTD_H
456 fschmid 46
#include <unistd.h>
2702 craig 47
#endif
48
 
456 fschmid 49
#include <qcursor.h>
50
#include <qurl.h>
51
#include <qdir.h>
52
#include <qevent.h>
2880 fschmid 53
#include <qsizegrip.h>
456 fschmid 54
#if QT_VERSION  > 0x030102
55
        #define SPLITVC SplitHCursor
56
        #define SPLITHC SplitVCursor
57
#else
58
        #define SPLITVC SplitVCursor
59
        #define SPLITHC SplitHCursor
60
#endif
181 Franz 61
#include "scribus.h"
1427 fschmid 62
#include "tree.h"
456 fschmid 63
#include "mpalette.h"
64
#include "scribusXml.h"
3903 cbradney 65
#include "selection.h"
456 fschmid 66
#include "serializer.h"
67
#include "insertTable.h"
838 cbradney 68
#include "hruler.h"
69
#include "vruler.h"
1151 fschmid 70
#include "filewatcher.h"
1226 tsoots 71
#include "undomanager.h"
1525 cbradney 72
#include "units.h"
1633 fschmid 73
#include "extimageprops.h"
3695 cbradney 74
#include "page.h"
1655 cbradney 75
#include "pageitemattributes.h"
3625 avox 76
#include "pageitem_imageframe.h"
77
#include "pageitem_line.h"
78
#include "pageitem_pathtext.h"
79
#include "pageitem_polygon.h"
80
#include "pageitem_polyline.h"
81
#include "pageitem_textframe.h"
3053 avox 82
#include "pageselector.h"
1693 craig 83
#include "scpaths.h"
2103 cbradney 84
#include "actionmanager.h"
456 fschmid 85
#ifdef HAVE_TIFF
86
        #include <tiffio.h>
87
#endif
88
#ifdef HAVE_CMS
89
        #include CMS_INC
90
#endif
68 Franz 91
 
3942 cbradney 92
#include "scmessagebox.h"
2529 craig 93
#include "util.h"
2495 cbradney 94
#include "story.h"
2834 cbradney 95
#include "prefsmanager.h"
2868 fschmid 96
#include "rulermover.h"
3252 craig 97
#include "hyphenator.h"
3510 cbradney 98
#include "commonstrings.h"
5087 subik 99
#include "guidemanager.h"
5184 avox 100
#include "text/nlsconfig.h"
5827 fschmid 101
#include "scrap.h"
102
#include "stencilreader.h"
5746 fschmid 103
#ifdef HAVE_CAIRO
104
#include <cairo.h>
105
#endif
2495 cbradney 106
 
504 cbradney 107
using namespace std;
108
 
3 paul 109
 
3205 craig 110
 
5781 cbradney 111
ScribusView::ScribusView(QWidget* win, ScribusMainWindow* mw, ScribusDoc *doc) :
112
        QScrollView(win, "s", WRepaintNoErase | WNorthWestGravity),
3981 craig 113
        Doc(doc),
114
        Prefs(&(PrefsManager::instance()->appPrefs)),
3982 craig 115
        undoManager(UndoManager::instance()),
116
        OldScale(0),
117
        GroupX(0), GroupY(0), GroupW(0), GroupH(0),
118
        oldW(-1), oldCp(-1),
119
        Mxp(-1), Myp(-1), Dxp(-1), Dyp(-1),
4663 cbradney 120
        frameResizeHandle(-1),
3982 craig 121
        SeRx(-1), SeRy(-1), GyM(-1), GxM(-1),
122
        ClRe(-1), ClRe2(-1),
123
        SegP1(-1), SegP2(-1),
124
        RotMode(0),
125
        DrHY(-1), DrVX(-1),
126
        EdPoints(true),
4705 cbradney 127
        m_MouseButtonPressed(false),   
4663 cbradney 128
        operItemMoving(false),
3982 craig 129
        MoveGY(false), MoveGX(false),
130
        HaveSelRect(false),
4663 cbradney 131
        operItemResizing(false),
3982 craig 132
        EditContour(false),
4049 cbradney 133
        //GroupSel(false),
3982 craig 134
        DraggedGroup(false),
135
        DraggedGroupFirst(false),
4663 cbradney 136
        operItemResizeInEditMode(false),
3982 craig 137
        MidButt(false),
138
        updateOn(true),
139
        FirstPoly(true),
140
        Magnify(false),
141
        MoveSym(false),
142
        previewMode(false),
143
        RCenter(-1,-1),
144
        RecordP(),
145
        Ready(false),
146
        oldX(0), oldY(0),
147
        _groupTransactionStarted(false),
148
        _isGlobalMode(true),
149
        evSpon(false),
150
        forceRedraw(false),
4654 cbradney 151
        Scale(Prefs->DisScale),
6191 tsoots 152
        oldClip(0),
4704 cbradney 153
        m_vhRulerHW(17),
5781 cbradney 154
        m_cursorVisible(false),
155
        m_ScMW(mw)
3 paul 156
{
157
        setHScrollBarMode(QScrollView::AlwaysOn);
158
        setVScrollBarMode(QScrollView::AlwaysOn);
4654 cbradney 159
        setMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
3 paul 160
        setResizePolicy(Manual);
240 Franz 161
        viewport()->setBackgroundMode(PaletteBackground);
3 paul 162
        QFont fo = QFont(font());
2887 fschmid 163
        int posi = fo.pointSize()-2;
164
        fo.setPointSize(posi);
3689 cbradney 165
        unitSwitcher = new QComboBox( false, this, "unitSwitcher" );
2887 fschmid 166
        unitSwitcher->setFocusPolicy(QWidget::NoFocus);
167
        unitSwitcher->setFont(fo);
2966 fschmid 168
        for (int i=0;i<=unitGetMaxIndex();++i)
169
                unitSwitcher->insertItem(unitGetStrFromIndex(i));
3309 cbradney 170
        zoomSpinBox = new MSpinBox( 10, 3200, this, 2 );
171
        zoomSpinBox->setFont(fo);
172
        zoomSpinBox->setValue( 100 );
173
        zoomSpinBox->setFocusPolicy(QWidget::ClickFocus);
174
        zoomSpinBox->setSuffix( tr( " %" ) );
3053 avox 175
#if OPTION_USE_QTOOLBUTTON
176
        zoomOutToolbarButton = new QToolButton(this);
3274 fschmid 177
        zoomDefaultToolbarButton = new QToolButton(this);
3053 avox 178
        zoomInToolbarButton = new QToolButton(this);
6549 fschmid 179
        previewToolbarButton = new QToolButton(this);
3274 fschmid 180
        zoomDefaultToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
3053 avox 181
        zoomOutToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
182
        zoomInToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
6549 fschmid 183
        previewToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
184
        previewToolbarButton->setToggleButton(true);
185
        QIconSet ic;
186
        ic.setPixmap(loadIcon("previewOff.png"), QIconSet::Automatic, QIconSet::Normal, QIconSet::Off);
187
        ic.setPixmap(loadIcon("previewOn.png"), QIconSet::Automatic, QIconSet::Normal, QIconSet::On);
188
        previewToolbarButton->setIconSet(ic);
3053 avox 189
#else
3274 fschmid 190
        zoomDefaultToolbarButton = new QPushButton(this);
191
        zoomDefaultToolbarButton->setFocusPolicy(QWidget::NoFocus);
192
        zoomDefaultToolbarButton->setDefault( false );
193
        zoomDefaultToolbarButton->setAutoDefault( false );
194
        zoomDefaultToolbarButton->setFlat(OPTION_FLAT_BUTTON);
1822 cbradney 195
        zoomOutToolbarButton = new QPushButton(this);
196
        zoomOutToolbarButton->setFocusPolicy(QWidget::NoFocus);
3053 avox 197
        zoomOutToolbarButton->setDefault( false );
198
        zoomOutToolbarButton->setAutoDefault( false );
199
        zoomOutToolbarButton->setFlat(OPTION_FLAT_BUTTON);
3274 fschmid 200
        zoomInToolbarButton = new QPushButton(this);
201
        zoomInToolbarButton->setFocusPolicy(QWidget::NoFocus);
3053 avox 202
        zoomInToolbarButton->setDefault( false );
203
        zoomInToolbarButton->setAutoDefault( false );
204
        zoomInToolbarButton->setFlat(OPTION_FLAT_BUTTON);
6549 fschmid 205
        previewToolbarButton = new QPushButton(this);
206
        previewToolbarButton->setFocusPolicy(QWidget::NoFocus);
207
        previewToolbarButton->setDefault( false );
208
        previewToolbarButton->setAutoDefault( false );
209
        previewToolbarButton->setFlat(OPTION_FLAT_BUTTON);
210
        previewToolbarButton->setPixmap(loadIcon("previewOn.png"));
3053 avox 211
#endif
5287 cbradney 212
        //zoomDefaultToolbarButton->setText("1:1");
213
        zoomDefaultToolbarButton->setPixmap(loadIcon("16/zoom-original.png"));
214
        zoomOutToolbarButton->setPixmap(loadIcon("16/zoom-out.png"));
215
        zoomInToolbarButton->setPixmap(loadIcon("16/zoom-in.png"));
3309 cbradney 216
        pageSelector = new PageSelector(this, 1);
217
        pageSelector->setFont(fo);
218
        pageSelector->setFocusPolicy(QWidget::ClickFocus);
219
        layerMenu = new QComboBox( true, this, "LY" );
220
        layerMenu->setEditable(false);
221
        layerMenu->setFont(fo);
222
        layerMenu->setFocusPolicy(QWidget::NoFocus);
6549 fschmid 223
        visualMenu = new QComboBox( false, this, "visualMenu" );
224
        visualMenu->setFocusPolicy(QWidget::NoFocus);
225
        visualMenu->setFont(fo);
226
        visualMenu->setEnabled(false);
1612 cbradney 227
        horizRuler = new Hruler(this, Doc);
228
        vertRuler = new Vruler(this, Doc);
3309 cbradney 229
        rulerMover = new RulerMover(this);
230
        rulerMover->setFocusPolicy(QWidget::NoFocus);
3 paul 231
        Ready = true;
456 fschmid 232
        viewport()->setMouseTracking(true);
233
        setAcceptDrops(true);
234
        viewport()->setAcceptDrops(true);
235
        setDragAutoScroll(false);
236
        Doc->DragP = false;
237
        Doc->leaveDrag = false;
1330 fschmid 238
        Doc->SubMode = -1;
5237 fschmid 239
        storedFramesShown = Doc->guidesSettings.framesShown;
5235 fschmid 240
        viewAsPreview = false;
6549 fschmid 241
        previewVisual = 0;
6349 fschmid 242
        shiftSelItems = false;
5664 fschmid 243
#ifdef HAVE_CAIRO
5781 cbradney 244
        m_ScMW->scrActions["viewFit20"]->setOn(viewAsPreview);
5664 fschmid 245
#endif
6477 fschmid 246
        m_SnapCounter = 0;
1822 cbradney 247
        connect(zoomOutToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomOut()));
248
        connect(zoomInToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomIn()));
3274 fschmid 249
        connect(zoomDefaultToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoom100()));
4704 cbradney 250
        connect(zoomSpinBox, SIGNAL(valueChanged(int)), this, SLOT(setZoom()));
3309 cbradney 251
        connect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
252
        connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
2966 fschmid 253
        connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
6549 fschmid 254
        connect(previewToolbarButton, SIGNAL(clicked()), this, SLOT(togglePreview()));
255
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
3 paul 256
        connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
1443 tsoots 257
        connect(this, SIGNAL(HaveSel(int)), this, SLOT(selectionChanged()));
6549 fschmid 258
        languageChange();
3 paul 259
}
260
 
2199 cbradney 261
void ScribusView::languageChange()
262
{
6549 fschmid 263
//      disconnect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
264
//      disconnect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
265
        disconnect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
266
//      zoomSpinBox->setSuffix( tr( " %" ) );
267
//      layerMenu->setCurrentText( tr("Layer")+" 0");
2199 cbradney 268
        //CB TODO Convert to actions later
6549 fschmid 269
//      unitSwitcher->clear();
270
//      for (int i=0;i<=unitGetMaxIndex();++i)
271
//              unitSwitcher->insertItem(unitGetStrFromIndex(i));
272
        visualMenu->clear();
273
        visualMenu->insertItem( tr("Normal Vision"));
274
        visualMenu->insertItem( tr("Protanopia (Red)"));
275
        visualMenu->insertItem( tr("Deuteranopia (Green)"));
276
        visualMenu->insertItem( tr("Tritanopia (Blue)"));
277
        visualMenu->insertItem( tr("Full Color Blindness"));
278
        visualMenu->setCurrentItem(previewVisual);
279
//      unitSwitcher->setCurrentText(unitGetStrFromIndex(Doc->unitIndex()));
280
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
281
//      connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
282
//      connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
2199 cbradney 283
}
284
 
6549 fschmid 285
void ScribusView::switchPreviewVisual(int vis)
286
{
287
        previewVisual = vis;
288
        Doc->recalculateColors();
289
        Doc->recalcPicturesRes();
290
        updateContents();
291
}
292
 
5235 fschmid 293
void ScribusView::togglePreview()
294
{
295
        viewAsPreview = !viewAsPreview;
5237 fschmid 296
        if (viewAsPreview)
297
        {
298
                storedFramesShown = Doc->guidesSettings.framesShown;
299
                Doc->guidesSettings.framesShown = false;
300
        }
301
        else
302
                Doc->guidesSettings.framesShown = storedFramesShown;
5781 cbradney 303
        m_ScMW->scrActions["viewFit20"]->setOn(viewAsPreview);
304
        m_ScMW->scrActions["viewShowMargins"]->setEnabled(!viewAsPreview);
305
        m_ScMW->scrActions["viewShowFrames"]->setEnabled(!viewAsPreview);
306
        m_ScMW->scrActions["viewShowLayerMarkers"]->setEnabled(!viewAsPreview);
307
        m_ScMW->scrActions["viewShowGrid"]->setEnabled(!viewAsPreview);
308
        m_ScMW->scrActions["viewShowGuides"]->setEnabled(!viewAsPreview);
309
        m_ScMW->scrActions["viewShowColumnBorders"]->setEnabled(!viewAsPreview);
310
        m_ScMW->scrActions["viewShowBaseline"]->setEnabled(!viewAsPreview);
311
        m_ScMW->scrActions["viewShowTextChain"]->setEnabled(!viewAsPreview);
312
        m_ScMW->scrActions["viewShowTextControls"]->setEnabled(!viewAsPreview);
6549 fschmid 313
#if OPTION_USE_QTOOLBUTTON
314
        previewToolbarButton->setOn(viewAsPreview);
315
#endif
316
        visualMenu->setEnabled(viewAsPreview);
317
        Doc->recalculateColors();
318
        Doc->recalcPicturesRes();
5235 fschmid 319
        updateContents();
320
}
321
 
2171 fschmid 322
void ScribusView::viewportPaintEvent ( QPaintEvent * p )
323
{
4011 cbradney 324
        #ifndef _WIN32
2171 fschmid 325
        if (p->spontaneous())
326
                evSpon = true;
4011 cbradney 327
        #endif
2171 fschmid 328
        QScrollView::viewportPaintEvent(p);
329
}
330
 
5373 fschmid 331
void ScribusView::drawContents(QPainter *psx, int clipx, int clipy, int clipw, int cliph)
456 fschmid 332
{
2891 cbradney 333
        if (Doc->isLoading())
456 fschmid 334
                return;
335
        if (!updateOn)
336
                return;
337
//      QTime tim;
338
//      tim.start();
339
        if ((clipw > 0) && (cliph > 0))
340
        {
3313 cbradney 341
                QPoint vr = contentsToViewport(QPoint(clipx, clipy));
5373 fschmid 342
                ScPainter *painter;
343
#ifdef HAVE_CAIRO
344
                struct Layer la;
345
                la.LNr = 0;
346
                int Lnr = 0;
347
                Level2Layer(Doc, &la, Lnr);
5433 fschmid 348
                QImage img = QImage(clipw, cliph, 32);
5746 fschmid 349
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5373 fschmid 350
                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
351
                        painter = new ScPainter(&img, img.width(), img.height(), 1.0, 0);
352
                else
353
                        painter = new ScPainter(&img, img.width(), img.height());
354
#else
5746 fschmid 355
                painter = new ScPainter(&img, img.width(), img.height(), 1.0, 0);
356
#endif
357
#else
5373 fschmid 358
                        painter = new ScPainter(viewport(), clipw, cliph, vr.x(), vr.y());
359
#endif
456 fschmid 360
                painter->clear(paletteBackgroundColor());
2848 fschmid 361
                painter->translate(-Doc->minCanvasCoordinate.x()*Scale, -Doc->minCanvasCoordinate.y()*Scale);
456 fschmid 362
                painter->translate(-clipx, -clipy);
363
                painter->setLineWidth(1);
364
                painter->setFillMode(ScPainter::Solid);
2538 fschmid 365
//              painter->translate(0.5, 0.5);
456 fschmid 366
                painter->setZoomFactor(1.0);
367
/* Draw Page Outlines */
3724 cbradney 368
                if (!Doc->masterPageMode())
456 fschmid 369
                {
3724 cbradney 370
                        uint docPagesCount=Doc->Pages->count();
5664 fschmid 371
                        for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
456 fschmid 372
                        {
5664 fschmid 373
                                int x = qRound(Doc->Pages->at(a)->xOffset() * Scale);
374
                                int y = qRound(Doc->Pages->at(a)->yOffset() * Scale);
375
                                int w = qRound(Doc->Pages->at(a)->width() * Scale);
376
                                int h = qRound(Doc->Pages->at(a)->height() * Scale);
377
                                QRect drawRect = QRect(x, y, w+5, h+5);
378
                                drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
379
                                if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
456 fschmid 380
                                {
5373 fschmid 381
#ifdef HAVE_CAIRO
5752 fschmid 382
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 383
                                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
384
                                                painter->beginLayer(1.0, 0);
5752 fschmid 385
#else
386
                                        painter->beginLayer(1.0, 0);
5373 fschmid 387
#endif
5752 fschmid 388
#endif
5664 fschmid 389
                                        painter->setFillMode(ScPainter::Solid);
390
                                        painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
6534 fschmid 391
                                        if (!viewAsPreview)
392
                                        {
393
                                                painter->setBrush(QColor(128,128,128));
394
                                                painter->drawRect(x+5, y+5, w, h);
395
                                        }
5664 fschmid 396
                                        if (a == Doc->currentPageNumber())
6326 fschmid 397
                                                painter->setPen(Prefs->DPageBorderColor, 2, SolidLine, FlatCap, MiterJoin);
5664 fschmid 398
                                        else
5235 fschmid 399
                                                painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
5664 fschmid 400
                                        painter->setBrush(Doc->papColor);
6549 fschmid 401
                                        painter->drawRect(x, y, w, h);
5664 fschmid 402
                                        if ((Doc->guidesSettings.before) && (!viewAsPreview))
403
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
6536 fschmid 404
#ifdef HAVE_CAIRO
5752 fschmid 405
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 406
                                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
6534 fschmid 407
                                                        painter->endLayer();
5752 fschmid 408
#else
409
                                        painter->endLayer();
5373 fschmid 410
#endif
6536 fschmid 411
#endif
456 fschmid 412
                                }
5664 fschmid 413
                        }
5601 fschmid 414
#ifdef HAVE_CAIRO
5752 fschmid 415
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 416
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
417
                                painter->beginLayer(1.0, 0);
5752 fschmid 418
#else
419
                        painter->beginLayer(1.0, 0);
5660 fschmid 420
#endif
5752 fschmid 421
#endif
5664 fschmid 422
                        for (uint a = 0; a < docPagesCount; ++a)
423
                        {
424
                                DrawMasterItems(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
425
                        }
426
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
5604 fschmid 427
#ifdef HAVE_CAIRO
6534 fschmid 428
                        if (viewAsPreview)
429
                        {
430
                                FPointArray PoLine;
431
                                bool first = true;
432
                                for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
433
                                {
434
                                        if (!first)
435
                                                PoLine.setMarker();
436
                                        first = false;
437
                                        double x = Doc->Pages->at(a)->xOffset() * Scale;
438
                                        double y = Doc->Pages->at(a)->yOffset() * Scale;
439
                                        double w = Doc->Pages->at(a)->width() * Scale;
440
                                        double h = Doc->Pages->at(a)->height() * Scale;
441
                                        static double rect[] = {0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0,
442
                                                                                                        1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0,
443
                                                                                                        0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0};
444
                                        for (int a = 0; a < 29; a += 4)
445
                                        {
446
                                                PoLine.addPoint(x + w * rect[a], y + h * rect[a+1]);
447
                                                PoLine.addPoint(x + w * rect[a+2], y + h * rect[a+3]);
448
                                        }
449
                                }
5752 fschmid 450
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
6534 fschmid 451
                                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
452
                                        painter->endLayer(&PoLine);
5752 fschmid 453
#else
6534 fschmid 454
                                painter->endLayer(&PoLine);
5604 fschmid 455
#endif
6534 fschmid 456
                        }
457
                        else
458
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
459
                        {
460
                                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
461
                                        painter->endLayer();
462
                        }
463
#else
464
                                painter->endLayer();
465
#endif
466
#endif
5664 fschmid 467
                        if ((!Doc->guidesSettings.before) && (!viewAsPreview))
468
                        {
469
                                for (uint a = 0; a < docPagesCount; ++a)
5235 fschmid 470
                                {
5664 fschmid 471
                                        int x = static_cast<int>(Doc->Pages->at(a)->xOffset() * Scale);
472
                                        int y = static_cast<int>(Doc->Pages->at(a)->yOffset() * Scale);
473
                                        int w = static_cast<int>(Doc->Pages->at(a)->width() * Scale);
474
                                        int h = static_cast<int>(Doc->Pages->at(a)->height() * Scale);
475
                                        QRect drawRect = QRect(x, y, w+5, h+5);
476
                                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
477
                                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
478
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
5235 fschmid 479
                                }
456 fschmid 480
                        }
481
                }
482
                else
483
                {
484
                        int x = static_cast<int>(Doc->ScratchLeft * Scale);
485
                        int y = static_cast<int>(Doc->ScratchTop * Scale);
5087 subik 486
                        int w = static_cast<int>(Doc->currentPage()->width() * Scale);
487
                        int h = static_cast<int>(Doc->currentPage()->height() * Scale);
2848 fschmid 488
                        QRect drawRect = QRect(x, y, w+5, h+5);
489
                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
490
                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
456 fschmid 491
                        {
5373 fschmid 492
#ifdef HAVE_CAIRO
5752 fschmid 493
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5373 fschmid 494
                                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
495
                                        painter->beginLayer(1.0, 0);
5752 fschmid 496
#else
497
                                painter->beginLayer(1.0, 0);
5373 fschmid 498
#endif
5752 fschmid 499
#endif
456 fschmid 500
                                painter->setFillMode(ScPainter::Solid);
501
                                painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
502
                                painter->setBrush(QColor(128,128,128));
503
                                painter->drawRect(x+5, y+5, w, h);
504
                                painter->setBrush(Doc->papColor);
505
                                painter->drawRect(x, y, w, h);
1187 fschmid 506
                                if (Doc->guidesSettings.before)
5087 subik 507
                                        DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
5373 fschmid 508
#ifdef HAVE_CAIRO
5752 fschmid 509
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5373 fschmid 510
                                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
511
                                        painter->endLayer();
5752 fschmid 512
#else
513
                                painter->endLayer();
5373 fschmid 514
#endif
5752 fschmid 515
#endif
456 fschmid 516
                        }
5604 fschmid 517
#ifdef HAVE_CAIRO
5752 fschmid 518
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5604 fschmid 519
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
520
                                painter->beginLayer(1.0, 0);
5752 fschmid 521
#else
522
                        painter->beginLayer(1.0, 0);
5604 fschmid 523
#endif
5752 fschmid 524
#endif
456 fschmid 525
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
5604 fschmid 526
#ifdef HAVE_CAIRO
5752 fschmid 527
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5604 fschmid 528
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
529
                                painter->endLayer();
5752 fschmid 530
#else
531
                        painter->endLayer();
5604 fschmid 532
#endif
5752 fschmid 533
#endif
2848 fschmid 534
                        if ((!Doc->guidesSettings.before) && (drawRect.intersects(QRect(clipx, clipy, clipw, cliph))))
5087 subik 535
                                DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
456 fschmid 536
                }
5235 fschmid 537
                if (((Doc->m_Selection->count() != 0) || (linkedFramesToShow.count() != 0))  && (!viewAsPreview))
456 fschmid 538
                {
539
                        double z = painter->zoomFactor();
540
                        painter->setZoomFactor(Scale);
541
                        painter->save();
1957 cbradney 542
                        PageItem *currItem;
879 fschmid 543
                        if ((Doc->guidesSettings.linkShown) && (linkedFramesToShow.count() != 0))
1957 cbradney 544
                                currItem = linkedFramesToShow.at(0);
705 fschmid 545
                        else
808 fschmid 546
                        {
547
                                if (linkedFramesToShow.count() != 0)
1957 cbradney 548
                                        currItem = linkedFramesToShow.at(0);
808 fschmid 549
                                else
4847 cbradney 550
                                        currItem = Doc->m_Selection->itemAt(0);
808 fschmid 551
                        }
3594 cbradney 552
                        //Draw the frame links
2603 cbradney 553
                        if ((((Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
1957 cbradney 554
                                   && (currItem->itemType() == PageItem::TextFrame)) || (Doc->guidesSettings.linkShown))
456 fschmid 555
                        {
1957 cbradney 556
                                PageItem *nextItem = currItem;
879 fschmid 557
                                if (Doc->guidesSettings.linkShown)
456 fschmid 558
                                {
705 fschmid 559
                                        for (uint lks = 0; lks < linkedFramesToShow.count(); ++lks)
560
                                        {
1957 cbradney 561
                                                nextItem = linkedFramesToShow.at(lks);
562
                                                while (nextItem != 0)
705 fschmid 563
                                                {
3954 cbradney 564
                                                        //Calculate the link points of the frames
3903 cbradney 565
                                                        double x11 = nextItem->xPos();
566
                                                        double y11 = nextItem->yPos();
3934 cbradney 567
                                                        double x12 = x11+nextItem->width();
568
                                                        double y12 = y11+nextItem->height();
3708 cbradney 569
                                                        double x1mid = x11+(x12-x11)/2;
570
                                                        double y1mid = y11+(y12-y11)/2;
814 cbradney 571
 
3934 cbradney 572
                                                        if (nextItem->rotation()!=0.000)
814 cbradney 573
                                                        {
3934 cbradney 574
                                                                FPoint tempPoint(0,0, x11, y11, nextItem->rotation(), 1, 1);
814 cbradney 575
                                                                x11=tempPoint.x();
576
                                                                y11=tempPoint.y();
3934 cbradney 577
                                                                FPoint tempPoint2(0,0, x12, y12, nextItem->rotation(), 1, 1);
3242 cbradney 578
                                                                x12=tempPoint2.x();
579
                                                                y12=tempPoint2.y();
3934 cbradney 580
                                                                FPoint tempPoint3(0,0, x1mid, y1mid, nextItem->rotation(), 1, 1);
3242 cbradney 581
                                                                x1mid=tempPoint3.x();
582
                                                                y1mid=tempPoint3.y();
814 cbradney 583
                                                        }
584
 
1485 tsoots 585
 
814 cbradney 586
                                                        double a1, b1, a2, b2;
823 fschmid 587
                                                        a1 = a2 = b1 = b2 = 0;
5732 avox 588
                                                        if (nextItem->NextBox != NULL)
814 cbradney 589
                                                        {
3903 cbradney 590
                                                                double x21 = nextItem->NextBox->xPos();
591
                                                                double y21 = nextItem->NextBox->yPos();
3934 cbradney 592
                                                                double x22 = x21+nextItem->NextBox->width();
593
                                                                double y22 = y21+nextItem->NextBox->height();
594
                                                                double x2mid = x21 + nextItem->NextBox->width()/2;
595
                                                                double y2mid = y21 + nextItem->NextBox->height()/2;
3708 cbradney 596
                                                                //x2mid = x21+(x22-x21)/2;
597
                                                                //y2mid = y21+(y22-y21)/2;
814 cbradney 598
 
3934 cbradney 599
                                                                if (nextItem->NextBox->rotation()!=0.000)
814 cbradney 600
                                                                {
3934 cbradney 601
                                                                        FPoint tempPoint(0,0, x21, y21, nextItem->NextBox->rotation(), 1, 1);
814 cbradney 602
                                                                        x21=tempPoint.x();
603
                                                                        y21=tempPoint.y();
3934 cbradney 604
                                                                        FPoint tempPoint2(0,0, x22, y22, nextItem->NextBox->rotation(), 1, 1);
3242 cbradney 605
                                                                        x22=tempPoint2.x();
606
                                                                        y22=tempPoint2.y();
3934 cbradney 607
                                                                        FPoint tempPoint3(0,0, x2mid, y2mid, nextItem->NextBox->rotation(), 1, 1);
3242 cbradney 608
                                                                        x2mid=tempPoint3.x();
609
                                                                        y2mid=tempPoint3.y();
814 cbradney 610
                                                                }
1485 tsoots 611
 
814 cbradney 612
                                                                if (x22<x11) { a1 = x11; a2 = x22; }
613
                                                                if (x21>x12) { a1 = x12; a2 = x21; }
614
                                                                if (y22<y11) { b1 = y11; b2 = y22; }
615
                                                                if (y21>y12) { b1 = y12; b2 = y21; }
616
 
617
                                                                if (x21<x12 && x21>x11) { a1 = x1mid; a2 = x2mid; }
618
                                                                if (x21<x11 && x22>x11) { a1 = x1mid; a2 = x2mid; }
619
 
620
                                                                if (y21<y12 && y21>y11) { b1 = y1mid; b2 = y2mid; }
621
                                                                if (y21<y11 && y22>y11) { b1 = y1mid; b2 = y2mid; }
622
 
623
                                                        }
3954 cbradney 624
                                                        //Draw the link frame lines
3934 cbradney 625
                                                        FPoint Start(a1-nextItem->xPos(), b1-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3903 cbradney 626
                                                        //FPoint Start = transformPoint(FPoint(nextItem->Width/2, nextItem->Height), nextItem->xPos(), nextItem->yPos(), nextItem->Rot, 1, 1);
1957 cbradney 627
                                                        nextItem = nextItem->NextBox;
628
                                                        if (nextItem != NULL)
705 fschmid 629
                                                        {
3934 cbradney 630
                                                                FPoint End(a2-nextItem->xPos(), b2-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3954 cbradney 631
                                                                drawLinkFrameLine(painter, Start, End);
705 fschmid 632
                                                        }
633
                                                }
634
                                        }
456 fschmid 635
                                }
705 fschmid 636
                                else
456 fschmid 637
                                {
1957 cbradney 638
                                        while (nextItem != 0)
456 fschmid 639
                                        {
1957 cbradney 640
                                                if (nextItem->BackBox != 0)
641
                                                        nextItem = nextItem->BackBox;
705 fschmid 642
                                                else
643
                                                        break;
456 fschmid 644
                                        }
1957 cbradney 645
                                        while (nextItem != 0)
705 fschmid 646
                                        {
3934 cbradney 647
                                                FPoint Start(nextItem->width()/2, nextItem->height(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
1957 cbradney 648
                                                nextItem = nextItem->NextBox;
3954 cbradney 649
                                                //Draw the link frame indicator for a new link
650
                                                //CB unsure if we need to do this
1957 cbradney 651
                                                if (nextItem != 0)
705 fschmid 652
                                                {
3934 cbradney 653
                                                        FPoint End(nextItem->width()/2, 0, nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3954 cbradney 654
                                                        drawLinkFrameLine(painter, Start, End);
705 fschmid 655
                                                }
656
                                        }
456 fschmid 657
                                }
658
                        }
659
                        painter->setLineWidth(1);
660
                        painter->setPenOpacity(1.0);
661
                        painter->restore();
662
                        painter->setZoomFactor(z);
663
                }
664
                painter->end();
5373 fschmid 665
#ifdef HAVE_CAIRO
666
                psx->drawImage(clipx, clipy, img);
667
#endif
456 fschmid 668
                delete painter;
3708 cbradney 669
                painter=NULL;
456 fschmid 670
        }
4847 cbradney 671
        if (Doc->m_Selection->count() != 0)
456 fschmid 672
        {
4847 cbradney 673
                PageItem *currItem = Doc->m_Selection->itemAt(0);
1957 cbradney 674
                currItem->paintObj();
3934 cbradney 675
                if ((Doc->EditClip) && (currItem->isSelected()))
2934 fschmid 676
                {
677
                if (EditContour)
678
                        MarkClip(currItem, currItem->ContourLine, true);
679
                else
680
                        MarkClip(currItem, currItem->PoLine, true);
681
                }
4847 cbradney 682
                if (Doc->m_Selection->isMultipleSelection())
456 fschmid 683
                {
684
                        setGroupRect();
685
                        paintGroupRect();
686
                }
687
        }
2603 cbradney 688
        if (Doc->appMode == modeEdit)
456 fschmid 689
                slotDoCurs(true);
2603 cbradney 690
        if (Doc->appMode == modeEditGradientVectors)
735 fschmid 691
        {
4847 cbradney 692
                PageItem *currItem = Doc->m_Selection->itemAt(0);
735 fschmid 693
                QPainter p;
694
                p.begin(viewport());
695
                ToView(&p);
1957 cbradney 696
                Transform(currItem, &p);
735 fschmid 697
                p.setPen(QPen(blue, 1, SolidLine, FlatCap, MiterJoin));
698
                p.setBrush(NoBrush);
1957 cbradney 699
                p.drawLine(QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)), QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)));
735 fschmid 700
                p.setPen(QPen(magenta, 8, SolidLine, RoundCap, MiterJoin));
1957 cbradney 701
                p.drawLine(QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)), QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)));
702
                p.drawLine(QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)), QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)));
735 fschmid 703
                p.end();
704
        }
2171 fschmid 705
        evSpon = false;
2951 fschmid 706
        forceRedraw = false;
456 fschmid 707
//      qDebug( "Time elapsed: %d ms", tim.elapsed() );
708
}
709
 
710
void ScribusView::DrawMasterItems(ScPainter *painter, Page *page, QRect clip)
711
{
6451 fschmid 712
        QPtrStack<PageItem> groupStack;
713
        QPtrStack<PageItem> groupClips;
456 fschmid 714
        double z = painter->zoomFactor();
2877 cbradney 715
        if (!page->MPageNam.isEmpty())
456 fschmid 716
        {
717
                Page* Mp = Doc->MasterPages.at(Doc->MasterNames[page->MPageNam]);
718
                if (page->FromMaster.count() != 0)
719
                {
4689 mrdocs 720
                        //QPainter p;
3313 cbradney 721
                        int Lnr;
722
                        struct Layer ll;
723
                        PageItem *currItem;
724
                        ll.isViewable = false;
725
                        ll.LNr = 0;
456 fschmid 726
                        Lnr = 0;
2951 fschmid 727
                        uint layerCount=Doc->layerCount();
2937 cbradney 728
                        for (uint la = 0; la < layerCount; ++la)
456 fschmid 729
                        {
730
                                Level2Layer(Doc, &ll, Lnr);
1874 fschmid 731
                                bool pr = true;
732
                                if ((previewMode) && (!ll.isPrintable))
733
                                        pr = false;
734
                                if ((ll.isViewable) && (pr))
456 fschmid 735
                                {
5373 fschmid 736
#ifdef HAVE_CAIRO
737
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
5375 fschmid 738
                                                painter->beginLayer(ll.transparency, ll.blendMode);
5373 fschmid 739
#endif
3689 cbradney 740
                                        uint pageFromMasterCount=page->FromMaster.count();
741
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
456 fschmid 742
                                        {
1957 cbradney 743
                                                currItem = page->FromMaster.at(a);
744
                                                if (currItem->LayerNr != ll.LNr)
456 fschmid 745
                                                        continue;
3200 cbradney 746
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
456 fschmid 747
                                                        continue;
4698 cbradney 748
                                                if ((previewMode) && (!currItem->printEnabled()))
1874 fschmid 749
                                                        continue;
6451 fschmid 750
                                                if (currItem->isGroupControl)
751
                                                {
752
                                                        painter->save();
753
#ifdef HAVE_CAIRO
754
                                                        painter->beginLayer(1.0 - currItem->fillTransparency(), currItem->fillBlendmode());
755
#endif
756
                                                        groupClips.push(currItem);
757
                                                        groupStack.push(currItem->groupsLastItem);
758
                                                        continue;
759
                                                }
4401 fschmid 760
                                                currItem->savedOwnPage = currItem->OwnPage;
761
//                                              int savedOwnPage = currItem->OwnPage;
3903 cbradney 762
                                                double OldX = currItem->xPos();
763
                                                double OldY = currItem->yPos();
1957 cbradney 764
                                                double OldBX = currItem->BoundingX;
765
                                                double OldBY = currItem->BoundingY;
3200 cbradney 766
                                                currItem->OwnPage = page->pageNr();
1957 cbradney 767
                                                if (!currItem->ChangedMasterItem)
456 fschmid 768
                                                {
4644 cbradney 769
                                                        //Hack to not check for undo changes, indicate drawing only
770
                                                        currItem->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset(), true);
3200 cbradney 771
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
772
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
456 fschmid 773
                                                }
5387 avox 774
                                                if (!evSpon || forceRedraw)
5362 avox 775
                                                        currItem->invalid = true;
3656 cbradney 776
                                                QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 777
                                                if (clip.intersects(oldR))
1957 cbradney 778
                                                        currItem->DrawObj(painter, clip);
4401 fschmid 779
                                                currItem->OwnPage = currItem->savedOwnPage;
780
//                                              currItem->OwnPage = savedOwnPage;
1957 cbradney 781
                                                if (!currItem->ChangedMasterItem)
456 fschmid 782
                                                {
4644 cbradney 783
                                                        //Hack to not check for undo changes, indicate drawing only
784
                                                        currItem->setXYPos(OldX, OldY, true);
1957 cbradney 785
                                                        currItem->BoundingX = OldBX;
786
                                                        currItem->BoundingY = OldBY;
456 fschmid 787
                                                }
6451 fschmid 788
                                                if (groupStack.count() != 0)
789
                                                {
790
                                                        while (currItem == groupStack.top())
791
                                                        {
792
                                                                PageItem *tmpItem = groupClips.pop();
793
                                                                FPointArray cl = tmpItem->PoLine.copy();
794
                                                                QWMatrix mm;
795
                                                                mm.translate(tmpItem->xPos(), tmpItem->yPos());
796
                                                                mm.rotate(tmpItem->rotation());
797
                                                                cl.map( mm );
798
#ifdef HAVE_CAIRO
799
                                                                painter->endLayer(&cl);
800
#endif
801
                                                                painter->restore();
802
                                                                groupStack.pop();
803
                                                        }
804
                                                }
456 fschmid 805
                                        }
3689 cbradney 806
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
456 fschmid 807
                                        {
1957 cbradney 808
                                                currItem = page->FromMaster.at(a);
809
                                                if (currItem->LayerNr != ll.LNr)
456 fschmid 810
                                                        continue;
1957 cbradney 811
                                                if (!currItem->isTableItem)
456 fschmid 812
                                                        continue;
3200 cbradney 813
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
456 fschmid 814
                                                        continue;
3903 cbradney 815
                                                double OldX = currItem->xPos();
816
                                                double OldY = currItem->yPos();
1957 cbradney 817
                                                double OldBX = currItem->BoundingX;
818
                                                double OldBY = currItem->BoundingY;
819
                                                if (!currItem->ChangedMasterItem)
456 fschmid 820
                                                {
4644 cbradney 821
                                                        //Hack to not check for undo changes, indicate drawing only
822
                                                        currItem->setXYPos(OldX - Mp->xOffset() + page->xOffset(), OldY - Mp->yOffset() + page->yOffset(), true);
3200 cbradney 823
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
824
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
456 fschmid 825
                                                }
3656 cbradney 826
                                                QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 827
                                                if (clip.intersects(oldR))
456 fschmid 828
                                                {
829
                                                        painter->setZoomFactor(Scale);
830
                                                        painter->save();
3903 cbradney 831
                                                        painter->translate(currItem->xPos()*Scale, currItem->yPos()*Scale);
3934 cbradney 832
                                                        painter->rotate(currItem->rotation());
4546 subik 833
                                                        if (currItem->lineColor() != CommonStrings::None)
456 fschmid 834
                                                        {
835
                                                                QColor tmp;
1957 cbradney 836
                                                                currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
837
                                                                if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
456 fschmid 838
                                                                {
4580 cbradney 839
                                                                        painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
1957 cbradney 840
                                                                        if (currItem->TopLine)
3934 cbradney 841
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
1957 cbradney 842
                                                                        if (currItem->RightLine)
3934 cbradney 843
                                                                                painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
1957 cbradney 844
                                                                        if (currItem->BottomLine)
3934 cbradney 845
                                                                                painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
1957 cbradney 846
                                                                        if (currItem->LeftLine)
3934 cbradney 847
                                                                                painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
456 fschmid 848
                                                                }
849
                                                        }
850
                                                        painter->restore();
851
                                                }
1957 cbradney 852
                                                if (!currItem->ChangedMasterItem)
456 fschmid 853
                                                {
4644 cbradney 854
                                                        //Hack to not check for undo changes, indicate drawing only
855
                                                        currItem->setXYPos(OldX, OldY, true);
1957 cbradney 856
                                                        currItem->BoundingX = OldBX;
857
                                                        currItem->BoundingY = OldBY;
456 fschmid 858
                                                }
859
                                        }
5373 fschmid 860
#ifdef HAVE_CAIRO
861
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
862
                                                painter->endLayer();
863
#endif
456 fschmid 864
                                }
865
                                Lnr++;
866
                        }
867
                }
868
        }
869
        painter->setZoomFactor(z);
870
}
871
 
872
void ScribusView::DrawPageItems(ScPainter *painter, QRect clip)
873
{
705 fschmid 874
        linkedFramesToShow.clear();
456 fschmid 875
        double z = painter->zoomFactor();
6451 fschmid 876
        QPtrStack<PageItem> groupStack;
877
        QPtrStack<PageItem> groupClips;
3727 cbradney 878
        if (Doc->Items->count() != 0)
456 fschmid 879
        {
3313 cbradney 880
                int Lnr=0;
881
                struct Layer ll;
882
                PageItem *currItem;
883
                ll.isViewable = false;
884
                ll.LNr = 0;
2951 fschmid 885
                uint layerCount=Doc->layerCount();
3689 cbradney 886
                int docCurrPageNo=static_cast<int>(Doc->currentPageNumber());
2937 cbradney 887
                for (uint la2 = 0; la2 < layerCount; ++la2)
456 fschmid 888
                {
889
                        Level2Layer(Doc, &ll, Lnr);
1874 fschmid 890
                        bool pr = true;
891
                        if ((previewMode) && (!ll.isPrintable))
892
                                pr = false;
893
                        if ((ll.isViewable) && (pr))
456 fschmid 894
                        {
5373 fschmid 895
#ifdef HAVE_CAIRO
896
                                if ((layerCount > 1) || (ll.transparency != 1.0))
5375 fschmid 897
                                        painter->beginLayer(ll.transparency, ll.blendMode);
5373 fschmid 898
#endif
3727 cbradney 899
                                QPtrListIterator<PageItem> docItem(*Doc->Items);
3689 cbradney 900
                                while ( (currItem = docItem.current()) != 0)
901
                                {
2434 fschmid 902
                                        ++docItem;
1957 cbradney 903
                                        if (currItem->LayerNr != ll.LNr)
456 fschmid 904
                                                continue;
4698 cbradney 905
                                        if ((previewMode) && (!currItem->printEnabled()))
1874 fschmid 906
                                                continue;
3724 cbradney 907
                                        if ((Doc->masterPageMode()) && ((currItem->OwnPage != -1) && (currItem->OwnPage != docCurrPageNo)))
456 fschmid 908
                                                continue;
3724 cbradney 909
                                        if (!Doc->masterPageMode() && !currItem->OnMasterPage.isEmpty())
1781 fschmid 910
                                        {
5685 cbradney 911
                                                if (currItem->OnMasterPage != Doc->currentPage()->pageName())
1781 fschmid 912
                                                        continue;
913
                                        }
6451 fschmid 914
                                        if (currItem->isGroupControl)
915
                                        {
916
                                                painter->save();
917
#ifdef HAVE_CAIRO
918
                                                painter->beginLayer(1.0 - currItem->fillTransparency(), currItem->fillBlendmode());
919
#endif
920
                                                groupClips.push(currItem);
921
                                                groupStack.push(currItem->groupsLastItem);
922
                                                continue;
923
                                        }
3656 cbradney 924
                                        QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 925
                                        if (clip.intersects(oldR))
456 fschmid 926
                                        {
5362 avox 927
                                                if (!evSpon || forceRedraw)
928
                                                        currItem->invalid = true;
4704 cbradney 929
//                                              if ((!m_MouseButtonPressed) || (Doc->EditClip))
5637 fschmid 930
                                                currItem->DrawObj(painter, clip);
5362 avox 931
//                                              currItem->Redrawn = true;
3625 avox 932
                                                if ((currItem->asTextFrame()) && ((currItem->NextBox != 0) || (currItem->BackBox != 0)))
705 fschmid 933
                                                {
1957 cbradney 934
                                                        PageItem *nextItem = currItem;
935
                                                        while (nextItem != 0)
705 fschmid 936
                                                        {
1957 cbradney 937
                                                                if (nextItem->BackBox != 0)
938
                                                                        nextItem = nextItem->BackBox;
705 fschmid 939
                                                                else
940
                                                                        break;
941
                                                        }
1957 cbradney 942
                                                        if (linkedFramesToShow.find(nextItem) == -1)
943
                                                                linkedFramesToShow.append(nextItem);
705 fschmid 944
                                                }
3934 cbradney 945
                                                if ((Doc->appMode == modeEdit) && (currItem->isSelected()) && (currItem->itemType() == PageItem::TextFrame))
456 fschmid 946
                                                {
1764 cbradney 947
                                                        //CB 230305 Stop redrawing the horizontal ruler if it hasnt changed when typing text!!!
3934 cbradney 948
                                                        if ((qRound(horizRuler->ItemPos*10000) != qRound((currItem->xPos())*10000)) || (qRound(horizRuler->ItemEndPos*10000) != qRound(((currItem->xPos()+currItem->width()) )*10000)))
1764 cbradney 949
                                                        {
5569 avox 950
                                                                horizRuler->setItem(currItem);
4546 subik 951
                                                                if (currItem->lineColor() != CommonStrings::None)
4580 cbradney 952
                                                                        horizRuler->lineCorr = currItem->lineWidth() / 2.0;
1764 cbradney 953
                                                                else
954
                                                                        horizRuler->lineCorr = 0;
1957 cbradney 955
                                                                horizRuler->ColGap = currItem->ColGap;
956
                                                                horizRuler->Cols = currItem->Cols;
3988 cbradney 957
                                                                horizRuler->Extra = currItem->textToFrameDistLeft();
958
                                                                horizRuler->RExtra = currItem->textToFrameDistRight();
5569 avox 959
                                                                horizRuler->First = currItem->currentStyle().firstIndent();
960
                                                                horizRuler->Indent = currItem->currentStyle().leftMargin();
961
                                                                double columnWidth = (currItem->width() - (currItem->columnGap() * (currItem->columns() - 1))
962
                                                                        - currItem->textToFrameDistLeft() - currItem->textToFrameDistLeft()
963
                                                                        - 2*horizRuler->lineCorr) / currItem->columns();
964
                                                                horizRuler->RMargin = columnWidth - currItem->currentStyle().rightMargin();
3988 cbradney 965
                                                                if (currItem->imageFlippedH() || (currItem->reversed()))
1764 cbradney 966
                                                                        horizRuler->Revers = true;
967
                                                                else
968
                                                                        horizRuler->Revers = false;
969
                                                                horizRuler->ItemPosValid = true;
5569 avox 970
                                                                horizRuler->TabValues = currItem->currentStyle().tabValues();
1764 cbradney 971
                                                                horizRuler->repaint();
972
                                                        }
456 fschmid 973
                                                }
974
                                        }
6451 fschmid 975
                                        if (groupStack.count() != 0)
976
                                        {
977
                                                while (currItem == groupStack.top())
978
                                                {
979
                                                        PageItem *tmpItem = groupClips.pop();
980
                                                        FPointArray cl = tmpItem->PoLine.copy();
981
                                                        QWMatrix mm;
982
                                                        mm.translate(tmpItem->xPos(), tmpItem->yPos());
983
                                                        mm.rotate(tmpItem->rotation());
984
                                                        cl.map( mm );
985
#ifdef HAVE_CAIRO
986
                                                        painter->endLayer(&cl);
987
#endif
988
                                                        painter->restore();
989
                                                        groupStack.pop();
990
                                                }
991
                                        }
456 fschmid 992
                                }
3727 cbradney 993
                                QPtrListIterator<PageItem> docItem2(*Doc->Items);
3689 cbradney 994
                                while ( (currItem = docItem2.current()) != 0 )
995
                                {
2538 fschmid 996
                                        ++docItem2;
1957 cbradney 997
                                        if (currItem->LayerNr != ll.LNr)
456 fschmid 998
                                                continue;
1957 cbradney 999
                                        if (!currItem->isTableItem)
456 fschmid 1000
                                                continue;
3656 cbradney 1001
                                        QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 1002
                                        if (clip.intersects(oldR))
456 fschmid 1003
                                        {
1004
                                                painter->setZoomFactor(Scale);
1005
                                                painter->save();
3903 cbradney 1006
                                                painter->translate(currItem->xPos()*Scale, currItem->yPos()*Scale);
3934 cbradney 1007
                                                painter->rotate(currItem->rotation());
4546 subik 1008
                                                if (currItem->lineColor() != CommonStrings::None)
456 fschmid 1009
                                                {
1010
                                                        QColor tmp;
1957 cbradney 1011
                                                        currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
1012
                                                        if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
456 fschmid 1013
                                                        {
4580 cbradney 1014
                                                                painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
1957 cbradney 1015
                                                                if (currItem->TopLine)
3934 cbradney 1016
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
1957 cbradney 1017
                                                                if (currItem->RightLine)
3934 cbradney 1018
                                                                        painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
1957 cbradney 1019
                                                                if (currItem->BottomLine)
3934 cbradney 1020
                                                                        painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
1957 cbradney 1021
                                                                if (currItem->LeftLine)
3934 cbradney 1022
                                                                        painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
456 fschmid 1023
                                                        }
1024
                                                }
1025
                                                painter->restore();
1026
                                        }
1027
                                }
5373 fschmid 1028
#ifdef HAVE_CAIRO
1029
                                if ((layerCount > 1) || (ll.transparency != 1.0))
1030
                                        painter->endLayer();
1031
#endif
456 fschmid 1032
                        }
1033
                        Lnr++;
1034
                }
1035
        }
1036
        painter->setZoomFactor(z);
1037
}
1038
 
5166 fschmid 1039
void ScribusView::DrawPageMarks(ScPainter *p, Page *page, QRect clip)
456 fschmid 1040
{
1041
        double z = p->zoomFactor();
1042
        p->save();
1043
        p->setZoomFactor(Scale);
3200 cbradney 1044
        p->translate(page->xOffset() * Scale, page->yOffset() * Scale);
4704 cbradney 1045
        double lineWidth = 0.5 / Scale;
1046
        p->setLineWidth(lineWidth);
3226 cbradney 1047
        double pageHeight=page->height();
1048
        double pageWidth=page->width();
3962 cbradney 1049
        //Draw the margins
879 fschmid 1050
        if (Doc->guidesSettings.marginsShown)
456 fschmid 1051
        {
879 fschmid 1052
                p->setPen(Doc->guidesSettings.margColor);
1065 cbradney 1053
                if (Doc->marginColored)
456 fschmid 1054
                {
879 fschmid 1055
                        p->setBrush(Doc->guidesSettings.margColor);
3226 cbradney 1056
                        p->drawRect(0, 0, pageWidth, page->Margins.Top);
1057
                        p->drawRect(0, page->Margins.Top, page->Margins.Left, pageHeight - page->Margins.Top);
1058
                        p->drawRect(page->Margins.Left, pageHeight - page->Margins.Bottom, pageWidth - page->Margins.Right - page->Margins.Left, page->Margins.Bottom);
1059
                        p->drawRect(pageWidth - page->Margins.Right, page->Margins.Top, page->Margins.Right, pageHeight-page->Margins.Top);
456 fschmid 1060
                }
879 fschmid 1061
                p->setPen(Doc->guidesSettings.margColor);
3226 cbradney 1062
                p->drawLine(FPoint(0, page->Margins.Top), FPoint(pageWidth, page->Margins.Top));
1063
                p->drawLine(FPoint(0, pageHeight - page->Margins.Bottom), FPoint(pageWidth, pageHeight - page->Margins.Bottom));
1064
                p->drawLine(FPoint(page->Margins.Left, 0), FPoint(page->Margins.Left, pageHeight));
1065
                p->drawLine(FPoint(pageWidth - page->Margins.Right, 0), FPoint(pageWidth - page->Margins.Right, pageHeight));
456 fschmid 1066
        }
3962 cbradney 1067
        //Draw the baseline grid
879 fschmid 1068
        if (Doc->guidesSettings.baseShown)
456 fschmid 1069
        {
4704 cbradney 1070
                p->setPen(Doc->guidesSettings.baseColor, lineWidth, SolidLine, FlatCap, MiterJoin);
3226 cbradney 1071
                for (double yg = Doc->typographicSettings.offsetBaseGrid; yg < pageHeight; yg += Doc->typographicSettings.valueBaseGrid)
1072
                        p->drawLine(FPoint(0, yg), FPoint(pageWidth, yg));
456 fschmid 1073
        }
3962 cbradney 1074
        //Draw the grid lines
879 fschmid 1075
        if (Doc->guidesSettings.gridShown)
456 fschmid 1076
        {
5233 fschmid 1077
                double lowerBx = QMAX(clip.x() / Scale + Doc->minCanvasCoordinate.x() - page->xOffset(), 0);
1078
                double lowerBy = QMAX(clip.y() / Scale + Doc->minCanvasCoordinate.y() - page->yOffset(), 0);
1079
                double highBx = QMIN(lowerBx + clip.width() / Scale, pageWidth);
1080
                double highBy = QMIN(lowerBy + clip.height() / Scale, pageHeight);
456 fschmid 1081
                if (Scale > 0.49)
1082
                {
1083
                        double i,start;
879 fschmid 1084
                        i = Doc->guidesSettings.majorGrid;
4704 cbradney 1085
                        p->setPen(Doc->guidesSettings.majorColor, lineWidth, SolidLine, FlatCap, MiterJoin);
5233 fschmid 1086
                        start=floor(lowerBy/i);
456 fschmid 1087
                        start*=i;
5233 fschmid 1088
                        for (double b = start; b <= highBy; b+=i)
5166 fschmid 1089
                        {
5233 fschmid 1090
                                p->drawLine(FPoint(QMAX(lowerBx, 0), b), FPoint(QMIN(pageWidth, highBx), b));
5166 fschmid 1091
                        }
5233 fschmid 1092
                        start=floor(lowerBx/i);
456 fschmid 1093
                        start*=i;
5233 fschmid 1094
                        for (double b = start; b <= highBx; b+=i)
5166 fschmid 1095
                        {
5233 fschmid 1096
                                p->drawLine(FPoint(b, QMAX(lowerBy, 0)), FPoint(b, QMIN(pageHeight, highBy)));
5166 fschmid 1097
                        }
879 fschmid 1098
                        i = Doc->guidesSettings.minorGrid;
4704 cbradney 1099
                        p->setPen(Doc->guidesSettings.minorColor, lineWidth, DotLine, FlatCap, MiterJoin);
5233 fschmid 1100
                        start=floor(lowerBy/i);
456 fschmid 1101
                        start*=i;
5233 fschmid 1102
                        for (double b = start; b <= highBy; b+=i)
5166 fschmid 1103
                        {
5233 fschmid 1104
                                p->drawLine(FPoint(QMAX(lowerBx, 0), b), FPoint(QMIN(pageWidth, highBx), b));
5166 fschmid 1105
                        }
5233 fschmid 1106
                        start=floor(lowerBx/i);
456 fschmid 1107
                        start*=i;
5233 fschmid 1108
                        for (double b = start; b <= highBx; b+=i)
5166 fschmid 1109
                        {
5233 fschmid 1110
                                p->drawLine(FPoint(b, QMAX(lowerBy, 0)), FPoint(b, QMIN(pageHeight, highBy)));
5166 fschmid 1111
                        }
456 fschmid 1112
                }
1113
        }
3962 cbradney 1114
        //Draw the guides
879 fschmid 1115
        if (Doc->guidesSettings.guidesShown)
5087 subik 1116
                page->guides.drawPage(p, Doc, lineWidth);
6203 subik 1117
 
456 fschmid 1118
        p->restore();
1119
        p->setZoomFactor(z);
1120
}
1121
 
1122
void ScribusView::leaveEvent(QEvent *)
1123
{
1124
/*      if (BlockLeave)
1125
                return; */
4704 cbradney 1126
        if (!m_MouseButtonPressed)
456 fschmid 1127
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1128
/*      else
1129
        {
4704 cbradney 1130
                if ((SelItem.count() != 0) && (m_MouseButtonPressed) && (!doku->DragP) && (doku->appMode == 1))
456 fschmid 1131
                {
1957 cbradney 1132
                        PageItem *currItem = SelItem.at(0);
456 fschmid 1133
                        if ((b->Locked) || (b->Sizing))
1134
                                return;
1135
                        doku->DragP = true;
1136
                        doku->leaveDrag = true;
1137
                        doku->DraggedElem = b;
1138
                        doku->DragElements.clear();
1139
                        for (uint dre=0; dre<SelItem.count(); ++dre)
1140
                                doku->DragElements.append(SelItem.at(dre)->ItemNr);
1141
                        ScriXmlDoc *ss = new ScriXmlDoc();
1142
                        QDragObject *dr = new QTextDrag(ss->WriteElem(&SelItem, doku), this);
1143
                        dr->setPixmap(loadIcon("DragPix.xpm"));
1144
                        dr->drag();
1145
                        delete ss;
3708 cbradney 1146
                        ss=NULL;
456 fschmid 1147
                        doku->DragP = false;
1148
                        doku->leaveDrag = false;
4704 cbradney 1149
                        m_MouseButtonPressed = false;
456 fschmid 1150
                        doku->DraggedElem = 0;
1151
                        doku->DragElements.clear();
1152
                }
1153
        } */
1154
}
1155
 
1156
void ScribusView::contentsDragEnterEvent(QDragEnterEvent *e)
1157
{
1158
        QString text;
1159
        e->accept(QTextDrag::canDecode(e));
1160
        if (QTextDrag::decode(e, text))
1161
        {
1162
                double gx, gy, gw, gh;
5055 cbradney 1163
                /*<< #3524
456 fschmid 1164
                setActiveWindow();
1165
                raise();
5781 cbradney 1166
                m_ScMW->newActWin(Doc->WinHan);
456 fschmid 1167
                updateContents();
5055 cbradney 1168
                >>*/
456 fschmid 1169
//              SeleItemPos(e->pos());
1170
                QUrl ur(text);
1171
                QFileInfo fi = QFileInfo(ur.path());
1172
                ScriXmlDoc *ss = new ScriXmlDoc();
1173
                if (fi.exists())
1174
                        text = ur.path();
1175
                if(ss->ReadElemHeader(text,fi.exists(), &gx, &gy, &gw, &gh))
1176
                {
1177
                        GroupX = e->pos().x() / Scale;
1178
                        GroupY = e->pos().y() / Scale;
1179
                        GroupW = gw;
1180
                        GroupH = gh;
1181
                        DraggedGroup = true;
1182
                        DraggedGroupFirst = true;
4049 cbradney 1183
                        //GroupSel = false;
456 fschmid 1184
                        QPainter p;
1185
                        p.begin(viewport());
1186
                        PaintSizeRect(&p, QRect());
3640 fschmid 1187
                        emit ItemGeom(gw, gh);
456 fschmid 1188
//                      QPoint pv = QPoint(qRound(gx), qRound(gy));
1189
//                      PaintSizeRect(&p, QRect(pv, QPoint(pv.x()+qRound(gw), pv.y()+qRound(gh))));
1190
                        p.end();
1191
                }
1192
                delete ss;
3708 cbradney 1193
                ss=NULL;
456 fschmid 1194
        }
1195
}
1196
 
1197
void ScribusView::contentsDragMoveEvent(QDragMoveEvent *e)
1198
{
1199
        QString text;
1957 cbradney 1200
//      PageItem *currItem;
456 fschmid 1201
//      bool img;
1202
        e->accept(QTextDrag::canDecode(e));
1203
        if (QTextDrag::decode(e, text))
1204
        {
1205
                if (DraggedGroup)
1206
                {
1207
                        double gx, gy, gw, gh;
1208
                        GroupX = e->pos().x() / Scale;
1209
                        GroupY = e->pos().y() / Scale;
1210
                        getGroupRectScreen(&gx, &gy, &gw, &gh);
1211
                        QPainter p;
1212
                        p.begin(viewport());
2852 fschmid 1213
                        gx += Doc->minCanvasCoordinate.x();
1214
                        gy += Doc->minCanvasCoordinate.y();
456 fschmid 1215
                        QPoint pv = QPoint(qRound(gx), qRound(gy));
1216
                        if (!DraggedGroupFirst)
1217
                                PaintSizeRect(&p, QRect(pv, QPoint(pv.x()+qRound(gw), pv.y()+qRound(gh))));
1218
                        DraggedGroupFirst = false;
1219
                        p.end();
2867 fschmid 1220
                        emit MousePos(GroupX+Doc->minCanvasCoordinate.x(), GroupY+Doc->minCanvasCoordinate.y());
1612 cbradney 1221
                        horizRuler->Draw(e->pos().x());
1222
                        vertRuler->Draw(e->pos().y());
456 fschmid 1223
                        return;
1224
                }
1225
/*              QUrl ur(text);
1226
                QFileInfo fi = QFileInfo(ur.path());
1227
                QString ext = fi.extension(false).upper();
1228
                QStrList imfo = QImageIO::inputFormats();
1229
                if (ext == "JPG")
1230
                        ext = "JPEG";
1231
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
1232
                if (!SeleItemPos(e->pos()))
1233
                {
1234
                        if (SelItem.count() != 0)
1235
                                Deselect(true);
1236
                }
1237
                else
1238
                {
1239
                        b = SelItem.at(0);
1240
                        if (img)
1241
                        {
1242
                                if (b->PType != 2)
1243
                                        Deselect(true);
1244
                        }
1245
                        else
1246
                        {
1247
                                if (b->PType != 4)
1248
                                        Deselect(true);
1249
                        }
1250
                } */
1251
        }
1252
}
1253
 
632 fschmid 1254
void ScribusView::contentsDragLeaveEvent(QDragLeaveEvent *)
456 fschmid 1255
{
1256
        if (DraggedGroup)
1257
        {
1258
                updateContents();
1259
                DraggedGroup = false;
1260
                DraggedGroupFirst = false;
1261
        }
1262
}
1263
 
1264
void ScribusView::contentsDropEvent(QDropEvent *e)
1265
{
1266
        QString text;
1957 cbradney 1267
        PageItem *currItem;
456 fschmid 1268
        bool img = false;
1065 cbradney 1269
//      struct ScText *hg;
456 fschmid 1270
//      uint a;
693 fschmid 1271
        int re = 0;
456 fschmid 1272
        e->accept(QTextDrag::canDecode(e));
1273
        DraggedGroupFirst = false;
2852 fschmid 1274
        int ex = qRound(e->pos().x()/Scale + Doc->minCanvasCoordinate.x());
1275
        int ey = qRound(e->pos().y()/Scale + Doc->minCanvasCoordinate.y());
456 fschmid 1276
        if (QTextDrag::decode(e, text))
1277
        {
5055 cbradney 1278
                //<<#3524
1279
                setActiveWindow();
1280
                raise();
5781 cbradney 1281
                m_ScMW->newActWin(Doc->WinHan);
5055 cbradney 1282
                updateContents();
1283
                //>>
456 fschmid 1284
                QUrl ur(text);
1285
                QFileInfo fi = QFileInfo(ur.path());
1286
                QString ext = fi.extension(false).upper();
1287
                QStrList imfo = QImageIO::inputFormats();
1288
                if (ext == "JPG")
1289
                        ext = "JPEG";
4020 cbradney 1290
                //CB Need to handle this ugly file extension list elsewhere... some capabilities class perhaps
1291
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="PDF")||(ext=="TIF")||(ext=="PSD"));
4019 cbradney 1292
                bool selectedItemByDrag=false;
1293
                int pscx=qRound(e->pos().x()/Scale), pscy=qRound(e->pos().y()/Scale);
1294
                //Loop through all items and see which one(s) were under the drop point on the current layer
1295
                //Should make a nice function for this.
4049 cbradney 1296
                for (uint i=0; i<Doc->Items->count(); ++i)
4019 cbradney 1297
                {
1298
                        if (Doc->Items->at(i)->LayerNr==Doc->activeLayer())
1299
                        {
1300
                                if (Doc->Items->at(i)->pointWithinItem(pscx, pscy))
1301
                                {
1302
                                        Deselect(false);
1303
                                        SelectItem(Doc->Items->at(i));
1304
                                        selectedItemByDrag=true;
1305
                                        break;
1306
                                }
1307
                        }
1308
                }
4018 cbradney 1309
                //CB When we drag an image to a page from outside
1310
                //SeleItemPos is from 1.2.x. Needs reenabling for dragging *TO* a frame
4019 cbradney 1311
                if ((fi.exists()) && (img) && !selectedItemByDrag)// && (!SeleItemPos(e->pos())))
456 fschmid 1312
                {
4018 cbradney 1313
                        //int z = PaintPict(qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), 1, 1);
4546 subik 1314
                        int z = Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, pscx, pscy, 1, 1, 1, Doc->toolSettings.dBrushPict, CommonStrings::None, true);
4018 cbradney 1315
                        PageItem *b = Doc->Items->at(z);
1316
                        Doc->LoadPict(ur.path(), b->ItemNr);
1317
                        b->setWidth(static_cast<double>(b->pixm.width()));
1318
                        b->setHeight(static_cast<double>(b->pixm.height()));
1319
                        b->OldB2 = b->width();
1320
                        b->OldH2 = b->height();
4688 cbradney 1321
                        b->updateClip();
456 fschmid 1322
                        emit DocChanged();
1323
                        update();
1324
                        return;
4019 cbradney 1325
                }
1326
                //if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
4847 cbradney 1327
                if (Doc->m_Selection->count()>0 && Doc->m_Selection->itemAt(0)->pointWithinItem(pscx, pscy) && (!text.startsWith("<SCRIBUSELEM")))
456 fschmid 1328
                {
4847 cbradney 1329
                        PageItem *b = Doc->m_Selection->itemAt(0);
4494 cbradney 1330
                        if (b->itemType() == PageItem::ImageFrame)
456 fschmid 1331
                        {
4494 cbradney 1332
                                if ((fi.exists()) && (img))
456 fschmid 1333
                                {
4494 cbradney 1334
                                        Doc->LoadPict(ur.path(), b->ItemNr);
1335
                                        update();
1336
                                }
1337
                        }
1338
                        /* CB leaving this out for now...
1339
                        if (b->PType == 4)
1340
                        {
1341
                                if ((b->BackBox != 0) && (b->itemText.count() == 0))
1342
                                        return;
1343
                                if ((fi.exists()) && (!img) && (fi.size() < 500000))
1344
                                {
1345
                                        Serializer *ss = new Serializer(ur.path());
1346
                                        if (ss->Read())
456 fschmid 1347
                                        {
4494 cbradney 1348
                                                int st = doku->currentParaStyle;
1349
                                                ss->GetText(b, st, doku->docParagraphStyles[st].Font, doku->docParagraphStyles[st].FontSize, true);
1350
                                                emit DocChanged();
456 fschmid 1351
                                        }
4494 cbradney 1352
                                        delete ss;
1353
                                        ss=NULL;
1354
                                        update();
456 fschmid 1355
                                }
4494 cbradney 1356
                                else
456 fschmid 1357
                                {
4494 cbradney 1358
                                        slotDoCurs(false);
1359
                                        slotSetCurs(e->pos().x(), e->pos().y());
1360
                                        if (text.startsWith("<SCRIBUSELEM"))
456 fschmid 1361
                                                return;
4494 cbradney 1362
                                        for (a=0; a<text.length(); ++a)
456 fschmid 1363
                                        {
4494 cbradney 1364
                                                hg = new ScText;
1365
                                                hg->ch = text.at(a);
1366
                                                if (hg->ch == QChar(10))
1367
                                                        hg->ch = QChar(13);
1368
                                                if (hg->ch == QChar(4))
1369
                                                        hg->ch = QChar(9);
1370
                                                if (hg->ch == QChar(5))
1371
                                                        hg->ch = QChar(13);
1372
                                                hg->cfont = b->IFont;
1373
                                                hg->csize = b->ISize;
1374
                                                hg->ccolor = b->TxtFill;
1375
                                                hg->cshade = b->ShTxtFill;
1376
                                                hg->cstroke = b->TxtStroke;
1377
                                                hg->cshade2 = b->ShTxtStroke;
1378
                                                hg->cselect = false;
1379
                                                hg->cscale = b->TxtScale;
1380
                                                hg->cextra = 0;
1381
                                                hg->cstyle = 0;
1382
                                                hg->cab = 0;
1383
                                                hg->xp = 0;
1384
                                                hg->yp = 0;
1385
                                                hg->PRot = 0;
1386
                                                hg->PtransX = 0;
1387
                                                hg->PtransY = 0;
1388
                                                b->itemText.insert(b->CPos, hg);
1389
                                                b->CPos += 1;
456 fschmid 1390
                                        }
4494 cbradney 1391
                                        emit DocChanged();
1392
                                        update();
1393
                                }
1394
                        }*/
456 fschmid 1395
                }
1396
                else
4042 subik 1397
                {
3727 cbradney 1398
                        for (uint as = 0; as < Doc->Items->count(); ++as)
855 fschmid 1399
                        {
3934 cbradney 1400
                                Doc->Items->at(as)->setSelected(false);
855 fschmid 1401
                        }
3934 cbradney 1402
                        uint oldDocItemCount = Doc->Items->count();
456 fschmid 1403
                        if ((!img) && (Doc->DraggedElem == 0))
1163 fschmid 1404
                        {
1405
                                if ((fi.exists()) && (!img))
2852 fschmid 1406
                                        emit LoadElem(ur.path(), ex, ey, true, false, Doc, this);
1163 fschmid 1407
                                else
2852 fschmid 1408
                                        emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
4847 cbradney 1409
                                Doc->m_Selection->clear();
3934 cbradney 1410
                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
2233 fschmid 1411
                                {
3727 cbradney 1412
                                        currItem = Doc->Items->at(as);
6431 fschmid 1413
                                        Doc->setRedrawBounding(currItem);
4847 cbradney 1414
                                        Doc->m_Selection->addItem(currItem);
2233 fschmid 1415
                                        if (currItem->isBookmark)
1416
                                                emit AddBM(currItem);
1417
                                }
1163 fschmid 1418
                        }
456 fschmid 1419
                        else
1420
                        {
1421
                                if (Doc->DraggedElem != 0)
1422
                                {
1423
                                        if (!Doc->leaveDrag)
1424
                                        {
1425
                                                QPopupMenu *pmen = new QPopupMenu();
1426
                                                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1427
                                                pmen->insertItem( tr("Copy Here"));
6271 fschmid 1428
                                                int mov = pmen->insertItem( tr("Move Here"));
456 fschmid 1429
                                                pmen->insertItem( tr("Cancel"));
6271 fschmid 1430
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1431
                                                {
1432
                                                        if (Doc->Items->at(Doc->DragElements[dre])->locked())
1433
                                                        {
1434
                                                                pmen->setItemEnabled(mov, false);
1435
                                                                break;
1436
                                                        }
1437
                                                }
456 fschmid 1438
                                                re = pmen->indexOf(pmen->exec(QCursor::pos()));
1439
                                                delete pmen;
3708 cbradney 1440
                                                pmen=NULL;
456 fschmid 1441
                                        }
1442
                                        else
1443
                                                re = 1;
1444
                                        if ((re == 2) || (re == -1))
1445
                                        {
1446
                                                updateContents();
1447
                                                return;
1448
                                        }
1449
                                        if ((re == 1) || (Doc->leaveDrag))
1450
                                        {
1451
                                                QPtrList<PageItem> pasted;
2852 fschmid 1452
                                                emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
3934 cbradney 1453
                                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
456 fschmid 1454
                                                {
3727 cbradney 1455
                                                        pasted.append(Doc->Items->at(as));
456 fschmid 1456
                                                }
4847 cbradney 1457
                                                Doc->m_Selection->clear();
456 fschmid 1458
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1459
                                                {
4847 cbradney 1460
                                                        Doc->m_Selection->addItem(Doc->Items->at(Doc->DragElements[dre]));
456 fschmid 1461
                                                }
1462
                                                PageItem* bb;
1463
                                                int fin;
1464
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1465
                                                {
1466
                                                        bb = pasted.at(dre);
4847 cbradney 1467
                                                        currItem = Doc->m_Selection->itemAt(dre);
3625 avox 1468
                                                        if ((currItem->asTextFrame()) && ((currItem->NextBox != 0) || (currItem->BackBox != 0)))
456 fschmid 1469
                                                        {
1957 cbradney 1470
                                                                if (currItem->BackBox != 0)
456 fschmid 1471
                                                                {
1957 cbradney 1472
                                                                        bb->BackBox = currItem->BackBox;
4847 cbradney 1473
                                                                        fin = Doc->m_Selection->findItem(currItem->BackBox);
456 fschmid 1474
                                                                        if (fin != -1)
1475
                                                                                bb->BackBox = pasted.at(fin);
1476
                                                                        bb->BackBox->NextBox = bb;
1477
                                                                }
1957 cbradney 1478
                                                                if (currItem->NextBox != 0)
456 fschmid 1479
                                                                {
1957 cbradney 1480
                                                                        bb->NextBox = currItem->NextBox;
4847 cbradney 1481
                                                                        fin = Doc->m_Selection->findItem(currItem->NextBox);
456 fschmid 1482
                                                                        if (fin != -1)
1483
                                                                                bb->NextBox = pasted.at(fin);
1484
                                                                        bb->NextBox->BackBox = bb;
1485
                                                                }
1486
                                                        }
1487
                                                }
1488
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1489
                                                {
4847 cbradney 1490
                                                        currItem = Doc->m_Selection->itemAt(dre);
1957 cbradney 1491
                                                        currItem->NextBox = 0;
1492
                                                        currItem->BackBox = 0;
456 fschmid 1493
                                                }
1494
                                                pasted.clear();
4707 cbradney 1495
                                                Doc->itemSelection_DeleteItem();
456 fschmid 1496
                                        }
1497
                                }
1498
                                if ((!img) && ((re == 0)))
2852 fschmid 1499
                                        emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
456 fschmid 1500
                                Doc->DraggedElem = 0;
1501
                                Doc->DragElements.clear();
4847 cbradney 1502
                                Doc->m_Selection->clear();
3934 cbradney 1503
                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
456 fschmid 1504
                                {
3727 cbradney 1505
                                        currItem = Doc->Items->at(as);
6431 fschmid 1506
                                        Doc->setRedrawBounding(currItem);
4847 cbradney 1507
                                        Doc->m_Selection->addItem(currItem);
2193 fschmid 1508
                                        if (currItem->isBookmark)
1509
                                                emit AddBM(currItem);
456 fschmid 1510
                                }
1511
                        }
4847 cbradney 1512
                        if (Doc->m_Selection->count() > 1)
3640 fschmid 1513
                        {
1514
                                setGroupRect();
6289 fschmid 1515
                                double gx, gy, gh, gw;
1516
                                getGroupRect(&gx, &gy, &gw, &gh);
1517
                                double nx = gx;
1518
                                double ny = gy;
1519
                                if (!ApplyGuides(&nx, &ny))
1520
                                {
1521
                                        FPoint npx;
1522
                                        npx = Doc->ApplyGridF(FPoint(nx, ny));
1523
                                        nx = npx.x();
1524
                                        ny = npx.y();
1525
                                }
1526
                                moveGroup(nx-gx, ny-gy, false);
1527
                                setGroupRect();
1528
                                getGroupRect(&gx, &gy, &gw, &gh);
1529
                                nx = gx+gw;
1530
                                ny = gy+gh;
1531
                                ApplyGuides(&nx, &ny);
1532
                                moveGroup(nx-(gx+gw), ny-(gy+gh), false);
1533
                                setGroupRect();
1534
                                getGroupRect(&gx, &gy, &gw, &gh);
6368 fschmid 1535
                                for (uint a = 0; a < Doc->m_Selection->count(); ++a)
1536
                                {
1537
                                        PageItem *currItem = Doc->m_Selection->itemAt(a);
1538
                                        currItem->gXpos = currItem->xPos() - gx;
1539
                                        currItem->gYpos = currItem->yPos() - gy;
1540
                                        currItem->gWidth = gw;
1541
                                        currItem->gHeight = gh;
1542
                                }
6289 fschmid 1543
                                emit ItemPos(gx, gy);
1544
                                emit ItemGeom(gw, gh);
3640 fschmid 1545
                        }
6289 fschmid 1546
                        else
1547
                        {
1548
                                currItem = Doc->m_Selection->itemAt(0);
1549
                                if (Doc->useRaster)
1550
                                {
1551
                                        double nx = currItem->xPos();
1552
                                        double ny = currItem->yPos();
1553
                                        if (!ApplyGuides(&nx, &ny))
1554
                                        {
1555
                                                FPoint npx;
1556
                                                npx = Doc->ApplyGridF(FPoint(nx, ny));
1557
                                                nx = npx.x();
1558
                                                ny = npx.y();
1559
                                        }
1560
                                        MoveItem(nx-currItem->xPos(), ny-currItem->yPos(), currItem);
1561
                                }
1562
                        }
3941 cbradney 1563
                        updateContents();
4019 cbradney 1564
                }
6236 fschmid 1565
                if (!Doc->masterPageMode())
1566
                {
1567
                        uint docPagesCount=Doc->Pages->count();
1568
                        uint docCurrPageNo=Doc->currentPageNumber();
1569
                        for (uint i = 0; i < docPagesCount; ++i)
1570
                        {
6256 fschmid 1571
                                int x = static_cast<int>(Doc->Pages->at(i)->xOffset());
1572
                                int y = static_cast<int>(Doc->Pages->at(i)->yOffset());
1573
                                int w = static_cast<int>(Doc->Pages->at(i)->width());
1574
                                int h = static_cast<int>(Doc->Pages->at(i)->height());
6236 fschmid 1575
                                if (QRect(x, y, w, h).contains(ex, ey))
1576
                                {
1577
                                        if (docCurrPageNo != i)
1578
                                        {
1579
                                                Doc->setCurrentPage(Doc->Pages->at(i));
1580
                                                setMenTxt(i);
1581
                                                DrawNew();
1582
                                        }
1583
                                        break;
1584
                                }
1585
                        }
1586
                        setRulerPos(contentsX(), contentsY());
1587
                }
456 fschmid 1588
        }
1589
}
1590
 
1591
void ScribusView::contentsMouseDoubleClickEvent(QMouseEvent *m)
1592
{
1593
        m->accept();
4704 cbradney 1594
        m_MouseButtonPressed = false;
1957 cbradney 1595
        PageItem *currItem = 0;
456 fschmid 1596
        if (Doc->EditClip)
1597
        {
1598
                emit EndNodeEdit();
1599
                return;
1600
        }
4847 cbradney 1601
        if ((Doc->m_Selection->isMultipleSelection()) || (Doc->appMode != modeNormal))
456 fschmid 1602
        {
4847 cbradney 1603
                if ((Doc->m_Selection->isMultipleSelection()) && (Doc->appMode == modeNormal))
456 fschmid 1604
                {
1957 cbradney 1605
                        if (GetItem(&currItem))
456 fschmid 1606
                        {
1957 cbradney 1607
                                if (currItem->isTableItem)
456 fschmid 1608
                                {
1609
                                        Deselect(false);
4847 cbradney 1610
                                        Doc->m_Selection->addItem(currItem);
1957 cbradney 1611
                                        currItem->isSingleSel = true;
3946 cbradney 1612
                                        //CB FIXME dont call this if the added item is item 0
4847 cbradney 1613
                                        if (!Doc->m_Selection->primarySelectionIs(currItem))
4010 cbradney 1614
                                                currItem->emitAllToGUI();
1957 cbradney 1615
                                        currItem->paintObj();
456 fschmid 1616
                                }
1617
                        }
4351 cbradney 1618
                        return;
456 fschmid 1619
                }
1620
                else
4351 cbradney 1621
                {
1622
                        if (!(GetItem(&currItem) && (Doc->appMode == modeEdit) && currItem->asTextFrame()))
1623
                        {
1624
                                contentsMousePressEvent(m);
1625
                                return;
1626
                        }
1627
                }
456 fschmid 1628
        }
1957 cbradney 1629
        if (GetItem(&currItem))
456 fschmid 1630
        {
1957 cbradney 1631
                if ((currItem->itemType() == PageItem::Polygon) || (currItem->itemType() == PageItem::PolyLine) || (currItem->itemType() == PageItem::ImageFrame) || (currItem->itemType() == PageItem::PathText))
456 fschmid 1632
                {
1957 cbradney 1633
                        if ((currItem->locked()) || (!currItem->ScaleType))
456 fschmid 1634
                        {
1635
                                contentsMousePressEvent(m);
1636
                                return;
1637
                        }
3962 cbradney 1638
                        //If we double click on an image frame and theres no image assigned, open the
4492 cbradney 1639
                        //load picture dialog, else put it into edit mode if the frame is set to show the image
1640
                        if (currItem->itemType() == PageItem::ImageFrame)
1641
                        {
1642
                                if (currItem->Pfile.isEmpty())
1643
                                        emit LoadPic();
1644
                                else if (currItem->imageShown())
1645
                                        emit Amode(modeEdit);
1646
                        }
5036 cbradney 1647
                        else
1648
                                emit Amode(modeEdit);
456 fschmid 1649
                }
1650
                else
1957 cbradney 1651
                        if (currItem->itemType() == PageItem::TextFrame)
837 fschmid 1652
                        {
4351 cbradney 1653
                                //CB old code
1654
                                //emit currItem->isAnnotation() ? AnnotProps() : Amode(modeEdit);
1655
                                //contentsMousePressEvent(m);
1656
                                //CB if annotation, open the annotation dialog
1657
                                if (currItem->isAnnotation())
1658
                                {
1659
                                        emit AnnotProps();
1660
                                        contentsMousePressEvent(m);
1661
                                }
1662
                                //else if not in mode edit, set mode edit
1663
                                else if (Doc->appMode != modeEdit)
1664
                                {
4888 cbradney 1665
                                        emit Amode(modeEdit);
4351 cbradney 1666
                                        //CB ignore the double click and go with a single one
1667
                                        //if we werent in mode edit before.
1668
                                        //unsure if this is correct, but its ok given we had no
1669
                                        //double click select until now.
1670
                                        contentsMousePressEvent(m);
1671
                                }
1672
                                //otherwise, select between the whitespace
4546 subik 1673
                                else
4351 cbradney 1674
                                {       //Double click in a frame to select a word
1675
                                        PageItem_TextFrame *cItem=currItem->asTextFrame();
1676
                                        bool inText = slotSetCurs(m->x(), m->y());
1677
                                        if (!inText)
1678
                                        {
1679
                                                Deselect(true);
1680
                                                slotDoCurs(true);
1681
                                                emit Amode(modeNormal);
1682
                                                return;
1683
                                        }
1684
                                        int a=cItem->CPos;
1685
                                        while(a>0)
1686
                                        {
5184 avox 1687
                                                if (cItem->itemText.text(a-1).isLetterOrNumber())
4351 cbradney 1688
                                                        --a;
1689
                                                else
1690
                                                        break;
1691
                                        }
5569 avox 1692
                                        int b=cItem->CPos;
5184 avox 1693
                                        while(b<cItem->itemText.length())
4351 cbradney 1694
                                        {
5184 avox 1695
                                                if (cItem->itemText.text(b).isLetterOrNumber())
4351 cbradney 1696
                                                        ++b;
1697
                                                else
1698
                                                        break;
1699
                                        }
4968 cbradney 1700
                                        oldCp = a;
4351 cbradney 1701
                                        cItem->CPos=b;
1702
                                        cItem->ExpandSel(1, oldCp);
1703
                                        slotDoCurs(true);
1704
                                }
837 fschmid 1705
                        }
456 fschmid 1706
        }
1707
}
1708
 
1709
void ScribusView::contentsMouseReleaseEvent(QMouseEvent *m)
1710
{
1957 cbradney 1711
        PageItem *currItem;
4704 cbradney 1712
        m_MouseButtonPressed = false;
879 fschmid 1713
        if (Doc->guidesSettings.guidesShown)
456 fschmid 1714
        {
3962 cbradney 1715
                bool foundGuide = false;
2848 fschmid 1716
                double nx = m->x()/Scale + Doc->minCanvasCoordinate.x();
1717
                double ny = m->y()/Scale + Doc->minCanvasCoordinate.y();
5087 subik 1718
                /* PV - guides rafactoring
1065 cbradney 1719
                if (Doc->currentPage->YGuides.count() != 0)
456 fschmid 1720
                {
1065 cbradney 1721
                        for (uint yg = 0; yg < Doc->currentPage->YGuides.count(); ++yg)
456 fschmid 1722
                        {
3200 cbradney 1723
                                if ((Doc->currentPage->YGuides[yg]+Doc->currentPage->yOffset()< (ny+Doc->guidesSettings.grabRad)) &&
1724
                                         (Doc->currentPage->YGuides[yg]+Doc->currentPage->yOffset()> (ny-Doc->guidesSettings.grabRad)))
456 fschmid 1725
                                {
3962 cbradney 1726
                                        foundGuide = true;
456 fschmid 1727
                                        break;
1728
                                }
1729
                        }
1730
                }
1065 cbradney 1731
                if (Doc->currentPage->XGuides.count() != 0)
456 fschmid 1732
                {
1065 cbradney 1733
                        for (uint xg = 0; xg < Doc->currentPage->XGuides.count(); ++xg)
456 fschmid 1734
                        {
3200 cbradney 1735
                                if ((Doc->currentPage->XGuides[xg]+Doc->currentPage->xOffset()< (nx+Doc->guidesSettings.grabRad)) &&
1736
                                         (Doc->currentPage->XGuides[xg]+Doc->currentPage->xOffset()> (nx-Doc->guidesSettings.grabRad)))
456 fschmid 1737
                                {
3962 cbradney 1738
                                        foundGuide = true;
456 fschmid 1739
                                        break;
1740
                                }
1741
                        }
1742
                }
5087 subik 1743
                */
1744
                if (Doc->currentPage()->guides.isMouseOnHorizontal(ny + Doc->guidesSettings.grabRad,
1745
                                                                                                                ny - Doc->guidesSettings.grabRad,
1746
                                                                                                                GuideManagerCore::Standard)
1747
                                  || Doc->currentPage()->guides.isMouseOnVertical(nx + Doc->guidesSettings.grabRad,
1748
                                                                                                                        nx - Doc->guidesSettings.grabRad,
1749
                                                                                                                        GuideManagerCore::Standard))
1750
                        foundGuide = true;
3962 cbradney 1751
                if ((foundGuide) && (m->button() == RightButton) && (!GetItem(&currItem)))
456 fschmid 1752
                {
1753
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1754
                        MoveGY = false;
1755
                        MoveGX = false;
5087 subik 1756
                        //emit EditGuides(); // TODO: PV - guides refactoring
456 fschmid 1757
                        return;
1758
                }
1759
                if (MoveGY)
1760
                {
1115 tsoots 1761
                        SetYGuide(m, GyM);
456 fschmid 1762
                        MoveGY = false;
1763
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1764
                        updateContents();
2966 fschmid 1765
                        GyM = -1;
456 fschmid 1766
                        return;
1767
                }
1768
                if (MoveGX)
1769
                {
1115 tsoots 1770
                        SetXGuide(m, GxM);
456 fschmid 1771
                        MoveGX = false;
1772
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1773
                        updateContents();
2966 fschmid 1774
                        GxM = -1;
456 fschmid 1775
                        return;
1776
                }
1777
        }
2603 cbradney 1778
        if (Doc->appMode == modeEditGradientVectors)
735 fschmid 1779
                return;
2603 cbradney 1780
        if (Doc->appMode == modeCopyProperties)
1840 fschmid 1781
                return;
2603 cbradney 1782
        if (Doc->appMode == modeMeasurementTool)
456 fschmid 1783
        {
1784
                QPainter p;
1785
                p.begin(viewport());
2854 fschmid 1786
                QPoint out = contentsToViewport(QPoint(0, 0));
1787
                p.translate(out.x(), out.y());
456 fschmid 1788
                p.setRasterOp(XorROP);
1789
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
1790
                p.drawLine(Dxp, Dyp, Mxp, Myp);
1791
                p.end();
1792
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1525 cbradney 1793
                //emit PaintingDone();
456 fschmid 1794
                return;
1795
        }
2603 cbradney 1796
        if (Doc->appMode == modePanning)
4105 cbradney 1797
        {
1798
                if ((m->state() & Qt::RightButton) && (m->state() & Qt::ControlButton))
1799
                {
5781 cbradney 1800
                        m_ScMW->setAppMode(modeNormal);
4105 cbradney 1801
                }
456 fschmid 1802
                return;
4105 cbradney 1803
        }
2603 cbradney 1804
        if