Subversion Repositories Scribus

Rev

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