Subversion Repositories Scribus

Rev

Rev 3627 | Go to most recent revision | Details | Last modification | View Log | RSS feed

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