Subversion Repositories Scribus

Rev

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