Subversion Repositories Scribus

Rev

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