Subversion Repositories Scribus

Rev

Rev 2443 | Rev 2449 | 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;
436
        if ((itemType()==PathText && !PoShow)|| itemType()==PolyLine || itemType()==Line)
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
        {
2443 fschmid 504
                struct ParagraphStyle vg;
505
                QValueList<ParagraphStyle> savedParagraphStyles;
506
                for (int xxx=0; xxx<5; ++xxx)
507
                {
508
                        vg.LineSpaMode = Doc->docParagraphStyles[xxx].LineSpaMode;
509
                        vg.BaseAdj = Doc->docParagraphStyles[xxx].BaseAdj;
510
                        vg.LineSpa = Doc->docParagraphStyles[xxx].LineSpa;
511
                        vg.FontSize = Doc->docParagraphStyles[xxx].FontSize;
512
                        vg.Indent = Doc->docParagraphStyles[xxx].Indent;
513
                        vg.First = Doc->docParagraphStyles[xxx].First;
514
                        vg.gapBefore = Doc->docParagraphStyles[xxx].gapBefore;
515
                        vg.gapAfter = Doc->docParagraphStyles[xxx].gapAfter;
516
                        savedParagraphStyles.append(vg);
517
                }
2434 fschmid 518
                p->save();
2443 fschmid 519
                hl->embedded->Xpos = Xpos + hl->xco;
520
                hl->embedded->Ypos = Ypos + (hl->yco - (hl->embedded->Height * (hl->scalev / 1000.0)));
521
                p->translate(hl->xco * p->zoomFactor(), (hl->yco - (hl->embedded->Height * (hl->scalev / 1000.0))) * p->zoomFactor());
2434 fschmid 522
                if (hl->base != 0)
2443 fschmid 523
                        p->translate(0, -hl->embedded->Height * (hl->base / 1000.0) * p->zoomFactor());
2447 fschmid 524
                double pws = hl->embedded->Pwidth;
525
                hl->embedded->Pwidth *= QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
2434 fschmid 526
                p->scale(hl->scale / 1000.0, hl->scalev / 1000.0);
527
                hl->embedded->DrawObj(p, e);
528
                p->restore();
2447 fschmid 529
                hl->embedded->Pwidth = pws;
2443 fschmid 530
                for (int xxx=0; xxx<5; ++xxx)
531
                {
532
                        Doc->docParagraphStyles[xxx].LineSpaMode = savedParagraphStyles[xxx].LineSpaMode;
533
                        Doc->docParagraphStyles[xxx].BaseAdj = savedParagraphStyles[xxx].BaseAdj;
534
                        Doc->docParagraphStyles[xxx].LineSpa = savedParagraphStyles[xxx].LineSpa;
535
                        Doc->docParagraphStyles[xxx].FontSize = savedParagraphStyles[xxx].FontSize;
536
                        Doc->docParagraphStyles[xxx].Indent = savedParagraphStyles[xxx].Indent;
537
                        Doc->docParagraphStyles[xxx].First = savedParagraphStyles[xxx].First;
538
                        Doc->docParagraphStyles[xxx].gapBefore = savedParagraphStyles[xxx].gapBefore;
539
                        Doc->docParagraphStyles[xxx].gapAfter = savedParagraphStyles[xxx].gapAfter;
540
                }
541
                savedParagraphStyles.clear();
2434 fschmid 542
        }
543
}
544
 
1736 cbradney 545
/** Zeichnet das Item */
2434 fschmid 546
void PageItem::DrawObj_ImageFrame(ScPainter *p, double sc)
1736 cbradney 547
{
548
        if(!Doc->RePos)
167 Franz 549
        {
2434 fschmid 550
                if ((fillColor() != "None") || (GrType != 0))
551
                {
552
                        p->setupPolygon(&PoLine);
553
                        p->fillPath();
554
                }
555
                if (Pfile == "")
556
                {
557
                        if ((Frame) && (Doc->guidesSettings.framesShown))
167 Franz 558
                        {
2434 fschmid 559
                                p->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
560
                                p->drawLine(FPoint(0, 0), FPoint(Width, Height));
561
                                p->drawLine(FPoint(0, Height), FPoint(Width, 0));
167 Franz 562
                        }
2434 fschmid 563
                }
564
                else
565
                {
566
                        if ((!PicArt) || (!PicAvail))
167 Franz 567
                        {
879 fschmid 568
                                if ((Frame) && (Doc->guidesSettings.framesShown))
310 Franz 569
                                {
2434 fschmid 570
                                        p->setPen(red, 1, SolidLine, FlatCap, MiterJoin);
310 Franz 571
                                        p->drawLine(FPoint(0, 0), FPoint(Width, Height));
572
                                        p->drawLine(FPoint(0, Height), FPoint(Width, 0));
573
                                }
167 Franz 574
                        }
68 Franz 575
                        else
167 Franz 576
                        {
2434 fschmid 577
                                if (imageClip.size() != 0)
578
                                        p->setupPolygon(&imageClip);
579
                                else
580
                                        p->setupPolygon(&PoLine);
581
                                p->setClipPath();
582
                                p->save();
583
                                if (imageFlippedH())
167 Franz 584
                                {
2434 fschmid 585
                                        p->translate(Width * sc, 0);
586
                                        p->scale(-1, 1);
167 Franz 587
                                }
2434 fschmid 588
                                if (imageFlippedV())
167 Franz 589
                                {
2434 fschmid 590
                                        p->translate(0, Height * sc);
591
                                        p->scale(1, -1);
167 Franz 592
                                }
2434 fschmid 593
                                p->translate(LocalX*LocalScX*sc, LocalY*LocalScY*sc);
594
                                p->scale(LocalScX, LocalScY);
595
                                if (pixm.imgInfo.lowResType != 0)
596
                                        p->scale(pixm.imgInfo.lowResScale, pixm.imgInfo.lowResScale);
597
                                p->drawImage(&pixm);
598
                                p->restore();
167 Franz 599
                        }
2434 fschmid 600
                }
1736 cbradney 601
        }
602
}
603
 
604
/** Zeichnet das Item */
2434 fschmid 605
void PageItem::DrawObj_TextFrame(ScPainter *p, QRect e, double sc)
1736 cbradney 606
{
607
        switch (itemType())
608
        {
1460 cbradney 609
                case TextFrame:
1741 cbradney 610
                {
611
                        QPainter pp, pf2;
1957 cbradney 612
                        PageItem *nextItem;
1741 cbradney 613
                        QPoint pt1, pt2;
614
                        FPoint ColBound;
615
                        QRegion cm;
616
                        uint a, nrc, nrc2, startLin;
2155 fschmid 617
                        int absa, aSpa, chs, chsd, CurrCol;
1741 cbradney 618
                        uint BuPos, LastSP, MaxText;
619
                        double oldCurY, LastXp, EndX, OFs, OFs2, wide, lineCorr, ColWidth, kernVal, RTabX;
620
                        QString chx, chx2, chx3;
621
                        struct ScText *hl;
622
                        struct ZZ *Zli;
623
                        struct ZZ *Zli2;
624
 
625
                        bool outs = false;
626
                        bool fBorder = false;
627
                        bool RTab = false;
628
                        bool goNoRoom = false;
2384 fschmid 629
                        bool goNextColumn = false;
1741 cbradney 630
                        uint StartRT, StartRT2;
631
                        int TabCode = 0;
632
                        int HyphenCount = 0;
2282 fschmid 633
                        QValueList<TabRecord> tTabValues;
1741 cbradney 634
                        bool DropCmode = false;
635
                        bool AbsHasDrop = false;
2219 fschmid 636
                        double desc, asce, maxDY, firstDes, desc2, maxDX, tabDist;
1741 cbradney 637
                        int DropLines;
638
                        bool StartOfCol = true;
639
                        tTabValues.clear();
640
 
641
                        for (int xxx=0; xxx<5; ++xxx)
642
                        {
2309 fschmid 643
                                Doc->docParagraphStyles[xxx].LineSpaMode = LineSpMode;
644
                                if (LineSpMode == 2)
645
                                        Doc->docParagraphStyles[xxx].BaseAdj = true;
646
                                else
647
                                        Doc->docParagraphStyles[xxx].BaseAdj = false;
1741 cbradney 648
                                Doc->docParagraphStyles[xxx].LineSpa = LineSp;
649
                                Doc->docParagraphStyles[xxx].FontSize = ISize;
650
                                Doc->docParagraphStyles[xxx].Indent = 0;
651
                                Doc->docParagraphStyles[xxx].First = 0;
652
                                Doc->docParagraphStyles[xxx].gapBefore = 0;
653
                                Doc->docParagraphStyles[xxx].gapAfter = 0;
654
                                Doc->docParagraphStyles[xxx].textAlignment = xxx;
655
                        }
656
 
657
                        QPtrList<ZZ> LiList;
658
                        LiList.setAutoDelete(true);
659
                        QRect e2 = QRect(qRound(e.x() / sc), qRound(e.y() / sc), qRound(e.width() / sc), qRound(e.height() / sc));
68 Franz 660
                        p->save();
456 fschmid 661
                        pf2.begin(ScApp->view->viewport());
209 Franz 662
                        pf2.translate(Xpos, Ypos);
663
                        pf2.rotate(Rot);
1394 cbradney 664
                        if ((fillColor() != "None") || (GrType != 0))
971 fschmid 665
                        {
68 Franz 666
                                p->setupPolygon(&PoLine);
745 fschmid 667
                                p->fillPath();
971 fschmid 668
                        }
1394 cbradney 669
                        if (lineColor() != "None")
110 Franz 670
                                lineCorr = Pwidth / 2.0;
671
                        else
672
                                lineCorr = 0;
68 Franz 673
                        if ((isAnnotation) && (AnType == 2) && (Pfile != "") && (PicAvail) && (PicArt) && (AnUseIcons))
971 fschmid 674
                        {
675
                                p->setupPolygon(&PoLine);
676
                                p->setClipPath();
677
                                p->save();
678
                                p->scale(LocalScX, LocalScY);
679
                                p->translate(static_cast<int>(LocalX*LocalScX), static_cast<int>(LocalY*LocalScY));
680
                                if (!pixm.isNull())
681
                                        p->drawImage(&pixm);
682
                                p->restore();
683
                        }
1065 cbradney 684
                        if ((itemText.count() != 0) && (Dirty))
384 Franz 685
                        {
1392 cbradney 686
                                if (imageFlippedH())
384 Franz 687
                                {
688
                                        p->translate(Width * sc, 0);
689
                                        p->scale(-1, 1);
690
                                }
1392 cbradney 691
                                if (imageFlippedV())
384 Franz 692
                                {
693
                                        p->translate(0, Height * sc);
694
                                        p->scale(1, -1);
695
                                }
696
                                struct ZZ Zli3;
2219 fschmid 697
                                CurrCol = 0;
698
                                ColWidth = (Width - (ColGap * (Cols - 1)) - Extra - RExtra - 2*lineCorr) / Cols;
699
                                ColBound = FPoint((ColWidth + ColGap) * CurrCol+Extra + lineCorr, ColWidth * (CurrCol+1) + ColGap * CurrCol + Extra+lineCorr);
700
                                ColBound = FPoint(ColBound.x(), ColBound.y()+RExtra+lineCorr);
701
                                tabDist = ColBound.x();
2282 fschmid 702
                                uint tabCc = 0;
1065 cbradney 703
                                for (a = 0; a < itemText.count(); ++a)
384 Franz 704
                                {
2309 fschmid 705
                                        if (a >= MaxChars)
387 Franz 706
                                                break;
1065 cbradney 707
                                        hl = itemText.at(a);
2282 fschmid 708
                                        if (hl->cab < 5)
709
                                                tTabValues = TabValues;
710
                                        else
711
                                                tTabValues = Doc->docParagraphStyles[hl->cab].TabValues;
712
                                        if (hl->cstyle & 16384)
713
                                                tabCc = 0;
384 Franz 714
                                        chx = hl->ch;
2228 fschmid 715
                                        if (hl->yp == 0)
716
                                                continue;
384 Franz 717
                                        if (hl->ch == QChar(30))
718
                                                chx = ExpandToken(a);
719
                                        if (hl->ccolor != "None")
720
                                        {
1741 cbradney 721
                                                QColor tmp;
384 Franz 722
                                                SetFarbe(&tmp, hl->ccolor, hl->cshade);
723
                                                p->setBrush(tmp);
724
                                        }
725
                                        if (hl->cstroke != "None")
726
                                        {
1741 cbradney 727
                                                QColor tmp;
384 Franz 728
                                                SetFarbe(&tmp, hl->cstroke, hl->cshade2);
729
                                                p->setPen(tmp, 1, SolidLine, FlatCap, MiterJoin);
730
                                        }
414 Franz 731
                                        chs = hl->csize;
2304 fschmid 732
                                        if (hl->cstyle & 2048)
733
                                        {
734
                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
2307 fschmid 735
                                                        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 736
                                                else
2309 fschmid 737
                                                {
738
                                                        if (Doc->docParagraphStyles[hl->cab].LineSpaMode == 0)
739
                                                                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))));
740
                                                        else
741
                                                        {
2316 fschmid 742
                                                                double currasce = RealFHeight(Doc, hl->cfont, Doc->docParagraphStyles[hl->cab].FontSize);
2309 fschmid 743
                                                                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)));
744
                                                        }
745
                                                }
2304 fschmid 746
                                        }
414 Franz 747
                                        oldCurY = SetZeichAttr(hl, &chs, &chx);
2285 fschmid 748
                                        if ((chx == QChar(9)) && (tTabValues.count() != 0) && (tabCc < tTabValues.count()) && (!tTabValues[tabCc].tabFillChar.isNull()))
2219 fschmid 749
                                        {
2282 fschmid 750
                                                double wt = Cwidth(Doc, hl->cfont, QString(tTabValues[tabCc].tabFillChar), chs);
2219 fschmid 751
                                                int coun = static_cast<int>((hl->xp - tabDist) / wt);
752
                                                double sPos = hl->xp - (hl->xp - tabDist) + 1;
753
                                                desc = hl->cfont->numDescender * (-chs / 10.0);
754
                                                asce = hl->cfont->numAscent * (chs / 10.0);
2282 fschmid 755
                                                Zli3.Zeich = QString(tTabValues[tabCc].tabFillChar);
2219 fschmid 756
                                                Zli3.Farb = hl->ccolor;
757
                                                Zli3.Farb2 = hl->cstroke;
758
                                                Zli3.shade = hl->cshade;
759
                                                Zli3.shade2 = hl->cshade2;
760
                                                Zli3.yco = hl->yp;
761
                                                Zli3.Sele = hl->cselect;
762
                                                Zli3.Siz = chs;
763
                                                Zli3.realSiz = hl->csize;
764
                                                Zli3.Style = hl->cstyle;
765
                                                Zli3.ZFo = hl->cfont;
766
                                                Zli3.wide = wt;
767
                                                Zli3.kern = 0;
2242 fschmid 768
                                                Zli3.scale = 1000;
769
                                                Zli3.scalev = 1000;
2247 fschmid 770
                                                Zli3.shadowX = hl->cshadowx;
771
                                                Zli3.shadowY = hl->cshadowy;
2257 fschmid 772
                                                Zli3.outline = hl->coutline;
2242 fschmid 773
                                                Zli3.base = hl->cbase;
2262 fschmid 774
                                                Zli3.underpos = hl->cunderpos;
775
                                                Zli3.underwidth = hl->cunderwidth;
2272 fschmid 776
                                                Zli3.strikepos = hl->cstrikepos;
777
                                                Zli3.strikewidth = hl->cstrikewidth;
2219 fschmid 778
                                                for (int cx = 0; cx < coun; ++cx)
779
                                                {
780
                                                        Zli3.xco =  sPos + wt * cx;
781
                                                        if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
782
                                                                DrawZeichenS(p, &Zli3);
783
                                                }
784
                                        }
2282 fschmid 785
                                        if (chx == QChar(9))
786
                                                tabCc++;
414 Franz 787
                                        Zli3.Zeich = chx;
384 Franz 788
                                        Zli3.Farb = hl->ccolor;
789
                                        Zli3.Farb2 = hl->cstroke;
790
                                        Zli3.shade = hl->cshade;
791
                                        Zli3.shade2 = hl->cshade2;
792
                                        Zli3.xco = hl->xp;
793
                                        Zli3.yco = hl->yp;
794
                                        Zli3.Sele = hl->cselect;
414 Franz 795
                                        Zli3.Siz = chs;
2185 fschmid 796
                                        Zli3.realSiz = hl->csize;
384 Franz 797
                                        Zli3.Style = hl->cstyle;
798
                                        Zli3.ZFo = hl->cfont;
2434 fschmid 799
                                        if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
800
                                                Zli3.wide = hl->cembedded->Width * (hl->cscale / 1000.0);
801
                                        else
802
                                                Zli3.wide = Cwidth(Doc, hl->cfont, chx, hl->csize) * (hl->cscale / 1000.0);
2185 fschmid 803
                                        if (hl->cstyle & 16384)
2174 fschmid 804
                                                Zli3.kern = 0;
805
                                        else
2382 fschmid 806
                                                Zli3.kern = chs * hl->cextra / 10000.0;
384 Franz 807
                                        Zli3.scale = hl->cscale;
2230 fschmid 808
                                        Zli3.scalev = hl->cscalev;
2234 fschmid 809
                                        Zli3.base = hl->cbase;
2247 fschmid 810
                                        Zli3.shadowX = hl->cshadowx;
811
                                        Zli3.shadowY = hl->cshadowy;
2257 fschmid 812
                                        Zli3.outline = hl->coutline;
2262 fschmid 813
                                        Zli3.underpos = hl->cunderpos;
814
                                        Zli3.underwidth = hl->cunderwidth;
2272 fschmid 815
                                        Zli3.strikepos = hl->cstrikepos;
816
                                        Zli3.strikewidth = hl->cstrikewidth;
2434 fschmid 817
                                        Zli3.embedded = hl->cembedded;
384 Franz 818
                                        if (!Doc->RePos)
418 Franz 819
                                        {
2155 fschmid 820
                                                desc = Zli3.ZFo->numDescender * (-Zli3.Siz / 10.0);
821
                                                asce = Zli3.ZFo->numAscent * (Zli3.Siz / 10.0);
2366 fschmid 822
                                                if (((chx == QChar(13)) || (chx == QChar(28))) && (Doc->guidesSettings.showControls))
2353 fschmid 823
                                                {
824
                                                        if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco+Zli3.wide),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
825
                                                        {
826
                                                                FPointArray points;
2359 fschmid 827
                                                                QWMatrix chma, chma2, chma4, chma5;
2366 fschmid 828
                                                                double ytrans, xtrans;
829
                                                                if (chx == QChar(13))
2359 fschmid 830
                                                                {
2366 fschmid 831
                                                                        points = Doc->symReturn.copy();
832
                                                                        if (a > 0)
833
                                                                                ytrans = itemText.at(a-1)->yp-((Zli3.Siz / 10.0) * 0.8);
2359 fschmid 834
                                                                        else
2366 fschmid 835
                                                                                ytrans = Zli3.yco-Doc->docParagraphStyles[hl->cab].LineSpa-((Zli3.Siz / 10.0) * 0.8);
2359 fschmid 836
                                                                }
2366 fschmid 837
                                                                else
2359 fschmid 838
                                                                {
2366 fschmid 839
                                                                        points = Doc->symNewLine.copy();
840
                                                                        if (a > 0)
841
                                                                                ytrans = itemText.at(a-1)->yp-((Zli3.Siz / 10.0) * 0.4);
2359 fschmid 842
                                                                        else
2366 fschmid 843
                                                                                ytrans = Zli3.yco-Doc->docParagraphStyles[hl->cab].LineSpa-((Zli3.Siz / 10.0) * 0.4);
2359 fschmid 844
                                                                }
2366 fschmid 845
                                                                if (hl->cstyle & 16384)
846
                                                                        xtrans = Zli3.xco;
847
                                                                else
2359 fschmid 848
                                                                {
2366 fschmid 849
                                                                        if (a > 0)
850
                                                                                xtrans = itemText.at(a-1)->xp+ Cwidth(Doc, itemText.at(a-1)->cfont, itemText.at(a-1)->ch, itemText.at(a-1)->csize);
851
                                                                        else
852
                                                                                xtrans = Zli3.xco;
2359 fschmid 853
                                                                }
2366 fschmid 854
                                                                chma4.translate(xtrans, ytrans);
855
                                                                chma.scale(Zli3.Siz / 100.0, Zli3.Siz / 100.0);
856
                                                                chma2.scale(Zli3.scale / 1000.0, Zli3.scalev / 1000.0);
857
                                                                chma5.scale(p->zoomFactor(), p->zoomFactor());
858
                                                                points.map(chma * chma2 * chma4 * chma5);
859
                                                                p->setupTextPolygon(&points);
860
                                                                p->setFillMode(1);
861
                                                                p->fillPath();
2353 fschmid 862
                                                        }
863
                                                }
1093 fschmid 864
                                                if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
2434 fschmid 865
                                                {
866
                                                        if (Zli3.Zeich == QChar(25))
867
                                                                DrawObj_Embedded(p, e, &Zli3);
868
                                                        else
869
                                                                DrawZeichenS(p, &Zli3);
870
                                                }
2185 fschmid 871
                                                if (hl->cstyle & 8192)
418 Franz 872
                                                {
873
                                                        Zli3.Zeich = "-";
2416 fschmid 874
                                                        Zli3.xco = Zli3.xco + Zli3.wide;
1093 fschmid 875
                                                        if (e2.intersects(pf2.xForm(QRect(qRound(Zli3.xco),qRound(Zli3.yco-asce), qRound(Zli3.wide+1), qRound(asce+desc)))))
454 fschmid 876
                                                                DrawZeichenS(p, &Zli3);
418 Franz 877
                                                }
878
                                        }
2225 fschmid 879
                                        tabDist = Zli3.xco+Zli3.wide;
384 Franz 880
                                }
1065 cbradney 881
                                if (itemText.count() > MaxChars)
385 Franz 882
                                {
883
                                        if (!Doc->RePos)
884
                                        {
2380 cbradney 885
                                                double scp1 = 1 / QMAX(ScApp->view->getScale(), 1);
421 Franz 886
                                                double scp16 = 16 * scp1;
887
                                                double scp14 = 14 * scp1;
888
                                                double scp3 = 3 * scp1;
889
                                                double scpwidth16 = Width - scp16;
890
                                                double scpheight16 = Height - scp16;
891
                                                double scpwidth3 = Width - scp3;
892
                                                double scpheight3 = Height - scp3;
456 fschmid 893
                                                p->setBrush(white);
421 Franz 894
                                                p->setPen(black, scp1, SolidLine, FlatCap, MiterJoin);
895
                                                p->drawRect(scpwidth16, scpheight16, scp14, scp14);
896
                                                p->drawLine(FPoint(scpwidth16, scpheight16), FPoint(scpwidth3, scpheight3));
897
                                                p->drawLine(FPoint(scpwidth16, scpheight3), FPoint(scpwidth3, scpheight16));
385 Franz 898
                                        }
899
                                }
384 Franz 900
                                Dirty = false;
901
                                Redrawn = true;
902
                                pf2.end();
903
                                p->restore();
904
                                break;
905
                        }
1065 cbradney 906
                        if ((itemText.count() != 0) || (NextBox != 0))
971 fschmid 907
                        {
908
                                if (NextBox != 0)
68 Franz 909
                                {
1957 cbradney 910
                                        nextItem = NextBox;
911
                                        while (nextItem != 0)
971 fschmid 912
                                        {
1957 cbradney 913
                                                a = nextItem->itemText.count();
68 Franz 914
                                                for (uint s=0; s<a; ++s)
971 fschmid 915
                                                {
1957 cbradney 916
                                                        itemText.append(nextItem->itemText.take(0));
971 fschmid 917
                                                }
1957 cbradney 918
                                                nextItem->MaxChars = 0;
919
                                                nextItem = nextItem->NextBox;
971 fschmid 920
                                        }
1957 cbradney 921
                                        nextItem = NextBox;
971 fschmid 922
                                }
1065 cbradney 923
                                Doc->docParagraphStyles[0].LineSpa = LineSp;
209 Franz 924
                                QRegion cl = QRegion(pf2.xForm(Clip));
2122 fschmid 925
                                int LayerLev = Layer2Level(Doc, LayerNr);
1866 fschmid 926
                                if (OnMasterPage != "")
927
                                {
928
                                        Page* Mp = Doc->MasterPages.at(Doc->MasterNames[OnMasterPage]);
1905 fschmid 929
                                        Page* Dp = Doc->Pages.at(savedOwnPage);
1866 fschmid 930
                                        for (a = 0; a < Doc->MasterItems.count(); ++a)
931
                                        {
932
                                                PageItem* docItem = Doc->MasterItems.at(a);
2122 fschmid 933
                                                int LayerLevItem = Layer2Level(Doc, docItem->LayerNr);
934
                                                if (((docItem->ItemNr > ItemNr) && (docItem->LayerNr == LayerNr)) || (LayerLevItem > LayerLev))
1866 fschmid 935
                                                {
2447 fschmid 936
                                                        if (docItem->textFlowsAroundFrame())
1866 fschmid 937
                                                        {
938
                                                                pp.begin(ScApp->view->viewport());
939
                                                                pp.translate(docItem->Xpos - Mp->Xoffset + Dp->Xoffset, docItem->Ypos - Mp->Yoffset + Dp->Yoffset);
940
                                                                pp.rotate(docItem->Rot);
941
                                                                if (docItem->textFlowUsesBoundingBox())
942
                                                                {
943
                                                                        QPointArray tcli;
944
                                                                        tcli.resize(4);
945
                                                                        tcli.setPoint(0, QPoint(0,0));
946
                                                                        tcli.setPoint(1, QPoint(qRound(docItem->Width), 0));
947
                                                                        tcli.setPoint(2, QPoint(qRound(docItem->Width), qRound(docItem->Height)));
948
                                                                        tcli.setPoint(3, QPoint(0, qRound(docItem->Height)));
949
                                                                        cm = QRegion(pp.xForm(tcli));
950
                                                                }
951
                                                                else
952
                                                                {
953
                                                                        if ((docItem->textFlowUsesContourLine()) && (docItem->ContourLine.size() != 0))
954
                                                                        {
955
                                                                                QValueList<uint> Segs;
956
                                                                                QPointArray Clip2 = FlattenPath(docItem->ContourLine, Segs);
957
                                                                                cm = QRegion(pp.xForm(Clip2));
958
                                                                        }
959
                                                                        else
960
                                                                                cm = QRegion(pp.xForm(docItem->Clip));
961
                                                                }
962
                                                                pp.end();
963
                                                                cl = cl.subtract(cm);
964
                                                        }
965
                                                }
966
                                        }
967
                                        for (a = 0; a < Doc->Items.count(); ++a)
968
                                        {
969
                                                PageItem* docItem = Doc->Items.at(a);
2447 fschmid 970
                                                if (docItem->textFlowsAroundFrame())
1866 fschmid 971
                                                {
972
                                                        pp.begin(ScApp->view->viewport());
973
                                                        pp.translate(docItem->Xpos, docItem->Ypos);
974
                                                        pp.rotate(docItem->Rot);
975
                                                        if (docItem->textFlowUsesBoundingBox())
976
                                                        {
977
                                                                QPointArray tcli;
978
                                                                tcli.resize(4);
979
                                                                tcli.setPoint(0, QPoint(0,0));
980
                                                                tcli.setPoint(1, QPoint(qRound(docItem->Width), 0));
981
                                                                tcli.setPoint(2, QPoint(qRound(docItem->Width), qRound(docItem->Height)));
982
                                                                tcli.setPoint(3, QPoint(0, qRound(docItem->Height)));
983
                                                                cm = QRegion(pp.xForm(tcli));
984
                                                        }
985
                                                        else
986
                                                        {
987
                                                                if ((docItem->textFlowUsesContourLine()) && (docItem->ContourLine.size() != 0))
988
                                                                {
989
                                                                        QValueList<uint> Segs;
990
                                                                        QPointArray Clip2 = FlattenPath(docItem->ContourLine, Segs);
991
                                                                        cm = QRegion(pp.xForm(Clip2));
992
                                                                }
993
                                                                else
994
                                                                        cm = QRegion(pp.xForm(docItem->Clip));
995
                                                        }
996
                                                        pp.end();
997
                                                        cl = cl.subtract(cm);
998
                                                }
999
                                        }
1000
                                }
456 fschmid 1001
                                for (a = 0; a < Doc->Items.count(); ++a)
971 fschmid 1002
                                {
1866 fschmid 1003
                                        PageItem* docItem = Doc->Items.at(a);
2122 fschmid 1004
                                        int LayerLevItem = Layer2Level(Doc, docItem->LayerNr);
1005
                                        if (((docItem->ItemNr > ItemNr) && (docItem->LayerNr == LayerNr)) || (LayerLevItem > LayerLev))
971 fschmid 1006
                                        {
2447 fschmid 1007
                                                if (docItem->textFlowsAroundFrame())
3 paul 1008
                                                {
456 fschmid 1009
                                                        pp.begin(ScApp->view->viewport());
1866 fschmid 1010
                                                        pp.translate(docItem->Xpos, docItem->Ypos);
1011
                                                        pp.rotate(docItem->Rot);
1012
                                                        if (docItem->textFlowUsesBoundingBox())
971 fschmid 1013
                                                        {
68 Franz 1014
                                                                QPointArray tcli;
1015
                                                                tcli.resize(4);
1016
                                                                tcli.setPoint(0, QPoint(0,0));
1866 fschmid 1017
                                                                tcli.setPoint(1, QPoint(qRound(docItem->Width), 0));
1018
                                                                tcli.setPoint(2, QPoint(qRound(docItem->Width), qRound(docItem->Height)));
1019
                                                                tcli.setPoint(3, QPoint(0, qRound(docItem->Height)));
68 Franz 1020
                                                                cm = QRegion(pp.xForm(tcli));
971 fschmid 1021
                                                        }
68 Franz 1022
                                                        else
340 Franz 1023
                                                        {
1866 fschmid 1024
                                                                if ((docItem->textFlowUsesContourLine()) && (docItem->ContourLine.size() != 0))
340 Franz 1025
                                                                {
1026
                                                                        QValueList<uint> Segs;
1866 fschmid 1027
                                                                        QPointArray Clip2 = FlattenPath(docItem->ContourLine, Segs);
340 Franz 1028
                                                                        cm = QRegion(pp.xForm(Clip2));
1029
                                                                }
1030
                                                                else
1866 fschmid 1031
                                                                        cm = QRegion(pp.xForm(docItem->Clip));
340 Franz 1032
                                                        }
68 Franz 1033
                                                        pp.end();
1034
                                                        cl = cl.subtract(cm);
3 paul 1035
                                                }
1036
                                        }
971 fschmid 1037
                                }
1392 cbradney 1038
                                if (imageFlippedH())
383 Franz 1039
                                {
68 Franz 1040
                                        p->translate(Width * sc, 0);
1041
                                        p->scale(-1, 1);
263 Franz 1042
                                        pf2.translate(Width, 0);
262 Franz 1043
                                        pf2.scale(-1, 1);
383 Franz 1044
                                }
1392 cbradney 1045
                                if (imageFlippedV())
383 Franz 1046
                                {
68 Franz 1047
                                        p->translate(0, Height * sc);
1048
                                        p->scale(1, -1);
263 Franz 1049
                                        pf2.translate(0, Height);
262 Franz 1050
                                        pf2.scale(1, -1);
383 Franz 1051
                                }
134 Franz 1052
                                CurrCol = 0;
140 Franz 1053
                                ColWidth = (Width - (ColGap * (Cols - 1)) - Extra - RExtra - 2*lineCorr) / Cols;
1054
                                ColBound = FPoint((ColWidth + ColGap) * CurrCol+Extra + lineCorr, ColWidth * (CurrCol+1) + ColGap * CurrCol + Extra+lineCorr);
138 Franz 1055
                                ColBound = FPoint(ColBound.x(), ColBound.y()+RExtra+lineCorr);
140 Franz 1056
                                CurX = ColBound.x();
1065 cbradney 1057
                                if (itemText.count() > 0)
971 fschmid 1058
                                {
1065 cbradney 1059
                                        hl = itemText.at(0);
1060
                                        if (Doc->docParagraphStyles[hl->cab].Drop)
241 Franz 1061
                                        {
1065 cbradney 1062
                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
1063
                                                        chs = qRound(Doc->typographicSetttings.valueBaseGrid  * Doc->docParagraphStyles[hl->cab].DropLin * 10);
241 Franz 1064
                                                else
1065 cbradney 1065
                                                        chs = qRound(Doc->docParagraphStyles[hl->cab].LineSpa * Doc->docParagraphStyles[hl->cab].DropLin * 10);
241 Franz 1066
                                        }
160 Franz 1067
                                        else
1068
                                                chs = hl->csize;
1789 fschmid 1069
                                        desc2 = -hl->cfont->numDescender * (chs / 10.0);
175 Franz 1070
                                        CurY = TExtra+lineCorr;
971 fschmid 1071
                                }
160 Franz 1072
                                else
971 fschmid 1073
                                {
160 Franz 1074
                                        desc2 = -(*Doc->AllFonts)[IFont]->numDescender * (ISize / 10.0);
1065 cbradney 1075
                                        CurY = Doc->docParagraphStyles[0].LineSpa+TExtra+lineCorr-desc2;
971 fschmid 1076
                                }
160 Franz 1077
                                firstDes = desc2;
68 Franz 1078
                                LiList.clear();
1079
                                BuPos = 0;
1080
                                LastSP = 0;
1081
                                LastXp = 0;
1082
                                outs = false;
1083
                                OFs = 0;
1084
                                OFs2 = 0;
1085
                                aSpa = 0;
1086
                                absa = 0;
209 Franz 1087
                                MaxChars = 0;
2219 fschmid 1088
                                tabDist = 0;
1065 cbradney 1089
                                MaxText = itemText.count();
209 Franz 1090
                                StartOfCol = true;
114 Franz 1091
                                for (a = 0; a < MaxText; ++a)
971 fschmid 1092
                                {
1065 cbradney 1093
                                        hl = itemText.at(a);
68 Franz 1094
                                        chx = hl->ch;
1095
                                        if (hl->ch == QChar(30))
1096
                                                chx = ExpandToken(a);
1097
                                        absa = hl->cab;
2309 fschmid 1098
                                        if (Doc->docParagraphStyles[absa].LineSpaMode == 1)
1099
                                                Doc->docParagraphStyles[absa].LineSpa = RealFHeight(Doc, hl->cfont, hl->csize);
68 Franz 1100
                                        if (a == 0)
971 fschmid 1101
                                        {
1102
                                                if (BackBox != 0)
3 paul 1103
                                                {
1957 cbradney 1104
                                                        nextItem = BackBox;
1105
                                                        while (nextItem != 0)
971 fschmid 1106
                                                        {
1957 cbradney 1107
                                                                if (nextItem->itemText.count() != 0)
3 paul 1108
                                                                {
1957 cbradney 1109
                                                                        if (nextItem->itemText.at(nextItem->itemText.count()-1)->ch == QChar(13))
3 paul 1110
                                                                        {
1065 cbradney 1111
                                                                                CurY += Doc->docParagraphStyles[absa].gapBefore;
153 Franz 1112
                                                                                if (chx != QChar(13))
1065 cbradney 1113
                                                                                        DropCmode = Doc->docParagraphStyles[absa].Drop;
175 Franz 1114
                                                                                else
1115
                                                                                        DropCmode = false;
153 Franz 1116
                                                                                if (DropCmode)
1065 cbradney 1117
                                                                                        DropLines = Doc->docParagraphStyles[absa].DropLin;
116 Franz 1118
                                                                                break;
971 fschmid 1119
                                                                        }
116 Franz 1120
                                                                        else
1121
                                                                                break;
971 fschmid 1122
                                                                }
1957 cbradney 1123
                                                                nextItem = nextItem->BackBox;
3 paul 1124
                                                        }
971 fschmid 1125
                                                }
3 paul 1126
                                                else
971 fschmid 1127
                                                {
153 Franz 1128
                                                        if (chx != QChar(13))
1065 cbradney 1129
                                                                DropCmode = Doc->docParagraphStyles[absa].Drop;
175 Franz 1130
                                                        else
1131
                                                                DropCmode = false;
1065 cbradney 1132
                                                        CurY += Doc->docParagraphStyles[absa].gapBefore;
153 Franz 1133
                                                        if (DropCmode)
1065 cbradney 1134
                                                                DropLines = Doc->docParagraphStyles[absa].DropLin;
3 paul 1135
                                                }
971 fschmid 1136
                                        }
2304 fschmid 1137
                                        hl->cstyle &= 0xF7FF; // 2047;
2407 fschmid 1138
                                        hl->cstyle &= 8191;
1065 cbradney 1139
                                        if (((Doc->docParagraphStyles[absa].textAlignment == 3) || (Doc->docParagraphStyles[absa].textAlignment == 4)) && (LiList.count() == 0) && (hl->ch == " "))
316 Franz 1140
                                        {
2185 fschmid 1141
                                                hl->cstyle |= 4096;
316 Franz 1142
                                                continue;
1143
                                        }
1144
                                        else
2304 fschmid 1145
                                                hl->cstyle &= 0xEFFF; // 4095;
68 Franz 1146
                                        if (LiList.count() == 0)
971 fschmid 1147
                                        {
2159 fschmid 1148
                                                if (((a > 0) && (itemText.at(a-1)->ch == QChar(13))) || ((a == 0) && (BackBox == 0)))
3 paul 1149
                                                {
1065 cbradney 1150
                                                        CurY += Doc->docParagraphStyles[absa].gapBefore;
153 Franz 1151
                                                        if (chx != QChar(13))
1065 cbradney 1152
                                                                DropCmode = Doc->docParagraphStyles[absa].Drop;
175 Franz 1153
                                                        else
1154
                                                                DropCmode = false;
153 Franz 1155
                                                        if (DropCmode)
971 fschmid 1156
                                                        {
1065 cbradney 1157
                                                                DropLines = Doc->docParagraphStyles[absa].DropLin;
1158
                                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
823 fschmid 1159
                                                                        CurY += Doc->typographicSetttings.valueBaseGrid * (DropLines-1);
241 Franz 1160
                                                                else
2309 fschmid 1161
                                                                {
1162
                                                                        if (Doc->docParagraphStyles[absa].LineSpaMode == 0)
1163
                                                                                CurY += Doc->docParagraphStyles[absa].LineSpa * (DropLines-1);
1164
                                                                        else
2316 fschmid 1165
                                                                                CurY += RealFHeight(Doc, hl->cfont, Doc->docParagraphStyles[absa].FontSize) * (DropLines-1);
2309 fschmid 1166
                                                                }
3 paul 1167
                                                        }
68 Franz 1168
                                                }
971 fschmid 1169
                                        }
153 Franz 1170
                                        if (DropCmode)
971 fschmid 1171
                                        {
1065 cbradney 1172
                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
310 Franz 1173
                                                {
2307 fschmid 1174
                                                        chsd = qRound(10 * ((Doc->typographicSetttings.valueBaseGrid * (DropLines-1)+(hl->cfont->numAscent * (Doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(Doc, hl->cfont, chx, 10))));
1175
                                                        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 1176
                                                }
241 Franz 1177
                                                else
310 Franz 1178
                                                {
2309 fschmid 1179
                                                        if (Doc->docParagraphStyles[absa].LineSpaMode == 0)
1180
                                                        {
1181
                                                                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))));
1182
                                                                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)));
1183
                                                        }
1184
                                                        else
1185
                                                        {
2316 fschmid 1186
                                                                double currasce = RealFHeight(Doc, hl->cfont, Doc->docParagraphStyles[hl->cab].FontSize);
2309 fschmid 1187
                                                                chsd = qRound(10 * ((currasce * (DropLines-1)+(hl->cfont->numAscent * (Doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / (RealCHeight(Doc, hl->cfont, chx, 10))));
1188
                                                                chs = qRound(10 * ((currasce * (DropLines-1)+(hl->cfont->numAscent * (Doc->docParagraphStyles[hl->cab].FontSize / 10.0))) / RealCAscent(Doc, hl->cfont, chx, 10)));
1189
                                                        }
153 Franz 1190
                                                }
2304 fschmid 1191
                                                hl->cstyle |= 2048;
971 fschmid 1192
                                        }
153 Franz 1193
                                        else
2434 fschmid 1194
                                        {
1195
                                                if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1196
                                                        chs = qRound(hl->cembedded->Height * 10);
1197
                                                else
1198
                                                        chs = hl->csize;
1199
                                        }
157 Franz 1200
                                        oldCurY = SetZeichAttr(hl, &chs, &chx);
68 Franz 1201
                                        if (chx == QChar(29))
1202
                                                chx2 = " ";
2407 fschmid 1203
                                        else if (chx == QChar(24))
1204
                                                chx2 = "-";
68 Franz 1205
                                        else
1206
                                                chx2 = chx;
2434 fschmid 1207
                                        if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1208
                                                wide = hl->cembedded->Width;
1209
                                        else
971 fschmid 1210
                                        {
2434 fschmid 1211
                                                if (a < MaxText-1)
1212
                                                {
1213
                                                        if (itemText.at(a+1)->ch == QChar(29))
1214
                                                                chx3 = " ";
1215
                                                        else if (itemText.at(a+1)->ch == QChar(24))
1216
                                                                chx3 = "-";
1217
                                                        else
1218
                                                                chx3 = itemText.at(a+1)->ch;
1219
                                                        wide = Cwidth(Doc, hl->cfont, chx2, chs, chx3);
1220
                                                }
3 paul 1221
                                                else
2434 fschmid 1222
                                                        wide = Cwidth(Doc, hl->cfont, chx2, chs);
971 fschmid 1223
                                        }
220 Franz 1224
                                        if (DropCmode)
310 Franz 1225
                                        {
2434 fschmid 1226
                                                if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1227
                                                {
1228
                                                        wide = hl->cembedded->Width;
1229
                                                        asce = hl->cembedded->Height;
1230
                                                }
1231
                                                else
1232
                                                {
1233
                                                        wide = RealCWidth(Doc, hl->cfont, chx2, chsd);
1234
                                                        asce = RealCHeight(Doc, hl->cfont, chx2, chsd);
1235
                                                }
310 Franz 1236
                                                desc2 = 0;
1237
                                                desc = 0;
1238
                                        }
1239
                                        else
1240
                                        {
2434 fschmid 1241
                                                if ((hl->ch == QChar(25)) && (hl->cembedded != 0))
1242
                                                {
1243
                                                        asce = hl->cembedded->Height;
1244
                                                        desc2 = 0;
1245
                                                        desc = 0;
1246
                                                }
1247
                                                else
1248
                                                {
1249
                                                        desc2 = -hl->cfont->numDescender * (hl->csize / 10.0);
1250
                                                        desc = -hl->cfont->numDescender * (hl->csize / 10.0);
1251
                                                        asce = hl->cfont->numAscent * (hl->csize / 10.0);
1252
                                                }
310 Franz 1253
                                        }
2242 fschmid 1254
                                        wide = wide * (hl->cscale / 1000.0);
138 Franz 1255
                                        fBorder = false;
68 Franz 1256
                                        if (LiList.isEmpty())
971 fschmid 1257
                                        {
251 Franz 1258
                                                startLin = a;
246 Franz 1259
                                                double TopOffset = asce;
1260
                                                double BotOffset = desc2;
949 fschmid 1261
                                                goNoRoom = false;
175 Franz 1262
                                                if (StartOfCol)
204 Franz 1263
                                                {
1264
                                                        CurY = asce+TExtra+lineCorr+1;
2159 fschmid 1265
                                                        if (((a > 0) && (itemText.at(a-1)->ch == QChar(13))) || ((a == 0) && (BackBox == 0)))
1065 cbradney 1266
                                                                CurY += Doc->docParagraphStyles[hl->cab].gapBefore;
204 Franz 1267
                                                }
1065 cbradney 1268
                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
242 Franz 1269
                                                {
634 fschmid 1270
                                                        double by = Ypos;
1271
                                                        if (OwnPage != -1)
1272
                                                                by = Ypos - Doc->Pages.at(OwnPage)->Yoffset;
823 fschmid 1273
                                                        int ol1 = qRound((by + CurY - Doc->typographicSetttings.offsetBaseGrid) * 10000.0);
1274
                                                        int ol2 = static_cast<int>(ol1 / Doc->typographicSetttings.valueBaseGrid);
1275
                                                        CurY = ceil(  ol2 / 10000.0 ) * Doc->typographicSetttings.valueBaseGrid + Doc->typographicSetttings.offsetBaseGrid - by;
242 Franz 1276
                                                }
318 Franz 1277
                                                if (CurY-TopOffset < 0.0)
1278
                                                        CurY = TopOffset+1;
205 Franz 1279
                                                pt1 = QPoint(static_cast<int>(ceil(CurX)), static_cast<int>(CurY+BotOffset));
204 Franz 1280
                                                pt2 = QPoint(static_cast<int>(ceil(CurX)), static_cast<int>(ceil(CurY-TopOffset)));
209 Franz 1281
                                                while ((!cl.contains(pf2.xForm(pt1))) || (!cl.contains(pf2.xForm(pt2))))
971 fschmid 1282
                                                {
135 Franz 1283
                                                        fBorder = true;
68 Franz 1284
                                                        CurX++;
134 Franz 1285
                                                        if (CurX+RExtra+lineCorr > ColBound.y())
971 fschmid 1286
                                                        {
158 Franz 1287
                                                                fBorder = false;
175 Franz 1288
                                                                if (StartOfCol)
1065 cbradney 1289
                                                                {
2159 fschmid 1290
                                                                        CurX = ColBound.x();
175 Franz 1291
                                                                        CurY++;
1065 cbradney 1292
                                                                }
175 Franz 1293
                                                                else
242 Franz 1294
                                                                {
1065 cbradney 1295
                                                                        CurY += Doc->docParagraphStyles[hl->cab].LineSpa;
1296
                                                                        CurX = ColBound.x();
1297
                                                                }
1298
                                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
1299
                                                                {
635 fschmid 1300
                                                                        double by = Ypos;
1301
                                                                        if (OwnPage != -1)
1302
                                                                                by = Ypos - Doc->Pages.at(OwnPage)->Yoffset;
823 fschmid 1303
                                                                        int ol1 = qRound((by + CurY - Doc->typographicSetttings.offsetBaseGrid) * 10000.0);
1304
                                                                        int ol2 = static_cast<int>(ol1 / Doc->typographicSetttings.valueBaseGrid);
1305
                                                                        CurY = ceil(  ol2 / 10000.0 ) * Doc->typographicSetttings.valueBaseGrid + Doc->typographicSetttings.offsetBaseGrid - by;
242 Franz 1306
                                                                }
110 Franz 1307
                                                                if (CurY+BExtra+lineCorr > Height)
971 fschmid 1308
                                                                {
161 Franz 1309
                                                                        StartOfCol = true;
135 Franz 1310
                                                                        fBorder = false;
134 Franz 1311
                                                                        CurrCol++;
1312
                                                                        if (CurrCol < Cols)
971 fschmid 1313
                                                                        {
140 Franz 1314
                                                                                ColWidth = (Width - (ColGap * (Cols - 1)) - Extra - RExtra - 2*lineCorr) / Cols;
136 Franz 1315
                                                                                ColBound = FPoint((ColWidth + ColGap) * CurrCol + Extra+lineCorr, ColWidth * (CurrCol+1) + ColGap * CurrCol + Extra+lineCorr);
1316
                                                                                CurX = ColBound.x();
1317
                                                                                ColBound = FPoint(ColBound.x(), ColBound.y()+RExtra+lineCorr);
204 Franz 1318
                                                                                CurY = asce+TExtra+lineCorr+1;
2159 fschmid 1319
                                                                                if (((a > 0) && (itemText.at(a-1)->ch == QChar(13))) || ((a == 0) && (BackBox == 0)))
971 fschmid 1320
                                                                                {
161 Franz 1321
                                                                                        if (chx != QChar(13))
1065 cbradney 1322
                                                                                                DropCmode = Doc->docParagraphStyles[hl->cab].Drop;
175 Franz 1323
                                                                                        else
1324
                                                                                                DropCmode = false;
161 Franz 1325
                                                                                        if (DropCmode)
241 Franz 1326
                                                                                        {
1065 cbradney 1327
                                                                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
1789 fschmid 1328
                                                                                                        desc2 = -hl->cfont->numDescender * Doc->typographicSetttings.valueBaseGrid * Doc->docParagraphStyles[hl->cab].DropLin;
241 Franz 1329
                                                                                                else
1789 fschmid 1330
                                                                                                        desc2 = -hl->cfont->numDescender * Doc->docParagraphStyles[hl->cab].LineSpa * Doc->docParagraphStyles[hl->cab].DropLin;
241 Franz 1331
                                                                                        }
153 Franz 1332
                                                                                        if (DropCmode)
1065 cbradney 1333
                                                                                                DropLines = Doc->docParagraphStyles[hl->cab].DropLin;
971 fschmid 1334
                                                                                }
1065 cbradney 1335
                                                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
242 Franz 1336
                                                                                {
635 fschmid 1337
                                                                                        double by = Ypos;
1338
                                                                                        if (OwnPage != -1)
1339
                                                                                                by = Ypos - Doc->Pages.at(OwnPage)->Yoffset;
823 fschmid 1340
                                                                                        int ol1 = qRound((by + CurY - Doc->typographicSetttings.offsetBaseGrid) * 10000.0);
1341
                                                                                        int ol2 = static_cast<int>(ol1 / Doc->typographicSetttings.valueBaseGrid);
1342
                                                                                        CurY = ceil(  ol2 / 10000.0 ) * Doc->typographicSetttings.valueBaseGrid + Doc->typographicSetttings.offsetBaseGrid - by;
134 Franz 1343
                                                                                }
971 fschmid 1344
                                                                        }
134 Franz 1345
                                                                        else
971 fschmid 1346
                                                                        {
134 Franz 1347
                                                                                nrc = a;
1348
                                                                                goto NoRoom;
3 paul 1349
                                                                        }
1350
                                                                }
971 fschmid 1351
                                                        }
205 Franz 1352
                                                        pt1 = QPoint(static_cast<int>(ceil(CurX)), static_cast<int>(CurY+BotOffset));
204 Franz 1353
                                                        pt2 = QPoint(static_cast<int>(ceil(CurX)), static_cast<int>(ceil(CurY-TopOffset)));
971 fschmid 1354
                                                }
161 Franz 1355
                                                if ((fBorder) && (!AbsHasDrop))
1356
                                                        CurX += Extra;
2254 fschmid 1357
                                                if (a > 0)
2159 fschmid 1358
                                                {
2254 fschmid 1359
                                                        if (itemText.at(a-1)->ch == QChar(13))
1360
                                                                CurX += Doc->docParagraphStyles[hl->cab].First;
2159 fschmid 1361
                                                }
2254 fschmid 1362
                                                else
1363
                                                {
1364
                                                        if (BackBox == 0)
1365
                                                                CurX += Doc->docParagraphStyles[hl->cab].First;
1366
                                                        else
1367
                                                        {
1368
                                                                if (BackBox->itemText.at(BackBox->itemText.count()-1)->ch == QChar(13))
1369
                                                                        CurX += Doc->docParagraphStyles[hl->cab].First;
1370
                                                        }
1371
                                                }
2284 fschmid 1372
                                                if (!AbsHasDrop)
1373
                                                        CurX += Doc->docParagraphStyles[hl->cab].Indent;
135 Franz 1374
                                                fBorder = false;
971 fschmid 1375
                                        }
163 Franz 1376
                                        if (RTab)
971 fschmid 1377
                                        {
2219 fschmid 1378
                                                if (((hl->ch == ".") && (TabCode == 2)) || ((hl->ch == ",") && (TabCode == 3)) || (hl->ch == QChar(9)))
971 fschmid 1379
                                                {
163 Franz 1380
                                                        RTab = false;
1381
                                                        TabCode = 0;
140 Franz 1382
                                                }
971 fschmid 1383
                                        }
139 Franz 1384
                                        if (hl->ch == QChar(9))
537 fschmid 1385
                                        {
140 Franz 1386
                                                wide = 1;
1387
                                                if (RTab)
1388
                                                        RTab = false;
139 Franz 1389
                                                else
537 fschmid 1390
                                                {
280 Franz 1391
                                                        RTabX = CurX+wide;
140 Franz 1392
                                                        if (hl->cab < 5)
1393
                                                                tTabValues = TabValues;
1394
                                                        else
1065 cbradney 1395
                                                                tTabValues = Doc->docParagraphStyles[hl->cab].TabValues;
140 Franz 1396
                                                        if (tTabValues.isEmpty())
537 fschmid 1397
                                                        {
376 Franz 1398
                                                                if ((CurX - ColBound.x()) != 0)
1992 fschmid 1399
                                                                {
2285 fschmid 1400
                                                                        if (CurX == ColBound.x() + ceil((CurX-ColBound.x()) / Doc->toolSettings.dTabWidth) * Doc->toolSettings.dTabWidth)
1401
                                                                                CurX += Doc->toolSettings.dTabWidth;
1992 fschmid 1402
                                                                        else
2285 fschmid 1403
                                                                                CurX = ColBound.x() + ceil((CurX-ColBound.x()) / Doc->toolSettings.dTabWidth) * Doc->toolSettings.dTabWidth;
1992 fschmid 1404
                                                                }
376 Franz 1405
                                                                else
2285 fschmid 1406
                                                                        CurX = ColBound.x() + Doc->toolSettings.dTabWidth;
140 Franz 1407
                                                                TabCode = 0;
1408
                                                                RTab = false;
537 fschmid 1409
                                                        }
140 Franz 1410
                                                        else
537 fschmid 1411
                                                        {
140 Franz 1412
                                                                double tCurX = CurX - ColBound.x();
1016 fschmid 1413
                                                                double oCurX = tCurX + wide;
2282 fschmid 1414
                                                                for (int yg = static_cast<int>(tTabValues.count()-1); yg > -1; yg--)
537 fschmid 1415
                                                                {
2282 fschmid 1416
                                                                        if (oCurX < tTabValues[yg].tabPosition)
139 Franz 1417
                                                                        {
2282 fschmid 1418
                                                                                tCurX = tTabValues[yg].tabPosition;
1419
                                                                                TabCode = static_cast<int>(tTabValues[yg].tabType);
139 Franz 1420
                                                                        }
537 fschmid 1421
                                                                }
140 Franz 1422
                                                                if (TabCode == 0)
1423
                                                                        RTab = false;
1424
                                                                else
1425
                                                                        RTab = true;
1016 fschmid 1426
                                                                if (tCurX == oCurX-wide)
2285 fschmid 1427
                                                                        CurX = ColBound.x() + ceil((CurX-ColBound.x()) / Doc->toolSettings.dTabWidth) * Doc->toolSettings.dTabWidth;
140 Franz 1428
                                                                else
1429
                                                                        CurX = ColBound.x() + tCurX;
537 fschmid 1430
                                                        }
1431
                                                        CurX -= 1;
140 Franz 1432
                                                        StartRT = LiList.count();
1433
                                                        StartRT2 = a;
139 Franz 1434
                                                }
537 fschmid 1435
                                        }
157 Franz 1436
                                        hl->yp = CurY + oldCurY;
2284 fschmid 1437
                                        if (DropCmode)
1438
                                                hl->yp -= RealCHeight(Doc, hl->cfont, chx2, chsd) - RealCAscent(Doc, hl->cfont, chx2, chsd);
238 Franz 1439
                                        if (LiList.count() == 0)
2174 fschmid 1440
                                        {
2185 fschmid 1441
                                                itemText.at(a)->cstyle |= 16384;
238 Franz 1442
                                                kernVal = 0;
2174 fschmid 1443
                                        }
238 Franz 1444
                                        else
2174 fschmid 1445
                                        {
2382 fschmid 1446
                                                kernVal = chs * hl->cextra / 10000.0;
2185 fschmid 1447
                                                itemText.at(a)->cstyle &= 16383;
2174 fschmid 1448
                                        }
140 Franz 1449
                                        if (!RTab)
971 fschmid 1450
                                        {
2443 fschmid 1451
                                                hl->xp = QMAX(CurX+kernVal, ColBound.x());
238 Franz 1452
                                                CurX += wide+kernVal;
2443 fschmid 1453
                                                CurX = QMAX(CurX, ColBound.x());
971 fschmid 1454
                                        }
140 Franz 1455
                                        else
2384 fschmid 1456
                                        {
2443 fschmid 1457
                                                CurX = QMAX(CurX, ColBound.x());
140 Franz 1458
                                                hl->xp = CurX;
2384 fschmid 1459
                                        }
158 Franz 1460
                                        if ((TabCode == 4) && (RTab))
2384 fschmid 1461
                                        {
238 Franz 1462
                                                CurX += (wide+kernVal) / 2;
2443 fschmid 1463
                                                CurX = QMAX(CurX, ColBound.x());
2384 fschmid 1464
                                        }
2416 fschmid 1465
                                        if (((hl->cstyle & 128) || (hl->ch == "-")) && ((HyphenCount < Doc->HyCount) || (Doc->HyCount == 0)))
1065 cbradney 1466
                                        {
2416 fschmid 1467
                                                if (hl->cstyle & 128)
1065 cbradney 1468
                                                {
2416 fschmid 1469
                                                        pt1 = QPoint(qRound(ceil(CurX+RExtra+Cwidth(Doc, hl->cfont, "-", hl->csize) * (hl->cscale / 1000.0))), qRound(CurY+desc));
1470
                                                        pt2 = QPoint(qRound(ceil(CurX+RExtra+Cwidth(Doc, hl->cfont, "-", hl->csize) * (hl->cscale / 1000.0))), qRound(ceil(CurY-asce)));
1065 cbradney 1471
                                                }
2416 fschmid 1472
                                                else
1473
                                                {
1474
                                                        pt1 = QPoint(qRound(ceil(CurX+RExtra)), qRound(CurY+desc));
1475
                                                        pt2 = QPoint(qRound(ceil(CurX+RExtra)), qRound(ceil(CurY-asce)));
1476
                                                }
1065 cbradney 1477
                                        }
1478
                                        else
1479
                                        {
1480
                                                pt1 = QPoint(qRound(ceil(CurX+RExtra)), qRound(CurY+desc));
1481
                                                pt2 = QPoint(qRound(ceil(CurX+RExtra)), qRound(ceil(CurY-asce)));
1482
                                        }
209 Franz 1483
                                        if ((!cl.contains(pf2.xForm(pt1))) || (!cl.contains(pf2.xForm(pt2))) || (CurX+RExtra+lineCorr > ColBound.y()))
68 Franz 1484
                                                outs = true;
246 Franz 1485
                                        if (CurY > (Height - BExtra - lineCorr))
1486
                                                outs = true;
2352 fschmid 1487
                                        if ((hl->ch == QChar(27)) && (a < itemText.count()-1))
1488
                                                goNoRoom = true;
2384 fschmid 1489
                                        if ((hl->ch == QChar(26)) && (Cols > 1))
1490
                                                goNextColumn = true;
68 Franz 1491
                                        Zli = new ZZ;
1492
                                        Zli->Zeich = chx;
1493
                                        Zli->Farb = hl->ccolor;
1494
                                        Zli->shade = hl->cshade;
1495
                                        Zli->Farb2 = hl->cstroke;
1496
                                        Zli->shade2 = hl->cshade2;
1497
                                        Zli->xco = hl->xp;
175 Franz 1498
                                        Zli->yco = hl->yp;
68 Franz 1499
                                        Zli->Sele = hl->cselect;
310 Franz 1500
                                        if (DropCmode)
2316 fschmid 1501
                                        {
310 Franz 1502
                                                Zli->Siz = chsd;
2316 fschmid 1503
                                                Zli->realSiz = Doc->docParagraphStyles[hl->cab].FontSize;
1504
                                        }
310 Franz 1505
                                        else
2316 fschmid 1506
                                        {
310 Franz 1507
                                                Zli->Siz = chs;
2316 fschmid 1508
                                                Zli->realSiz = hl->csize;
1509
                                        }
68 Franz 1510
                                        Zli->Style = hl->cstyle;
1511
                                        Zli->ZFo = hl->cfont;
1512
                                        Zli->wide = wide;
238 Franz 1513
                                        Zli->kern = kernVal;
68 Franz 1514
                                        Zli->scale = hl->cscale;
2230 fschmid 1515
                                        Zli->scalev = hl->cscalev;
2234 fschmid 1516
                                        Zli->base = hl->cbase;
2247 fschmid 1517
                                        Zli->shadowX = hl->cshadowx;
1518
                                        Zli->shadowY = hl->cshadowy;
2257 fschmid 1519
                                        Zli->outline = hl->coutline;
2262 fschmid 1520
                                        Zli->underpos = hl->cunderpos;
1521
                                        Zli->underwidth = hl->cunderwidth;
2272 fschmid 1522
                                        Zli->strikepos = hl->cstrikepos;
1523
                                        Zli->strikewidth = hl->cstrikewidth;
2434 fschmid 1524
                                        Zli->embedded = hl->cembedded;
139 Franz 1525
                                        if (((hl->ch == " ") || (hl->ch == QChar(9))) && (!outs))
244 Franz 1526
                                        {
1527
                                                if (a > 0)
68 Franz 1528
                                                {
1065 cbradney 1529
                                                        if (itemText.at(a-1)->ch !=  " ")
244 Franz 1530
                                                        {
1736 cbradney 1531
                                                                LastXp = hl->xp;
1532
                                                                LastSP = BuPos;
244 Franz 1533
                                                        }
68 Franz 1534
                                                }
244 Franz 1535
                                                else
1536
                                                {
1537
                                                        LastXp = hl->xp;
1538
                                                        LastSP = BuPos;
1539
                                                }
1540
                                        }
249 Franz 1541
                                        if (((hl->cstyle & 128) || (hl->ch == "-")) && (!outs))
971 fschmid 1542
                                        {
1543
                                                if ((HyphenCount < Doc->HyCount) || (Doc->HyCount == 0))
68 Franz 1544
                                                {
249 Franz 1545
                                                        if (hl->ch == "-")
1546
                                                                LastXp = CurX;
1547
                                                        else
2416 fschmid 1548
                                                                LastXp = CurX + Cwidth(Doc, hl->cfont, "-", hl->csize) * (hl->cscale / 1000.0);
249 Franz 1549
                                                        LastSP = BuPos;
68 Franz 1550
                                                }
971 fschmid 1551
                                        }
68 Franz 1552
                                        LiList.append(Zli);
140 Franz 1553
                                        if (RTab)
971 fschmid 1554
                                        {
140 Franz 1555
                                                uint rtx2 = 0;
147 Franz 1556
                                                double cen = 1;
1557
                                                if (TabCode == 4)
1558
                                                        cen = 2;
140 Franz 1559
                                                for (uint rtx = StartRT; rtx < LiList.count(); ++rtx)
971 fschmid 1560
                                                {
1736 cbradney 1561
                                                        LiList.at(rtx)->xco = QMAX(LiList.at(rtx)->xco-(wide+kernVal) / cen, 0.0);
1562
                                                        itemText.at(StartRT2+rtx2)->xp = QMAX(itemText.at(StartRT2+rtx2)->xp-(wide+kernVal) / cen, 0.0);
1563
                                                        if (itemText.at(StartRT2+rtx2)->xp < RTabX)
1564
                                                        {
1565
                                                                RTab = false;
1566
                                                                TabCode = 0;
1567
                                                        }
1568
                                                        rtx2++;
140 Franz 1569
                                                }
971 fschmid 1570
                                        }
68 Franz 1571
                                        BuPos++;
153 Franz 1572
                                        if (DropCmode)
971 fschmid 1573
                                        {
153 Franz 1574
                                                DropCmode = false;
154 Franz 1575
                                                AbsHasDrop = true;
153 Franz 1576
                                                maxDY = CurY;
2362 fschmid 1577
                                                CurX += Doc->docParagraphStyles[hl->cab].DropDist;
2443 fschmid 1578
                                                CurX = QMAX(CurX, ColBound.x());
161 Franz 1579
                                                maxDX = CurX;
182 Franz 1580
                                                QPointArray tcli;
1581
                                                tcli.resize(4);
1065 cbradney 1582
                                                if (Doc->docParagraphStyles[hl->cab].BaseAdj)
241 Franz 1583
                                                {
823 fschmid 1584
                                                        CurY -= Doc->typographicSetttings.valueBaseGrid * (DropLines-1);
635 fschmid 1585
                                                        double by = Ypos;
1586
                                                        if (OwnPage != -1)
1587
                                                                by = Ypos - Doc->Pages.at(OwnPage)->Yoffset;
823 fschmid 1588
                                                        int ol1 = qRound((by + CurY - Doc->typographicSetttings.offsetBaseGrid) * 10000.0);
1589
                                                        int ol2 = static_cast<int>(ol1 / Doc->typographicSetttings.valueBaseGrid);
1590
                                                        CurY = ceil(  ol2 / 10000.0 ) * Doc->typographicSetttings.valueBaseGrid + Doc->typographicSetttings.offsetBaseGrid - by;
1591
                                                        tcli.setPoint(0, QPoint(qRound(hl->xp), qRound(maxDY-DropLines*Doc->typographicSetttings.valueBaseGrid)));
2362 fschmid 1592
                                                        tcli.setPoint(1, QPoint(qRound(maxDX), qRound(maxDY-DropLines*Doc->typographicSetttings.valueBaseGrid)));
241 Franz 1593
                                                }
1594
                                                else
1595
                                                {
2309 fschmid 1596
                                                        if (Doc->docParagraphStyles[absa].LineSpaMode == 0)
1597
                                                        {
1598
                                                                CurY -= Doc->docParagraphStyles[absa].LineSpa * (DropLines-1);
1599
                                                                tcli.setPoint(0, QPoint(qRound(hl->xp), qRound(maxDY-DropLines*Doc->docParagraphStyles[absa].LineSpa)));
2362 fschmid 1600
                                                                tcli.setPoint(1, QPoint(qRound(maxDX), qRound(maxDY-DropLines*Doc->docParagraphStyles[absa].LineSpa)));
2309 fschmid 1601
                                                        }
1602
                                                        else
1603
                                                        {
2316 fschmid 1604
                                                                double currasce = RealFHeight(Doc, hl->cfont, Doc->docParagraphStyles[hl->cab].FontSize);
2309 fschmid 1605
                                                                CurY -= currasce * (DropLines-1);
1606
                                                                tcli.setPoint(0, QPoint(qRound(hl->xp), qRound(maxDY-DropLines*currasce)));
2362 fschmid 1607
                                                                tcli.setPoint(1, QPoint(qRound(maxDX), qRound(maxDY-DropLines*currasce)));
2309 fschmid 1608
                                                        }
241 Franz 1609
                                                }
2362 fschmid 1610
                                                tcli.setPoint(2, QPoint(qRound(maxDX), qRound(maxDY)));
182 Franz 1611
                                                tcli.setPoint(3, QPoint(qRound(hl->xp), qRound(maxDY)));
209 Franz 1612
                                                cm = QRegion(pf2.xForm(tcli));
153 Franz 1613
                                                cl = cl.subtract(cm);
971 fschmid 1614
                                        }
2384 fschmid 1615
                                        if ((hl->ch == QChar(13)) || (hl->ch == QChar(28)) || (hl->ch == QChar(27))  || ((hl->ch == QChar(26)) && (Cols > 1)) || (outs))
971 fschmid 1616
                                        {
140 Franz 1617
                                                RTab = false;
1618
                                                TabCode = 0;
68 Franz 1619
                                                if (outs)
971 fschmid 1620
                                                {
1621
                                                        if (LastSP != 0)            // Hier koenen auch andere Trennungen eingebaut werden
3 paul 1622
                                                        {
68 Franz 1623
                                                                a -= BuPos - LastSP;
1624
                                                                a++;
1065 cbradney 1625
                                                                if (itemText.at(a)->cstyle & 128)
251 Franz 1626
                                                                {
249 Franz 1627
                                                                        HyphenCount++;
2185 fschmid 1628
                                                                        itemText.at(a)->cstyle |= 8192;
68 Franz 1629
                                                                        Zli = new ZZ;
1630
                                                                        Zli->Zeich = "-";
1065 cbradney 1631
                                                                        Zli->Farb = itemText.at(a)->ccolor;
1632
                                                                        Zli->Farb2 = itemText.at(a)->cstroke;
1633
                                                                        Zli->shade = itemText.at(a)->cshade;
1634
                                                                        Zli->shade2 = itemText.at(a)->cshade2;
2416 fschmid 1635
                                                                        Zli->xco = LastXp - Cwidth(Doc, itemText.at(a)->cfont, "-", itemText.at(a)->csize) * (itemText.at(a)->cscale / 1000.0);
1065 cbradney 1636
                                                                        Zli->yco = itemText.at(a)->yp;
1637
                                                                        Zli->Sele = itemText.at(a)->cselect;
1638
                                                                        Zli->Siz = itemText.at(a)->csize;
2185 fschmid 1639
                                                                        Zli->realSiz = itemText.at(a)->csize;
1065 cbradney 1640
                                                                        Zli->Style = itemText.at(a)->cstyle;
1641
                                                                        Zli->ZFo = itemText.at(a)->cfont;
2416 fschmid 1642
                                                                        Zli->wide = Cwidth(Doc, itemText.at(a)->cfont, "-", itemText.at(a)->csize) * (itemText.at(a)->cscale / 1000.0);
2382 fschmid 1643
                                                                        Zli->kern = itemText.at(a)->csize * itemText.at(a)->cextra / 10000.0;
1065 cbradney 1644
                                                                        Zli->scale = itemText.at(a)->cscale;
2230 fschmid 1645
                                                                        Zli->scalev = itemText.at(a)->cscalev;
2234 fschmid 1646
                                                                        Zli->base = itemText.at(a)->cbase;
2247 fschmid 1647
                                                                        Zli->shadowX = itemText.