Subversion Repositories Scribus

Rev

Rev 404 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          page.cpp  -  description
3
                             -------------------
4
    begin                : Sat Apr 7 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 "page.h"
19
#include "page.moc"
20
#include "pageitem.h"
21
#include "serializer.h"
22
#include "scribusXml.h"
132 Franz 23
#include "scribus.h"
232 Franz 24
#include "insertTable.h"
265 Franz 25
#include "mpalette.h"
128 Franz 26
 
27
#if (_MSC_VER >= 1200)
28
 #include "win-config.h"
29
#else
30
 #include "config.h"
31
#endif
32
 
3 paul 33
#include <qapplication.h>
34
#include <qcolor.h>
35
#include <qrect.h>
36
#include <qpointarray.h>
37
#include <qregion.h>
38
#include <qcursor.h>
39
#include <qimage.h>
40
#include <qfileinfo.h>
41
#include <qfile.h>
42
#include <qtextstream.h>
43
#include <qcstring.h>
44
#include <qdragobject.h>
45
#include <qurl.h>
46
#include <cmath>
47
#include <cstdio>
48
#include <cstdlib>
49
#include <qbitmap.h>
50
#include <qwmatrix.h>
51
#include <qpopupmenu.h>
125 Franz 52
#include <qbuttongroup.h>
53
#include <qlayout.h>
214 Franz 54
#include <qevent.h>
55
#include <qeventloop.h>
56
#include <qprocess.h>
237 Franz 57
#include <qscrollbar.h>
356 Franz 58
#include <qmessagebox.h>
239 Franz 59
#include <unistd.h>
272 Franz 60
#if QT_VERSION  > 0x030102
61
        #define SPLITVC SplitHCursor
62
        #define SPLITHC SplitVCursor
63
#else
64
        #define SPLITVC SplitVCursor
65
        #define SPLITHC SplitHCursor
66
#endif
3 paul 67
 
284 Franz 68
#include <unistd.h>
69
 
3 paul 70
#ifdef HAVE_TIFF
71
        #include <tiffio.h>
72
#endif
73
#ifdef HAVE_CMS
44 Franz 74
        #include CMS_INC
3 paul 75
#endif
76
extern int PolyC;
77
extern int PolyFd;
80 Franz 78
extern double PolyF;
3 paul 79
extern bool PolyS;
80 Franz 80
extern double PolyR;
294 Franz 81
extern double UmReFaktor;
3 paul 82
extern ProfilesL InputProfiles;
83
extern QPixmap loadIcon(QString nam);
80 Franz 84
extern double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
3 paul 85
#ifdef HAVE_CMS
86
QImage ProofPict(QImage *Im, QString Prof, int Rend, cmsHPROFILE emPr=0);
87
#else
88
QImage ProofPict(QImage *Im, QString Prof, int Rend);
89
#endif
80 Franz 90
extern FPointArray RegularPolygonF(double w, double h, uint c, bool star, double factor, double rota);
3 paul 91
extern QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs);
80 Franz 92
extern double xy2Deg(double x, double y);
3 paul 93
extern void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4);
94
extern void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level);
95 Franz 95
extern FPoint GetMaxClipF(FPointArray Clip);
125 Franz 96
extern void WordAndPara(PageItem* b, int *w, int *p, int *c, int *wN, int *pN, int *cN);
132 Franz 97
extern ScribusApp* ScApp;
204 Franz 98
extern int callGS(const QStringList & args);
3 paul 99
 
100
Page::Page(QWidget *pa, int x, int y, int b, int h, ScribusDoc *doc, QScrollView *view)
217 Franz 101
                : QWidget(pa, "ps", WRepaintNoErase)
3 paul 102
{
103
        resize(b, h);
104
        move(x, y);
105
        setEraseColor(doc->papColor);
106
        doku = doc;
107
        Anz = view;
108
        Items.clear();
109
        Items.setAutoDelete(true);
110
        Margins.Top = 9;
111
        Margins.Left = 9;
112
        Margins.Right = 9;
113
        Margins.Bottom = 40;
114
        SelItem.clear();
115
        ClRe = -1;
116
        ClRe2 = -1;
117
        setAcceptDrops(true);
118
        emit DocChanged();
119
        doku->DragP = false;
227 Franz 120
        doku->leaveDrag = false;
3 paul 121
        Imoved = false;
122
        Mpressed = false;
123
        MidButt = false;
124
        HaveSelRect = false;
125
        PageNam = "";
126
        LeftPg = false;
127
        Magnify = false;
128
        FirstPoly = true;
129
        EdPoints = true;
130
        MoveSym = false;
131
        GroupSel = false;
132
        DraggedGroup = false;
133
        GroupX = 0;
134
        GroupY = 0;
135
        GroupW = 0;
136
        GroupH = 0;
137
        DrHY = -1;
138
        DrVX = -1;
139
        XGuides.clear();
140
        YGuides.clear();
141
        GyM = 0;
142
        MoveGY = false;
143
        GxM = 0;
144
        MoveGX = false;
266 Franz 145
        CursVis = false;
340 Franz 146
        EditContour = false;
3 paul 147
}
148
 
149
void Page::dragLeaveEvent(QDragLeaveEvent *e)
150
{
151
        if (DraggedGroup)
167 Franz 152
        {
80 Franz 153
                double gx, gy, gw, gh;
3 paul 154
                getGroupRectScreen(&gx, &gy, &gw, &gh);
155
                repaint(static_cast<int>(gx), static_cast<int>(gy), static_cast<int>(gw), static_cast<int>(gh));
156
                DraggedGroup = false;
167 Franz 157
        }
3 paul 158
}
159
 
160
void Page::dragEnterEvent(QDragEnterEvent *e)
161
{
162
        QString text;
163
        e->accept(QTextDrag::canDecode(e));
164
        if (QTextDrag::decode(e, text))
167 Franz 165
        {
80 Franz 166
                double gx, gy, gw, gh;
3 paul 167
                QUrl ur(text);
168
                QFileInfo fi = QFileInfo(ur.path());
217 Franz 169
                ScriXmlDoc *ss = new ScriXmlDoc();
3 paul 170
                if (fi.exists())
171
                        text = ur.path();
217 Franz 172
                if(ss->ReadElemHeader(text,fi.exists(), &gx, &gy, &gw, &gh))
167 Franz 173
                {
3 paul 174
                        GroupX = e->pos().x() / doku->Scale;
175
                        GroupY = e->pos().y() / doku->Scale;
176
                        GroupW = gw;
177
                        GroupH = gh;
178
                        DraggedGroup = true;
179
                        GroupSel = false;
167 Franz 180
                }
3 paul 181
                delete ss;
182
                setActiveWindow();
183
                raise();
228 Franz 184
                ScApp->newActWin(doku->WinHan);
3 paul 185
                SeleItemPos(e->pos());
167 Franz 186
        }
3 paul 187
}
188
 
189
void Page::dragMoveEvent(QDragMoveEvent *e)
190
{
191
        QString text;
192
        PageItem *b;
193
        bool img;
194
        e->accept(QTextDrag::canDecode(e));
195
        if (QTextDrag::decode(e, text))
167 Franz 196
        {
197
                if (DraggedGroup)
3 paul 198
                {
80 Franz 199
                        double gx, gy, gw, gh;
3 paul 200
                        getGroupRectScreen(&gx, &gy, &gw, &gh);
201
                        repaint(static_cast<int>(gx), static_cast<int>(gy), static_cast<int>(gw), static_cast<int>(gh));
202
                        GroupX = e->pos().x() / doku->Scale;
203
                        GroupY = e->pos().y() / doku->Scale;
204
                        paintGroupRect(false);
205
                        emit MousePos(GroupX, GroupY);
206
                        emit Hrule(e->pos().x()+Anz->childX(parentWidget()));
207
                        emit Vrule(e->pos().y()+Anz->childY(parentWidget()));
208
                        return;
167 Franz 209
                }
3 paul 210
                QUrl ur(text);
211
                QFileInfo fi = QFileInfo(ur.path());
212
                QString ext = fi.extension(false).upper();
213
                QStrList imfo = QImageIO::inputFormats();
214
                if (ext == "JPG")
215
                        ext = "JPEG";
216
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
217
                if (!SeleItemPos(e->pos()))
167 Franz 218
                {
3 paul 219
                        if (SelItem.count() != 0)
220
                                Deselect(true);
167 Franz 221
                }
3 paul 222
                else
167 Franz 223
                {
3 paul 224
                        b = SelItem.at(0);
225
                        if (img)
167 Franz 226
                        {
3 paul 227
                                if (b->PType != 2)
228
                                        Deselect(true);
167 Franz 229
                        }
3 paul 230
                        else
167 Franz 231
                        {
3 paul 232
                                if (b->PType != 4)
233
                                        Deselect(true);
234
                        }
235
                }
167 Franz 236
        }
3 paul 237
}
238
 
239
void Page::dropEvent(QDropEvent *e)
240
{
241
        QString text;
242
        PageItem *b;
75 Franz 243
        bool img = false;
3 paul 244
        struct Pti *hg;
245
        uint a;
246
        int re;
275 Franz 247
        e->accept(QTextDrag::canDecode(e));
3 paul 248
        if (QTextDrag::decode(e, text))
167 Franz 249
        {
3 paul 250
                QUrl ur(text);
251
                QFileInfo fi = QFileInfo(ur.path());
252
                QString ext = fi.extension(false).upper();
253
                QStrList imfo = QImageIO::inputFormats();
254
                if (ext == "JPG")
255
                        ext = "JPEG";
98 Franz 256
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="PDF")||(ext=="TIF"));
97 Franz 257
                if ((fi.exists()) && (img) && (!SeleItemPos(e->pos())))
167 Franz 258
                {
97 Franz 259
                        int z = PaintPict(qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), 1, 1);
260
                        b = Items.at(z);
217 Franz 261
                        LoadPict(ur.path(), b->ItemNr);
97 Franz 262
                        b->Width = static_cast<double>(b->pixm.width());
263
                        b->Height = static_cast<double>(b->pixm.height());
264
                        b->OldB2 = b->Width;
265
                        b->OldH2 = b->Height;
266
                        UpdateClip(b);
267
                        emit DocChanged();
268
                        update();
269
                        return;
167 Franz 270
                }
3 paul 271
                if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
167 Franz 272
                {
3 paul 273
                        b = SelItem.at(0);
274
                        if (b->PType == 2)
167 Franz 275
                        {
276
                                if ((fi.exists()) && (img))
3 paul 277
                                {
217 Franz 278
                                        LoadPict(ur.path(), b->ItemNr);
279
                                        update();
3 paul 280
                                }
167 Franz 281
                        }
3 paul 282
                        if (b->PType == 4)
167 Franz 283
                        {
3 paul 284
                                if ((b->BackBox != 0) && (b->Ptext.count() == 0))
285
                                        return;
286
                                if ((fi.exists()) && (!img) && (fi.size() < 500000))
167 Franz 287
                                {
217 Franz 288
                                        Serializer *ss = new Serializer(ur.path());
289
                                        if (ss->Read())
290
                                        {
24 Franz 291
                                                int st = doku->CurrentABStil;
217 Franz 292
                                                ss->GetText(b, st, doku->Vorlagen[st].Font, doku->Vorlagen[st].FontSize);
3 paul 293
                                                emit DocChanged();
217 Franz 294
                                        }
295
                                        delete ss;
296
                                        update();
297
                                }
3 paul 298
                                else
167 Franz 299
                                {
3 paul 300
                                        slotDoCurs(false);
301
                                        slotSetCurs(e->pos().x(), e->pos().y());
302
                                        if (text.startsWith("<SCRIBUSELEM"))
303
                                                return;
304
                                        for (a=0; a<text.length(); ++a)
167 Franz 305
                                        {
3 paul 306
                                                hg = new Pti;
307
                                                hg->ch = text.at(a);
68 Franz 308
                                                if (hg->ch == QChar(10))
217 Franz 309
                                                        hg->ch = QChar(13);
139 Franz 310
                                                if (hg->ch == QChar(4))
217 Franz 311
                                                        hg->ch = QChar(9);
3 paul 312
                                                if (hg->ch == QChar(5))
68 Franz 313
                                                        hg->ch = QChar(13);
3 paul 314
                                                hg->cfont = b->IFont;
315
                                                hg->csize = b->ISize;
68 Franz 316
                                                hg->ccolor = b->TxtFill;
317
                                                hg->cshade = b->ShTxtFill;
318
                                                hg->cstroke = b->TxtStroke;
319
                                                hg->cshade2 = b->ShTxtStroke;
320
                                                hg->cselect = false;
321
                                                hg->cscale = b->TxtScale;
3 paul 322
                                                hg->cextra = 0;
323
                                                hg->cstyle = 0;
324
                                                hg->cab = 0;
325
                                                hg->xp = 0;
326
                                                hg->yp = 0;
327
                                                hg->PRot = 0;
328
                                                hg->PtransX = 0;
329
                                                hg->PtransY = 0;
330
                                                b->Ptext.insert(b->CPos, hg);
217 Franz 331
                                                b->CPos += 1;
167 Franz 332
                                        }
3 paul 333
                                        emit DocChanged();
334
                                        update();
335
                                }
336
                        }
167 Franz 337
                }
3 paul 338
                else
167 Franz 339
                {
335 Franz 340
                        uint ac = Items.count();
227 Franz 341
                        if ((!img) && (doku->DraggedElem == 0))
342
                                emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
279 Franz 343
                        else
167 Franz 344
                        {
345
                                if (doku->DraggedElem != 0)
3 paul 346
                                {
227 Franz 347
                                        if (!doku->leaveDrag)
167 Franz 348
                                        {
227 Franz 349
                                                QPopupMenu *pmen = new QPopupMenu();
350
                                                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
351
                                                pmen->insertItem( tr("Copy Here"));
352
                                                pmen->insertItem( tr("Move Here"));
353
                                                pmen->insertItem( tr("Cancel"));
354
                                                re = pmen->indexOf(pmen->exec(QCursor::pos()));
355
                                                delete pmen;
356
                                        }
357
                                        else
358
                                                re = 1;
344 Franz 359
                                        if ((re == 2) || (re == -1))
227 Franz 360
                                        {
361
                                                update();
362
                                                return;
363
                                        }
364
                                        if ((re == 1) || (doku->leaveDrag))
365
                                        {
228 Franz 366
                                                QPtrList<PageItem> pasted;
367
                                                emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
368
                                                for (uint as = ac; as < doku->ActPage->Items.count(); ++as)
369
                                                {
370
                                                        pasted.append(Items.at(as));
371
                                                }
3 paul 372
                                                doku->DraggedElem->OwnPage->SelItem.clear();
373
                                                for (uint dre=0; dre<doku->DragElements.count(); ++dre)
167 Franz 374
                                                {
227 Franz 375
                                                        doku->DraggedElem->OwnPage->SelItem.append(doku->DraggedElem->OwnPage->Items.at(doku->DragElements[dre]));
167 Franz 376
                                                }
228 Franz 377
                                                PageItem* bb;
378
                                                int fin;
379
                                                for (uint dre=0; dre<doku->DragElements.count(); ++dre)
380
                                                {
381
                                                        bb = pasted.at(dre);
382
                                                        b = doku->DraggedElem->OwnPage->SelItem.at(dre);
383
                                                        if ((b->PType == 4) && ((b->NextBox != 0) || (b->BackBox != 0)))
384
                                                        {
385
                                                                if (b->BackBox != 0)
386
                                                                {
387
                                                                        bb->BackBox = b->BackBox;
388
                                                                        fin = doku->DraggedElem->OwnPage->SelItem.find(b->BackBox);
389
                                                                        if (fin != -1)
390
                                                                                bb->BackBox = pasted.at(fin);
391
                                                                        bb->BackBox->NextBox = bb;
392
                                                                }
393
                                                                if (b->NextBox != 0)
394
                                                                {
395
                                                                        bb->NextBox = b->NextBox;
396
                                                                        fin = doku->DraggedElem->OwnPage->SelItem.find(b->NextBox);
397
                                                                        if (fin != -1)
398
                                                                                bb->NextBox = pasted.at(fin);
399
                                                                        bb->NextBox->BackBox = bb;
400
                                                                }
401
                                                        }
402
                                                }
403
                                                for (uint dre=0; dre<doku->DragElements.count(); ++dre)
404
                                                {
405
                                                        b = doku->DraggedElem->OwnPage->SelItem.at(dre);
406
                                                        b->NextBox = 0;
407
                                                        b->BackBox = 0;
408
                                                }
409
                                                pasted.clear();
3 paul 410
                                                doku->DraggedElem->OwnPage->DeleteItem();
411
                                        }
167 Franz 412
                                }
228 Franz 413
                                if ((!img) && ((re == 0)))
227 Franz 414
                                        emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
3 paul 415
                                doku->DraggedElem = 0;
416
                                doku->DragElements.clear();
335 Franz 417
                                doku->ActPage->SelItem.clear();
418
                                for (uint as = ac; as < doku->ActPage->Items.count(); ++as)
419
                                {
420
                                        doku->ActPage->SelectItemNr(as);
421
                                }
125 Franz 422
                                update();
282 Franz 423
                        }
3 paul 424
                }
167 Franz 425
        }
3 paul 426
}
227 Franz 427
void Page::leaveEvent(QEvent *)
428
{
228 Franz 429
        if (BlockLeave)
430
                return;
227 Franz 431
        if (!Mpressed)
432
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
433
        else
434
        {
435
                if ((SelItem.count() != 0) && (Mpressed) && (!doku->DragP) && (doku->AppMode == 1))
436
                {
437
                        PageItem *b = SelItem.at(0);
438
                        if ((b->Locked) || (b->Sizing))
439
                                return;
440
                        doku->DragP = true;
441
                        doku->leaveDrag = true;
442
                        doku->DraggedElem = b;
443
                        doku->DragElements.clear();
444
                        for (uint dre=0; dre<SelItem.count(); ++dre)
445
                                doku->DragElements.append(SelItem.at(dre)->ItemNr);
446
                        ScriXmlDoc *ss = new ScriXmlDoc();
447
                        QDragObject *dr = new QTextDrag(ss->WriteElem(&SelItem, doku), this);
448
                        dr->setPixmap(loadIcon("DragPix.xpm"));
449
                        dr->drag();
450
                        delete ss;
451
                        doku->DragP = false;
452
                        doku->leaveDrag = false;
453
                        Mpressed = false;
454
                        doku->DraggedElem = 0;
455
                        doku->DragElements.clear();
456
                }
457
        }
458
}
3 paul 459
 
68 Franz 460
void Page::paintEvent(QPaintEvent *e)
3 paul 461
{
377 Franz 462
        if (doku->loading)
463
                return;
68 Franz 464
        QRect vr = ViewReg().boundingRect().intersect(e->rect());
465
        if ((vr.width() < 1) || (vr.height() < 1))
466
                return;
266 Franz 467
        if (doku->AppMode == 7)
468
                slotDoCurs(false);
386 Franz 469
        bool sp = e->spontaneous();
68 Franz 470
        QPixmap pgPix(vr.width(), vr.height());
471
        ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
214 Franz 472
        painter->clear(doku->papColor);
68 Franz 473
        painter->translate(0.5, 0.5);
474
        if (doku->Before)
108 Franz 475
                DrawPageMarks(painter, vr);
268 Franz 476
//      QTime tim;
477
//      tim.start();
386 Franz 478
        DrawPageItems(painter, vr, sp);
268 Franz 479
//      qDebug( "Time elapsed: %d ms", tim.elapsed() );
68 Franz 480
        if (!doku->Before)
108 Franz 481
                DrawPageMarks(painter, vr);
68 Franz 482
        painter->end();
483
        bitBlt( this, vr.x(), vr.y(), &pgPix, 0, 0, pgPix.width(), pgPix.height() );
3 paul 484
        QPainter p;
68 Franz 485
        p.begin(this);
486
        p.setPen(QColor(0, 0, 0));
487
        p.setBrush(NoBrush);
488
        p.drawRect(0, 0, width(), height());
217 Franz 489
        p.end();
167 Franz 490
        if (SelItem.count() != 0)
217 Franz 491
        {
68 Franz 492
                PageItem *b = SelItem.at(0);
493
                b->paintObj(e->rect());
494
                if ((doku->EditClip) && (b->Select))
495
                        MarkClip(b);
496
                if (GroupSel)
167 Franz 497
                {
68 Franz 498
                        setGroupRect();
499
                        paintGroupRect();
500
                }
167 Franz 501
        }
68 Franz 502
        delete painter;
266 Franz 503
        if (doku->AppMode == 7)
504
                slotDoCurs(true);
68 Franz 505
}
506
 
108 Franz 507
void Page::DrawPageMarks(ScPainter *p, QRect rd)
68 Franz 508
{
80 Franz 509
        double b;
68 Franz 510
        if ((rd.width() == 0) || (rd.height() == 0))
511
                return;
80 Franz 512
        double lw = 1.0 / doku->Scale;
68 Franz 513
        p->setZoomFactor(doku->Scale);
514
        QWMatrix ma = p->worldMatrix();
515
        QWMatrix ma2 = p->worldMatrix();
516
        ma.translate(-rd.x(), -rd.y());
517
        p->setWorldMatrix(ma);
518
        p->setLineWidth(lw);
243 Franz 519
        if (ScApp->Prefs.MarginsShown)
167 Franz 520
        {
68 Franz 521
                p->setPen(doku->margColor);
3 paul 522
                if (doku->RandFarbig)
167 Franz 523
                {
68 Franz 524
                        p->setBrush(doku->margColor);
525
                        p->drawRect(0, 0, width()/doku->Scale, Margins.Top);
526
                        p->drawRect(0, Margins.Top, Margins.Left, height()/doku->Scale-Margins.Top);
167 Franz 527
                        p->drawRect(Margins.Left, height()/doku->Scale-Margins.Bottom,
217 Franz 528
                                    width()/doku->Scale-Margins.Right-Margins.Left, Margins.Bottom);
68 Franz 529
                        p->drawRect(width()/doku->Scale-Margins.Right, Margins.Top, Margins.Right, height()/doku->Scale);
167 Franz 530
                }
68 Franz 531
                p->setPen(doku->margColor);
532
                p->drawLine(FPoint(0, Margins.Top), FPoint(width()/doku->Scale, Margins.Top));
167 Franz 533
                p->drawLine(FPoint(0, height()/doku->Scale-Margins.Bottom), FPoint(width()/doku->Scale,
217 Franz 534
                            height()/doku->Scale-Margins.Bottom));
68 Franz 535
                p->drawLine(FPoint(Margins.Left, 0), FPoint(Margins.Left, height()/doku->Scale));
167 Franz 536
                p->drawLine(FPoint(width()/doku->Scale-Margins.Right, 0), FPoint(width()/doku->Scale-Margins.Right,
217 Franz 537
                            height()/doku->Scale));
167 Franz 538
        }
243 Franz 539
        if (ScApp->Prefs.BaseShown)
241 Franz 540
        {
338 Franz 541
                p->setPen(doku->baseColor, lw, SolidLine, FlatCap, MiterJoin);
241 Franz 542
                for (double yg = doku->BaseOffs; yg < doku->PageH; yg += doku->BaseGrid)
543
                        p->drawLine(FPoint(0, yg), FPoint(doku->PageB, yg));
544
        }
243 Franz 545
        if (ScApp->Prefs.GridShown)
167 Franz 546
        {
108 Franz 547
                double stx = rd.x()/doku->Scale;
548
                double endx = rd.x()/doku->Scale+rd.width()/doku->Scale;
549
                double sty = rd.y()/doku->Scale;
550
                double endy = rd.y()/doku->Scale+rd.height()/doku->Scale;
3 paul 551
                if (doku->Scale > 0.49)
167 Franz 552
                {
80 Franz 553
                        double i,start;
125 Franz 554
                        i=doku->majorGrid;
68 Franz 555
                        p->setPen(doku->majorColor, lw, SolidLine, FlatCap, MiterJoin);
3 paul 556
                        start=floor(sty/i);
557
                        start*=i;
558
                        for (b = start; b < endy; b+=i)
217 Franz 559
                                p->drawLine(FPoint(0, b), FPoint(width()/doku->Scale, b));
3 paul 560
                        start=floor(stx/i);
561
                        start*=i;
562
                        for (b = start; b <= endx; b+=i)
167 Franz 563
                                p->drawLine(FPoint(b, 0), FPoint(b, height()/doku->Scale));
125 Franz 564
                        i=doku->minorGrid;
68 Franz 565
                        p->setPen(doku->minorColor, lw, DotLine, FlatCap, MiterJoin);
3 paul 566
                        start=floor(sty/i);
567
                        start*=i;
568
                        for (b = start; b < endy; b+=i)
167 Franz 569
                                p->drawLine(FPoint(0, b), FPoint(width()/doku->Scale, b));
3 paul 570
                        start=floor(stx/i);
571
                        start*=i;
572
                        for (b = start; b <= endx; b+=i)
217 Franz 573
                                p->drawLine(FPoint(b, 0), FPoint(b, height()/doku->Scale));
574
                }
575
        }
243 Franz 576
        if (ScApp->Prefs.GuidesShown)
167 Franz 577
        {
578
                if (XGuides.count() != 0)
3 paul 579
                {
333 Franz 580
                        p->setPen(doku->guideColor, lw, DotLine, FlatCap, MiterJoin);
3 paul 581
                        for (uint xg = 0; xg < XGuides.count(); ++xg)
68 Franz 582
                                p->drawLine(FPoint(XGuides[xg], 0), FPoint(XGuides[xg], doku->PageH));
167 Franz 583
                }
3 paul 584
                if (YGuides.count() != 0)
167 Franz 585
                {
333 Franz 586
                        p->setPen(doku->guideColor, lw, DotLine, FlatCap, MiterJoin);
3 paul 587
                        for (uint yg = 0; yg < YGuides.count(); ++yg)
68 Franz 588
                                p->drawLine(FPoint(0, YGuides[yg]), FPoint(doku->PageB, YGuides[yg]));
3 paul 589
                }
167 Franz 590
        }
68 Franz 591
        p->setWorldMatrix(ma2);
3 paul 592
}
593
 
386 Franz 594
void Page::DrawPageItems(ScPainter *painter, QRect rd, bool sp)
3 paul 595
{
596
        QPainter p;
597
        uint a;
598
        int Lnr;
599
        struct Layer ll;
600
        PageItem* b;
601
        ll.Sichtbar = false;
602
        ll.LNr = 0;
603
        ScribusView* vi = (ScribusView*)Anz;
68 Franz 604
        if ((rd.width() == 0) || (rd.height() == 0))
605
                return;
3 paul 606
        if (MPageNam != "")
167 Franz 607
        {
3 paul 608
                Page* Mp = vi->MasterPages.at(vi->MasterNames[MPageNam]);
609
                QWidget* Opa;
610
                Page* Opa2;
611
                if (Mp->Items.count() != 0)
167 Franz 612
                {
3 paul 613
                        Lnr = 0;
614
                        for (uint la = 0; la < doku->Layers.count(); ++la)
167 Franz 615
                        {
3 paul 616
                                Level2Layer(doku, &ll, Lnr);
617
                                if (ll.Sichtbar)
167 Franz 618
                                {
619
                                        for (a = 0; a < Mp->Items.count(); ++a)
3 paul 620
                                        {
621
                                                b = Mp->Items.at(a);
622
                                                if (b->LayerNr != ll.LNr)
623
                                                        continue;
624
                                                Opa = b->Parent;
625
                                                Opa2 = b->OwnPage;
626
                                                b->Parent = this;
627
                                                b->OwnPage = this;
236 Franz 628
                                                QPainter p;
629
                                                p.begin(this);
630
                                                Transform(b, &p);
631
                                                QRegion apr = QRegion(p.xForm(b->Clip));
238 Franz 632
                                                QRegion apr2 = QRegion(p.xForm(QRect(-1, -1, static_cast<int>(b->Width), static_cast<int>(b->Height))));
236 Franz 633
                                                p.end();
634
                                                if ((rd.intersects(apr.boundingRect())) || (rd.intersects(apr2.boundingRect())))
635
                                                        b->DrawObj(painter, rd);
3 paul 636
                                                b->Parent = Opa;
637
                                                b->OwnPage = Opa2;
638
                                        }
236 Franz 639
                                        for (a = 0; a < Mp->Items.count(); ++a)
640
                                        {
641
                                                b = Mp->Items.at(a);
642
                                                if (b->LayerNr != ll.LNr)
643
                                                        continue;
644
                                                if (!b->isTableItem)
645
                                                        continue;
646
                                                Opa = b->Parent;
647
                                                Opa2 = b->OwnPage;
648
                                                b->Parent = this;
649
                                                b->OwnPage = this;
650
                                                QPainter p;
651
                                                p.begin(this);
652
                                                Transform(b, &p);
653
                                                QRegion apr = QRegion(p.xForm(b->Clip));
238 Franz 654
                                                QRegion apr2 = QRegion(p.xForm(QRect(-1, -1, static_cast<int>(b->Width), static_cast<int>(b->Height))));
236 Franz 655
                                                p.end();
656
                                                if ((rd.intersects(apr.boundingRect())) || (rd.intersects(apr2.boundingRect())))
657
                                                {
658
                                                        painter->setZoomFactor(doku->Scale);
659
                                                        painter->save();
660
                                                        painter->translate(-rd.x(), -rd.y());
661
                                                        painter->translate(b->Xpos*doku->Scale, b->Ypos*doku->Scale);
662
                                                        painter->rotate(b->Rot);
663
                                                        if (b->Pcolor2 != "None")
664
                                                        {
665
                                                                QColor tmp;
666
                                                                b->SetFarbe(&tmp, b->Pcolor2, b->Shade2);
667
                                                                if ((b->TopLine) || (b->RightLine) || (b->BottomLine) || (b->LeftLine))
668
                                                                {
669
                                                                        painter->setPen(tmp, b->Pwidth, b->PLineArt, Qt::SquareCap, b->PLineJoin);
670
                                                                        if (b->TopLine)
262 Franz 671
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(b->Width, 0.0));
236 Franz 672
                                                                        if (b->RightLine)
262 Franz 673
                                                                                painter->drawLine(FPoint(b->Width, 0.0), FPoint(b->Width, b->Height));
236 Franz 674
                                                                        if (b->BottomLine)
262 Franz 675
                                                                                painter->drawLine(FPoint(b->Width, b->Height), FPoint(0.0, b->Height));
236 Franz 676
                                                                        if (b->LeftLine)
262 Franz 677
                                                                                painter->drawLine(FPoint(0.0, b->Height), FPoint(0.0, 0.0));
236 Franz 678
                                                                }
679
                                                        }
680
                                                        painter->restore();
681
                                                }
682
                                                b->Parent = Opa;
683
                                                b->OwnPage = Opa2;
684
                                        }
167 Franz 685
                                }
3 paul 686
                                Lnr++;
687
                        }
688
                }
167 Franz 689
        }
3 paul 690
        if (Items.count() != 0)
167 Franz 691
        {
3 paul 692
                Lnr = 0;
693
                for (uint la2 = 0; la2 < doku->Layers.count(); ++la2)
167 Franz 694
                {
3 paul 695
                        Level2Layer(doku, &ll, Lnr);
696
                        if (ll.Sichtbar)
167 Franz 697
                        {
698
                                for (a = 0; a < Items.count(); ++a)
3 paul 699
                                {
700
                                        b = Items.at(a);
701
                                        if (b->LayerNr != ll.LNr)
702
                                                continue;
703
                                        QPainter p;
704
                                        p.begin(this);
705
                                        Transform(b, &p);
706
                                        QRegion apr = QRegion(p.xForm(b->Clip));
262 Franz 707
                                        QRegion apr2 = QRegion(p.xForm(QRect(-1, -1, static_cast<int>(b->Width), static_cast<int>(b->Height))));
3 paul 708
                                        p.end();
68 Franz 709
                                        if ((rd.intersects(apr.boundingRect())) || (rd.intersects(apr2.boundingRect())))
167 Franz 710
                                        {
387 Franz 711
//                                              if ((sp) && (b->Ptext.count() >= b->MaxChars))
712
//                                                      b->Dirty = true;
262 Franz 713
                                                if (!((doku->EditClip) && (Mpressed)))
714
                                                        b->DrawObj(painter, rd);
74 Franz 715
                                                b->Redrawn = true;
272 Franz 716
                                                if ((doku->AppMode == 7) && (b->Select) && (b->PType == 4))
717
                                                {
718
                                                        vi->HR->ItemPos = b->Xpos;
719
                                                        vi->HR->ItemEndPos = b->Xpos+b->Width;
720
                                                        if (b->Pcolor2 != "None")
721
                                                                vi->HR->lineCorr = b->Pwidth / 2.0;
722
                                                        else
723
                                                                vi->HR->lineCorr = 0;
724
                                                        vi->HR->ColGap = b->ColGap;
725
                                                        vi->HR->Cols = b->Cols;
726
                                                        vi->HR->Extra = b->Extra;
727
                                                        vi->HR->RExtra = b->RExtra;
728
                                                        vi->HR->First = doku->Vorlagen[doku->CurrentABStil].First;
729
                                                        vi->HR->Indent = doku->Vorlagen[doku->CurrentABStil].Indent;
730
                                                        if ((b->flippedH % 2 != 0) || (b->Reverse))
731
                                                                vi->HR->Revers = true;
732
                                                        else
733
                                                                vi->HR->Revers = false;
734
                                                        vi->HR->ItemPosValid = true;
735
                                                        vi->HR->repX = false;
736
                                                        if (doku->CurrentABStil < 5)
737
                                                                vi->HR->TabValues = b->TabValues;
738
                                                        else
739
                                                                vi->HR->TabValues = doku->Vorlagen[doku->CurrentABStil].TabValues;
740
                                                        vi->HR->repaint();
741
                                                }
3 paul 742
                                        }
743
                                }
236 Franz 744
                                for (a = 0; a < Items.count(); ++a)
745
                                {
746
                                        b = Items.at(a);
747
                                        if (b->LayerNr != ll.LNr)
748
                                                continue;
749
                                        if (!b->isTableItem)
750
                                                continue;
751
                                        QPainter p;
752
                                        p.begin(this);
753
                                        Transform(b, &p);
754
                                        QRegion apr = QRegion(p.xForm(b->Clip));
262 Franz 755
                                        QRegion apr2 = QRegion(p.xForm(QRect(-1, -1, static_cast<int>(b->Width), static_cast<int>(b->Height))));
236 Franz 756
                                        p.end();
757
                                        if ((rd.intersects(apr.boundingRect())) || (rd.intersects(apr2.boundingRect())))
758
                                        {
759
                                                painter->setZoomFactor(doku->Scale);
760
                                                painter->save();
761
                                                painter->translate(-rd.x(), -rd.y());
762
                                                painter->translate(b->Xpos*doku->Scale, b->Ypos*doku->Scale);
763
                                                painter->rotate(b->Rot);
764
                                                if (b->Pcolor2 != "None")
765
                                                {
766
                                                        QColor tmp;
767
                                                        b->SetFarbe(&tmp, b->Pcolor2, b->Shade2);
768
                                                        if ((b->TopLine) || (b->RightLine) || (b->BottomLine) || (b->LeftLine))
769
                                                        {
770
                                                                painter->setPen(tmp, b->Pwidth, b->PLineArt, Qt::SquareCap, b->PLineJoin);
771
                                                                if (b->TopLine)
262 Franz 772
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(b->Width, 0.0));
236 Franz 773
                                                                if (b->RightLine)
262 Franz 774
                                                                        painter->drawLine(FPoint(b->Width, 0.0), FPoint(b->Width, b->Height));
236 Franz 775
                                                                if (b->BottomLine)
262 Franz 776
                                                                        painter->drawLine(FPoint(b->Width, b->Height), FPoint(0.0, b->Height));
236 Franz 777
                                                                if (b->LeftLine)
262 Franz 778
                                                                        painter->drawLine(FPoint(0.0, b->Height), FPoint(0.0, 0.0));
236 Franz 779
                                                        }
780
                                                }
781
                                                painter->restore();
782
                                        }
783
                                }
167 Franz 784
                        }
3 paul 785
                        Lnr++;
786
                }
167 Franz 787
        }
3 paul 788
}
789
 
790
void Page::setGroupRect()
791
{
792
        PageItem* b;
80 Franz 793
        double minx = 99999.9;
794
        double miny = 99999.9;
795
        double maxx = -99999.9;
796
        double maxy = -99999.9;
3 paul 797
        for (uint gc = 0; gc < SelItem.count(); ++gc)
167 Franz 798
        {
3 paul 799
                b = SelItem.at(gc);
75 Franz 800
                if (b->Rot != 0)
167 Franz 801
                {
217 Franz 802
                        FPointArray pb;
133 Franz 803
                        FPoint p1;
804
                        pb.resize(0);
805
                        pb.addPoint(FPoint(b->Xpos, b->Ypos));
806
                        p1 = transformPoint(FPoint(b->Width, 0.0), b->Xpos, b->Ypos, b->Rot, 1.0, 1.0);
807
                        pb.addPoint(p1);
808
                        p1 = transformPoint(FPoint(b->Width, b->Height), b->Xpos, b->Ypos, b->Rot, 1.0, 1.0);
809
                        pb.addPoint(p1);
810
                        p1 = transformPoint(FPoint(0.0, b->Height), b->Xpos, b->Ypos, b->Rot, 1.0, 1.0);
811
                        pb.addPoint(p1);
812
                        for (uint pc = 0; pc < 4; ++pc)
167 Franz 813
                        {
133 Franz 814
                                minx = QMIN(minx, pb.point(pc).x());
815
                                miny = QMIN(miny, pb.point(pc).y());
816
                                maxx = QMAX(maxx, pb.point(pc).x());
817
                                maxy = QMAX(maxy, pb.point(pc).y());
75 Franz 818
                        }
167 Franz 819
                }
75 Franz 820
                else
167 Franz 821
                {
75 Franz 822
                        minx = QMIN(minx, b->Xpos);
823
                        miny = QMIN(miny, b->Ypos);
824
                        maxx = QMAX(maxx, b->Xpos + b->Width);
825
                        maxy = QMAX(maxy, b->Ypos + b->Height);
3 paul 826
                }
167 Franz 827
        }
3 paul 828
        GroupX = minx;
829
        GroupY = miny;
830
        GroupW = maxx - minx;
831
        GroupH = maxy - miny;
832
        GroupSel = true;
833
}
834
 
80 Franz 835
void Page::moveGroup(double x, double y, bool fromMP)
3 paul 836
{
837
        PageItem* b;
314 Franz 838
        QPainter p;
80 Franz 839
        double gx, gy, gw, gh;
3 paul 840
        if (GroupSel)
318 Franz 841
        {
842
                p.begin(this);
3 paul 843
                getGroupRectScreen(&gx, &gy, &gw, &gh);
318 Franz 844
                PaintSizeRect(&p, QRect(qRound(gx), qRound(gy), qRound(gw), qRound(gh)));
845
                p.end();
846
        }
3 paul 847
        for (uint a = 0; a < SelItem.count(); ++a)
167 Franz 848
        {
3 paul 849
                b = SelItem.at(a);
314 Franz 850
                if (!fromMP)
851
                {
852
                        p.begin(this);
853
                        Transform(b, &p);
854
                        p.setRasterOp(XorROP);
855
                        p.setBrush(NoBrush);
856
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
857
                        if ((b->PType != 5) && (b->FrameType != 0) || (b->PType == 7))
858
                                b->DrawPolyL(&p, b->Clip);
859
                        else
860
                                p.drawRect(0, 0, static_cast<int>(b->Width)+1, static_cast<int>(b->Height)+1);
861
                        p.end();
862
                }
3 paul 863
                MoveItem(x, y, b, fromMP);
314 Franz 864
                if (!fromMP)
865
                {
866
                        p.begin(this);
867
                        Transform(b, &p);
868
                        p.setRasterOp(XorROP);
869
                        p.setBrush(NoBrush);
870
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
871
                        if ((b->PType != 5) && (b->FrameType != 0) || (b->PType == 7))
872
                                b->DrawPolyL(&p, b->Clip);
873
                        else
874
                                p.drawRect(0, 0, static_cast<int>(b->Width)+1, static_cast<int>(b->Height)+1);
875
                        p.end();
876
                }
167 Franz 877
        }
314 Franz 878
        if ((GroupSel) && (fromMP))
238 Franz 879
                repaint(QRect(static_cast<int>(gx-5), static_cast<int>(gy-5), static_cast<int>(gw+10), static_cast<int>(gh+10)));
3 paul 880
}
881
 
80 Franz 882
void Page::getGroupRect(double *x, double *y, double *w, double *h)
3 paul 883
{
884
        *x = GroupX;
885
        *y = GroupY;
886
        *w = GroupW;
887
        *h = GroupH;
888
}
889
 
80 Franz 890
void Page::getGroupRectScreen(double *x, double *y, double *w, double *h)
3 paul 891
{
80 Franz 892
        double sc = doku->Scale;
3 paul 893
        *x = GroupX*sc;
894
        *y = GroupY*sc;
895
        *w = GroupW*sc;
896
        *h = GroupH*sc;
897
}
898
 
899
void Page::paintGroupRect(bool norm)
900
{
80 Franz 901
        double x, y, w, h;
3 paul 902
        getGroupRectScreen(&x, &y, &w, &h);
903
        QPainter pgc;
904
        pgc.begin(this);
217 Franz 905
        pgc.setPen(QPen((norm ? red : black), 1, DotLine, FlatCap, MiterJoin));
3 paul 906
        pgc.setBrush(NoBrush);
907
        pgc.drawRect(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h));
908
        pgc.setBrush(red);
909
        if (norm)
167 Franz 910
        {
3 paul 911
                pgc.setPen(QPen(red, 1, SolidLine, FlatCap, MiterJoin));
238 Franz 912
                pgc.drawRect(qRound(x+w-6), qRound(y+h-6), 6, 6);
913
                pgc.drawRect(qRound(x+w/2 - 3), qRound(y+h-6), 6, 6);
914
                pgc.drawRect(qRound(x+w/2 - 3), qRound(y), 6, 6);
915
                pgc.drawRect(qRound(x+w-6), qRound(y+h/2 - 3), 6, 6);
916
                pgc.drawRect(qRound(x+w-6), qRound(y), 6, 6);
917
                pgc.drawRect(qRound(x), qRound(y), 6, 6);
918
                pgc.drawRect(qRound(x), qRound(y+h/2 - 3), 6, 6);
919
                pgc.drawRect(qRound(x), qRound(y+h-6), 6, 6);
167 Franz 920
        }
3 paul 921
        pgc.end();
922
}
923
 
924
void Page::storeUndoInf(PageItem* b)
925
{
926
        if ((doku->UnData.UnCode == 0) && (doku->UnDoValid))
927
                delete doku->UnData.Item;
928
        doku->UnDoValid = false;
929
        doku->UnData.Xpos = b->Xpos;
930
        doku->UnData.Ypos = b->Ypos;
931
        doku->UnData.Width = b->Width;
932
        doku->UnData.Height = b->Height;
933
        doku->UnData.Rot = b->Rot;
934
        doku->UnData.Item = b;
935
        doku->UnData.PageNr = PageNr;
936
        doku->UnData.ItemNr = b->ItemNr;
937
}
938
 
939
QRegion Page::ViewReg()
940
{
68 Franz 941
        int cx = Anz->contentsX() - Anz->childX(parentWidget());
942
        int cy = Anz->contentsY() - Anz->childY(parentWidget());
3 paul 943
        int cw = Anz->visibleWidth();
944
        int ch = Anz->visibleHeight();
945
        return QRegion(QRect(cx, cy, cw, ch));
946
}
947
 
948
void Page::Transform(PageItem *b, QPainter *p)
949
{
230 Franz 950
        p->translate(static_cast<int>(b->Xpos*doku->Scale), static_cast<int>(b->Ypos*doku->Scale));
3 paul 951
        p->scale(doku->Scale, doku->Scale);
952
        p->rotate(b->Rot);
953
}
954
 
955
bool Page::GetItem(PageItem **b, int nr)
956
{
217 Franz 957
        if (SelItem.count() != 0)
958
        {
3 paul 959
                if (nr == -1)
217 Franz 960
                        *(b) = SelItem.at(0);
3 paul 961
                else
217 Franz 962
                        *(b) = SelItem.at(nr);
3 paul 963
                return true;
217 Franz 964
        }
3 paul 965
        else
217 Franz 966
        {
3 paul 967
                *(b) = 0;
968
                return false;
217 Franz 969
        }
3 paul 970
}
971
 
972
void Page::TransformM(PageItem *b, QPainter *p)
973
{
974
        if (b->flippedH % 2 != 0)
167 Franz 975
        {
3 paul 976
                p->translate(b->Width, 0);
977
                p->scale(-1, 1);
167 Franz 978
        }
3 paul 979
        if (b->flippedV % 2 != 0)
167 Franz 980
        {
3 paul 981
                p->translate(0, b->Height);
982
                p->scale(1, -1);
167 Franz 983
        }
3 paul 984
}
985
 
237 Franz 986
void Page::PaintSizeRect(QPainter *p, QRect neu)
3 paul 987
{
237 Franz 988
        static QRect old;
989
        if (!neu.isNull())
990
        {
991
                QWMatrix ma = p->worldMatrix();
992
                ma.setTransformationMode ( QWMatrix::Areas );
993
                p->setWorldMatrix(ma);
994
                p->setRasterOp(XorROP);
995
                p->setBrush(NoBrush);
996
                p->setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
997
                if (!old.isNull())
998
                        p->drawRect(old);
238 Franz 999
                p->drawRect(neu);
237 Franz 1000
        }
1001
        old = neu;
3 paul 1002
}
1003
 
1004
QPoint Page::ApplyGrid(QPoint in)
1005
{
1006
        QPoint np;
1007
        if (doku->useRaster)
167 Franz 1008
        {
3 paul 1009
                np.setX(static_cast<int>(qRound(in.x() / doku->minorGrid) * doku->minorGrid));
1010
                np.setY(static_cast<int>(qRound(in.y() / doku->minorGrid) * doku->minorGrid));
167 Franz 1011
        }
3 paul 1012
        else
1013
                np = in;
1014
        return np;
1015
}
1016
 
315 Franz 1017
bool Page::ApplyGuides(double *x, double *y)
3 paul 1018
{
315 Franz 1019
        bool ret = false;
3 paul 1020
        if (doku->SnapGuides)
167 Franz 1021
        {
1022
                if (YGuides.count() != 0)
3 paul 1023
                {
167 Franz 1024
                        for (uint yg = 0; yg < YGuides.count(); ++yg)
3 paul 1025
                        {
167 Franz 1026
                                if ((YGuides[yg] < (*y+doku->GuideRad)) && (YGuides[yg] > (*y-doku->GuideRad)))
3 paul 1027
                                {
1028
                                        *y= YGuides[yg];
315 Franz 1029
                                        ret = true;
3 paul 1030
                                        break;
1031
                                }
1032
                        }
167 Franz 1033
                }
3 paul 1034
                if (XGuides.count() != 0)
167 Franz 1035
                {
1036
                        for (uint xg = 0; xg < XGuides.count(); ++xg)
3 paul 1037
                        {
167 Franz 1038
                                if ((XGuides[xg] < (*x+doku->GuideRad)) && (XGuides[xg] > (*x-doku->GuideRad)))
3 paul 1039
                                {
1040
                                        *x = XGuides[xg];
315 Franz 1041
                                        ret = true;
3 paul 1042
                                        break;
1043
                                }
1044
                        }
1045
                }
319 Franz 1046
                if ((doku->PageM.Left < (*x+doku->GuideRad)) && (doku->PageM.Left > (*x-doku->GuideRad)))
1047
                {
1048
                        *x = doku->PageM.Left;
1049
                        ret = true;
1050
                }
1051
                if (((doku->PageB - doku->PageM.Right) < (*x+doku->GuideRad)) && ((doku->PageB - doku->PageM.Right) > (*x-doku->GuideRad)))
1052
                {
1053
                        *x = doku->PageB - doku->PageM.Right;
1054
                        ret = true;
1055
                }
1056
                if ((doku->PageM.Top < (*y+doku->GuideRad)) && (doku->PageM.Top > (*y-doku->GuideRad)))
1057
                {
1058
                        *y = doku->PageM.Top;
1059
                        ret = true;
1060
                }
1061
                if (((doku->PageH - doku->PageM.Bottom) < (*y+doku->GuideRad)) && ((doku->PageH - doku->PageM.Bottom) > (*y-doku->GuideRad)))
1062
                {
1063
                        *y = doku->PageH - doku->PageM.Bottom;
1064
                        ret = true;
1065
                }
167 Franz 1066
        }
315 Franz 1067
        return ret;
3 paul 1068
}
1069
 
1070
FPoint Page::ApplyGridF(FPoint in)
1071
{
1072
        FPoint np;
1073
        if (doku->useRaster)
167 Franz 1074
        {
3 paul 1075
                np.setX(qRound(in.x() / doku->minorGrid) * doku->minorGrid);
1076
                np.setY(qRound(in.y() / doku->minorGrid) * doku->minorGrid);
167 Franz 1077
        }
3 paul 1078
        else
1079
                np = in;
1080
        return np;
1081
}
1082
 
74 Franz 1083
void Page::RefreshItem(PageItem *b, bool single)
3 paul 1084
{
272 Franz 1085
        bool dirtyT = b->Dirty;
3 paul 1086
        QPainter p;
1087
        p.begin(this);
1088
        Transform(b, &p);
287 Franz 1089
        QRect rd;
1090
        rd = QRect(qRound(ceil(-b->OldPwidth / 2.0))-2,
1091
                                        qRound(ceil(-b->OldPwidth / 2.0))-2,
1092
                                        qRound(ceil(b->Width+b->OldPwidth*2))+4,
1093
                                        qRound(ceil(b->Height+b->OldPwidth*2))+4);
263 Franz 1094
        if ((b->isTableItem) && (b->Pcolor2 != "None"))
1095
        {
1096
                if (!b->TopLine)
1097
                {
1098
                        rd.setY(rd.y()+qRound(ceil(b->OldPwidth / 2.0)));
1099
                        rd.setHeight(rd.height()-qRound(ceil(b->OldPwidth)));
1100
                }
1101
                if (!b->RightLine)
1102
                        rd.setWidth(rd.width()-qRound(ceil(b->OldPwidth)));
1103
                if (!b->BottomLine)
1104
                        rd.setHeight(rd.height()-qRound(ceil(b->OldPwidth)));
1105
                if (!b->LeftLine)
1106
                {
1107
                        rd.setX(rd.x()+qRound(ceil(b->OldPwidth / 2.0)));
1108
                        rd.setWidth(rd.width()-qRound(ceil(b->OldPwidth)));
1109
                }
1110
        }
74 Franz 1111
        if (single)
125 Franz 1112
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
3 paul 1113
        else
266 Franz 1114
        {
1115
                if (doku->AppMode == 7)
1116
                        slotDoCurs(false);
125 Franz 1117
                update(QRegion(p.xForm(rd)).intersect(ViewReg()).boundingRect());
266 Franz 1118
                if (doku->AppMode == 7)
272 Franz 1119
                {
266 Franz 1120
                        slotDoCurs(true);
272 Franz 1121
                        if ((b->PType == 4) && (!dirtyT))
1122
                        {
1123
                                ScribusView* vi = (ScribusView*)Anz;
1124
                                vi->HR->ItemPos = b->Xpos;
1125
                                vi->HR->ItemEndPos = b->Xpos+b->Width;
1126
                                if (b->Pcolor2 != "None")
1127
                                        vi->HR->lineCorr = b->Pwidth / 2.0;
1128
                                else
1129
                                        vi->HR->lineCorr = 0;
1130
                                vi->HR->ColGap = b->ColGap;
1131
                                vi->HR->Cols = b->Cols;
1132
                                vi->HR->Extra = b->Extra;
1133
                                vi->HR->RExtra = b->RExtra;
1134
                                vi->HR->First = doku->Vorlagen[doku->CurrentABStil].First;
1135
                                vi->HR->Indent = doku->Vorlagen[doku->CurrentABStil].Indent;
1136
                                if ((b->flippedH % 2 != 0) || (b->Reverse))
1137
                                        vi->HR->Revers = true;
1138
                                else
1139
                                        vi->HR->Revers = false;
1140
                                vi->HR->ItemPosValid = true;
1141
                                vi->HR->repX = false;
1142
                                if (doku->CurrentABStil < 5)
1143
                                        vi->HR->TabValues = b->TabValues;
1144
                                else
1145
                                        vi->HR->TabValues = doku->Vorlagen[doku->CurrentABStil].TabValues;
1146
                                vi->HR->repaint();
1147
                        }
1148
                }
266 Franz 1149
        }
3 paul 1150
        p.end();
263 Franz 1151
        b->OldPwidth = b->Pwidth;
3 paul 1152
}
1153
 
75 Franz 1154
void Page::RepaintTextRegion(PageItem *b, QRegion alt, bool single)
3 paul 1155
{
167 Franz 1156
        if (!isUpdatesEnabled())
1157
                return;
272 Franz 1158
        bool dirtyT = b->Dirty;
266 Franz 1159
        if (doku->AppMode == 7)
1160
                slotDoCurs(false);
3 paul 1161
        QPainter p;
1162
        QRegion neu;
1163
        p.begin(this);
1164
        Transform(b, &p);
1165
        neu = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width+1), static_cast<int>(b->Height+1)))).unite(alt);
1166
        p.end();
1167
        QRect g = neu.boundingRect();
263 Franz 1168
        if (!single)
1169
        {
287 Franz 1170
                g.setX(g.x()-static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))-4);
1171
                g.setY(g.y()-static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))-4);
1172
                g.setWidth(g.width()+static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))+8);
1173
                g.setHeight(g.height()+static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))+8);
263 Franz 1174
        }
75 Franz 1175
        if (single)
167 Franz 1176
        {
75 Franz 1177
                QRect rd = ViewReg().boundingRect().intersect(g);
1178
                if ((rd.width() < 1) || (rd.height() < 1))
1179
                        return;
1180
                QPixmap pgPix(rd.width(), rd.height());
1181
                ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
1182
                painter->translate(0.5, 0.5);
108 Franz 1183
                if (doku->Before)
1184
                        DrawPageMarks(painter, rd);
238 Franz 1185
                if (!((doku->EditClip) && (Mpressed)))
1186
                        b->DrawObj(painter, rd);
108 Franz 1187
                if (!doku->Before)
1188
                        DrawPageMarks(painter, rd);
263 Franz 1189
                if (b->isTableItem)
1190
                {
1191
                        painter->setZoomFactor(doku->Scale);
1192
                        painter->save();
1193
                        painter->translate(-rd.x(), -rd.y());
1194
                        painter->translate(b->Xpos*doku->Scale, b->Ypos*doku->Scale);
1195
                        painter->rotate(b->Rot);
1196
                        if (b->Pcolor2 != "None")
1197
                        {
1198
                                QColor tmp;
1199
                                b->SetFarbe(&tmp, b->Pcolor2, b->Shade2);
1200
                                if ((b->TopLine) || (b->RightLine) || (b->BottomLine) || (b->LeftLine))
1201
                                {
1202
                                        painter->setPen(tmp, b->Pwidth, b->PLineArt, Qt::SquareCap, b->PLineJoin);
1203
                                        if (b->TopLine)
1204
                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(b->Width, 0.0));
1205
                                        if (b->RightLine)
1206
                                                painter->drawLine(FPoint(b->Width, 0.0), FPoint(b->Width, b->Height));
1207
                                        if (b->BottomLine)
1208
                                                painter->drawLine(FPoint(b->Width, b->Height), FPoint(0.0, b->Height));
1209
                                        if (b->LeftLine)
1210
                                                painter->drawLine(FPoint(0.0, b->Height), FPoint(0.0, 0.0));
1211
                                }
1212
                        }
1213
                        painter->restore();
1214
                }
75 Franz 1215
                painter->end();
1216
                bitBlt( this, rd.x(), rd.y(), &pgPix, 0, 0, pgPix.width(), pgPix.height() );
1217
                QPainter px;
1218
                px.begin(this);
1219
                px.setPen(QColor(0, 0, 0));
1220
                px.setBrush(NoBrush);
1221
                px.drawRect(0, 0, width(), height());
217 Franz 1222
                px.end();
75 Franz 1223
                b->paintObj(rd);
1224
                if ((doku->EditClip) && (b->Select))
1225
                        MarkClip(b);
1226
                if (GroupSel)
167 Franz 1227
                {
75 Franz 1228
                        setGroupRect();
1229
                        paintGroupRect();
167 Franz 1230
                }
75 Franz 1231
                delete painter;
167 Franz 1232
        }
75 Franz 1233
        else
167 Franz 1234
        {
75 Franz 1235
                neu = QRegion(g);
1236
                update(neu.intersect(ViewReg()).boundingRect());
167 Franz 1237
        }
266 Franz 1238
        if (doku->AppMode == 7)
272 Franz 1239
        {
266 Franz 1240
                slotDoCurs(true);
272 Franz 1241
                if ((b->PType == 4) && (!dirtyT))
1242
                {
1243
                        ScribusView* vi = (ScribusView*)Anz;
1244
                        vi->HR->ItemPos = b->Xpos;
1245
                        vi->HR->ItemEndPos = b->Xpos+b->Width;
1246
                        if (b->Pcolor2 != "None")
1247
                                vi->HR->lineCorr = b->Pwidth / 2.0;
1248
                        else
1249
                                vi->HR->lineCorr = 0;
1250
                        vi->HR->ColGap = b->ColGap;
1251
                        vi->HR->Cols = b->Cols;
1252
                        vi->HR->Extra = b->Extra;
1253
                        vi->HR->RExtra = b->RExtra;
1254
                        vi->HR->First = doku->Vorlagen[doku->CurrentABStil].First;
1255
                        vi->HR->Indent = doku->Vorlagen[doku->CurrentABStil].Indent;
1256
                        if ((b->flippedH % 2 != 0) || (b->Reverse))
1257
                                vi->HR->Revers = true;
1258
                        else
1259
                                vi->HR->Revers = false;
1260
                        vi->HR->ItemPosValid = true;
1261
                        vi->HR->repX = false;
1262
                        if (doku->CurrentABStil < 5)
1263
                                vi->HR->TabValues = b->TabValues;
1264
                        else
1265
                                vi->HR->TabValues = doku->Vorlagen[doku->CurrentABStil].TabValues;
1266
                        vi->HR->repaint();
1267
                }
1268
        }
3 paul 1269
}
1270
 
222 Franz 1271
void Page::AdjustPreview(PageItem *b, bool reload)
3 paul 1272
{
1273
        int neww, newh, fho, fvo;
63 Franz 1274
        bool savF;
3 paul 1275
        if ((b->LocalViewX < 1.0) || (b->LocalViewY < 1.0))
167 Franz 1276
        {
1277
                if ((b->Pfile != "") && (b->PicAvail))
3 paul 1278
                {
167 Franz 1279
                        if (!b->Sizing)
3 paul 1280
                        {
1281
                                fho = b->flippedH;
1282
                                fvo = b->flippedV;
63 Franz 1283
                                savF = b->PicArt;
204 Franz 1284
                                if ( !b->pixmOrg.isNull() )
1285
                                {
1286
                                        b->pixm = b->pixmOrg.copy();
1287
                                        b->OrigW = b->pixm.width();
1288
                                        b->OrigH  = b->pixm.height();
1289
                                        b->LocalViewX = b->LocalScX;
1290
                                        b->LocalViewY = b->LocalScY;
1291
                                }
222 Franz 1292
                                else if (reload == false ) // jjsa begin
1293
                                {
1294
                                        b->OrigW = b->pixm.width();
1295
                                        b->OrigH  = b->pixm.height();
1296
                                        b->LocalViewX = b->LocalScX;
1297
                                        b->LocalViewY = b->LocalScY; // jjsa end
1298
                                }
204 Franz 1299
                                else
1300
                                        LoadPict(b->Pfile, b->ItemNr);
3 paul 1301
                                b->flippedH = fho;
1302
                                b->flippedV = fvo;
63 Franz 1303
                                b->PicArt = savF;
167 Franz 1304
                        }
3 paul 1305
                        neww = qRound(b->pixm.width() * b->LocalViewX);
1306
                        newh = qRound(b->pixm.height() * b->LocalViewY);
1307
                        b->pixm = b->pixm.smoothScale(neww, newh);
1308
                        b->LocalViewX = 1;
1309
                        b->LocalViewY = 1;
1310
                }
167 Franz 1311
        }
3 paul 1312
}
222 Franz 1313
void Page::AdjustPictScale(PageItem *b, bool reload)
3 paul 1314
{
1315
        if (b->ScaleType)
1316
                return;
238 Franz 1317
        if ((b->OrigW == 0) || (b->OrigH == 0))
1318
                return;
167 Franz 1319
        bool savF;
3 paul 1320
        b->LocalX = 0;
1321
        b->LocalY = 0;
80 Franz 1322
        double xs = b->Width / static_cast<double>(b->OrigW);
1323
        double ys = b->Height / static_cast<double>(b->OrigH);
3 paul 1324
        if (!b->Sizing)
167 Franz 1325
        {
1326
                int fho = b->flippedH, fvo = b->flippedV;
63 Franz 1327
                savF = b->PicArt;
204 Franz 1328
                if (!b->pixmOrg.isNull())
1329
                {
1330
                        b->pixm = b->pixmOrg.copy();
1331
                        b->OrigW = b->pixm.width();
1332
                        b->OrigH  = b->pixm.height();
1333
                        b->LocalViewX = b->LocalScX;
1334
                        b->LocalViewY = b->LocalScY;
1335
                }
222 Franz 1336
                else if ( reload == false ) // jjsa begin
1337
                        {
1338
                        b->OrigW = b->pixm.width();
1339
                        b->OrigH  = b->pixm.height();
1340
                        b->LocalViewX = b->LocalScX;
1341
                        b->LocalViewY = b->LocalScY;
1342
                        }
1343
                else // jjsa end
204 Franz 1344
                        LoadPict(b->Pfile, b->ItemNr);
3 paul 1345
                b->flippedH = fho;
1346
                b->flippedV = fvo;
63 Franz 1347
                b->PicArt = savF;
167 Franz 1348
        }
3 paul 1349
        if (b->AspectRatio)
167 Franz 1350
        {
3 paul 1351
                b->LocalScX = QMIN(xs, ys);
1352
                b->LocalScY = QMIN(xs, ys);
1353
                b->LocalViewX = QMIN(xs, ys);
1354
                b->LocalViewY = QMIN(xs, ys);
167 Franz 1355
        }
3 paul 1356
        else
167 Franz 1357
        {
3 paul 1358
                b->LocalScX = xs;
1359
                b->LocalScY = ys;
1360
                b->LocalViewX = xs;
1361
                b->LocalViewY = ys;
167 Franz 1362
        }
3 paul 1363
        emit SetLocalValues(b->LocalScX, b->LocalScY, b->LocalX, b->LocalY );
1364
}
1365
 
236 Franz 1366
bool Page::MoveSizeItem(FPoint newX, FPoint newY, int ite, bool fromMP)
3 paul 1367
{
1368
        QRegion alt;
1369
        QPainter p;
1370
        PageItem *b = Items.at(ite);
1371
        p.begin(this);
1372
        Transform(b, &p);
1373
        alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
1374
        p.end();
1375
        if (b->PType == 5)
167 Franz 1376
        {
3 paul 1377
                QWMatrix ma;
1378
                ma.translate(b->Xpos, b->Ypos);
1379
                ma.rotate(b->Rot);
80 Franz 1380
                double mx = ma.m11() * b->Width + ma.m21() * b->Height + ma.dx();
1381
                double my = ma.m22() * b->Height + ma.m12() * b->Width + ma.dy();
236 Franz 1382
                MoveItem(newX.x(), newX.y(), b, fromMP);
3 paul 1383
                b->Rot = xy2Deg(mx - b->Xpos, my - b->Ypos);
1384
                b->Width = sqrt(pow(mx - b->Xpos,2)+pow(my - b->Ypos,2));
1385
                b->Height = 0;
1386
                UpdateClip(b);
1387
                RepaintTextRegion(b, alt);
1388
                emit ItemPos(b->Xpos, b->Ypos);
1389
                emit ItemGeom(b->Width, b->Height);
1390
                emit SetAngle(b->Rot);
167 Franz 1391
        }
3 paul 1392
        else
167 Franz 1393
        {
236 Franz 1394
                b->OldB2 = b->Width;
1395
                b->OldH2 = b->Height;
167 Franz 1396
                if (b->Rot != 0)
3 paul 1397
                {
1398
                        FPoint npv = FPoint(newX.x(), newX.y());
1399
                        QWMatrix ma3;
1400
                        ma3.translate(b->Xpos, b->Ypos);
1401
                        ma3.rotate(b->Rot);
80 Franz 1402
                        double mxc3 = b->Xpos - (ma3.m11() * npv.x() + ma3.m21() * npv.y() + ma3.dx());
1403
                        double myc3 = b->Ypos - (ma3.m22() * npv.y() + ma3.m12() * npv.x() + ma3.dy());
236 Franz 1404
                        SizeItem(b->Width - newY.x(), b->Height - newY.y(), ite, fromMP);
1405
                        MoveItem(-mxc3, -myc3, b, fromMP);
167 Franz 1406
                }
3 paul 1407
                else
167 Franz 1408
                {
236 Franz 1409
                        SizeItem(b->Width - newY.x(), b->Height - newY.y(), ite, fromMP);
1410
                        MoveItem(newX.x(), newX.y(), b, fromMP);
3 paul 1411
                }
167 Franz 1412
        }
3 paul 1413
        return true;
1414
}
1415
 
1416
void Page::UpdateClip(PageItem* b)
1417
{
232 Franz 1418
        if (doku->AppMode == 13)
1419
                return;
3 paul 1420
        int ph = static_cast<int>(QMAX(1.0, b->Pwidth / 2.0));
1421
        switch (b->PType)
167 Franz 1422
        {
217 Franz 1423
        case 5:
1424
                b->Clip.setPoints(4, -ph,-ph, static_cast<int>(b->Width+ph),-ph,
1425
                                  static_cast<int>(b->Width+ph),static_cast<int>(b->Height+ph),
1426
                                  -ph,static_cast<int>(b->Height+ph));
1427
                break;
1428
        default:
376 Franz 1429
                if ((!b->ClipEdited) || (b->FrameType < 3))
217 Franz 1430
                {
1431
                        switch (b->FrameType)
167 Franz 1432
                        {
217 Franz 1433
                        case 0:
1434
                                SetRectFrame(b);
1435
                                break;
1436
                        case 1:
1437
                                SetOvalFrame(b);
1438
                                break;
1439
                        case 2:
1440
                                SetFrameRound(b);
1441
                                break;
376 Franz 1442
                        default:
1443
                                break;
167 Franz 1444
                        }
295 Franz 1445
                        if ((b->OldB2 != 0) && (b->OldH2 != 0))
1446
                        {
1447
                                double scx = b->Width / b->OldB2;
1448
                                double scy = b->Height / b->OldH2;
1449
                                QWMatrix ma;
1450
                                ma.scale(scx, scy);
1451
                                FPointArray gr;
1452
                                gr.addPoint(b->GrStartX, b->GrStartY);
1453
                                gr.addPoint(b->GrEndX, b->GrEndY);
1454
                                gr.map(ma);
1455
                                b->GrStartX = gr.point(0).x();
1456
                                b->GrStartY = gr.point(0).y();
1457
                                b->GrEndX = gr.point(1).x();
1458
                                b->GrEndY = gr.point(0).y();
376 Franz 1459
                                if (b->FrameType > 2)
1460
                                {
1461
                                        b->PoLine.map(ma);
1462
                                        b->ContourLine.map(ma);
1463
                                        if (b->PType == 8)
1464
                                                UpdatePolyClip(b);
1465
                                        else
1466
                                                b->Clip = FlattenPath(b->PoLine, b->Segments);
1467
                                }
295 Franz 1468
                        }
217 Franz 1469
                        b->OldB2 = b->Width;
1470
                        b->OldH2 = b->Height;
376 Franz 1471
                        if (b->FrameType < 3)
1472
                                b->ContourLine = b->PoLine.copy();
217 Franz 1473
                }
1474
                else
1475
                {
1476
                        if (doku->SubMode != -1)
167 Franz 1477
                        {
217 Franz 1478
                                switch (doku->SubMode)
80 Franz 1479
                                {
217 Franz 1480
                                case 0:
1481
                                        SetRectFrame(b);
1482
                                        break;
1483
                                case 1:
1484
                                        SetOvalFrame(b);
1485
                                        break;
1486
                                default:
1487
                                        SetFrameShape(b, doku->ValCount, doku->ShapeValues);
1488
                                        break;
167 Franz 1489
                                }
3 paul 1490
                                b->OldB2 = b->Width;
1491
                                b->OldH2 = b->Height;
340 Franz 1492
                                b->ContourLine = b->PoLine.copy();
167 Franz 1493
                        }
217 Franz 1494
                        if ((b->OldB2 == 0) || (b->OldH2 == 0))
1495
                                return;
1496
                        double scx = b->Width / b->OldB2;
1497
                        double scy = b->Height / b->OldH2;
1498
                        QWMatrix ma;
1499
                        ma.scale(scx, scy);
292 Franz 1500
                        FPointArray gr;
1501
                        gr.addPoint(b->GrStartX, b->GrStartY);
1502
                        gr.addPoint(b->GrEndX, b->GrEndY);
1503
                        gr.map(ma);
1504
                        b->GrStartX = gr.point(0).x();
1505
                        b->GrStartY = gr.point(0).y();
1506
                        b->GrEndX = gr.point(1).x();
1507
                        b->GrEndY = gr.point(0).y();
217 Franz 1508
                        b->PoLine.map(ma);
340 Franz 1509
                        b->ContourLine.map(ma);
217 Franz 1510
                        if (b->PType == 8)
1511
                                UpdatePolyClip(b);
1512
                        else
1513
                                b->Clip = FlattenPath(b->PoLine, b->Segments);
1514
                        b->OldB2 = b->Width;
1515
                        b->OldH2 = b->Height;
1516
                }
1517
                break;
167 Franz 1518
        }
294 Franz 1519
        updateGradientVectors(b);
3 paul 1520
}
1521
 
80 Franz 1522
bool Page::SizeItem(double newX, double newY, int ite, bool fromMP, bool DoUpdateClip)
3 paul 1523
{
1524
        PageItem *b = Items.at(ite);
1525
        if (b->Locked)
1526
                return false;
167 Franz 1527
        QRegion alt, neu;
1528
        QPainter p;
3 paul 1529
        if (b->PType != 5)
167 Franz 1530
        {
68 Franz 1531
                newX = QMAX(newX, 1);
1532
                newY = QMAX(newY, 1);
167 Franz 1533
        }
3 paul 1534
        int ph = static_cast<int>(QMAX(1.0, b->Pwidth / 2.0));
1535
        p.begin(this);
1536
        Transform(b, &p);
1537
        alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
1538
        p.end();
132 Franz 1539
        QWMatrix ma;
1540
        ma.rotate(b->Rot);
1541
        double dX = ma.m11() * (b->Width - newX) + ma.m21() * (b->Height - newY) + ma.dx();
1542
        double dY = ma.m22() * (b->Height - newY) + ma.m12() * (b->Width - newX) + ma.dy();
3 paul 1543
        b->Width = newX;
1544
        b->Height = newY;
132 Franz 1545
        if ((doku->RotMode != 0) && (fromMP))
167 Franz 1546
        {
1547
                switch (doku->RotMode)
132 Franz 1548
                {
217 Franz 1549
                case 2:
1550
                        MoveItem(dX / 2.0, dY / 2.0, b);
1551
                        break;
1552
                case 4:
1553
                        MoveItem(dX, dY, b);
1554
                        break;
1555
                case 3:
1556
                        MoveItem(0.0, dY, b);
1557
                        break;
1558
                case 1:
1559
                        MoveItem(dX, 0.0, b);
1560
                        break;
132 Franz 1561
                }
167 Franz 1562
        }
1563
        b->RadRect = QMIN(b->RadRect, QMIN(b->Width,b->Height)/2);
3 paul 1564
        if ((b->PType == 2) && (!b->Sizing) && (!doku->EditClip))
167 Franz 1565
        {
3 paul 1566
                AdjustPictScale(b);
222 Franz 1567
                AdjustPreview(b, false);
167 Franz 1568
        }
3 paul 1569
        if (b->PType == 5)
167 Franz 1570
        {
1571
                if (!fromMP)
3 paul 1572
                {
1573
                        b->Rot = atan2(b->Height,b->Width)*(180.0/3.1415927);
1574
                        b->Width = sqrt(pow(b->Width,2)+pow(b->Height,2));
1575
                        b->Height = 0;
1576
                        emit SetAngle(b->Rot);
1577
                }
167 Franz 1578
                b->Clip.setPoints(4, -ph,-ph, static_cast<int>(b->Width+ph),-ph,
217 Franz 1579
                                  static_cast<int>(b->Width+ph),static_cast<int>(b->Height+ph),
1580
                                  -ph,static_cast<int>(b->Height+ph));
167 Franz 1581
        }
3 paul 1582
        if (b->Sizing)
167 Franz 1583
        {
230 Franz 1584
                emit ItemGeom(b->Width, b->Height);
1585
                emit ItemRadius(b->RadRect);
3 paul 1586
                b->FrameOnly = true;
1587
                b->Tinput = true;
1588
                if ((HowTo == 1) && (b->PType != 5))
1589
                        b->paintObj();
231 Franz 1590
                if ((b->FrameType == 0) || (b->PType == 5) || (HowTo != 1))
230 Franz 1591
                        return true;
1592
                QPainter p;
1593
                p.begin(this);
1594
                Transform(b, &p);
1595
                p.setRasterOp(XorROP);
1596
                p.setBrush(NoBrush);
1597
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
1598
                b->DrawPolyL(&p, b->Clip);
1599
                UpdateClip(b);
1600
                b->DrawPolyL(&p, b->Clip);
1601
                p.end();
3 paul 1602
                return true;
167 Franz 1603
        }
3 paul 1604
        if (DoUpdateClip)
167 Franz 1605
        {
1606
                if (fromMP)
3 paul 1607
                {
1608
                        if (b->flippedH % 2 != 0)
1609
                                MoveItemI(-(b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
1610
                        if (b->flippedV % 2 != 0)
1611
                                MoveItemI(0, -(b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
167 Franz 1612
                }
3 paul 1613
                else
167 Franz 1614
                {
3 paul 1615
                        if (b->flippedH % 2 == 0)
1616
                                MoveItemI((b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
1617
                        if (b->flippedV % 2 == 0)
1618
                                MoveItemI(0, (b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
167 Franz 1619
                }
3 paul 1620
                UpdateClip(b);
167 Franz 1621
        }
295 Franz 1622
        updateGradientVectors(b);
3 paul 1623
        RepaintTextRegion(b, alt);
1624
        if (!fromMP)
167 Franz 1625
        {
1626
                if (GroupSel)
3 paul 1627
                {
80 Franz 1628
                        double gx, gy, gh, gw;
3 paul 1629
                        setGroupRect();
1630
                        getGroupRect(&gx, &gy, &gw, &gh);
1631
                        emit ItemGeom(gw, gh);
167 Franz 1632
                }
3 paul 1633
                else
1634
                        emit ItemGeom(b->Width, b->Height);
167 Franz 1635
        }
3 paul 1636
        emit ItemRadius(b->RadRect);
80 Franz 1637
        return true;
3 paul 1638
}
1639
 
80 Franz 1640
void Page::MoveItemI(double newX, double newY, int ite)
3 paul 1641
{
1642
        PageItem *b = Items.at(ite);
167 Franz 1643
        if ((b->Locked) || (!b->ScaleType))
3 paul 1644
                return;
167 Franz 1645
        QPainter p;
3 paul 1646
        p.begin(this);
1647
        Transform(b, &p);
1648
        TransformM(b, &p);
1649
        QRegion alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
1650
        p.end();
1651
        if (b->flippedH % 2 != 0)
1652
                b->LocalX -= newX;
1653
        else
1654
                b->LocalX += newX;
1655
        if (b->flippedV % 2 != 0)
1656
                b->LocalY -= newY;
1657
        else
1658
                b->LocalY += newY;
272 Franz 1659
        RepaintTextRegion(b, alt, true);
80 Franz 1660
        emit SetLocalValues(b->LocalScX, b->LocalScY, b->LocalX, b->LocalY);
3 paul 1661
}
1662
 
80 Franz 1663
bool Page::MoveItem(double newX, double newY, PageItem* b, bool fromMP)
3 paul 1664
{
167 Franz 1665
        if (b->Locked)
1666
                return false;
3 paul 1667
        QRegion alt;
1668
        bool retw = false;
80 Franz 1669
        double oldx = b->Xpos;
1670
        double oldy = b->Ypos;
3 paul 1671
        if (!Imoved)
167 Franz 1672
        {
3 paul 1673
                QPainter p;
1674
                p.begin(this);
1675
                Transform(b, &p);
1676
                alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
1677
                p.end();
167 Franz 1678
        }
3 paul 1679
        b->Xpos += newX;
1680
        b->Ypos += newY;
254 Franz 1681
        if ((doku->useRaster) && (!Imoved) && (!fromMP))
167 Franz 1682
        {
3 paul 1683
                b->Xpos = qRound(b->Xpos / doku->minorGrid) * doku->minorGrid;
1684
                b->Ypos = qRound(b->Ypos / doku->minorGrid) * doku->minorGrid;
167 Franz 1685
        }
254 Franz 1686
        if ((doku->SnapGuides) && (!Imoved) && (doku->AppMode == 1) && (!doku->EditClip) && (!fromMP))
3 paul 1687
                SnapToGuides(b);
1688
        if ((b->Xpos != oldx) || (b->Ypos != oldy))
1689
                retw = true;
1690
        if ((!Imoved) && (!b->Sizing))
1691
                RepaintTextRegion(b, alt);
1692
        if (!fromMP)
167 Franz 1693
        {
1694
                if (GroupSel)
3 paul 1695
                {
80 Franz 1696
                        double gx, gy, gh, gw;
3 paul 1697
                        setGroupRect();
1698
                        getGroupRect(&gx, &gy, &gw, &gh);
1699
                        emit ItemPos(gx, gy);
167 Franz 1700
                }
3 paul 1701
                else
1702
                        emit ItemPos(b->Xpos, b->Ypos);
167 Franz 1703
        }
91 Franz 1704
        if (!doku->loading)
1705
                emit UpdtObj(PageNr, b->ItemNr);
80 Franz 1706
        return retw;
3 paul 1707
}
1708
 
128 Franz 1709
void Page::RotateGroup(double win)
1710
{
129 Franz 1711
        double gxS, gyS, ghS, gwS;
128 Franz 1712
        PageItem* b;
1713
        FPoint n;
1714
        getGroupRectScreen(&gxS, &gyS, &gwS, &ghS);
129 Franz 1715
        QWMatrix ma;
1716
        ma.translate(RCenter.x(), RCenter.y());
1717
        ma.scale(1, 1);
1718
        ma.rotate(win);
167 Franz 1719
        QRect alt = QRect(static_cast<int>(gxS-5), static_cast<int>(gyS-5), static_cast<int>(gwS+10),
217 Franz 1720
                          static_cast<int>(ghS+10));
128 Franz 1721
        for (uint a = 0; a < SelItem.count(); ++a)
167 Franz 1722
        {
128 Franz 1723
                b = SelItem.at(a);
129 Franz 1724
                n = FPoint(b->Xpos - RCenter.x(), b->Ypos - RCenter.y());
128 Franz 1725
                b->Xpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1726
                b->Ypos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
129 Franz 1727
                b->Rot += win;
167 Franz 1728
        }
128 Franz 1729
        setGroupRect();
1730
        getGroupRectScreen(&gxS, &gyS, &gwS, &ghS);
167 Franz 1731
        repaint(QRect(static_cast<int>(gxS-5), static_cast<int>(gyS-5), static_cast<int>(gwS+10),
217 Franz 1732
                      static_cast<int>(ghS+10)).unite(alt));
128 Franz 1733
}
1734
 
80 Franz 1735
void Page::RotateItem(double win, int ite)
3 paul 1736
{
1737
        PageItem *b;
1738
        b = Items.at(ite);
1739
        if (b->Locked)
1740
                return;
167 Franz 1741
        QRegion alt, neu;
1742
        QPainter p;
1743
        FPoint n;
3 paul 1744
        p.begin(this);
1745
        Transform(b, &p);
1746
        alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
1747
        p.end();
1748
        if ((doku->RotMode != 0) && (b->PType != 5))
167 Franz 1749
        {
3 paul 1750
                QWMatrix ma;
1751
                ma.translate(b->Xpos, b->Ypos);
1752
                ma.scale(1, 1);
1753
                ma.rotate(b->Rot);
80 Franz 1754
                double ro = win-b->Rot;
3 paul 1755
                b->Rot = win;
1756
                switch (doku->RotMode)
167 Franz 1757
                {
217 Franz 1758
                case 2:
1759
                        ma.translate(b->Width/2, b->Height/2);
1760
                        n = FPoint(-b->Width/2, -b->Height/2);
1761
                        break;
1762
                case 4:
1763
                        ma.translate(b->Width, b->Height);
1764
                        n = FPoint(-b->Width, -b->Height);
1765
                        break;
1766
                case 3:
1767
                        ma.translate(0, b->Height);
1768
                        n = FPoint(0, -b->Height);
1769
                        break;
1770
                case 1:
1771
                        ma.translate(b->Width, 0);
1772
                        n = FPoint(-b->Width, 0);
1773
                        break;
167 Franz 1774
                }
3 paul 1775
                ma.rotate(ro);
80 Franz 1776
                double x = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
1777
                double y = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
3 paul 1778
                MoveItem(x-b->Xpos, y-b->Ypos, b);
167 Franz 1779
        }
3 paul 1780
        else
1781
                b->Rot = win;
1782
        RepaintTextRegion(b, alt);
1783
        emit SetAngle(b->Rot);
1784
}
1785
 
1786
void Page::SnapToGuides(PageItem* b)
1787
{
1788
        if (YGuides.count() != 0)
167 Franz 1789
        {
1790
                for (uint yg = 0; yg < YGuides.count(); ++yg)
3 paul 1791
                {
167 Franz 1792
                        if ((YGuides[yg] < (b->Ypos+doku->GuideRad)) && (YGuides[yg] > (b->Ypos-doku->GuideRad)))
3 paul 1793
                        {
1794
                                b->Ypos = YGuides[yg];
1795
                                break;
167 Franz 1796
                        }
3 paul 1797
                        if (b->PType == 5)
167 Franz 1798
                        {
3 paul 1799
                                QWMatrix ma;
1800
                                ma.translate(b->Xpos, b->Ypos);
1801
                                ma.rotate(b->Rot);
80 Franz 1802
                                double my = ma.m22() * b->Height + ma.m12() * b->Width + ma.dy();
3 paul 1803
                                if ((YGuides[yg] < (my+doku->GuideRad)) && (YGuides[yg] > (my-doku->GuideRad)))
167 Franz 1804
                                {
3 paul 1805
                                        b->Ypos = b->Ypos + YGuides[yg] - my;
1806
                                        break;
1807
                                }
167 Franz 1808
                        }
3 paul 1809
                        else
167 Franz 1810
                        {
217 Franz 1811
                                if ((YGuides[yg] < (b->Ypos+b->Height+doku->GuideRad)) &&
1812
                                        (YGuides[yg] > ((b->Ypos+b->Height)-doku->GuideRad)))
3 paul 1813
                                {
1814
                                        b->Ypos = YGuides[yg]-b->Height;
1815
                                        break;
1816
                                }
1817
                        }
1818
                }
167 Franz 1819
        }
3 paul 1820
        if (XGuides.count() != 0)
167 Franz 1821
        {
1822
                for (uint xg = 0; xg < XGuides.count(); ++xg)
3 paul 1823
                {
167 Franz 1824
                        if ((XGuides[xg] < (b->Xpos+doku->GuideRad)) && (XGuides[xg] > (b->Xpos-doku->GuideRad)))
3 paul 1825
                        {
1826
                                b->Xpos = XGuides[xg];
1827
                                break;
167 Franz 1828
                        }
3 paul 1829
                        if (b->PType == 5)
167 Franz 1830
                        {
3 paul 1831
                                QWMatrix ma;
1832
                                ma.translate(b->Xpos, b->Ypos);
1833
                                ma.rotate(b->Rot);
80 Franz 1834
                                double mx = ma.m11() * b->Width + ma.m21() * b->Height + ma.dx();
3 paul 1835
                                if ((XGuides[xg] < (mx+doku->GuideRad)) && (XGuides[xg] > (mx-doku->GuideRad)))
167 Franz 1836
                                {
3 paul 1837
                                        b->Xpos = b->Xpos + XGuides[xg] - mx;
1838
                                        break;
1839
                                }
167 Franz 1840
                        }
3 paul 1841
                        else
167 Franz 1842
                        {
217 Franz 1843
                                if ((XGuides[xg] < (b->Xpos+b->Width+doku->GuideRad)) &&
1844
                                        (XGuides[xg] > ((b->Xpos+b->Width)-doku->GuideRad)))
3 paul 1845
                                {
1846
                                        b->Xpos = XGuides[xg]-b->Width;
1847
                                        break;
1848
                                }
1849
                        }
1850
                }
167 Franz 1851
        }
3 paul 1852
}
1853
 
1854
void Page::sentToScrap()
1855
{
1856
        ScriXmlDoc *ss = new ScriXmlDoc();
1857
        emit ToScrap(ss->WriteElem(&SelItem, doku));
1858
        delete ss;
1859
}
1860
 
1861
void Page::sentToLayer(int id)
80 Franz 1862
{
3 paul 1863
        int d = pmen3->indexOf(id);
153 Franz 1864
        int dd = doku->Layers[d].LNr;
167 Franz 1865
        if (SelItem.count() != 0)
217 Franz 1866
        {
1867
                for (uint a = 0; a < SelItem.count(); ++a)
1868
                {
142 Franz 1869
                        PageItem *b = SelItem.at(a);
153 Franz 1870
                        b->LayerNr = dd;
142 Franz 1871
                }
167 Franz 1872
        }
3 paul 1873
        Deselect(true);
167 Franz 1874
        update();
268 Franz 1875
        emit DocChanged();
3 paul 1876
}
1877
 
1878
bool Page::PointOnLine(QPoint Start, QPoint Ende, QRect MArea)
1879
{
1880
        QPoint an, en;
1881
        if (Start.x() == Ende.x())
167 Franz 1882
        {
1883
                an = Start.y() > Ende.y() ? Ende : Start;
1884
                en = an == Ende ? Start : Ende;
1885
                for (int a=an.y(); a<en.y(); ++a)
3 paul 1886
&nbs