Subversion Repositories Scribus

Rev

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

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