Subversion Repositories Scribus

Rev

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