Subversion Repositories Scribus

Rev

Rev 9700 | Rev 9722 | 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"
8508 cbradney 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>
8501 cbradney 33
#include <q3pointarray.h>
3 paul 34
#include <qstringlist.h>
8501 cbradney 35
#include <q3dragobject.h>
3 paul 36
#include <qimage.h>
8501 cbradney 37
#include <q3cstring.h>
173 Franz 38
#include <qfileinfo.h>
456 fschmid 39
#include <qfile.h>
8501 cbradney 40
#include <q3ptrstack.h>
41
//Added by qt3to4:
42
#include <QWheelEvent>
43
#include <Q3PtrList>
44
#include <QPaintEvent>
45
#include <QDragMoveEvent>
46
#include <QDragLeaveEvent>
47
#include <Q3StrList>
48
#include <QLabel>
49
#include <QDropEvent>
50
#include <Q3PopupMenu>
9514 fschmid 51
#include <QMenu>
8501 cbradney 52
#include <QDragEnterEvent>
53
#include <Q3ValueList>
54
#include <QMouseEvent>
55
#include <Q3GridLayout>
9380 fschmid 56
#include <QImageReader>
9514 fschmid 57
#include <QWidgetAction>
307 Franz 58
#include <cmath>
456 fschmid 59
#include <cstdio>
60
#include <cstdlib>
2702 craig 61
 
62
#ifdef HAVE_UNISTD_H
456 fschmid 63
#include <unistd.h>
2702 craig 64
#endif
65
 
8501 cbradney 66
#include <q3url.h>
456 fschmid 67
#include <qdir.h>
68
#include <qevent.h>
2880 fschmid 69
#include <qsizegrip.h>
456 fschmid 70
#if QT_VERSION  > 0x030102
8501 cbradney 71
        #define SPLITVC Qt::SplitHCursor
72
        #define SPLITHC Qt::SplitVCursor
456 fschmid 73
#else
8501 cbradney 74
        #define SPLITVC Qt::SplitVCursor
75
        #define SPLITHC Qt::SplitHCursor
456 fschmid 76
#endif
181 Franz 77
#include "scribus.h"
8221 fschmid 78
//#include "tree.h"
456 fschmid 79
#include "mpalette.h"
80
#include "scribusXml.h"
3903 cbradney 81
#include "selection.h"
456 fschmid 82
#include "serializer.h"
83
#include "insertTable.h"
838 cbradney 84
#include "hruler.h"
85
#include "vruler.h"
1151 fschmid 86
#include "filewatcher.h"
1226 tsoots 87
#include "undomanager.h"
1525 cbradney 88
#include "units.h"
1633 fschmid 89
#include "extimageprops.h"
3695 cbradney 90
#include "page.h"
1655 cbradney 91
#include "pageitemattributes.h"
3625 avox 92
#include "pageitem_imageframe.h"
93
#include "pageitem_line.h"
94
#include "pageitem_pathtext.h"
95
#include "pageitem_polygon.h"
96
#include "pageitem_polyline.h"
97
#include "pageitem_textframe.h"
3053 avox 98
#include "pageselector.h"
1693 craig 99
#include "scpaths.h"
2103 cbradney 100
#include "actionmanager.h"
6566 fschmid 101
#include <tiffio.h>
102
#include CMS_INC
68 Franz 103
 
3942 cbradney 104
#include "scmessagebox.h"
2529 craig 105
#include "util.h"
2495 cbradney 106
#include "story.h"
2834 cbradney 107
#include "prefsmanager.h"
7284 fschmid 108
#include "prefscontext.h"
109
#include "prefsfile.h"
2868 fschmid 110
#include "rulermover.h"
3252 craig 111
#include "hyphenator.h"
3510 cbradney 112
#include "commonstrings.h"
5087 subik 113
#include "guidemanager.h"
7296 fschmid 114
#include "oneclick.h"
5184 avox 115
#include "text/nlsconfig.h"
5827 fschmid 116
#include "scrap.h"
117
#include "stencilreader.h"
2495 cbradney 118
 
504 cbradney 119
using namespace std;
120
 
3 paul 121
 
3205 craig 122
 
5781 cbradney 123
ScribusView::ScribusView(QWidget* win, ScribusMainWindow* mw, ScribusDoc *doc) :
8501 cbradney 124
        Q3ScrollView(win, "s", Qt::WNoAutoErase | Qt::WStaticContents),
3981 craig 125
        Doc(doc),
126
        Prefs(&(PrefsManager::instance()->appPrefs)),
3982 craig 127
        undoManager(UndoManager::instance()),
128
        OldScale(0),
7575 cbradney 129
        dragX(0), dragY(0), dragW(0), dragH(0),
3982 craig 130
        oldW(-1), oldCp(-1),
131
        Mxp(-1), Myp(-1), Dxp(-1), Dyp(-1),
4663 cbradney 132
        frameResizeHandle(-1),
3982 craig 133
        SeRx(-1), SeRy(-1), GyM(-1), GxM(-1),
134
        ClRe(-1), ClRe2(-1),
135
        SegP1(-1), SegP2(-1),
136
        RotMode(0),
137
        DrHY(-1), DrVX(-1),
138
        EdPoints(true),
4705 cbradney 139
        m_MouseButtonPressed(false),   
4663 cbradney 140
        operItemMoving(false),
3982 craig 141
        MoveGY(false), MoveGX(false),
142
        HaveSelRect(false),
4663 cbradney 143
        operItemResizing(false),
3982 craig 144
        EditContour(false),
4049 cbradney 145
        //GroupSel(false),
3982 craig 146
        DraggedGroup(false),
147
        DraggedGroupFirst(false),
4663 cbradney 148
        operItemResizeInEditMode(false),
3982 craig 149
        MidButt(false),
150
        updateOn(true),
151
        FirstPoly(true),
152
        Magnify(false),
153
        MoveSym(false),
154
        previewMode(false),
155
        RCenter(-1,-1),
156
        RecordP(),
157
        Ready(false),
158
        oldX(0), oldY(0),
159
        _groupTransactionStarted(false),
160
        _isGlobalMode(true),
161
        evSpon(false),
162
        forceRedraw(false),
4654 cbradney 163
        Scale(Prefs->DisScale),
6191 tsoots 164
        oldClip(0),
4704 cbradney 165
        m_vhRulerHW(17),
5781 cbradney 166
        m_cursorVisible(false),
167
        m_ScMW(mw)
3 paul 168
{
8501 cbradney 169
        setHScrollBarMode(Q3ScrollView::AlwaysOn);
170
        setVScrollBarMode(Q3ScrollView::AlwaysOn);
4654 cbradney 171
        setMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
3 paul 172
        setResizePolicy(Manual);
8528 cbradney 173
        viewport()->setBackgroundMode(Qt::PaletteBackground);
3 paul 174
        QFont fo = QFont(font());
2887 fschmid 175
        int posi = fo.pointSize()-2;
176
        fo.setPointSize(posi);
3689 cbradney 177
        unitSwitcher = new QComboBox( false, this, "unitSwitcher" );
8573 jghali 178
        unitSwitcher->setFocusPolicy(Qt::NoFocus);
2887 fschmid 179
        unitSwitcher->setFont(fo);
8700 fschmid 180
        int maxUindex = unitGetMaxIndex() - 2;
181
        for (int i = 0; i <= maxUindex; ++i)
2966 fschmid 182
                unitSwitcher->insertItem(unitGetStrFromIndex(i));
8707 fschmid 183
        zoomSpinBox = new ScrSpinBox( 10, 3200, this, 6 );
7884 fschmid 184
        zoomSpinBox->setTabAdvance(false);
3309 cbradney 185
        zoomSpinBox->setFont(fo);
186
        zoomSpinBox->setValue( 100 );
8141 cbradney 187
        zoomSpinBox->setLineStepM(10);
8573 jghali 188
        zoomSpinBox->setFocusPolicy(Qt::ClickFocus);
3309 cbradney 189
        zoomSpinBox->setSuffix( tr( " %" ) );
3053 avox 190
#if OPTION_USE_QTOOLBUTTON
191
        zoomOutToolbarButton = new QToolButton(this);
3274 fschmid 192
        zoomDefaultToolbarButton = new QToolButton(this);
3053 avox 193
        zoomInToolbarButton = new QToolButton(this);
6726 fschmid 194
        cmsToolbarButton = new QToolButton(this);
6549 fschmid 195
        previewToolbarButton = new QToolButton(this);
3274 fschmid 196
        zoomDefaultToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
3053 avox 197
        zoomOutToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
198
        zoomInToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
6726 fschmid 199
        cmsToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
200
        cmsToolbarButton->setToggleButton(true);
8501 cbradney 201
        QIcon ic2;
8700 fschmid 202
        ic2.addPixmap(loadIcon("cmsOff.png"), QIcon::Normal, QIcon::Off);
203
        ic2.addPixmap(loadIcon("cmsOn.png"), QIcon::Normal, QIcon::On);
204
        cmsToolbarButton->setIcon(ic2);
6549 fschmid 205
        previewToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
206
        previewToolbarButton->setToggleButton(true);
8501 cbradney 207
        QIcon ic;
8700 fschmid 208
        ic.addPixmap(loadIcon("previewOff.png"), QIcon::Normal, QIcon::Off);
209
        ic.addPixmap(loadIcon("previewOn.png"), QIcon::Normal, QIcon::On);
210
        previewToolbarButton->setIcon(ic);
3053 avox 211
#else
3274 fschmid 212
        zoomDefaultToolbarButton = new QPushButton(this);
8501 cbradney 213
        zoomDefaultToolbarButton->setFocusPolicy(Qt::NoFocus);
3274 fschmid 214
        zoomDefaultToolbarButton->setDefault( false );
215
        zoomDefaultToolbarButton->setAutoDefault( false );
216
        zoomDefaultToolbarButton->setFlat(OPTION_FLAT_BUTTON);
1822 cbradney 217
        zoomOutToolbarButton = new QPushButton(this);
8501 cbradney 218
        zoomOutToolbarButton->setFocusPolicy(Qt::NoFocus);
3053 avox 219
        zoomOutToolbarButton->setDefault( false );
220
        zoomOutToolbarButton->setAutoDefault( false );
221
        zoomOutToolbarButton->setFlat(OPTION_FLAT_BUTTON);
3274 fschmid 222
        zoomInToolbarButton = new QPushButton(this);
8501 cbradney 223
        zoomInToolbarButton->setFocusPolicy(Qt::NoFocus);
3053 avox 224
        zoomInToolbarButton->setDefault( false );
225
        zoomInToolbarButton->setAutoDefault( false );
226
        zoomInToolbarButton->setFlat(OPTION_FLAT_BUTTON);
6549 fschmid 227
        previewToolbarButton = new QPushButton(this);
8501 cbradney 228
        cmsToolbarButton->setFocusPolicy(Qt::NoFocus);
6726 fschmid 229
        cmsToolbarButton->setDefault( false );
230
        cmsToolbarButton->setAutoDefault( false );
231
        cmsToolbarButton->setFlat(OPTION_FLAT_BUTTON);
232
        cmsToolbarButton->setPixmap(loadIcon("cmsOn.png"));
233
        previewToolbarButton = new QPushButton(this);
8501 cbradney 234
        previewToolbarButton->setFocusPolicy(Qt::NoFocus);
6549 fschmid 235
        previewToolbarButton->setDefault( false );
236
        previewToolbarButton->setAutoDefault( false );
237
        previewToolbarButton->setFlat(OPTION_FLAT_BUTTON);
238
        previewToolbarButton->setPixmap(loadIcon("previewOn.png"));
3053 avox 239
#endif
5287 cbradney 240
        //zoomDefaultToolbarButton->setText("1:1");
241
        zoomDefaultToolbarButton->setPixmap(loadIcon("16/zoom-original.png"));
242
        zoomOutToolbarButton->setPixmap(loadIcon("16/zoom-out.png"));
243
        zoomInToolbarButton->setPixmap(loadIcon("16/zoom-in.png"));
7651 cbradney 244
        pageSelector = new PageSelector(this, Doc->Pages->count());
3309 cbradney 245
        pageSelector->setFont(fo);
8573 jghali 246
        pageSelector->setFocusPolicy(Qt::ClickFocus);
3309 cbradney 247
        layerMenu = new QComboBox( true, this, "LY" );
248
        layerMenu->setEditable(false);
249
        layerMenu->setFont(fo);
8573 jghali 250
        layerMenu->setFocusPolicy(Qt::NoFocus);
6549 fschmid 251
        visualMenu = new QComboBox( false, this, "visualMenu" );
8573 jghali 252
        visualMenu->setFocusPolicy(Qt::NoFocus);
6549 fschmid 253
        visualMenu->setFont(fo);
254
        visualMenu->setEnabled(false);
1612 cbradney 255
        horizRuler = new Hruler(this, Doc);
256
        vertRuler = new Vruler(this, Doc);
3309 cbradney 257
        rulerMover = new RulerMover(this);
8573 jghali 258
        rulerMover->setFocusPolicy(Qt::NoFocus);
3 paul 259
        Ready = true;
456 fschmid 260
        viewport()->setMouseTracking(true);
261
        setAcceptDrops(true);
262
        viewport()->setAcceptDrops(true);
263
        setDragAutoScroll(false);
264
        Doc->DragP = false;
265
        Doc->leaveDrag = false;
1330 fschmid 266
        Doc->SubMode = -1;
5237 fschmid 267
        storedFramesShown = Doc->guidesSettings.framesShown;
7624 fschmid 268
        storedShowControls = Doc->guidesSettings.showControls;
5235 fschmid 269
        viewAsPreview = false;
6549 fschmid 270
        previewVisual = 0;
6349 fschmid 271
        shiftSelItems = false;
7284 fschmid 272
        inItemCreation = false;
8720 fschmid 273
        redrawMode = 0;
274
        redrawCount = 0;
8994 fschmid 275
        redrawMarker = new QRubberBand(QRubberBand::Rectangle);
8720 fschmid 276
        redrawMarker->hide();
9041 fschmid 277
        redrawPolygon.clear();
9431 fschmid 278
        specialRendering = false;
279
        firstSpecial = false;
280
        m_buffer = QPixmap();
7587 cbradney 281
        m_ScMW->scrActions["viewFitPreview"]->setOn(viewAsPreview);
6477 fschmid 282
        m_SnapCounter = 0;
1822 cbradney 283
        connect(zoomOutToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomOut()));
284
        connect(zoomInToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomIn()));
3274 fschmid 285
        connect(zoomDefaultToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoom100()));
8705 fschmid 286
        connect(zoomSpinBox, SIGNAL(valueChanged(double)), this, SLOT(setZoom()));
3309 cbradney 287
        connect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
288
        connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
2966 fschmid 289
        connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
6549 fschmid 290
        connect(previewToolbarButton, SIGNAL(clicked()), this, SLOT(togglePreview()));
6726 fschmid 291
        connect(cmsToolbarButton, SIGNAL(clicked()), this, SLOT(toggleCMS()));
6549 fschmid 292
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
3 paul 293
        connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
1443 tsoots 294
        connect(this, SIGNAL(HaveSel(int)), this, SLOT(selectionChanged()));
6549 fschmid 295
        languageChange();
9668 fschmid 296
        dragTimer = new QTimer(this);
297
        connect(dragTimer, SIGNAL(timeout()), this, SLOT(dragTimerTimeOut()));
298
        dragTimer->stop();
299
        dragTimerFired = false;
3 paul 300
}
301
 
2199 cbradney 302
void ScribusView::languageChange()
303
{
6758 fschmid 304
        QToolTip::remove(cmsToolbarButton);
305
        QToolTip::remove(previewToolbarButton);
306
        QToolTip::remove(visualMenu);
6769 cbradney 307
        QToolTip::add(cmsToolbarButton, tr("Switches Color Management on or off"));
6758 fschmid 308
        QToolTip::add(previewToolbarButton, tr("Enables the Preview Mode"));
309
        QToolTip::add(visualMenu, tr("Here you can select the visual appearance of the display\nYou can choose between normal and several color blindness forms"));
6549 fschmid 310
        disconnect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
311
        visualMenu->clear();
7167 cbradney 312
        visualMenu->insertItem(CommonStrings::trVisionNormal);
313
        visualMenu->insertItem(CommonStrings::trVisionProtanopia);
314
        visualMenu->insertItem(CommonStrings::trVisionDeuteranopia);
315
        visualMenu->insertItem(CommonStrings::trVisionTritanopia);
316
        visualMenu->insertItem(CommonStrings::trVisionFullColorBlind);
6549 fschmid 317
        visualMenu->setCurrentItem(previewVisual);
318
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
2199 cbradney 319
}
320
 
6726 fschmid 321
void ScribusView::toggleCMS()
322
{
323
        Doc->enableCMS(!Doc->HasCMS);
324
        updateContents();
325
}
326
 
6549 fschmid 327
void ScribusView::switchPreviewVisual(int vis)
328
{
329
        previewVisual = vis;
330
        Doc->recalculateColors();
331
        Doc->recalcPicturesRes();
332
        updateContents();
333
}
334
 
5235 fschmid 335
void ScribusView::togglePreview()
336
{
337
        viewAsPreview = !viewAsPreview;
5237 fschmid 338
        if (viewAsPreview)
339
        {
340
                storedFramesShown = Doc->guidesSettings.framesShown;
341
                Doc->guidesSettings.framesShown = false;
7624 fschmid 342
                storedShowControls = Doc->guidesSettings.showControls;
343
                Doc->guidesSettings.showControls = false;
6802 subik 344
                // warning popping up in case colour management and out-of-gamut-display are active
345
                // as from #4346: Add a preview for daltonian - PV
7141 fschmid 346
                if (Doc->HasCMS && Doc->Gamut)
7400 cbradney 347
                        QMessageBox::information(m_ScMW, tr("Preview Mode"),
348
                                                "<qt>" + tr("CMS is active. Therefore the color display may not match the perception by visually impaired") + "</qt>",
349
                                                QMessageBox::Ok);
5237 fschmid 350
        }
351
        else
7624 fschmid 352
        {
5237 fschmid 353
                Doc->guidesSettings.framesShown = storedFramesShown;
7624 fschmid 354
                Doc->guidesSettings.showControls = storedShowControls;
355
        }
7587 cbradney 356
        m_ScMW->scrActions["viewFitPreview"]->setOn(viewAsPreview);
5781 cbradney 357
        m_ScMW->scrActions["viewShowMargins"]->setEnabled(!viewAsPreview);
358
        m_ScMW->scrActions["viewShowFrames"]->setEnabled(!viewAsPreview);
359
        m_ScMW->scrActions["viewShowLayerMarkers"]->setEnabled(!viewAsPreview);
360
        m_ScMW->scrActions["viewShowGrid"]->setEnabled(!viewAsPreview);
361
        m_ScMW->scrActions["viewShowGuides"]->setEnabled(!viewAsPreview);
362
        m_ScMW->scrActions["viewShowColumnBorders"]->setEnabled(!viewAsPreview);
363
        m_ScMW->scrActions["viewShowBaseline"]->setEnabled(!viewAsPreview);
364
        m_ScMW->scrActions["viewShowTextChain"]->setEnabled(!viewAsPreview);
365
        m_ScMW->scrActions["viewShowTextControls"]->setEnabled(!viewAsPreview);
6549 fschmid 366
#if OPTION_USE_QTOOLBUTTON
367
        previewToolbarButton->setOn(viewAsPreview);
368
#endif
369
        visualMenu->setEnabled(viewAsPreview);
370
        Doc->recalculateColors();
371
        Doc->recalcPicturesRes();
5235 fschmid 372
        updateContents();
373
}
374
 
2171 fschmid 375
void ScribusView::viewportPaintEvent ( QPaintEvent * p )
376
{
4011 cbradney 377
        #ifndef _WIN32
2171 fschmid 378
        if (p->spontaneous())
379
                evSpon = true;
4011 cbradney 380
        #endif
8501 cbradney 381
        Q3ScrollView::viewportPaintEvent(p);
2171 fschmid 382
}
383
 
5373 fschmid 384
void ScribusView::drawContents(QPainter *psx, int clipx, int clipy, int clipw, int cliph)
456 fschmid 385
{
2891 cbradney 386
        if (Doc->isLoading())
456 fschmid 387
                return;
388
        if (!updateOn)
389
                return;
390
//      QTime tim;
391
//      tim.start();
9700 fschmid 392
        psx->setRenderHint(QPainter::Antialiasing, false);
393
        psx->setRenderHint(QPainter::SmoothPixmapTransform, false);
456 fschmid 394
        if ((clipw > 0) && (cliph > 0))
395
        {
9431 fschmid 396
 
397
                if ((specialRendering) || (Doc->EditClip && specialRendering))
398
                {
399
                        if (firstSpecial)
400
                        {
401
                                m_buffer = QPixmap::grabWindow(viewport()->winId(), 0, 0);
402
                                firstSpecial = false;
403
                        }
404
                        QPainter pp;
405
                        QPixmap ppx = m_buffer;
406
                        pp.begin(&ppx);
407
                        pp.setRenderHint(QPainter::Antialiasing, true);
9441 fschmid 408
                        if (redrawMode == 1)
409
                        {
410
                                pp.resetMatrix();
411
                                pp.setBrush(Qt::NoBrush);
412
                                pp.setPen(QPen(Qt::black, 1.0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
413
                                QPoint nXY = redrawPolygon.point(0);
414
                                pp.drawLine(0, nXY.y(), viewport()->width(), nXY.y());
415
                                pp.drawLine(nXY.x(), 0, nXY.x(), viewport()->height());
416
                                redrawPolygon.clear();
417
                        }
9434 fschmid 418
                        if ((Doc->appMode == modeDrawBezierLine) && (!redrawPolygon.isEmpty()) && (Doc->m_Selection->count() != 0))
419
                        {
420
                                pp.setBrush(Qt::NoBrush);
421
                                pp.setPen(QPen(Qt::black, 1.0 / Scale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
422
                                pp.resetMatrix();
423
                                QPoint out = contentsToViewport(QPoint(0, 0));
424
                                pp.translate(out.x(), out.y());
425
                                pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
426
                                PageItem *currItem = Doc->m_Selection->itemAt(0);
427
                                Transform(currItem, &pp);
428
                                Q3PointArray Bez(4);
429
                                if (currItem->PoLine.size() > 1)
430
                                {
431
                                        QPoint nXY = redrawPolygon.point(0);
432
                                        if (!m_MouseButtonPressed)
433
                                        {
434
                                                QPoint a1 = currItem->PoLine.pointQ(currItem->PoLine.size()-2);
435
                                                QPoint a2 = currItem->PoLine.pointQ(currItem->PoLine.size()-1);
436
                                                BezierPoints(&Bez, a1, a2, nXY, nXY);
437
                                                pp.drawCubicBezier(Bez);
438
                                        }
439
                                        else
440
                                        {
441
                                                QPoint a2 = currItem->PoLine.pointQ(currItem->PoLine.size()-1);
442
                                                if (currItem->PoLine.size() > 2)
443
                                                {
444
                                                        QPoint a1 = currItem->PoLine.pointQ(currItem->PoLine.size()-2);
445
                                                        QPoint a3 = currItem->PoLine.pointQ(currItem->PoLine.size()-3);
446
                                                        BezierPoints(&Bez, a3, a1, nXY, a2);
447
                                                        pp.drawCubicBezier(Bez);
448
                                                }
449
                                                pp.drawLine(a2, nXY);
450
                                        }
451
                                }
452
                                else
453
                                {
454
                                        QPoint a2 = currItem->PoLine.pointQ(currItem->PoLine.size()-1);
455
                                        QPoint nXY = redrawPolygon.point(0);
456
                                        pp.drawLine(a2, nXY);
457
                                }
458
                                redrawPolygon.clear();
459
                        }
9441 fschmid 460
                        if (m_MouseButtonPressed && (Doc->appMode == modeMeasurementTool))
9431 fschmid 461
                        {
462
                                pp.resetMatrix();
463
                                QPoint out = contentsToViewport(QPoint(0, 0));
464
                                pp.translate(out.x(), out.y());
9441 fschmid 465
                                pp.setBrush(Qt::NoBrush);
466
                                pp.setPen(QPen(Qt::black, 1.0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
467
                                pp.drawPolyline(redrawPolygon);
468
                                redrawPolygon.clear();
469
                        }
470
                        if (m_MouseButtonPressed && (Doc->appMode == modeDrawLine))
471
                        {
472
                                QPoint out = contentsToViewport(QPoint(0, 0));
473
                                pp.resetMatrix();
474
                                pp.translate(out.x(), out.y());
9431 fschmid 475
                                pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
9441 fschmid 476
                                pp.scale(Scale, Scale);
9431 fschmid 477
                                pp.setBrush(Qt::NoBrush);
478
                                pp.setPen(QPen(Qt::black, 1.0 / Scale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
479
                                pp.drawPolyline(redrawPolygon);
480
                                redrawPolygon.clear();
481
                        }
482
                        if (operItemMoving || operItemResizing)
483
                        {
484
                                if (operItemResizing)
485
                                {
486
                                        if (!redrawPolygon.isEmpty())
487
                                        {
488
                                                if (m_MouseButtonPressed && (Doc->appMode == modeDrawFreehandLine))
489
                                                {
490
                                                        pp.resetMatrix();
491
                                                        QPoint out = contentsToViewport(QPoint(0, 0));
492
                                                        pp.translate(out.x(), out.y());
493
                                                        pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
494
                                                        pp.scale(Scale, Scale);
495
                                                        pp.setBrush(Qt::NoBrush);
496
                                                        pp.setPen(QPen(Qt::black, 1.0 / Scale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
497
                                                        pp.drawPolyline(redrawPolygon);
498
                                                        redrawPolygon.clear();
499
                                                }
500
                                                else
501
                                                {
502
                                                        QColor drawColor = qApp->palette().color(QPalette::Active, QColorGroup::Highlight);
503
                                                        pp.setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
504
                                                        drawColor.setAlpha(64);
505
                                                        pp.resetMatrix();
506
                                                        QPoint out = contentsToViewport(QPoint(0, 0));
507
                                                        pp.translate(out.x(), out.y());
9441 fschmid 508
//                                                      pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
9431 fschmid 509
                                                        pp.setBrush(drawColor);
510
                                                        pp.drawPolygon(redrawPolygon);
511
                                                        redrawPolygon.clear();
512
                                                }
513
                                        }
514
                                }
515
                                else
516
                                {
517
                                        if (Doc->m_Selection->count() != 0)
518
                                        {
519
                                                uint selectedItemCount = Doc->m_Selection->count();
520
                                                PageItem *currItem = Doc->m_Selection->itemAt(0);
521
                                                if (selectedItemCount < moveWithBoxesOnlyThreshold)
522
                                                {
523
                                                        for (uint cu = 0; cu < selectedItemCount; cu++)
524
                                                        {
525
                                                                currItem = Doc->m_Selection->itemAt(cu);
526
                                                                pp.resetMatrix();
527
                                                                QPoint out = contentsToViewport(QPoint(0, 0));
528
                                                                pp.translate(out.x(), out.y());
529
                                                                pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
530
                                                                Transform(currItem, &pp);
531
                                                                pp.setBrush(Qt::NoBrush);
532
                                                                pp.setPen(QPen(Qt::black, 1.0 / Scale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
533
                                                                if (selectedItemCount < moveWithFullOutlinesThreshold)
534
                                                                {
535
                                                                        if (!(currItem->asLine()))
536
                                                                                currItem->DrawPolyL(&pp, currItem->Clip);
537
                                                                        else
538
                                                                        {
539
                                                                                if (currItem->asLine())
540
                                                                                {
541
                                                                                        int lw2 = 1;
542
                                                                                        int lw = 1;
543
                                                                                        Qt::PenCapStyle le = Qt::FlatCap;
544
                                                                                        if (currItem->NamedLStyle.isEmpty())
545
                                                                                        {
546
                                                                                                lw2 = qRound(currItem->lineWidth()  / 2.0);
547
                                                                                                lw = qRound(qMax(currItem->lineWidth(), 1.0));
548
                                                                                                le = currItem->PLineEnd;
549
                                                                                        }
550
                                                                                        else
551
                                                                                        {
552
                                                                                                multiLine ml = Doc->MLineStyles[currItem->NamedLStyle];
553
                                                                                                lw2 = qRound(ml[ml.size()-1].Width  / 2.0);
554
                                                                                                lw = qRound(qMax(ml[ml.size()-1].Width, 1.0));
555
                                                                                                le = static_cast<Qt::PenCapStyle>(ml[ml.size()-1].LineEnd);
556
                                                                                        }
557
                                                                                        if (le != Qt::FlatCap)
558
                                                                                                pp.drawRect(-lw2, -lw2, qRound(currItem->width())+lw, lw);
559
                                                                                        else
560
                                                                                                pp.drawRect(-1, -lw2, qRound(currItem->width()), lw);
561
                                                                                }
562
                                                                        }
563
                                                                }
564
                                                                else
565
                                                                        pp.drawRect(0, 0, static_cast<int>(currItem->width())+1, static_cast<int>(currItem->height())+1);
566
                                                        }
567
                                                }
568
                                                else
569
                                                {
570
                                                        double gx, gy, gw, gh;
571
                                                        Doc->m_Selection->setGroupRect();
572
                                                        Doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
573
                                                        QPoint out = contentsToViewport(QPoint(0, 0));
574
                                                        pp.resetMatrix();
575
                                                        pp.translate(out.x(), out.y());
576
                                                        pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
577
                                                        pp.scale(Scale, Scale);
578
                                                        pp.translate(qRound(gx), qRound(gy));
579
                                                        pp.drawRect(QRect(0, 0, qRound(gw), qRound(gh)));
580
                                                }
581
                                        }
582
                                }
583
                        }
584
                        else
585
                        {
9434 fschmid 586
                                if ((Doc->m_Selection->count() != 0) && (Doc->appMode != modeDrawBezierLine))
9431 fschmid 587
                                {
588
                                        PageItem *currItem = Doc->m_Selection->itemAt(0);
589
                                        if ((Doc->EditClip) && (currItem->isSelected()))
590
                                        {
591
                                                if (EditContour)
592
                                                        MarkClip(&pp, currItem, currItem->ContourLine, true);
593
                                                else
594
                                                        MarkClip(&pp, currItem, currItem->PoLine, true);
595
                                        }
596
                                        else
597
                                        {
598
                                                if (Doc->m_Selection->isMultipleSelection())
599
                                                {
600
                                                        pp.resetMatrix();
601
                                                        QPoint out = contentsToViewport(QPoint(0, 0));
602
                                                        pp.translate(out.x(), out.y());
603
                                                        pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
604
                                                        double x, y, w, h;
605
                                                        Doc->m_Selection->setGroupRect();
606
                                                        Doc->m_Selection->getGroupRect(&x, &y, &w, &h);
607
                                                        x *= Scale;
608
                                                        y *= Scale;
609
                                                        w *= Scale;
610
                                                        h *= Scale;
611
                                                        pp.setPen(QPen(Qt::red, 1, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
612
                                                        pp.setBrush(Qt::NoBrush);
613
                                                        pp.drawRect(QRectF(x, y, w, h));
614
                                                        pp.setBrush(Qt::red);
615
                                                        pp.setPen(QPen(Qt::red, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
616
                                                        pp.drawRect(QRectF(x+w-6, y+h-6, 6, 6));
617
                                                        pp.drawRect(QRectF(x+w/2 - 3, y+h-6, 6, 6));
618
                                                        pp.drawRect(QRectF(x+w/2 - 3, y, 6, 6));
619
                                                        pp.drawRect(QRectF(x+w-6, y+h/2 - 3, 6, 6));
620
                                                        pp.drawRect(QRectF(x+w-6, y, 6, 6));
621
                                                        pp.drawRect(QRectF(x, y, 6, 6));
622
                                                        pp.drawRect(QRectF(x, y+h/2 - 3, 6, 6));
623
                                                        pp.drawRect(QRectF(x, y+h-6, 6, 6));
624
                                                }
625
                                                else
626
                                                {
627
                                                        pp.resetMatrix();
628
                                                        QPoint out = contentsToViewport(QPoint(0, 0));
629
                                                        pp.translate(out.x(), out.y());
630
                                                        pp.translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
631
                                                        Transform(currItem, &pp);
632
                                                        currItem->paintObj(&pp);
633
                                                }
634
                                        }
635
                                }
636
                        }
637
                        pp.end();
638
                        psx->resetMatrix();
639
                        psx->drawPixmap(0, 0, ppx);
640
                        return;
641
                }
642
 
3313 cbradney 643
                QPoint vr = contentsToViewport(QPoint(clipx, clipy));
7643 cbradney 644
                ScPainter *painter=0;
9319 fschmid 645
                QImage img = QImage(clipw, cliph, QImage::Format_ARGB32);
5746 fschmid 646
                painter = new ScPainter(&img, img.width(), img.height(), 1.0, 0);
7141 fschmid 647
                painter->clear(paletteBackgroundColor());
7290 fschmid 648
                painter->newPath();
649
                painter->moveTo(0, 0);
650
                painter->lineTo(clipw, 0);
651
                painter->lineTo(clipw, cliph);
652
                painter->lineTo(0, cliph);
653
                painter->closePath();
654
                painter->setClipPath();
7141 fschmid 655
                painter->translate(-clipx, -clipy);
656
                painter->setZoomFactor(Scale);
657
                painter->translate(-Doc->minCanvasCoordinate.x(), -Doc->minCanvasCoordinate.y());
658
                painter->setLineWidth(1);
659
                painter->setFillMode(ScPainter::Solid);
456 fschmid 660
/* Draw Page Outlines */
3724 cbradney 661
                if (!Doc->masterPageMode())
456 fschmid 662
                {
3724 cbradney 663
                        uint docPagesCount=Doc->Pages->count();
7221 fschmid 664
                        if (!viewAsPreview)
665
                        {
666
                                painter->setBrush(QColor(128,128,128));
667
                                painter->setAntialiasing(false);
668
                                painter->beginLayer(1.0, 0);
8501 cbradney 669
                                painter->setPen(Qt::black, 1.0 / Scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
8703 fschmid 670
                                Page *actPg;
7221 fschmid 671
                                for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
672
                                {
8703 fschmid 673
                                        actPg = Doc->Pages->at(a);
7221 fschmid 674
                                        double bleedRight = 0.0;
675
                                        double bleedLeft = 0.0;
676
                                        double bleedBottom = 0.0;
677
                                        double bleedTop = 0.0;
8703 fschmid 678
                                        Doc->getBleeds(actPg, &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
679
                                        double blx = (actPg->xOffset() - bleedLeft) * Scale;
680
                                        double bly = (actPg->yOffset() - bleedTop) * Scale;
681
                                        double blw = (actPg->width() + bleedLeft + bleedRight) * Scale;
682
                                        double blh = (actPg->height() + bleedBottom + bleedTop) * Scale;
7221 fschmid 683
 
8703 fschmid 684
                                        QRectF drawRect = QRectF(blx-1, bly-1, blw+6, blh+6);
685
                                        drawRect.translate(-Doc->minCanvasCoordinate.x() * Scale, -Doc->minCanvasCoordinate.y() * Scale);
686
                                        if (drawRect.intersects(QRectF(clipx, clipy, clipw, cliph)))
7221 fschmid 687
                                        {
688
                                                painter->setFillMode(ScPainter::Solid);
8703 fschmid 689
                                                double blx2 = actPg->xOffset();
690
                                                double bly2 = actPg->yOffset();
691
                                                double blw2 = actPg->width();
692
                                                double blh2 = actPg->height();
7221 fschmid 693
                                                if (Doc->guidesSettings.showBleed)
694
                                                {
8703 fschmid 695
                                                        blx2 -= bleedLeft;
696
                                                        bly2 -= bleedTop;
697
                                                        blw2 += bleedLeft + bleedRight;
698
                                                        blh2 += bleedBottom + bleedTop;
7221 fschmid 699
                                                }
700
                                                painter->drawRect(blx2 + 5 / Scale, bly2 + 5 / Scale, blw2, blh2);
7225 cbradney 701
                                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
7221 fschmid 702
                                                {
703
                                                        painter->setFillMode(ScPainter::None);
8501 cbradney 704
                                                        painter->setPen(Qt::black, 1.0 / Scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7221 fschmid 705
                                                        painter->drawRect(blx2, bly2 - 1 / Scale, blw2 + 1 / Scale, blh2 + 2 / Scale);
706
                                                }
707
                                        }
708
                                }
7760 fschmid 709
                                painter->endLayer();
7221 fschmid 710
                                painter->setAntialiasing(true);
711
                        }
712
                        painter->setFillMode(ScPainter::Solid);
8703 fschmid 713
                        Page *actPg;
5664 fschmid 714
                        for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
456 fschmid 715
                        {
8703 fschmid 716
                                actPg = Doc->Pages->at(a);
717
                                double x = actPg->xOffset();
718
                                double y = actPg->yOffset();
719
                                double w = actPg->width();
720
                                double h = actPg->height();
7051 fschmid 721
                                double bleedRight = 0.0;
722
                                double bleedLeft = 0.0;
723
                                double bleedBottom = 0.0;
724
                                double bleedTop = 0.0;
6922 fschmid 725
                                bool drawBleed = false;
7225 cbradney 726
                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
7051 fschmid 727
                                {
6922 fschmid 728
                                        drawBleed = true;
7157 fschmid 729
                                        Doc->getBleeds(a, &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
6922 fschmid 730
                                }
8703 fschmid 731
                                double blx = (actPg->xOffset() - bleedLeft) * Scale;
732
                                double bly = (actPg->yOffset() - bleedTop) * Scale;
733
                                double blw = (actPg->width() + bleedLeft + bleedRight) * Scale;
734
                                double blh = (actPg->height() + bleedBottom + bleedTop) * Scale;
6922 fschmid 735
 
8703 fschmid 736
                                QRectF drawRect = QRectF(blx, bly, blw+5, blh+5);
737
                                drawRect.translate(-Doc->minCanvasCoordinate.x() * Scale, -Doc->minCanvasCoordinate.y() * Scale);
738
                                if (drawRect.intersects(QRectF(clipx, clipy, clipw, cliph)))
456 fschmid 739
                                {
7141 fschmid 740
                                        painter->setFillMode(ScPainter::Solid);
8522 cbradney 741
                                        painter->setPen(Qt::black, 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7760 fschmid 742
                                        painter->setAntialiasing(false);
5752 fschmid 743
                                        painter->beginLayer(1.0, 0);
7157 fschmid 744
                                        painter->setLineWidth(0.0);
5664 fschmid 745
                                        painter->setBrush(Doc->papColor);
6922 fschmid 746
                                        if (!viewAsPreview)
747
                                        {
8703 fschmid 748
                                                double blx2 = actPg->xOffset() - bleedLeft;
749
                                                double bly2 = actPg->yOffset() - bleedTop;
750
                                                double blw2 = actPg->width() + bleedLeft + bleedRight;
751
                                                double blh2 = actPg->height() + bleedBottom + bleedTop;
7141 fschmid 752
                                                painter->drawRect(blx2, bly2, blw2, blh2);
6922 fschmid 753
                                                if (drawBleed)
754
                                                        painter->drawRect(x, y, w, h);
755
                                        }
756
                                        else
757
                                                painter->drawRect(x, y, w, h);
7760 fschmid 758
                                        painter->endLayer();
6809 fschmid 759
                                        painter->setAntialiasing(true);
456 fschmid 760
                                }
5664 fschmid 761
                        }
6534 fschmid 762
                        if (viewAsPreview)
763
                        {
764
                                FPointArray PoLine;
765
                                bool first = true;
8703 fschmid 766
                                Page *actPg;
6534 fschmid 767
                                for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
768
                                {
769
                                        if (!first)
770
                                                PoLine.setMarker();
771
                                        first = false;
8703 fschmid 772
                                        actPg = Doc->Pages->at(a);
773
                                        double x = actPg->xOffset();
774
                                        double y = actPg->yOffset();
775
                                        double w = actPg->width();
776
                                        double h = actPg->height();
6534 fschmid 777
                                        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,
778
                                                                                                        1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0,
779
                                                                                                        0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0};
780
                                        for (int a = 0; a < 29; a += 4)
781
                                        {
782
                                                PoLine.addPoint(x + w * rect[a], y + h * rect[a+1]);
783
                                                PoLine.addPoint(x + w * rect[a+2], y + h * rect[a+3]);
784
                                        }
785
                                }
7049 fschmid 786
                                painter->beginLayer(1.0, 0, &PoLine);
6534 fschmid 787
                        }
788
                        else
7049 fschmid 789
                                painter->beginLayer(1.0, 0);
7157 fschmid 790
                        if ((Doc->guidesSettings.before) && (!viewAsPreview))
791
                        {
8703 fschmid 792
                                Page *actPg;
7157 fschmid 793
                                for (uint a = 0; a < docPagesCount; ++a)
794
                                {
8703 fschmid 795
                                        actPg = Doc->Pages->at(a);
796
                                        double x = actPg->xOffset() * Scale;
797
                                        double y = actPg->yOffset() * Scale;
798
                                        double w = actPg->width() * Scale;
799
                                        double h = actPg->height() * Scale;
800
                                        QRectF drawRect = QRectF(x, y, w+5, h+5);
801
                                        drawRect.translate(-Doc->minCanvasCoordinate.x() * Scale, -Doc->minCanvasCoordinate.y() * Scale);
802
                                        if (drawRect.intersects(QRectF(clipx, clipy, clipw, cliph)))
7157 fschmid 803
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
804
                                }
805
                        }
7049 fschmid 806
                        for (uint a = 0; a < docPagesCount; ++a)
6534 fschmid 807
                        {
7049 fschmid 808
                                DrawMasterItems(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
6534 fschmid 809
                        }
7049 fschmid 810
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
811
                        painter->endLayer();
5664 fschmid 812
                        if ((!Doc->guidesSettings.before) && (!viewAsPreview))
813
                        {
8703 fschmid 814
                                Page *actPg;
5664 fschmid 815
                                for (uint a = 0; a < docPagesCount; ++a)
5235 fschmid 816
                                {
8703 fschmid 817
                                        actPg = Doc->Pages->at(a);
818
                                        double x = actPg->xOffset() * Scale;
819
                                        double y = actPg->yOffset() * Scale;
820
                                        double w = actPg->width() * Scale;
821
                                        double h = actPg->height() * Scale;
822
                                        QRectF drawRect = QRectF(x, y, w+5, h+5);
823
                                        drawRect.translate(-Doc->minCanvasCoordinate.x() * Scale, -Doc->minCanvasCoordinate.y() * Scale);
824
                                        if (drawRect.intersects(QRectF(clipx, clipy, clipw, cliph)))
5664 fschmid 825
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
5235 fschmid 826
                                }
456 fschmid 827
                        }
828
                }
829
                else
830
                {
8703 fschmid 831
                        double x = Doc->scratch.Left * Scale;
832
                        double y = Doc->scratch.Top * Scale;
833
                        double w = Doc->currentPage()->width() * Scale;
834
                        double h = Doc->currentPage()->height() * Scale;
835
                        QRectF drawRect = QRectF(x, y, w+5, h+5);
836
                        drawRect.translate(-Doc->minCanvasCoordinate.x() * Scale, -Doc->minCanvasCoordinate.y() * Scale);
837
                        if (drawRect.intersects(QRectF(clipx, clipy, clipw, cliph)))
456 fschmid 838
                        {
7141 fschmid 839
                                painter->setFillMode(ScPainter::Solid);
840
                                painter->setBrush(QColor(128,128,128));
8014 fschmid 841
                                double bleedRight = 0.0;
842
                                double bleedLeft = 0.0;
843
                                double bleedBottom = 0.0;
844
                                double bleedTop = 0.0;
845
                                Doc->getBleeds(Doc->currentPage(), &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
5752 fschmid 846
                                painter->beginLayer(1.0, 0);
7141 fschmid 847
                                painter->setAntialiasing(false);
8501 cbradney 848
                                painter->setPen(Qt::black, 1 / Scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
8504 cbradney 849
                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
8014 fschmid 850
                                {
8504 cbradney 851
                                        painter->drawRect(Doc->scratch.Left - bleedLeft+5 / Scale, Doc->scratch.Top - bleedTop+5 / Scale, Doc->currentPage()->width() + bleedLeft + bleedRight, Doc->currentPage()->height() + bleedBottom + bleedTop);
8014 fschmid 852
                                        painter->setBrush(Doc->papColor);
8504 cbradney 853
                                        painter->drawRect(Doc->scratch.Left - bleedLeft, Doc->scratch.Top - bleedTop, Doc->currentPage()->width() + bleedLeft + bleedRight, Doc->currentPage()->height() + bleedBottom + bleedTop);
8014 fschmid 854
                                }
855
                                else
856
                                {
8504 cbradney 857
                                        painter->drawRect(Doc->scratch.Left+5 / Scale, Doc->scratch.Top+5 / Scale, Doc->currentPage()->width(), Doc->currentPage()->height());
8014 fschmid 858
                                        painter->setBrush(Doc->papColor);
8504 cbradney 859
                                        painter->drawRect(Doc->scratch.Left, Doc->scratch.Top, Doc->currentPage()->width(), Doc->currentPage()->height());
8014 fschmid 860
                                }
7141 fschmid 861
                                painter->setAntialiasing(true);
1187 fschmid 862
                                if (Doc->guidesSettings.before)
5087 subik 863
                                        DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
5752 fschmid 864
                                painter->endLayer();
456 fschmid 865
                        }
5752 fschmid 866
                        painter->beginLayer(1.0, 0);
456 fschmid 867
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
5752 fschmid 868
                        painter->endLayer();
2848 fschmid 869
                        if ((!Doc->guidesSettings.before) && (drawRect.intersects(QRect(clipx, clipy, clipw, cliph))))
5087 subik 870
                                DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
456 fschmid 871
                }
5235 fschmid 872
                if (((Doc->m_Selection->count() != 0) || (linkedFramesToShow.count() != 0))  && (!viewAsPreview))
456 fschmid 873
                {
874
                        painter->save();
1957 cbradney 875
                        PageItem *currItem;
879 fschmid 876
                        if ((Doc->guidesSettings.linkShown) && (linkedFramesToShow.count() != 0))
1957 cbradney 877
                                currItem = linkedFramesToShow.at(0);
705 fschmid 878
                        else
808 fschmid 879
                        {
880
                                if (linkedFramesToShow.count() != 0)
1957 cbradney 881
                                        currItem = linkedFramesToShow.at(0);
808 fschmid 882
                                else
4847 cbradney 883
                                        currItem = Doc->m_Selection->itemAt(0);
808 fschmid 884
                        }
3594 cbradney 885
                        //Draw the frame links
2603 cbradney 886
                        if ((((Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
1957 cbradney 887
                                   && (currItem->itemType() == PageItem::TextFrame)) || (Doc->guidesSettings.linkShown))
456 fschmid 888
                        {
1957 cbradney 889
                                PageItem *nextItem = currItem;
879 fschmid 890
                                if (Doc->guidesSettings.linkShown)
456 fschmid 891
                                {
705 fschmid 892
                                        for (uint lks = 0; lks < linkedFramesToShow.count(); ++lks)
893
                                        {
1957 cbradney 894
                                                nextItem = linkedFramesToShow.at(lks);
895
                                                while (nextItem != 0)
705 fschmid 896
                                                {
3954 cbradney 897
                                                        //Calculate the link points of the frames
3903 cbradney 898
                                                        double x11 = nextItem->xPos();
899
                                                        double y11 = nextItem->yPos();
3934 cbradney 900
                                                        double x12 = x11+nextItem->width();
901
                                                        double y12 = y11+nextItem->height();
3708 cbradney 902
                                                        double x1mid = x11+(x12-x11)/2;
903
                                                        double y1mid = y11+(y12-y11)/2;
814 cbradney 904
 
3934 cbradney 905
                                                        if (nextItem->rotation()!=0.000)
814 cbradney 906
                                                        {
3934 cbradney 907
                                                                FPoint tempPoint(0,0, x11, y11, nextItem->rotation(), 1, 1);
814 cbradney 908
                                                                x11=tempPoint.x();
909
                                                                y11=tempPoint.y();
3934 cbradney 910
                                                                FPoint tempPoint2(0,0, x12, y12, nextItem->rotation(), 1, 1);
3242 cbradney 911
                                                                x12=tempPoint2.x();
912
                                                                y12=tempPoint2.y();
3934 cbradney 913
                                                                FPoint tempPoint3(0,0, x1mid, y1mid, nextItem->rotation(), 1, 1);
3242 cbradney 914
                                                                x1mid=tempPoint3.x();
915
                                                                y1mid=tempPoint3.y();
814 cbradney 916
                                                        }
917
 
1485 tsoots 918
 
814 cbradney 919
                                                        double a1, b1, a2, b2;
823 fschmid 920
                                                        a1 = a2 = b1 = b2 = 0;
7994 avox 921
                                                        if (nextItem->nextInChain() != NULL)
814 cbradney 922
                                                        {
7994 avox 923
                                                                double x21 = nextItem->nextInChain()->xPos();
924
                                                                double y21 = nextItem->nextInChain()->yPos();
925
                                                                double x22 = x21+nextItem->nextInChain()->width();
926
                                                                double y22 = y21+nextItem->nextInChain()->height();
927
                                                                double x2mid = x21 + nextItem->nextInChain()->width()/2;
928
                                                                double y2mid = y21 + nextItem->nextInChain()->height()/2;
3708 cbradney 929
                                                                //x2mid = x21+(x22-x21)/2;
930
                                                                //y2mid = y21+(y22-y21)/2;
814 cbradney 931
 
7994 avox 932
                                                                if (nextItem->nextInChain()->rotation()!=0.000)
814 cbradney 933
                                                                {
7994 avox 934
                                                                        FPoint tempPoint(0,0, x21, y21, nextItem->nextInChain()->rotation(), 1, 1);
814 cbradney 935
                                                                        x21=tempPoint.x();
936
                                                                        y21=tempPoint.y();
7994 avox 937
                                                                        FPoint tempPoint2(0,0, x22, y22, nextItem->nextInChain()->rotation(), 1, 1);
3242 cbradney 938
                                                                        x22=tempPoint2.x();
939
                                                                        y22=tempPoint2.y();
7994 avox 940
                                                                        FPoint tempPoint3(0,0, x2mid, y2mid, nextItem->nextInChain()->rotation(), 1, 1);
3242 cbradney 941
                                                                        x2mid=tempPoint3.x();
942
                                                                        y2mid=tempPoint3.y();
814 cbradney 943
                                                                }
1485 tsoots 944
 
814 cbradney 945
                                                                if (x22<x11) { a1 = x11; a2 = x22; }
946
                                                                if (x21>x12) { a1 = x12; a2 = x21; }
947
                                                                if (y22<y11) { b1 = y11; b2 = y22; }
948
                                                                if (y21>y12) { b1 = y12; b2 = y21; }
949
 
950
                                                                if (x21<x12 && x21>x11) { a1 = x1mid; a2 = x2mid; }
951
                                                                if (x21<x11 && x22>x11) { a1 = x1mid; a2 = x2mid; }
952
 
953
                                                                if (y21<y12 && y21>y11) { b1 = y1mid; b2 = y2mid; }
954
                                                                if (y21<y11 && y22>y11) { b1 = y1mid; b2 = y2mid; }
955
 
956
                                                        }
3954 cbradney 957
                                                        //Draw the link frame lines
3934 cbradney 958
                                                        FPoint Start(a1-nextItem->xPos(), b1-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3903 cbradney 959
                                                        //FPoint Start = transformPoint(FPoint(nextItem->Width/2, nextItem->Height), nextItem->xPos(), nextItem->yPos(), nextItem->Rot, 1, 1);
7994 avox 960
                                                        nextItem = nextItem->nextInChain();
1957 cbradney 961
                                                        if (nextItem != NULL)
705 fschmid 962
                                                        {
3934 cbradney 963
                                                                FPoint End(a2-nextItem->xPos(), b2-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3954 cbradney 964
                                                                drawLinkFrameLine(painter, Start, End);
705 fschmid 965
                                                        }
966
                                                }
967
                                        }
456 fschmid 968
                                }
705 fschmid 969
                                else
456 fschmid 970
                                {
1957 cbradney 971
                                        while (nextItem != 0)
456 fschmid 972
                                        {
7994 avox 973
                                                if (nextItem->prevInChain() != 0)
974
                                                        nextItem = nextItem->prevInChain();
705 fschmid 975
                                                else
976
                                                        break;
456 fschmid 977
                                        }
1957 cbradney 978
                                        while (nextItem != 0)
705 fschmid 979
                                        {
3934 cbradney 980
                                                FPoint Start(nextItem->width()/2, nextItem->height(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
7994 avox 981
                                                nextItem = nextItem->nextInChain();
3954 cbradney 982
                                                //Draw the link frame indicator for a new link
983
                                                //CB unsure if we need to do this
1957 cbradney 984
                                                if (nextItem != 0)
705 fschmid 985
                                                {
3934 cbradney 986
                                                        FPoint End(nextItem->width()/2, 0, nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3954 cbradney 987
                                                        drawLinkFrameLine(painter, Start, End);
705 fschmid 988
                                                }
989
                                        }
456 fschmid 990
                                }
991
                        }
992
                        painter->setLineWidth(1);
993
                        painter->setPenOpacity(1.0);
994
                        painter->restore();
995
                }
996
                painter->end();
5373 fschmid 997
                psx->drawImage(clipx, clipy, img);
456 fschmid 998
                delete painter;
3708 cbradney 999
                painter=NULL;
456 fschmid 1000
        }
9431 fschmid 1001
/*      psx->setRenderHint(QPainter::Antialiasing, true);
9041 fschmid 1002
        if (operItemMoving || operItemResizing)
456 fschmid 1003
        {
9041 fschmid 1004
                if (operItemResizing)
2934 fschmid 1005
                {
9041 fschmid 1006
                        if (!redrawPolygon.isEmpty())
1007
                        {
9349 fschmid 1008
                                if (m_MouseButtonPressed && (Doc->appMode == modeDrawFreehandLine))
1009
                                {
1010
                                        psx->resetMatrix();
1011
                                        QPoint out = contentsToViewport(QPoint(0, 0));
1012
                                        psx->translate(out.x(), out.y());
1013
                                        psx->translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
1014
                                        psx->scale(Scale, Scale);
1015
                                        psx->setBrush(Qt::NoBrush);
1016
                                        psx->setPen(QPen(Qt::black, 1.0 / Scale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
1017
                                        psx->drawPolyline(redrawPolygon);
1018
                                        redrawPolygon.clear();
1019
                                }
1020
                                else
1021
                                {
1022
                                        QColor drawColor = qApp->palette().color(QPalette::Active, QColorGroup::Highlight);
1023
                                        psx->setPen(QPen(drawColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
1024
                                        drawColor.setAlpha(64);
1025
                                        psx->setBrush(drawColor);
1026
                                        psx->drawPolygon(redrawPolygon);
1027
                                        redrawPolygon.clear();
1028
                                }
9041 fschmid 1029
                        }
8994 fschmid 1030
                }
1031
                else
1032
                {
1033
                        if (Doc->m_Selection->count() != 0)
8770 fschmid 1034
                        {
8994 fschmid 1035
                                uint selectedItemCount = Doc->m_Selection->count();
1036
                                PageItem *currItem = Doc->m_Selection->itemAt(0);
1037
                                if (selectedItemCount < moveWithBoxesOnlyThreshold)
8770 fschmid 1038
                                {
9343 fschmid 1039
                                        for (uint cu = 0; cu < selectedItemCount; cu++)
8770 fschmid 1040
                                        {
9343 fschmid 1041
                                                currItem = Doc->m_Selection->itemAt(cu);
1042
                                                psx->resetMatrix();
1043
                                                QPoint out = contentsToViewport(QPoint(0, 0));
1044
                                                psx->translate(out.x(), out.y());
9349 fschmid 1045
                                                psx->translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
9343 fschmid 1046
                                                Transform(currItem, psx);
1047
                                                psx->setBrush(Qt::NoBrush);
1048
                                                psx->setPen(QPen(Qt::black, 1.0 / Scale, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
1049
                                                if (selectedItemCount < moveWithFullOutlinesThreshold)
8770 fschmid 1050
                                                {
9343 fschmid 1051
                                                        if (!(currItem->asLine()))
1052
                                                                currItem->DrawPolyL(psx, currItem->Clip);
1053
                                                        else
8770 fschmid 1054
                                                        {
9343 fschmid 1055
                                                                if (currItem->asLine())
8994 fschmid 1056
                                                                {
9343 fschmid 1057
                                                                        int lw2 = 1;
1058
                                                                        int lw = 1;
1059
                                                                        Qt::PenCapStyle le = Qt::FlatCap;
1060
                                                                        if (currItem->NamedLStyle.isEmpty())
1061
                                                                        {
1062
                                                                                lw2 = qRound(currItem->lineWidth()  / 2.0);
1063
                                                                                lw = qRound(qMax(currItem->lineWidth(), 1.0));
1064
                                                                                le = currItem->PLineEnd;
1065
                                                                        }
1066
                                                                        else
1067
                                                                        {
1068
                                                                                multiLine ml = Doc->MLineStyles[currItem->NamedLStyle];
1069
                                                                                lw2 = qRound(ml[ml.size()-1].Width  / 2.0);
1070
                                                                                lw = qRound(qMax(ml[ml.size()-1].Width, 1.0));
1071
                                                                                le = static_cast<Qt::PenCapStyle>(ml[ml.size()-1].LineEnd);
1072
                                                                        }
1073
                                                                        if (le != Qt::FlatCap)
1074
                                                                                psx->drawRect(-lw2, -lw2, qRound(currItem->width())+lw, lw);
1075
                                                                        else
1076
                                                                                psx->drawRect(-1, -lw2, qRound(currItem->width()), lw);
8994 fschmid 1077
                                                                }
8770 fschmid 1078
                                                        }
1079
                                                }
9343 fschmid 1080
                                                else
1081
                                                        psx->drawRect(0, 0, static_cast<int>(currItem->width())+1, static_cast<int>(currItem->height())+1);
8770 fschmid 1082
                                        }
1083
                                }
1084
                                else
8994 fschmid 1085
                                {
1086
                                        double gx, gy, gw, gh;
1087
                                        Doc->m_Selection->setGroupRect();
1088
                                        getGroupRectScreen(&gx, &gy, &gw, &gh);
1089
                                        QPoint out = contentsToViewport(QPoint(0, 0));
9327 fschmid 1090
                                        psx->resetMatrix();
9041 fschmid 1091
                                        psx->translate(-out.x(), -out.y());
8994 fschmid 1092
                                        psx->translate(qRound(gx), qRound(gy));
1093
                                        psx->scale(Scale, Scale);
1094
                                        psx->drawRect(QRect(0, 0, qRound(gw), qRound(gh)));
1095
                                }
8770 fschmid 1096
                        }
2934 fschmid 1097
                }
8770 fschmid 1098
        }
1099
        else
9431 fschmid 1100
        { */
9434 fschmid 1101
                if ((Doc->m_Selection->count() != 0) && !(operItemMoving || operItemResizing) && (Doc->appMode != modeDrawBezierLine))
456 fschmid 1102
                {
8770 fschmid 1103
                        PageItem *currItem = Doc->m_Selection->itemAt(0);
9431 fschmid 1104
                        if ((Doc->EditClip) && (currItem->isSelected()) && (!specialRendering))
8770 fschmid 1105
                        {
9041 fschmid 1106
                                if (EditContour)
1107
                                        MarkClip(psx, currItem, currItem->ContourLine, true);
1108
                                else
1109
                                        MarkClip(psx, currItem, currItem->PoLine, true);
1110
                        }
8770 fschmid 1111
                        else
1112
                        {
9041 fschmid 1113
                                if (Doc->m_Selection->isMultipleSelection())
1114
                                {
9477 fschmid 1115
 
9431 fschmid 1116
                                        psx->resetMatrix();
9343 fschmid 1117
                                        QPoint out = contentsToViewport(QPoint(0, 0));
9431 fschmid 1118
                                        psx->translate(out.x(), out.y());
1119
                                        psx->translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
9477 fschmid 1120
                                        if (Doc->m_Selection->count() != 0)
1121
                                        {
1122
                                                uint docSelectionCount = Doc->m_Selection->count();
1123
                                                PageItem *currItem;
1124
                                                for (uint a=0; a<docSelectionCount; ++a)
1125
                                                {
1126
                                                        currItem = Doc->m_Selection->itemAt(a);
1127
                                                        psx->save();
1128
                                                        Transform(currItem, psx);
1129
                                                        currItem->paintObj(psx);
1130
                                                        psx->restore();
1131
                                                }
1132
                                        }
1133
                                        psx->resetMatrix();
1134
                                        psx->translate(out.x(), out.y());
1135
                                        psx->translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
9041 fschmid 1136
                                        double x, y, w, h;
1137
                                        Doc->m_Selection->setGroupRect();
9431 fschmid 1138
                                        Doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1139
                                        x *= Scale;
1140
                                        y *= Scale;
1141
                                        w *= Scale;
1142
                                        h *= Scale;
9041 fschmid 1143
                                        psx->setPen(QPen(Qt::red, 1, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
1144
                                        psx->setBrush(Qt::NoBrush);
1145
                                        psx->drawRect(QRectF(x, y, w, h));
1146
                                        psx->setBrush(Qt::red);
1147
                                        psx->setPen(QPen(Qt::red, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
1148
                                        psx->drawRect(QRectF(x+w-6, y+h-6, 6, 6));
1149
                                        psx->drawRect(QRectF(x+w/2 - 3, y+h-6, 6, 6));
1150
                                        psx->drawRect(QRectF(x+w/2 - 3, y, 6, 6));
1151
                                        psx->drawRect(QRectF(x+w-6, y+h/2 - 3, 6, 6));
1152
                                        psx->drawRect(QRectF(x+w-6, y, 6, 6));
1153
                                        psx->drawRect(QRectF(x, y, 6, 6));
1154
                                        psx->drawRect(QRectF(x, y+h/2 - 3, 6, 6));
1155
                                        psx->drawRect(QRectF(x, y+h-6, 6, 6));
1156
                                }
1157
                                else
9343 fschmid 1158
                                {
1159
                                        psx->resetMatrix();
1160
                                        QPoint out = contentsToViewport(QPoint(0, 0));
1161
                                        psx->translate(out.x(), out.y());
9349 fschmid 1162
                                        psx->translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
9343 fschmid 1163
                                        Transform(currItem, psx);
1164
                                        currItem->paintObj(psx);
1165
                                }
9041 fschmid 1166
                        }
456 fschmid 1167
                }
9431 fschmid 1168
/*      } */
2603 cbradney 1169
        if (Doc->appMode == modeEdit)
456 fschmid 1170
                slotDoCurs(true);
2603 cbradney 1171
        if (Doc->appMode == modeEditGradientVectors)
735 fschmid 1172
        {
4847 cbradney 1173
                PageItem *currItem = Doc->m_Selection->itemAt(0);
9391 fschmid 1174
                psx->resetMatrix();
1175
                QPoint out = contentsToViewport(QPoint(0, 0));
1176
                psx->translate(out.x(), out.y());
1177
                psx->translate(-qRound(Doc->minCanvasCoordinate.x()*Scale), -qRound(Doc->minCanvasCoordinate.y()*Scale));
1178
                Transform(currItem, psx);
1179
                psx->setPen(QPen(Qt::blue, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
1180
                psx->setBrush(Qt::NoBrush);
1181
                psx->drawLine(QPointF(currItem->GrStartX, currItem->GrStartY), QPointF(currItem->GrEndX, currItem->GrEndY));
1182
                psx->setPen(QPen(Qt::magenta, 8, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
1183
                psx->drawPoint(QPointF(currItem->GrStartX, currItem->GrStartY));
1184
                psx->drawPoint(QPointF(currItem->GrEndX, currItem->GrEndY));
735 fschmid 1185
        }
2171 fschmid 1186
        evSpon = false;
2951 fschmid 1187
        forceRedraw = false;
456 fschmid 1188
//      qDebug( "Time elapsed: %d ms", tim.elapsed() );
1189
}
1190
 
1191
void ScribusView::DrawMasterItems(ScPainter *painter, Page *page, QRect clip)
1192
{
7537 fschmid 1193
        QRect oldR;
8501 cbradney 1194
        Q3PtrStack<PageItem> groupStack;
1195
        Q3PtrStack<PageItem> groupStack2;
2877 cbradney 1196
        if (!page->MPageNam.isEmpty())
456 fschmid 1197
        {
1198
                Page* Mp = Doc->MasterPages.at(Doc->MasterNames[page->MPageNam]);
1199
                if (page->FromMaster.count() != 0)
1200
                {
3313 cbradney 1201
                        int Lnr;
1202
                        struct Layer ll;
1203
                        PageItem *currItem;
1204
                        ll.isViewable = false;
1205
                        ll.LNr = 0;
456 fschmid 1206
                        Lnr = 0;
2951 fschmid 1207
                        uint layerCount=Doc->layerCount();
2937 cbradney 1208
                        for (uint la = 0; la < layerCount; ++la)
456 fschmid 1209
                        {
1210
                                Level2Layer(Doc, &ll, Lnr);
1874 fschmid 1211
                                bool pr = true;
1212
                                if ((previewMode) && (!ll.isPrintable))
1213
                                        pr = false;
7137 fschmid 1214
                                if ((viewAsPreview) && (!ll.isPrintable))
1215
                                        pr = false;
1874 fschmid 1216
                                if ((ll.isViewable) && (pr))
456 fschmid 1217
                                {
5373 fschmid 1218
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
5375 fschmid 1219
                                                painter->beginLayer(ll.transparency, ll.blendMode);
3689 cbradney 1220
                                        uint pageFromMasterCount=page->FromMaster.count();
1221
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
456 fschmid 1222
                                        {
1957 cbradney 1223
                                                currItem = page->FromMaster.at(a);
1224
                                                if (currItem->LayerNr != ll.LNr)
456 fschmid 1225
                                                        continue;
3200 cbradney 1226
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
456 fschmid 1227
                                                        continue;
4698 cbradney 1228
                                                if ((previewMode) && (!currItem->printEnabled()))
1874 fschmid 1229
                                                        continue;
7137 fschmid 1230
                                                if ((viewAsPreview) && (!currItem->printEnabled()))
1231
                                                        continue;
7444 fschmid 1232
                                                double OldX = currItem->xPos();
1233
                                                double OldY = currItem->yPos();
1234
                                                double OldBX = currItem->BoundingX;
1235
                                                double OldBY = currItem->BoundingY;
1236
                                                if (!currItem->ChangedMasterItem)
1237
                                                {
1238
                                                        //Hack to not check for undo changes, indicate drawing only
1239
                                                        currItem->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset(), true);
1240
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
1241
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
1242
                                                }
7549 fschmid 1243
                                                oldR = currItem->getRedrawBounding(Scale);
6451 fschmid 1244
                                                if (currItem->isGroupControl)
1245
                                                {
1246
                                                        painter->save();
7549 fschmid 1247
                                                        currItem->savedOwnPage = currItem->OwnPage;
1248
                                                        currItem->OwnPage = page->pageNr();
1249
                                                        if ((clip.intersects(oldR)) && (Doc->guidesSettings.layerMarkersShown) && (Doc->layerCount() > 1))
1250
                                                                currItem->DrawObj(painter, clip);
7049 fschmid 1251
                                                        FPointArray cl = currItem->PoLine.copy();
8501 cbradney 1252
                                                        QMatrix mm;
7049 fschmid 1253
                                                        mm.translate(currItem->xPos(), currItem->yPos());
1254
                                                        mm.rotate(currItem->rotation());
1255
                                                        cl.map( mm );
1256
                                                        painter->beginLayer(1.0 - currItem->fillTransparency(), currItem->fillBlendmode(), &cl);
6451 fschmid 1257
                                                        groupStack.push(currItem->groupsLastItem);
7838 fschmid 1258
                                                        groupStack2.push(currItem);
7549 fschmid 1259
                                                        currItem->OwnPage = currItem->savedOwnPage;
7444 fschmid 1260
                                                        if (!currItem->ChangedMasterItem)
1261
                                                        {
1262
                                                                //Hack to not check for undo changes, indicate drawing only
1263
                                                                currItem->setXYPos(OldX, OldY, true);
1264
                                                                currItem->BoundingX = OldBX;
1265
                                                                currItem->BoundingY = OldBY;
1266
                                                        }
6451 fschmid 1267
                                                        continue;
1268
                                                }
4401 fschmid 1269
                                                currItem->savedOwnPage = currItem->OwnPage;
3200 cbradney 1270
                                                currItem->OwnPage = page->pageNr();
5387 avox 1271
                                                if (!evSpon || forceRedraw)
5362 avox 1272
                                                        currItem->invalid = true;
537 fschmid 1273
                                                if (clip.intersects(oldR))
8770 fschmid 1274
                                                {
8994 fschmid 1275
                                                        if (!((operItemMoving || operItemResizeInEditMode) && (currItem->isSelected())))
8770 fschmid 1276
                                                                currItem->DrawObj(painter, clip);
1277
                                                }
4401 fschmid 1278
                                                currItem->OwnPage = currItem->savedOwnPage;
1957 cbradney 1279
                                                if (!currItem->ChangedMasterItem)
456 fschmid 1280
                                                {
4644 cbradney 1281
                                                        //Hack to not check for undo changes, indicate drawing only
1282
                                                        currItem->setXYPos(OldX, OldY, true);
1957 cbradney 1283
                                                        currItem->BoundingX = OldBX;
1284
                                                        currItem->BoundingY = OldBY;
456 fschmid 1285
                                                }
6451 fschmid 1286
                                                if (groupStack.count() != 0)
1287
                                                {
1288
                                                        while (currItem == groupStack.top())
1289
                                                        {
7049 fschmid 1290
                                                                painter->endLayer();
6451 fschmid 1291
                                                                painter->restore();
7549 fschmid 1292
                                                                PageItem *cite = groupStack2.pop();
1293
                                                                double OldX = cite->xPos();
1294
                                                                double OldY = cite->yPos();
1295
                                                                double OldBX = cite->BoundingX;
1296
                                                                double OldBY = cite->BoundingY;
1297
                                                                if (!cite->ChangedMasterItem)
1298
                                                                {
1299
                                                                        //Hack to not check for undo changes, indicate drawing only
1300
                                                                        cite->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset(), true);
1301
                                                                        cite->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
1302
                                                                        cite->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
1303
                                                                }
1304
                                                                oldR = cite->getRedrawBounding(Scale);
1305
                                                                if ((clip.intersects(oldR)) && (Doc->guidesSettings.layerMarkersShown) && (Doc->layerCount() > 1))
1306
                                                                        cite->DrawObj(painter, clip);
1307
                                                                cite->OwnPage = cite->savedOwnPage;
1308
                                                                if (!currItem->ChangedMasterItem)
1309
                                                                {
1310
                                                                        //Hack to not check for undo changes, indicate drawing only
1311
                                                                        cite->setXYPos(OldX, OldY, true);
1312
                                                                        cite->BoundingX = OldBX;
1313
                                                                        cite->BoundingY = OldBY;
1314
                                                                }
6451 fschmid 1315
                                                                groupStack.pop();
1316
                                                        }
1317
                                                }
456 fschmid 1318
                                        }
3689 cbradney 1319
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
456 fschmid 1320
                                        {
1957 cbradney 1321
                                                currItem = page->FromMaster.at(a);
1322
                                                if (currItem->LayerNr != ll.LNr)
456 fschmid 1323
                                                        continue;
1957 cbradney 1324
                                                if (!currItem->isTableItem)
456 fschmid 1325
                                                        continue;
7137 fschmid 1326
                                                if ((previewMode) && (!currItem->printEnabled()))
1327
                                                        continue;
1328
                                                if ((viewAsPreview) && (!currItem->printEnabled()))
1329
                                                        continue;
3200 cbradney 1330
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
456 fschmid 1331
                                                        continue;
7444 fschmid 1332
                                                if (currItem->isGroupControl)
1333
                                                        continue;
3903 cbradney 1334
                                                double OldX = currItem->xPos();
1335
                                                double OldY = currItem->yPos();
1957 cbradney 1336
                                                double OldBX = currItem->BoundingX;
1337
                                                double OldBY = currItem->BoundingY;
1338
                                                if (!currItem->ChangedMasterItem)
456 fschmid 1339
                                                {
4644 cbradney 1340
                                                        //Hack to not check for undo changes, indicate drawing only
1341
                                                        currItem->setXYPos(OldX - Mp->xOffset() + page->xOffset(), OldY - Mp->yOffset() + page->yOffset(), true);
3200 cbradney 1342
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
1343
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
456 fschmid 1344
                                                }
7537 fschmid 1345
                                                oldR = currItem->getRedrawBounding(Scale);
537 fschmid 1346
                                                if (clip.intersects(oldR))
456 fschmid 1347
                                                {
7141 fschmid 1348
                                                        painter->save();
1349
                                                        painter->translate(currItem->xPos(), currItem->yPos());
3934 cbradney 1350
                                                        painter->rotate(currItem->rotation());
6570 fschmid 1351
                                                        if ((currItem->lineColor() != CommonStrings::None) && (currItem->lineWidth() != 0.0))
456 fschmid 1352
                                                        {
1353
                                                                QColor tmp;
1957 cbradney 1354
                                                                currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
1355
                                                                if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
456 fschmid 1356
                                                                {
4580 cbradney 1357
                                                                        painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
1957 cbradney 1358
                                                                        if (currItem->TopLine)
3934 cbradney 1359
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
1957 cbradney 1360
                                                                        if (currItem->RightLine)
3934 cbradney 1361
                                                                                painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
1957 cbradney 1362
                                                                        if (currItem->BottomLine)
3934 cbradney 1363
                                                                                painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
1957 cbradney 1364
                                                                        if (currItem->LeftLine)
3934 cbradney 1365
                                                                                painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
456 fschmid 1366
                                                                }
1367
                                                        }
1368
                                                        painter->restore();
1369
                                                }
1957 cbradney 1370
                                                if (!currItem->ChangedMasterItem)
456 fschmid 1371
                                                {
4644 cbradney 1372
                                                        //Hack to not check for undo changes, indicate drawing only
1373
                                                        currItem->setXYPos(OldX, OldY, true);
1957 cbradney 1374
                                                        currItem->BoundingX = OldBX;
1375
                                                        currItem->BoundingY = OldBY;
456 fschmid 1376
                                                }
1377
                                        }
5373 fschmid 1378
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
1379
                                                painter->endLayer();
456 fschmid 1380
                                }
1381
                                Lnr++;
1382
                        }
1383
                }
1384
        }
1385
}
1386
 
1387
void ScribusView::DrawPageItems(ScPainter *painter, QRect clip)
1388
{
705 fschmid 1389
        linkedFramesToShow.clear();
7537 fschmid 1390
        QRect oldR;
8501 cbradney 1391
        Q3PtrStack<PageItem> groupStack;
1392
        Q3PtrStack<PageItem> groupStack2;
3727 cbradney 1393
        if (Doc->Items->count() != 0)
456 fschmid 1394
        {
3313 cbradney 1395
                int Lnr=0;
1396
                struct Layer ll;
1397
                PageItem *currItem;
1398
                ll.isViewable = false;
1399
                ll.LNr = 0;
2951 fschmid 1400
                uint layerCount=Doc->layerCount();
3689 cbradney 1401
                int docCurrPageNo=static_cast<int>(Doc->currentPageNumber());
2937 cbradney 1402
                for (uint la2 = 0; la2 < layerCount; ++la2)
456 fschmid 1403
                {
1404
                        Level2Layer(Doc, &ll, Lnr);
1874 fschmid 1405
                        bool pr = true;
1406
                        if ((previewMode) && (!ll.isPrintable))
1407
                                pr = false;
7137 fschmid 1408
                        if ((viewAsPreview) && (!ll.isPrintable))
1409
                                pr = false;
1874 fschmid 1410
                        if ((ll.isViewable) && (pr))
456 fschmid 1411
                        {
5373 fschmid 1412
                                if ((layerCount > 1) || (ll.transparency != 1.0))
5375 fschmid 1413
                                        painter->beginLayer(ll.transparency, ll.blendMode);
8501 cbradney 1414
                                Q3PtrListIterator<PageItem> docItem(*Doc->Items);
3689 cbradney 1415
                                while ( (currItem = docItem.current()) != 0)
1416
                                {
2434 fschmid 1417
                                        ++docItem;
1957 cbradney 1418
                                        if (currItem->LayerNr != ll.LNr)
456 fschmid 1419
                                                continue;
4698 cbradney 1420
                                        if ((previewMode) && (!currItem->printEnabled()))
1874 fschmid 1421
                                                continue;
7137 fschmid 1422
                                        if ((viewAsPreview) && (!currItem->printEnabled()))
1423
                                                continue;
3724 cbradney 1424
                                        if ((Doc->masterPageMode()) && ((currItem->OwnPage != -1) && (currItem->OwnPage != docCurrPageNo)))
456 fschmid 1425
                                                continue;
3724 cbradney 1426
                                        if (!Doc->masterPageMode() && !currItem->OnMasterPage.isEmpty())
1781 fschmid 1427
                                        {
5685 cbradney 1428
                                                if (currItem->OnMasterPage != Doc->currentPage()->pageName())
1781 fschmid 1429
                                                        continue;
1430
                                        }
7549 fschmid 1431
                                        oldR = currItem->getRedrawBounding(Scale);
6451 fschmid 1432
                                        if (currItem->isGroupControl)
1433
                                        {
1434
                                                painter->save();
7049 fschmid 1435
                                                FPointArray cl = currItem->PoLine.copy();
8501 cbradney 1436
                                                QMatrix mm;
7049 fschmid 1437
                                                mm.translate(currItem->xPos(), currItem->yPos());
1438
                                                mm.rotate(currItem->rotation());
1439
                                                cl.map( mm );
1440
                                                painter->beginLayer(1.0 - currItem->fillTransparency(), currItem->fillBlendmode(), &cl);
6451 fschmid 1441
                                                groupStack.push(currItem->groupsLastItem);
7549 fschmid 1442
                                                groupStack2.push(currItem);
6451 fschmid 1443
                                                continue;
1444
                                        }
537 fschmid 1445
                                        if (clip.intersects(oldR))
456 fschmid 1446
                                        {
5362 avox 1447
                                                if (!evSpon || forceRedraw)
1448
                                                        currItem->invalid = true;
4704 cbradney 1449
//                                              if ((!m_MouseButtonPressed) || (Doc->EditClip))
9099 fschmid 1450
                                                if (!((operItemMoving || operItemResizeInEditMode) && (currItem->isSelected())))
8770 fschmid 1451
                                                        currItem->DrawObj(painter, clip);
5362 avox 1452
//                                              currItem->Redrawn = true;
7994 avox 1453
                                                if ((currItem->asTextFrame()) && ((currItem->nextInChain() != 0) || (currItem->prevInChain() != 0)))
705 fschmid 1454
                                                {
1957 cbradney 1455
                                                        PageItem *nextItem = currItem;
1456
                                                        while (nextItem != 0)
705 fschmid 1457
                                                        {
7994 avox 1458
                                                                if (nextItem->prevInChain() != 0)
1459
                                                                        nextItem = nextItem->prevInChain();
705 fschmid 1460
                                                                else
1461
                                                                        break;
1462
                                                        }
1957 cbradney 1463
                                                        if (linkedFramesToShow.find(nextItem) == -1)
1464
                                                                linkedFramesToShow.append(nextItem);
705 fschmid 1465
                                                }
3934 cbradney 1466
                                                if ((Doc->appMode == modeEdit) && (currItem->isSelected()) && (currItem->itemType() == PageItem::TextFrame))
456 fschmid 1467
                                                {
1764 cbradney 1468
                                                        //CB 230305 Stop redrawing the horizontal ruler if it hasnt changed when typing text!!!
3934 cbradney 1469
                                                        if ((qRound(horizRuler->ItemPos*10000) != qRound((currItem->xPos())*10000)) || (qRound(horizRuler->ItemEndPos*10000) != qRound(((currItem->xPos()+currItem->width()) )*10000)))
1764 cbradney 1470
                                                        {
5569 avox 1471
                                                                horizRuler->setItem(currItem);
4546 subik 1472
                                                                if (currItem->lineColor() != CommonStrings::None)
4580 cbradney 1473
                                                                        horizRuler->lineCorr = currItem->lineWidth() / 2.0;
1764 cbradney 1474
                                                                else
1475
                                                                        horizRuler->lineCorr = 0;
1957 cbradney 1476
                                                                horizRuler->ColGap = currItem->ColGap;
1477
                                                                horizRuler->Cols = currItem->Cols;
3988 cbradney 1478
                                                                horizRuler->Extra = currItem->textToFrameDistLeft();
1479
                                                                horizRuler->RExtra = currItem->textToFrameDistRight();
5569 avox 1480
                                                                horizRuler->First = currItem->currentStyle().firstIndent();
1481
                                                                horizRuler->Indent = currItem->currentStyle().leftMargin();
1482
                                                                double columnWidth = (currItem->width() - (currItem->columnGap() * (currItem->columns() - 1))
1483
                                                                        - currItem->textToFrameDistLeft() - currItem->textToFrameDistLeft()
1484
                                                                        - 2*horizRuler->lineCorr) / currItem->columns();
1485
                                                                horizRuler->RMargin = columnWidth - currItem->currentStyle().rightMargin();
3988 cbradney 1486
                                                                if (currItem->imageFlippedH() || (currItem->reversed()))
1764 cbradney 1487
                                                                        horizRuler->Revers = true;
1488
                                                                else
1489
                                                                        horizRuler->Revers = false;
1490
                                                                horizRuler->ItemPosValid = true;
5569 avox 1491
                                                                horizRuler->TabValues = currItem->currentStyle().tabValues();
9391 fschmid 1492
                                                                horizRuler->update();
1764 cbradney 1493
                                                        }
456 fschmid 1494
                                                }
1495
                                        }
6451 fschmid 1496
                                        if (groupStack.count() != 0)
1497
                                        {
1498
                                                while (currItem == groupStack.top())
1499
                                                {
7049 fschmid 1500
                                                        painter->endLayer();
6451 fschmid 1501
                                                        painter->restore();
7549 fschmid 1502
                                                        PageItem *cite = groupStack2.pop();
1503
                                                        oldR = cite->getRedrawBounding(Scale);
8494 fschmid 1504
                                                        if ((clip.intersects(oldR)) && (((Doc->guidesSettings.layerMarkersShown) && (Doc->layerCount() > 1)) || (cite->textFlowUsesContourLine())))
7549 fschmid 1505
                                                                cite->DrawObj(painter, clip);
6451 fschmid 1506
                                                        groupStack.pop();
1507
                                                }
1508
                                        }
456 fschmid 1509
                                }
8501 cbradney 1510
                                Q3PtrListIterator<PageItem> docItem2(*Doc->Items);
3689 cbradney 1511
                                while ( (currItem = docItem2.current()) != 0 )
1512
                                {
2538 fschmid 1513
                                        ++docItem2;
1957 cbradney 1514
                                        if (currItem->LayerNr != ll.LNr)
456 fschmid 1515
                                                continue;
1957 cbradney 1516
                                        if (!currItem->isTableItem)
456 fschmid 1517
                                                continue;
7137 fschmid 1518
                                        if ((previewMode) && (!currItem->printEnabled()))
1519
                                                continue;
1520
                                        if ((viewAsPreview) && (!currItem->printEnabled()))
1521
                                                continue;
7537 fschmid 1522
                                        oldR = currItem->getRedrawBounding(Scale);
537 fschmid 1523
                                        if (clip.intersects(oldR))
456 fschmid 1524
                                        {
7141 fschmid 1525
                                                painter->save();
1526
                                                painter->translate(currItem->xPos(), currItem->yPos());
3934 cbradney 1527
                                                painter->rotate(currItem->rotation());
6570 fschmid 1528
                                                if ((currItem->lineColor() != CommonStrings::None) && (currItem->lineWidth() != 0.0))
456 fschmid 1529
                                                {
1530
                                                        QColor tmp;
1957 cbradney 1531
                                                        currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
1532
                                                        if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
456 fschmid 1533
                                                        {
4580 cbradney 1534
                                                                painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
1957 cbradney 1535
                                                                if (currItem->TopLine)
3934 cbradney 1536
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
1957 cbradney 1537
                                                                if (currItem->RightLine)
3934 cbradney 1538
                                                                        painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
1957 cbradney 1539
                                                                if (currItem->BottomLine)
3934 cbradney 1540
                                                                        painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
1957 cbradney 1541
                                                                if (currItem->LeftLine)
3934 cbradney 1542
                                                                        painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
456 fschmid 1543
                                                        }
1544
                                                }
1545
                                                painter->restore();
1546
                                        }
1547
                                }
5373 fschmid 1548
                                if ((layerCount > 1) || (ll.transparency != 1.0))
1549
                                        painter->endLayer();
456 fschmid 1550
                        }
1551
                        Lnr++;
1552
                }
1553
        }
1554
}
1555
 
5166 fschmid 1556
void ScribusView::DrawPageMarks(ScPainter *p, Page *page, QRect clip)
456 fschmid 1557
{
1558
        p->save();
6809 fschmid 1559
        p->setAntialiasing(false);
7141 fschmid 1560
        p->translate(page->xOffset(), page->yOffset());
6809 fschmid 1561
        double lineWidth = 1.0 / Scale;
3226 cbradney 1562
        double pageHeight=page->height();
1563
        double pageWidth=page->width();
7157 fschmid 1564
        p->setFillMode(ScPainter::None);
8522 cbradney 1565
        p->setPen(Qt::black, lineWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7157 fschmid 1566
        p->drawRect(0, 0, pageWidth, pageHeight);
3962 cbradney 1567
        //Draw the margins
879 fschmid 1568
        if (Doc->guidesSettings.marginsShown)
456 fschmid 1569
        {
879 fschmid 1570
                p->setPen(Doc->guidesSettings.margColor);
1065 cbradney 1571
                if (Doc->marginColored)
456 fschmid 1572
                {
879 fschmid 1573
                        p->setBrush(Doc->guidesSettings.margColor);
3226 cbradney 1574
                        p->drawRect(0, 0, pageWidth, page->Margins.Top);
1575
                        p->drawRect(0, page->Margins.Top, page->Margins.Left, pageHeight - page->Margins.Top);
1576
                        p->drawRect(page->Margins.Left, pageHeight - page->Margins.Bottom, pageWidth - page->Margins.Right - page->Margins.Left, page->Margins.Bottom);
1577
                        p->drawRect(pageWidth - page->Margins.Right, page->Margins.Top, page->Margins.Right, pageHeight-page->Margins.Top);
456 fschmid 1578
                }
7179 fschmid 1579
//              p->setPen(Doc->guidesSettings.margColor);
1580
                p->setFillMode(ScPainter::None);
7206 fschmid 1581
                p->drawRect(page->Margins.Left, page->Margins.Top, pageWidth - page->Margins.Left - page->Margins.Right, pageHeight - page->Margins.Top - page->Margins.Bottom);
7179 fschmid 1582
//              p->drawLine(FPoint(0, page->Margins.Top), FPoint(pageWidth, page->Margins.Top));
1583
//              p->drawLine(FPoint(0, pageHeight - page->Margins.Bottom), FPoint(pageWidth, pageHeight - page->Margins.Bottom));
1584
//              p->drawLine(FPoint(page->Margins.Left, 0), FPoint(page->Margins.Left, pageHeight));
1585
//              p->drawLine(FPoint(pageWidth - page->Margins.Right, 0), FPoint(pageWidth - page->Margins.Right, pageHeight));
456 fschmid 1586
        }
3962 cbradney 1587
        //Draw the baseline grid
879 fschmid 1588
        if (Doc->guidesSettings.baseShown)
456 fschmid 1589
        {
8522 cbradney 1590
                p->setPen(Doc->guidesSettings.baseColor, lineWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
3226 cbradney 1591
                for (double yg = Doc->typographicSettings.offsetBaseGrid; yg < pageHeight; yg += Doc->typographicSettings.valueBaseGrid)
1592
                        p->drawLine(FPoint(0, yg), FPoint(pageWidth, yg));
456 fschmid 1593
        }
3962 cbradney 1594
        //Draw the grid lines
879 fschmid 1595
        if (Doc->guidesSettings.gridShown)
456 fschmid 1596
        {
8573 jghali 1597
                double lowerBx = qMax(clip.x() / Scale + Doc->minCanvasCoordinate.x() - page->xOffset(), 0.0);
1598
                double lowerBy = qMax(clip.y() / Scale + Doc->minCanvasCoordinate.y() - page->yOffset(), 0.0);
8562 jghali 1599
                double highBx = qMin(lowerBx + clip.width() / Scale, pageWidth);
1600
                double highBy = qMin(lowerBy + clip.height() / Scale, pageHeight);
456 fschmid 1601
                if (Scale > 0.49)
1602
                {
1603
                        double i,start;
879 fschmid 1604
                        i = Doc->guidesSettings.majorGrid;
8522 cbradney 1605
                        p->setPen(Doc->guidesSettings.majorColor, lineWidth, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5233 fschmid 1606
                        start=floor(lowerBy/i);
456 fschmid 1607
                        start*=i;
5233 fschmid 1608
                        for (double b = start; b <= highBy; b+=i)
5166 fschmid 1609
                        {
8573 jghali 1610
                                p->drawLine(FPoint(qMax(lowerBx, 0.0), b), FPoint(qMin(pageWidth, highBx), b));
5166 fschmid 1611
                        }
5233 fschmid 1612
                        start=floor(lowerBx/i);
456 fschmid 1613
                        start*=i;
5233 fschmid 1614
                        for (double b = start; b <= highBx; b+=i)
5166 fschmid 1615
                        {
8573 jghali 1616
                                p->drawLine(FPoint(b, qMax(lowerBy, 0.0)), FPoint(b, qMin(pageHeight, highBy)));
5166 fschmid 1617
                        }
879 fschmid 1618
                        i = Doc->guidesSettings.minorGrid;
8522 cbradney 1619
                        p->setPen(Doc->guidesSettings.minorColor, lineWidth, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin);
5233 fschmid 1620
                        start=floor(lowerBy/i);
456 fschmid 1621
                        start*=i;
5233 fschmid 1622
                        for (double b = start; b <= highBy; b+=i)
5166 fschmid 1623
                        {
8573 jghali 1624
                                p->drawLine(FPoint(qMax(lowerBx, 0.0), b), FPoint(qMin(pageWidth, highBx), b));
5166 fschmid 1625
                        }
5233 fschmid 1626
                        start=floor(lowerBx/i);
456 fschmid 1627
                        start*=i;
5233 fschmid 1628
                        for (double b = start; b <= highBx; b+=i)
5166 fschmid 1629
                        {
8573 jghali 1630
                                p->drawLine(FPoint(b, qMax(lowerBy, 0.0)), FPoint(b, qMin(pageHeight, highBy)));
5166 fschmid 1631
                        }
456 fschmid 1632
                }
1633
        }
3962 cbradney 1634
        //Draw the guides
879 fschmid 1635
        if (Doc->guidesSettings.guidesShown)
5087 subik 1636
                page->guides.drawPage(p, Doc, lineWidth);
7285 fschmid 1637
        if (Doc->currentPage() == page)
1638
        {
8501 cbradney 1639
                p->setPen(Prefs->DPageBorderColor, 2 / Scale, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7285 fschmid 1640
                p->drawRect(0, 0, pageWidth, pageHeight);
1641
        }
6809 fschmid 1642
        p->setAntialiasing(true);
1643
 
456 fschmid 1644
        p->restore();
1645
}
1646
 
6583 fschmid 1647
void ScribusView::enterEvent(QEvent *)
1648
{
1649
        if (!m_MouseButtonPressed)
1650
        {
1651
                switch (Doc->appMode)
1652
                {
1653
                        case modeDrawShapes:
9380 fschmid 1654
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawFrame.xpm")));
6583 fschmid 1655
                                break;
1656
                        case modeDrawPicture:
9380 fschmid 1657
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawImageFrame.xpm")));
6583 fschmid 1658
                                break;
1659
                        case modeDrawText:
9380 fschmid 1660
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawTextFrame.xpm")));
6583 fschmid 1661
                                break;
1662
                        case modeDrawTable:
9380 fschmid 1663
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawTable.xpm")));
6583 fschmid 1664
                                break;
1665
                        case modeDrawRegularPolygon:
9380 fschmid 1666
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawPolylineFrame.xpm")));
6583 fschmid 1667
                                break;
7378 fschmid 1668
                        case modeDrawLine:
1669
                        case modeDrawBezierLine:
9380 fschmid 1670
                                qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
7378 fschmid 1671
                                break;
1672
                        case modeDrawFreehandLine:
9380 fschmid 1673
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawFreeLine.png"), 0, 32));
7378 fschmid 1674
                                break;
6583 fschmid 1675
                        case modeMagnifier:
7448 fschmid 1676
                                if (Magnify)
9380 fschmid 1677
                                        qApp->changeOverrideCursor(QCursor(loadIcon("LupeZ.xpm")));
7448 fschmid 1678
              &