Subversion Repositories Scribus

Rev

Rev 114 | Rev 116 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          pageitem.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 "pageitem.h"
19
#include <qpainter.h>
20
#include <qpen.h>
68 Franz 21
#include <qfont.h>
3 paul 22
#include <qregion.h>
23
#include <qpoint.h>
24
#include <qfileinfo.h>
25
#include <qdrawutil.h>
26
#include <qbitmap.h>
27
#include <cmath>
28
#include "page.h"
29
#include "config.h"
68 Franz 30
#include <ft2build.h>
31
#include FT_GLYPH_H
80 Franz 32
extern double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
3 paul 33
extern QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs);
80 Franz 34
extern double xy2Deg(double x, double y);
3 paul 35
extern void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4);
36
 
80 Franz 37
PageItem::PageItem(Page *pa, int art, double x, double y, double w, double h, double w2, QString fill, QString outline, ScribusDoc *doc) : QObject(pa)
3 paul 38
{
39
        QString tmp;
40
        BackBox = 0;
41
        NextBox = 0;
42
        Locked = false;
43
        Xpos = x;
44
        Ypos = y;
45
        Width = w;
46
        Height = h;
47
        OldB = Width;
48
        OldH = Height;
49
        OldB2 = Width;
50
        OldH2 = Height;
51
        PType = art;
52
        Rot = 0;
53
        Parent = pa;
54
        Doc = doc;
55
        Pcolor = fill;
68 Franz 56
        if (PType == 4)
57
                Pcolor2 = fill;
58
        else
59
                Pcolor2 = outline;
60
        TxtFill = Doc->DpenText;
61
        TxtStroke = TxtFill;
62
        ShTxtStroke = 100;
63
        ShTxtFill = 100;
64
        TxtScale = 100;
65
        TxTStyle = 0;
3 paul 66
        Shade = 100;
67
        Shade2 = 100;
98 Franz 68
        GrColor = Pcolor2;
69
        GrColor2 = Pcolor2;
3 paul 70
        GrShade = 100;
71
        GrShade2 = 100;
72
        GrType = 0;
73
        Pwidth = w2;
74
        PLineArt = Doc->DLineArt;
75
        PLineEnd = FlatCap;
76
        PLineJoin = MiterJoin;
77
        Select = false;
78
        FrameOnly = false;
79
        ClipEdited = false;
80
        FrameType = 0;
81
        IFont = Doc->Dfont;
82
        ISize = Doc->Dsize;
111 Franz 83
        LineSp = ((Doc->Dsize / 10.0) * static_cast<double>(Doc->AutoLine) / 100) + (Doc->Dsize / 10.0);
3 paul 84
        Doc->Vorlagen[0].LineSpa = LineSp;
85
        CurX = 0;
86
        CurY = 0;
87
        CPos = 0;
88
        Extra = 1;
89
        TExtra = 1;
90
        BExtra = 1;
91
        RExtra = 1;
92
        ExtraV = 0;
93
        Ptext.clear();
94
        Ptext.setAutoDelete(true);
95
        Pfile = "";
96
        pixm = QImage();
97
        Pfile2 = "";
98
        Pfile3 = "";
99
        LocalScX = 1;
100
        LocalScY = 1;
101
        LocalViewX = 1;
102
        LocalViewY = 1;
103
        OrigW = 0;
104
        OrigH = 0;
105
        LocalX = 0;
106
        LocalY = 0;
107
        flippedH = 0;
108
        flippedV = 0;
109
        BBoxX = 0;
110
        BBoxH = 0;
111
        RadRect = 0;
112
        if ((art == 4) || (art == 2))
113
                Frame = true;
114
        else
115
                Frame = false;
116
        switch (art)
117
                {
118
                case 6:
119
                        Clip.setPoints(4, static_cast<int>(w/2),0, static_cast<int>(w),static_cast<int>(h/2), static_cast<int>(w/2),static_cast<int>(h), 0,static_cast<int>(h/2));
120
                        break;
121
                default:
122
                        Clip.setPoints(4, 0,0, static_cast<int>(w),0, static_cast<int>(w),static_cast<int>(h), 0,static_cast<int>(h));
123
                        break;
124
                }
125
        PoLine.resize(0);
126
        Segments.clear();
127
        PoShow = false;
128
        BaseOffs = 0;
129
        OwnPage = pa;
130
        PicArt = true;
131
        PicAvail = false;
132
        isPrintable = true;
133
        isBookmark = false;
134
  BMnr = 0;
135
        isAnnotation = false;
136
        AnType = 0;
137
        AnActType = 0;
138
        AnBwid = 1;
139
        AnAction = "";
140
        An_E_act = "";
141
        An_X_act = "";
142
        An_D_act = "";
143
        An_Fo_act = "";
144
        An_Bl_act = "";
145
        An_K_act = "";
146
        An_F_act = "";
147
        An_V_act = "";
148
        An_C_act = "";
19 Franz 149
        An_Extern = "";
3 paul 150
        AnName = "Item"+tmp.setNum(Doc->TotalItems);
87 Franz 151
        AutoName = true;
3 paul 152
        Doc->TotalItems++;
153
        AnToolTip = "";
154
        AnRollOver = "";
155
        AnDown = "";
156
        AnBsty = 0;
157
        AnFeed = 1;
158
        AnFlag = 0;
159
        AnZiel = 0;
160
        AnVis = 0;
161
        AnChkStil = 0;
162
        AnFormat = 0;
163
        AnFont = 4;
164
        AnIsChk = false;
165
        AnAAact = false;
166
        AnHTML = false;
167
        AnUseIcons = false;
168
        AnIPlace = 1;
169
        AnScaleW = 0;
170
        AnMaxChar = -1;
171
        AnBColor = outline;
172
        HasSel = false;
173
        Textflow = true;
17 Franz 174
        Textflow2 = false;
3 paul 175
        Tinput = false;
176
        isAutoText = false;
177
        Ausrich = 0;
178
        Redrawn = false;
179
        isRaster = false;
180
        Sizing = false;
181
        toPixmap = false;
182
        UseEmbedded = true;
183
        EmProfile = "";
184
        Groups.clear();
185
        LayerNr = Doc->ActiveLayer;
186
        ScaleType = true;
187
        AspectRatio = true;
188
        Transparency = 0.0;
68 Franz 189
        TranspStroke = 0.0;
3 paul 190
        Reverse = false;
20 Franz 191
        InvPict = false;
27 Franz 192
        NamedLStyle = "";
68 Franz 193
        DashValues.clear();
194
        DashOffset = 0;
195
        fill_gradient = VGradient(VGradient::linear);
196
        Language = doc->Language;
3 paul 197
}
198
 
199
/** Zeichnet das Item */
68 Franz 200
void PageItem::DrawObj(ScPainter *p, QRect e)
3 paul 201
{
68 Franz 202
        QColor tmp;
203
        FPointArray CL;
204
        QPointArray cl;
205
        QPainter pf, pp;
206
        PageItem *nb;
3 paul 207
        QPoint pt1, pt2;
68 Franz 208
        FPoint gv;
3 paul 209
        QRegion cm;
210
        uint a, nrc, nrc2, zae;
68 Franz 211
        int desc, asce, absa, aSpa, chs;
114 Franz 212
        uint BuPos, LastSP, BuPos2, MaxText;
110 Franz 213
        double oldCurY, LastXp, EndX, OFs, OFs2, wide, rota, wid, lineCorr;
80 Franz 214
        double sc = Doc->Scale;
55 Franz 215
        QString chx, chx2, chx3;
3 paul 216
        struct Pti *hl;
217
        struct ZZ *Zli;
218
        struct ZZ *Zli2;
219
        QPtrList<ZZ> LiList;
68 Franz 220
        bool outs = false;
63 Franz 221
        if (!Doc->DoDrawing)
222
                {
223
                Redrawn = true;
224
                Tinput = false;
225
                FrameOnly = false;
226
                Dirty = false;
227
                return;
228
                }
3 paul 229
        LiList.setAutoDelete(true);
230
        for (int xxx=0; xxx<5; ++xxx)
231
                {
232
                Doc->Vorlagen[xxx].LineSpa = LineSp;
233
                Doc->Vorlagen[xxx].Indent = 0;
234
                Doc->Vorlagen[xxx].First = 0;
235
                Doc->Vorlagen[xxx].Avor = 0;
236
                Doc->Vorlagen[xxx].Anach = 0;
237
                }
238
        Doc->Vorlagen[0].Ausri = Ausrich;
68 Franz 239
        pf.begin(Parent);
240
        pf.translate(static_cast<int>(Xpos*sc), static_cast<int>(Ypos*sc));
241
        pf.scale(static_cast<double>(sc), static_cast<double>(sc));
242
        pf.rotate(static_cast<double>(Rot));
243
        if (!Doc->RePos)
3 paul 244
                {
245
                if (!e.isEmpty())
68 Franz 246
                        pf.setClipRect(e);
3 paul 247
                else
68 Franz 248
                        pf.setClipRect(OwnPage->ViewReg().boundingRect());
3 paul 249
                }
68 Franz 250
        bool doStroke = true;
251
        p->setZoomFactor(sc);
252
        p->save();
253
        p->translate(-e.x(), -e.y());
254
        p->translate(Xpos*sc, Ypos*sc);
255
        p->rotate(static_cast<double>(Rot));
256
        p->setLineWidth(Pwidth);
3 paul 257
        if (Pcolor != "None")
258
                {
259
                SetFarbe(&tmp, Pcolor, Shade);
68 Franz 260
                p->setBrush(tmp);
261
                p->setFillMode(1);
3 paul 262
                }
263
        else
68 Franz 264
                p->setFillMode(0);
265
        if (GrType != 0)
266
                {
267
                p->setFillMode(2);
268
                p->fill_gradient = fill_gradient;
269
                QWMatrix grm;
270
                grm.rotate(Rot);
271
                FPointArray gra;
272
                switch (GrType)
273
                        {
274
                        case 1:
275
                                gra.setPoints(2, 0, 0, Width, 0);
276
                                gra.map(grm);
277
                                p->setGradient(VGradient::linear, gra.point(0), gra.point(1));
278
                                break;
279
                        case 2:
280
                                gra.setPoints(2, 0, 0, Height, 0);
281
                                grm.rotate(90);
282
                                gra.map(grm);
283
                                p->setGradient(VGradient::linear, gra.point(0), gra.point(1));
284
                                break;
285
                        case 3:
286
                                gra.setPoints(2, 0, 0, Width, Height);
287
                                gra.map(grm);
288
                                p->setGradient(VGradient::linear, gra.point(0), gra.point(1));
289
                                break;
290
                        case 4:
291
                                gra.setPoints(2, 0, Height, Width, 0);
292
                                gra.map(grm);
293
                                p->setGradient(VGradient::linear, gra.point(0), gra.point(1));
294
                                break;
295
                        case 5:
296
                                if (Width > Height)
297
                                        gv = FPoint(Width, Height / 2.0);
298
                                else
299
                                        gv = FPoint(Width / 2.0, Height);
300
                                p->setGradient(VGradient::radial, FPoint(Width / 2.0,Height / 2.0), gv, FPoint(Width / 2.0,Height / 2.0));
301
                                break;
302
                        }
303
                }
3 paul 304
        if (Pcolor2 != "None")
305
                {
306
                SetFarbe(&tmp, Pcolor2, Shade2);
307
                if ((Pwidth == 0) && (PType != 5))
68 Franz 308
                        p->setLineWidth(0);
3 paul 309
                else
68 Franz 310
                        {
311
                        p->setPen(tmp, Pwidth, PLineArt, PLineEnd, PLineJoin);
312
                        if (DashValues.count() != 0)
313
                                p->setDash(DashValues, DashOffset);
314
                        }
3 paul 315
                }
316
        else
68 Franz 317
                p->setLineWidth(0);
318
        p->setBrushOpacity(1.0 - Transparency);
319
        p->setPenOpacity(1.0 - TranspStroke);
320
        switch (PType)
3 paul 321
                {
68 Franz 322
                case 2:
323
                        if (Doc->RePos)
324
                                break;
325
                        if ((Pcolor != "None") || (GrType != 0))
326
                                {
327
                                p->setupPolygon(&PoLine);
328
                                p->drawPolygon();
329
                                }
330
                        if (Pfile == "")
331
                                {
332
                                p->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
333
                                p->drawLine(FPoint(0, 0), FPoint(Width, Height));
334
                                p->drawLine(FPoint(0, Height), FPoint(Width, 0));
335
                                }
336
                        else
337
                                {
338
                                QBitmap bmd = QBitmap(static_cast<int>(Width), static_cast<int>(Height));
3 paul 339
                                bmd.fill(Qt::color0);
68 Franz 340
                                QPainter pb;
3 paul 341
                                pb.begin(&bmd);
342
                                pb.setBrush(Qt::color1);
343
                                pb.setPen(QPen(Qt::color1, 1, DotLine, FlatCap, MiterJoin));
344
                                DrawPoly(&pb, Clip, pb.brush().color(), true);
345
                                pb.end();
68 Franz 346
                                QPixmap pmd = QPixmap(static_cast<int>(Width), static_cast<int>(Height));
3 paul 347
                                pmd.fill();
68 Franz 348
                                QPainter pd;
3 paul 349
                                pd.begin(&pmd);
68 Franz 350
                                if ((!PicArt) || (!PicAvail))
3 paul 351
                                        {
352
                                        pd.setPen(QPen(black, 1, SolidLine, FlatCap, MiterJoin));
68 Franz 353
                                        pd.drawLine(0, 0, static_cast<int>(Width), static_cast<int>(Height));
354
                                        pd.drawLine(0, static_cast<int>(Height), static_cast<int>(Width), 0);
355
                                        if (PicAvail)
356
                                                pd.setPen(blue);
357
                                        else
358
                                                pd.setPen(red);
359
                                        pd.setBackgroundMode(OpaqueMode);
360
                                        pd.setFont(QFont("Helvetica", 18));
361
                                        QFileInfo fi = QFileInfo(Pfile);
362
                                        int leng = pd.fontMetrics().width(fi.fileName());
363
                                        int xp = static_cast<int>(Width / 2 - leng / 2);
364
                                        int yp = static_cast<int>(Height / 2 + pd.fontMetrics().height() / 2);
365
                                        pd.drawText(xp, yp, fi.fileName());
3 paul 366
                                        }
367
                                else
368
                                        {
68 Franz 369
                                        if ((Pcolor != "None") || (GrType != 0))
3 paul 370
                                                {
68 Franz 371
                                                pd.setPen(NoPen);
372
                                                SetFarbe(&tmp, Pcolor, Shade);
373
                                                pd.setBrush(tmp);
374
                                                if (!Doc->RePos)
3 paul 375
                                                        {
68 Franz 376
                                                        if (GrType == 0)
377
                                                                DrawPoly(&pd, Clip, pd.brush().color());
3 paul 378
                                                        }
379
                                                }
68 Franz 380
                                        if (flippedH % 2 != 0)
31 Franz 381
                                                {
68 Franz 382
                                                pd.translate(Width, 0);
383
                                                pd.scale(-1, 1);
31 Franz 384
                                                }
68 Franz 385
                                        if (flippedV % 2 != 0)
3 paul 386
                                                {
68 Franz 387
                                                pd.translate(0, static_cast<int>(Height));
388
                                                pd.scale(1, -1);
3 paul 389
                                                }
68 Franz 390
                                        if ((LocalViewX != 1) || (LocalViewY != 1))
391
                                                pd.scale(LocalViewX, LocalViewY);
392
                                        if (InvPict)
3 paul 393
                                                {
68 Franz 394
                                                QImage ip = pixm.copy();
395
                                                ip.invertPixels();
396
                                                pd.drawImage(static_cast<int>(LocalX*LocalScX), static_cast<int>(LocalY*LocalScY), ip);
3 paul 397
                                                }
68 Franz 398
                                        else
399
                                                pd.drawImage(static_cast<int>(LocalX*LocalScX), static_cast<int>(LocalY*LocalScY), pixm);
3 paul 400
                                        }
80 Franz 401
                                pmd.setMask(bmd);
402
                                QImage ip2 = pmd.convertToImage();
403
                                p->drawImage(ip2);
68 Franz 404
                                pd.end();
405
                                }
406
                        break;
407
                case 5:
408
                        if (Doc->RePos)
409
                                break;
410
                        if (NamedLStyle == "")
411
                                p->drawLine(FPoint(0, 0), FPoint(Width, 0));
412
                        else
413
                                {
414
                                multiLine ml = Doc->MLineStyles[NamedLStyle];
415
                                for (int it = ml.size()-1; it > -1; it--)
9 Franz 416
                                        {
68 Franz 417
                                        SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
418
                                        p->setPen(tmp, ml[it].Width,
419
                                                                         static_cast<PenStyle>(ml[it].Dash),
420
                                                                         static_cast<PenCapStyle>(ml[it].LineEnd),
421
                                                                         static_cast<PenJoinStyle>(ml[it].LineJoin));
422
                                        p->drawLine(FPoint(0, 0), FPoint(Width, 0));
9 Franz 423
                                        }
68 Franz 424
                                doStroke = false;
425
                                }
426
                        break;
427
                case 1:
428
                case 3:
429
                case 6:
430
                        if (Doc->RePos)
3 paul 431
                                break;
68 Franz 432
                        p->setupPolygon(&PoLine);
433
                        p->drawPolygon();
434
                        break;
435
                case 7:
436
                        if (Doc->RePos)
437
                                break;
438
                        p->setupPolygon(&PoLine);
439
                        if (NamedLStyle == "")
440
                                p->drawPolyLine();
441
                        else
442
                                {
443
                                multiLine ml = Doc->MLineStyles[NamedLStyle];
444
                                for (int it = ml.size()-1; it > -1; it--)
3 paul 445
                                        {
68 Franz 446
                                        SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
447
                                        p->setPen(tmp, ml[it].Width,
448
                                                                         static_cast<PenStyle>(ml[it].Dash),
449
                                                                         static_cast<PenCapStyle>(ml[it].LineEnd),
450
                                                                         static_cast<PenJoinStyle>(ml[it].LineJoin));
451
                                        p->drawPolyLine();
452
                                        }
453
                                }
454
                        doStroke = false;
455
                        break;
456
                case 4:
457
                        p->save();
458
                        if ((Pcolor != "None") || (GrType != 0))
459
                                {
460
                                p->setupPolygon(&PoLine);
461
                                p->drawPolygon();
462
                                }
110 Franz 463
                        if (Pcolor2 != "None")
464
                                lineCorr = Pwidth / 2.0;
465
                        else
466
                                lineCorr = 0;
68 Franz 467
                        if ((isAnnotation) && (AnType == 2) && (Pfile != "") && (PicAvail) && (PicArt) && (AnUseIcons))
468
                                {
469
                                QBitmap bmd = QBitmap(static_cast<int>(Width), static_cast<int>(Height));
470
                                bmd.fill(Qt::color0);
471
                                QPainter pb;
472
                                pb.begin(&bmd);
473
                                pb.setBrush(Qt::color1);
474
                                pb.setPen(QPen(Qt::color1, 1, DotLine, FlatCap, MiterJoin));
475
                                DrawPoly(&pb, Clip, pb.brush().color(), true);
476
                                pb.end();
477
                                QPixmap pmd = QPixmap(static_cast<int>(Width), static_cast<int>(Height));
478
                                pmd.fill();
479
                                QPainter pd;
480
                                pd.begin(&pmd);
481
                                if ((Pcolor != "None") || (GrType != 0))
482
                                        {
483
                                        pd.setPen(NoPen);
484
                                        SetFarbe(&tmp, Pcolor, Shade);
485
                                        pd.setBrush(tmp);
3 paul 486
                                        if (!Doc->RePos)
487
                                                {
488
                                                if (GrType == 0)
68 Franz 489
                                                        DrawPoly(&pd, Clip, pd.brush().color());
3 paul 490
                                                }
491
                                        }
68 Franz 492
                                pd.drawImage(static_cast<int>(LocalX*LocalScX), static_cast<int>(LocalY*LocalScY), pixm);
493
                                pmd.setMask(bmd);
494
                                QImage ip2 = pmd.convertToImage();
495
                                p->drawImage(ip2);
496
                                }
497
                        if ((Ptext.count() != 0) || (Dirty) || (NextBox != 0))
498
                                {
499
                                if (NextBox != 0)
3 paul 500
                                        {
68 Franz 501
                                        nb = NextBox;
502
                                        while (nb != 0)
3 paul 503
                                                {
68 Franz 504
                                                a = nb->Ptext.count();
505
                                                for (uint s=0; s<a; ++s)
3 paul 506
                                                        {
68 Franz 507
                                                        Ptext.append(nb->Ptext.take(0));
3 paul 508
                                                        }
108 Franz 509
                                                nb->MaxChars = 0;
68 Franz 510
                                                nb->Dirty = true;
511
                                                nb = nb->NextBox;
3 paul 512
                                                }
68 Franz 513
                                        nb = NextBox;
3 paul 514
                                        }
68 Franz 515
                                Doc->Vorlagen[0].LineSpa = LineSp;
516
                                QRegion cl = QRegion(pf.xForm(Clip));
517
                                for (a=0; a<OwnPage->Items.count(); ++a)
3 paul 518
                                        {
68 Franz 519
                                        if (((OwnPage->Items.at(a)->ItemNr > ItemNr)
520
                                                                && (OwnPage->Items.at(a)->LayerNr == LayerNr))
521
                                                        || (Doc->Layers[OwnPage->Items.at(a)->LayerNr].Level > Doc->Layers[LayerNr].Level))
3 paul 522
                                                {
68 Franz 523
                                                if (OwnPage->Items.at(a)->Textflow)
3 paul 524
                                                        {
68 Franz 525
                                                        pp.begin(Parent);
526
                                                        pp.translate(OwnPage->Items.at(a)->Xpos*sc, OwnPage->Items.at(a)->Ypos*sc);
527
                                                        pp.scale(sc, sc);
528
                                                        pp.rotate(OwnPage->Items.at(a)->Rot);
529
                                                        if (OwnPage->Items.at(a)->Textflow2)
530
                                                                {
531
                                                                QPointArray tcli;
532
                                                                tcli.resize(4);
533
                                                                tcli.setPoint(0, QPoint(0,0));
534
                                                                tcli.setPoint(1, QPoint(qRound(OwnPage->Items.at(a)->Width), 0));
535
                                                                tcli.setPoint(2, QPoint(qRound(OwnPage->Items.at(a)->Width), qRound(OwnPage->Items.at(a)->Height)));
536
                                                                tcli.setPoint(3, QPoint(0, qRound(OwnPage->Items.at(a)->Height)));
537
                                                                cm = QRegion(pp.xForm(tcli));
538
                                                                }
539
                                                        else
540
                                                                cm = QRegion(pp.xForm(OwnPage->Items.at(a)->Clip));
541
                                                        pp.end();
542
                                                        cl = cl.subtract(cm);
3 paul 543
                                                        }
544
                                                }
545
                                        }
68 Franz 546
                                if (flippedH % 2 != 0)
3 paul 547
                                        {
68 Franz 548
                                        p->translate(Width * sc, 0);
549
                                        p->scale(-1, 1);
3 paul 550
                                        }
68 Franz 551
                                if (flippedV % 2 != 0)
3 paul 552
                                        {
68 Franz 553
                                        p->translate(0, Height * sc);
554
                                        p->scale(1, -1);
3 paul 555
                                        }
68 Franz 556
                                if ((Doc->AppMode == 7) && (Dirty))
557
                                        Dirty = false;
110 Franz 558
                                CurX = Extra + lineCorr;
559
                                CurY = Doc->Vorlagen[0].LineSpa+TExtra+lineCorr;
68 Franz 560
                                LiList.clear();
561
                                BuPos = 0;
562
                                BuPos2 = 0;
563
                                LastSP = 0;
564
                                LastXp = 0;
565
                                outs = false;
566
                                OFs = 0;
567
                                OFs2 = 0;
568
                                aSpa = 0;
569
                                absa = 0;
114 Franz 570
                                MaxText = Ptext.count();
571
                                for (a = 0; a < MaxText; ++a)
3 paul 572
                                        {
68 Franz 573
                                        hl = Ptext.at(a);
574
                                        chx = hl->ch;
575
                                        if (hl->ch == QChar(30))
576
                                                chx = ExpandToken(a);
577
                                        absa = hl->cab;
578
                                        if (a == 0)
3 paul 579
                                                {
68 Franz 580
                                                if (BackBox != 0)
3 paul 581
                                                        {
68 Franz 582
                                                        nb = BackBox;
115 Franz 583
                                                        if (nb->Ptext.count() != 0)
3 paul 584
                                                                {
115 Franz 585
                                                                if (nb->Ptext.at(nb->Ptext.count()-1)->ch == QChar(13))
3 paul 586
                                                                        {
115 Franz 587
                                                                        CurX += Doc->Vorlagen[absa].First;
588
                                                                        CurX += Doc->Vorlagen[absa].Indent;
589
                                                                        CurY += Doc->Vorlagen[absa].Avor;
3 paul 590
                                                                        }
115 Franz 591
                                                                else
592
                                                                        CurX += Doc->Vorlagen[absa].Indent;
3 paul 593
                                                                }
594
                                                        }
595
                                                else
596
                                                        {
68 Franz 597
                                                        CurX += Doc->Vorlagen[absa].First;
598
                                                        CurX += Doc->Vorlagen[absa].Indent;
599
                                                        CurY += Doc->Vorlagen[absa].Avor;
3 paul 600
                                                        }
601
                                                }
68 Franz 602
                                        if ((Doc->Vorlagen[0].LineSpa != Doc->Vorlagen[absa].LineSpa) && (a == 0))
603
                                                CurY += Doc->Vorlagen[absa].Avor;
604
                                        if (LiList.count() == 0)
3 paul 605
                                                {
68 Franz 606
                                                CurY += Doc->Vorlagen[absa].LineSpa - Doc->Vorlagen[0].LineSpa;
607
                                                if ((a > 0) && (Ptext.at(a-1)->ch == QChar(13)))
3 paul 608
                                                        {
68 Franz 609
                                                        CurX += Doc->Vorlagen[hl->cab].First;
610
                                                        CurX += Doc->Vorlagen[hl->cab].Indent;
611
                                                        CurY += Doc->Vorlagen[hl->cab].Avor;
3 paul 612
                                                        }
68 Franz 613
                                                }
614
                                        oldCurY = CurY;
615
                                        chs = hl->csize;
616
                                        SetZeichAttr(hl, &chs, &chx);
617
                                        if (chx == QChar(29))
618
                                                chx2 = " ";
619
                                        else
620
                                                chx2 = chx;
114 Franz 621
                                        if (a < MaxText-1)
68 Franz 622
                                                {
623
                                                if (Ptext.at(a+1)->ch == QChar(29))
624
                                                        chx3 = " ";
3 paul 625
                                                else
68 Franz 626
                                                        chx3 = Ptext.at(a+1)->ch;
627
                                                wide = Cwidth(Doc, hl->cfont, chx2, chs, chx3);
628
                                                }
629
                                        else
630
                                                wide = Cwidth(Doc, hl->cfont, chx2, chs);
631
                                        wide = wide * (hl->cscale / 100.0);
111 Franz 632
                                        desc = static_cast<int>(-(*Doc->AllFonts)[hl->cfont]->numDescender * (chs / 10.0));
633
                                        asce = static_cast<int>((*Doc->AllFonts)[hl->cfont]->numAscent * (chs / 10.0));
68 Franz 634
                                        if (LiList.isEmpty())
635
                                                {
110 Franz 636
                                                pt1 = QPoint(static_cast<int>(CurX), static_cast<int>(CurY+desc+BExtra+lineCorr));
68 Franz 637
                                                pt2 = QPoint(static_cast<int>(CurX), static_cast<int>(CurY-asce));
638
                                                while ((!cl.contains(pf.xForm(pt1))) || (!cl.contains(pf.xForm(pt2))))
3 paul 639
                                                        {
68 Franz 640
                                                        CurX++;
641
                                                        pt1 = QPoint(static_cast<int>(CurX), static_cast<int>(CurY+desc));
3 paul 642
                                                        pt2 = QPoint(static_cast<int>(CurX), static_cast<int>(CurY-asce));
110 Franz 643
                                                        if (CurX+RExtra+lineCorr > Width)
3 paul 644
                                                                {
68 Franz 645
                                                                CurY += Doc->Vorlagen[hl->cab].LineSpa;
646
                                                                CurY += Doc->Vorlagen[hl->cab].Anach;
110 Franz 647
                                                                CurX = Extra+lineCorr;
648
                                                                if (CurY+BExtra+lineCorr > Height)
3 paul 649
                                                                        {
68 Franz 650
                                                                        nrc = a;
651
                                                                        goto NoRoom;
3 paul 652
                                                                        }
653
                                                                }
654
                                                        }
68 Franz 655
                                                }
656
                                        hl->xp = CurX+hl->cextra;
657
                                        hl->yp = CurY;
658
                                        CurY = oldCurY;
659
                                        CurX += wide+hl->cextra;
110 Franz 660
                                        pt1 = QPoint(static_cast<int>(CurX+RExtra+lineCorr), static_cast<int>(CurY+desc+BExtra+lineCorr));
661
                                        pt2 = QPoint(static_cast<int>(CurX+RExtra+lineCorr), static_cast<int>(CurY-asce));
68 Franz 662
                                        if ((!cl.contains(pf.xForm(pt1))) || (!cl.contains(pf.xForm(pt2))))
663
                                                outs = true;
664
                                        Zli = new ZZ;
665
                                        Zli->Zeich = chx;
666
                                        Zli->Farb = hl->ccolor;
667
                                        Zli->shade = hl->cshade;
668
                                        Zli->Farb2 = hl->cstroke;
669
                                        Zli->shade2 = hl->cshade2;
670
                                        Zli->xco = hl->xp;
671
                                        Zli->yco = hl->yp;
672
                                        Zli->Sele = hl->cselect;
673
                                        Zli->Siz = chs;
674
                                        Zli->Style = hl->cstyle;
675
                                        Zli->ZFo = hl->cfont;
676
                                        Zli->wide = wide;
677
                                        Zli->kern = hl->cextra;
678
                                        Zli->scale = hl->cscale;
679
                                        if ((hl->ch == " ") && (!outs))
680
                                                {
681
                                                LastXp = hl->xp;
682
                                                LastSP = BuPos;
683
                                                }
684
                                        if ((hl->ch == "-") && (!outs))
685
                                                {
686
                                                LastXp = CurX;
687
                                                LastSP = BuPos;
688
                                                }
689
                                        if ((hl->cstyle & 128) && (!outs))
690
                                                {
691
                                                LastXp = CurX + Cwidth(Doc, hl->cfont, "-", hl->csize);
692
                                                LastSP = BuPos;
693
                                                }
694
                                        LiList.append(Zli);
695
                                        BuPos++;
696
                                        if ((hl->ch == QChar(13)) || (outs))
697
                                                {
698
                                                if (outs)
3 paul 699
                                                        {
114 Franz 700
                                                        if (LastSP != 0)            // Hier koenen auch andere Trennungen eingebaut werden
3 paul 701
                                                                {
68 Franz 702
                                                                a -= BuPos - LastSP;
703
                                                                a++;
704
                                                                if (Ptext.at(a)->cstyle & 128)
3 paul 705
                                                                        {
68 Franz 706
                                                                        Zli = new ZZ;
707
                                                                        Zli->Zeich = "-";
708
                                                                        Zli->Farb = Ptext.at(a)->ccolor;
709
                                                                        Zli->Farb2 = Ptext.at(a)->cstroke;
710
                                                                        Zli->shade = Ptext.at(a)->cshade;
711
                                                                        Zli->shade2 = Ptext.at(a)->cshade2;
712
                                                                        Zli->xco = LastXp - Cwidth(Doc, Ptext.at(a)->cfont, "-", Ptext.at(a)->csize);
713
                                                                        Zli->yco = Ptext.at(a)->yp;
714
                                                                        Zli->Sele = Ptext.at(a)->cselect;
715
                                                                        Zli->Siz = Ptext.at(a)->csize;
716
                                                                        Zli->Style = Ptext.at(a)->cstyle;
717
                                                                        Zli->ZFo = Ptext.at(a)->cfont;
718
                                                                        Zli->wide = Cwidth(Doc, Ptext.at(a)->cfont, "-", Ptext.at(a)->csize);
719
                                                                        Zli->kern = Ptext.at(a)->cextra;
720
                                                                        Zli->scale = Ptext.at(a)->cscale;
721
                                                                        LiList.insert(LastSP+1, Zli);
722
                                                                        LastSP += 1;
3 paul 723
                                                                        }
68 Franz 724
                                                                BuPos = LastSP+1;
3 paul 725
                                                                if (Doc->Vorlagen[absa].Ausri != 0)
726
                                                                        {
68 Franz 727
                                                                        EndX = LastXp;
3 paul 728
                                                                        do
68 Franz 729
                                                                                {
110 Franz 730
                                                                                pt1 = QPoint(static_cast<int>(EndX+RExtra+lineCorr), static_cast<int>(CurY+desc));
731
                                                                                pt2 = QPoint(static_cast<int>(EndX+RExtra+lineCorr), static_cast<int>(CurY-asce));
3 paul 732
                                                                                EndX++;
68 Franz 733
                                                                                }
734
                                                                        while ((cl.contains(pf.xForm(pt1))) && (cl.contains(pf.xForm(pt2))));
3 paul 735
                                                                        if (Doc->Vorlagen[absa].Ausri == 2)
68 Franz 736
                                                                                OFs = EndX - LastXp;
3 paul 737
                                                                        if (Doc->Vorlagen[absa].Ausri == 1)
68 Franz 738
                                                                                OFs = (EndX - LastXp) / 2;
739
                                                                        if ((Doc->Vorlagen[absa].Ausri == 3) || (Doc->Vorlagen[absa].Ausri == 4))
3 paul 740
                                                                                {
741
                                                                                aSpa = 0;
68 Franz 742
                                                                                for (uint sof = 0; sof<BuPos-1; ++sof)
3 paul 743
                                                                                        {
744
                                                                                        if (LiList.at(sof)->Zeich == QChar(32))
745
                                                                                                aSpa++;
746
                                                                                        }
68 Franz 747
                                                                                if (aSpa > 1)
748
                                                                                        OFs2 = (EndX - LastXp) / aSpa;
749
                                                                                else
3 paul 750
                                                                                        {
68 Franz 751
                                                                                        if (aSpa == 0)
752
                                                                                                OFs2 = 0;
753
                                                                                        else
754
                                                                                                OFs2 = (EndX - LastXp);
3 paul 755
                                                                                        }
756
                                                                                OFs = 0;
757
                                                                                for (uint yof = 0; yof < LiList.count(); ++yof)
758
                                                                                        {
759
                                                                                        LiList.at(yof)->xco += OFs;
114 Franz 760
                                                                                        Ptext.at(QMIN(BuPos2, MaxText-1))->xp += OFs;
3 paul 761
                                                                                        BuPos2++;
762
                                                                                        if (LiList.at(yof)->Zeich == QChar(32))
68 Franz 763
                                                                                                OFs += OFs2;
3 paul 764
                                                                                        }
765
                                                                                }
766
                                                                        else
767
                                                                                {
768
                                                                                for (uint xof = 0; xof<LiList.count(); ++xof)
769
                                                                                        {
770
                                                                                        LiList.at(xof)->xco += OFs;
114 Franz 771
                                                                                        Ptext.at(QMIN(BuPos2, MaxText-1))->xp += OFs;
3 paul 772
                                                                                        BuPos2++;
773
                                                                                        }
774
                                                                                }
68 Franz 775
                                                                        }
3 paul 776
                                                                }
777
                                                        else
778
                                                                {
68 Franz 779
                                                                a--;
780
                                                                BuPos--;
3 paul 781
                                                                }
68 Franz 782
                                                        }
783
                                                else
784
                                                        {
785
                                                        if (Doc->Vorlagen[absa].Ausri != 0)
3 paul 786
                                                                {
68 Franz 787
                                                                EndX = CurX;
788
                                                                do
3 paul 789
                                                                        {
110 Franz 790
                                                                        pt1 = QPoint(static_cast<int>(EndX+RExtra+lineCorr), static_cast<int>(CurY+desc));
791
                                                                        pt2 = QPoint(static_cast<int>(EndX+RExtra+lineCorr), static_cast<int>(CurY-asce));
68 Franz 792
                                                                        EndX++;
3 paul 793
                                                                        }
68 Franz 794
                                                                while ((cl.contains(pf.xForm(pt1))) && (cl.contains(pf.xForm(pt2))));
795
                                                                if (Doc->Vorlagen[absa].Ausri == 2)
110 Franz 796
                                                                        OFs = EndX - CurX - Extra - lineCorr;
68 Franz 797
                                                                if (Doc->Vorlagen[absa].Ausri == 1)
110 Franz 798
                                                                        OFs = (EndX - CurX - Extra - lineCorr) / 2;
68 Franz 799
                                                                if (Doc->Vorlagen[absa].Ausri == 3)
800
                                                                        OFs = 0;
801
                                                                if (Doc->Vorlagen[absa].Ausri == 4)
3 paul 802
                                                                        {
68 Franz 803
                                                                        aSpa = 0;
804
                                                                        for (uint sof = 0; sof<LiList.count(); ++sof)
3 paul 805
                                                                                {
68 Franz 806
                                                                                if (LiList.at(sof)->Zeich == QChar(32))
807
                                                                                        aSpa++;
3 paul 808
                                                                                }
68 Franz 809
                                                                        if (aSpa != 0)
810
                                                                                {
110 Franz 811
                                                                                OFs2 = (EndX - CurX - Extra - lineCorr) / aSpa;
68 Franz 812
                                                                                }
813
                                                                        else
814
                                                                                OFs2 = 0;
815
                                                                        OFs = 0;
816
                                                                        for (uint yof = 0; yof < LiList.count(); ++yof)
817
                                                                                {
818
                                                                                LiList.at(yof)->xco += OFs;
114 Franz 819
                                                                                Ptext.at(QMIN(BuPos2, MaxText-1))->xp += OFs;
68 Franz 820
                                                                                BuPos2++;
821
                                                                                if (LiList.at(yof)->Zeich == QChar(32))
822
                                                                                        OFs += OFs2;
823
                                                                                }
3 paul 824
                                                                        }
825
                                                                else
826
                                                                        {
68 Franz 827
                                                                        for (uint xof = 0; xof<LiList.count(); ++xof)
828
                                                                                {
3 paul 829
                                                                                LiList.at(xof)->xco += OFs;
114 Franz 830
                                                                                Ptext.at(QMIN(BuPos2, MaxText-1))->xp += OFs;
3 paul 831
                                                                                BuPos2++;
68 Franz 832
                                                                                }
3 paul 833
                                                                        }
834
                                                                }
835
                                                        }
68 Franz 836
                                                BuPos2 = a;
837
                                                BuPos2++;
838
                                                uint BuPos3 = BuPos;
839
                                                CurY += Doc->Vorlagen[0].LineSpa;
110 Franz 840
                                                CurX = Extra+lineCorr;
68 Franz 841
                                                if (hl->ch != QChar(13))
842
                                                        CurX += Doc->Vorlagen[hl->cab].Indent;
843
                                                else
3 paul 844
                                                        {
68 Franz 845
                                                        CurY += Doc->Vorlagen[hl->cab].Anach;
846
                                                        if (BuPos3 > 0)
847
                                                                BuPos3 -= 1;
848
                                                        }
849
                                                hl->xp = CurX;
850
                                                hl->yp = CurY;
851
                                                LiList.at(LiList.count()-1)->xco = hl->xp;
852
                                                LiList.at(LiList.count()-1)->yco = hl->yp;
853
                                                for (uint zc = 0; zc<BuPos3; ++zc)
854
                                                        {
3 paul 855
                                                        Zli2 = LiList.at(zc);
68 Franz 856
                                                        if (Zli2->Farb != "None")
857
                                                                {
858
                                                                SetFarbe(&tmp, Zli2->Farb, Zli2->shade);
859
                                                                p->setBrush(tmp);
860
                                                                }
861
                                                        if (Zli2->Farb2 != "None")
862
                                                                {
863
                                                                SetFarbe(&tmp, Zli2->Farb2, Zli2->shade2);
864
                                                                p->setPen(tmp, 1, SolidLine, FlatCap, MiterJoin);
865
                                                                }
3 paul 866
                                                        if ((Zli2->Sele) && (Doc->AppMode == 7) && (Select))
867
                                                                {
868
                                                                wide = Zli2->wide;
111 Franz 869
                                                                desc = static_cast<int>((*Doc->AllFonts)[Zli2->ZFo]->numDescender * (-Zli2->Siz / 10.0));
870
                                                                asce = static_cast<int>((*Doc->AllFonts)[Zli2->ZFo]->numAscent * (Zli2->Siz / 10.0));
68 Franz 871
                                                                p->setFillMode(1);
872
                                p->setBrush(darkBlue);
3 paul 873
                                                                if (!Doc->RePos)
68 Franz 874
                                        p->drawRect(Zli2->xco, Zli2->yco-asce, wide+1, asce+desc);
875
                                                                p->setBrush(white);
3 paul 876
                                                                }
68 Franz 877
                                                        if (!Doc->RePos)
3 paul 878
                                                                {
87 Franz 879
                                                                if (e.intersects(pf.xForm(QRect(qRound(Zli2->xco),qRound(Zli2->yco-LineSp), qRound(Zli2->wide+1), qRound(LineSp)))))
68 Franz 880
                                                                        DrawZeichenS(p, Zli2);
3 paul 881
                                                                }
882
                                                        }
883
                                                LiList.clear();
884
                                                BuPos = 0;
885
                                                LastSP = 0;
68 Franz 886
                                                LastXp = 0;
3 paul 887
                                                outs = false;
68 Franz 888
                                                }
889
                                        }
890
                                if (Doc->Vorlagen[absa].Ausri != 0)
891
                                        {
892
                                        EndX = CurX;
893
                                        do
3 paul 894
                                                {
68 Franz 895
                                                pt1 = QPoint(static_cast<int>(EndX+RExtra), static_cast<int>(CurY+desc));
896
                                                pt2 = QPoint(static_cast<int>(EndX+RExtra), static_cast<int>(CurY-asce));
897
                                                EndX++;
898
                                                }
899
                                        while ((cl.contains(pf.xForm(pt1))) && (cl.contains(pf.xForm(pt2))));
900
                                        if (Doc->Vorlagen[absa].Ausri == 2)
110 Franz 901
                                                OFs = EndX - CurX - Extra - lineCorr;
68 Franz 902
                                        if (Doc->Vorlagen[absa].Ausri == 1)
110 Franz 903
                                                OFs = (EndX - CurX - Extra - lineCorr) / 2;
68 Franz 904
                                        if (Doc->Vorlagen[absa].Ausri == 3)
905
                                                OFs = 0;
906
                                        if (Doc->Vorlagen[absa].Ausri == 4)
907
                                                {
908
                                                aSpa = 0;
909
                                                for (uint sof = 0; sof<LiList.count(); ++sof)
3 paul 910
                                                        {
68 Franz 911
                                                        if (LiList.at(sof)->Zeich == QChar(32))
912
                                                                aSpa++;
3 paul 913
                                                        }
68 Franz 914
                                                if (aSpa != 0)
3 paul 915
                                                        {
110 Franz 916
                                                        OFs2 = (EndX - CurX - Extra - lineCorr) / aSpa;
3 paul 917
                                                        }
68 Franz 918
                                                else
919
                                                        OFs2 = 0;
920
                                                OFs = 0;
921
                                                for (uint yof = 0; yof < LiList.count(); ++yof)
57 Franz 922
                                                        {
68 Franz 923
                                                        LiList.at(yof)->xco += OFs;
114 Franz 924
                                                        Ptext.at(QMIN(BuPos2, MaxText-1))->xp += OFs;
68 Franz 925
                                                        BuPos2++;
926
                                                        if (LiList.at(yof)->Zeich == QChar(32))
927
                                                                OFs += OFs2;
57 Franz 928
                                                        }
3 paul 929
                                                }
930
                                        else
931
                                                {
68 Franz 932
                                                for (uint xof = 0; xof<LiList.count(); ++xof)
3 paul 933
                                                        {
68 Franz 934
                                                        LiList.at(xof)->xco += OFs;
114 Franz 935
                                                        Ptext.at(QMIN(BuPos2, MaxText-1))->xp += OFs;
68 Franz 936
                                                        BuPos2++;
3 paul 937
                                                        }
938
                                                }
68 Franz 939
                                        }
940
                                for (uint zc = 0; zc<LiList.count(); ++zc)
27 Franz 941
                                        {
68 Franz 942
                                        Zli2 = LiList.at(zc);
943
                                        if (Zli2->Farb != "None")
27 Franz 944
                                                {
68 Franz 945
                                                SetFarbe(&tmp, Zli2->Farb, Zli2->shade);
946
                                                p->setBrush(tmp);
27 Franz 947
                                                }
68 Franz 948
                                        if (Zli2->Farb2 != "None")
27 Franz 949
                                                {
68 Franz 950
                                                SetFarbe(&tmp, Zli2->Farb2, Zli2->shade2);
951
                                                p->setPen(tmp, 1, SolidLine, FlatCap, MiterJoin);
27 Franz 952
                                                }
68 Franz 953
                                        if ((Zli2->Sele) && (Doc->AppMode == 7) && (Select))
954
                                                {
955
                                                wide = Zli2->wide;
111 Franz 956
                                                desc = static_cast<int>((*Doc->AllFonts)[Zli2->ZFo]->numDescender * (-Zli2->Siz / 10.0));
957
                                                asce = static_cast<int>((*Doc->AllFonts)[Zli2->ZFo]->numAscent * (Zli2->Siz / 10.0));
68 Franz 958
                                                p->setFillMode(1);
959
                        p->setBrush(darkBlue);
960
                                                if (!Doc->RePos)
961
                                p->drawRect(Zli2->xco, Zli2->yco-asce, wide+1, asce+desc);
962
                                                p->setBrush(white);
963
                                                }
3 paul 964
                                        if (!Doc->RePos)
965
                                                {
87 Franz 966
                                                if (e.intersects(pf.xForm(QRect(qRound(Zli2->xco),qRound(Zli2->yco-LineSp), qRound(Zli2->wide+1), qRound(LineSp)))))
68 Franz 967
                                                        DrawZeichenS(p, Zli2);
3 paul 968
                                                }
969
                                        }
68 Franz 970
                                LiList.clear();
971
                                BuPos = 0;
972
                                LastSP = 0;
973
                                outs = false;
974
                                }
975
                        MaxChars = Ptext.count();
976
                        Redrawn = true;
977
                        p->restore();
978
                        break;
979
NoRoom: if (NextBox != 0)
3 paul 980
                                        {
68 Franz 981
                                        nrc2 = Ptext.count();
982
                                        for (uint ss=nrc; ss<nrc2; ++ss)
3 paul 983
                                                {
68 Franz 984
                                                NextBox->Ptext.append(Ptext.take(nrc));
985
                                                }
986
                                        NextBox->Dirty = true;
987
                                        if (uint(CPos) > nrc)
988
                                                {
989
                                                CPos = nrc;
990
                                                if ((Doc->AppMode == 7) && (Tinput))
27 Franz 991
                                                        {
68 Franz 992
                                                        OwnPage->Deselect(true);
993
                                                        NextBox->CPos = 1;
994
                                                        Doc->ActPage = NextBox->OwnPage;
995
                                                        NextBox->OwnPage->SelectItemNr(NextBox->ItemNr);
996
                                                        break;
27 Franz 997
                                                        }
3 paul 998
                                                }
79 Franz 999
                                        if (NextBox->OwnPage != OwnPage)
73 Franz 1000
                                                NextBox->OwnPage->RefreshItem(NextBox, true);
79 Franz 1001
                                        else
1002
                                                {
1003
                                                bool savre = Doc->RePos;
1004
                                                Doc->RePos = true;
1005
                                                p->save();
1006
                                                NextBox->DrawObj(p, QRect(0, 0, 1, 1));
1007
                                                p->restore();
1008
                                                Doc->RePos = savre;
1009
                                                }
3 paul 1010
                                        }
68 Franz 1011
                                else
3 paul 1012
                                        {
68 Franz 1013
                                        if (!Doc->RePos)
3 paul 1014
                                                {
68 Franz 1015
                                                p->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
1016
                                                p->setBrush(white);
1017
                                                p->drawRect(Width-16, Height-16, 14, 14);
1018
                                                p->drawLine(FPoint(Width-16, Height-16), FPoint(Width-3, Height-3));
1019
                                                p->drawLine(FPoint(Width-16, Height-3), FPoint(Width-3, Height-16));
3 paul 1020
                                                }
1021
                                        }
68 Franz 1022
                                MaxChars = nrc;
1023
                                Redrawn = true;
1024
                                p->restore();
1025
                                break;
1026
                case 8:
1027
                        if (!PoShow)
1028
                                doStroke = false;
1029
                        cl = FlattenPath(PoLine, Segments);
1030
                        CurX = Extra;
1031
                        if (Ptext.count() != 0)
1032
                                CurX += Ptext.at(0)->cextra;
1033
                        zae = 0;
1034
                        wid = sqrt(pow(cl.point(zae+1).x()-cl.point(zae).x(),2)+pow(cl.point(zae+1).y()-cl.point(zae).y(),2));
1035
                        while (wid < 1)
1036
                                {
1037
                                zae++;
97 Franz 1038
                                if (zae > cl.size()-2)
80 Franz 1039
                                {
1040
                                        MaxChars = Ptext.count();
1041
                                        break;
1042
                                }
3 paul 1043
                                wid = sqrt(pow(cl.point(zae+1).x()-cl.point(zae).x(),2)+pow(cl.point(zae+1).y()-cl.point(zae).y(),2));
68 Franz 1044
                                }
1045
                        rota = xy2Deg(cl.point(zae+1).x()-cl.point(zae).x(),cl.point(zae+1).y()-cl.point(zae).y());
1046
                        for (a = 0; a < Ptext.count(); ++a)
1047
                                {
1048
                                CurY = 0;
1049
                                hl = Ptext.at(a);
1050
                                chx = hl->ch;
1051
                                if ((chx == QChar(30)) || (chx == QChar(13)))
1052
                                        continue;
1053
                                chs = hl->csize;
1054
                                SetZeichAttr(hl, &chs, &chx);
1055
                                if (chx == QChar(29))
1056
                                        chx2 = " ";
1057
                                else
1058
                                        chx2 = chx;
1059
                                if (a < Ptext.count()-1)
3 paul 1060
                                        {
68 Franz 1061
                                        if (Ptext.at(a+1)->ch == QChar(29))
1062
                                                chx3 = " ";
1063
                                        else
1064
                                                chx3 = Ptext.at(a+1)->ch;
1065
                                        wide = Cwidth(Doc, hl->cfont, chx2, chs, chx3);
3 paul 1066
                                        }
68 Franz 1067
                                else
1068
                                        wide = Cwidth(Doc, hl->cfont, chx2, chs);
1069
                                wide = wide * (hl->cscale / 100.0);
1070
                                if ((CurX+(wide+hl->cextra)/2) >= wid)
3 paul 1071
                                        {
68 Franz 1072
                                        if (zae < cl.size()-1)
3 paul 1073
                                                {
68 Franz 1074
                                                CurX = CurX - wid;
1075
                                                wid = 0;
1076
                                                EndX = CurX;
1077
                                                do
3 paul 1078
                                                        {
1079
                                                        do
1080
                                                                {
68 Franz 1081
                                                                zae++;
97 Franz 1082
                                                                if (zae > cl.size()-2)
1083
                                                                        {
1084
                                                                        MaxChars = a+1;
80 Franz 1085
                                                                        break;
97 Franz 1086
                                                                        }
68 Franz 1087
                                                                wid = sqrt(pow(cl.point(zae+1).x()-cl.point(zae).x(),2)+pow(cl.point(zae+1).y()-cl.point(zae).y(),2));
1088
                                                                rota = xy2Deg(cl.point(zae+1).x()-cl.point(zae).x(),cl.point(zae+1).y()-cl.point(zae).y());
3 paul 1089
                                                                }
68 Franz 1090
                                                        while (wid == 0);
1091
                                                        EndX -= wid;
97 Franz 1092
                                                        if (zae > cl.size()-2)
1093
                                                                {
1094
                                                                MaxChars = a+1;
1095
                                                                break;
1096
                                                                }
3 paul 1097
                                                        }
68 Franz 1098
                                                while (wid < EndX);
1099
                                                CurX = EndX + wid;
3 paul 1100
                                                }
68 Franz 1101
                                        else
97 Franz 1102
                                                {
1103
                                                MaxChars = a+1;
80 Franz 1104
                                                break;
97 Franz 1105
                                                }
3 paul 1106
                                        }
97 Franz 1107
                                if (zae > cl.size()-2)
1108
                                        break;
68 Franz 1109
                                p->save();
1110
                                p->translate(cl.point(zae).x()*sc, cl.point(zae).y()*sc);
1111
                                p->rotate(rota);
1112
                                hl->xp = CurX+hl->cextra;
1113
                                hl->yp = CurY+BaseOffs;
1114
                                hl->PtransX = cl.point(zae).x();
1115
                                hl->PtransY = cl.point(zae).y();
1116
                                hl->PRot = rota;
1117
                                Zli = new ZZ;
1118
                                Zli->Zeich = chx;
1119
                                if (hl->ccolor != "None")
1120
                                        {
1121
                                        SetFarbe(&tmp, hl->ccolor, hl->cshade);
1122
                                        p->setBrush(tmp);
1123
                                        }
1124
                                if (hl->cstroke != "None")
1125
                                        {
1126
                                        SetFarbe(&tmp, hl->cstroke, hl->cshade2);
1127
                                        p->setPen(tmp, 1, SolidLine, FlatCap, MiterJoin);
1128
                                        }
1129
                                Zli->Farb = hl->ccolor;
1130
                                Zli->Farb2 = hl->cstroke;
1131
                                Zli->shade = hl->cshade;
1132
                                Zli->shade2 = hl->cshade2;
1133
                                Zli->xco = hl->xp;
1134
                                Zli->yco = hl->yp;
1135
                                Zli->Sele = hl->cselect;
1136
                                Zli->Siz = chs;
1137
                                Zli->Style = hl->cstyle;
1138
                                Zli->ZFo = hl->cfont;
1139
                                Zli->wide = wide;
1140
                                Zli->kern = hl->cextra;
1141
                                Zli->scale = hl->cscale;
1142
                                if (!Doc->RePos)
1143
                                        DrawZeichenS(p, Zli);
1144
                                delete Zli;
1145
                                p->restore();
1146
                                p->setZoomFactor(sc);
97 Franz 1147
                                MaxChars = a+1;
68 Franz 1148
                                CurX += wide+hl->cextra;
1149
                                }
1150
                default:
1151
                        break;
1152
                }
1153
        if ((doStroke) && (!Doc->RePos))
1154
                {
1155
                if (Pcolor2 != "None")
1156
                        {
1157
                        SetFarbe(&tmp, Pcolor2, Shade2);
1158
                        p->setPen(tmp, Pwidth, PLineArt, PLineEnd, PLineJoin);
1159
                        if (DashValues.count() != 0)
1160
                                p->setDash(DashValues, DashOffset);
3 paul 1161
                        }
68 Franz 1162
                else
1163
                        p->setLineWidth(0);
1164
                p->setupPolygon(&PoLine);
1165
                if (NamedLStyle == "")
1166
                        p->drawPolyLine();
1167
                else
1168
                        {
1169
                        multiLine ml = Doc->MLineStyles[NamedLStyle];
1170
                        for (int it = ml.size()-1; it > -1; it--)
1171
                                {
1172
                                SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1173
                                p->setPen(tmp, ml[it].Width,
1174
                                                                 static_cast<PenStyle>(ml[it].Dash),
1175
                                                                 static_cast<PenCapStyle>(ml[it].LineEnd),
1176
                                                                 static_cast<PenJoinStyle>(ml[it].LineJoin));
1177
                                p->drawPolyLine();
1178
                                }
1179
                        }
3 paul 1180
                }
68 Franz 1181
        if ((!Tinput) && (!Doc->RePos))
1182
                {
1183
                if ((Frame) && (Doc->ShFrames) && ((PType == 2) || (PType == 4)))
1184
                        {
1185
                        p->setPen(black, 1, DotLine, FlatCap, MiterJoin);
1186
                        if ((isBookmark) || (isAnnotation))
1187
                                p->setPen(blue, 1, DotLine, FlatCap, MiterJoin);
1188
                        if ((BackBox != 0) || (NextBox != 0))
1189
                                p->setPen(red, 1, SolidLine, FlatCap, MiterJoin);
1190
                        if (Locked)
1191
                                p->setPen(darkRed, 1, SolidLine, FlatCap, MiterJoin);
1192
                        p->setFillMode(0);
1193
                        p->setupPolygon(&PoLine);
1194
                        p->drawPolyLine();
1195
                        }
1196
                }
1197
        Tinput = false;
1198
        FrameOnly = false;
1199
        Dirty = false;
1200
        p->restore();
1201
        pf.end();
1202
}
1203
 
1204
void PageItem::paintObj(QRect e, QPixmap *ppX)
1205
{
1206
        QPainter p;
1207
        if (!Doc->DoDrawing)
1208
                {
1209
                Redrawn = true;
1210
                Tinput = false;
1211
                FrameOnly = false;
1212
                Dirty = false;
1213
                return;
1214
                }
1215
        if (toPixmap)
1216
                p.begin(ppX);
1217
        else
1218
                p.begin(Parent);
1219
        if ((!toPixmap) && (!Doc->RePos))
1220
                {
1221
                if (!e.isEmpty())
1222
                        p.setClipRect(e);
1223
                else
1224
                        p.setClipRect(OwnPage->ViewReg().boundingRect());
1225
                }
1226
        p.translate(static_cast<int>(Xpos*Doc->Scale), static_cast<int>(Ypos*Doc->Scale));
1227
        p.scale(static_cast<double>(Doc->Scale), static_cast<double>(Doc->Scale));
1228
        p.rotate(static_cast<double>(Rot));
3 paul 1229
        if (Sizing)
1230
                {
1231
                p.setRasterOp(XorROP);
1232
                p.setBrush(NoBrush);
1233
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
1234
                p.drawRect(0, 0, static_cast<int>(OldB), static_cast<int>(OldH));
1235
                p.drawRect(0, 0, static_cast<int>(Width), static_cast<int>(Height));
1236
                OldB = Width;
1237
                OldH = Height;
1238
                }
1239
        if ((!Tinput) && (!Doc->RePos))
1240
                {
1241
                if ((Frame) && (Doc->ShFrames))
1242
                        {
1243
                        p.setPen(QPen(black, 1, DotLine, FlatCap, MiterJoin));
1244
                        if ((isBookmark) || (isAnnotation))
1245
                                p.setPen(QPen(blue, 1, DotLine, FlatCap, MiterJoin));
1246
                        if ((BackBox != 0) || (NextBox != 0))
1247
                                p.setPen(QPen(red, 1, SolidLine, FlatCap, MiterJoin));
1248
                        if (Locked)
1249
                                p.setPen(QPen(darkRed, 1, SolidLine, FlatCap, MiterJoin));
1250
                        p.setBrush(NoBrush);
1251
                        DrawPolyL(&p, Clip);
1252
                        }
1253
                if (Select) // && (!Doc->EditClip))
1254
                        {
1255
                        if (!OwnPage->SelItem.isEmpty())
1256
                                {
1257
                                if (Groups.count() == 0)
1258
                                        {
1259
                                        QPainter pr;
1260
                                        pr.begin(Parent);
1261
                                        pr.translate(static_cast<int>(Xpos*Doc->Scale), static_cast<int>(Ypos*Doc->Scale));
1262
                                        pr.rotate(static_cast<double>(Rot));
1263
                                        if (Locked)
1264
                                                pr.setPen(QPen(darkRed, 1, SolidLine, FlatCap, MiterJoin));
1265
                                        else
1266
                                                pr.setPen(QPen(red, 1, DotLine, FlatCap, MiterJoin));
1267
                                        pr.setBrush(NoBrush);
24 Franz 1268
                                        pr.drawRect(-1, -1, static_cast<int>(Width*Doc->Scale)+2, static_cast<int>(Height*Doc->Scale)+2);
3 paul 1269
                                        if (Locked)
1270
                                                {
1271
                                                pr.setPen(QPen(darkRed, 1, SolidLine, FlatCap, MiterJoin));
1272
                                                pr.setBrush(darkRed);
1273
                                                }
1274
                                        else
1275
                                                {
1276
                                                pr.setPen(QPen(red, 1, SolidLine, FlatCap, MiterJoin));
1277
                                                pr.setBrush(red);
1278
                                                }
1279
                                        if (PType != 5)
80 Franz 1280
                                                {
3 paul 1281
                                                pr.drawRect(-1, -1, 6, 6);
1282
                                                pr.drawRect(static_cast<int>(Width*Doc->Scale), static_cast<int>(Height*Doc->Scale), -6, -6);
1283
                                                pr.drawRect(static_cast<int>(Width*Doc->Scale), -1, -6, 6);
1284
                                                pr.drawRect(-1, static_cast<int>(Height*Doc->Scale), 6, -6);
1285
                                                if (Width > 6)
1286
                                                        {
1287
                                                        pr.drawRect(static_cast<int>(Width/2*Doc->Scale - 3), static_cast<int>(Height*Doc->Scale), 6, -6);
1288
                                                        pr.drawRect(static_cast<int>(Width/2*Doc->Scale - 3), -1, 6, 6);
1289
                                                        }
1290
                                                if (Height > 6)
1291
                                                        {
1292
                                                        pr.drawRect(static_cast<int>(Width*Doc->Scale), static_cast<int>(Height/2*Doc->Scale - 3), -6, 6);
1293
                                                        pr.drawRect(-1, static_cast<int>(Height/2*Doc->Scale - 3), 6, 6);
1294
                                                        }
1295
                                                }
1296
                                        else
1297
                                                {
1298
                                                pr.drawRect(-3, -3, 6, 6);
1299
                                                pr.drawRect(static_cast<int>(Width*Doc->Scale)+3, -3, -6, 6);
1300
                                                }
1301
                                        pr.end();
1302
                                        }
1303
                                else
1304
                                        {
1305
                                        p.setPen(QPen(darkCyan, 1, DotLine, FlatCap, MiterJoin));
1306
                                        p.setBrush(NoBrush);
24 Franz 1307
                                        p.drawRect(-1, -1, static_cast<int>(Width+2), static_cast<int>(Height+2));
3 paul 1308
                                        }
1309
                                }
1310
                        }
1311
                }
1312
        Tinput = false;
1313
        FrameOnly = false;
1314
        Dirty = false;
1315
        p.end();
1316
}
1317
 
1318
QString PageItem::ExpandToken(uint base)
1319
{
1320
        uint zae = 0;
1321
        QString chx = "#";
1322
        if (!Doc->MasterP)
1323
                {
1324
                while (Ptext.at(base+zae)->ch == QChar(30))
1325
                        {
1326
                        zae++;
1327
                        if (base+zae == Ptext.count())
1328
                                break;
1329
                        }
1330
                QString out="%1";
1331
                chx = out.arg(OwnPage->PageNr+Doc->FirstPnum, zae).right(zae).left(1);
1332
                }
1333
        return chx;
1334
}
1335
 
1336
void PageItem::SetFarbe(QColor *tmp, QString farbe, int shad)
1337
{
1338
        int h, s, v, sneu;
1339
        Doc->PageColors[farbe].getRGBColor().rgb(&h, &s, &v);
1340
        if ((h == s) && (s == v))
1341
                {
1342
                Doc->PageColors[farbe].getRGBColor().hsv(&h, &s, &v);
1343
                sneu = 255 - ((255 - v) * shad / 100);
80 Franz 1344
                tmp->setHsv(h, s, sneu);
3 paul 1345
                }
1346
        else
1347
                {
1348
                Doc->PageColors[farbe].getRGBColor().hsv(&h, &s, &v);
1349
                sneu = s * shad / 100;
1350
                tmp->setHsv(h, sneu, v);
1351
                }
1352
}
1353
 
68 Franz 1354
void PageItem::SetZeichAttr(struct Pti *hl, int *chs, QString *chx)
3 paul 1355
{
111 Franz 1356
        int     asce = static_cast<int>((*Doc->AllFonts)[hl->cfont]->numAscent * (hl->csize / 10.0));
3 paul 1357
        int chst = hl->cstyle & 127;
1358
        if (chst != 0)
1359
                {
1360
                if (chst & 1)
1361
                        {
1362
                        CurY -= asce * Doc->VHoch / 100;
1363
                        *chs = QMAX(static_cast<int>(hl->csize * Doc->VHochSc / 100), 1);
1364
                        }
1365
                if (chst & 2)
1366
                        {
1367
                        CurY += asce * Doc->VTief / 100;
111 Franz 1368
                        *chs = QMAX(static_cast<int>(hl->csize * Doc->VTiefSc / 100), 1);
3 paul 1369
                        }
1370
                if (chst & 64)
1371
                        {
1372
                        if (chx->upper() != *chx)
1373
                                {
1374
                                *chs = QMAX(static_cast<int>(hl->csize * Doc->VKapit / 100), 1);
1375
                                *chx = chx->upper();
1376
                                }
1377
                        }
1378
                }
1379
}
1380
 
68 Franz 1381
void PageItem::DrawZeichenS(ScPainter *p, struct ZZ *hl)
3 paul 1382
{
55 Franz 1383
        QString ccx = hl->Zeich;
1384
        if (ccx == QChar(29))
1385
                ccx = " ";
68 Franz 1386
        if (ccx == QChar(13))
1387
                return;
111 Franz 1388
        double csi = static_cast<double>(hl->Siz) / 100.0;
55 Franz 1389
        uint chr = ccx[0].unicode();
68 Franz 1390
        if ((*Doc->AllFonts)[hl->ZFo]->CharWidth.contains(chr))
3 paul 1391
                {
68 Franz 1392
                QWMatrix chma;
1393
                chma.scale(csi, csi);
1394
                FPointArray gly = (*Doc->AllFonts)[hl->ZFo]->GlyphArray[chr].Outlines.copy();
87 Franz 1395
                if (gly.size() > 3)
3 paul 1396
                        {
68 Franz 1397
                        gly.map(chma);
1398
                        chma = QWMatrix();
1399
                        chma.scale(hl->scale / 100.0, 1);
1400
                        gly.map(chma);
1401
                        chma = QWMatrix();
1402
                        if (Reverse)
3 paul 1403
                                {
68 Franz 1404
                                chma.scale(-1, 1);
1405
                                chma.translate(-hl->wide, 0);
1406
                                gly.map(chma);
1407
                                chma = QWMatrix();
111 Franz 1408
                                chma.translate(hl->xco, hl->yco-(hl->Siz / 10.0));
3 paul 1409
                                }
68 Franz 1410
                        else
111 Franz 1411
                                chma.translate(hl->xco, hl->yco-(hl->Siz / 10.0));
68 Franz 1412
                        gly.map(chma);
87 Franz 1413
                        p->setFillMode(1);
68 Franz 1414
                        p->setupPolygon(&gly);
1415
                        if (hl->Farb != "None")
1416
                                p->fillPath();
1417
                        if ((hl->Style & 4) && (hl->Farb2 != "None"))
3 paul 1418
                                {
111 Franz 1419
                                p->setLineWidth((*Doc->AllFonts)[hl->ZFo]->strokeWidth * (hl->Siz / 10.0) / 2);
68 Franz 1420
                                p->strokePath();
3 paul 1421
                                }
1422
                        }
68 Franz 1423
                if (hl->Style & 16)
3 paul 1424
                        {
68 Franz 1425
                        p->setPen(p->brush());
111 Franz 1426
                        double st = (*Doc->AllFonts)[hl->ZFo]->strikeout_pos * (hl->Siz / 10.0);
1427
                        p->setLineWidth(QMAX((*Doc->AllFonts)[hl->ZFo]->strokeWidth * (hl->Siz / 10.0), 1));
68 Franz 1428
                        p->drawLine(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st));
3 paul 1429
                        }
68 Franz 1430
                if (hl->Style & 8)
3 paul 1431
                        {
111 Franz 1432
                        double st = (*Doc->AllFonts)[hl->ZFo]->underline_pos * (hl->Siz / 10.0);
68 Franz 1433
                        QString dummy;
1434
                        p->setPen(p->brush());
111 Franz 1435
                        p->setLineWidth(QMAX((*Doc->AllFonts)[hl->ZFo]->strokeWidth * (hl->Siz / 10.0), 1));
92 Franz 1436
                        if ((gly.size() > 4) && (ccx != QChar(32)))
68 Franz 1437
                                p->drawUnderline(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st), false, &dummy);
1438
                        else
1439
                                p->drawLine(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st));
3 paul 1440
                        }
1441
                }
68 Franz 1442
        else
3 paul 1443
                {
68 Franz 1444
                p->setLineWidth(1);
1445
                p->setPen(black);
1446
                p->setFillMode(0);
111 Franz 1447
                p->drawRect(hl->xco, hl->yco-(hl->Siz / 10.0), (hl->Siz / 10.0)*(hl->scale / 100.0), (hl->Siz / 10.0));
3 paul 1448
                }
1449
}
1450
 
1451
void PageItem::DrawPoly(QPainter *p, QPointArray pts, QColor BackF, bool bitm)
1452
{
1453
        if ((Pcolor != "None") || (GrType != 0) || (PType == 2))
1454
                {
1455
                QBitmap bm(static_cast<int>(Width), static_cast<int>(Height));
1456
                bm.fill(Qt::color0);
1457
                QPainter pbm;
1458
                pbm.begin(&bm);
1459
                pbm.setBrush(Qt::color1);
1460
                pbm.setPen(NoPen);
1461
                pbm.setRasterOp(XorROP);
1462
                QPointArray dr;
1463
                QValueList<uint>::Iterator it3;
1464
                uint FirstVal = 0;
1465
                for (it3 = Segments.begin(); it3 != Segments.end(); ++it3)
1466
                        {
1467
                        dr.resize(0);
1468
                        dr.putPoints(0, (*it3)-FirstVal-1, pts, FirstVal);
1469
                        pbm.drawPolygon(dr);
1470
                        FirstVal = (*it3);
1471
                        }
1472
                dr.resize(0);
1473
                dr.putPoints(0, pts.size()-FirstVal-1, pts, FirstVal);
1474
                pbm.drawPolygon(dr);
1475
                pbm.end();
1476
                if (bitm)
1477
                        p->drawPixmap(0, 0, bm);
1478
                else
1479
                        {
1480
                        QPixmap ppm(static_cast<int>(Width), static_cast<int>(Height));
1481
                        ppm.fill(BackF);
1482
                        ppm.setMask(bm);
1483
                        p->drawPixmap(0, 0, ppm);
1484
                        }
1485
                }
27 Franz 1486
}
1487
 
1488
void PageItem::DrawPolyL(QPainter *p, QPointArray pts)
1489
{
1490
        QColor tmp;
3 paul 1491
        if (Segments.count() != 0)
1492
                {
1493
                QValueList<uint>::Iterator it2;
1494
                uint FirstVal = 0;
1495
                for (it2 = Segments.begin(); it2 != Segments.end(); ++it2)
1496
                        {
27 Franz 1497
                        if (NamedLStyle == "")
1498
                                p->drawPolyline(pts, FirstVal, (*it2)-FirstVal);
1499
                        else
1500
                                {
1501
                                multiLine ml = Doc->MLineStyles[NamedLStyle];
31 Franz 1502
                                for (int it = ml.size()-1; it > -1; it--)
27 Franz 1503
                                        {
1504
                                        SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1505
                                        p->setPen(QPen(tmp,
1506
                                                                         QMAX(static_cast<int>(ml[it].Width*Doc->Scale), 1),
1507
                                                                         static_cast<PenStyle>(ml[it].Dash),
1508
                                                                         static_cast<PenCapStyle>(ml[it].LineEnd),
1509
                                                                         static_cast<PenJoinStyle>(ml[it].LineJoin)));
1510
                                        p->drawPolyline(pts, FirstVal, (*it2)-FirstVal);
1511
                                        }
1512
                                }
3 paul 1513
                        FirstVal = (*it2);
1514
                        }
27 Franz 1515
                if (NamedLStyle == "")
1516
                        p->drawPolyline(pts, FirstVal);
1517
                else
1518
                        {
1519
                        multiLine ml = Doc->MLineStyles[NamedLStyle];
31 Franz 1520
                        for (int it = ml.size()-1; it > -1; it--)
27 Franz 1521
                                {
1522
                                SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1523
                                p->setPen(QPen(tmp,
1524
                                                                 QMAX(static_cast<int>(ml[it].Width*Doc->Scale), 1),
1525
                                                                 static_cast<PenStyle>(ml[it].Dash),
1526
                                                                 static_cast<PenCapStyle>(ml[it].LineEnd),
1527
                                                                 static_cast<PenJoinStyle>(ml[it].LineJoin)));
1528
                                p->drawPolyline(pts, FirstVal);
1529
                                }
1530
                        }
3 paul 1531
                }
1532
        else
1533
                {
27 Franz 1534
                if (NamedLStyle == "")
1535
                        p->drawPolyline(pts);
1536
                else
3 paul 1537
                        {
27 Franz 1538
                        multiLine ml = Doc->MLineStyles[NamedLStyle];
31 Franz 1539
                        for (int it = ml.size()-1; it > -1; it--)
27 Franz 1540
                                {
1541
                                SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1542
                                p->setPen(QPen(tmp,
1543
                                                                 QMAX(static_cast<int>(ml[it].Width*Doc->Scale), 1),
1544
                                                                 static_cast<PenStyle>(ml[it].Dash),
1545
                                                                 static_cast<PenCapStyle>(ml[it].LineEnd),
1546
                                                                 static_cast<PenJoinStyle>(ml[it].LineJoin)));
1547
                                p->drawPolyline(pts);
1548
                                }
3 paul 1549
                        }
1550
                }
1551
}
1552
 
27 Franz 1553
 
3 paul 1554
void PageItem::CopyIt(struct CLBuf *Buffer)
1555
{
1556
        uint a;
1557
        Buffer->PType = PType;
1558
        Buffer->Xpos = Xpos;
1559
        Buffer->Ypos = Ypos;
1560
        Buffer->Width = Width;
1561
        Buffer->Height = Height;
1562
        Buffer->RadRect = RadRect;
1563
        Buffer->FrameType = FrameType;
1564
        Buffer->ClipEdited = ClipEdited;
1565
        Buffer->Pwidth = Pwidth;
1566
        Buffer->Pcolor = Pcolor;
1567
        Buffer->Pcolor2 = Pcolor2;
1568
        Buffer->Shade = Shade;
1569
        Buffer->Shade2 = Shade2;
1570
        Buffer->GrColor = GrColor;
1571
        Buffer->GrColor2 = GrColor2;
1572
        Buffer->GrShade = GrShade;
1573
        Buffer->GrShade2 = GrShade2;
1574
        Buffer->GrType = GrType;
68 Franz 1575
        Buffer->TxtStroke = TxtStroke;
1576
        Buffer->TxtFill = TxtFill;
1577
        Buffer->ShTxtStroke = ShTxtStroke;
1578
        Buffer->ShTxtFill = ShTxtFill;
1579
        Buffer->TxtScale = TxtScale;
1580
        Buffer->TxTStyle = TxTStyle;
3 paul 1581
        Buffer->Rot = Rot;
1582
        Buffer->PLineArt = PLineArt;
1583
        Buffer->PLineEnd = PLineEnd;
1584
        Buffer->PLineJoin = PLineJoin;
1585
        Buffer->LineSp = LineSp;
1586
        Buffer->LocalScX = LocalScX;
1587
        Buffer->LocalScY = LocalScY;
1588
        Buffer->LocalX = LocalX;
1589
        Buffer->LocalY = LocalY;
1590
        Buffer->PicArt = PicArt;
1591
        Buffer->flippedH = flippedH;
1592
        Buffer->flippedV = flippedV;
1593
        Buffer->BBoxX = BBoxX;
1594
        Buffer->BBoxH = BBoxH;
1595
        Buffer->isPrintable = isPrintable;
1596
        Buffer->isBookmark = isBookmark;
1597
        Buffer->BMnr = BMnr;
1598
        Buffer->isAnnotation = isAnnotation;
1599
        Buffer->AnType = AnType;
1600
        Buffer->AnAction = AnAction;
1601
        Buffer->An_E_act = An_E_act;
1602
        Buffer->An_X_act = An_X_act;
1603
        Buffer->An_D_act = An_D_act;
1604
        Buffer->An_Fo_act = An_Fo_act;
1605
        Buffer->An_Bl_act = An_Bl_act;
1606
        Buffer->An_K_act = An_K_act;
1607
        Buffer->An_F_act = An_F_act;
1608
        Buffer->An_V_act = An_V_act;
1609
        Buffer->An_C_act = An_C_act;
19 Franz 1610
        Buffer->An_Extern = An_Extern;
3 paul 1611
        Buffer->AnZiel = AnZiel;
1612
        Buffer->AnName = AnName;
1613
        Buffer->AnActType = AnActType;
1614
        Buffer->AnToolTip = AnToolTip;
1615
        Buffer->AnBwid = AnBwid;
1616
        Buffer->AnBsty = AnBsty;
1617
        Buffer->AnFeed = AnFeed;
1618
        Buffer->AnFlag = AnFlag;
1619
        Buffer->AnFont = AnFont;
1620
        Buffer->AnRollOver = AnRollOver;
1621
        Buffer->AnDown = AnDown;
1622
        Buffer->AnFormat = AnFormat;
1623
        Buffer->AnVis = AnVis;
1624
        Buffer->AnMaxChar = AnMaxChar;
1625
        Buffer->AnChkStil = AnChkStil;
1626
        Buffer->AnIsChk = AnIsChk;
1627
        Buffer->AnAAact = AnAAact;
1628
        Buffer->AnBColor = AnBColor;
1629
        Buffer->AnHTML = AnHTML;
1630
        Buffer->AnUseIcons = AnUseIcons;
1631
        Buffer->AnIPlace = AnIPlace;
1632
        Buffer->AnScaleW = AnScaleW;
1633
        Buffer->Extra = Extra;
1634
        Buffer->TExtra = TExtra;
1635
        Buffer->BExtra = BExtra;
1636
        Buffer->RExtra = RExtra;
1637
        Buffer->Pfile = Pfile;
1638
        Buffer->Pfile2 = Pfile2;
1639
        Buffer->Pfile3 = Pfile3;
1640
        QString Text = "";
1641
        if (Ptext.count() != 0)
1642
                {
1643
                for (a=0; a<Ptext.count(); ++a)
1644
                        {
1645
                        if( (Ptext.at(a)->ch == "\n") || (Ptext.at(a)->ch == "\r"))
1646
                                Text += QString(QChar(5))+"\t";
1647
                        else
1648
                                Text += Ptext.at(a)->ch+"\t";
1649
                        Text += Ptext.at(a)->cfont+"\t";
111 Franz 1650
                        Text += QString::number(Ptext.at(a)->csize / 10.0)+"\t";
3 paul 1651
                        Text += Ptext.at(a)->ccolor+"\t";
1652
                        Text += QString::number(Ptext.at(a)->cextra)+"\t";
1653
                        Text += QString::number(Ptext.at(a)->cshade)+'\t';
1654
                        Text += QString::number(Ptext.at(a)->cstyle)+'\t';
68 Franz 1655
                        Text += QString::number(Ptext.at(a)->cab)+'\t';
1656
                        Text += Ptext.at(a)->cstroke+"\t";
1657
                        Text += QString::number(Ptext.at(a)->cshade2)+'\t';
1658
                        Text += QString::number(Ptext.at(a)->cscale)+'\n';
3 paul 1659
                        }
1660
                }
1661
        Buffer->Ptext = Text;
1662
        Buffer->Clip = Clip.copy();
1663
        Buffer->PoLine = PoLine.copy();
1664
        Buffer->PoShow = PoShow;
1665
        Buffer->BaseOffs = BaseOffs;
1666
        Buffer->Textflow = Textflow;
17 Franz 1667
        Buffer->Textflow2 = Textflow2;
3 paul 1668
        Buffer->Ausrich = Ausrich;
1669
        Buffer->IFont = IFont;
1670
        Buffer->ISize = ISize;
1671
        Buffer->ExtraV = ExtraV;
1672
        Buffer->Groups = Groups;
1673
        Buffer->IProfile = IProfile;
1674
        Buffer->IRender = IRender;
1675
        Buffer->UseEmbedded = UseEmbedded;
1676
        Buffer->EmProfile = EmProfile;
1677
        Buffer->LayerNr = LayerNr;
1678
        Buffer->ScaleType = ScaleType;
1679
        Buffer->AspectRatio = AspectRatio;
1680
        Buffer->Locked = Locked;
1681
        Buffer->Transparency = Transparency;
68 Franz 1682
        Buffer->TranspStroke = TranspStroke;
3 paul 1683
        Buffer->Reverse = Reverse;
20 Franz 1684
        Buffer->InvPict = InvPict;
27 Franz 1685
        Buffer->NamedLStyle = NamedLStyle;
68 Franz 1686
        Buffer->Language = Language;
3 paul 1687
}