Subversion Repositories Scribus

Rev

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