Subversion Repositories Scribus

Rev

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

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