Subversion Repositories Scribus

Rev

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