Subversion Repositories Scribus

Rev

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

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