Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
3 paul 7
/***************************************************************************
8
                          pageitem.cpp  -  description
9
                             -------------------
10
    begin                : Sat Apr 7 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
136 Franz 23
 
3 paul 24
#include "pageitem.h"
10220 cbradney 25
#include <QPainter>
26
#include <QPen>
27
#include <QFont>
28
#include <QRegion>
29
#include <QPoint>
30
#include <QFileInfo>
3 paul 31
#include <qdrawutil.h>
10220 cbradney 32
#include <QRegExp>
33
#include <QMessageBox>
10284 fschmid 34
#include <QPolygon>
3 paul 35
#include <cmath>
2104 cbradney 36
#include <cassert>
11645 fschmid 37
#include <QDebug>
4772 cbradney 38
 
10532 avox 39
#include "canvas.h"
40
#include "scpaths.h"
10601 mrdocs 41
#include "cmsettings.h"
10212 cbradney 42
#include "colorblind.h"
43
#include "commonstrings.h"
44
#include "cpalette.h"
45
#include "guidemanager.h"
3 paul 46
#include "page.h"
10386 mrdocs 47
#include "pageitem_latexframe.h"
10212 cbradney 48
#include "prefsmanager.h"
10862 cbradney 49
#include "propertiespalette.h"
10212 cbradney 50
#include "resourcecollection.h"
13497 jghali 51
#include "scclocale.h"
10212 cbradney 52
#include "sccolorengine.h"
53
#include "scconfig.h"
4772 cbradney 54
#include "scpainter.h"
10212 cbradney 55
#include "scpaths.h"
56
#include "scpattern.h"
243 Franz 57
#include "scribus.h"
10212 cbradney 58
#include "scribusapp.h"
5243 cbradney 59
#include "scribuscore.h"
10212 cbradney 60
#include "scribusdoc.h"
3030 cbradney 61
#include "scribusstructs.h"
4320 cbradney 62
#include "scribuswin.h"
13503 cbradney 63
#include "sctextstream.h"
3934 cbradney 64
#include "selection.h"
15022 jghali 65
#include "sclimits.h"
10212 cbradney 66
#include "text/nlsconfig.h"
1204 tsoots 67
#include "undomanager.h"
68
#include "undostate.h"
2533 craig 69
#include "util.h"
10212 cbradney 70
#include "util_formats.h"
10203 cbradney 71
#include "util_math.h"
12277 cbradney 72
#include "util_text.h"
12795 fschmid 73
#include "util_file.h"
12004 fschmid 74
#ifdef HAVE_CAIRO
75
        #include <cairo.h>
76
#endif
2533 craig 77
 
504 cbradney 78
using namespace std;
79
 
3625 avox 80
PageItem::PageItem(const PageItem & other)
81
        : QObject(other.parent()),
10532 avox 82
         UndoObject(other), SingleObservable<PageItem>(other.m_Doc->itemsChanged()),
3625 avox 83
 
84
// 200 attributes! That is madness, or to quote some famous people from Kriquet:
85
// "THAT ALL HAS TO GO!"
86
        gXpos(other.gXpos),
87
        gYpos(other.gYpos),
88
        gWidth(other.gWidth),
89
        gHeight(other.gHeight),
90
        GrType(other.GrType),
91
        GrStartX(other.GrStartX),
92
        GrStartY(other.GrStartY),
93
        GrEndX(other.GrEndX),
94
        GrEndY(other.GrEndY),
95
        Cols(other.Cols),
96
        ColGap(other.ColGap),
3903 cbradney 97
        PLineArt(other.PLineArt),
3625 avox 98
        PLineEnd(other.PLineEnd),
99
        PLineJoin(other.PLineJoin),
100
        NamedLStyle(other.NamedLStyle),
101
        Clip(other.Clip),
102
        PoLine(other.PoLine),
103
        ContourLine(other.ContourLine),
104
        imageClip(other.imageClip),
105
        Segments(other.Segments),
106
        effectsInUse(other.effectsInUse),
107
        PoShow(other.PoShow),
108
        BaseOffs(other.BaseOffs),
7926 fschmid 109
        textPathType(other.textPathType),
110
        textPathFlipped(other.textPathFlipped),
3625 avox 111
        ClipEdited(other.ClipEdited),
112
        FrameType(other.FrameType),
113
        ItemNr(other.ItemNr),
114
        Frame(other.Frame),
115
        OwnPage(other.OwnPage),
116
        oldOwnPage(other.oldOwnPage),
3903 cbradney 117
        pixm(other.pixm),
118
        Pfile(other.Pfile),
3625 avox 119
        Pfile2(other.Pfile2),
120
        Pfile3(other.Pfile3),
121
        IProfile(other.IProfile),
122
        UseEmbedded(other.UseEmbedded),
123
        EmProfile(other.EmProfile),
124
        IRender(other.IRender),
4621 cbradney 125
 
13097 subik 126
        PictureIsAvailable(other.PictureIsAvailable),
3625 avox 127
        OrigW(other.OrigW),
128
        OrigH(other.OrigH),
3903 cbradney 129
        BBoxX(other.BBoxX),
130
        BBoxH(other.BBoxH),
3625 avox 131
        CurX(other.CurX),
132
        CurY(other.CurY),
133
        CPos(other.CPos),
134
        itemText(other.itemText),
3903 cbradney 135
        isBookmark(other.isBookmark),
136
        HasSel(other.HasSel),
8174 avox 137
//      Tinput(other.Tinput),
3625 avox 138
        isAutoText(other.isAutoText),
8047 avox 139
        BackBox(NULL),  // otherwise other.BackBox->NextBox would be inconsistent
140
        NextBox(NULL),  // otherwise other.NextBox->BackBox would be inconsistent
141
        firstChar(0),   // since this box is unlinked now
8050 avox 142
        MaxChars(0),   // since the layout is invalid now
5362 avox 143
        inPdfArticle(other.inPdfArticle),
3625 avox 144
        isRaster(other.isRaster),
145
        OldB(other.OldB),
146
        OldH(other.OldH),
147
        OldB2(other.OldB2),
148
        OldH2(other.OldH2),
149
        Sizing(other.Sizing),
150
        toPixmap(other.toPixmap),
151
        LayerNr(other.LayerNr),
152
        ScaleType(other.ScaleType),
153
        AspectRatio(other.AspectRatio),
154
        Groups(other.Groups),
155
        DashValues(other.DashValues),
156
        DashOffset(other.DashOffset),
157
        fill_gradient(other.fill_gradient),
158
        fillRule(other.fillRule),
5320 fschmid 159
        doOverprint(other.doOverprint),
3625 avox 160
        LeftLink(other.LeftLink),
161
        RightLink(other.RightLink),
162
        TopLink(other.TopLink),
163
        BottomLink(other.BottomLink),
164
        LeftLinkID(other.LeftLinkID),
165
        RightLinkID(other.RightLinkID),
166
        TopLinkID(other.TopLinkID),
167
        BottomLinkID(other.BottomLinkID),
168
        LeftLine(other.LeftLine),
169
        RightLine(other.RightLine),
170
        TopLine(other.TopLine),
171
        BottomLine(other.BottomLine),
172
        isTableItem(other.isTableItem),
173
        isSingleSel(other.isSingleSel),
6451 fschmid 174
        isGroupControl(other.isGroupControl),
175
        groupsLastItem(other.groupsLastItem),
3625 avox 176
        BoundingX(other.BoundingX),
177
        BoundingY(other.BoundingY),
178
        BoundingW(other.BoundingW),
179
        BoundingH(other.BoundingH),
180
        ChangedMasterItem(other.ChangedMasterItem),
181
        OnMasterPage(other.OnMasterPage),
182
        isEmbedded(other.isEmbedded),
183
 
184
        // protected
4061 craig 185
        undoManager(other.undoManager),
12241 fschmid 186
        m_ItemType(other.m_ItemType),
3625 avox 187
        AnName(other.AnName),
6668 cbradney 188
        patternVal(other.patternVal),
189
        patternScaleX(other.patternScaleX),
190
        patternScaleY(other.patternScaleY),
191
        patternOffsetX(other.patternOffsetX),
192
        patternOffsetY(other.patternOffsetY),
193
        patternRotation(other.patternRotation),
3625 avox 194
        fillColorVal(other.fillColorVal),
195
        lineColorVal(other.lineColorVal),
196
        lineShadeVal(other.lineShadeVal),
197
        fillShadeVal(other.fillShadeVal),
198
        fillTransparencyVal(other.fillTransparencyVal),
5746 fschmid 199
        lineTransparencyVal(other.lineTransparencyVal),
200
        fillBlendmodeVal(other.fillBlendmodeVal),
201
        lineBlendmodeVal(other.lineBlendmodeVal),
4699 cbradney 202
        m_ImageIsFlippedH(other.m_ImageIsFlippedH),
203
        m_ImageIsFlippedV(other.m_ImageIsFlippedV),
4695 cbradney 204
        m_Locked(other.m_Locked),
205
        m_SizeLocked(other.m_SizeLocked),
5620 jghali 206
        textFlowModeVal(other.textFlowModeVal),
3625 avox 207
        pageItemAttributes(other.pageItemAttributes),
4698 cbradney 208
        m_PrintEnabled(other.m_PrintEnabled),
3903 cbradney 209
        tagged(other.tagged),
210
        fillQColor(other.fillQColor),
3934 cbradney 211
        strokeQColor(other.strokeQColor),
212
        Xpos(other.Xpos),
213
        Ypos(other.Ypos),
214
        Width(other.Width),
215
        Height(other.Height),
3939 cbradney 216
        Rot(other.Rot),
3988 cbradney 217
        Select(other.Select),
4010 cbradney 218
        LocalScX(other.LocalScX),
219
        LocalScY(other.LocalScY),
220
        LocalX(other.LocalX),
221
        LocalY(other.LocalY),
4061 craig 222
        Reverse(other.Reverse),
223
        m_startArrowIndex(other.m_startArrowIndex),
224
        m_endArrowIndex(other.m_endArrowIndex),
4010 cbradney 225
        Extra(other.Extra),
226
        TExtra(other.TExtra),
227
        BExtra(other.BExtra),
228
        RExtra(other.RExtra),
12270 cbradney 229
        firstLineOffsetP(other.firstLineOffsetP),
4010 cbradney 230
        RadRect(other.RadRect),
3988 cbradney 231
        oldXpos(other.oldXpos),
232
        oldYpos(other.oldYpos),
233
        oldWidth(other.oldWidth),
4010 cbradney 234
        oldHeight(other.oldHeight),
4073 cbradney 235
        oldRot(other.oldRot),
4821 cbradney 236
        oldLocalScX(other.oldLocalScX),
237
        oldLocalScY(other.oldLocalScY),
238
        oldLocalX(other.oldLocalX),
239
        oldLocalY(other.oldLocalY),
4084 cbradney 240
        m_Doc(other.m_Doc),
241
        m_isAnnotation(other.m_isAnnotation),
4621 cbradney 242
        m_annotation(other.m_annotation),
243
        PicArt(other.PicArt),
244
        m_lineWidth(other.m_lineWidth),
5559 avox 245
        Oldm_lineWidth(other.Oldm_lineWidth)
3625 avox 246
{
7068 fschmid 247
        QString tmp;
248
        m_Doc->TotalItems++;
249
        AnName += tmp.setNum(m_Doc->TotalItems);
250
        uniqueNr = m_Doc->TotalItems;
8047 avox 251
        invalid = true;
12795 fschmid 252
        if (other.isInlineImage)
253
        {
254
                QFileInfo inlFi(Pfile);
255
                QString ext = inlFi.suffix();
256
                tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_XXXXXX." + ext);
257
                tempImageFile->open();
258
                QString fileName = getLongPathName(tempImageFile->fileName());
259
                tempImageFile->close();
260
                copyFile(Pfile, fileName);
261
                Pfile = fileName;
262
                isInlineImage = true;
263
        }
264
        else
265
        {
266
                tempImageFile = NULL;
267
                isInlineImage = false;
268
        }
3625 avox 269
}
270
 
271
 
2707 subik 272
PageItem::PageItem(ScribusDoc *pa, ItemType newType, double x, double y, double w, double h, double w2, QString fill, QString outline)
4061 craig 273
        // Initialize superclass(es)
10532 avox 274
        : QObject(pa), SingleObservable<PageItem>(pa->itemsChanged()),
4061 craig 275
        // Initialize member variables
4688 cbradney 276
        itemText(pa),
4061 craig 277
        undoManager(UndoManager::instance()),
1749 craig 278
        lineShadeVal(100),
1657 craig 279
        fillShadeVal(100),
280
        fillTransparencyVal(0.0),
281
        lineTransparencyVal(0.0),
5746 fschmid 282
        fillBlendmodeVal(0),
283
        lineBlendmodeVal(0),
4699 cbradney 284
        m_ImageIsFlippedH(0),
285
        m_ImageIsFlippedV(0),
4695 cbradney 286
        m_Locked(false),
287
        m_SizeLocked(false),
5620 jghali 288
        textFlowModeVal(TextFlowDisabled)
3 paul 289
{
10532 avox 290
        m_Doc = pa;
3 paul 291
        QString tmp;
292
        BackBox = 0;
293
        NextBox = 0;
4821 cbradney 294
        oldXpos = Xpos = x;
295
        oldYpos = Ypos = y;
296
        //CB Surely we can remove some of these?
297
        OldB2 = OldB = oldWidth = Width = w;
298
        OldH2 = OldH = oldHeight = Height = h;
456 fschmid 299
        BoundingX = x;
300
        BoundingY = y;
301
        BoundingW = w;
302
        BoundingH = h;
4593 cbradney 303
        m_ItemType = newType;
4821 cbradney 304
        oldRot = Rot = 0;
1394 cbradney 305
        fillColorVal = fill;
4593 cbradney 306
        lineColorVal = m_ItemType == PageItem::TextFrame ? fill : outline;
12726 jghali 307
        gXpos = gYpos = 0;
308
        gWidth = gHeight = 0;
3 paul 309
        GrType = 0;
292 Franz 310
        GrStartX = 0;
311
        GrStartY = 0;
294 Franz 312
        GrEndX = w;
292 Franz 313
        GrEndY = 0;
6368 fschmid 314
        patternVal = "";
6414 fschmid 315
        patternScaleX = 100;
316
        patternScaleY = 100;
317
        patternOffsetX = 0;
318
        patternOffsetY = 0;
319
        patternRotation = 0;
4580 cbradney 320
        m_lineWidth = w2;
321
        Oldm_lineWidth = w2;
8557 subik 322
        PLineArt = Qt::PenStyle(m_Doc->toolSettings.dLineArt);
8522 cbradney 323
        PLineEnd = Qt::FlatCap;
324
        PLineJoin = Qt::MiterJoin;
3 paul 325
        Select = false;
326
        ClipEdited = false;
327
        FrameType = 0;
328
        CurX = 0;
329
        CurY = 0;
330
        CPos = 0;
6225 fschmid 331
        Extra = 0;
332
        TExtra = 0;
333
        BExtra = 0;
334
        RExtra = 0;
5721 avox 335
        firstChar = 0;
387 Franz 336
        MaxChars = 0;
3 paul 337
        Pfile = "";
2004 fschmid 338
        pixm = ScImage();
4084 cbradney 339
        pixm.imgInfo.lowResType = m_Doc->toolSettings.lowResType;
3 paul 340
        Pfile2 = "";
341
        Pfile3 = "";
4821 cbradney 342
        oldLocalScX = LocalScX = 1;
343
        oldLocalScY = LocalScY = 1;
3 paul 344
        OrigW = 0;
345
        OrigH = 0;
4821 cbradney 346
        oldLocalX = LocalX = 0;
347
        oldLocalY = LocalY = 0;
3 paul 348
        BBoxX = 0;
349
        BBoxH = 0;
350
        RadRect = 0;
4593 cbradney 351
        if ((m_ItemType == TextFrame) || (m_ItemType == ImageFrame) || (m_ItemType == PathText))
1460 cbradney 352
                // TODO: Frame should become a read-only calculated property
3 paul 353
                Frame = true;
354
        else
355
                Frame = false;
4593 cbradney 356
        switch (m_ItemType)
167 Franz 357
        {
1460 cbradney 358
                case Polygon:
340 Franz 359
                        Clip.setPoints(4, static_cast<int>(w/2), 0, static_cast<int>(w), static_cast<int>(h/2),
360
                                                                static_cast<int>(w/2), static_cast<int>(h), 0,static_cast<int>(h/2));
3 paul 361
                        break;
362
                default:
340 Franz 363
                        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 364
                        break;
167 Franz 365
        }
3 paul 366
        PoLine.resize(0);
340 Franz 367
        ContourLine.resize(0);
2040 fschmid 368
        imageClip.resize(0);
3 paul 369
        Segments.clear();
370
        PoShow = false;
371
        BaseOffs = 0;
7926 fschmid 372
        textPathType = 0;
373
        textPathFlipped = false;
5087 subik 374
        OwnPage = m_Doc->currentPage()->pageNr();
1211 tsoots 375
        oldOwnPage = OwnPage;
4401 fschmid 376
        savedOwnPage = OwnPage;
3 paul 377
        PicArt = true;
13097 subik 378
        PictureIsAvailable = false;
4698 cbradney 379
        m_PrintEnabled = true;
3 paul 380
        isBookmark = false;
4102 cbradney 381
        m_isAnnotation = false;
10321 mrdocs 382
 
4593 cbradney 383
        switch (m_ItemType)
268 Franz 384
        {
1460 cbradney 385
        case ImageFrame:
10321 mrdocs 386
        case LatexFrame:
387
                //We can't determine if this is a latex frame here
388
                // because c++'s typeinfos are still saying it's 
389
                // a plain pageitem
390
                // This is fixed in the PageItem_LatexFrame constructor
268 Franz 391
                AnName = tr("Image");
1250 tsoots 392
                setUPixmap(Um::IImageFrame);
268 Franz 393
                break;
1460 cbradney 394
        case TextFrame:
268 Franz 395
                AnName = tr("Text");
1250 tsoots 396
                setUPixmap(Um::ITextFrame);
268 Franz 397
                break;
1460 cbradney 398
        case Line:
268 Franz 399
                AnName = tr("Line");
1250 tsoots 400
                setUPixmap(Um::ILine);
268 Franz 401
                break;
1460 cbradney 402
        case Polygon:
268 Franz 403
                AnName = tr("Polygon");
1250 tsoots 404
                setUPixmap(Um::IPolygon);
268 Franz 405
                break;
1460 cbradney 406
        case PolyLine:
268 Franz 407
                AnName = tr("Polyline");
1250 tsoots 408
                setUPixmap(Um::IPolyline);
268 Franz 409
                break;
1460 cbradney 410
        case PathText:
268 Franz 411
                AnName = tr("PathText");
1250 tsoots 412
                setUPixmap(Um::IPathText);
268 Franz 413
                break;
414
        default:
415
                AnName = "Item";
416
                break;
417
        }
4939 fschmid 418
        m_Doc->TotalItems++;
4084 cbradney 419
        AnName += tmp.setNum(m_Doc->TotalItems); // +" "+QDateTime::currentDateTime().toString();
7068 fschmid 420
        uniqueNr = m_Doc->TotalItems;
87 Franz 421
        AutoName = true;
1204 tsoots 422
        setUName(AnName);
4084 cbradney 423
        m_annotation.setBorderColor(outline);
3 paul 424
        HasSel = false;
8174 avox 425
//      Tinput = false;
3 paul 426
        isAutoText = false;
5362 avox 427
        inPdfArticle = false;
3 paul 428
        isRaster = false;
429
        Sizing = false;
430
        toPixmap = false;
431
        UseEmbedded = true;
5608 jghali 432
        IRender = 1;
3 paul 433
        EmProfile = "";
434
        Groups.clear();
4084 cbradney 435
        LayerNr = m_Doc->activeLayer();
3 paul 436
        ScaleType = true;
437
        AspectRatio = true;
438
        Reverse = false;
27 Franz 439
        NamedLStyle = "";
68 Franz 440
        DashValues.clear();
441
        DashOffset = 0;
1905 fschmid 442
        fillRule = true;
5320 fschmid 443
        doOverprint = false;
68 Franz 444
        fill_gradient = VGradient(VGradient::linear);
295 Franz 445
        fill_gradient.clearStops();
7478 jghali 446
        if (fillColorVal != CommonStrings::None)
447
        {
448
                const ScColor& col = m_Doc->PageColors[fillColorVal];
12642 jghali 449
                QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
450
                fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, fillColorVal, 100);
451
                fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, fillColorVal, 100);
7478 jghali 452
        }
304 Franz 453
        else
7478 jghali 454
        {
7656 fschmid 455
                if (m_Doc->toolSettings.dBrush != CommonStrings::None)
456
                {
457
                        const ScColor& col = m_Doc->PageColors[m_Doc->toolSettings.dBrush];
12642 jghali 458
                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
459
                        fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, m_Doc->toolSettings.dBrush, 100);
460
                        fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, m_Doc->toolSettings.dBrush, 100);
7656 fschmid 461
                }
462
                else
463
                {
464
                        if (lineColorVal != CommonStrings::None)
465
                        {
466
                                const ScColor& col = m_Doc->PageColors[lineColorVal];
12642 jghali 467
                                QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
468
                                fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, lineColorVal, 100);
469
                                fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, lineColorVal, 100);
7656 fschmid 470
                        }
471
                        else
472
                        {
473
                                if (m_Doc->toolSettings.dPen != CommonStrings::None)
474
                                {
475
                                        const ScColor& col = m_Doc->PageColors[m_Doc->toolSettings.dPen];
12642 jghali 476
                                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
477
                                        fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, m_Doc->toolSettings.dPen, 100);
478
                                        fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, m_Doc->toolSettings.dPen, 100);
7656 fschmid 479
                                }
12642 jghali 480
                                else if (m_Doc->PageColors.contains("Black"))
481
                                {
482
                                        const ScColor& col = m_Doc->PageColors["Black"];
483
                                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
484
                                        fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, "Black", 100);
485
                                        fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, "Black", 100);
486
                                }
7656 fschmid 487
                        }
488
                }
7478 jghali 489
        }
12270 cbradney 490
        firstLineOffsetP = FLOPRealGlyphHeight;
4084 cbradney 491
        Cols = m_Doc->toolSettings.dCols;
492
        ColGap = m_Doc->toolSettings.dGap;
232 Franz 493
        LeftLink = 0;
494
        RightLink = 0;
495
        TopLink = 0;
496
        BottomLink = 0;
234 Franz 497
        LeftLinkID = 0;
498
        RightLinkID = 0;
499
        TopLinkID = 0;
500
        BottomLinkID = 0;
232 Franz 501
        LeftLine = 0;
502
        RightLine = false;
503
        TopLine = false;
504
        BottomLine = false;
505
        isTableItem = false;
506
        isSingleSel = false;
383 Franz 507
        Dirty = false;
5362 avox 508
        invalid = true;
6451 fschmid 509
        isGroupControl = false;
510
        groupsLastItem = 0;
456 fschmid 511
        ChangedMasterItem = false;
2434 fschmid 512
        isEmbedded = false;
5685 cbradney 513
        OnMasterPage = m_Doc->currentPage()->pageName();
4084 cbradney 514
        m_startArrowIndex = m_Doc->toolSettings.dStartArrow;
515
        m_endArrowIndex = m_Doc->toolSettings.dEndArrow;
2056 fschmid 516
        effectsInUse.clear();
1659 cbradney 517
        //Page Item Attributes
518
        pageItemAttributes.clear();
4084 cbradney 519
        for(ObjAttrVector::Iterator objAttrIt = m_Doc->docItemAttributes.begin() ; objAttrIt != m_Doc->docItemAttributes.end(); ++objAttrIt )
1659 cbradney 520
        {
4593 cbradney 521
                if (((*objAttrIt).autoaddto=="textframes" && m_ItemType==TextFrame) ||
522
                        ((*objAttrIt).autoaddto=="imageframes" && m_ItemType==ImageFrame)
1659 cbradney 523
                        )
524
                        pageItemAttributes.append(*objAttrIt);
525
        }
12795 fschmid 526
        tempImageFile = NULL;
527
        isInlineImage = false;
3 paul 528
}
529
 
4644 cbradney 530
void PageItem::setXPos(const double newXPos, bool drawingOnly)
3903 cbradney 531
{
3934 cbradney 532
        Xpos = newXPos;
4644 cbradney 533
        if (drawingOnly || m_Doc->isLoading())
534
                return;
4621 cbradney 535
        checkChanges();
3934 cbradney 536
        emit position(Xpos, Ypos);
3903 cbradney 537
}
538
 
4644 cbradney 539
void PageItem::setYPos(const double newYPos, bool drawingOnly)
3903 cbradney 540
{
3934 cbradney 541
        Ypos = newYPos;
4644 cbradney 542
        if (drawingOnly || m_Doc->isLoading())
543
                return;
4621 cbradney 544
        checkChanges();
3934 cbradney 545
        emit position(Xpos, Ypos);
3903 cbradney 546
}
547
 
4644 cbradney 548
void PageItem::setXYPos(const double newXPos, const double newYPos, bool drawingOnly)
3903 cbradney 549
{
3934 cbradney 550
        Xpos = newXPos;
551
        Ypos = newYPos;
4644 cbradney 552
        if (drawingOnly || m_Doc->isLoading())
553
                return;
4621 cbradney 554
        checkChanges();
3934 cbradney 555
        emit position(Xpos, Ypos);
556
}
557
 
4644 cbradney 558
void PageItem::moveBy(const double dX, const double dY, bool drawingOnly)
3934 cbradney 559
{
560
        if (dX==0.0 && dY==0.0)
561
                return;
12820 pierre 562
        invalid = true;
3903 cbradney 563
        if (dX!=0.0)
564
                Xpos+=dX;
565
        if (dY!=0.0)
566
                Ypos+=dY;
4644 cbradney 567
        if (drawingOnly || m_Doc->isLoading())
568
                return;
4621 cbradney 569
        checkChanges();
3934 cbradney 570
        emit position(Xpos, Ypos);
3903 cbradney 571
}
572
 
3934 cbradney 573
void PageItem::setWidth(const double newWidth)
574
{
575
        Width = newWidth;
13013 fschmid 576
        updateConstants();
4621 cbradney 577
        checkChanges();
3934 cbradney 578
        emit widthAndHeight(Width, Height);
579
}
580
 
581
void PageItem::setHeight(const double newHeight)
582
{
583
        Height = newHeight;
13013 fschmid 584
        updateConstants();
4621 cbradney 585
        checkChanges();
3934 cbradney 586
        emit widthAndHeight(Width, Height);
587
}
588
 
8418 fschmid 589
void PageItem::setWidthHeight(const double newWidth, const double newHeight, bool drawingOnly)
590
{
591
        Width = newWidth;
592
        Height = newHeight;
13013 fschmid 593
        updateConstants();
8418 fschmid 594
        if (drawingOnly)
595
                return;
596
        checkChanges();
597
        emit widthAndHeight(Width, Height);
598
}
599
 
3934 cbradney 600
void PageItem::setWidthHeight(const double newWidth, const double newHeight)
601
{
602
        Width = newWidth;
603
        Height = newHeight;
13013 fschmid 604
        updateConstants();
4621 cbradney 605
        checkChanges();
3934 cbradney 606
        emit widthAndHeight(Width, Height);
607
}
608
 
609
void PageItem::resizeBy(const double dH, const double dW)
610
{
611
        if (dH==0.0 && dW==0.0)
612
                return;
613
        if (dH!=0.0)
614
                Width+=dH;
615
        if (dW!=0.0)
616
                Height+=dW;
13013 fschmid 617
        updateConstants();
4621 cbradney 618
        checkChanges();
3934 cbradney 619
        emit widthAndHeight(Width, Height);
620
}
621
 
4663 cbradney 622
void PageItem::setRotation(const double newRotation, bool drawingOnly)
3934 cbradney 623
{
624
        Rot=newRotation;
4621 cbradney 625
        checkChanges();
4663 cbradney 626
        if (drawingOnly || m_Doc->isLoading())
627
                return;
3946 cbradney 628
        emit rotation(Rot);
3934 cbradney 629
}
630
 
631
void PageItem::rotateBy(const double dR)
632
{
633
        if (dR==0.0)
634
                return;
635
        Rot+=dR;
4621 cbradney 636
        checkChanges();
3934 cbradney 637
        emit rotation(Rot);
638
}
639
 
640
void PageItem::setSelected(const bool toSelect)
641
{
642
        Select=toSelect;
643
}
644
 
3988 cbradney 645
void PageItem::setImageXScale(const double newImageXScale)
3985 cbradney 646
{
3988 cbradney 647
        LocalScX=newImageXScale;
4821 cbradney 648
        checkChanges();
4960 cbradney 649
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 650
}
651
 
652
void PageItem::setImageYScale(const double newImageYScale)
653
{
654
        LocalScY=newImageYScale;
4821 cbradney 655
        checkChanges();
4960 cbradney 656
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 657
}
658
 
659
void PageItem::setImageXYScale(const double newImageXScale, const double newImageYScale)
660
{
661
        LocalScX=newImageXScale;
662
        LocalScY=newImageYScale;
4821 cbradney 663
        checkChanges();
4960 cbradney 664
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 665
}
666
 
3988 cbradney 667
void PageItem::setImageXOffset(const double newImageXOffset)
3985 cbradney 668
{
3988 cbradney 669
        LocalX=newImageXOffset;
4821 cbradney 670
        checkChanges();
3991 cbradney 671
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 672
}
673
 
674
void PageItem::setImageYOffset(const double newImageYOffset)
675
{
676
        LocalY=newImageYOffset;
4821 cbradney 677
        checkChanges();
3991 cbradney 678
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 679
}
680
 
681
void PageItem::setImageXYOffset(const double newImageXOffset, const double newImageYOffset)
682
{
683
        LocalX=newImageXOffset;
684
        LocalY=newImageYOffset;
4821 cbradney 685
        checkChanges();
3991 cbradney 686
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 687
}
688
 
689
void PageItem::moveImageXYOffsetBy(const double dX, const double dY)
690
{
691
        if (dX==0.0 && dY==0.0)
692
                return;
693
        if (dX!=0.0)
694
                LocalX+=dX;
695
        if (dY!=0.0)
696
                LocalY+=dY;
4821 cbradney 697
        checkChanges();
3991 cbradney 698
        emit imageOffsetScale(LocalScX, LocalScY, LocalX, LocalY);
3985 cbradney 699
}
700
 
3988 cbradney 701
void PageItem::setReversed(bool newReversed)
702
{
703
        Reverse=newReversed;
704
}
3985 cbradney 705
 
5559 avox 706
 
707
/// returns true if text overflows
708
bool PageItem::frameOverflows() const
709
{
710
#ifndef NLS_PROTO
12414 jghali 711
        // Fix #6991 : "Text overflow" warning when there is a text underflow in fact
712
        /*return NextBox == NULL && itemText.length() > static_cast<int>(MaxChars);*/
12820 pierre 713
        return ( NextBox == NULL )
714
               && ( static_cast<int> ( firstChar ) < itemText.length() )
13131 jghali 715
                   // Fix #7766 : scribus.textOverflows() returns 0 if there is no place for the overflow mark
716
               /*&& ( firstChar < MaxChars )*/
717
                   && ( firstChar <= MaxChars )
12820 pierre 718
               && ( itemText.length() > static_cast<int> ( MaxChars ) );
5559 avox 719
#else
720
        return false; // FIXME:NLS
721
#endif
722
}
723
 
724
int PageItem::firstInFrame() const
725
{
5721 avox 726
        return firstChar;
5559 avox 727
}
728
int PageItem::lastInFrame() const
729
{
730
#ifndef NLS_PROTO
8562 jghali 731
        return qMin(signed(MaxChars), itemText.length()) - 1;
5559 avox 732
#else
733
        return itemText.length() - 1;
734
#endif
735
}
736
 
7994 avox 737
 
738
void PageItem::link(PageItem* nxt)
739
{
740
        assert( !nextInChain() );
741
        assert( !nxt->prevInChain() );
8075 avox 742
        for (PageItem* ff=nxt; ff; ff=ff->nextInChain())
743
        {
744
                assert (ff != this);
745
        }
13656 jghali 746
        // Append only if necessary to avoid the
747
        // charstyle: access at end of text warning
748
        if (nxt->itemText.length() > 0)
749
                itemText.append(nxt->itemText);
7994 avox 750
        NextBox = nxt;
751
        nxt->BackBox = this;
8325 avox 752
        // update AutoText
753
        if (isAutoText)
754
        {
755
                PageItem* after = nxt;
756
                while (after)
757
                {
758
                        after->isAutoText = true;
759
                        m_Doc->LastAuto = after;
760
                        after = after->NextBox;
761
                }
762
        }
763
        else if (nxt->isAutoText)
764
        {
765
                PageItem* before = this;
766
                while (before)
767
                {
768
                        before->isAutoText = true;
769
                        m_Doc->FirstAuto = before;
770
                        before = before->BackBox;
771
                }
772
        }
7994 avox 773
        invalid = true;
8325 avox 774
        while (nxt)
775
        {
9490 avox 776
                nxt->itemText = itemText;
8325 avox 777
                nxt->invalid = true;
778
                nxt->firstChar = 0;
779
                nxt = nxt->NextBox;
780
        }
7994 avox 781
}
782
 
783
void PageItem::unlink()
784
{
785
        if( NextBox )
786
        {
787
                // make sure lastInFrame is valid
788
                layout();
12246 cbradney 789
                /*
790
                //<< CB #6332: Stop the StoryText cut and break and act like other publishing apps
7994 avox 791
                // move following text to new StoryText
792
                itemText.select(lastInFrame()+1, itemText.length()-lastInFrame()-1);
12246 cbradney 793
                */
7994 avox 794
                StoryText follow(m_Doc);
12246 cbradney 795
                /*
7994 avox 796
                follow.setDefaultStyle(itemText.defaultStyle());
797
                follow.insert(0, itemText, true);
798
                // remove following text from this chain
799
                itemText.removeSelection();
12246 cbradney 800
                //>>
801
                */
8325 avox 802
                // update auto pointers
803
                if (isAutoText)
804
                {
805
                        PageItem* before = this;
806
                        while (before)
807
                        {
808
                                before->isAutoText = false;
809
                                before = before->BackBox;
810
                        }
811
                        m_Doc->FirstAuto = NextBox;
812
                }
7994 avox 813
                // link following frames to new text
814
                NextBox->firstChar = 0;
815
                NextBox->BackBox = NULL;
816
                while (NextBox) {
817
                        NextBox->itemText = follow;
818
                        NextBox->invalid = true;
8325 avox 819
                        NextBox->firstChar = 0;
7994 avox 820
                        NextBox = NextBox->NextBox;
821
                }
822
                // NextBox == NULL now
11743 jghali 823
                NextBox = NULL;
7994 avox 824
        }
825
}
826
 
8325 avox 827
 
828
void PageItem::dropLinks()
829
{
830
        // update auto pointers
831
        if (isAutoText && NextBox == 0)
832
        {
833
                m_Doc->LastAuto = BackBox;
834
        }
835
        if (isAutoText && BackBox == 0)
836
        {
837
                m_Doc->FirstAuto = NextBox;
838
        }
839
        isAutoText = false;
840
 
841
        // leave text in remaining chain
842
        PageItem* before = BackBox;
843
        PageItem* after = NextBox;
844
        if (after != 0 || before != 0)
845
        {
846
                itemText = StoryText(m_Doc);
847
                if (before)
848
                        before->NextBox = after;
849
                if (after)
850
                {
851
                        after->BackBox = before;
852
                        while (after)
853
                        {
854
                                after->invalid = true;
855
                                after->firstChar = 0;
856
                                after = after->NextBox;
857
                        }
858
                }
9403 jghali 859
                // JG we should set BackBox and NextBox to NULL at a point
11743 jghali 860
                BackBox = NextBox = NULL;
8325 avox 861
        }
862
}
863
 
5559 avox 864
/// tests if a character is displayed by this frame
865
bool PageItem::frameDisplays(int textpos) const
866
{
867
#ifndef NLS_PROTO
5673 avox 868
        return 0 <= textpos && textpos < signed(MaxChars) &&  textpos < itemText.length();
5559 avox 869
#else
870
        return true; // FIXME:NLS
871
#endif
872
}
873
 
874
 
875
/// returns the style at the current charpos
876
const ParagraphStyle& PageItem::currentStyle() const
877
{
878
        if (frameDisplays(CPos))
879
                return itemText.paragraphStyle(CPos);
880
        else
881
                return itemText.defaultStyle();
882
}
883
 
5569 avox 884
/// returns the style at the current charpos for changing
885
ParagraphStyle& PageItem::changeCurrentStyle()
886
{
887
        if (frameDisplays(CPos))
5691 avox 888
                return const_cast<ParagraphStyle&>(itemText.paragraphStyle(CPos));
5569 avox 889
        else
5691 avox 890
                return const_cast<ParagraphStyle&>(itemText.defaultStyle());
5569 avox 891
}
892
 
5559 avox 893
/// returns the style at the current charpos
894
const CharStyle& PageItem::currentCharStyle() const
895
{
896
        if (frameDisplays(CPos))
897
                return itemText.charStyle(CPos);
898
        else
899
                return itemText.defaultStyle().charStyle();
900
}
901
 
3988 cbradney 902
void PageItem::setTextToFrameDistLeft(double newLeft)
903
{
904
        Extra=newLeft;
3991 cbradney 905
        emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 906
}
3985 cbradney 907
 
3988 cbradney 908
void PageItem::setTextToFrameDistRight(double newRight)
909
{
910
        RExtra=newRight;
3991 cbradney 911
        emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 912
}
3985 cbradney 913
 
3988 cbradney 914
void PageItem::setTextToFrameDistTop(double newTop)
915
{
916
        TExtra=newTop;
3991 cbradney 917
        emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 918
}
3985 cbradney 919
 
3988 cbradney 920
void PageItem::setTextToFrameDistBottom(double newBottom)
921
{
922
        BExtra=newBottom;
3991 cbradney 923
        emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 924
}
3985 cbradney 925
 
3988 cbradney 926
void PageItem::setTextToFrameDist(double newLeft, double newRight, double newTop, double newBottom)
927
{
928
        Extra=newLeft;
929
        RExtra=newRight;
930
        TExtra=newTop;
931
        BExtra=newBottom;
3991 cbradney 932
        emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 933
}
3985 cbradney 934
 
5559 avox 935
double PageItem::gridOffset() const { return m_Doc->typographicSettings.offsetBaseGrid; }
936
double PageItem::gridDistance() const { return m_Doc->typographicSettings.valueBaseGrid; }
937
 
938
void PageItem::setGridOffset(double) { } // FIXME
939
void PageItem::setGridDistance(double) { } // FIXME
940
void PageItem::setColumns(int n)
941
{
8562 jghali 942
        Cols = qMax(1, n); //FIXME: undo
5559 avox 943
}
944
void PageItem::setColumnGap(double gap)
945
{
946
        ColGap = gap; //FIXME: undo
947
}
948
 
3989 cbradney 949
void PageItem::setCornerRadius(double newRadius)
950
{
951
        RadRect=newRadius;
952
        emit cornerRadius(RadRect);
953
}
3985 cbradney 954
 
3988 cbradney 955
 
956
 
957
 
958
 
959
 
960
 
961
 
962
 
10840 avox 963
/** Paints the item.
964
    CHANGE: cullingArea is in doc coordinates!
965
 */
11052 avox 966
void PageItem::DrawObj(ScPainter *p, QRectF cullingArea)
3 paul 967
{
13085 jghali 968
//      qDebug << "PageItem::DrawObj";
2434 fschmid 969
        double sc;
4084 cbradney 970
        if (!m_Doc->DoDrawing)
1740 cbradney 971
        {
8174 avox 972
//              Tinput = false;
1740 cbradney 973
                return;
974
        }
10945 jghali 975
        if (cullingArea.isNull())
10840 avox 976
        {
977
                cullingArea = QRectF(QPointF(m_Doc->minCanvasCoordinate.x(), m_Doc->minCanvasCoordinate.y()),
978
                                                         QPointF(m_Doc->maxCanvasCoordinate.x(), m_Doc->maxCanvasCoordinate.y())).toAlignedRect();
979
        }
980
 
2434 fschmid 981
        DrawObj_Pre(p, sc);
5619 fschmid 982
        if (m_Doc->layerOutline(LayerNr))
5572 fschmid 983
        {
7549 fschmid 984
                if ((itemType()==TextFrame || itemType()==ImageFrame || itemType()==PathText || itemType()==Line || itemType()==PolyLine) && (!isGroupControl))
10840 avox 985
                        DrawObj_Item(p, cullingArea, sc);
5572 fschmid 986
        }
987
        else
7549 fschmid 988
        {
989
                if (!isGroupControl)
10840 avox 990
                        DrawObj_Item(p, cullingArea, sc);
7549 fschmid 991
        }
2434 fschmid 992
        DrawObj_Post(p);
1736 cbradney 993
}
994
 
2434 fschmid 995
void PageItem::DrawObj_Pre(ScPainter *p, double &sc)
1740 cbradney 996
{
4320 cbradney 997
        ScribusView* view = m_Doc->view();
4593 cbradney 998
        sc = view->scale();
1741 cbradney 999
        p->save();
2434 fschmid 1000
        if (!isEmbedded)
11196 fschmid 1001
                p->translate(Xpos, Ypos);
7141 fschmid 1002
        p->rotate(Rot);
5619 fschmid 1003
        if (m_Doc->layerOutline(LayerNr))
1741 cbradney 1004
        {
8522 cbradney 1005
                p->setPen(m_Doc->layerMarker(LayerNr), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5572 fschmid 1006
                p->setFillMode(ScPainter::None);
1007
                p->setBrushOpacity(1.0);
1008
                p->setPenOpacity(1.0);
1741 cbradney 1009
        }
1010
        else
1011
        {
7549 fschmid 1012
        if (!isGroupControl)
1013
        {
5746 fschmid 1014
                if (fillBlendmode() != 0)
1015
                        p->beginLayer(1.0 - fillTransparency(), fillBlendmode());
1016
 
5572 fschmid 1017
                p->setLineWidth(m_lineWidth);
1018
                if (GrType != 0)
1741 cbradney 1019
                {
6368 fschmid 1020
                        if (GrType == 8)
5572 fschmid 1021
                        {
6368 fschmid 1022
                                if ((patternVal.isEmpty()) || (!m_Doc->docPatterns.contains(patternVal)))
1023
                                {
1024
                                        p->fill_gradient = VGradient(VGradient::linear);
1025
                                        if (fillColor() != CommonStrings::None)
1026
                                        {
1027
                                                p->setBrush(fillQColor);
1028
                                                p->setFillMode(ScPainter::Solid);
1029
                                        }
1030
                                        else
1031
                                                p->setFillMode(ScPainter::None);
12215 fschmid 1032
                                        if ((!patternVal.isEmpty()) && (!m_Doc->docPatterns.contains(patternVal)))
1033
                                        {
1034
                                                GrType = 0;
1035
                                                patternVal = "";
1036
                                        }
6368 fschmid 1037
                                }
1038
                                else
1039
                                {
6414 fschmid 1040
                                        p->setPattern(&m_Doc->docPatterns[patternVal], patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation);
6368 fschmid 1041
                                        p->setFillMode(ScPainter::Pattern);
1042
                                }
5572 fschmid 1043
                        }
6368 fschmid 1044
                        else
1045
                        {
7684 fschmid 1046
                                if (fill_gradient.Stops() < 2) // fall back to solid filling if there are not enough colorstops in the gradient.
6368 fschmid 1047
                                {
7684 fschmid 1048
                                        if (fillColor() != CommonStrings::None)
1049
                                        {
1050
                                                p->setBrush(fillQColor);
1051
                                                p->setFillMode(ScPainter::Solid);
1052
                                        }
1053
                                        else
1054
                                                p->setFillMode(ScPainter::None);
1055
                                }
1056
                                else
1057
                                {
1058
                                        p->setFillMode(ScPainter::Gradient);
1059
                                        p->fill_gradient = fill_gradient;
8501 cbradney 1060
                                        QMatrix grm;
7684 fschmid 1061
                                        grm.rotate(Rot);
1062
                                        FPointArray gra;
1063
                                        switch (GrType)
1064
                                        {
1065
                                                case 1:
1066
                                                case 2:
1067
                                                case 3:
1068
                                                case 4:
1069
                                                case 6:
1070
                                                        p->setGradient(VGradient::linear, FPoint(GrStartX, GrStartY), FPoint(GrEndX, GrEndY));
1071
                                                        break;
1072
                                                case 5:
1073
                                                case 7:
1074
                                                        gra.setPoints(2, GrStartX, GrStartY, GrEndX, GrEndY);
1075
                                                        p->setGradient(VGradient::radial, gra.point(0), gra.point(1), gra.point(0));
1076
                                                        break;
1077
                                        }
6368 fschmid 1078
                                }
1079
                        }
1741 cbradney 1080
                }
1081
                else
1082
                {
5572 fschmid 1083
                        p->fill_gradient = VGradient(VGradient::linear);
1084
                        if (fillColor() != CommonStrings::None)
1085
                        {
1086
                                p->setBrush(fillQColor);
1087
                                p->setFillMode(ScPainter::Solid);
1088
                        }
1089
                        else
1090
                                p->setFillMode(ScPainter::None);
1741 cbradney 1091
                }
5572 fschmid 1092
                if (lineColor() != CommonStrings::None)
1093
                {
13013 fschmid 1094
//                      if ((m_lineWidth == 0) && ! asLine())
1095
//                              p->setLineWidth(0);
1096
//                      else
1097
//                      {
5572 fschmid 1098
                                p->setPen(strokeQColor, m_lineWidth, PLineArt, PLineEnd, PLineJoin);
1099
                                if (DashValues.count() != 0)
1100
                                        p->setDash(DashValues, DashOffset);
13013 fschmid 1101
//                      }
5572 fschmid 1102
                }
1103
                else
1104
                        p->setLineWidth(0);
5746 fschmid 1105
                if (fillBlendmode() == 0)
1106
                        p->setBrushOpacity(1.0 - fillTransparency());
1107
                if (lineBlendmode() == 0)
1108
                        p->setPenOpacity(1.0 - lineTransparency());
7549 fschmid 1109
                p->setFillRule(fillRule);
5572 fschmid 1110
                }
7549 fschmid 1111
        }
1740 cbradney 1112
}
1113
 
2434 fschmid 1114
void PageItem::DrawObj_Post(ScPainter *p)
1740 cbradney 1115
{
1116
        bool doStroke=true;
4320 cbradney 1117
        ScribusView* view = m_Doc->view();
7549 fschmid 1118
        if (!isGroupControl)
1740 cbradney 1119
        {
7549 fschmid 1120
                if (m_Doc->layerOutline(LayerNr))
1740 cbradney 1121
                {
7549 fschmid 1122
                        if (itemType()!=Line)
5582 fschmid 1123
                        {
8522 cbradney 1124
                                p->setPen(m_Doc->layerMarker(LayerNr), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1125
                                p->setFillMode(ScPainter::None);
1126
                                p->setBrushOpacity(1.0);
1127
                                p->setPenOpacity(1.0);
1128
                                if (itemType()==PolyLine)
5582 fschmid 1129
                                        p->setupPolygon(&PoLine, false);
7549 fschmid 1130
                                else if (itemType() == PathText)
1131
                                {
1132
                                        if (PoShow)
1133
                                                p->setupPolygon(&PoLine, false);
1134
                                        else
1135
                                                doStroke = false;
1136
                                }
5582 fschmid 1137
                                else
7549 fschmid 1138
                                        p->setupPolygon(&PoLine);
1139
                                if (doStroke)
1140
                                        p->strokePath();
1141
                                if (itemType()==ImageFrame)
5584 fschmid 1142
                                {
7549 fschmid 1143
                                        if (imageClip.size() != 0)
1144
                                        {
1145
                                                p->setupPolygon(&imageClip);
1146
                                                p->strokePath();
1147
                                        }
5584 fschmid 1148
                                }
1149
                        }
1740 cbradney 1150
                }
7549 fschmid 1151
                else
1152
                {
1153
                        if (fillBlendmode() != 0)
1154
                                p->endLayer();
1155
                        if (itemType()==PathText || itemType()==PolyLine || itemType()==Line)
1156
                                doStroke=false;
1157
                        if ((doStroke) && (!m_Doc->RePos))
1158
                        {
1159
                                if (lineBlendmode() != 0)
1160
                                        p->beginLayer(1.0 - lineTransparency(), lineBlendmode());
13013 fschmid 1161
//                              if (lineColor() != CommonStrings::None)
1162
//                              {
1163
//                                      p->setPen(strokeQColor, m_lineWidth, PLineArt, PLineEnd, PLineJoin);
1164
//                                      if (DashValues.count() != 0)
1165
//                                              p->setDash(DashValues, DashOffset);
1166
//                              }
1167
//                              else
1168
//                                      p->setLineWidth(0);
7549 fschmid 1169
                                if (!isTableItem)
1740 cbradney 1170
                                {
12697 fschmid 1171
                                        if ((itemType() == LatexFrame) || (itemType() == ImageFrame))
11682 fschmid 1172
                                                p->setupPolygon(&PoLine);
7549 fschmid 1173
                                        if (NamedLStyle.isEmpty())
13013 fschmid 1174
                                        {
1175
                                                if (lineColor() != CommonStrings::None)
1176
                                                {
1177
                                                        p->setPen(strokeQColor, m_lineWidth, PLineArt, PLineEnd, PLineJoin);
1178
                                                        if (DashValues.count() != 0)
1179
                                                                p->setDash(DashValues, DashOffset);
1180
                                                        p->strokePath();
1181
                                                }
1182
                                        }
7549 fschmid 1183
                                        else
5572 fschmid 1184
                                        {
7549 fschmid 1185
                                                multiLine ml = m_Doc->MLineStyles[NamedLStyle];
1186
                                                QColor tmp;
1187
                                                for (int it = ml.size()-1; it > -1; it--)
6568 fschmid 1188
                                                {
7549 fschmid 1189
                                                        struct SingleLine& sl = ml[it];
8557 subik 1190
                                                        // Qt4 if ((!sl.Color != CommonStrings::None) && (sl.Width != 0))
13013 fschmid 1191
                                                        if (sl.Color != CommonStrings::None) // && (sl.Width != 0))
7549 fschmid 1192
                                                        {
11333 jghali 1193
                                                                SetQColor(&tmp, sl.Color, sl.Shade);
8501 cbradney 1194
                                                                p->setPen(tmp, sl.Width, static_cast<Qt::PenStyle>(sl.Dash), static_cast<Qt::PenCapStyle>(sl.LineEnd), static_cast<Qt::PenJoinStyle>(sl.LineJoin));
7549 fschmid 1195
                                                                p->strokePath();
1196
                                                        }
6568 fschmid 1197
                                                }
5572 fschmid 1198
                                        }
1740 cbradney 1199
                                }
7549 fschmid 1200
                                if (lineBlendmode() != 0)
1201
                                        p->endLayer();
1202
                        }
5746 fschmid 1203
                }
1740 cbradney 1204
        }
4084 cbradney 1205
        if ((!isEmbedded) && (!m_Doc->RePos))
2434 fschmid 1206
        {
12513 pierre 1207
                double aestheticFactor(5.0);
1208
                double scpInv = 1.0 / (qMax(view->scale(), 1.0) * aestheticFactor);
7549 fschmid 1209
                if (!isGroupControl)
1740 cbradney 1210
                {
12697 fschmid 1211
                        if ((Frame) && (m_Doc->guidesSettings.framesShown) && ((itemType() == ImageFrame) || (itemType() == LatexFrame) || (itemType() == PathText)))
3919 fschmid 1212
                        {
12453 pierre 1213
                                p->setPen(PrefsManager::instance()->appPrefs.DFrameNormColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1214
                                if ((isBookmark) || (m_isAnnotation))
12453 pierre 1215
                                        p->setPen(PrefsManager::instance()->appPrefs.DFrameAnnotationColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1216
                                if ((BackBox != 0) || (NextBox != 0))
8522 cbradney 1217
                                        p->setPen(PrefsManager::instance()->appPrefs.DFrameLinkColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1218
                                if (m_Locked)
8522 cbradney 1219
                                        p->setPen(PrefsManager::instance()->appPrefs.DFrameLockColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1220
                                p->setFillMode(0);
1221
                                if (itemType()==PathText)
3919 fschmid 1222
                                {
7549 fschmid 1223
                                        if (Clip.count() != 0)
3919 fschmid 1224
                                        {
7549 fschmid 1225
                                                FPointArray tclip;
1226
                                                FPoint np = FPoint(Clip.point(0));
1227
                                                tclip.resize(2);
1228
                                                tclip.setPoint(0, np);
1229
                                                tclip.setPoint(1, np);
8557 subik 1230
                                                for (int a = 1; a < Clip.size(); ++a)
7549 fschmid 1231
                                                {
1232
                                                        np = FPoint(Clip.point(a));
1233
                                                        tclip.putPoints(tclip.size(), 4, np.x(), np.y(), np.x(), np.y(), np.x(), np.y(), np.x(), np.y());
1234
                                                }
1235
                                                np = FPoint(Clip.point(0));
1236
                                                tclip.putPoints(tclip.size(), 2, np.x(), np.y(), np.x(), np.y());
1237
                                                p->setupPolygon(&tclip);
3919 fschmid 1238
                                        }
1239
                                }
12004 fschmid 1240
                                else
12769 cbradney 1241
// Ugly Hack to fix rendering problems with cairo >=1.5.10 && <1.8.0 follows
12004 fschmid 1242
#ifdef HAVE_CAIRO
12769 cbradney 1243
        #if ((CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 5, 10)) && (CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 8, 0)))
12004 fschmid 1244
                                        p->setupPolygon(&PoLine, false);
1245
        #else
7549 fschmid 1246
                                        p->setupPolygon(&PoLine);
12004 fschmid 1247
        #endif
1248
#else
1249
                                        p->setupPolygon(&PoLine);
1250
#endif
7549 fschmid 1251
                                p->strokePath();
3919 fschmid 1252
                        }
1740 cbradney 1253
                }
8494 fschmid 1254
                if ((m_Doc->guidesSettings.framesShown) && textFlowUsesContourLine() && (ContourLine.size() != 0))
1255
                {
14957 fschmid 1256
                        p->setPen(Qt::darkGray, 1.0 / qMax(view->scale(), 1.0), Qt::DotLine, Qt::FlatCap, Qt::MiterJoin);
12769 cbradney 1257
// Ugly Hack to fix rendering problems with cairo >=1.5.10 && <1.8.0 follows
12004 fschmid 1258
#ifdef HAVE_CAIRO
12768 cbradney 1259
        #if ((CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 5, 10)) && (CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 8, 0)))
12004 fschmid 1260
                        p->setupPolygon(&ContourLine, false);
1261
        #else
8494 fschmid 1262
                        p->setupPolygon(&ContourLine);
12004 fschmid 1263
        #endif
1264
#else
1265
                        p->setupPolygon(&ContourLine);
1266
#endif
8494 fschmid 1267
                        p->strokePath();
1268
                }
11170 jghali 1269
                if ((m_Doc->guidesSettings.layerMarkersShown) && (m_Doc->layerCount() > 1) && (!m_Doc->layerOutline(LayerNr)) && ((isGroupControl) || (Groups.count() == 0)) && (!view->m_canvas->isPreviewMode()))
1740 cbradney 1270
                {
8522 cbradney 1271
                        p->setPen(Qt::black, 0.5/ m_Doc->view()->scale(), Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5619 fschmid 1272
                        p->setPenOpacity(1.0);
1273
                        p->setBrush(m_Doc->layerMarker(LayerNr));
1274
                        p->setBrushOpacity(1.0);
5572 fschmid 1275
                        p->setFillMode(ScPainter::Solid);
5584 fschmid 1276
                        double ofwh = 10;
1277
                        double ofx = Width - ofwh/2;
1278
                        double ofy = Height - ofwh*3;
1279
                        p->drawRect(ofx, ofy, ofwh, ofwh);
5572 fschmid 1280
                }
4145 cbradney 1281
                //CB disabled for now
4847 cbradney 1282
                //if (m_Doc->m_Selection->findItem(this)!=-1)
4145 cbradney 1283
                //      drawLockedMarker(p);
2434 fschmid 1284
        }
8174 avox 1285
//      Tinput = false;
8180 fschmid 1286
        FrameOnly = false;
2434 fschmid 1287
        p->restore();
1740 cbradney 1288
}
1289
 
11052 avox 1290
void PageItem::DrawObj_Embedded(ScPainter *p, QRectF cullingArea, const CharStyle& style, PageItem* cembedded)
2434 fschmid 1291
{
8174 avox 1292
        if (!cembedded)
1293
                return;
1294
        if (!m_Doc->DoDrawing)
1295
                return;
9856 fschmid 1296
        QList<PageItem*> emG;
9922 fschmid 1297
        QStack<PageItem*> groupStack;
12299 fschmid 1298
        groupStack.clear();
2955 fschmid 1299
        emG.clear();
8174 avox 1300
        emG.append(cembedded);
1301
        if (cembedded->Groups.count() != 0)
2434 fschmid 1302
        {
9856 fschmid 1303
                for (int ga=0; ga<m_Doc->FrameItems.count(); ++ga)
2453 fschmid 1304
                {
8174 avox 1305
                        if (m_Doc->FrameItems.at(ga)->Groups.count() != 0)
2955 fschmid 1306
                        {
8174 avox 1307
                                if (m_Doc->FrameItems.at(ga)->Groups.top() == cembedded->Groups.top())
2955 fschmid 1308
                                {
8174 avox 1309
                                        if (m_Doc->FrameItems.at(ga)->ItemNr != cembedded->ItemNr)
2955 fschmid 1310
                                        {
9856 fschmid 1311
                                                if (!emG.contains(m_Doc->FrameItems.at(ga)))
8174 avox 1312
                                                        emG.append(m_Doc->FrameItems.at(ga));
2955 fschmid 1313
                                        }
1314
                                }
1315
                        }
2443 fschmid 1316
                }
8174 avox 1317
        }
9856 fschmid 1318
        for (int em = 0; em < emG.count(); ++em)
8174 avox 1319
        {
1320
                PageItem* embedded = emG.at(em);
8212 fschmid 1321
                if (embedded->isGroupControl)
1322
                {
1323
                        p->save();
1324
                        FPointArray cl = embedded->PoLine.copy();
8501 cbradney 1325
                        QMatrix mm;
12299 fschmid 1326
                        mm.translate((embedded->gXpos * (style.scaleH() / 1000.0)), ( - (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos * (style.scaleV() / 1000.0)));
1327
                        if (style.baselineOffset() != 0)
1328
                                mm.translate(0, -embedded->gHeight * (style.baselineOffset() / 1000.0));
1329
                        mm.scale(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
12317 fschmid 1330
                        mm.rotate(embedded->rotation());
8212 fschmid 1331
                        cl.map( mm );
1332
                        p->beginLayer(1.0 - embedded->fillTransparency(), embedded->fillBlendmode(), &cl);
1333
                        groupStack.push(embedded->groupsLastItem);
1334
                        continue;
1335
                }
12299 fschmid 1336
                p->save();
1337
                double x = embedded->xPos();
1338
                double y = embedded->yPos();
1339
                embedded->Xpos = embedded->gXpos;
1340
                embedded->Ypos = (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos;
1341
                p->translate((embedded->gXpos * (style.scaleH() / 1000.0)), ( - (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos * (style.scaleV() / 1000.0)));
1342
                if (style.baselineOffset() != 0)
1343
                {
1344
                        p->translate(0, -embedded->gHeight * (style.baselineOffset() / 1000.0));
1345
                        embedded->Ypos -= embedded->gHeight * (style.baselineOffset() / 1000.0);
1346
                }
1347
                p->scale(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
8174 avox 1348
                embedded->Dirty = Dirty;
12309 fschmid 1349
                embedded->invalid = true;
8174 avox 1350
                double sc;
1351
                double pws = embedded->m_lineWidth;
1352
                embedded->DrawObj_Pre(p, sc);
1353
                switch(embedded->itemType())
1354
                {
1355
                        case ImageFrame:
1356
                        case TextFrame:
10321 mrdocs 1357
                        case LatexFrame:
8174 avox 1358
                        case Polygon:
1359
                        case PathText:
10840 avox 1360
                                embedded->DrawObj_Item(p, cullingArea, sc);
8174 avox 1361
                                break;
1362
                        case Line:
1363
                        case PolyLine:
8562 jghali 1364
                                embedded->m_lineWidth = pws * qMin(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
10840 avox 1365
                                embedded->DrawObj_Item(p, cullingArea, sc);
8174 avox 1366
                                break;
1367
                        default:
1368
                                break;
1369
                }
8562 jghali 1370
                embedded->m_lineWidth = pws * qMin(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
8174 avox 1371
                embedded->DrawObj_Post(p);
12299 fschmid 1372
                embedded->Xpos = x;
1373
                embedded->Ypos = y;
8174 avox 1374
                p->restore();
8212 fschmid 1375
                if (groupStack.count() != 0)
1376
                {
1377
                        while (embedded == groupStack.top())
1378
                        {
1379
                                p->endLayer();
1380
                                p->restore();
1381
                                groupStack.pop();
9827 fschmid 1382
                                if (groupStack.count() == 0)
1383
                                        break;
8212 fschmid 1384
                        }
1385
                }
8174 avox 1386
                embedded->m_lineWidth = pws;
2434 fschmid 1387
        }
12297 fschmid 1388
        for (int em = 0; em < emG.count(); ++em)
1389
        {
1390
                PageItem* embedded = emG.at(em);
12299 fschmid 1391
                if (!embedded->isTableItem)
1392
                        continue;
12297 fschmid 1393
                p->save();
12299 fschmid 1394
                double x = embedded->xPos();
1395
                double y = embedded->yPos();
1396
                embedded->Xpos = embedded->gXpos;
1397
                embedded->Ypos = (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos;
12297 fschmid 1398
                p->translate((embedded->gXpos * (style.scaleH() / 1000.0)), ( - (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos * (style.scaleV() / 1000.0)));
1399
                if (style.baselineOffset() != 0)
1400
                {
1401
                        p->translate(0, -embedded->gHeight * (style.baselineOffset() / 1000.0));
1402
                        embedded->Ypos -= embedded->gHeight * (style.baselineOffset() / 1000.0);
1403
                }
1404
                p->scale(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
1405
                p->rotate(embedded->rotation());
1406
                double pws = embedded->m_lineWidth;
1407
                embedded->m_lineWidth = pws * qMin(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
1408
                if ((embedded->lineColor() != CommonStrings::None) && (embedded->lineWidth() != 0.0))
1409
                {
1410
                        QColor tmp;
1411
                        embedded->SetQColor(&tmp, embedded->lineColor(), embedded->lineShade());
1412
                        if ((embedded->TopLine) || (embedded->RightLine) || (embedded->BottomLine) || (embedded->LeftLine))
1413
                        {
1414
                                p->setPen(tmp, embedded->lineWidth(), embedded->PLineArt, Qt::SquareCap, embedded->PLineJoin);
1415
                                if (embedded->TopLine)
1416
                                        p->drawLine(FPoint(0.0, 0.0), FPoint(embedded->width(), 0.0));
1417
                                if (embedded->RightLine)
1418
                                        p->drawLine(FPoint(embedded->width(), 0.0), FPoint(embedded->width(), embedded->height()));
1419
                                if (embedded->BottomLine)
1420
                                        p->drawLine(FPoint(embedded->width(), embedded->height()), FPoint(0.0, embedded->height()));
1421
                                if (embedded->LeftLine)
1422
                                        p->drawLine(FPoint(0.0, embedded->height()), FPoint(0.0, 0.0));
1423
                        }
1424
                }
1425
                embedded->m_lineWidth = pws;
12299 fschmid 1426
                embedded->Xpos = x;
1427
                embedded->Ypos = y;
12297 fschmid 1428
                p->restore();
1429
        }
2434 fschmid 1430
}
1431
 
8174 avox 1432
 
9343 fschmid 1433
void PageItem::paintObj(QPainter *p)
68 Franz 1434
{
9343 fschmid 1435
        if ((!m_Doc->DoDrawing) || (m_Doc->RePos))
167 Franz 1436
        {
8180 fschmid 1437
                FrameOnly = false;
68 Franz 1438
                return;
167 Franz 1439
        }
9343 fschmid 1440
        double sc = m_Doc->view()->scale();
9720 fschmid 1441
        double handleSize = 6.0 / sc;
1442
        double halfSize = 3.0 / sc;
8179 fschmid 1443
        if ((!FrameOnly) && (!m_Doc->RePos))
167 Franz 1444
        {
9343 fschmid 1445
                if (!m_Doc->m_Selection->isEmpty())
167 Franz 1446
                {
11645 fschmid 1447
//                              qDebug() << "Item: " << ItemNr << "W: " << Width << "H: " << Height;
9343 fschmid 1448
                        if (Groups.count() == 0)
3 paul 1449
                        {
9705 cbradney 1450
                                //Locked line colour selection
9343 fschmid 1451
                                if (m_Locked)
9349 fschmid 1452
                                        p->setPen(QPen(PrefsManager::instance()->appPrefs.DFrameLockColor, 1.0 / sc, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
9343 fschmid 1453
                                else
12453 pierre 1454
                                        p->setPen(QPen(PrefsManager::instance()->appPrefs.DFrameColor, 1.0 / sc, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
9343 fschmid 1455
                                p->setBrush(Qt::NoBrush);
9349 fschmid 1456
                                double lw2 = 1.0 / sc;
1457
                                double lw = 1.0 / sc;
9343 fschmid 1458
                                Qt::PenCapStyle le = Qt::FlatCap;
1459
                                if (NamedLStyle.isEmpty())
3 paul 1460
                                {
9349 fschmid 1461
                                        lw2 = (m_lineWidth / 2.0)  / sc;
1462
                                        lw = qMax(m_lineWidth, 1.0)  / sc;
9343 fschmid 1463
                                        le = PLineEnd;
1464
                                }
1465
                                else
1466
                                {
1467
                                        multiLine ml = m_Doc->MLineStyles[NamedLStyle];
9349 fschmid 1468
                                        lw2 = (ml[ml.size()-1].Width / 2.0) / sc;
1469
                                        lw = qMax(ml[ml.size()-1].Width, 1.0) / sc;
9343 fschmid 1470
                                        le = static_cast<Qt::PenCapStyle>(ml[ml.size()-1].LineEnd);
1471
                                }
9705 cbradney 1472
                                //Draw our frame outline
9343 fschmid 1473
                                if (asLine())
1474
                                {
1475
                                        if (le != Qt::FlatCap)
9349 fschmid 1476
                                                p->drawRect(QRectF(-lw2, -lw2, Width+lw, lw));
3 paul 1477
                                        else
9349 fschmid 1478
                                                p->drawRect(QRectF(-1 / sc, -lw2, Width, lw));
167 Franz 1479
                                }
3 paul 1480
                                else
9720 fschmid 1481
                                        p->drawRect(QRectF(0, 0, Width, Height));
1482
//                              p->setPen(QPen(PrefsManager::instance()->appPrefs.DFrameColor, 1.0 / sc, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
9343 fschmid 1483
                                p->setBrush(PrefsManager::instance()->appPrefs.DFrameColor);
9720 fschmid 1484
                                p->setPen(Qt::NoPen);
9343 fschmid 1485
                                if ((!m_Locked) && (!m_SizeLocked))
167 Franz 1486
                                {
9343 fschmid 1487
                                        if (! asLine())
227 Franz 1488
                                        {
9720 fschmid 1489
                                                p->drawRect(QRectF(0.0, 0.0, handleSize, handleSize));
1490
                                                p->drawRect(QRectF(Width - handleSize, Height - handleSize, handleSize, handleSize));
1491
                                                p->drawRect(QRectF(Width - handleSize, 0.0, handleSize, handleSize));
1492
                                                p->drawRect(QRectF(0.0, Height - handleSize, handleSize, handleSize));
227 Franz 1493
                                                if (Width > 6)
1494
                                                {
9720 fschmid 1495
                                                        p->drawRect(QRectF(Width / 2.0 - halfSize, Height - handleSize, handleSize, handleSize));
1496
                                                        p->drawRect(QRectF(Width / 2.0 - halfSize, 0.0, handleSize, handleSize));
227 Franz 1497
                                                }
1498
                                                if (Height > 6)
1499
                                                {
9720 fschmid 1500
                                                        p->drawRect(QRectF(Width - handleSize, Height / 2.0 - halfSize, handleSize, handleSize));
1501
                                                        p->drawRect(QRectF(0.0, Height / 2.0 - halfSize, handleSize, handleSize));
227 Franz 1502
                                                }
1503
                                        }
9343 fschmid 1504
                                        else
1505
                                        {
9720 fschmid 1506
                                                p->drawRect(QRectF(-halfSize, -halfSize, handleSize, handleSize));
1507
                                                p->drawRect(QRectF(Width + halfSize, -halfSize, -handleSize, handleSize));
9343 fschmid 1508
                                        }
3 paul 1509
                                }
1510
                        }
9343 fschmid 1511
                        else
1512
                        {
12453 pierre 1513
                                p->setPen(QPen(PrefsManager::instance()->appPrefs.DFrameGroupColor, 1.0 / sc, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
9343 fschmid 1514
                                p->setBrush(Qt::NoBrush);
9720 fschmid 1515
                                p->drawRect(QRectF(0.0, 0.0, Width, Height));
9343 fschmid 1516
                                if (m_Doc->m_Selection->count() == 1)
1517
                                {
9720 fschmid 1518
                                        p->setPen(Qt::NoPen);
1519
//                                      p->setPen(QPen(PrefsManager::instance()->appPrefs.DFrameGroupColor, 1.0 / sc, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
9343 fschmid 1520
                                        p->setBrush(PrefsManager::instance()->appPrefs.DFrameGroupColor);
9720 fschmid 1521
                                        p->drawRect(QRectF(0.0, 0.0, handleSize, handleSize));
1522
                                        p->drawRect(QRectF(Width - handleSize, Height - handleSize, handleSize, handleSize));
1523
                                        p->drawRect(QRectF(Width - handleSize, 0.0, handleSize, handleSize));
1524
                                        p->drawRect(QRectF(0.0, Height - handleSize, handleSize, handleSize));
9343 fschmid 1525
                                        if (Width > 6)
1526
                                        {
9720 fschmid 1527
                                                p->drawRect(QRectF(Width / 2.0 - halfSize, Height - handleSize, handleSize, handleSize));
1528
                                                p->drawRect(QRectF(Width / 2.0 - halfSize, 0.0, handleSize, handleSize));
9343 fschmid 1529
                                        }
1530
                                        if (Height > 6)
1531
                                        {
9720 fschmid 1532
                                                p->drawRect(QRectF(Width - handleSize, Height / 2.0 - halfSize, handleSize, handleSize));
1533
                                                p->drawRect(QRectF(0.0, Height / 2.0 - halfSize, handleSize, handleSize));
9343 fschmid 1534
                                        }
1535
                                }
1536
                        }
3 paul 1537
                }
167 Franz 1538
        }
8179 fschmid 1539
        FrameOnly = false;
3 paul 1540
}
1541
 
6368 fschmid 1542
QImage PageItem::DrawObj_toImage()
1543
{
9856 fschmid 1544
        QList<PageItem*> emG;
6368 fschmid 1545
        emG.clear();
15075 jghali 1546
        double minx =  std::numeric_limits<double>::max();
1547
        double miny =  std::numeric_limits<double>::max();
1548
        double maxx = -std::numeric_limits<double>::max();
1549
        double maxy = -std::numeric_limits<double>::max();
6368 fschmid 1550
        if (Groups.count() != 0)
1551
        {
9856 fschmid 1552
                for (int ga=0; ga<m_Doc->Items->count(); ++ga)
6368 fschmid 1553
                {
1554
                        if (m_Doc->Items->at(ga)->Groups.count() != 0)
1555
                        {
1556
                                if (m_Doc->Items->at(ga)->Groups.top() == Groups.top())
1557
                                {
9856 fschmid 1558
                                        if (!emG.contains(m_Doc->Items->at(ga)))
6368 fschmid 1559
                                        {
1560
                                                emG.append(m_Doc->Items->at(ga));
1561
                                                PageItem *currItem = m_Doc->Items->at(ga);
11878 fschmid 1562
                                                double x1, x2, y1, y2;
12467 pierre 1563
                                                currItem->getVisualBoundingRect(&x1, &y1, &x2, &y2);
11878 fschmid 1564
                                                minx = qMin(minx, x1);
1565
                                                miny = qMin(miny, y1);
1566
                                                maxx = qMax(maxx, x2);
1567
                                                maxy = qMax(maxy, y2);
6368 fschmid 1568
                                        }
1569
                                }
1570
                        }
1571
                }
9856 fschmid 1572
                for (int em = 0; em < emG.count(); ++em)
6368 fschmid 1573
                {
1574
                        PageItem* currItem = emG.at(em);
12750 fschmid 1575
                        currItem->gXpos = currItem->xPos() - minx;
1576
                        currItem->gYpos = currItem->yPos() - miny;
6368 fschmid 1577
                        currItem->gWidth = maxx - minx;
1578
                        currItem->gHeight = maxy - miny;
1579
                }
1580
        }
1581
        else
1582
        {
11878 fschmid 1583
                double x1, x2, y1, y2;
12467 pierre 1584
                getVisualBoundingRect(&x1, &y1, &x2, &y2);
11878 fschmid 1585
                minx = qMin(minx, x1);
1586
                miny = qMin(miny, y1);
1587
                maxx = qMax(maxx, x2);
1588
                maxy = qMax(maxy, y2);
6368 fschmid 1589
                gXpos = xPos() - minx;
1590
                gYpos = yPos() - miny;
1591
                gWidth = maxx - minx;
1592
                gHeight = maxy - miny;
1593
                emG.append(this);
1594
        }
6602 fschmid 1595
        return DrawObj_toImage(emG);
1596
}
1597
 
9856 fschmid 1598
QImage PageItem::DrawObj_toImage(QList<PageItem*> &emG)
6602 fschmid 1599
{
13048 jghali 1600
        QImage retImg = QImage(qRound(gWidth), qRound(gHeight), QImage::Format_ARGB32);
11383 fschmid 1601
//      retImg.fill( qRgba(255, 255, 255, 0) );
1602
        retImg.fill( qRgba(0, 0, 0, 0) );
8557 subik 1603
        ScPainter *painter = new ScPainter(&retImg, retImg.width(), retImg.height(), 1, 0);
13942 fschmid 1604
//      painter->setZoomFactor(1.0);
1605
        painter->setZoomFactor(qMax(qRound(gWidth) / gWidth, qRound(gHeight) / gHeight));
9922 fschmid 1606
        QStack<PageItem*> groupStack;
9903 fschmid 1607
        for (int em = 0; em < emG.count(); ++em)
6368 fschmid 1608
        {
1609
                PageItem* embedded = emG.at(em);
6501 fschmid 1610
                if (embedded->isGroupControl)
1611
                {
11287 fschmid 1612
                        painter->save();
7049 fschmid 1613
                        FPointArray cl = embedded->PoLine.copy();
8501 cbradney 1614
                        QMatrix mm;
7049 fschmid 1615
                        mm.translate(embedded->gXpos, embedded->gYpos);
1616
                        mm.rotate(embedded->rotation());
1617
                        cl.map( mm );
1618
                        painter->beginLayer(1.0 - embedded->fillTransparency(), embedded->fillBlendmode(), &cl);
6501 fschmid 1619
                        groupStack.push(embedded->groupsLastItem);
1620
                        continue;
1621
                }
6368 fschmid 1622
                painter->save();
13034 pierre 1623
//              qDebug()<<embedded<<embedded->xPos()<<embedded->yPos()<<embedded->gXpos<<embedded->gYpos;
1624
//              double x = embedded->xPos();
1625
//              double y = embedded->yPos();
1626
//              embedded->Xpos = embedded->gXpos;
1627
//              embedded->Ypos = embedded->gYpos;
1628
                // Seems to work without all this coordinates mess. To monitor tho
6368 fschmid 1629
                painter->translate(embedded->gXpos, embedded->gYpos);
1630
                embedded->isEmbedded = true;
6420 fschmid 1631
                embedded->invalid = true;
11052 avox 1632
                embedded->DrawObj(painter, QRectF());
13034 pierre 1633
//              embedded->Xpos = x;
1634
//              embedded->Ypos = y;
6368 fschmid 1635
                embedded->isEmbedded = false;
1636
                painter->restore();
6501 fschmid 1637
                if (groupStack.count() != 0)
1638
                {
1639
                        while (embedded == groupStack.top())
1640
                        {
7049 fschmid 1641
                                painter->endLayer();
6501 fschmid 1642
                                painter->restore();
1643
                                groupStack.pop();
9827 fschmid 1644
                                if (groupStack.count() == 0)
1645
                                        break;
6501 fschmid 1646
                        }
1647
                }
6368 fschmid 1648
        }
12297 fschmid 1649
        for (int em = 0; em < emG.count(); ++em)
1650
        {
1651
                PageItem* embedded = emG.at(em);
1652
                if (!embedded->isTableItem)
1653
                        continue;
1654
                painter->save();
13034 pierre 1655
//              double x = embedded->xPos();
1656
//              double y = embedded->yPos();
1657
//              embedded->Xpos = embedded->gXpos;
1658
//              embedded->Ypos = embedded->gYpos;
12297 fschmid 1659
                painter->translate(embedded->gXpos, embedded->gYpos);
1660
                painter->rotate(embedded->rotation());
1661
                embedded->isEmbedded = true;
1662
                embedded->invalid = true;
1663
                if ((embedded->lineColor() != CommonStrings::None) && (embedded->lineWidth() != 0.0))
1664
                {
1665
                        QColor tmp;
1666
                        embedded->SetQColor(&tmp, embedded->lineColor(), embedded->lineShade());
1667
                        if ((embedded->TopLine) || (embedded->RightLine) || (embedded->BottomLine) || (embedded->LeftLine))
1668
                        {
1669
                                painter->setPen(tmp, embedded->lineWidth(), embedded->PLineArt, Qt::SquareCap, embedded->PLineJoin);
1670
                                if (embedded->TopLine)
1671
                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(embedded->width(), 0.0));
1672
                                if (embedded->RightLine)
1673
                                        painter->drawLine(FPoint(embedded->width(), 0.0), FPoint(embedded->width(), embedded->height()));
1674
                                if (embedded->BottomLine)
1675
                                        painter->drawLine(FPoint(embedded->width(), embedded->height()), FPoint(0.0, embedded->height()));
1676
                                if (embedded->LeftLine)
1677
                                        painter->drawLine(FPoint(0.0, embedded->height()), FPoint(0.0, 0.0));
1678
                        }
1679
                }
1680
                embedded->isEmbedded = false;
13034 pierre 1681
//              embedded->Xpos = x;
1682
//              embedded->Ypos = y;
12297 fschmid 1683
                painter->restore();
1684
        }
6368 fschmid 1685
        painter->end();
1686
        delete painter;
1687
        return retImg;
1688
}
1689
 
3 paul 1690
QString PageItem::ExpandToken(uint base)
1691
{
1692
        uint zae = 0;
6144 avox 1693
        QChar ch = itemText.text(base);
1694
        QString chstr = ch;
11713 fschmid 1695
        if (ch == SpecialChars::PAGENUMBER)
1696
        {
6144 avox 1697
                // compatibility mode: ignore subsequent pagenumber chars
11713 fschmid 1698
                if (base > 0 && itemText.text(base-1) == SpecialChars::PAGENUMBER)
6144 avox 1699
                        return "";
1700
                if ((!m_Doc->masterPageMode()) && (OwnPage != -1))
362 Franz 1701
                {
6144 avox 1702
                        QString out("%1");
1703
                        //CB Section numbering
1704
                        chstr = out.arg(m_Doc->getSectionPageNumberForPageIndex(OwnPage), -(int)zae);
167 Franz 1705
                }
11713 fschmid 1706
                else
6144 avox 1707
                        return "#";
167 Franz 1708
        }
11713 fschmid 1709
        else if (ch == SpecialChars::PAGECOUNT)
1710
        {
1711
                if (!m_Doc->masterPageMode())
1712
                {
1713
                        QString out("%1");
1714
                        int key = m_Doc->getSectionKeyForPageIndex(OwnPage);
1715
                        if (key == -1)
1716
                                return "%";
1717
                        chstr = out.arg(getStringFromSequence(m_Doc->sections[key].type, m_Doc->sections[key].toindex - m_Doc->sections[key].fromindex + 1));
1718
                }
1719
                else
1720
                        return "%";
1721
        }
5721 avox 1722
        return chstr;
3 paul 1723
}
1724
 
11333 jghali 1725
void PageItem::SetQColor(QColor *tmp, QString farbe, double shad)
3 paul 1726
{
7478 jghali 1727
        const ScColor& col = m_Doc->PageColors[farbe];
1728
        *tmp = ScColorEngine::getShadeColorProof(col, m_Doc, shad);
10532 avox 1729
        if ((m_Doc->view()) && (m_Doc->view()->m_canvas->usePreviewVisual()))
6549 fschmid 1730
        {
11336 jghali 1731
                VisionDefectColor defect;
1732
                *tmp = defect.convertDefect(*tmp, m_Doc->view()->m_canvas->previewVisual());
6549 fschmid 1733
        }
3 paul 1734
}
1735
 
6144 avox 1736
/**
1737
    layout glyphs translates the chars into a number of glyphs, applying the Charstyle
1738
    'style'. The following fields are set in layout: glyph, more, scaleH, scaleV, xoffset, yoffset, xadvance.
1739
    If the DropCap-bit in style.effects is set and yadvance is > 0, scaleH/V, x/yoffset and xadvance
1740
    are modified to scale the glyphs to this height.
1741
    Otherwise yadvance is set to the max ascender of all generated glyphs.
1742
    It scales according to smallcaps and
1743
    sets xadvance to the advance width without kerning. If more than one glyph
1744
    is generated, kerning is included in all but the last xadvance.
1745
*/
11744 jghali 1746
double PageItem::layoutGlyphs(const CharStyle& style, const QString& chars, GlyphLayout& layout)
3 paul 1747
{
157 Franz 1748
        double retval = 0.0;
5980 avox 1749
        double asce = style.font().ascent(style.fontSize() / 10.0);
5691 avox 1750
        int chst = style.effects() & 1919;
9042 avox 1751
/*      if (chars[0] == SpecialChars::ZWSPACE ||
6933 avox 1752
                chars[0] == SpecialChars::ZWNBSPACE ||
1753
                chars[0] == SpecialChars::NBSPACE ||
6144 avox 1754
                chars[0] == SpecialChars::NBHYPHEN ||
6933 avox 1755
                chars[0] == SpecialChars::SHYPHEN ||
6144 avox 1756
                chars[0] == SpecialChars::PARSEP ||
1757
                chars[0] == SpecialChars::COLBREAK ||
1758
                chars[0] == SpecialChars::LINEBREAK ||
1759
                chars[0] == SpecialChars::FRAMEBREAK ||
1760
                chars[0] == SpecialChars::TAB)
1761
        {
1762
                layout.glyph = ScFace::CONTROL_GLYPHS + chars[0].unicode();
1763
        }
9042 avox 1764
        else */
8096 avox 1765
        {
6144 avox 1766
                layout.glyph = style.font().char2CMap(chars[0].unicode());
1767
        }
8098 avox 1768
 
1769
        double tracking = 0.0;
1770
        if ( (style.effects() & ScStyle_StartOfLine) == 0)
8100 avox 1771
                tracking = style.fontSize() * style.tracking() / 10000.0;
8098 avox 1772
 
1773
        layout.xoffset = tracking;
6144 avox 1774
        layout.yoffset = 0;
5315 avox 1775
        if (chst != ScStyle_Default)
167 Franz 1776
        {
5315 avox 1777
                if (chst & ScStyle_Superscript)
3 paul 1778
                {
6375 avox 1779
                        retval -= asce * m_Doc->typographicSettings.valueSuperScript / 100.0;
1780
                        layout.yoffset -= asce * m_Doc->typographicSettings.valueSuperScript / 100.0;
8562 jghali 1781
                        layout.scaleV = layout.scaleH = qMax(m_Doc->typographicSettings.scalingSuperScript / 100.0, 10.0 / style.fontSize());
167 Franz 1782
                }
5980 avox 1783
                else if (chst & ScStyle_Subscript)
167 Franz 1784
                {
6375 avox 1785
                        retval += asce * m_Doc->typographicSettings.valueSubScript / 100.0;
1786
                        layout.yoffset += asce * m_Doc->typographicSettings.valueSubScript / 100.0;
8562 jghali 1787
                        layout.scaleV = layout.scaleH = qMax(m_Doc->typographicSettings.scalingSubScript / 100.0, 10.0 / style.fontSize());
167 Franz 1788
                }
5980 avox 1789
                else {
6375 avox 1790
                        layout.scaleV = layout.scaleH = 1.0;
5980 avox 1791
                }
1792
                layout.scaleH *= style.scaleH() / 1000.0;
1793
                layout.scaleV *= style.scaleV() / 1000.0;
5315 avox 1794
                if (chst & ScStyle_AllCaps)
2185 fschmid 1795
                {
10398 cbradney 1796
                        layout.glyph = style.font().char2CMap(chars[0].toUpper().unicode());
2185 fschmid 1797
                }
5315 avox 1798
                if (chst & ScStyle_SmallCaps)
167 Franz 1799
                {
5980 avox 1800
                        double smallcapsScale = m_Doc->typographicSettings.valueSmallCaps / 100.0;
10398 cbradney 1801
                        QChar uc = chars[0].toUpper();
6144 avox 1802
                        if (uc != chars[0])
3 paul 1803
                        {
10398 cbradney 1804
                                layout.glyph = style.font().char2CMap(chars[0].toUpper().unicode());
5980 avox 1805
                                layout.scaleV *= smallcapsScale;
1806
                                layout.scaleH *= smallcapsScale;
3 paul 1807
                        }
1808
                }
167 Franz 1809
        }
5980 avox 1810
        else {
1811
                layout.scaleH = style.scaleH() / 1000.0;
1812
                layout.scaleV = style.scaleV() / 1000.0;
6997 avox 1813
        }      
1814
 
9042 avox 1815
/*      if (layout.glyph == (ScFace::CONTROL_GLYPHS + SpecialChars::NBSPACE.unicode())) {
6997 avox 1816
                uint replGlyph = style.font().char2CMap(QChar(' '));
1817
                layout.xadvance = style.font().glyphWidth(replGlyph, style.fontSize() / 10) * layout.scaleH;
1818
                layout.yadvance = style.font().glyphBBox(replGlyph, style.fontSize() / 10).ascent * layout.scaleV;
5980 avox 1819
        }
6997 avox 1820
        else if (layout.glyph == (ScFace::CONTROL_GLYPHS + SpecialChars::NBHYPHEN.unicode())) {
1821
                uint replGlyph = style.font().char2CMap(QChar('-'));
1822
                layout.xadvance = style.font().glyphWidth(replGlyph, style.fontSize() / 10) * layout.scaleH;
1823
                layout.yadvance = style.font().glyphBBox(replGlyph, style.fontSize() / 10).ascent * layout.scaleV;
1824
        }
1825
        else if (layout.glyph >= ScFace::CONTROL_GLYPHS) {
1826
                layout.xadvance = 0;
1827
                layout.yadvance = 0;
1828
        }
9042 avox 1829
        else */
1830
        {
6997 avox 1831
                layout.xadvance = style.font().glyphWidth(layout.glyph, style.fontSize() / 10) * layout.scaleH;
1832
                layout.yadvance = style.font().glyphBBox(layout.glyph, style.fontSize() / 10).ascent * layout.scaleV;
1833
        }
7030 avox 1834
        if (layout.xadvance > 0)
8098 avox 1835
                layout.xadvance += tracking;
7030 avox 1836
 
6144 avox 1837
        if (chars.length() > 1) {
1838
                layout.grow();
1839
                layoutGlyphs(style, chars.mid(1), *layout.more);
6354 avox 1840
                layout.xadvance += style.font().glyphKerning(layout.glyph, layout.more->glyph, style.fontSize() / 10) * layout.scaleH;
6144 avox 1841
                if (layout.more->yadvance > layout.yadvance)
1842
                        layout.yadvance = layout.more->yadvance;
1843
        }
1844
        else {
1845
                layout.shrink();
1846
        }
157 Franz 1847
        return retval;
3 paul 1848
}
1849
 
5980 avox 1850
void PageItem::drawGlyphs(ScPainter *p, const CharStyle& style, GlyphLayout& glyphs)
3 paul 1851
{
6144 avox 1852
        uint glyph = glyphs.glyph;
6997 avox 1853
        if ((m_Doc->guidesSettings.showControls) &&
1854
                (glyph == style.font().char2CMap(QChar(' ')) || glyph >=  ScFace::CONTROL_GLYPHS))
2353 fschmid 1855
        {
6997 avox 1856
                bool stroke = false;
1857
                if (glyph >=  ScFace::CONTROL_GLYPHS)
1858
                        glyph -= ScFace::CONTROL_GLYPHS;
1859
                else
1860
                        glyph = 32;
8501 cbradney 1861
                QMatrix chma, chma4, chma5;
2353 fschmid 1862
                FPointArray points;
6997 avox 1863
                if (glyph == SpecialChars::TAB.unicode())
2389 fschmid 1864
                {
4084 cbradney 1865
                        points = m_Doc->symTab.copy();
7356 avox 1866
                        chma4.translate(glyphs.xoffset + glyphs.xadvance - ((style.fontSize() / 10.0) * glyphs.scaleH * 0.7), glyphs.yoffset - ((style.fontSize() / 10.0) * glyphs.scaleV * 0.5));
2389 fschmid 1867
                }
6997 avox 1868
                else if (glyph == SpecialChars::COLBREAK.unicode())
2389 fschmid 1869
                {
4084 cbradney 1870
                        points = m_Doc->symNewCol.copy();
5980 avox 1871
                        chma4.translate(glyphs.xoffset, glyphs.yoffset-((style.fontSize() / 10.0) * glyphs.scaleV * 0.6));
2389 fschmid 1872
                }
6997 avox 1873
                else if (glyph == SpecialChars::FRAMEBREAK.unicode())
2389 fschmid 1874
                {
4084 cbradney 1875
                        points = m_Doc->symNewFrame.copy();
5980 avox 1876
                        chma4.translate(glyphs.xoffset, glyphs.yoffset-((style.fontSize() / 10.0) * glyphs.scaleV * 0.6));
2389 fschmid 1877
                }
6997 avox 1878
                else if (glyph == SpecialChars::PARSEP.unicode())
6144 avox 1879
                {
1880
                        points = m_Doc->symReturn.copy();
1881
                        chma4.translate(glyphs.xoffset, glyphs.yoffset-((style.fontSize() / 10.0) * glyphs.scaleV * 0.8));
1882
                }
6997 avox 1883
                else if (glyph == SpecialChars::LINEBREAK.unicode())
6144 avox 1884
                {
1885
                        points = m_Doc->symNewLine.copy();
1886
                        chma4.translate(glyphs.xoffset, glyphs.yoffset-((style.fontSize() / 10.0) * glyphs.scaleV * 0.4));
1887
                }
6997 avox 1888
                else if (glyph == SpecialChars::NBSPACE.unicode() ||
1889
                                 glyph == 32)
2389 fschmid 1890
                {
6997 avox 1891
                        stroke = (glyph == 32);
4084 cbradney 1892
                        points = m_Doc->symNonBreak.copy();
5980 avox 1893
                        chma4.translate(glyphs.xoffset, glyphs.yoffset-((style.fontSize() / 10.0) * glyphs.scaleV * 0.4));
2389 fschmid 1894
                }
6997 avox 1895
                else if (glyph == SpecialChars::NBHYPHEN.unicode())
1896
                {
7016 avox 1897
                        points = style.font().glyphOutline(style.font().char2CMap(QChar('-')), style.fontSize() / 100);
1898
                        chma4.translate(glyphs.xoffset, glyphs.yoffset-((style.fontSize() / 10.0) * glyphs.scaleV));
6997 avox 1899
                }
1900
                else if (glyph == SpecialChars::SHYPHEN.unicode())
1901
                {
1902
                        points.resize(0);
1903
                        points.addQuadPoint(0, -10, 0, -10, 0, -6, 0, -6);
1904
                        stroke = true;
1905
                }
1906
                else // ???
1907
                {
1908
                        points.resize(0);
1909
                        points.addQuadPoint(0, -10, 0, -10, 0, -9, 0, -9);                     
1910
                        points.addQuadPoint(0, -9, 0, -9, 1, -9, 1, -9);                       
1911
                        points.addQuadPoint(1, -9, 1, -9, 1, -10, 1, -10);                     
1912
                        points.addQuadPoint(1, -10, 1, -10, 0, -10, 0, -10);                   
1913
                }
5980 avox 1914
                chma.scale(glyphs.scaleH * style.fontSize() / 100.0, glyphs.scaleV * style.fontSize() / 100.0);
7141 fschmid 1915
                points.map(chma * chma4);
9319 fschmid 1916
                p->setupPolygon(&points, true);
6144 avox 1917
                QColor oldBrush = p->brush();
8096 avox 1918
                p->setBrush( (style.effects() & ScStyle_SuppressSpace) ? Qt::green
1919
                                        : PrefsManager::instance()->appPrefs.DControlCharColor);
6997 avox 1920
                if (stroke)
2359 fschmid 1921
                {
1922
                        QColor tmp = p->pen();
8522 cbradney 1923
                        p->setPen(p->brush(), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5980 avox 1924
                        p->setLineWidth(style.fontSize() * glyphs.scaleV / 200.0);
2359 fschmid 1925
                        p->strokePath();
8522 cbradney 1926
                        p->setPen(tmp, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
2359 fschmid 1927
                }
1928
                else
1929
                {
1930
                        p->setFillMode(1);
1931
                        p->fillPath();
1932
                }
6144 avox 1933
                p->setBrush(oldBrush);
7141 fschmid 1934
                if (glyphs.more)
1935
                {
1936
                        p->translate(glyphs.xadvance, 0);
6997 avox 1937
                        drawGlyphs(p, style, *glyphs.more);
1938
                }                      
6144 avox 1939
                return;
2353 fschmid 1940
        }
8096 avox 1941
        else if (glyph == (ScFace::CONTROL_GLYPHS + SpecialChars::NBSPACE.unicode()) ||
1942
                         glyph == (ScFace::CONTROL_GLYPHS + 32))
1943
                glyph = style.font().char2CMap(QChar(' '));
6933 avox 1944
        else if (glyph == (ScFace::CONTROL_GLYPHS + SpecialChars::NBHYPHEN.unicode()))
6144 avox 1945
                glyph = style.font().char2CMap(QChar('-'));
1946
 
12426 jghali 1947
        if (glyph >= ScFace::CONTROL_GLYPHS || (style.effects() & ScStyle_SuppressSpace)) {
13085 jghali 1948
//              qDebug("drawGlyphs: skipping %d", glyph);
6997 avox 1949
                // all those are empty
7141 fschmid 1950
                if (glyphs.more)
1951
                {
1952
                        p->translate(glyphs.xadvance, 0);
6997 avox 1953
                        drawGlyphs(p, style, *glyphs.more);
1954
                }                      
167 Franz 1955
                return;
6997 avox 1956
        }
6144 avox 1957
//      if (style.font().canRender(QChar(glyph)))
167 Franz 1958
        {
6144 avox 1959
                FPointArray gly = style.font().glyphOutline(glyph);
5408 avox 1960
                // Do underlining first so you can get typographically correct
1961
                // underlines when drawing a white outline
12428 cbradney 1962
                if (((style.effects() & ScStyle_Underline) || ((style.effects() & ScStyle_UnderlineWords) && glyph != style.font().char2CMap(QChar(' ')))) && (style.strokeColor() != CommonStrings::None))
5408 avox 1963
                {
1964
                        double st, lw;
6704 fschmid 1965
                        if ((style.underlineOffset() != -1) || (style.underlineWidth() != -1))
5408 avox 1966
                        {
6704 fschmid 1967
                                if (style.underlineOffset() != -1)
1968
                                        st = (style.underlineOffset() / 1000.0) * (style.font().descent(style.fontSize() / 10.0));
5408 avox 1969
                                else
5980 avox 1970
                                        st = style.font().underlinePos(style.fontSize() / 10.0);
1971
                                if (style.underlineWidth() != -1)
1972
                                        lw = (style.underlineWidth() / 1000.0) * (style.fontSize() / 10.0);
5408 avox 1973
                                else
8557 subik 1974
                                        lw = qMax(style.font().strokeWidth(style.fontSize() / 10.0), 1.0);
5408 avox 1975
                        }
1976
                        else
1977
                        {
5980 avox 1978
                                st = style.font().underlinePos(style.fontSize() / 10.0);
8557 subik 1979
                                lw = qMax(style.font().strokeWidth(style.fontSize() / 10.0), 1.0);
5408 avox 1980
                        }
5980 avox 1981
                        if (style.baselineOffset() != 0)
1982
                                st += (style.fontSize() / 10.0) * glyphs.scaleV * (style.baselineOffset() / 1000.0);
6689 fschmid 1983
                        QColor tmpC = p->pen();
5408 avox 1984
                        p->setPen(p->brush());
1985
                        p->setLineWidth(lw);
12625 fschmid 1986
                        if (style.effects() & ScStyle_Subscript)
8118 fschmid 1987
                                p->drawLine(FPoint(glyphs.xoffset, glyphs.yoffset - st), FPoint(glyphs.xoffset + glyphs.xadvance, glyphs.yoffset - st));
1988
                        else
1989
                                p->drawLine(FPoint(glyphs.xoffset, -st), FPoint(glyphs.xoffset + glyphs.xadvance, -st));
6689 fschmid 1990
                        p->setPen(tmpC);
5408 avox 1991
                }
87 Franz 1992
                if (gly.size() > 3)
167 Franz 1993
                {
8075 avox 1994
                        if (glyph == 0)
1995
                        {
13085 jghali 1996
//                              qDebug() << QString("glyph 0: (%1,%2) * %3 %4 + %5").arg(glyphs.xoffset).arg(glyphs.yoffset).arg(glyphs.scaleH).arg(glyphs.scaleV).arg(glyphs.xadvance));
8075 avox 1997
                        }
7148 fschmid 1998
                        p->save();
1999
                        p->translate(glyphs.xoffset, glyphs.yoffset - ((style.fontSize() / 10.0) * glyphs.scaleV));
68 Franz 2000
                        if (Reverse)
167 Franz 2001
                        {
7148 fschmid 2002
                                p->scale(-1, 1);
2003
                                p->translate(-glyphs.xadvance, 0);
2004
                        }
2005
                        if (style.baselineOffset() != 0)
2006
                                p->translate(0, -(style.fontSize() / 10.0) * (style.baselineOffset() / 1000.0));
2007
                        double glxSc = glyphs.scaleH * style.fontSize() / 100.00;
2008
                        double glySc = glyphs.scaleV * style.fontSize() / 100.0;
2009
                        p->scale(glxSc, glySc);
11684 fschmid 2010
//                      p->setFillMode(1);
1888 fschmid 2011
                        bool fr = p->fillRule();
2012
                        p->setFillRule(false);
7994 avox 2013
//                      double  a = gly.point(0).x();
2014
//                      double  b = gly.point(0).y();
2015
//                      double  c = gly.point(3).x();
2016
//                      double  d = gly.point(3).y();
13085 jghali 2017
//                      qDebug() << QString("drawglyphs: %1 (%2,%3) (%4,%5) scaled %6,%7 trans %8,%9")
7994 avox 2018
//                                 .arg(gly.size()).arg(a).arg(b).arg(c).arg(d)
13085 jghali 2019
//                                 .arg(p->worldMatrix().m11()).arg(p->worldMatrix().m22()).arg(p->worldMatrix().dx()).arg(p->worldMatrix().dy());
9319 fschmid 2020
                        p->setupPolygon(&gly, true);
5619 fschmid 2021
                        if (m_Doc->layerOutline(LayerNr))
5582 fschmid 2022
                        {
2023
                                p->save();
8522 cbradney 2024
                                p->setPen(m_Doc->layerMarker(LayerNr), 0.5, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5582 fschmid 2025
                                p->setFillMode(ScPainter::None);
2026
                                p->setBrushOpacity(1.0);
2027
                                p->setPenOpacity(1.0);
2028
                                p->strokePath();
2029
                                p->restore();
2030
                                p->setFillRule(fr);
7148 fschmid 2031
                                p->restore();