Subversion Repositories Scribus

Rev

Rev 18454 | Rev 18524 | 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
 
18357 jghali 882
int PageItem::level() const
17092 jghali 883
{
18357 jghali 884
        PageItem* thisItem = const_cast<PageItem*>(this);
17092 jghali 885
        if (Parent == NULL)
886
        {
887
                if (m_Doc)
888
                {
889
                        QList<PageItem*>* items = OnMasterPage.isEmpty() ? &m_Doc->DocItems : &m_Doc->MasterItems;
18357 jghali 890
                        return (items->indexOf(thisItem) + 1);
17092 jghali 891
                }
892
                return 0;
893
        }
18357 jghali 894
        return (Parent->asGroupFrame()->groupItemList.indexOf(thisItem) + 1);
17092 jghali 895
}
896
 
4644 cbradney 897
void PageItem::moveBy(const double dX, const double dY, bool drawingOnly)
3934 cbradney 898
{
899
        if (dX==0.0 && dY==0.0)
900
                return;
12820 pierre 901
        invalid = true;
3903 cbradney 902
        if (dX!=0.0)
16115 fschmid 903
        {
18032 craig 904
                m_xPos+=dX;
16115 fschmid 905
                gXpos+=dX;
906
        }
3903 cbradney 907
        if (dY!=0.0)
16115 fschmid 908
        {
18032 craig 909
                m_yPos+=dY;
16115 fschmid 910
                gYpos+=dY;
911
        }
4644 cbradney 912
        if (drawingOnly || m_Doc->isLoading())
913
                return;
17826 craig 914
        moveWelded(dX, dY);
4621 cbradney 915
        checkChanges();
3903 cbradney 916
}
917
 
3934 cbradney 918
void PageItem::setWidth(const double newWidth)
919
{
18095 craig 920
        m_width = newWidth;
13013 fschmid 921
        updateConstants();
14681 fschmid 922
        if (m_Doc->isLoading())
923
                return;
4621 cbradney 924
        checkChanges();
3934 cbradney 925
}
926
 
927
void PageItem::setHeight(const double newHeight)
928
{
18095 craig 929
        m_height = newHeight;
13013 fschmid 930
        updateConstants();
14681 fschmid 931
        if (m_Doc->isLoading())
932
                return;
4621 cbradney 933
        checkChanges();
3934 cbradney 934
}
935
 
8418 fschmid 936
void PageItem::setWidthHeight(const double newWidth, const double newHeight, bool drawingOnly)
937
{
18095 craig 938
        m_width = newWidth;
939
        m_height = newHeight;
13013 fschmid 940
        updateConstants();
8418 fschmid 941
        if (drawingOnly)
942
                return;
943
        checkChanges();
944
}
945
 
3934 cbradney 946
void PageItem::setWidthHeight(const double newWidth, const double newHeight)
947
{
18095 craig 948
        m_width = newWidth;
949
        m_height = newHeight;
13013 fschmid 950
        updateConstants();
14681 fschmid 951
        if (m_Doc->isLoading())
952
                return;
4621 cbradney 953
        checkChanges();
3934 cbradney 954
}
955
 
956
void PageItem::resizeBy(const double dH, const double dW)
957
{
958
        if (dH==0.0 && dW==0.0)
959
                return;
960
        if (dH!=0.0)
18095 craig 961
                m_width+=dH;
3934 cbradney 962
        if (dW!=0.0)
18095 craig 963
                m_height+=dW;
13013 fschmid 964
        updateConstants();
14681 fschmid 965
        if (m_Doc->isLoading())
966
                return;
4621 cbradney 967
        checkChanges();
3934 cbradney 968
}
969
 
4663 cbradney 970
void PageItem::setRotation(const double newRotation, bool drawingOnly)
3934 cbradney 971
{
18022 craig 972
        double dR = newRotation - m_rotation;
973
        double oldRot = m_rotation;
974
        m_rotation = newRotation;
4663 cbradney 975
        if (drawingOnly || m_Doc->isLoading())
976
                return;
17826 craig 977
        rotateWelded(dR, oldRot);
14681 fschmid 978
        checkChanges();
3934 cbradney 979
}
980
 
981
void PageItem::rotateBy(const double dR)
982
{
983
        if (dR==0.0)
984
                return;
18022 craig 985
        m_rotation+=dR;
14681 fschmid 986
        if (m_Doc->isLoading())
987
                return;
4621 cbradney 988
        checkChanges();
3934 cbradney 989
}
990
 
991
void PageItem::setSelected(const bool toSelect)
992
{
18022 craig 993
        m_isSelected=toSelect;
3934 cbradney 994
}
995
 
3988 cbradney 996
void PageItem::setImageXScale(const double newImageXScale)
3985 cbradney 997
{
18022 craig 998
        m_imageXScale=newImageXScale;
14681 fschmid 999
        if (m_Doc->isLoading())
1000
                return;
4821 cbradney 1001
        checkChanges();
3985 cbradney 1002
}
1003
 
1004
void PageItem::setImageYScale(const double newImageYScale)
1005
{
18022 craig 1006
        m_imageYScale=newImageYScale;
14681 fschmid 1007
        if (m_Doc->isLoading())
1008
                return;
4821 cbradney 1009
        checkChanges();
3985 cbradney 1010
}
1011
 
1012
void PageItem::setImageXYScale(const double newImageXScale, const double newImageYScale)
1013
{
18022 craig 1014
        m_imageXScale=newImageXScale;
1015
        m_imageYScale=newImageYScale;
14681 fschmid 1016
        if (m_Doc->isLoading())
1017
                return;
4821 cbradney 1018
        checkChanges();
3985 cbradney 1019
}
1020
 
3988 cbradney 1021
void PageItem::setImageXOffset(const double newImageXOffset)
3985 cbradney 1022
{
18032 craig 1023
        m_imageXOffset=newImageXOffset;
14681 fschmid 1024
        if (m_Doc->isLoading())
1025
                return;
4821 cbradney 1026
        checkChanges();
3985 cbradney 1027
}
1028
 
1029
void PageItem::setImageYOffset(const double newImageYOffset)
1030
{
18032 craig 1031
        m_imageYOffset=newImageYOffset;
14681 fschmid 1032
        if (m_Doc->isLoading())
1033
                return;
4821 cbradney 1034
        checkChanges();
3985 cbradney 1035
}
1036
 
1037
void PageItem::setImageXYOffset(const double newImageXOffset, const double newImageYOffset)
1038
{
18032 craig 1039
        m_imageXOffset=newImageXOffset;
1040
        m_imageYOffset=newImageYOffset;
14681 fschmid 1041
        if (m_Doc->isLoading())
1042
                return;
4821 cbradney 1043
        checkChanges();
3985 cbradney 1044
}
1045
 
1046
void PageItem::moveImageXYOffsetBy(const double dX, const double dY)
1047
{
1048
        if (dX==0.0 && dY==0.0)
1049
                return;
16703 jghali 1050
        if (dX != 0.0)
18032 craig 1051
                m_imageXOffset += dX;
16703 jghali 1052
        if (dY != 0.0)
18032 craig 1053
                m_imageYOffset += dY;
14681 fschmid 1054
        if (m_Doc->isLoading())
1055
                return;
4821 cbradney 1056
        checkChanges();
3985 cbradney 1057
}
1058
 
14861 fschmid 1059
void PageItem::setImageRotation(const double newRotation)
1060
{
18022 craig 1061
        if(m_imageRotation == newRotation)
17709 craig 1062
                return;
17744 craig 1063
        if(UndoManager::undoEnabled())
1064
        {
1065
                SimpleState *ss = new SimpleState(Um::Rotate,"",Um::IRotate);
1066
                ss->set("IMAGE_ROTATION","image_rotation");
18022 craig 1067
                ss->set("OLD_ROT",m_imageRotation);
17744 craig 1068
                ss->set("NEW_ROT",newRotation);
1069
                undoManager->action(this,ss);
1070
        }
18022 craig 1071
        m_imageRotation = newRotation;
14861 fschmid 1072
        if (m_Doc->isLoading())
1073
                return;
1074
        checkChanges();
1075
}
1076
 
3988 cbradney 1077
void PageItem::setReversed(bool newReversed)
1078
{
18022 craig 1079
        if (m_isReversed == newReversed)
16703 jghali 1080
                return;
16609 craig 1081
        if (UndoManager::undoEnabled())
1082
        {
1083
                SimpleState *ss = new SimpleState(Um::FlipH, 0, Um::IFlipH);
16703 jghali 1084
                ss->set("REVERSE_TEXT", newReversed);
16609 craig 1085
                undoManager->action(this, ss);
1086
        }
18022 craig 1087
        m_isReversed = newReversed;
3988 cbradney 1088
}
3985 cbradney 1089
 
16621 craig 1090
//return frame where is text end
1091
PageItem * PageItem::frameTextEnd()
1092
{
1093
        PageItem * LastBox = this;
1094
        if (frameOverflows() && NextBox)
1095
        { // text ending in some next frame
1096
                LastBox = NextBox;
1097
                while (LastBox != 0 && !LastBox->frameDisplays(itemText.length()-1))
1098
                        LastBox = LastBox->nextInChain();
1099
        }
1100
        else if (frameUnderflows() && BackBox)
1101
        { //text ending in some previous frame
1102
                LastBox = BackBox;
1103
                while (LastBox != 0 && !LastBox->frameDisplays(itemText.length()-1))
1104
                        LastBox = LastBox->prevInChain();
1105
        }
1106
        return LastBox;
1107
}
5559 avox 1108
 
1109
/// returns true if text overflows
1110
bool PageItem::frameOverflows() const
1111
{
1112
#ifndef NLS_PROTO
12414 jghali 1113
        // Fix #6991 : "Text overflow" warning when there is a text underflow in fact
1114
        /*return NextBox == NULL && itemText.length() > static_cast<int>(MaxChars);*/
12820 pierre 1115
        return ( NextBox == NULL )
1116
               && ( static_cast<int> ( firstChar ) < itemText.length() )
13131 jghali 1117
                   // Fix #7766 : scribus.textOverflows() returns 0 if there is no place for the overflow mark
1118
               /*&& ( firstChar < MaxChars )*/
1119
                   && ( firstChar <= MaxChars )
12820 pierre 1120
               && ( itemText.length() > static_cast<int> ( MaxChars ) );
5559 avox 1121
#else
1122
        return false; // FIXME:NLS
1123
#endif
1124
}
1125
 
16845 craig 1126
int PageItem::frameOverflowCount() const
1127
{
1128
        if (frameOverflows())
1129
                return itemText.length()-MaxChars;
1130
        return 0;
1131
}
1132
 
17100 fschmid 1133
int PageItem::maxCharsInFrame()
1134
{
1135
        return MaxChars;
1136
}
1137
 
16621 craig 1138
/// returns true if text is ending before that frame
1139
bool PageItem::frameUnderflows() const
1140
{
1141
        if (BackBox == NULL)
1142
                return false;
1143
        //FIX ME - I have found that condition if frame is empty
1144
        //and has been linked with previous frame
1145
        //if you will find any better solution - fix that function
1146
        return (firstInFrame() > lastInFrame());
1147
}
1148
 
16856 craig 1149
void PageItem::drawOverflowMarker(ScPainter *p)
1150
{
1151
        qreal sideLength = 10 / qMax(p->zoomFactor(), 1.0);
1152
        qreal offset = 1 / qMax(p->zoomFactor(), 1.0);
18095 craig 1153
        qreal left = m_width - sideLength-offset;// / 2;
16856 craig 1154
        qreal right = left + sideLength;
18095 craig 1155
        qreal top = m_height - sideLength-offset;// * 1.5;
16856 craig 1156
        qreal bottom = top + sideLength;
1157
 
1158
        QColor color(PrefsManager::instance()->appPrefs.displayPrefs.frameNormColor);
1159
        if ((isBookmark) || (m_isAnnotation))
1160
                color = PrefsManager::instance()->appPrefs.displayPrefs.frameAnnotationColor;
1161
        if ((BackBox != 0) || (NextBox != 0))
1162
                color = PrefsManager::instance()->appPrefs.displayPrefs.frameLinkColor;
1163
        if (m_Locked)
1164
                color = PrefsManager::instance()->appPrefs.displayPrefs.frameLockColor;
1165
        if (m_Doc->m_Selection->containsItem(this))
1166
                color = Qt::red;
1167
 
1168
        p->save();
1169
 
17790 fschmid 1170
        p->setPen(color, 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
16856 craig 1171
        p->setPenOpacity(1.0);
1172
        p->setBrush(Qt::white);
1173
        p->setBrushOpacity(1.0);
1174
        p->setFillMode(ScPainter::Solid);
17790 fschmid 1175
        p->drawSharpRect(left, top, sideLength, sideLength);
1176
        p->drawSharpLine(QPointF(left, top), QPointF(right, bottom));
1177
        p->drawSharpLine(QPointF(left, bottom), QPointF(right, top));
16856 craig 1178
 
1179
        p->restore();
1180
}
1181
 
5559 avox 1182
int PageItem::firstInFrame() const
1183
{
5721 avox 1184
        return firstChar;
5559 avox 1185
}
1186
int PageItem::lastInFrame() const
1187
{
1188
#ifndef NLS_PROTO
8562 jghali 1189
        return qMin(signed(MaxChars), itemText.length()) - 1;
5559 avox 1190
#else
1191
        return itemText.length() - 1;
1192
#endif
1193
}
1194
 
16589 jghali 1195
bool PageItem::testLinkCandidate(PageItem* nxt)
1196
{
1197
        if (this->nextInChain() )
1198
                return false;
18338 jghali 1199
        if (!nxt || nxt->prevInChain() )
16589 jghali 1200
                return false;
1201
        for (PageItem* ff=nxt; ff; ff=ff->nextInChain())
1202
        {
1203
                if (ff == this) return false;
1204
        }
1205
        return true;
1206
}
7994 avox 1207
 
17708 craig 1208
void PageItem::link(PageItem* nxt, bool addPARSEP)
7994 avox 1209
{
1210
        assert( !nextInChain() );
1211
        assert( !nxt->prevInChain() );
8075 avox 1212
        for (PageItem* ff=nxt; ff; ff=ff->nextInChain())
1213
        {
1214
                assert (ff != this);
1215
        }
13655 jghali 1216
        // Append only if necessary to avoid the
1217
        // charstyle: access at end of text warning
17708 craig 1218
        bool first = false;
1219
        bool createUndo = addPARSEP;
1220
 
1221
        if (nxt->prevInChain() == NULL)
1222
                first = true;
1223
        int textLen = itemText.length();
13655 jghali 1224
        if (nxt->itemText.length() > 0)
17708 craig 1225
        {   //case when text will be joined with next frame text
1226
                //do not add PARSEP if first frame has no text or text ends already with PARSEP
1227
                if (addPARSEP && (textLen > 0) && (itemText.text(textLen-1) != SpecialChars::PARSEP))
1228
                        itemText.insertChars(textLen, SpecialChars::PARSEP);
1229
                else
1230
                        addPARSEP = false;
13655 jghali 1231
                itemText.append(nxt->itemText);
17708 craig 1232
        }
7994 avox 1233
        NextBox = nxt;
1234
        nxt->BackBox = this;
8325 avox 1235
        // update AutoText
1236
        if (isAutoText)
1237
        {
1238
                PageItem* after = nxt;
1239
                while (after)
1240
                {
1241
                        after->isAutoText = true;
1242
                        m_Doc->LastAuto = after;
1243
                        after = after->NextBox;
1244
                }
1245
        }
1246
        else if (nxt->isAutoText)
1247
        {
1248
                PageItem* before = this;
1249
                while (before)
1250
                {
1251
                        before->isAutoText = true;
1252
                        m_Doc->FirstAuto = before;
1253
                        before = before->BackBox;
1254
                }
1255
        }
7994 avox 1256
        invalid = true;
8325 avox 1257
        while (nxt)
1258
        {
9490 avox 1259
                nxt->itemText = itemText;
8325 avox 1260
                nxt->invalid = true;
1261
                nxt->firstChar = 0;
1262
                nxt = nxt->NextBox;
1263
        }
17708 craig 1264
        if (UndoManager::undoEnabled() && createUndo) //addPARESEP is false only if linking is invoked from undo action for unlinkWithText
16490 craig 1265
        {
17744 craig 1266
                ScItemState<QPair<PageItem*, PageItem*> > *is = new ScItemState<QPair<PageItem*, PageItem*> >(Um::LinkTextFrame);
16490 craig 1267
                is->set("LINK_TEXT_FRAME", "linkTextFrame");
17708 craig 1268
                is->set("FIRST", first);
1269
                is->set("JOIN_POS", textLen);
1270
                is->set("ADDPARSEP", addPARSEP);
17744 craig 1271
                is->setItem(qMakePair(this, NextBox));
16490 craig 1272
                undoManager->action(this, is);
1273
        }
7994 avox 1274
}
1275
 
17708 craig 1276
void PageItem::unlink(bool createUndo)
7994 avox 1277
{
1278
        if( NextBox )
1279
        {
16490 craig 1280
                PageItem *undoNextBox=NextBox;
7994 avox 1281
                // make sure lastInFrame is valid
1282
                layout();
12246 cbradney 1283
                /*
1284
                //<< CB #6332: Stop the StoryText cut and break and act like other publishing apps
7994 avox 1285
                // move following text to new StoryText
1286
                itemText.select(lastInFrame()+1, itemText.length()-lastInFrame()-1);
12246 cbradney 1287
                */
7994 avox 1288
                StoryText follow(m_Doc);
12246 cbradney 1289
                /*
7994 avox 1290
                follow.setDefaultStyle(itemText.defaultStyle());
1291
                follow.insert(0, itemText, true);
1292
                // remove following text from this chain
1293
                itemText.removeSelection();
12246 cbradney 1294
                //>>
1295
                */
8325 avox 1296
                // update auto pointers
1297
                if (isAutoText)
1298
                {
1299
                        PageItem* before = this;
1300
                        while (before)
1301
                        {
1302
                                before->isAutoText = false;
1303
                                before = before->BackBox;
1304
                        }
1305
                        m_Doc->FirstAuto = NextBox;
1306
                }
7994 avox 1307
                // link following frames to new text
1308
                NextBox->firstChar = 0;
1309
                NextBox->BackBox = NULL;
1310
                while (NextBox) {
1311
                        NextBox->itemText = follow;
1312
                        NextBox->invalid = true;
8325 avox 1313
                        NextBox->firstChar = 0;
7994 avox 1314
                        NextBox = NextBox->NextBox;
1315
                }
1316
                // NextBox == NULL now
11743 jghali 1317
                NextBox = NULL;
17708 craig 1318
                if (UndoManager::undoEnabled() && createUndo)
16490 craig 1319
                {
17744 craig 1320
                        ScItemState<QPair<PageItem*, PageItem*> > *is = new ScItemState<QPair<PageItem*, PageItem*> >(Um::UnlinkTextFrame);
16490 craig 1321
                        is->set("UNLINK_TEXT_FRAME", "unlinkTextFrame");
17744 craig 1322
                        is->setItem(qMakePair(this, undoNextBox));
16490 craig 1323
                        undoManager->action(this, is);
1324
                }
7994 avox 1325
        }
1326
}
1327
 
8325 avox 1328
void PageItem::dropLinks()
1329
{
1330
        // update auto pointers
1331
        if (isAutoText && NextBox == 0)
1332
        {
1333
                m_Doc->LastAuto = BackBox;
1334
        }
1335
        if (isAutoText && BackBox == 0)
1336
        {
1337
                m_Doc->FirstAuto = NextBox;
1338
        }
1339
        isAutoText = false;
1340
 
1341
        // leave text in remaining chain
1342
        PageItem* before = BackBox;
1343
        PageItem* after = NextBox;
1344
        if (after != 0 || before != 0)
1345
        {
1346
                itemText = StoryText(m_Doc);
1347
                if (before)
1348
                        before->NextBox = after;
1349
                if (after)
1350
                {
1351
                        after->BackBox = before;
1352
                        while (after)
1353
                        {
1354
                                after->invalid = true;
1355
                                after->firstChar = 0;
1356
                                after = after->NextBox;
1357
                        }
1358
                }
9403 jghali 1359
                // JG we should set BackBox and NextBox to NULL at a point
11743 jghali 1360
                BackBox = NextBox = NULL;
8325 avox 1361
        }
1362
}
1363
 
17565 craig 1364
//unlink selected frame from text chain
1365
//but copy or cut its content from itemText
1366
void PageItem::unlinkWithText(bool cutText)
1367
{
1368
        PageItem * Next = NextBox;
17708 craig 1369
        PageItem * Prev = BackBox;
1370
        int length = itemText.length();
1371
 
1372
        //unlink first frame in chain
1373
        if (Prev == NULL)
1374
        {
1375
                if (lastInFrame() < length -1)
1376
                {
1377
                        StoryText content(m_Doc);
1378
                        itemText.select(lastInFrame() +1, length - (lastInFrame() +1));
1379
                        content.insert(0, itemText, cutText);
1380
                        itemText.removeSelection();
1381
                        unlink(false);
1382
                        Next->itemText.insert(0, content);
1383
                        Next->update();
1384
                }
1385
                else
1386
                {
1387
                        unlink(false);
1388
                        if (!cutText)
1389
                        {
1390
                                Next->itemText.insert(0, itemText);
1391
                                Next->update();
1392
                        }
1393
                }
1394
        }
1395
        else
1396
        {
1397
                itemText.select(firstInFrame(), length - firstInFrame());
1398
                StoryText content(m_Doc);
1399
                content.insert(0, itemText, true);
1400
                if (cutText)
1401
                        itemText.removeSelection();
1402
                Prev->unlink(false);
1403
                itemText.insert(0, content);
1404
                update();
1405
        }
1406
        if (UndoManager::undoEnabled())
1407
        {
17744 craig 1408
                ScItemState<QPair<PageItem*, PageItem*> > *is = new ScItemState<QPair<PageItem*, PageItem*> >(Um::UnlinkTextFrame);
17708 craig 1409
                is->set("UNLINK_TEXT_FRAME", "unlinkTextFrame");
1410
                is->set("CUT_TEXT", cutText);
17744 craig 1411
                is->setItem(qMakePair(Prev, Next));
17708 craig 1412
                undoManager->action(this, is);
1413
        }
17565 craig 1414
}
1415
 
5559 avox 1416
/// tests if a character is displayed by this frame
1417
bool PageItem::frameDisplays(int textpos) const
1418
{
1419
#ifndef NLS_PROTO
5673 avox 1420
        return 0 <= textpos && textpos < signed(MaxChars) &&  textpos < itemText.length();
5559 avox 1421
#else
1422
        return true; // FIXME:NLS
1423
#endif
1424
}
1425
 
1426
 
1427
/// returns the style at the current charpos
1428
const ParagraphStyle& PageItem::currentStyle() const
1429
{
16626 jghali 1430
        if (frameDisplays(itemText.cursorPosition()))
1431
                return itemText.paragraphStyle(itemText.cursorPosition());
5559 avox 1432
        else
1433
                return itemText.defaultStyle();
1434
}
1435
 
5569 avox 1436
/// returns the style at the current charpos for changing
1437
ParagraphStyle& PageItem::changeCurrentStyle()
1438
{
16626 jghali 1439
        if (frameDisplays(itemText.cursorPosition()))
1440
                return const_cast<ParagraphStyle&>(itemText.paragraphStyle(itemText.cursorPosition()));
5569 avox 1441
        else
5691 avox 1442
                return const_cast<ParagraphStyle&>(itemText.defaultStyle());
5569 avox 1443
}
1444
 
5559 avox 1445
/// returns the style at the current charpos
1446
const CharStyle& PageItem::currentCharStyle() const
1447
{
16626 jghali 1448
        if (frameDisplays(itemText.cursorPosition()))
1449
                return itemText.charStyle(itemText.cursorPosition());
5559 avox 1450
        else
1451
                return itemText.defaultStyle().charStyle();
1452
}
1453
 
16838 jghali 1454
void PageItem::currentTextProps(ParagraphStyle& parStyle) const
1455
{
1456
        parStyle = this->currentStyle();
1457
        int position = itemText.cursorPosition();
1458
        if (itemText.lengthOfSelection() > 0)
1459
                position = qMin(qMax(itemText.endOfSelection() - 1, 0), qMax(position, itemText.startOfSelection()));
1460
 
1461
        if (frameDisplays(position))
1462
                parStyle.charStyle().setStyle( itemText.charStyle(position) );
1463
        else
1464
                parStyle.charStyle().setStyle( itemText.defaultStyle().charStyle() );
1465
}
1466
 
3988 cbradney 1467
void PageItem::setTextToFrameDistLeft(double newLeft)
1468
{
18012 craig 1469
        if(m_textDistanceMargins.Left==newLeft)
17641 craig 1470
                return;
1471
        if (UndoManager::undoEnabled())
1472
        {
1473
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1474
                ss->set("LEFT_TEXTFRAMEDIST", "left_textframedist");
18012 craig 1475
                ss->set("OLD_DIST",m_textDistanceMargins.Left);
17641 craig 1476
                ss->set("NEW_DIST",newLeft);
1477
                undoManager->action(this, ss);
1478
        }
18012 craig 1479
        m_textDistanceMargins.Left=newLeft;
16546 jghali 1480
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1481
}
3985 cbradney 1482
 
3988 cbradney 1483
void PageItem::setTextToFrameDistRight(double newRight)
1484
{
18012 craig 1485
        if(m_textDistanceMargins.Right==newRight)
17641 craig 1486
                return;
1487
        if (UndoManager::undoEnabled())
1488
        {
1489
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1490
                ss->set("RIGHT_TEXTFRAMEDIST", "right_textframedist");
18012 craig 1491
                ss->set("OLD_DIST",m_textDistanceMargins.Right);
17641 craig 1492
                ss->set("NEW_DIST",newRight);
1493
                undoManager->action(this, ss);
1494
        }
18012 craig 1495
        m_textDistanceMargins.Right=newRight;
16546 jghali 1496
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1497
}
3985 cbradney 1498
 
3988 cbradney 1499
void PageItem::setTextToFrameDistTop(double newTop)
1500
{
18012 craig 1501
        if(m_textDistanceMargins.Top==newTop)
17641 craig 1502
                return;
1503
        if (UndoManager::undoEnabled())
1504
        {
1505
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1506
                ss->set("TOP_TEXTFRAMEDIST", "top_textframedist");
18012 craig 1507
                ss->set("OLD_DIST",m_textDistanceMargins.Top);
17641 craig 1508
                ss->set("NEW_DIST",newTop);
1509
                undoManager->action(this, ss);
1510
        }
18012 craig 1511
        m_textDistanceMargins.Top=newTop;
16546 jghali 1512
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1513
}
3985 cbradney 1514
 
3988 cbradney 1515
void PageItem::setTextToFrameDistBottom(double newBottom)
1516
{
18012 craig 1517
        if(m_textDistanceMargins.Bottom==newBottom)
17641 craig 1518
                return;
1519
        if (UndoManager::undoEnabled())
1520
        {
1521
                SimpleState *ss = new SimpleState(Um::TextFrameDist, "", Um::ITextFrame);
1522
                ss->set("BOTTOM_TEXTFRAMEDIST", "bottom_textframedist");
18012 craig 1523
                ss->set("OLD_DIST",m_textDistanceMargins.Bottom);
17641 craig 1524
                ss->set("NEW_DIST",newBottom);
1525
                undoManager->action(this, ss);
1526
        }
18012 craig 1527
        m_textDistanceMargins.Bottom=newBottom;
16546 jghali 1528
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1529
}
3985 cbradney 1530
 
3988 cbradney 1531
void PageItem::setTextToFrameDist(double newLeft, double newRight, double newTop, double newBottom)
1532
{
17641 craig 1533
        UndoTransaction* activeTransaction = NULL;
1534
        if (UndoManager::undoEnabled())
1535
                activeTransaction = new UndoTransaction(undoManager->beginTransaction(Um::TextFrame, Um::IDocument, Um::TextFrameDist, "", Um::ITextFrame));
1536
        setTextToFrameDistLeft(newLeft);
1537
        setTextToFrameDistRight(newRight);
1538
        setTextToFrameDistTop(newTop);
1539
        setTextToFrameDistBottom(newBottom);
1540
        if (activeTransaction)
1541
        {
1542
                activeTransaction->commit();
1543
                delete activeTransaction;
1544
                activeTransaction = NULL;
1545
        }
16546 jghali 1546
        //emit textToFrameDistances(Extra, TExtra, BExtra, RExtra);
3988 cbradney 1547
}
3985 cbradney 1548
 
14932 cbradney 1549
double PageItem::gridOffset() const { return m_Doc->guidesPrefs().offsetBaselineGrid; }
1550
double PageItem::gridDistance() const { return m_Doc->guidesPrefs().valueBaselineGrid; }
5559 avox 1551
 
1552
void PageItem::setGridOffset(double) { } // FIXME
1553
void PageItem::setGridDistance(double) { } // FIXME
1554
void PageItem::setColumns(int n)
1555
{
17641 craig 1556
        if(Cols==n)
1557
                return;
17744 craig 1558
        if(UndoManager::undoEnabled())
1559
        {
17641 craig 1560
                SimpleState *ss = new SimpleState(Um::Columns, "", Um::IBorder);
1561
                ss->set("COLUMNS", "columns");
1562
                ss->set("OLD_COLUMNS", Cols);
1563
                ss->set("NEW_COLUMNS",n);
1564
                undoManager->action(this, ss);
1565
        }
1566
        Cols = qMax(1, n);
5559 avox 1567
}
1568
void PageItem::setColumnGap(double gap)
1569
{
17641 craig 1570
        if(ColGap==gap)
1571
                return;
1572
        if(UndoManager::undoEnabled()){
1573
                SimpleState *ss = new SimpleState(Um::Columns, "", Um::IBorder);
1574
                ss->set("COLUMNSGAP", "columnsgap");
1575
                ss->set("OLD_COLUMNS", ColGap);
1576
                ss->set("NEW_COLUMNS",gap);
1577
                undoManager->action(this, ss);
1578
        }
1579
        ColGap = gap;
5559 avox 1580
}
1581
 
3989 cbradney 1582
void PageItem::setCornerRadius(double newRadius)
1583
{
18022 craig 1584
        if(m_roundedCorderRadius==newRadius)
17644 craig 1585
                return;
17744 craig 1586
        if(UndoManager::undoEnabled())
1587
        {
1588
                SimpleState *state = new SimpleState(Um::RoundCorner,"",Um::IBorder);
1589
                state->set("CORNER_RADIUS","corner_radius");
18022 craig 1590
                state->set("OLD_RADIUS",m_roundedCorderRadius);
17744 craig 1591
                state->set("NEW_RADIUS",newRadius);
1592
                undoManager->action(this,state);
1593
        }
18022 craig 1594
        m_roundedCorderRadius=newRadius;
16546 jghali 1595
        //emit cornerRadius(RadRect);
3989 cbradney 1596
}
3985 cbradney 1597
 
3988 cbradney 1598
 
1599
 
10840 avox 1600
/** Paints the item.
1601
    CHANGE: cullingArea is in doc coordinates!
1602
 */
11052 avox 1603
void PageItem::DrawObj(ScPainter *p, QRectF cullingArea)
3 paul 1604
{
4084 cbradney 1605
        if (!m_Doc->DoDrawing)
1740 cbradney 1606
                return;
10945 jghali 1607
        if (cullingArea.isNull())
10840 avox 1608
        {
1609
                cullingArea = QRectF(QPointF(m_Doc->minCanvasCoordinate.x(), m_Doc->minCanvasCoordinate.y()),
1610
                                                         QPointF(m_Doc->maxCanvasCoordinate.x(), m_Doc->maxCanvasCoordinate.y())).toAlignedRect();
1611
        }
17394 fschmid 1612
 
1613
        no_fill = false;
1614
        no_stroke = false;
14681 fschmid 1615
        DrawObj_Pre(p);
13875 jghali 1616
        if (m_Doc->layerOutline(LayerID))
5572 fschmid 1617
        {
16902 fschmid 1618
                if ((itemType()==TextFrame || itemType()==ImageFrame || itemType()==PathText || itemType()==Line || itemType()==PolyLine || itemType()==Group || itemType()==Symbol))
14681 fschmid 1619
                        DrawObj_Item(p, cullingArea);
5572 fschmid 1620
        }
1621
        else
7549 fschmid 1622
        {
16105 fschmid 1623
                DrawObj_Item(p, cullingArea);
7549 fschmid 1624
        }
2434 fschmid 1625
        DrawObj_Post(p);
1736 cbradney 1626
}
1627
 
14681 fschmid 1628
void PageItem::DrawObj_Pre(ScPainter *p)
1740 cbradney 1629
{
1741 cbradney 1630
        p->save();
2434 fschmid 1631
        if (!isEmbedded)
18032 craig 1632
                p->translate(m_xPos, m_yPos);
18022 craig 1633
        p->rotate(m_rotation);
13875 jghali 1634
        if (m_Doc->layerOutline(LayerID))
1741 cbradney 1635
        {
13875 jghali 1636
                p->setPen(m_Doc->layerMarker(LayerID), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5572 fschmid 1637
                p->setFillMode(ScPainter::None);
1638
                p->setBrushOpacity(1.0);
1639
                p->setPenOpacity(1.0);
1741 cbradney 1640
        }
1641
        else
1642
        {
16105 fschmid 1643
                if (!isGroup())
1741 cbradney 1644
                {
14306 fschmid 1645
                        p->setBlendModeFill(fillBlendmode());
14297 fschmid 1646
                        p->setLineWidth(m_lineWidth);
1647
                        if (GrType != 0)
5572 fschmid 1648
                        {
14297 fschmid 1649
                                if (GrType == 8)
6368 fschmid 1650
                                {
14297 fschmid 1651
                                        if ((patternVal.isEmpty()) || (!m_Doc->docPatterns.contains(patternVal)))
6368 fschmid 1652
                                        {
14297 fschmid 1653
                                                p->fill_gradient = VGradient(VGradient::linear);
1654
                                                if (fillColor() != CommonStrings::None)
1655
                                                {
1656
                                                        p->setBrush(fillQColor);
1657
                                                        p->setFillMode(ScPainter::Solid);
1658
                                                }
1659
                                                else
17394 fschmid 1660
                                                {
1661
                                                        no_fill = true;
14297 fschmid 1662
                                                        p->setFillMode(ScPainter::None);
17394 fschmid 1663
                                                }
14297 fschmid 1664
                                                if ((!patternVal.isEmpty()) && (!m_Doc->docPatterns.contains(patternVal)))
1665
                                                {
1666
                                                        GrType = 0;
1667
                                                        patternVal = "";
1668
                                                }
6368 fschmid 1669
                                        }
1670
                                        else
12215 fschmid 1671
                                        {
14297 fschmid 1672
                                                p->setPattern(&m_Doc->docPatterns[patternVal], patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation, patternSkewX, patternSkewY, patternMirrorX, patternMirrorY);
1673
                                                p->setFillMode(ScPainter::Pattern);
12215 fschmid 1674
                                        }
6368 fschmid 1675
                                }
1676
                                else
1677
                                {
14952 fschmid 1678
                                        if (GrType == 9)
14297 fschmid 1679
                                        {
14952 fschmid 1680
                                                p->setFillMode(ScPainter::Gradient);
1681
                                                FPoint pG1 = FPoint(0, 0);
1682
                                                FPoint pG2 = FPoint(width(), 0);
1683
                                                FPoint pG3 = FPoint(width(), height());
1684
                                                FPoint pG4 = FPoint(0, height());
1685
                                                p->set4ColorGeometry(pG1, pG2, pG3, pG4, GrControl1, GrControl2, GrControl3, GrControl4);
1686
                                                p->set4ColorColors(GrColorP1QColor, GrColorP2QColor, GrColorP3QColor, GrColorP4QColor);
14297 fschmid 1687
                                        }
1688
                                        else
1689
                                        {
14952 fschmid 1690
                                                if ((!gradientVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientVal)))
1691
                                                        gradientVal = "";
1692
                                                if (!(gradientVal.isEmpty()) && (m_Doc->docGradients.contains(gradientVal)))
1693
                                                        fill_gradient = m_Doc->docGradients[gradientVal];
15024 fschmid 1694
                                                if ((fill_gradient.Stops() < 2) && (GrType < 9)) // fall back to solid filling if there are not enough colorstops in the gradient.
14297 fschmid 1695
                                                {
14952 fschmid 1696
                                                        if (fillColor() != CommonStrings::None)
1697
                                                        {
1698
                                                                p->setBrush(fillQColor);
1699
                                                                p->setFillMode(ScPainter::Solid);
1700
                                                        }
1701
                                                        else
17394 fschmid 1702
                                                        {
1703
                                                                no_fill = true;
14952 fschmid 1704
                                                                p->setFillMode(ScPainter::None);
17394 fschmid 1705
                                                        }
14297 fschmid 1706
                                                }
14952 fschmid 1707
                                                else
1708
                                                {
1709
                                                        p->setFillMode(ScPainter::Gradient);
1710
                                                        p->fill_gradient = fill_gradient;
1711
                                                        switch (GrType)
1712
                                                        {
1713
                                                                case 1:
1714
                                                                case 2:
1715
                                                                case 3:
1716
                                                                case 4:
1717
                                                                case 6:
1718
                                                                        p->setGradient(VGradient::linear, FPoint(GrStartX, GrStartY), FPoint(GrEndX, GrEndY), FPoint(GrStartX, GrStartY), GrScale, GrSkew);
1719
                                                                        break;
1720
                                                                case 5:
1721
                                                                case 7:
1722
                                                                        p->setGradient(VGradient::radial, FPoint(GrStartX, GrStartY), FPoint(GrEndX, GrEndY), FPoint(GrFocalX, GrFocalY), GrScale, GrSkew);
1723
                                                                        break;
14981 fschmid 1724
                                                                case 10:
1725
                                                                        p->setFillMode(ScPainter::Gradient);
15024 fschmid 1726
                                                                        p->setDiamondGeometry(FPoint(0, 0), FPoint(width(), 0), FPoint(width(), height()), FPoint(0, height()), GrControl1, GrControl2, GrControl3, GrControl4, GrControl5);
14981 fschmid 1727
                                                                        break;
15024 fschmid 1728
                                                                case 11:
16786 fschmid 1729
                                                                case 13:
15024 fschmid 1730
                                                                        p->setFillMode(ScPainter::Gradient);
1731
                                                                        p->setMeshGradient(FPoint(0, 0), FPoint(width(), 0), FPoint(width(), height()), FPoint(0, height()), meshGradientArray);
1732
                                                                        break;
16729 fschmid 1733
                                                                case 12:
1734
                                                                        p->setFillMode(ScPainter::Gradient);
1735
                                                                        p->setMeshGradient(FPoint(0, 0), FPoint(width(), 0), FPoint(width(), height()), FPoint(0, height()), meshGradientPatches);
1736
                                                                        break;
14952 fschmid 1737
                                                        }
1738
                                                }
14297 fschmid 1739
                                        }
6368 fschmid 1740
                                }
5572 fschmid 1741
                        }
6368 fschmid 1742
                        else
1743
                        {
14297 fschmid 1744
                                p->fill_gradient = VGradient(VGradient::linear);
1745
                                if (fillColor() != CommonStrings::None)
6368 fschmid 1746
                                {
14297 fschmid 1747
                                        p->setBrush(fillQColor);
1748
                                        p->setFillMode(ScPainter::Solid);
7684 fschmid 1749
                                }
1750
                                else
17394 fschmid 1751
                                {
1752
                                        no_fill = true;
14297 fschmid 1753
                                        p->setFillMode(ScPainter::None);
17394 fschmid 1754
                                }
6368 fschmid 1755
                        }
14297 fschmid 1756
                        if ((lineColor() != CommonStrings::None) || (!patternStrokeVal.isEmpty()) || (GrTypeStroke > 0))
5572 fschmid 1757
                        {
14297 fschmid 1758
                                p->setPen(strokeQColor, m_lineWidth, PLineArt, PLineEnd, PLineJoin);
1759
                                if (DashValues.count() != 0)
1760
                                        p->setDash(DashValues, DashOffset);
5572 fschmid 1761
                        }
1762
                        else
14297 fschmid 1763
                                p->setLineWidth(0);
14306 fschmid 1764
                        p->setBrushOpacity(1.0 - fillTransparency());
1765
                        p->setPenOpacity(1.0 - lineTransparency());
14297 fschmid 1766
                        p->setFillRule(fillRule);
14318 fschmid 1767
                        if ((GrMask == 1) || (GrMask == 2) || (GrMask == 4) || (GrMask == 5))
14297 fschmid 1768
                        {
14318 fschmid 1769
                                if ((GrMask == 1) || (GrMask == 2))
1770
                                        p->setMaskMode(1);
1771
                                else
1772
                                        p->setMaskMode(3);
14300 fschmid 1773
                                if ((!gradientMaskVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientMaskVal)))
1774
                                        gradientMaskVal = "";
1775
                                if (!(gradientMaskVal.isEmpty()) && (m_Doc->docGradients.contains(gradientMaskVal)))
1776
                                        mask_gradient = m_Doc->docGradients[gradientMaskVal];
14297 fschmid 1777
                                p->mask_gradient = mask_gradient;
14318 fschmid 1778
                                if ((GrMask == 1) || (GrMask == 4))
14297 fschmid 1779
                                        p->setGradientMask(VGradient::linear, FPoint(GrMaskStartX, GrMaskStartY), FPoint(GrMaskEndX, GrMaskEndY), FPoint(GrMaskStartX, GrMaskStartY), GrMaskScale, GrMaskSkew);
1780
                                else
1781
                                        p->setGradientMask(VGradient::radial, FPoint(GrMaskStartX, GrMaskStartY), FPoint(GrMaskEndX, GrMaskEndY), FPoint(GrMaskFocalX, GrMaskFocalY), GrMaskScale, GrMaskSkew);
1782
                        }
16732 fschmid 1783
                        else if ((GrMask == 3) || (GrMask == 6) || (GrMask == 7) || (GrMask == 8))
14308 fschmid 1784
                        {
1785
                                if ((patternMaskVal.isEmpty()) || (!m_Doc->docPatterns.contains(patternMaskVal)))
1786
                                        p->setMaskMode(0);
1787
                                else
1788
                                {
1789
                                        p->setPatternMask(&m_Doc->docPatterns[patternMaskVal], patternMaskScaleX, patternMaskScaleY, patternMaskOffsetX, patternMaskOffsetY, patternMaskRotation, patternMaskSkewX, patternMaskSkewY, patternMaskMirrorX, patternMaskMirrorY);
14318 fschmid 1790
                                        if (GrMask == 3)
1791
                                                p->setMaskMode(2);
16732 fschmid 1792
                                        else if (GrMask == 6)
1793
                                                p->setMaskMode(4);
1794
                                        else if (GrMask == 7)
1795
                                                p->setMaskMode(5);
14318 fschmid 1796
                                        else
16732 fschmid 1797
                                                p->setMaskMode(6);
14308 fschmid 1798
                                }
1799
                        }
14297 fschmid 1800
                        else
1801
                                p->setMaskMode(0);
1741 cbradney 1802
                }
7549 fschmid 1803
        }
1740 cbradney 1804
}
1805
 
2434 fschmid 1806
void PageItem::DrawObj_Post(ScPainter *p)
1740 cbradney 1807
{
1808
        bool doStroke=true;
16899 fschmid 1809
        if (m_Doc->layerOutline(LayerID))
1740 cbradney 1810
        {
16899 fschmid 1811
                if (itemType()!=Line)
1740 cbradney 1812
                {
16899 fschmid 1813
                        p->setPen(m_Doc->layerMarker(LayerID), 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
1814
                        p->setFillMode(ScPainter::None);
1815
                        p->setBrushOpacity(1.0);
1816
                        p->setPenOpacity(1.0);
1817
                        if (itemType()==PolyLine)
1818
                                p->setupPolygon(&PoLine, false);
1819
                        else if (itemType() == PathText)
5582 fschmid 1820
                        {
16899 fschmid 1821
                                if (PoShow)
5582 fschmid 1822
                                        p->setupPolygon(&PoLine, false);
16899 fschmid 1823
                                else
1824
                                        doStroke = false;
1825
                        }
1826
                        else
1827
                                p->setupPolygon(&PoLine);
1828
                        if (doStroke)
1829
                                p->strokePath();
1830
                        if (itemType()==ImageFrame)
1831
                        {
1832
                                if (imageClip.size() != 0)
7549 fschmid 1833
                                {
16899 fschmid 1834
                                        p->setupPolygon(&imageClip);
7549 fschmid 1835
                                        p->strokePath();
5584 fschmid 1836
                                }
1837
                        }
1740 cbradney 1838
                }
16899 fschmid 1839
        }
1840
        else
1841
        {
1842
                if (!isGroup())
7549 fschmid 1843
                {
14308 fschmid 1844
                        p->setBlendModeFill(0);
14298 fschmid 1845
                        p->setMaskMode(0);
16856 craig 1846
                        // TODO: Investigate whether itemType()==Table should really be here. I got artifacts without it so keeping it here for now. /estan
1847
                        if (itemType()==PathText || itemType()==PolyLine || itemType()==Spiral || itemType()==Line || itemType()==Symbol || itemType()==Group || itemType()==Table)
7549 fschmid 1848
                                doStroke=false;
1849
                        if ((doStroke) && (!m_Doc->RePos))
1850
                        {
14306 fschmid 1851
                                p->setBlendModeStroke(lineBlendmode());
1852
                                p->setPenOpacity(1.0 - lineTransparency());
14197 fschmid 1853
                                if ((lineColor() != CommonStrings::None) || (!patternStrokeVal.isEmpty()) || (GrTypeStroke > 0))
14168 fschmid 1854
                                {
1855
                                        p->setPen(strokeQColor, m_lineWidth, PLineArt, PLineEnd, PLineJoin);
1856
                                        if (DashValues.count() != 0)
1857
                                                p->setDash(DashValues, DashOffset);
1858
                                }
1859
                                else
1860
                                        p->setLineWidth(0);
17418 fschmid 1861
                                if ((itemType() == LatexFrame) || (itemType() == ImageFrame) || (itemType() == OSGFrame))
1862
                                        p->setupPolygon(&PoLine);
1863
                                if (NamedLStyle.isEmpty())
1740 cbradney 1864
                                {
17418 fschmid 1865
                                        if ((!patternStrokeVal.isEmpty()) && (m_Doc->docPatterns.contains(patternStrokeVal)))
13013 fschmid 1866
                                        {
17418 fschmid 1867
                                                if (patternStrokePath)
13013 fschmid 1868
                                                {
17418 fschmid 1869
                                                        QPainterPath guidePath = PoLine.toQPainterPath(false);
1870
                                                        DrawStrokePattern(p, guidePath);
14168 fschmid 1871
                                                }
17418 fschmid 1872
                                                else
14197 fschmid 1873
                                                {
17418 fschmid 1874
                                                        p->setPattern(&m_Doc->docPatterns[patternStrokeVal], patternStrokeScaleX, patternStrokeScaleY, patternStrokeOffsetX, patternStrokeOffsetY, patternStrokeRotation, patternStrokeSkewX, patternStrokeSkewY, patternStrokeMirrorX, patternStrokeMirrorY);
1875
                                                        p->setStrokeMode(ScPainter::Pattern);
1876
                                                        p->strokePath();
1877
                                                }
1878
                                        }
1879
                                        else if (GrTypeStroke > 0)
1880
                                        {
1881
                                                if ((!gradientStrokeVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientStrokeVal)))
1882
                                                        gradientStrokeVal = "";
1883
                                                if (!(gradientStrokeVal.isEmpty()) && (m_Doc->docGradients.contains(gradientStrokeVal)))
1884
                                                        stroke_gradient = m_Doc->docGradients[gradientStrokeVal];
1885
                                                if (stroke_gradient.Stops() < 2) // fall back to solid stroking if there are not enough colorstops in the gradient.
1886
                                                {
1887
                                                        if (lineColor() != CommonStrings::None)
14197 fschmid 1888
                                                        {
17418 fschmid 1889
                                                                p->setBrush(strokeQColor);
1890
                                                                p->setStrokeMode(ScPainter::Solid);
14197 fschmid 1891
                                                        }
1892
                                                        else
1893
                                                        {
17418 fschmid 1894
                                                                no_stroke = true;
1895
                                                                p->setStrokeMode(ScPainter::None);
14197 fschmid 1896
                                                        }
1897
                                                }
17418 fschmid 1898
                                                else
14168 fschmid 1899
                                                {
17418 fschmid 1900
                                                        p->setStrokeMode(ScPainter::Gradient);
1901
                                                        p->stroke_gradient = stroke_gradient;
1902
                                                        if (GrTypeStroke == 6)
1903
                                                                p->setGradient(VGradient::linear, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeStartX, GrStrokeStartY), GrStrokeScale, GrStrokeSkew);
1904
                                                        else
1905
                                                                p->setGradient(VGradient::radial, FPoint(GrStrokeStartX, GrStrokeStartY), FPoint(GrStrokeEndX, GrStrokeEndY), FPoint(GrStrokeFocalX, GrStrokeFocalY), GrStrokeScale, GrStrokeSkew);
13013 fschmid 1906
                                                }
17418 fschmid 1907
                                                p->strokePath();
13013 fschmid 1908
                                        }
17418 fschmid 1909
                                        else if (lineColor() != CommonStrings::None)
1910
                                        {
1911
                                                p->setStrokeMode(ScPainter::Solid);
1912
                                                p->setPen(strokeQColor, m_lineWidth, PLineArt, PLineEnd, PLineJoin);
1913
                                                if (DashValues.count() != 0)
1914
                                                        p->setDash(DashValues, DashOffset);
1915
                                                p->strokePath();
1916
                                        }
7549 fschmid 1917
                                        else
17418 fschmid 1918
                                                no_stroke = true;
1919
                                }
1920
                                else
1921
                                {
1922
                                        p->setStrokeMode(ScPainter::Solid);
1923
                                        multiLine ml = m_Doc->MLineStyles[NamedLStyle];
1924
                                        QColor tmp;
1925
                                        for (int it = ml.size()-1; it > -1; it--)
5572 fschmid 1926
                                        {
17418 fschmid 1927
                                                struct SingleLine& sl = ml[it];
1928
                                                // Qt4 if ((!sl.Color != CommonStrings::None) && (sl.Width != 0))
1929
                                                if (sl.Color != CommonStrings::None) // && (sl.Width != 0))
6568 fschmid 1930
                                                {
17418 fschmid 1931
                                                        SetQColor(&tmp, sl.Color, sl.Shade);
1932
                                                        p->setPen(tmp, sl.Width, static_cast<Qt::PenStyle>(sl.Dash), static_cast<Qt::PenCapStyle>(sl.LineEnd), static_cast<Qt::PenJoinStyle>(sl.LineJoin));
1933
                                                        p->strokePath();
6568 fschmid 1934
                                                }
5572 fschmid 1935
                                        }
1740 cbradney 1936
                                }
14308 fschmid 1937
                                p->setBlendModeStroke(0);
7549 fschmid 1938
                        }
5746 fschmid 1939
                }
1740 cbradney 1940
        }
14208 fschmid 1941
        p->setFillMode(ScPainter::Solid);
14469 fschmid 1942
        p->setBlendModeFill(0);
14208 fschmid 1943
        p->setStrokeMode(ScPainter::Solid);
14469 fschmid 1944
        p->setBlendModeStroke(0);
14681 fschmid 1945
        p->restore();
1946
}
1947
 
1948
void PageItem::DrawObj_Decoration(ScPainter *p)
1949
{
1950
        p->save();
18079 fschmid 1951
        p->setAntialiasing(false);
14681 fschmid 1952
        if (!isEmbedded)
18032 craig 1953
                p->translate(m_xPos, m_yPos);
18022 craig 1954
        p->rotate(m_rotation);
4084 cbradney 1955
        if ((!isEmbedded) && (!m_Doc->RePos))
2434 fschmid 1956
        {
17790 fschmid 1957
                double scpInv = 0;
16105 fschmid 1958
                if (!isGroup())
1740 cbradney 1959
                {
18007 craig 1960
                        if ((drawFrame()) && (m_Doc->guidesPrefs().framesShown) && ((itemType() == ImageFrame) || (itemType() == LatexFrame) || (itemType() == OSGFrame) || (itemType() == PathText)) && (no_stroke))
3919 fschmid 1961
                        {
13974 cbradney 1962
                                p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameNormColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1963
                                if ((isBookmark) || (m_isAnnotation))
13974 cbradney 1964
                                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameAnnotationColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1965
                                if ((BackBox != 0) || (NextBox != 0))
13974 cbradney 1966
                                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameLinkColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1967
                                if (m_Locked)
13974 cbradney 1968
                                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameLockColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
7549 fschmid 1969
                                p->setFillMode(0);
1970
                                if (itemType()==PathText)
3919 fschmid 1971
                                {
7549 fschmid 1972
                                        if (Clip.count() != 0)
3919 fschmid 1973
                                        {
7549 fschmid 1974
                                                FPointArray tclip;
1975
                                                FPoint np = FPoint(Clip.point(0));
1976
                                                tclip.resize(2);
1977
                                                tclip.setPoint(0, np);
1978
                                                tclip.setPoint(1, np);
8557 subik 1979
                                                for (int a = 1; a < Clip.size(); ++a)
7549 fschmid 1980
                                                {
1981
                                                        np = FPoint(Clip.point(a));
1982
                                                        tclip.putPoints(tclip.size(), 4, np.x(), np.y(), np.x(), np.y(), np.x(), np.y(), np.x(), np.y());
1983
                                                }
1984
                                                np = FPoint(Clip.point(0));
1985
                                                tclip.putPoints(tclip.size(), 2, np.x(), np.y(), np.x(), np.y());
1986
                                                p->setupPolygon(&tclip);
3919 fschmid 1987
                                        }
1988
                                }
12004 fschmid 1989
                                else
17790 fschmid 1990
                                        p->setupSharpPolygon(&PoLine);
7549 fschmid 1991
                                p->strokePath();
3919 fschmid 1992
                        }
1740 cbradney 1993
                }
14932 cbradney 1994
                if ((m_Doc->guidesPrefs().framesShown) && textFlowUsesContourLine() && (ContourLine.size() != 0))
8494 fschmid 1995
                {
17790 fschmid 1996
                        p->setPen(Qt::darkGray, 0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin);
1997
                        p->setupSharpPolygon(&ContourLine);
8494 fschmid 1998
                        p->strokePath();
1999
                }
14808 fschmid 2000
                if (itemType()==ImageFrame)
2001
                {
14971 cbradney 2002
                        double minres = m_Doc->checkerProfiles()[m_Doc->curCheckProfile()].minResolution;
2003
                        double maxres = m_Doc->checkerProfiles()[m_Doc->curCheckProfile()].maxResolution;
2004
                        bool checkres = m_Doc->checkerProfiles()[m_Doc->curCheckProfile()].checkResolution;
17224 craig 2005
                        if  ((((72.0 / imageXScale()) < minres)
14808 fschmid 2006
                                || ((72.0 / imageYScale()) < minres)
2007
                                || ((72.0 / imageXScale()) > maxres)
2008
                                || ((72.0 / imageYScale()) > maxres))
16177 fschmid 2009
                                && (isRaster) && (checkres) && (!m_Doc->drawAsPreview) && (PrefsManager::instance()->appPrefs.displayPrefs.showVerifierWarningsOnCanvas))
14808 fschmid 2010
                        {
18095 craig 2011
                                double ofx = m_width - 22.0;
2012
                                double ofy = m_height - 22.0;
14808 fschmid 2013
                                p->save();
2014
                                p->translate(ofx, ofy);
2015
                                QImage ico = loadIcon("22/dialog-warning.png").toImage();
2016
                                p->drawImage(&ico);
2017
                                p->restore();
2018
                        }
2019
                }
16177 fschmid 2020
                if ((m_Doc->guidesPrefs().layerMarkersShown) && (m_Doc->layerCount() > 1) && (!m_Doc->layerOutline(LayerID)) && (isGroup()) && (!m_Doc->drawAsPreview))
1740 cbradney 2021
                {
17790 fschmid 2022
                        p->setPen(Qt::black, 0, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
5619 fschmid 2023
                        p->setPenOpacity(1.0);
13875 jghali 2024
                        p->setBrush(m_Doc->layerMarker(LayerID));
5619 fschmid 2025
                        p->setBrushOpacity(1.0);
5572 fschmid 2026
                        p->setFillMode(ScPainter::Solid);
5584 fschmid 2027
                        double ofwh = 10;
18095 craig 2028
                        double ofx = m_width - ofwh/2;
2029
                        double ofy = m_height - ofwh*3;
17790 fschmid 2030
                        p->drawSharpRect(ofx, ofy, ofwh, ofwh);
5572 fschmid 2031
                }
17394 fschmid 2032
                if (no_fill && no_stroke && m_Doc->guidesPrefs().framesShown)
2033
                {
2034
                        p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameNormColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
2035
                        if (m_Locked)
2036
                                p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameLockColor, scpInv, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
2037
                        p->setFillMode(ScPainter::None);
18095 craig 2038
                        p->drawSharpRect(0, 0, m_width, m_height);
17394 fschmid 2039
                        no_fill = false;
2040
                        no_stroke = false;
2041
                }
4145 cbradney 2042
                //CB disabled for now
4847 cbradney 2043
                //if (m_Doc->m_Selection->findItem(this)!=-1)
4145 cbradney 2044
                //      drawLockedMarker(p);
2434 fschmid 2045
        }
8180 fschmid 2046
        FrameOnly = false;
18079 fschmid 2047
        p->setAntialiasing(true);
2434 fschmid 2048
        p->restore();
1740 cbradney 2049
}
2050
 
11052 avox 2051
void PageItem::DrawObj_Embedded(ScPainter *p, QRectF cullingArea, const CharStyle& style, PageItem* cembedded)
2434 fschmid 2052
{
8174 avox 2053
        if (!cembedded)
2054
                return;
2055
        if (!m_Doc->DoDrawing)
2056
                return;
9856 fschmid 2057
        QList<PageItem*> emG;
2955 fschmid 2058
        emG.clear();
8174 avox 2059
        emG.append(cembedded);
9856 fschmid 2060
        for (int em = 0; em < emG.count(); ++em)
8174 avox 2061
        {
2062
                PageItem* embedded = emG.at(em);
12299 fschmid 2063
                p->save();
2064
                double x = embedded->xPos();
2065
                double y = embedded->yPos();
18032 craig 2066
                embedded->m_xPos = embedded->gXpos;
2067
                embedded->m_yPos = (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos;
12299 fschmid 2068
                p->translate((embedded->gXpos * (style.scaleH() / 1000.0)), ( - (embedded->gHeight * (style.scaleV() / 1000.0)) + embedded->gYpos * (style.scaleV() / 1000.0)));
2069
                if (style.baselineOffset() != 0)
2070
                {
2071
                        p->translate(0, -embedded->gHeight * (style.baselineOffset() / 1000.0));
18032 craig 2072
                        embedded->m_yPos -= embedded->gHeight * (style.baselineOffset() / 1000.0);
12299 fschmid 2073
                }
2074
                p->scale(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
8174 avox 2075
                embedded->Dirty = Dirty;
12309 fschmid 2076
                embedded->invalid = true;
8174 avox 2077
                double pws = embedded->m_lineWidth;
14681 fschmid 2078
                embedded->DrawObj_Pre(p);
8174 avox 2079
                switch(embedded->itemType())
2080
                {
2081
                        case ImageFrame:
2082
                        case TextFrame:
10321 mrdocs 2083
                        case LatexFrame:
13839 fschmid 2084
                        case OSGFrame:
8174 avox 2085
                        case Polygon:
2086
                        case PathText:
15060 fschmid 2087
                        case Symbol:
16105 fschmid 2088
                        case Group:
16191 fschmid 2089
                        case RegularPolygon:
16215 fschmid 2090
                        case Arc:
17349 fschmid 2091
                        case Table:
14681 fschmid 2092
                                embedded->DrawObj_Item(p, cullingArea);
8174 avox 2093
                                break;
2094
                        case Line:
2095
                        case PolyLine:
16311 fschmid 2096
                        case Spiral:
8562 jghali 2097
                                embedded->m_lineWidth = pws * qMin(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
14681 fschmid 2098
                                embedded->DrawObj_Item(p, cullingArea);
8174 avox 2099
                                break;
2100
                        default:
2101
                                break;
2102
                }
8562 jghali 2103
                embedded->m_lineWidth = pws * qMin(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
8174 avox 2104
                embedded->DrawObj_Post(p);
18032 craig 2105
                embedded->m_xPos = x;
2106
                embedded->m_yPos = y;
8174 avox 2107
                p->restore();
2108
                embedded->m_lineWidth = pws;
2434 fschmid 2109
        }
18052 fschmid 2110
        if (m_Doc->guidesPrefs().framesShown)
2111
        {
2112
                p->save();
18095 craig 2113
                p->translate(0, -(cembedded->m_height * (style.scaleV() / 1000.0)));
18052 fschmid 2114
                if (style.baselineOffset() != 0)
18095 craig 2115
                        p->translate(0, -cembedded->m_height * (style.baselineOffset() / 1000.0));
18052 fschmid 2116
                p->scale(style.scaleH() / 1000.0, style.scaleV() / 1000.0);
2117
                p->setPen(PrefsManager::instance()->appPrefs.displayPrefs.frameNormColor, 0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin);
2118
                p->setFillMode(ScPainter::None);
18095 craig 2119
                p->drawSharpRect(0, 0, cembedded->m_width, cembedded->m_height);
18052 fschmid 2120
                p->restore();
2121
        }
2434 fschmid 2122
}
2123
 
14403 fschmid 2124
void PageItem::DrawStrokePattern(ScPainter *p, QPainterPath &path)
2125
{
2126
        ScPattern pat = m_Doc->docPatterns[patternStrokeVal];
2127
        double pLen = path.length() - ((pat.width / 2.0) * (patternStrokeScaleX / 100.0))