Subversion Repositories Scribus

Rev

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