Subversion Repositories Scribus

Rev

Rev 19323 | Rev 19397 | 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"
16503 craig 25
 
10220 cbradney 26
#include <QPainter>
27
#include <QPen>
28
#include <QFont>
29
#include <QRegion>
30
#include <QPoint>
16856 craig 31
#include <QPointF>
10220 cbradney 32
#include <QFileInfo>
3 paul 33
#include <qdrawutil.h>
10220 cbradney 34
#include <QRegExp>
19266 jghali 35
#include <QRegularExpression>
10220 cbradney 36
#include <QMessageBox>
10284 fschmid 37
#include <QPolygon>
2104 cbradney 38
#include <cassert>
17826 craig 39
#include <sstream>
11645 fschmid 40
#include <QDebug>
4772 cbradney 41
 
19067 craig 42
#include "appmodes.h"
10532 avox 43
#include "canvas.h"
10601 mrdocs 44
#include "cmsettings.h"
10212 cbradney 45
#include "colorblind.h"
46
#include "commonstrings.h"
17826 craig 47
#include "desaxe/saxXML.h"
48
#include "marks.h"
18794 jghali 49
#include "pageitem_arc.h"
17092 jghali 50
#include "pageitem_group.h"
19067 craig 51
#include "pageitem_latexframe.h"
18794 jghali 52
#include "pageitem_noteframe.h"
17709 craig 53
#include "pageitem_regularpolygon.h"
17735 craig 54
#include "pageitem_spiral.h"
18794 jghali 55
#include "pageitem_table.h"
19067 craig 56
#include "pageitem_textframe.h"
10212 cbradney 57
#include "prefsmanager.h"
58
#include "resourcecollection.h"
13497 jghali 59
#include "scclocale.h"
10212 cbradney 60
#include "sccolorengine.h"
14539 jghali 61
#include "scimagecacheproxy.h"
16736 jghali 62
#include "sclimits.h"
63
#include "scpage.h"
4772 cbradney 64
#include "scpainter.h"
10212 cbradney 65
#include "scpaths.h"
66
#include "scpattern.h"
67
#include "scribusapp.h"
5243 cbradney 68
#include "scribuscore.h"
10212 cbradney 69
#include "scribusdoc.h"
19093 craig 70
#include "scribusview.h"
4320 cbradney 71
#include "scribuswin.h"
13503 cbradney 72
#include "sctextstream.h"
3934 cbradney 73
#include "selection.h"
16159 fschmid 74
#include "text/storytext.h"
19093 craig 75
#include "ui/guidemanager.h"
76
#include "ui/propertiespalette.h"
1204 tsoots 77
#include "undomanager.h"
78
#include "undostate.h"
19297 jghali 79
#include "units.h"
2533 craig 80
#include "util.h"
16736 jghali 81
#include "util_file.h"
10212 cbradney 82
#include "util_formats.h"
16736 jghali 83
#include "util_icon.h"
10203 cbradney 84
#include "util_math.h"
12277 cbradney 85
#include "util_text.h"
2533 craig 86
 
19067 craig 87
 
16281 jghali 88
#include <cairo.h>
89
 
504 cbradney 90
using namespace std;
91
 
3625 avox 92
PageItem::PageItem(const PageItem & other)
93
        : QObject(other.parent()),
10532 avox 94
         UndoObject(other), SingleObservable<PageItem>(other.m_Doc->itemsChanged()),
3625 avox 95
 
96
// 200 attributes! That is madness, or to quote some famous people from Kriquet:
97
// "THAT ALL HAS TO GO!"
98
        gXpos(other.gXpos),
99
        gYpos(other.gYpos),
100
        gWidth(other.gWidth),
101
        gHeight(other.gHeight),
102
        GrType(other.GrType),
103
        GrStartX(other.GrStartX),
104
        GrStartY(other.GrStartY),
105
        GrEndX(other.GrEndX),
106
        GrEndY(other.GrEndY),
14278 fschmid 107
        GrFocalX(other.GrFocalX),
108
        GrFocalY(other.GrFocalY),
109
        GrScale(other.GrScale),
14284 fschmid 110
        GrSkew(other.GrSkew),
14952 fschmid 111
        GrControl1(other.GrControl1),
112
        GrControl2(other.GrControl2),
113
        GrControl3(other.GrControl3),
114
        GrControl4(other.GrControl4),
14981 fschmid 115
        GrControl5(other.GrControl5),
14952 fschmid 116
        GrColorP1(other.GrColorP1),
117
        GrColorP2(other.GrColorP2),
118
        GrColorP3(other.GrColorP3),
119
        GrColorP4(other.GrColorP4),
120
        GrCol1transp(other.GrCol1transp),
121
        GrCol2transp(other.GrCol2transp),
122
        GrCol3transp(other.GrCol3transp),
123
        GrCol4transp(other.GrCol4transp),
124
        GrCol1Shade(other.GrCol1Shade),
125
        GrCol2Shade(other.GrCol2Shade),
126
        GrCol3Shade(other.GrCol3Shade),
127
        GrCol4Shade(other.GrCol4Shade),
16729 fschmid 128
        meshGradientPatches(other.meshGradientPatches),
15024 fschmid 129
        meshGradientArray(other.meshGradientArray),
15517 fschmid 130
        selectedMeshPointX(other.selectedMeshPointX),
131
        selectedMeshPointY(other.selectedMeshPointY),
132
        selectedMeshControlPoint(other.selectedMeshControlPoint),
16891 fschmid 133
        snapToPatchGrid(other.snapToPatchGrid),
3625 avox 134
        Cols(other.Cols),
135
        ColGap(other.ColGap),
18204 fschmid 136
        m_startArrowIndex(other.m_startArrowIndex),
137
        m_endArrowIndex(other.m_endArrowIndex),
138
        m_startArrowScale(other.m_startArrowScale),
139
        m_endArrowScale(other.m_endArrowScale),
3903 cbradney 140
        PLineArt(other.PLineArt),
3625 avox 141
        PLineEnd(other.PLineEnd),
142
        PLineJoin(other.PLineJoin),
143
        NamedLStyle(other.NamedLStyle),
144
        Clip(other.Clip),
145
        PoLine(other.PoLine),
146
        ContourLine(other.ContourLine),
147
        imageClip(other.imageClip),
148
        Segments(other.Segments),
149
        effectsInUse(other.effectsInUse),
150
        PoShow(other.PoShow),
151
        BaseOffs(other.BaseOffs),
7926 fschmid 152
        textPathType(other.textPathType),
153
        textPathFlipped(other.textPathFlipped),
3625 avox 154
        ClipEdited(other.ClipEdited),
155
        FrameType(other.FrameType),
156
        OwnPage(other.OwnPage),
157
        oldOwnPage(other.oldOwnPage),
3903 cbradney 158
        pixm(other.pixm),
159
        Pfile(other.Pfile),
3625 avox 160
        Pfile2(other.Pfile2),
161
        Pfile3(other.Pfile3),
162
        IProfile(other.IProfile),
163
        UseEmbedded(other.UseEmbedded),
164
        EmProfile(other.EmProfile),
165
        IRender(other.IRender),
14444 fschmid 166
        OverrideCompressionMethod(other.OverrideCompressionMethod),
167
        CompressionMethodIndex(other.CompressionMethodIndex),
168
        OverrideCompressionQuality(other.OverrideCompressionQuality),
169
        CompressionQualityIndex(other.CompressionQualityIndex),
4621 cbradney 170
 
13097 subik 171
        PictureIsAvailable(other.PictureIsAvailable),
3625 avox 172
        OrigW(other.OrigW),
173
        OrigH(other.OrigH),
3903 cbradney 174
        BBoxX(other.BBoxX),
175
        BBoxH(other.BBoxH),
3625 avox 176
        CurX(other.CurX),
177
        CurY(other.CurY),
178
        itemText(other.itemText),
18987 avox 179
        textLayout(&itemText, this),
3903 cbradney 180
        isBookmark(other.isBookmark),
181
        HasSel(other.HasSel),
3625 avox 182
        isAutoText(other.isAutoText),
5362 avox 183
        inPdfArticle(other.inPdfArticle),
3625 avox 184
        isRaster(other.isRaster),
185
        OldB(other.OldB),
186
        OldH(other.OldH),
187
        OldB2(other.OldB2),
188
        OldH2(other.OldH2),
189
        Sizing(other.Sizing),
13875 jghali 190
        LayerID(other.LayerID),
3625 avox 191
        ScaleType(other.ScaleType),
192
        AspectRatio(other.AspectRatio),
193
        DashValues(other.DashValues),
194
        DashOffset(other.DashOffset),
195
        fill_gradient(other.fill_gradient),
196
        fillRule(other.fillRule),
5320 fschmid 197
        doOverprint(other.doOverprint),
18772 fschmid 198
        m_hasSoftShadow(other.m_hasSoftShadow),
199
        m_softShadowColor(other.m_softShadowColor),
200
        m_softShadowShade(other.m_softShadowShade),
201
        m_softShadowBlurRadius(other.m_softShadowBlurRadius),
202
        m_softShadowXOffset(other.m_softShadowXOffset),
203
        m_softShadowYOffset(other.m_softShadowYOffset),
204
        m_softShadowOpacity(other.m_softShadowOpacity),
205
        m_softShadowBlendMode(other.m_softShadowBlendMode),
3625 avox 206
        LeftLink(other.LeftLink),
207
        RightLink(other.RightLink),
208
        TopLink(other.TopLink),
209
        BottomLink(other.BottomLink),
210
        LeftLinkID(other.LeftLinkID),
211
        RightLinkID(other.RightLinkID),
212
        TopLinkID(other.TopLinkID),
213
        BottomLinkID(other.BottomLinkID),
214
        LeftLine(other.LeftLine),
215
        RightLine(other.RightLine),
216
        TopLine(other.TopLine),
217
        BottomLine(other.BottomLine),
218
        isTableItem(other.isTableItem),
219
        isSingleSel(other.isSingleSel),
16105 fschmid 220
        groupItemList(other.groupItemList),
221
        groupWidth(other.groupWidth),
222
        groupHeight(other.groupHeight),
3625 avox 223
        BoundingX(other.BoundingX),
224
        BoundingY(other.BoundingY),
225
        BoundingW(other.BoundingW),
226
        BoundingH(other.BoundingH),
227
        ChangedMasterItem(other.ChangedMasterItem),
228
        OnMasterPage(other.OnMasterPage),
229
        isEmbedded(other.isEmbedded),
18022 craig 230
        m_roundedCorderRadius(other.m_roundedCorderRadius),
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),
14168 fschmid 245
        Oldm_lineWidth(other.Oldm_lineWidth),
246
        patternStrokeVal(other.patternStrokeVal),
247
        patternStrokeScaleX(other.patternStrokeScaleX),
248
        patternStrokeScaleY(other.patternStrokeScaleY),
249
        patternStrokeOffsetX(other.patternStrokeOffsetX),
250
        patternStrokeOffsetY(other.patternStrokeOffsetY),
251
        patternStrokeRotation(other.patternStrokeRotation),
14260 fschmid 252
        patternStrokeSkewX(other.patternStrokeSkewX),
253
        patternStrokeSkewY(other.patternStrokeSkewY),
14403 fschmid 254
        patternStrokeSpace(other.patternStrokeSpace),
14276 fschmid 255
        patternStrokeMirrorX(other.patternStrokeMirrorX),
256
        patternStrokeMirrorY(other.patternStrokeMirrorY),
14398 fschmid 257
        patternStrokePath(other.patternStrokePath),
14168 fschmid 258
        gradientStrokeVal(other.gradientStrokeVal),
14213 fschmid 259
        stroke_gradient(other.stroke_gradient),
14168 fschmid 260
        GrTypeStroke(other.GrTypeStroke),
261
        GrStrokeStartX(other.GrStrokeStartX),
262
        GrStrokeStartY(other.GrStrokeStartY),
263
        GrStrokeEndX(other.GrStrokeEndX),
14278 fschmid 264
        GrStrokeEndY(other.GrStrokeEndY),
265
        GrStrokeFocalX(other.GrStrokeFocalX),
266
        GrStrokeFocalY(other.GrStrokeFocalY),
14284 fschmid 267
        GrStrokeScale(other.GrStrokeScale),
14297 fschmid 268
        GrStrokeSkew(other.GrStrokeSkew),
269
        GrMask(other.GrMask),
270
        GrMaskStartX(other.GrMaskStartX),
271
        GrMaskStartY(other.GrMaskStartY),
272
        GrMaskEndX(other.GrMaskEndX),
273
        GrMaskEndY(other.GrMaskEndY),
274
        GrMaskFocalX(other.GrMaskFocalX),
275
        GrMaskFocalY(other.GrMaskFocalY),
276
        GrMaskScale(other.GrMaskScale),
277
        GrMaskSkew(other.GrMaskSkew),
278
        patternMaskScaleX(other.patternMaskScaleX),
279
        patternMaskScaleY(other.patternMaskScaleY),
280
        patternMaskOffsetX(other.patternMaskOffsetX),
281
        patternMaskOffsetY(other.patternMaskOffsetY),
282
        patternMaskRotation(other.patternMaskRotation),
283
        patternMaskSkewX(other.patternMaskSkewX),
284
        patternMaskSkewY(other.patternMaskSkewY),
285
        patternMaskMirrorX(other.patternMaskMirrorX),
286
        patternMaskMirrorY(other.patternMaskMirrorY),
287
        patternMaskVal(other.patternMaskVal),
18204 fschmid 288
        mask_gradient(other.mask_gradient),
18935 fschmid 289
        hatchAngle(other.hatchAngle),
290
        hatchDistance(other.hatchDistance),
291
        hatchType(other.hatchType),
292
        hatchUseBackground(other.hatchUseBackground),
293
        hatchBackground(other.hatchBackground),
294
        hatchForeground(other.hatchForeground),
18204 fschmid 295
        // protected
296
        undoManager(other.undoManager),
297
        BackBox(NULL),  // otherwise other.BackBox->NextBox would be inconsistent
298
        NextBox(NULL),  // otherwise other.NextBox->BackBox would be inconsistent
299
        firstChar(0),   // since this box is unlinked now
300
        MaxChars(0),   // since the layout is invalid now
301
        m_sampleItem(false),
302
        m_textDistanceMargins(other.m_textDistanceMargins),
18889 fschmid 303
        verticalAlign(other.verticalAlign),
18204 fschmid 304
        m_ItemType(other.m_ItemType),
305
        AnName(other.AnName),
306
        gradientVal(other.gradientVal),
307
        patternVal(other.patternVal),
308
        patternScaleX(other.patternScaleX),
309
        patternScaleY(other.patternScaleY),
310
        patternOffsetX(other.patternOffsetX),
311
        patternOffsetY(other.patternOffsetY),
312
        patternRotation(other.patternRotation),
313
        patternSkewX(other.patternSkewX),
314
        patternSkewY(other.patternSkewY),
315
        patternMirrorX(other.patternMirrorX),
316
        patternMirrorY(other.patternMirrorY),
317
        fillColorVal(other.fillColorVal),
318
        lineColorVal(other.lineColorVal),
319
        lineShadeVal(other.lineShadeVal),
320
        fillShadeVal(other.fillShadeVal),
321
        fillTransparencyVal(other.fillTransparencyVal),
322
        lineTransparencyVal(other.lineTransparencyVal),
323
        fillBlendmodeVal(other.fillBlendmodeVal),
324
        lineBlendmodeVal(other.lineBlendmodeVal),
325
        m_ImageIsFlippedH(other.m_ImageIsFlippedH),
326
        m_ImageIsFlippedV(other.m_ImageIsFlippedV),
327
        m_Locked(other.m_Locked),
328
        m_SizeLocked(other.m_SizeLocked),
329
        m_SizeHLocked(other.m_SizeHLocked),
330
        m_SizeVLocked(other.m_SizeVLocked),
331
        textFlowModeVal(other.textFlowModeVal),
332
        pageItemAttributes(other.pageItemAttributes),
333
        m_PrintEnabled(other.m_PrintEnabled),
334
        tagged(other.tagged),
335
        fillQColor(other.fillQColor),
336
        strokeQColor(other.strokeQColor),
337
        GrColorP1QColor(other.GrColorP1QColor),
338
        GrColorP2QColor(other.GrColorP2QColor),
339
        GrColorP3QColor(other.GrColorP3QColor),
340
        GrColorP4QColor(other.GrColorP4QColor),
341
        m_xPos(other.m_xPos),
342
        m_yPos(other.m_yPos),
343
        m_width(other.m_width),
344
        m_height(other.m_height),
345
        m_rotation(other.m_rotation),
346
        m_isSelected(other.m_isSelected),
347
        m_imageXScale(other.m_imageXScale),
348
        m_imageYScale(other.m_imageYScale),
349
        m_imageXOffset(other.m_imageXOffset),
350
        m_imageYOffset(other.m_imageYOffset),
351
        m_imageRotation(other.m_imageRotation),
352
        m_isReversed(other.m_isReversed),
18776 fschmid 353
        firstLineOffsetP(other.firstLineOffsetP),
18935 fschmid 354
        m_groupClips(other.m_groupClips),
355
        hatchBackgroundQ(other.hatchBackgroundQ),
356
        hatchForegroundQ(other.hatchForegroundQ)
3625 avox 357
{
7068 fschmid 358
        QString tmp;
359
        m_Doc->TotalItems++;
360
        AnName += tmp.setNum(m_Doc->TotalItems);
361
        uniqueNr = m_Doc->TotalItems;
8047 avox 362
        invalid = true;
12795 fschmid 363
        if (other.isInlineImage)
364
        {
365
                QFileInfo inlFi(Pfile);
366
                QString ext = inlFi.suffix();
18203 fschmid 367
                QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_XXXXXX." + ext);
368
                tempFile->setAutoRemove(false);
369
                tempFile->open();
370
                QString fileName = getLongPathName(tempFile->fileName());
371
                tempFile->close();
12795 fschmid 372
                copyFile(Pfile, fileName);
373
                Pfile = fileName;
18203 fschmid 374
                delete tempFile;
12795 fschmid 375
                isInlineImage = true;
18203 fschmid 376
                isTempFile = true;
12795 fschmid 377
        }
378
        else
379
        {
380
                isInlineImage = false;
18203 fschmid 381
                isTempFile = false;
12795 fschmid 382
        }
16943 fschmid 383
        Parent = NULL;
16926 fschmid 384
        unWeld();
3625 avox 385
}
386
 
387
 
2707 subik 388
PageItem::PageItem(ScribusDoc *pa, ItemType newType, double x, double y, double w, double h, double w2, QString fill, QString outline)
4061 craig 389
        // Initialize superclass(es)
10532 avox 390
        : QObject(pa), SingleObservable<PageItem>(pa->itemsChanged()),
4061 craig 391
        // Initialize member variables
14444 fschmid 392
        OverrideCompressionMethod(false),
393
        CompressionMethodIndex(0),
394
        OverrideCompressionQuality(false),
395
        CompressionQualityIndex(0),
4688 cbradney 396
        itemText(pa),
18987 avox 397
        textLayout(&itemText, this),
4061 craig 398
        undoManager(UndoManager::instance()),
1749 craig 399
        lineShadeVal(100),
1657 craig 400
        fillShadeVal(100),
401
        fillTransparencyVal(0.0),
402
        lineTransparencyVal(0.0),
5746 fschmid 403
        fillBlendmodeVal(0),
404
        lineBlendmodeVal(0),
4699 cbradney 405
        m_ImageIsFlippedH(0),
406
        m_ImageIsFlippedV(0),
4695 cbradney 407
        m_Locked(false),
408
        m_SizeLocked(false),
17826 craig 409
        m_SizeHLocked(false),
410
        m_SizeVLocked(false),
5620 jghali 411
        textFlowModeVal(TextFlowDisabled)
3 paul 412
{
16943 fschmid 413
        Parent = NULL;
10532 avox 414
        m_Doc = pa;
3 paul 415
        QString tmp;
416
        BackBox = 0;
417
        NextBox = 0;
18032 craig 418
        gXpos = oldXpos = m_xPos = x;
419
        gYpos = oldYpos = m_yPos = y;
4821 cbradney 420
        //CB Surely we can remove some of these?
18095 craig 421
        OldB2 = OldB = oldWidth = m_width = w;
422
        OldH2 = OldH = oldHeight = m_height = h;
456 fschmid 423
        BoundingX = x;
424
        BoundingY = y;
425
        BoundingW = w;
426
        BoundingH = h;
4593 cbradney 427
        m_ItemType = newType;
18022 craig 428
        oldRot = m_rotation = 0;
1394 cbradney 429
        fillColorVal = fill;
4593 cbradney 430
        lineColorVal = m_ItemType == PageItem::TextFrame ? fill : outline;
12726 jghali 431
        gWidth = gHeight = 0;
3 paul 432
        GrType = 0;
292 Franz 433
        GrStartX = 0;
434
        GrStartY = 0;
294 Franz 435
        GrEndX = w;
292 Franz 436
        GrEndY = 0;
14278 fschmid 437
        GrFocalX = 0;
438
        GrFocalY = 0;
439
        GrScale = 1;
14284 fschmid 440
        GrSkew = 0;
14952 fschmid 441
        GrControl1 = FPoint(0,0);
442
        GrControl2 = FPoint(w, 0);
443
        GrControl3 = FPoint(w, h);
444
        GrControl4 = FPoint(0, h);
14981 fschmid 445
        GrControl5 = FPoint(w / 2.0, h / 2.0);
14952 fschmid 446
        GrCol1transp = 1.0;
447
        GrCol2transp = 1.0;
448
        GrCol3transp = 1.0;
449
        GrCol4transp = 1.0;
450
        GrCol1Shade = 100;
451
        GrCol2Shade = 100;
452
        GrCol3Shade = 100;
453
        GrCol4Shade = 100;
16729 fschmid 454
        meshGradientPatches.clear();
15024 fschmid 455
        meshGradientArray.clear();
456
        selectedMeshPointX = -1;
457
        selectedMeshPointY = -1;
14150 fschmid 458
        gradientVal = "";
14168 fschmid 459
        GrTypeStroke = 0;
460
        GrStrokeStartX = 0;
461
        GrStrokeStartY = 0;
462
        GrStrokeEndX = w;
463
        GrStrokeEndY = 0;
14278 fschmid 464
        GrStrokeFocalX = 0;
465
        GrStrokeFocalY = 0;
466
        GrStrokeScale = 1;
14284 fschmid 467
        GrStrokeSkew = 0;
14168 fschmid 468
        gradientStrokeVal = "";
6368 fschmid 469
        patternVal = "";
6414 fschmid 470
        patternScaleX = 100;
471
        patternScaleY = 100;
472
        patternOffsetX = 0;
473
        patternOffsetY = 0;
474
        patternRotation = 0;
14260 fschmid 475
        patternSkewX = 0;
476
        patternSkewY = 0;
14276 fschmid 477
        patternMirrorX = false;
478
        patternMirrorY = false;
14168 fschmid 479
        patternStrokeVal = "";
480
        patternStrokeScaleX = 100;
481
        patternStrokeScaleY = 100;
482
        patternStrokeOffsetX = 0;
483
        patternStrokeOffsetY = 0;
484
        patternStrokeRotation = 0;
14260 fschmid 485
        patternStrokeSkewX = 0;
486
        patternStrokeSkewY = 0;
14403 fschmid 487
        patternStrokeSpace = 1.0;
14276 fschmid 488
        patternStrokeMirrorX = false;
489
        patternStrokeMirrorY = false;
14398 fschmid 490
        patternStrokePath = false;
4580 cbradney 491
        m_lineWidth = w2;
492
        Oldm_lineWidth = w2;
14932 cbradney 493
        PLineArt = Qt::PenStyle(m_Doc->itemToolPrefs().shapeLineStyle);
8522 cbradney 494
        PLineEnd = Qt::FlatCap;
495
        PLineJoin = Qt::MiterJoin;
18022 craig 496
        m_isSelected = false;
3 paul 497
        ClipEdited = false;
498
        FrameType = 0;
499
        CurX = 0;
500
        CurY = 0;
18012 craig 501
        m_textDistanceMargins=m_Doc->itemToolPrefs().textDistances;
18889 fschmid 502
        verticalAlign = 0;
5721 avox 503
        firstChar = 0;
387 Franz 504
        MaxChars = 0;
18007 craig 505
        m_sampleItem = false;
3 paul 506
        Pfile = "";
2004 fschmid 507
        pixm = ScImage();
14932 cbradney 508
        pixm.imgInfo.lowResType = m_Doc->itemToolPrefs().imageLowResType;
3 paul 509
        Pfile2 = "";
510
        Pfile3 = "";
18022 craig 511
        oldLocalScX = m_imageXScale = 1;
512
        oldLocalScY = m_imageYScale = 1;
3 paul 513
        OrigW = 0;
514
        OrigH = 0;
18032 craig 515
        oldLocalX = m_imageXOffset = 0;
516
        oldLocalY = m_imageYOffset = 0;
18022 craig 517
        m_imageRotation = 0;
3 paul 518
        BBoxX = 0;
519
        BBoxH = 0;
18022 craig 520
        m_roundedCorderRadius = 0;
4593 cbradney 521
        switch (m_ItemType)
167 Franz 522
        {
1460 cbradney 523
                case Polygon:
340 Franz 524
                        Clip.setPoints(4, static_cast<int>(w/2), 0, static_cast<int>(w), static_cast<int>(h/2),
525
                                                                static_cast<int>(w/2), static_cast<int>(h), 0,static_cast<int>(h/2));
3 paul 526
                        break;
527
                default:
340 Franz 528
                        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 529
                        break;
167 Franz 530
        }
3 paul 531
        PoLine.resize(0);
340 Franz 532
        ContourLine.resize(0);
2040 fschmid 533
        imageClip.resize(0);
3 paul 534
        Segments.clear();
535
        PoShow = false;
536
        BaseOffs = 0;
7926 fschmid 537
        textPathType = 0;
538
        textPathFlipped = false;
13888 jghali 539
        OwnPage = m_Doc->currentPage() ? m_Doc->currentPage()->pageNr() : -1;
1211 tsoots 540
        oldOwnPage = OwnPage;
4401 fschmid 541
        savedOwnPage = OwnPage;
3 paul 542
        PicArt = true;
13097 subik 543
        PictureIsAvailable = false;
4698 cbradney 544
        m_PrintEnabled = true;
3 paul 545
        isBookmark = false;
4102 cbradney 546
        m_isAnnotation = false;
16926 fschmid 547
        weldList.clear();
10321 mrdocs 548
 
4593 cbradney 549
        switch (m_ItemType)
268 Franz 550
        {
1460 cbradney 551
        case ImageFrame:
13839 fschmid 552
        case OSGFrame:
10321 mrdocs 553
        case LatexFrame:
554
                //We can't determine if this is a latex frame here
555
                // because c++'s typeinfos are still saying it's 
556
                // a plain pageitem
557
                // This is fixed in the PageItem_LatexFrame constructor
268 Franz 558
                AnName = tr("Image");
1250 tsoots 559
                setUPixmap(Um::IImageFrame);
268 Franz 560
                break;
1460 cbradney 561
        case TextFrame:
268 Franz 562
                AnName = tr("Text");
1250 tsoots 563
                setUPixmap(Um::ITextFrame);
268 Franz 564
                break;
1460 cbradney 565
        case Line:
268 Franz 566
                AnName = tr("Line");
1250 tsoots 567
                setUPixmap(Um::ILine);
268 Franz 568
                break;
1460 cbradney 569
        case Polygon:
268 Franz 570
                AnName = tr("Polygon");
1250 tsoots 571
                setUPixmap(Um::IPolygon);
268 Franz 572
                break;
1460 cbradney 573
        case PolyLine:
268 Franz 574
                AnName = tr("Polyline");
1250 tsoots 575
                setUPixmap(Um::IPolyline);
268 Franz 576
                break;
1460 cbradney 577
        case PathText:
268 Franz 578
                AnName = tr("PathText");
1250 tsoots 579
                setUPixmap(Um::IPathText);
268 Franz 580
                break;
15060 fschmid 581
        case Symbol:
582
                AnName = tr("Symbol");
583
                setUPixmap(Um::IPolygon);
584
                break;
16105 fschmid 585
        case Group:
586
                AnName = tr("Group");
587
                setUPixmap(Um::IPolygon);
588
                break;
16191 fschmid 589
        case RegularPolygon:
590
                AnName = tr("RegularPolygon");
591
                setUPixmap(Um::IPolygon);
592
                break;
16215 fschmid 593
        case Arc:
594
                AnName = tr("Arc");
595
                setUPixmap(Um::IPolygon);
596
                break;
16311 fschmid 597
        case Spiral:
598
                AnName = tr("Spiral");
599
                setUPixmap(Um::IPolygon);
600
                break;
16856 craig 601
        case Table:
602
                AnName = tr("Table");
603
                //setUPixmap(Um::IPolygon); // TODO: Fix this.
604
                break;
268 Franz 605
        default:
606
                AnName = "Item";
607
                break;
608
        }
4939 fschmid 609
        m_Doc->TotalItems++;
4084 cbradney 610
        AnName += tmp.setNum(m_Doc->TotalItems); // +" "+QDateTime::currentDateTime().toString();
7068 fschmid 611
        uniqueNr = m_Doc->TotalItems;
87 Franz 612
        AutoName = true;
1204 tsoots 613
        setUName(AnName);
4084 cbradney 614
        m_annotation.setBorderColor(outline);
3 paul 615
        HasSel = false;
616
        isAutoText = false;
5362 avox 617
        inPdfArticle = false;
3 paul 618
        isRaster = false;
619
        Sizing = false;
16961 fschmid 620
//      toPixmap = false;
3 paul 621
        UseEmbedded = true;
14170 jghali 622
        IRender = Intent_Relative_Colorimetric;
3 paul 623
        EmProfile = "";
16105 fschmid 624
        groupItemList.clear();
625
        groupWidth = 1.0;
626
        groupHeight = 1.0;
13875 jghali 627
        LayerID = m_Doc->activeLayer();
3 paul 628
        ScaleType = true;
629
        AspectRatio = true;
18022 craig 630
        m_isReversed = false;
27 Franz 631
        NamedLStyle = "";
68 Franz 632
        DashValues.clear();
633
        DashOffset = 0;
1905 fschmid 634
        fillRule = true;
5320 fschmid 635
        doOverprint = false;
14168 fschmid 636
        stroke_gradient = VGradient(VGradient::linear);
637
        stroke_gradient.clearStops();
638
        if (lineColorVal != CommonStrings::None)
639
        {
640
                const ScColor& col = m_Doc->PageColors[lineColorVal];
641
                QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
642
                stroke_gradient.addStop(qcol, 0.0, 0.5, 1.0, lineColorVal, 100);
643
                stroke_gradient.addStop(qcol, 1.0, 0.5, 1.0, lineColorVal, 100);
644
        }
645
        else
646
        {
14932 cbradney 647
                if (m_Doc->itemToolPrefs().shapeLineColor != CommonStrings::None)
14168 fschmid 648
                {
14932 cbradney 649
                        const ScColor& col = m_Doc->PageColors[m_Doc->itemToolPrefs().shapeLineColor];
14168 fschmid 650
                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
14932 cbradney 651
                        stroke_gradient.addStop(qcol, 0.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeLineColor, 100);
652
                        stroke_gradient.addStop(qcol, 1.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeLineColor, 100);
14168 fschmid 653
                }
654
                else
655
                {
656
                        if (fillColorVal != CommonStrings::None)
657
                        {
658
                                const ScColor& col = m_Doc->PageColors[fillColorVal];
659
                                QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
660
                                stroke_gradient.addStop(qcol, 0.0, 0.5, 1.0, fillColorVal, 100);
661
                                stroke_gradient.addStop(qcol, 1.0, 0.5, 1.0, fillColorVal, 100);
662
                        }
663
                        else
664
                        {
14932 cbradney 665
                                if (m_Doc->itemToolPrefs().shapeLineColor != CommonStrings::None)
14168 fschmid 666
                                {
14932 cbradney 667
                                        const ScColor& col = m_Doc->PageColors[m_Doc->itemToolPrefs().shapeFillColor];
14168 fschmid 668
                                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
14932 cbradney 669
                                        stroke_gradient.addStop(qcol, 0.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeFillColor, 100);
670
                                        stroke_gradient.addStop(qcol, 1.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeFillColor, 100);
14168 fschmid 671
                                }
672
                                else if (m_Doc->PageColors.contains("Black"))
673
                                {
674
                                        const ScColor& col = m_Doc->PageColors["Black"];
675
                                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
676
                                        stroke_gradient.addStop(qcol, 0.0, 0.5, 1.0, "Black", 100);
677
                                        stroke_gradient.addStop(qcol, 1.0, 0.5, 1.0, "Black", 100);
678
                                }
679
                        }
680
                }
681
        }
68 Franz 682
        fill_gradient = VGradient(VGradient::linear);
295 Franz 683
        fill_gradient.clearStops();
7478 jghali 684
        if (fillColorVal != CommonStrings::None)
685
        {
686
                const ScColor& col = m_Doc->PageColors[fillColorVal];
12642 jghali 687
                QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
688
                fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, fillColorVal, 100);
689
                fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, fillColorVal, 100);
14952 fschmid 690
                GrColorP1 = fillColorVal;
691
                GrColorP2 = fillColorVal;
692
                GrColorP3 = fillColorVal;
693
                GrColorP4 = fillColorVal;
7478 jghali 694
        }
304 Franz 695
        else
7478 jghali 696
        {
14932 cbradney 697
                if (m_Doc->itemToolPrefs().shapeFillColor != CommonStrings::None)
7656 fschmid 698
                {
14932 cbradney 699
                        const ScColor& col = m_Doc->PageColors[m_Doc->itemToolPrefs().shapeFillColor];
12642 jghali 700
                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
14932 cbradney 701
                        fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeFillColor, 100);
702
                        fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeFillColor, 100);
14952 fschmid 703
                        GrColorP1 = m_Doc->itemToolPrefs().shapeFillColor;
704
                        GrColorP2 = m_Doc->itemToolPrefs().shapeFillColor;
705
                        GrColorP3 = m_Doc->itemToolPrefs().shapeFillColor;
706
                        GrColorP4 = m_Doc->itemToolPrefs().shapeFillColor;
7656 fschmid 707
                }
708
                else
709
                {
710
                        if (lineColorVal != CommonStrings::None)
711
                        {
712
                                const ScColor& col = m_Doc->PageColors[lineColorVal];
12642 jghali 713
                                QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
714
                                fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, lineColorVal, 100);
715
                                fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, lineColorVal, 100);
14952 fschmid 716
                                GrColorP1 = lineColorVal;
717
                                GrColorP2 = lineColorVal;
718
                                GrColorP3 = lineColorVal;
719
                                GrColorP4 = lineColorVal;
7656 fschmid 720
                        }
721
                        else
722
                        {
14932 cbradney 723
                                if (m_Doc->itemToolPrefs().shapeLineColor != CommonStrings::None)
7656 fschmid 724
                                {
14932 cbradney 725
                                        const ScColor& col = m_Doc->PageColors[m_Doc->itemToolPrefs().shapeLineColor];
12642 jghali 726
                                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
14932 cbradney 727
                                        fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeLineColor, 100);
728
                                        fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, m_Doc->itemToolPrefs().shapeLineColor, 100);
14952 fschmid 729
                                        GrColorP1 = m_Doc->itemToolPrefs().shapeLineColor;
730
                                        GrColorP2 = m_Doc->itemToolPrefs().shapeLineColor;
731
                                        GrColorP3 = m_Doc->itemToolPrefs().shapeLineColor;
732
                                        GrColorP4 = m_Doc->itemToolPrefs().shapeLineColor;
7656 fschmid 733
                                }
12642 jghali 734
                                else if (m_Doc->PageColors.contains("Black"))
735
                                {
736
                                        const ScColor& col = m_Doc->PageColors["Black"];
737
                                        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
738
                                        fill_gradient.addStop(qcol, 0.0, 0.5, 1.0, "Black", 100);
739
                                        fill_gradient.addStop(qcol, 1.0, 0.5, 1.0, "Black", 100);
14952 fschmid 740
                                        GrColorP1 = "Black";
741
                                        GrColorP2 = "Black";
742
                                        GrColorP3 = "Black";
743
                                        GrColorP4 = "Black";
12642 jghali 744
                                }
7656 fschmid 745
                        }
746
                }
7478 jghali 747
        }
14297 fschmid 748
        GrMask = 0;
749
        GrMaskStartX = 0;
750
        GrMaskStartY = 0;
751
        GrMaskEndX = w;
752
        GrMaskEndY = 0;
753
        GrMaskFocalX = 0;
754
        GrMaskFocalY = 0;
755
        GrMaskScale = 1;
756
        GrMaskSkew = 0;
757
        patternMaskScaleX = 100;
758
        patternMaskScaleY = 100;
759
        patternMaskOffsetX = 0;
760
        patternMaskOffsetY = 0;
761
        patternMaskRotation = 0;
762
        patternMaskSkewX = 0;
763
        patternMaskSkewY = 0;
764
        patternMaskMirrorX = false;
765
        patternMaskMirrorY = false;
766
        patternMaskVal = "";
767
        gradientMaskVal = "";
768
        mask_gradient = VGradient(VGradient::linear);
769
        mask_gradient.clearStops();
770
        const ScColor& col = m_Doc->PageColors["Black"];
771
        QColor qcol = ScColorEngine::getRGBColor(col, m_Doc);
772
        mask_gradient.addStop(qcol, 0.0, 0.5, 1.0, "Black", 100);
773
        mask_gradient.addStop(qcol, 1.0, 0.5, 1.0, "Black", 100);
15024 fschmid 774
 
775
        QList<meshPoint> mgList;
776
        meshPoint mgP;
16869 fschmid 777
        meshGradientPatch patch;
778
        mgP.resetTo(FPoint(0.0, 0.0));
15024 fschmid 779
        mgP.transparency = 1.0;
780
        mgP.shade = 100;
781
        mgP.colorName = "Black";
782
        mgP.color = qcol;
783
        mgList.append(mgP);
16869 fschmid 784
        patch.TL = mgP;
18095 craig 785
        mgP.resetTo(FPoint(m_width / 2.0, 0.0));
15024 fschmid 786
        mgList.append(mgP);
18095 craig 787
        mgP.resetTo(FPoint(m_width, 0.0));
15024 fschmid 788
        mgList.append(mgP);
16869 fschmid 789
        patch.TR = mgP;
15024 fschmid 790
        meshGradientArray.append(mgList);
791
        mgList.clear();
18095 craig 792
        mgP.resetTo(FPoint(0.0, m_height / 2.0));
15024 fschmid 793
        mgList.append(mgP);
18095 craig 794
        mgP.resetTo(FPoint(m_width / 2.0, m_height / 2.0));
15024 fschmid 795
        mgList.append(mgP);
18095 craig 796
        mgP.resetTo(FPoint(m_width, m_height / 2.0));
15024 fschmid 797
        mgList.append(mgP);
798
        meshGradientArray.append(mgList);
799
        mgList.clear();
18095 craig 800
        mgP.resetTo(FPoint(0.0, m_height));
15024 fschmid 801
        mgList.append(mgP);
16869 fschmid 802
        patch.BL = mgP;
18095 craig 803
        mgP.resetTo(FPoint(m_width / 2.0, m_height));
15024 fschmid 804
        mgList.append(mgP);
18095 craig 805
        mgP.resetTo(FPoint(m_width, m_height));
15024 fschmid 806
        mgList.append(mgP);
16869 fschmid 807
        patch.BR = mgP;
15024 fschmid 808
        meshGradientArray.append(mgList);
16869 fschmid 809
        meshGradientPatches.append(patch);
15024 fschmid 810
 
12270 cbradney 811
        firstLineOffsetP = FLOPRealGlyphHeight;
14932 cbradney 812
        Cols = m_Doc->itemToolPrefs().textColumns;
813
        ColGap = m_Doc->itemToolPrefs().textColumnGap;
232 Franz 814
        LeftLink = 0;
815
        RightLink = 0;
816
        TopLink = 0;
817
        BottomLink = 0;
234 Franz 818
        LeftLinkID = 0;
819
        RightLinkID = 0;
820
        TopLinkID = 0;
821
        BottomLinkID = 0;
232 Franz 822
        LeftLine = 0;
823
        RightLine = false;
824
        TopLine = false;
825
        BottomLine = false;
826
        isTableItem = false;
827
        isSingleSel = false;
383 Franz 828
        Dirty = false;
5362 avox 829
        invalid = true;
456 fschmid 830
        ChangedMasterItem = false;
2434 fschmid 831
        isEmbedded = false;
13888 jghali 832
        OnMasterPage = m_Doc->currentPage() ? m_Doc->currentPage()->pageName() : QString();
14932 cbradney 833
        m_startArrowIndex = m_Doc->itemToolPrefs().lineStartArrow;
834
        m_endArrowIndex = m_Doc->itemToolPrefs().lineEndArrow;
15345 fschmid 835
        m_startArrowScale = 100;
836
        m_endArrowScale = 100;
2056 fschmid 837
        effectsInUse.clear();
1659 cbradney 838
        //Page Item Attributes
839
        pageItemAttributes.clear();
14927 cbradney 840
        for(ObjAttrVector::Iterator objAttrIt = m_Doc->itemAttributes().begin() ; objAttrIt != m_Doc->itemAttributes().end(); ++objAttrIt )
1659 cbradney 841
        {
4593 cbradney 842
                if (((*objAttrIt).autoaddto=="textframes" && m_ItemType==TextFrame) ||
843
                        ((*objAttrIt).autoaddto=="imageframes" && m_ItemType==ImageFrame)
1659 cbradney 844
                        )
845
                        pageItemAttributes.append(*objAttrIt);
846
        }
12795 fschmid 847
        isInlineImage = false;
18203 fschmid 848
        isTempFile = false;
18772 fschmid 849
 
850
        m_hasSoftShadow = false;
851
        m_softShadowColor = "Black";
852
        m_softShadowShade = 100;
853
        m_softShadowBlurRadius = 5.0;
854
        m_softShadowXOffset = 5.0;
855
        m_softShadowYOffset = 5.0;
856
        m_softShadowOpacity = 0.0;
857
        m_softShadowBlendMode = 0;
18776 fschmid 858
        m_groupClips = true;
18935 fschmid 859
        hatchAngle = 0;
860
        hatchDistance = 2;
861
        hatchType = 0;
862
        hatchUseBackground = false;
863
        hatchBackground = CommonStrings::None;
864
        hatchBackgroundQ = QColor();
865
        hatchForeground = "Black";
866
        hatchForegroundQ = qcol;
3 paul 867
}
868
 
17826 craig 869
PageItem::~PageItem()
870
{
18203 fschmid 871
        if ((isTempFile) && (!Pfile.isEmpty()))
872
                QFile::remove(Pfile);
17826 craig 873
        //remove marks
874
 
875
        if (isTextFrame())
876
        {
877
                if (!asTextFrame()->isInChain() && itemText.length() >0)
878
                {
879
                        for (int pos=0; pos < itemText.length(); ++pos)
880
                        {
18524 avox 881
                if (itemText.hasMark(pos))
17826 craig 882
                                {
18524 avox 883
                    Mark* mrk = itemText.mark(pos);
18047 craig 884
                                        if (!mrk->isType(MARKBullNumType))
885
                                                m_Doc->eraseMark(mrk);
17826 craig 886
                                }
887
                        }
888
                }
889
        }
890
//              if (isWeld())
891
//                      unWeldFromMaster(true);
892
//              if (isWelded())
893
//                      unWeldChild();
894
}
895
 
18794 jghali 896
bool PageItem::isGroupChild() const
897
{
898
        return (dynamic_cast<PageItem_Group*>(Parent) != NULL);
899
}
900
 
901
bool PageItem::isTableCell() const
902
{
903
        return (dynamic_cast<PageItem_Table*>(Parent) != NULL);
904
}
905
 
4644 cbradney 906
void PageItem::setXPos(const double newXPos, bool drawingOnly)
3903 cbradney 907
{
18032 craig 908
        m_xPos = newXPos;
4644 cbradney 909
        if (drawingOnly || m_Doc->isLoading())
910
                return;
4621 cbradney 911
        checkChanges();
3903 cbradney 912
}
913
 
4644 cbradney 914
void PageItem::setYPos(const double newYPos, bool drawingOnly)
3903 cbradney 915
{
18032 craig 916
        m_yPos = newYPos;
4644 cbradney 917
        if (drawingOnly || m_Doc->isLoading())
918
                return;
4621 cbradney 919
        checkChanges();
3903 cbradney 920
}
921
 
4644 cbradney 922
void PageItem::setXYPos(const double newXPos, const double newYPos, bool drawingOnly)
3903 cbradney 923
{
18032 craig 924
        m_xPos = newXPos;
925
        m_yPos = newYPos;
4644 cbradney 926
        if (drawingOnly || m_Doc->isLoading())
927
                return;
4621 cbradney 928
        checkChanges();
3934 cbradney 929
}
930
 
18357 jghali 931
int PageItem::level() const
17092 jghali 932
{
18357 jghali 933
        PageItem* thisItem = const_cast<PageItem*>(this);
18794 jghali 934
        if (!isGroupChild())
17092 jghali 935
        {
936
                if (m_Doc)
937
                {
938
                        QList<PageItem*>* items = OnMasterPage.isEmpty() ? &m_Doc->DocItems : &m_Doc->MasterItems;
18357 jghali 939
                        return (items->indexOf(thisItem) + 1);
17092 jghali 940
                }
941
                return 0;
942
        }
18357 jghali 943
        return (Parent->asGroupFrame()->groupItemList.indexOf(thisItem) + 1);
17092 jghali 944
}
945
 
4644 cbradney 946
void PageItem::moveBy(const double dX, const double dY, bool drawingOnly)
3934 cbradney 947
{
948
        if (dX==0.0 && dY==0.0)
949
                return;
12820 pierre 950
        invalid = true;
3903 cbradney 951
        if (dX!=0.0)
16115 fschmid 952
        {
19220 jghali 953
                m_xPos += dX;
954
                gXpos += dX;
955
                BoundingX += dX;
16115 fschmid 956
        }
3903 cbradney 957
        if (dY!=0.0)
16115 fschmid 958
        {
19220 jghali 959
                m_yPos += dY;
960
                gYpos += dY;
961
                BoundingY += dY;
16115 fschmid 962
        }
4644 cbradney 963
        if (drawingOnly || m_Doc->isLoading())
964
                return;
17826 craig 965
        moveWelded(dX, dY);
4621 cbradney 966
        checkChanges();
3903 cbradney 967
}
968
 
3934 cbradney 969
void PageItem::setWidth(const double newWidth)
970
{
18095 craig 971
        m_width = newWidth;
13013 fschmid 972
        updateConstants();
14681 fschmid 973
        if (m_Doc->isLoading())
974
                return;
4621 cbradney 975
        checkChanges();
3934 cbradney 976
}
977
 
978
void PageItem::setHeight(const double newHeight)
979
{
18095 craig 980
        m_height = newHeight;
13013 fschmid 981
        updateConstants();
14681 fschmid 982
        if (m_Doc->isLoading())
983
                return;
4621 cbradney 984
        checkChanges();
3934 cbradney 985
}
986
 
8418 fschmid 987
void PageItem::setWidthHeight(const double newWidth, const double newHeight, bool drawingOnly)
988
{
18095 craig 989
        m_width = newWidth;
990
        m_height = newHeight;
13013 fschmid 991
        updateConstants();
8418 fschmid 992
        if (drawingOnly)
993
                return;
994
        checkChanges();
995
}
996
 
3934 cbradney 997
void PageItem::setWidthHeight(const double newWidth, const double newHeight)
998
{
18095 craig 999
        m_width = newWidth;
1000
        m_height = newHeight;
13013 fschmid 1001
        updateConstants();
14681 fschmid 1002
        if (m_Doc->isLoading())
1003
                return;
4621 cbradney 1004
        checkChanges();
3934 cbradney 1005
}
1006
 
1007
void PageItem::resizeBy(const double dH, const double dW)
1008
{
1009
        if (dH==0.0 && dW==0.0)
1010
                return;
1011
        if (dH!=0.0)
18095 craig 1012
                m_width+=dH;
3934 cbradney 1013
        if (dW!=0.0)
18095 craig 1014
                m_height+=dW;
13013 fschmid 1015
        updateConstants();
14681 fschmid 1016
        if (m_Doc->isLoading())
1017
                return;
4621 cbradney 1018
        checkChanges();
3934 cbradney 1019
}
1020
 
4663 cbradney 1021
void PageItem::setRotation(const double newRotation, bool drawingOnly)
3934 cbradney 1022
{
18022 craig 1023
        double dR = newRotation - m_rotation;
1024
        double oldRot = m_rotation;
1025
        m_rotation = newRotation;
4663 cbradney 1026
        if (drawingOnly || m_Doc->isLoading())
1027
                return;
17826 craig 1028
        rotateWelded(dR, oldRot);
14681 fschmid 1029
        checkChanges();
3934 cbradney 1030
}
1031
 
1032
void PageItem::rotateBy(const double dR)
1033
{
1034
        if (dR==0.0)
1035
                return;
18022 craig 1036
        m_rotation+=dR;
14681 fschmid 1037
        if (m_Doc->isLoading())
1038
                return;
4621 cbradney 1039
        checkChanges();
3934 cbradney 1040
}
1041
 
1042
void PageItem::setSelected(const bool toSelect)
1043
{
18022 craig 1044
        m_isSelected=toSelect;
3934 cbradney 1045
}
1046
 
3988 cbradney 1047
void PageItem::setImageXScale(const double newImageXScale)
3985 cbradney 1048
{
19263 jghali 1049
        m_imageXScale = newImageXScale;
14681 fschmid 1050
        if (m_Doc->isLoading())
19263 jghali 1051
        {
1052
                oldLocalScX = m_imageXScale;
14681 fschmid 1053
                return;
19263 jghali 1054
        }
4821 cbradney 1055
        checkChanges();
3985 cbradney 1056
}
1057
 
1058
void PageItem::setImageYScale(const double newImageYScale)
1059
{
19263 jghali 1060
        m_imageYScale = newImageYScale;
14681 fschmid 1061
        if (m_Doc->isLoading())
19263 jghali 1062
        {
1063
                oldLocalScY = m_imageYScale;
14681 fschmid 1064
                return;
19263 jghali 1065
        }
4821 cbradney 1066
        checkChanges();
3985 cbradney 1067
}
1068
 
1069
void PageItem::setImageXYScale(const double newImageXScale, const double newImageYScale)
1070
{
19263 jghali 1071
        m_imageXScale = newImageXScale;
1072
        m_imageYScale = newImageYScale;
14681 fschmid 1073
        if (m_Doc->isLoading())
19263 jghali 1074
        {
1075
                oldLocalScX = m_imageXScale;
1076
                oldLocalScY = m_imageYScale;
14681 fschmid 1077
                return;
19263 jghali 1078
        }
4821 cbradney 1079
        checkChanges();
3985 cbradney 1080
}
1081
 
3988 cbradney 1082
void PageItem::setImageXOffset(const double newImageXOffset)
3985 cbradney 1083
{
19263 jghali 1084
        m_imageXOffset = newImageXOffset;
14681 fschmid 1085
        if (m_Doc->isLoading())
19263 jghali 1086
        {
1087
                oldLocalX = m_imageXOffset;
14681 fschmid 1088
                return;
19263 jghali 1089
        }
4821 cbradney 1090
        checkChanges();
3985 cbradney 1091
}
1092
 
1093
void PageItem::setImageYOffset(const double newImageYOffset)
1094
{
19263 jghali 1095
        m_imageYOffset = newImageYOffset;
14681 fschmid 1096
        if (m_Doc->isLoading())
19263 jghali 1097
        {
1098
                oldLocalY = m_imageYOffset;
14681 fschmid 1099
                return;
19263 jghali 1100
        }
4821 cbradney 1101
        checkChanges();
3985 cbradney 1102
}
1103
 
1104
void PageItem::setImageXYOffset(const double newImageXOffset, const double newImageYOffset)
1105
{
19263 jghali 1106
        m_imageXOffset = newImageXOffset;
1107
        m_imageYOffset = newImageYOffset;
14681 fschmid 1108
        if (m_Doc->isLoading())
19263 jghali 1109
        {
1110
                oldLocalX = m_imageXOffset;
1111
                oldLocalY = m_imageYOffset;
14681 fschmid 1112
                return;
19263 jghali 1113
        }
4821 cbradney 1114
        checkChanges();
3985 cbradney 1115
}
1116
 
1117
void PageItem::moveImageXYOffsetBy(const double dX, const double dY)
1118
{
1119
        if (dX==0.0 && dY==0.0)
1120
                return;
16703 jghali 1121
        if (dX != 0.0)
18032 craig 1122
                m_imageXOffset += dX;
16703 jghali 1123
        if (dY != 0.0)
18032 craig 1124
                m_imageYOffset += dY;
14681 fschmid 1125
        if (m_Doc->isLoading())
1126
                return;
4821 cbradney 1127
        checkChanges();
3985 cbradney 1128
}
1129
 
14861 fschmid 1130
void PageItem::setImageRotation(const double newRotation)
1131
{
19263 jghali 1132
        if (m_imageRotation == newRotation)
17709 craig 1133
                return;
19263 jghali 1134
        if (UndoManager::undoEnabled())
17744 craig 1135
        {
1136
                SimpleState *ss = new SimpleState(Um::Rotate,"",Um::IRotate);
19263 jghali 1137
                ss->set("IMAGE_ROTATION", "image_rotation");
1138
                ss->set("OLD_ROT", m_imageRotation);
1139
                ss->set("NEW_ROT", newRotation);
17744 craig 1140
                undoManager->action(this,ss);
1141
        }
18022 craig 1142
        m_imageRotation = newRotation;
14861 fschmid 1143
        if (m_Doc->isLoading())
1144
                return;
1145
        checkChanges();
1146
}
1147
 
3988 cbradney 1148
void PageItem::setReversed(bool newReversed)
1149
{
18022 craig 1150
        if (m_isReversed == newReversed)
16703 jghali 1151
                return;
16609 craig 1152
        if (UndoManager::undoEnabled())
1153
        {
1154
                SimpleState *ss = new SimpleState(Um::FlipH, 0, Um::IFlipH);
16703 jghali 1155
                ss->set("REVERSE_TEXT", newReversed);
16609 craig 1156
                undoManager->action(this, ss);
1157
        }
18022 craig 1158
        m_isReversed = newReversed;
3988 cbradney 1159
}
3985 cbradney 1160
 
16621 craig 1161
//return frame where is text end
1162
PageItem * PageItem::frameTextEnd()
1163
{
1164
        PageItem * LastBox = this;
1165
        if (frameOverflows() && NextBox)
1166
        { // text ending in some next frame
1167
                LastBox = NextBox;
1168
                while (LastBox != 0 && !LastBox->frameDisplays(itemText.length()-1))
1169
                        LastBox = LastBox->nextInChain();
1170
        }
1171
        else if (frameUnderflows() && BackBox)
1172
        { //text ending in some previous frame
1173
                LastBox = BackBox;
1174
                while (LastBox != 0 && !LastBox->frameDisplays(itemText.length()-1))
1175
                        LastBox = LastBox->prevInChain();
1176
        }
1177
        return LastBox;
1178
}
5559 avox 1179
 
1180
/// returns true if text overflows
1181
bool PageItem::frameOverflows() const
1182
{
12414 jghali 1183
        // Fix #6991 : "Text overflow" warning when there is a text underflow in fact
1184
        /*return NextBox == NULL && itemText.length() > static_cast<int>(MaxChars);*/
12820 pierre 1185
        return ( NextBox == NULL )
1186
               && ( static_cast<int> ( firstChar ) < itemText.length() )
13131 jghali 1187
                   // Fix #7766 : scribus.textOverflows() returns 0 if there is no place for the overflow mark
1188
               /*&& ( firstChar < MaxChars )*/
1189
                   && ( firstChar <= MaxChars )
12820 pierre 1190
               && ( itemText.length() > static_cast<int> ( MaxChars ) );
5559 avox 1191
}
1192
 
16845 craig 1193
int PageItem::frameOverflowCount() const
1194
{
1195
        if (frameOverflows())
1196
                return itemText.length()-MaxChars;
1197
        return 0;
1198
}
1199
 
19188 craig 1200
int PageItem::frameOverflowBlankCount() const
1201
{
1202
        if (frameOverflows())
1203
                return itemText.plainText().right(itemText.length() - MaxChars).count(QRegularExpression("\\s+"));
1204
 
1205
        return 0;
1206
}
1207
 
17100 fschmid 1208
int PageItem::maxCharsInFrame()
1209
{
1210
        return MaxChars;
1211
}
1212
 
16621 craig 1213
/// returns true if text is ending before that frame
1214
bool PageItem::frameUnderflows() const
1215
{
1216
        if (BackBox == NULL)
1217
                return false;
1218
        //FIX ME - I have found that condition if frame is empty
1219
        //and has been linked with previous frame
1220
        //if you will find any better solution - fix that function
1221
        return (firstInFrame() > lastInFrame());
1222
}
1223
 
16856 craig 1224
void PageItem::drawOverflowMarker(ScPainter *p)
1225
{
1226
        qreal sideLength = 10 / qMax(p->zoomFactor(), 1.0);
1227
        qreal offset = 1 / qMax(p->zoomFactor(), 1.0);
18095 craig 1228
        qreal left = m_width - sideLength-offset;// / 2;
16856 craig 1229
        qreal right = left + sideLength;
18095 craig 1230
        qreal top = m_height - sideLength-offset;// * 1.5;
16856 craig 1231
        qreal bottom = top + sideLength;
1232
 
1233
        QColor color(PrefsManager::instance()->appPrefs.displayPrefs.frameNormColor);
1234
        if ((isBookmark) || (m_isAnnotation))
1235
                color = PrefsManager::instance()->appPrefs.displayPrefs.frameAnnotationColor;
1236
        if ((BackBox != 0) || (NextBox != 0))
1237
                color = PrefsManager::instance()->appPrefs.displayPrefs.frameLinkColor;
1238
        if (m_Locked)
1239
                color = PrefsManager::instance()->appPrefs.displayPrefs.frameLockColor;
1240
        if (m_Doc->m_Selection->containsItem(this))
1241
                color = Qt::red;
1242
 
1243
        p->save();
1244
 
17790 fschmid 1245
        p->setPen(color, 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
16856 craig 1246
        p->setPenOpacity(1.0);
1247
        p->setBrush(Qt::white);
1248
        p->setBrushOpacity(1.0);
1249
        p->setFillMode(ScPainter::Solid);
17790 fschmid 1250
        p->drawSharpRect(left, top, sideLength, sideLength);
1251
        p->drawSharpLine(QPointF(left, top), QPointF(right, bottom));
1252
        p->drawSharpLine(QPointF(left, bottom), QPointF(right, top));
16856 craig 1253
 
1254
        p->restore();
1255
}
1256
 
5559 avox 1257
int PageItem::firstInFrame() const
1258
{
5721 avox 1259
        return firstChar;
5559 avox 1260
}
1261
int PageItem::lastInFrame() const
1262
{
8562 jghali 1263
        return qMin(signed(MaxChars), itemText.length()) - 1;
5559 avox 1264
}
1265
 
16589 jghali 1266
bool PageItem::testLinkCandidate(PageItem* nxt)
1267
{
1268
        if (this->nextInChain() )
1269
                return false;
18338 jghali 1270
        if (!nxt || nxt->prevInChain() )
16589 jghali 1271
                return false;
1272
        for (PageItem* ff=nxt; ff; ff=ff->nextInChain())
1273
        {
1274
                if (ff == this) return false;
1275
        }
1276
        return true;
1277
}
7994 avox 1278
 
17708 craig 1279
void PageItem::link(PageItem* nxt, bool addPARSEP)
7994 avox 1280
{
1281
        assert( !nextInChain() );
1282
        assert( !nxt->prevInChain() );
8075 avox 1283
        for (PageItem* ff=nxt; ff; ff=ff->nextInChain())
1284
        {
1285
                assert (ff != this);
1286
        }
13655 jghali 1287
        // Append only if necessary to avoid the
1288
        // charstyle: access at end of text warning
17708 craig 1289
        bool first = false;
1290
        bool createUndo = addPARSEP;
1291
 
1292
        if (nxt->prevInChain() == NULL)
1293
                first = true;
1294
        int textLen = itemText.length();
13655 jghali 1295
        if (nxt->itemText.length() > 0)
17708 craig 1296
        {   //case when text will be joined with next frame text
1297
                //do not add PARSEP if first frame has no text or text ends already with PARSEP
1298
                if (addPARSEP && (textLen > 0) && (itemText.text(textLen-1) != SpecialChars::PARSEP))
1299
                        itemText.insertChars(textLen, SpecialChars::PARSEP);
1300
                else
1301
                        addPARSEP = false;
13655 jghali 1302
                itemText.append(nxt->itemText);
17708 craig 1303
        }
7994 avox 1304
        NextBox = nxt;
1305
        nxt->BackBox = this;
8325 avox 1306
        // update AutoText
1307
        if (isAutoText)
1308
        {
1309
                PageItem* after = nxt;
1310
                while (after)
1311
                {
1312
                        after->isAutoText = true;
1313
                        m_Doc->LastAuto = after;
1314
                        after = after->NextBox;
1315
                }
1316
        }
1317
        else if (nxt->isAutoText)
1318
        {
1319
                PageItem* before = this;
1320
                while (before)
1321
                {
1322
                        before->isAutoText = true;
1323
                        m_Doc->FirstAuto = before;
1324
                        before = before->BackBox;
1325
                }
1326
        }
7994 avox 1327
        invalid = true;
8325 avox 1328
        while (nxt)
1329
        {
9490 avox 1330
                nxt->itemText = itemText;
8325 avox 1331
                nxt->invalid = true;
1332
                nxt->firstChar = 0;
1333
                nxt = nxt->NextBox;
1334
        }
17708 craig 1335
        if (UndoManager::undoEnabled() && createUndo) //addPARESEP is false only if linking is invoked from undo action for unlinkWithText
16490 craig 1336
        {
17744 craig 1337
                ScItemState<QPair<PageItem*, PageItem*> > *is = new ScItemState<QPair<PageItem*, PageItem*> >(Um::LinkTextFrame);
16490 craig 1338
                is->set("LINK_TEXT_FRAME", "linkTextFrame");
17708 craig 1339
                is->set("FIRST", first);
1340
                is->set("JOIN_POS", textLen);
1341
                is->set("ADDPARSEP", addPARSEP);
17744 craig 1342
                is->setItem(qMakePair(this, NextBox));
16490 craig 1343
                undoManager->action(this, is);
1344
        }
7994 avox 1345
}
1346
 
17708 craig 1347
void PageItem::unlink(bool createUndo)
7994 avox 1348
{
1349
        if( NextBox )
1350
        {
16490 craig 1351
                PageItem *undoNextBox=NextBox;
7994 avox 1352
                // make sure lastInFrame is valid
1353
                layout();
12246 cbradney 1354
                /*
1355
                //<< CB #6332: Stop the StoryText cut and break and act like other publishing apps
7994 avox 1356
                // move following text to new StoryText
1357
                itemText.select(lastInFrame()+1, itemText.length()-lastInFrame()-1);
12246 cbradney 1358
                */
7994 avox 1359
                StoryText follow(m_Doc);
12246 cbradney 1360
                /*
7994 avox 1361
                follow.setDefaultStyle(itemText.defaultStyle());
1362
                follow.insert(0, itemText, true);
1363
                // remove following text from this chain
1364
                itemText.removeSelection();
12246 cbradney 1365
                //>>
1366
                */
8325 avox 1367
                // update auto pointers
1368
                if (isAutoText)
1369
                {
1370
                        PageItem* before = this;
1371
                        while (before)
1372
                        {
1373
                                before->isAutoText = false;
1374
                                before = before->BackBox;
1375
                        }
1376
                        m_Doc->FirstAuto = NextBox;
1377
                }
7994 avox 1378
                // link following frames to new text
1379
                NextBox->firstChar = 0;
1380
                NextBox->BackBox = NULL;
1381
                while (NextBox) {
1382
                        NextBox->itemText = follow;
1383
                        NextBox->invalid = true;
8325 avox 1384
                        NextBox->firstChar = 0;
7994 avox 1385
                        NextBox = NextBox->NextBox;
1386
                }
1387
                // NextBox == NULL now
11743 jghali 1388
                NextBox = NULL;
17708 craig 1389
                if (UndoManager::undoEnabled() && createUndo)
16490 craig 1390
                {
17744 craig 1391
                        ScItemState<QPair<PageItem*, PageItem*> > *is = new ScItemState<QPair<PageItem*, PageItem*> >(Um::UnlinkTextFrame);
16490 craig 1392
                        is->set("UNLINK_TEXT_FRAME", "unlinkTextFrame");
17744 craig 1393
                        is->setItem(qMakePair(this, undoNextBox));
16490 craig 1394
                        undoManager->action(this, is);
1395
                }
7994 avox 1396
        }
1397
}
1398
 
8325 avox 1399
void PageItem::dropLinks()
1400
{
1401
        // update auto pointers
1402
        if (isAutoText && NextBox == 0)
1403
        {
1404
                m_Doc->LastAuto = BackBox;
1405
        }
1406
        if (isAutoText && BackBox == 0)
1407
        {
1408
                m_Doc->FirstAuto = NextBox;
1409
        }
1410
        isAutoText = false;
1411
 
1412
        // leave text in remaining chain
1413
        PageItem* before = BackBox;
1414
        PageItem* after = NextBox;
1415
        if (after != 0 || before != 0)
1416
        {
1417
                itemText = StoryText(m_Doc);
1418
                if (before)
1419
                        before->NextBox = after;
1420
                if (after)
1421
                {
1422
                        after->BackBox = before;
1423
                        while (after)
1424
                        {
1425
                                after->invalid = true;
1426
                                after->firstChar = 0;
1427
                                after = after->NextBox;
1428
                        }
1429
                }
9403 jghali 1430
                // JG we should set BackBox and NextBox to NULL at a point
11743 jghali 1431
                BackBox = NextBox = NULL;
8325 avox 1432
        }
1433
}
1434
 
17565 craig 1435
//unlink selected frame from text chain
1436
//but copy or cut its content from itemText
1437
void PageItem::unlinkWithText(bool cutText)
1438
{
1439
        PageItem * Next = NextBox;
17708 craig 1440
        PageItem * Prev = BackBox;
1441
        int length = itemText.length();
1442
 
1443
        //unlink first frame in chain
1444
        if (Prev == NULL)
1445
        {
1446
                if (lastInFrame() < length -1)
1447
                {
1448
                        StoryText content(m_Doc);
1449
                        itemText.select(lastInFrame() +1, length - (lastInFrame() +1));
1450
                        content.insert(0, itemText, cutText);
1451
                        itemText.removeSelection();
1452
                        unlink(false);
1453
                        Next->itemText.insert(0, content);
1454
                        Next->update();
1455
                }
1456
                else
1457
                {
1458
                        unlink(false);
1459
                        if (!cutText)
1460
                        {
1461
                                Next->itemText.insert(0, itemText);
1462
                                Next->update();
1463
                        }
1464
                }
1465
        }
1466
        else
1467
        {
1468
                itemText.select(firstInFrame(), length - firstInFrame());
1469
                StoryText content(m_Doc);
1470
                content.insert(0, itemText, true);
1471
                if (cutText)
1472
                        itemText.removeSelection();
1473
                Prev->unlink(false);
1474
                itemText.insert(0, content);
1475
                update();
1476
        }
1477
        if (UndoManager::undoEnabled())
1478
        {
17744 craig 1479
                ScItemState<QPair<PageItem*, PageItem*> > *is = new ScItemState<QPair<PageItem*, PageItem*> >(Um::UnlinkTextFrame);
17708 craig 1480
                is->set("UNLINK_TEXT_FRAME", "unlinkTextFrame");
1481
                is->set("CUT_TEXT", cutText);
17744 craig 1482
                is->setItem(qMakePair(Prev, Next));
17708 craig 1483
                undoManager->action(this, is);
1484
        }
17565 craig 1485
}
1486
 
5559 avox 1487
/// tests if a character is displayed by this frame
1488
bool PageItem::frameDisplays(int textpos) const
1489
{
5673 avox 1490
        return 0 <= textpos && textpos < signed(MaxChars) &&  textpos < itemText.length();
5559 avox 1491
}
1492
 
1493
 
1494
/// returns the style at the current charpos
1495
const ParagraphStyle& PageItem::currentStyle() const
1496
{
16626 jghali 1497
        if (frameDisplays(itemText.cursorPosition()))
1498
                return itemText.paragraphStyle(itemText.cursorPosition());
5559 avox 1499
        else
1500
                return itemText.defaultStyle();
1501
}
1502
 
5569 avox 1503
/// returns the style at the current charpos for changing
1504
ParagraphStyle& PageItem::changeCurrentStyle()
1505
{
16626 jghali 1506
        if (frameDisplays(itemText.cursorPosition()))
1507
                return const_cast<ParagraphStyle&>(itemText.paragraphStyle(itemText.cursorPosition()));
5569 avox 1508
        else
5691 avox 1509
                return const_cast<ParagraphStyle&>(itemText.defaultStyle());
5569 avox 1510
}
1511
 
5559 avox 1512
/// returns the style at the current charpos
1513
const CharStyle& PageItem::currentCharStyle() const
1514
{
16626 jghali 1515
        if (frameDisplays(itemText.cursorPosition()))
1516
                return itemText.charStyle(itemText.cursorPosition());
5559 avox 1517
        else
1518
                return itemText.defaultStyle().charStyle();
1519
}
1520
 
16838 jghali 1521
void PageItem::currentTextProps(ParagraphStyle& parStyle) const
1522
{
1523
        parStyle = this->currentStyle();
1524
        int position = itemText.cursorPosition();
1525
        if (itemText.lengthOfSelection() > 0)
1526
                position = qMin(qMax(itemText.endOfSelection() - 1, 0), qMax(position, itemText.startOfSelection()));
1527
 
1528
        if (frameDisplays(position))
1529
                parStyle.charStyle().setStyle( itemText.charStyle(position) );
1530
        else
1531
                parStyle.charStyle().setStyle( itemText.defaultStyle().charStyle() );
1532
}
1533
 
3988 cbradney 1534
void PageItem::setTextToFrameDistLeft(double newLeft)
1535
{
18012 craig 1536
        if(m_textDistanceMargins.Left==newLeft)
17641 craig 1537
                return;
1538
        if (UndoManager::undoEnabled())
1539
        {
1540
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1541
                ss->set("LEFT_TEXTFRAMEDIST", "left_textframedist");
18012 craig 1542
                ss->set("OLD_DIST",m_textDistanceMargins.Left);
17641 craig 1543
                ss->set("NEW_DIST",newLeft);
1544
                undoManager->action(this, ss);
1545
        }
18012 craig 1546
        m_textDistanceMargins.Left=newLeft;
16546 jghali 1547
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1548
}
3985 cbradney 1549
 
3988 cbradney 1550
void PageItem::setTextToFrameDistRight(double newRight)
1551
{
18012 craig 1552
        if(m_textDistanceMargins.Right==newRight)
17641 craig 1553
                return;
1554
        if (UndoManager::undoEnabled())
1555
        {
1556
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1557
                ss->set("RIGHT_TEXTFRAMEDIST", "right_textframedist");
18012 craig 1558
                ss->set("OLD_DIST",m_textDistanceMargins.Right);
17641 craig 1559
                ss->set("NEW_DIST",newRight);
1560
                undoManager->action(this, ss);
1561
        }
18012 craig 1562
        m_textDistanceMargins.Right=newRight;
16546 jghali 1563
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1564
}
3985 cbradney 1565
 
3988 cbradney 1566
void PageItem::setTextToFrameDistTop(double newTop)
1567
{
18012 craig 1568
        if(m_textDistanceMargins.Top==newTop)
17641 craig 1569
                return;
1570
        if (UndoManager::undoEnabled())
1571
        {
1572
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1573
                ss->set("TOP_TEXTFRAMEDIST", "top_textframedist");
18012 craig 1574
                ss->set("OLD_DIST",m_textDistanceMargins.Top);
17641 craig 1575
                ss->set("NEW_DIST",newTop);
1576
                undoManager->action(this, ss);
1577
        }
18012 craig 1578
        m_textDistanceMargins.Top=newTop;
16546 jghali 1579
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1580
}
3985 cbradney 1581
 
3988 cbradney 1582
void PageItem::setTextToFrameDistBottom(double newBottom)
1583
{
18012 craig 1584
        if(m_textDistanceMargins.Bottom==newBottom)
17641 craig 1585
                return;
1586
        if (UndoManager::undoEnabled())
1587
        {
1588
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1589
                ss->set("BOTTOM_TEXTFRAMEDIST", "bottom_textframedist");
18012 craig 1590
                ss->set("OLD_DIST",m_textDistanceMargins.Bottom);
17641 craig 1591
                ss->set("NEW_DIST",newBottom);
1592
                undoManager->action(this, ss);
1593
        }
18012 craig 1594
        m_textDistanceMargins.Bottom=newBottom;
16546 jghali 1595
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1596
}
3985 cbradney 1597
 
3988 cbradney 1598
void PageItem::setTextToFrameDist(double newLeft, double newRight, double newTop, double newBottom)
1599
{
17641 craig 1600
        UndoTransaction* activeTransaction = NULL;
1601
        if (UndoManager::undoEnabled())
1602
                activeTransaction = new UndoTransaction(undoManager->beginTransaction(Um::TextFrame, Um::IDocument, Um::TextFrameDist, "", Um::ITextFrame));
1603
        setTextToFrameDistLeft(newLeft);
1604
        setTextToFrameDistRight(newRight);
1605
        setTextToFrameDistTop(newTop);
1606
        setTextToFrameDistBottom(newBottom);
1607
        if (activeTransaction)
1608
        {
1609
                activeTransaction->commit();
1610
                delete activeTransaction;
1611
                activeTransaction = NULL;
1612
        }
16546 jghali 1613
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1614
}
3985 cbradney 1615
 
14932 cbradney 1616
double PageItem::gridOffset() const { return m_Doc->guidesPrefs().offsetBaselineGrid; }
1617
double PageItem::gridDistance() const { return m_Doc->guidesPrefs().valueBaselineGrid; }
5559 avox 1618
 
1619
void PageItem::setGridOffset(double) { } // FIXME
1620
void PageItem::setGridDistance(double) { } // FIXME
1621
void PageItem::setColumns(int n)
1622
{
17641 craig 1623
        if(Cols==n)
1624
                return;
17744 craig 1625
        if(UndoManager::undoEnabled())
1626
        {
17641 craig 1627
                SimpleState *ss = new SimpleState(Um::Columns, "", Um::IBorder);
1628
                ss->set("COLUMNS", "columns");
1629
                ss->set("OLD_COLUMNS", Cols);
1630
                ss->set("NEW_COLUMNS",n);
1631
                undoManager->action(this, ss);
1632
        }
1633
        Cols = qMax(1, n);
5559 avox 1634
}
1635
void PageItem::setColumnGap(double gap)
1636
{
17641 craig 1637
        if(ColGap==gap)
1638
                return;
1639
        if(UndoManager::undoEnabled()){
1640
                SimpleState *ss = new SimpleState(Um::Columns, "", Um::IBorder);
1641
                ss->set("COLUMNSGAP", "columnsgap");
1642
                ss->set("OLD_COLUMNS", ColGap);
1643
                ss->set("NEW_COLUMNS",gap);
1644
                undoManager->action(this, ss);
1645
        }
1646
        ColGap = gap;
5559 avox 1647
}
1648
 
18889 fschmid 1649
int PageItem::verticalAlignment()
1650
{
1651
        return verticalAlign;
1652
}
1653
 
1654
void PageItem::setVerticalAlignment(int val)
1655
{
1656
        if (val == verticalAlign)
1657
                return;
19132 craig 1658
        if(UndoManager::undoEnabled())
1659
        {
1660
                SimpleState *ss = new SimpleState(Um::AlignText, "", Um::ITextFrame);
1661
                ss->set("VERTICAL_ALIGN", "vertical_align");
1662
                ss->set("OLD_VERTALIGN", verticalAlign);
1663
                ss->set("NEW_VERTALIGN", val);
1664
                undoManager->action(this, ss);
1665
        }
18889 fschmid 1666
        verticalAlign = val;
1667
}
1668
 
3989 cbradney 1669
void PageItem::setCornerRadius(double newRadius)
1670
{
18022 craig 1671
        if(m_roundedCorderRadius==newRadius)
17644 craig 1672
                return;
17744 craig 1673
        if(UndoManager::undoEnabled())
1674
        {
1675
                SimpleState *state = new SimpleState(Um::RoundCorner,"",Um::IBorder);
1676
                state->set("CORNER_RADIUS","corner_radius");
18022 craig 1677
                state->set("OLD_RADIUS",m_roundedCorderRadius);
17744 craig 1678
                state->set("NEW_RADIUS",newRadius);
1679
                undoManager->action(this,state);
1680
        }
18022 craig 1681
        m_roundedCorderRadius=newRadius;
16546 jghali 1682
        //emit cornerRadius(RadRect);
3989 cbradney 1683
}
3985 cbradney 1684
 
3988 cbradney 1685
 
1686
 
10840 avox 1687
/** Paints the item.
1688
    CHANGE: cullingArea is in doc coordinates!
1689
 */
11052 avox 1690
void PageItem::DrawObj(ScPainter *p, QRectF cullingArea)
3 paul 1691
{
4084 cbradney 1692
        if (!m_Doc->DoDrawing)
1740 cbradney 1693
                return;
10945 jghali 1694
        if (cullingArea.isNull())
10840 avox 1695
        {
1696
                cullingArea = QRectF(QPointF(m_Doc->minCanvasCoordinate.x(), m_Doc->minCanvasCoordinate.y()),
1697
                                                         QPointF(m_Doc->maxCanvasCoordinate.x(), m_Doc->maxCanvasCoordinate.y())).toAlignedRect();
1698
        }
17394 fschmid 1699
 
1700
        no_fill = false;
1701
        no_stroke = false;
14681 fschmid 1702
        DrawObj_Pre(p);
13875 jghali 1703
        if (m_Doc->layerOutline(LayerID))
5572 fschmid 1704
        {
16902 fschmid 1705
                if ((itemType()==TextFrame || itemType()==ImageFrame || itemType()==PathText || itemType()==Line || itemType()==PolyLine || itemType()==Group || itemType()==Symbol))
14681 fschmid 1706
                        DrawObj_Item(p, cullingArea);
5572 fschmid 1707
        }
1708
        else
7549 fschmid 1709
        {
16105 fschmid 1710
                DrawObj_Item(p, cullingArea);
7549 fschmid 1711
        }
2434 fschmid 1712
        DrawObj_Post(p);
1736 cbradney 1713
}
1714
 
14681 fschmid 1715
void PageItem::DrawObj_Pre(ScPainter *p)
1740 cbradney 1716
{
1741 cbradney 1717
        p->save();
18729 fschmid 1718
        double lwCorr = m_lineWidth;
1719
        double sc = p->zoomFactor();
1720
        if ((m_lineWidth * sc) < 1)
1721
                lwCorr = 0;
2434 fschmid 1722
        if (!isEmbedded)
18032 craig 1723
                p->translate(m_xPos, m_yPos);
18022 craig 1724
        p->rotate(m_rotation);
13875 jghali 1725
        if (m_Doc->layerOutline(LayerID))
1741 cbradney 1726
        {
18729 fschmid 1727
                p->setPen(m_Doc->layerMarker(LayerID), 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5572 fschmid 1728
                p->setFillMode(ScPainter::None);
1729
                p->setBrushOpacity(1.0);
1730
                p->setPenOpacity(1.0);
1741 cbradney 1731
        }
1732
        else
1733
        {
16105 fschmid 1734
                if (!isGroup())
1741 cbradney 1735
                {
18772 fschmid 1736
                        if (hasSoftShadow())
1737
                                DrawSoftShadow(p);
14306 fschmid 1738
                        p->setBlendModeFill(fillBlendmode());
18729 fschmid 1739
                        p->setLineWidth(lwCorr);
14297 fschmid 1740
                        if (GrType != 0)
5572 fschmid 1741
                        {
14297 fschmid 1742
                                if (GrType == 8)
6368 fschmid 1743
                                {
14297 fschmid 1744
                                        if ((patternVal.isEmpty()) || (!m_Doc->docPatterns.contains(patternVal)))
6368 fschmid 1745
                                        {
14297 fschmid 1746
                                                p->fill_gradient = VGradient(VGradient::linear);
19163 fschmid 1747
                                                p->fill_gradient.setRepeatMethod(GrExtend);
14297 fschmid 1748
                                                if (fillColor() != CommonStrings::None)
1749
                                                {
1750
                                                        p->setBrush(fillQColor);
1751
                                                        p->setFillMode(ScPainter::Solid);
1752
                                                }
1753
                                                else
17394 fschmid 1754
                                                {
1755
                                                        no_fill = true;
14297 fschmid 1756
                                                        p->setFillMode(ScPainter::None);
17394 fschmid 1757
                                                }
14297 fschmid 1758
                                                if ((!patternVal.isEmpty()) && (!m_Doc->docPatterns.contains(patternVal)))
1759
                                                {
1760
                                                        GrType = 0;
1761
                                                        patternVal = "";
1762
                                                }
6368 fschmid 1763
                                        }
1764
                                        else
12215 fschmid 1765
                                        {
14297 fschmid 1766
                                                p->setPattern(&m_Doc->docPatterns[patternVal], patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation, patternSkewX, patternSkewY, patternMirrorX, patternMirrorY);
1767
                                                p->setFillMode(ScPainter::Pattern);
12215 fschmid 1768
                                        }
6368 fschmid 1769
                                }
1770
                                else
1771
                                {
14952 fschmid 1772
                                        if (GrType == 9)
14297 fschmid 1773
                                        {
14952 fschmid 1774
                                                p->setFillMode(ScPainter::Gradient);
1775
                                                FPoint pG1 = FPoint(0, 0);
1776
                                                FPoint pG2 = FPoint(width(), 0);
1777
                                                FPoint pG3 = FPoint(width(), height());
1778
                                                FPoint pG4 = FPoint(0, height());
1779
                                                p->set4ColorGeometry(pG1, pG2, pG3, pG4, GrControl1, GrControl2, GrControl3, GrControl4);
1780
                                                p->set4ColorColors(GrColorP1QColor, GrColorP2QColor, GrColorP3QColor, GrColorP4QColor);
14297 fschmid 1781
                                        }
18935 fschmid 1782
                                        else if (GrType == 14)
1783
                                        {
1784
                                                if (fillColor() != CommonStrings::None)
1785
                                                        p->setBrush(fillQColor);
1786
                                                p->setFillMode(ScPainter::Hatch);
1787
                                                p->setHatchParameters(hatchType, hatchDistance, hatchAngle, hatchUseBackground, hatchBackgroundQ, hatchForegroundQ, width(), height());
1788
                                        }
14297 fschmid 1789
                                        else
1790
                                        {
14952 fschmid 1791
                                                if ((!gradientVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientVal)))
1792
                                                        gradientVal = "";
1793
                                                if (!(gradientVal.isEmpty()) && (m_Doc->docGradients.contains(gradientVal)))
1794
                                                        fill_gradient = m_Doc->docGradients[gradientVal];
15024 fschmid 1795
                                                if ((fill_gradient.Stops() < 2) && (GrType < 9)) // fall back to solid filling if there are not enough colorstops in the gradient.
14297 fschmid 1796
                                                {
14952 fschmid 1797
                                                        if (fillColor() != CommonStrings::None)
1798
                                                        {
1799
                                                                p->setBrush(fillQColor);
1800
                                                                p->setFillMode(ScPainter::Solid);
1801
                                                        }
1802
                                                        else
17394 fschmid 1803
                                                        {
1804
                                                                no_fill = true;
14952 fschmid 1805
                                                                p->setFillMode(ScPainter::None);
17394 fschmid 1806
                                                        }
14297 fschmid 1807
                                                }
14952 fschmid 1808
                                                else
1809
                                                {
1810
                                                        p->setFillMode(ScPainter::Gradient);
1811
                                                        p->fill_gradient = fill_gradient;
19163 fschmid 1812
                                                        p->fill_gradient.setRepeatMethod(GrExtend);
14952 fschmid 1813
                                                        switch (GrType)
1814
                                                        {
1815
                                                                case 1:
1816
                                                                case 2:
1817
                                                                case 3:
1818
                                                                case 4:
1819
                                                                case 6:
1820
                                                                        p->setGradient(VGradient::linear, FPoint(GrStartX, GrStartY), FPoint(GrEndX, GrEndY), FPoint(GrStartX, GrStartY), GrScale, GrSkew);
1821
                                                                        break;
1822
                                                                case 5:
1823
                                                                case 7:
1824
                                                                        p->setGradient(VGradient::radial, FPoint(GrStartX, GrStartY), FPoint(GrEndX, GrEndY), FPoint(GrFocalX, GrFocalY), GrScale, GrSkew);
1825
                                                                        break;
14981 fschmid 1826
                                                                case 10:
1827
                                                                        p->setFillMode(ScPainter::Gradient);
15024 fschmid 1828
                                                                        p->setDiamondGeometry(FPoint(0, 0), FPoint(width(), 0), FPoint(width(), height()), FPoint(0, height()), GrControl1, GrControl2, GrControl3, GrControl4, GrControl5);
14981 fschmid 1829
                                                                        break;
15024 fschmid 1830
                                                                case 11:
16786 fschmid 1831
                                                                case 13:
15024 fschmid 1832
                                                                        p->setFillMode(ScPainter::Gradient);
1833
                                                                        p->setMeshGradient(FPoint(0, 0), FPoint(width(), 0), FPoint(width(), height()), FPoint(0, height()), meshGradientArray);
1834
                                                                        break;
16729 fschmid 1835
                                                                case 12:
1836
                                                                        p->setFillMode(ScPainter::Gradient);
1837
                                                                        p->setMeshGradient(FPoint(0, 0), FPoint(width(), 0), FPoint(width(), height()), FPoint(0, height()), meshGradientPatches);
1838
                                                                        break;
14952 fschmid 1839
                                                        }
1840
                                                }
14297 fschmid 1841
                                        }
6368 fschmid 1842
                                }
5572 fschmid 1843
                        }
6368 fschmid 1844
                        else
1845
                        {
14297 fschmid 1846
                                p->fill_gradient = VGradient(VGradient::linear);
1847
                                if (fillColor() != CommonStrings::None)
6368 fschmid 1848
                                {
14297 fschmid 1849
                                        p->setBrush(fillQColor);
1850
                                        p->setFillMode(ScPainter::Solid);
7684 fschmid 1851
                                }
1852
                                else
17394 fschmid 1853
                                {
1854
                                        no_fill = true;
14297 fschmid 1855
                                        p->setFillMode(ScPainter::None);
17394 fschmid 1856
                                }
6368 fschmid 1857
                        }
14297 fschmid 1858
                        if ((lineColor() != CommonStrings::None) || (!patternStrokeVal.isEmpty()) || (GrTypeStroke > 0))
5572 fschmid 1859
                        {
18729 fschmid 1860
                                p->setPen(strokeQColor, lwCorr, PLineArt, PLineEnd, PLineJoin);
14297 fschmid 1861
                                if (DashValues.count() != 0)
1862
                                        p->setDash(DashValues, DashOffset);
5572 fschmid 1863
                        }
1864
                        else
14297 fschmid 1865
                                p->setLineWidth(0);
14306 fschmid 1866
                        p->setBrushOpacity(1.0 - fillTransparency());
1867
                        p->setPenOpacity(1.0 - lineTransparency());
14297 fschmid 1868
                        p->setFillRule(fillRule);
14318 fschmid 1869
                        if ((GrMask == 1) || (GrMask == 2) || (GrMask == 4) || (GrMask == 5))
14297 fschmid 1870
                        {
14318 fschmid 1871
                                if ((GrMask == 1) || (GrMask == 2))
1872
                                        p->setMaskMode(1);
1873
                                else
1874
                                        p->setMaskMode(3);
14300 fschmid 1875
                                if ((!gradientMaskVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientMaskVal)))
1876
                                        gradientMaskVal = "";
1877
                                if (!(gradientMaskVal.isEmpty()) && (m_Doc->docGradients.contains(gradientMaskVal)))
1878
                                        mask_gradient = m_Doc->docGradients[gradientMaskVal];
14297 fschmid 1879
                                p->mask_gradient = mask_gradient;
14318 fschmid 1880
                                if ((GrMask == 1) || (GrMask == 4))
14297 fschmid 1881
                                        p->setGradientMask(VGradient::linear, FPoint(GrMaskStartX, GrMaskStartY), FPoint(GrMaskEndX, GrMaskEndY), FPoint(GrMaskStartX, GrMaskStartY), GrMaskScale, GrMaskSkew);
1882
                                else
1883
                                        p->setGradientMask(VGradient::radial, FPoint(GrMaskStartX, GrMaskStartY), FPoint(GrMaskEndX, GrMaskEndY), FPoint(GrMaskFocalX, GrMaskFocalY), GrMaskScale, GrMaskSkew);
1884
                        }
16732 fschmid 1885
                        else if ((GrMask == 3) || (GrMask == 6) || (GrMask == 7) || (GrMask == 8))
14308 fschmid 1886
                        {
1887
                                if ((patternMaskVal.isEmpty()) || (!m_Doc->docPatterns.contains(patternMaskVal)))
1888
                                        p->setMaskMode(0);
1889
                                else
1890
                                {
1891
                                        p->setPatternMask(&m_Doc->docPatterns[patternMaskVal], patternMaskScaleX, patternMaskScaleY, patternMaskOffsetX, patternMaskOffsetY, patternMaskRotation, patternMaskSkewX, patternMaskSkewY, patternMaskMirrorX, patternMaskMirrorY);
14318 fschmid 1892
                                        if (GrMask == 3)
1893
                                                p->setMaskMode(2);
16732 fschmid 1894
                                        else if (GrMask == 6)
1895
                                                p->setMaskMode(4);
1896
                                        else if (GrMask == 7)
1897
                                                p->setMaskMode(5);
14318 fschmid 1898
                                        else
16732 fschmid 1899
                                                p->setMaskMode(6);
14308 fschmid 1900
                                }
1901
                        }
14297 fschmid 1902
                        else
1903
                                p->setMaskMode(0);
1741 cbradney 1904
                }
7549 fschmid 1905
        }
1740 cbradney 1906
}
1907
 
2434 fschmid 1908
void PageItem::DrawObj_Post(ScPainter *p)
1740 cbradney 1909
{
1910
        bool doStroke=true;
18729 fschmid 1911
        double lwCorr = m_lineWidth;
1912
        double sc = p->zoomFactor();
1913
        if ((m_lineWidth * sc) < 1)
1914
                lwCorr = 0;
16899 fschmid 1915
        if (m_Doc->layerOutline(LayerID))
1740 cbradney 1916
        {
16899 fschmid 1917
                if (itemType()!=Line)
1740 cbradney 1918
                {
18729 fschmid 1919
                        p->setPen(m_Doc->layerMarker(LayerID), 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
16899 fschmid 1920
                        p->setFillMode(ScPainter::None);
1921
                        p->setBrushOpacity(1.0);
1922
                        p->setPenOpacity(1.0);
1923
                        if (itemType()==PolyLine)
1924
                                p->setupPolygon(&PoLine, false);
1925
                        else if (itemType() == PathText)
5582 fschmid 1926
                        {
16899 fschmid 1927
                                if (PoShow)
5582 fschmid 1928
                                        p->setupPolygon(&PoLine, false);
16899 fschmid 1929
                                else
1930
                                        doStroke = false;
1931
                        }
1932
                        else
1933
                                p->setupPolygon(&PoLine);
1934
                        if (doStroke)
1935
                                p->strokePath();
1936
                        if (itemType()==ImageFrame)
1937
                        {
1938
                                if (imageClip.size() != 0)
7549 fschmid 1939
                                {
16899 fschmid 1940
                                        p->setupPolygon(&imageClip);
7549 fschmid 1941
                                        p->strokePath();
5584 fschmid 1942
                                }
1943
                        }
1740 cbradney 1944
                }
16899 fschmid 1945
        }
1946
        else
1947
        {
1948
                if (!isGroup())
7549 fschmid 1949
                {
14308 fschmid 1950
                        p->setBlendModeFill(0);
14298 fschmid 1951
                        p->setMaskMode(0);
16856 craig 1952
                        // TODO: Investigate whether itemType()==Table should really be here. I got artifacts without it so keeping it here for now. /estan
1953
                        if (itemType()==PathText || itemType()==PolyLine || itemType()==Spiral || itemType()==Line || itemType()==Symbol || itemType()==Group || itemType()==Table)
7549 fschmid 1954
                                doStroke=false;
1955
                        if ((doStroke) && (!m_Doc->RePos))
1956
                        {
14306 fschmid 1957
                                p->setBlendModeStroke(lineBlendmode());
1958
                                p->setPenOpacity(1.0 - lineTransparency());
14197 fschmid 1959
                                if ((lineColor() != CommonStrings::None) || (!patternStrokeVal.isEmpty()) || (GrTypeStroke > 0))
14168 fschmid 1960
                                {
18729 fschmid 1961
                                        p->setPen(strokeQColor, lwCorr, PLineArt, PLineEnd, PLineJoin);
14168 fschmid 1962
                                        if (DashValues.count() != 0)
1963
                                                p->setDash(DashValues, DashOffset);
1964
                                }
1965
                                else
1966
                                        p->setLineWidth(0);
17418 fschmid 1967
                                if ((itemType() == LatexFrame) || (itemType() == ImageFrame) || (itemType() == OSGFrame))
1968
                                        p->setupPolygon(&PoLine);
1969
                                if (NamedLStyle.isEmpty())
1740 cbradney 1970
                                {
17418 fschmid 1971
                                        if ((!patternStrokeVal.isEmpty()) && (m_Doc->docPatterns.contains(patternStrokeVal)))
13013 fschmid 1972
                                        {
17418 fschmid 1973
                                                if (patternStrokePath)
13013 fschmid 1974
                                                {
17418 fschmid 1975
                                                        QPainterPath guidePath = PoLine.toQPainterPath(false);
1976
                                                        DrawStrokePattern(p, guidePath);
14168 fschmid 1977
                                                }
17418 fschmid 1978
                                                else
14197 fschmid 1979
                                                {
17418 fschmid 1980
                                                        p->setPattern(&m_Doc->docPatterns[patternStrokeVal], patternStrokeScaleX, patternStrokeScaleY, patternStrokeOffsetX, patternStrokeOffsetY, patternStrokeRotation, patternStrokeSkewX, patternStrokeSkewY, patternStrokeMirrorX, patternStrokeMirrorY);
1981
                                                        p->setStrokeMode(ScPainter::Pattern);
1982
                                                        p->strokePath();
1983
                                                }
1984
                                        }
1985
                                        else if (GrTypeStroke > 0)
1986
                                        {
1987
                                                if ((!gradientStrokeVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientStrokeVal)))
1988
                                                        gradientStrokeVal = "";
1989
                                                if (!(gradientStrokeVal.isEmpty()) && (m_Doc->docGradients.contains(gradientStrokeVal)))
1990
                                                        stroke_gradient = m_Doc->docGradients[gradientStrokeVal];
1991
                                                if (stroke_gradient.Stops() < 2) // fall back to solid stroking if there are not enough colorstops in the gradient.
1992
                                                {
1993
                                                        if (lineColor() != CommonStrings::None)
14197 fschmid 1994
                                                        {
17418 fschmid 1995
                                                                p->setBrush(strokeQColor);
1996
                                                                p->setStrokeMode(ScPainter::Solid);
14197 fschmid 1997
                                                        }
1998
                                                        else
1999
                                                        {
17418 fschmid 2000
                                                                no_stroke = true;
2001
                                                                p->setStrokeMode(ScPainter::None);
14197 fschmid 2002
                                                        }
2003
                                                }
17418 fschmid 2004
                                                else
14168 fschmid 2005
                                                {
17418 fschmid 2006
                                                        p->setStrokeMode(ScPainter::Gradient);
2007
                                                        p->stroke_gradient = stroke_gradient;
19163 fschmid 2008
                                                        p->stroke_gradient.setRepeatMethod(GrStrokeExtend);
17418 fschmid 2009
                                                        if (GrTypeStroke == 6)
2010
                                                                p->setGradient(VGradient::linear, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeStartX, GrStrokeStartY), GrStrokeScale, GrStrokeSkew);
2011
                                                        else
2012
                                                                p->setGradient(VGradient::radial, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeFocalX, GrStrokeFocalY), GrStrokeScale, GrStrokeSkew);
13013 fschmid 2013
                                                }
17418 fschmid 2014
                                                p->strokePath();
13013 fschmid 2015
                                        }
17418 fschmid 2016
                                        else if (lineColor() != CommonStrings::None)
2017
                                        {
2018
                                                p->setStrokeMode(ScPainter::Solid);
18729 fschmid 2019
                                                p->setPen(strokeQColor, lwCorr, PLineArt, PLineEnd, PLineJoin);
17418 fschmid 2020
                                                if (DashValues.count() != 0)
2021
                                                        p->setDash(DashValues, DashOffset);
2022
                                                p->strokePath();
2023
                                        }
7549 fschmid 2024
                                        else
17418 fschmid 2025
                                                no_stroke = true;
18732 fschmid 2026
                                        if (lineTransparency() > 0.9)
2027
                                                no_stroke = true;
17418 fschmid 2028
                                }
2029
                                else
2030
                                {
2031
                                        p->setStrokeMode(ScPainter::Solid);
2032
                                        multiLine ml = m_Doc->MLineStyles[NamedLStyle];
2033
                                        QColor tmp;
2034
                                        for (int it = ml.size()-1; it > -1; it--)
5572 fschmid 2035
                                        {
17418 fschmid 2036
                                                struct SingleLine& sl = ml[it];
2037
                                                // Qt4 if ((!sl.Color != CommonStrings::None) && (sl.Width != 0))
2038
                                                if (sl.Color != CommonStrings::None) // && (sl.Width != 0))
6568 fschmid 2039
                                                {
17418 fschmid 2040
                                                        SetQColor(&tmp, sl.Color, sl.Shade);
2041
                                                        p->setPen(tmp, sl.Width, static_cast<Qt::PenStyle>(sl.Dash), static_cast<Qt::PenCapStyle>(sl.LineEnd), static_cast<Qt::PenJoinStyle>(sl.LineJoin));
2042
                                                        p->strokePath();
6568 fschmid 2043
                                                }
5572 fschmid 2044
                                        }
1740 cbradney 2045
                                }
14308 fschmid 2046
                                p->setBlendModeStroke(0);
7549 fschmid 2047
                        }
5746 fschmid 2048
                }
1740 cbradney 2049
        }
14208 fschmid 2050
        p->setFillMode(ScPainter::Solid);
14469 fschmid 2051
        p->setBlendModeFill(0);
14208 fschmid 2052
        p->setStrokeMode(ScPainter::Solid);
14469 fschmid 2053
        p->setBlendModeStroke(0);
14681 fschmid 2054
        p->restore();
2055
}
2056
 
2057
void PageItem::DrawObj_Decoration(ScPainter *p)
2058
{
2059
        p->save();
18079 fschmid 2060
        p->setAntialiasing(false);
14681 fschmid 2061
        if (!isEmbedded)
18032 craig 2062
                p->translate(m_xPos, m_yPos);
18022 craig 2063
        p->rotate(m_rotation);
4084 cbradney 2064
        if ((!isEmbedded) && (!m_Doc->RePos))
2434 fschmid 2065
        {
17790 fschmid 2066
                double scpInv = 0;
16105 fschmid 2067
                if (!isGroup())
1740 cbradney 2068
                {
18007 craig 2069
                        if ((drawFrame()) && (m_Doc->guidesPrefs().framesShown) && ((itemType() == ImageFrame) || (itemType() == LatexFrame) || (itemType() == OSGFrame) || (itemType() == PathText)) && (no_stroke))
3919 fschmid 2070
                        {
13974 cbradney 2071
                                p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameNormColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 2072
                                if ((isBookmark) || (m_isAnnotation))
13974 cbradney 2073
                                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameAnnotationColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 2074
                                if ((BackBox != 0) || (NextBox != 0))
13974 cbradney 2075
                                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameLinkColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 2076
                                if (m_Locked)
13974 cbradney 2077
                                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameLockColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 2078
                                p->setFillMode(0);
2079
                                if (itemType()==PathText)
3919 fschmid 2080
                                {
7549 fschmid 2081
                                        if (Clip.count() != 0)
3919 fschmid 2082
                                        {
7549 fschmid 2083
                                                FPointArray tclip;
2084
                                                FPoint np = FPoint(Clip.point(0));
2085
                                                tclip.resize(2);
2086
                                                tclip.setPoint(0, np);
2087
                                                tclip.setPoint(1, np);
8557 subik 2088
                                                for (int a = 1; a < Clip.size(); ++a)
7549 fschmid 2089
                                                {
2090
                                                        np = FPoint(Clip.point(a));
2091
                                                        tclip.putPoints(tclip.size(), 4, np.x(), np.y(), np.x(), np.y(), np.x(), np.y(), np.x(), np.y());
2092
                                                }
2093
                                                np = FPoint(Clip.point(0));
2094
                                                tclip.putPoints(tclip.size(), 2, np.x(), np.y(), np.x(), np.y());
2095
                                                p->setupPolygon(&tclip);
3919 fschmid 2096
                                        }
2097
                                }
12004 fschmid 2098
                                else
17790 fschmid 2099
                                        p->setupSharpPolygon(&PoLine);
7549 fschmid 2100
                                p->strokePath();
3919 fschmid 2101
                        }
1740 cbradney 2102
                }
14932 cbradney 2103
                if ((m_Doc->guidesPrefs().framesShown) && textFlowUsesContourLine() && (ContourLine.size() != 0))
8494 fschmid 2104
                {
17790 fschmid 2105
                        p->setPen(Qt::darkGray, 0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin);
2106
                        p->setupSharpPolygon(&ContourLine);
8494 fschmid 2107
                        p->strokePath();
2108
                }
14808 fschmid 2109
                if (itemType()==ImageFrame)
2110
                {
14971 cbradney 2111
                        double minres = m_Doc->checkerProfiles()[m_Doc->curCheckProfile()].minResolution;
2112
                        double maxres = m_Doc->checkerProfiles()[m_Doc->curCheckProfile()].maxResolution;
2113
                        bool checkres = m_Doc->checkerProfiles()[m_Doc->curCheckProfile()].checkResolution;
17224 craig 2114
                        if  ((((72.0 / imageXScale()) < minres)
14808 fschmid 2115
                                || ((72.0 / imageYScale()) < minres)
2116
                                || ((72.0 / imageXScale()) > maxres)
2117
                                || ((72.0 / imageYScale()) > maxres))
16177 fschmid 2118
                                && (isRaster) && (checkres) && (!m_Doc->drawAsPreview) && (PrefsManager::instance()->appPrefs.displayPrefs.showVerifierWarningsOnCanvas))
14808 fschmid 2119
                        {
18095 craig 2120
                                double ofx = m_width - 22.0;
2121
                                double ofy = m_height - 22.0;
18983 fschmid 2122
                                if ((m_width > 40) && (m_height > 40))
2123
                                {
2124
                                        p->save();
2125
                                        p->translate(ofx, ofy);
2126
                                        QImage ico = loadIcon("22/dialog-warning.png").toImage();
2127
                                        p->drawImage(&ico);
2128
                                        p->restore();
2129
                                }
14808 fschmid 2130
                        }
2131
                }
19261 craig 2132
                if ((m_Doc->guidesPrefs().layerMarkersShown) &&
2133
                        (m_Doc->layerCount() > 1) &&
2134
                        (!m_Doc->layerOutline(LayerID)) &&
19354 craig 2135
                        (!isGroupChild()) &&
19261 craig 2136
                        (!m_Doc->drawAsPreview))
1740 cbradney 2137
                {
17790 fschmid 2138
                        p->setPen(Qt::black, 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5619 fschmid 2139
                        p->setPenOpacity(1.0);
13875 jghali 2140
                        p->setBrush(m_Doc->layerMarker(LayerID));
5619 fschmid 2141
                        p->setBrushOpacity(1.0);
5572 fschmid 2142
                        p->setFillMode(ScPainter::Solid);
5584 fschmid 2143
                        double ofwh = 10;
18095 craig 2144
                        double ofx = m_width - ofwh/2;
2145
                        double ofy = m_height - ofwh*3;
17790 fschmid 2146
                        p->drawSharpRect(ofx, ofy, ofwh, ofwh);
5572 fschmid 2147
                }
17394 fschmid 2148
                if (no_fill && no_stroke && m_Doc->guidesPrefs().framesShown)
2149
                {
2150
                  &nb