Subversion Repositories Scribus

Rev

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

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