Subversion Repositories Scribus

Rev

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