Subversion Repositories Scribus

Rev

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