Subversion Repositories Scribus

Rev

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

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