Subversion Repositories Scribus

Rev

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