Subversion Repositories Scribus

Rev

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