Subversion Repositories Scribus

Rev

Rev 3870 | Rev 3903 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3 paul 1
/***************************************************************************
2
                          pageitem.cpp  -  description
3
                             -------------------
4
    begin                : Sat Apr 7 2001
5
    copyright            : (C) 2001 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 ***************************************************************************/
136 Franz 17
 
3 paul 18
#include "pageitem.h"
270 Franz 19
#include "pageitem.moc"
3 paul 20
#include <qpainter.h>
21
#include <qpen.h>
68 Franz 22
#include <qfont.h>
3 paul 23
#include <qregion.h>
24
#include <qpoint.h>
25
#include <qfileinfo.h>
26
#include <qdrawutil.h>
27
#include <qbitmap.h>
3056 avox 28
#include <qregexp.h>
1818 cbradney 29
#include <qmessagebox.h>
3 paul 30
#include <cmath>
2104 cbradney 31
#include <cassert>
2004 fschmid 32
#include "scpaths.h"
3 paul 33
#include "page.h"
243 Franz 34
#include "scribus.h"
3030 cbradney 35
#include "scribusstructs.h"
838 cbradney 36
#include "scribusdoc.h"
3302 cbradney 37
#include "prefsmanager.h"
1204 tsoots 38
#include "undomanager.h"
39
#include "undostate.h"
1263 tsoots 40
#include "mpalette.h"
128 Franz 41
 
2688 craig 42
#include "scconfig.h"
128 Franz 43
 
68 Franz 44
#include <ft2build.h>
45
#include FT_GLYPH_H
504 cbradney 46
 
2534 craig 47
#include "scfontmetrics.h"
2533 craig 48
#include "util.h"
49
 
504 cbradney 50
using namespace std;
51
 
3625 avox 52
PageItem::PageItem(const PageItem & other)
53
        : QObject(other.parent()),
54
 
55
// 200 attributes! That is madness, or to quote some famous people from Kriquet:
56
// "THAT ALL HAS TO GO!"
57
        Reverse(other.Reverse),
58
        Xpos(other.Xpos),
59
        oldXpos(other.oldXpos),
60
        Ypos(other.Ypos),
61
        oldYpos(other.oldYpos),
62
        Width(other.Width),
63
        oldWidth(other.oldWidth),
64
        Height(other.Height),
65
        oldHeight(other.oldHeight),
66
        gXpos(other.gXpos),
67
        gYpos(other.gYpos),
68
        gWidth(other.gWidth),
69
        gHeight(other.gHeight),
70
        RadRect(other.RadRect),
71
        Rot(other.Rot),
72
        oldRot(other.oldRot),
73
        Doc(other.Doc),
74
        GrType(other.GrType),
75
        GrStartX(other.GrStartX),
76
        GrStartY(other.GrStartY),
77
        GrEndX(other.GrEndX),
78
        GrEndY(other.GrEndY),
79
        TxtStroke(other.TxtStroke),
80
        TxtFill(other.TxtFill),
81
        ShTxtStroke(other.ShTxtStroke),
82
        ShTxtFill(other.ShTxtFill),
83
        TxtScale(other.TxtScale),
84
        TxtScaleV(other.TxtScaleV),
85
        TxTStyle(other.TxTStyle),
86
        TxtBase(other.TxtBase),
87
        TxtShadowX(other.TxtShadowX),
88
        TxtShadowY(other.TxtShadowY),
89
        TxtOutline(other.TxtOutline),
90
        TxtUnderPos(other.TxtUnderPos),
91
        TxtUnderWidth(other.TxtUnderWidth),
92
        TxtStrikePos(other.TxtStrikePos),
93
        TxtStrikeWidth(other.TxtStrikeWidth),
94
        Cols(other.Cols),
95
        ColGap(other.ColGap),
96
        Pwidth(other.Pwidth),
97
        OldPwidth(other.OldPwidth),
98
        PLineArt(other.PLineArt),
99
        PLineEnd(other.PLineEnd),
100
        PLineJoin(other.PLineJoin),
101
        NamedLStyle(other.NamedLStyle),
102
        Select(other.Select),
103
        Clip(other.Clip),
104
        PoLine(other.PoLine),
105
        ContourLine(other.ContourLine),
106
        imageClip(other.imageClip),
107
        Segments(other.Segments),
108
        effectsInUse(other.effectsInUse),
109
        PoShow(other.PoShow),
110
        BaseOffs(other.BaseOffs),
111
        ClipEdited(other.ClipEdited),
112
        FrameType(other.FrameType),
113
        ItemNr(other.ItemNr),
114
        Frame(other.Frame),
115
        OwnPage(other.OwnPage),
116
        oldOwnPage(other.oldOwnPage),
117
        pixm(other.pixm),
118
        Pfile(other.Pfile),
119
        Pfile2(other.Pfile2),
120
        Pfile3(other.Pfile3),
121
        IProfile(other.IProfile),
122
        UseEmbedded(other.UseEmbedded),
123
        EmProfile(other.EmProfile),
124
        IRender(other.IRender),
125
        PicArt(other.PicArt),
126
        PicAvail(other.PicAvail),
127
        LocalScX(other.LocalScX),
128
        LocalScY(other.LocalScY),
129
        LocalX(other.LocalX),
130
        LocalY(other.LocalY),
131
        OrigW(other.OrigW),
132
        OrigH(other.OrigH),
133
        BBoxX(other.BBoxX),
134
        BBoxH(other.BBoxH),
135
        Extra(other.Extra),
136
        TExtra(other.TExtra),
137
        BExtra(other.BExtra),
138
        RExtra(other.RExtra),
139
        LineSp(other.LineSp),
140
        LineSpMode(other.LineSpMode),
141
        CurX(other.CurX),
142
        CurY(other.CurY),
143
        CPos(other.CPos),
144
        itemText(other.itemText),
145
        isBookmark(other.isBookmark),
146
        BMnr(other.BMnr),
147
        isAnnotation(other.isAnnotation),
148
        AnType(other.AnType),
149
        AnActType(other.AnActType),
150
        AnAction(other.AnAction),
151
        An_E_act(other.An_E_act),
152
        An_X_act(other.An_X_act),
153
        An_D_act(other.An_D_act),
154
        An_Fo_act(other.An_Fo_act),
155
        An_Bl_act(other.An_Bl_act),
156
        An_K_act(other.An_K_act),
157
        An_F_act(other.An_F_act),
158
        An_V_act(other.An_V_act),
159
        An_C_act(other.An_C_act),
160
        AutoName(other.AutoName),
161
        AnToolTip(other.AnToolTip),
162
        AnRollOver(other.AnRollOver),
163
        AnDown(other.AnDown),
164
        AnBColor(other.AnBColor),
165
        An_Extern(other.An_Extern),
166
        AnBsty(other.AnBsty),
167
        AnBwid(other.AnBwid),
168
        AnFeed(other.AnFeed),
169
        AnZiel(other.AnZiel),
170
        AnFlag(other.AnFlag),
171
        AnMaxChar(other.AnVis),
172
        AnVis(other.AnVis),
173
        AnChkStil(other.AnChkStil),
174
        AnFont(other.AnFont),
175
        AnIsChk(other.AnIsChk),
176
        AnAAact(other.AnAAact),
177
        AnHTML(other.AnHTML),
178
        AnUseIcons(other.AnUseIcons),
179
        AnIPlace(other.AnIPlace),
180
        AnScaleW(other.AnScaleW),
181
        AnFormat(other.AnFormat),
182
        IFont(other.IFont),
183
        ISize(other.ISize),
184
        HasSel(other.HasSel),
185
        FrameOnly(other.FrameOnly),
186
        BackBox(other.BackBox),
187
        NextBox(other.NextBox),
188
        NextIt(other.NextIt),
189
        NextPg(other.NextPg),
190
        Tinput(other.Tinput),
191
        isAutoText(other.isAutoText),
192
        textAlignment(other.textAlignment),
193
        MaxChars(other.MaxChars),
194
        Redrawn(other.Redrawn),
195
        ExtraV(other.ExtraV),
196
        isRaster(other.isRaster),
197
        OldB(other.OldB),
198
        OldH(other.OldH),
199
        OldB2(other.OldB2),
200
        OldH2(other.OldH2),
201
        Sizing(other.Sizing),
202
        toPixmap(other.toPixmap),
203
        LayerNr(other.LayerNr),
204
        ScaleType(other.ScaleType),
205
        AspectRatio(other.AspectRatio),
206
        Groups(other.Groups),
207
        DashValues(other.DashValues),
208
        TabValues(other.TabValues),
209
        DashOffset(other.DashOffset),
210
        fill_gradient(other.fill_gradient),
211
        fillRule(other.fillRule),
212
        Language(other.Language),
213
        LeftLink(other.LeftLink),
214
        RightLink(other.RightLink),
215
        TopLink(other.TopLink),
216
        BottomLink(other.BottomLink),
217
        LeftLinkID(other.LeftLinkID),
218
        RightLinkID(other.RightLinkID),
219
        TopLinkID(other.TopLinkID),
220
        BottomLinkID(other.BottomLinkID),
221
        LeftLine(other.LeftLine),
222
        RightLine(other.RightLine),
223
        TopLine(other.TopLine),
224
        BottomLine(other.BottomLine),
225
        isTableItem(other.isTableItem),
226
        isSingleSel(other.isSingleSel),
227
        BoundingX(other.BoundingX),
228
        BoundingY(other.BoundingY),
229
        BoundingW(other.BoundingW),
230
        BoundingH(other.BoundingH),
231
        ChangedMasterItem(other.ChangedMasterItem),
232
        OnMasterPage(other.OnMasterPage),
233
        startArrowIndex(other.startArrowIndex),
234
        endArrowIndex(other.endArrowIndex),
235
        isEmbedded(other.isEmbedded),
236
        fillQColor(other.fillQColor),
237
        strokeQColor(other.strokeQColor),
238
        undoManager(other.undoManager),
239
 
240
        // protected
241
 
242
        AnName(other.AnName),
243
        fillColorVal(other.fillColorVal),
244
        lineColorVal(other.lineColorVal),
245
        lineShadeVal(other.lineShadeVal),
246
        fillShadeVal(other.fillShadeVal),
247
        fillTransparencyVal(other.fillTransparencyVal),
248
        lineTransparencyVal(other.fillTransparencyVal),
249
        imageIsFlippedH(other.imageIsFlippedH),
250
        imageIsFlippedV(other.imageIsFlippedV),
251
        Locked(other.Locked),
252
        LockRes(other.LockRes),
253
        textFlowsAroundFrameVal(other.textFlowsAroundFrameVal),
254
        textFlowUsesBoundingBoxVal(other.textFlowUsesBoundingBoxVal),
255
        textFlowUsesContourLineVal(other.textFlowUsesContourLineVal),
256
        pageItemAttributes(other.pageItemAttributes),
257
        isPrintable(other.isPrintable),
258
        tagged(other.tagged)
259
{
260
}
261
 
262
 
2707 subik 263
PageItem::PageItem(ScribusDoc *pa, ItemType newType, double x, double y, double w, double h, double w2, QString fill, QString outline)
1656 craig 264
        // Initialize superclasses
265
        : QObject(pa),
1657 craig 266
        // Initialize member variables - 2005-03-10 CR. Initializer lists can be faster and safer.
1749 craig 267
        lineShadeVal(100),
1657 craig 268
        fillShadeVal(100),
269
        fillTransparencyVal(0.0),
270
        lineTransparencyVal(0.0),
271
        imageIsFlippedH(0),
272
        imageIsFlippedV(0),
273
        Locked(false),
274
        LockRes(false),
1656 craig 275
        textFlowsAroundFrameVal(false),
276
        textFlowUsesBoundingBoxVal(false),
277
        textFlowUsesContourLineVal(false)
3 paul 278
{
279
        QString tmp;
280
        BackBox = 0;
281
        NextBox = 0;
282
        Xpos = x;
1204 tsoots 283
        oldXpos = x;
3 paul 284
        Ypos = y;
1204 tsoots 285
        oldYpos = y;
3 paul 286
        Width = w;
1206 tsoots 287
        oldWidth = w;
3 paul 288
        Height = h;
1206 tsoots 289
        oldHeight = h;
456 fschmid 290
        BoundingX = x;
291
        BoundingY = y;
292
        BoundingW = w;
293
        BoundingH = h;
3 paul 294
        OldB = Width;
295
        OldH = Height;
296
        OldB2 = Width;
297
        OldH2 = Height;
1460 cbradney 298
        itemTypeVal = newType;
3 paul 299
        Rot = 0;
1211 tsoots 300
        oldRot = 0;
456 fschmid 301
        Doc = pa;
1394 cbradney 302
        fillColorVal = fill;
1460 cbradney 303
        lineColorVal = itemTypeVal == PageItem::TextFrame ? fill : outline;
1194 fschmid 304
        TxtFill = Doc->toolSettings.dPenText;
305
        TxtStroke = Doc->toolSettings.dStrokeText;
68 Franz 306
        ShTxtStroke = 100;
307
        ShTxtFill = 100;
2242 fschmid 308
        TxtScale = 1000;
309
        TxtScaleV = 1000;
2247 fschmid 310
        TxtShadowX = 50;
311
        TxtShadowY = -50;
2257 fschmid 312
        TxtOutline = 10;
68 Franz 313
        TxTStyle = 0;
2234 fschmid 314
        TxtBase = 0;
2889 cbradney 315
        TxtUnderWidth = Doc->typographicSettings.valueUnderlineWidth;
316
        TxtUnderPos = Doc->typographicSettings.valueUnderlinePos;
317
        TxtStrikePos = Doc->typographicSettings.valueStrikeThruPos;
318
        TxtStrikeWidth = Doc->typographicSettings.valueStrikeThruWidth;
3 paul 319
        GrType = 0;
292 Franz 320
        GrStartX = 0;
321
        GrStartY = 0;
294 Franz 322
        GrEndX = w;
292 Franz 323
        GrEndY = 0;
3 paul 324
        Pwidth = w2;
263 Franz 325
        OldPwidth = w2;
1194 fschmid 326
        PLineArt = PenStyle(Doc->toolSettings.dLineArt);
3 paul 327
        PLineEnd = FlatCap;
328
        PLineJoin = MiterJoin;
329
        Select = false;
330
        FrameOnly = false;
331
        ClipEdited = false;
332
        FrameType = 0;
1194 fschmid 333
        IFont = Doc->toolSettings.defFont;
334
        ISize = Doc->toolSettings.defSize;
2309 fschmid 335
        LineSpMode = 0;
2889 cbradney 336
        LineSp = ((Doc->toolSettings.defSize / 10.0) * static_cast<double>(Doc->typographicSettings.autoLineSpacing) / 100) + (Doc->toolSettings.defSize / 10.0);
1065 cbradney 337
        Doc->docParagraphStyles[0].LineSpa = LineSp;
3 paul 338
        CurX = 0;
339
        CurY = 0;
340
        CPos = 0;
341
        Extra = 1;
342
        TExtra = 1;
343
        BExtra = 1;
344
        RExtra = 1;
345
        ExtraV = 0;
1065 cbradney 346
        itemText.clear();
347
        itemText.setAutoDelete(true);
387 Franz 348
        MaxChars = 0;
3 paul 349
        Pfile = "";
2004 fschmid 350
        pixm = ScImage();
2173 fschmid 351
        pixm.imgInfo.lowResType = Doc->toolSettings.lowResType;
3 paul 352
        Pfile2 = "";
353
        Pfile3 = "";
354
        LocalScX = 1;
355
        LocalScY = 1;
356
        OrigW = 0;
357
        OrigH = 0;
358
        LocalX = 0;
359
        LocalY = 0;
360
        BBoxX = 0;
361
        BBoxH = 0;
362
        RadRect = 0;
1460 cbradney 363
        if ((itemTypeVal == TextFrame) || (itemTypeVal == ImageFrame))
364
                // TODO: Frame should become a read-only calculated property
3 paul 365
                Frame = true;
366
        else
367
                Frame = false;
1460 cbradney 368
        switch (itemTypeVal)
167 Franz 369
        {
1460 cbradney 370
                case Polygon:
340 Franz 371
                        Clip.setPoints(4, static_cast<int>(w/2), 0, static_cast<int>(w), static_cast<int>(h/2),
372
                                                                static_cast<int>(w/2), static_cast<int>(h), 0,static_cast<int>(h/2));
3 paul 373
                        break;
374
                default:
340 Franz 375
                        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 376
                        break;
167 Franz 377
        }
3 paul 378
        PoLine.resize(0);
340 Franz 379
        ContourLine.resize(0);
2040 fschmid 380
        imageClip.resize(0);
3 paul 381
        Segments.clear();
382
        PoShow = false;
383
        BaseOffs = 0;
3200 cbradney 384
        OwnPage = Doc->currentPage->pageNr();
1211 tsoots 385
        oldOwnPage = OwnPage;
3 paul 386
        PicArt = true;
387
        PicAvail = false;
388
        isPrintable = true;
389
        isBookmark = false;
167 Franz 390
        BMnr = 0;
3 paul 391
        isAnnotation = false;
392
        AnType = 0;
393
        AnActType = 0;
394
        AnBwid = 1;
395
        AnAction = "";
396
        An_E_act = "";
397
        An_X_act = "";
398
        An_D_act = "";
399
        An_Fo_act = "";
400
        An_Bl_act = "";
401
        An_K_act = "";
402
        An_F_act = "";
403
        An_V_act = "";
404
        An_C_act = "";
19 Franz 405
        An_Extern = "";
1460 cbradney 406
        switch (itemTypeVal)
268 Franz 407
        {
1460 cbradney 408
        case ImageFrame:
268 Franz 409
                AnName = tr("Image");
1250 tsoots 410
                setUPixmap(Um::IImageFrame);
268 Franz 411
                break;
1460 cbradney 412
        case TextFrame:
268 Franz 413
                AnName = tr("Text");
1250 tsoots 414
                setUPixmap(Um::ITextFrame);
268 Franz 415
                break;
1460 cbradney 416
        case Line:
268 Franz 417
                AnName = tr("Line");
1250 tsoots 418
                setUPixmap(Um::ILine);
268 Franz 419
                break;
1460 cbradney 420
        case Polygon:
268 Franz 421
                AnName = tr("Polygon");
1250 tsoots 422
                setUPixmap(Um::IPolygon);
268 Franz 423
                break;
1460 cbradney 424
        case PolyLine:
268 Franz 425
                AnName = tr("Polyline");
1250 tsoots 426
                setUPixmap(Um::IPolyline);
268 Franz 427
                break;
1460 cbradney 428
        case PathText:
268 Franz 429
                AnName = tr("PathText");
1250 tsoots 430
                setUPixmap(Um::IPathText);
268 Franz 431
                break;
432
        default:
433
                AnName = "Item";
434
                break;
435
        }
270 Franz 436
        AnName += tmp.setNum(Doc->TotalItems); // +" "+QDateTime::currentDateTime().toString();
87 Franz 437
        AutoName = true;
1204 tsoots 438
        setUName(AnName);
3 paul 439
        Doc->TotalItems++;
440
        AnToolTip = "";
441
        AnRollOver = "";
442
        AnDown = "";
443
        AnBsty = 0;
444
        AnFeed = 1;
445
        AnFlag = 0;
446
        AnZiel = 0;
447
        AnVis = 0;
448
        AnChkStil = 0;
449
        AnFormat = 0;
450
        AnFont = 4;
451
        AnIsChk = false;
452
        AnAAact = false;
453
        AnHTML = false;
454
        AnUseIcons = false;
455
        AnIPlace = 1;
456
        AnScaleW = 0;
457
        AnMaxChar = -1;
458
        AnBColor = outline;
459
        HasSel = false;
460
        Tinput = false;
461
        isAutoText = false;
1065 cbradney 462
        textAlignment = 0;
3 paul 463
        Redrawn = false;
464
        isRaster = false;
465
        Sizing = false;
466
        toPixmap = false;
467
        UseEmbedded = true;
468
        EmProfile = "";
469
        Groups.clear();
2937 cbradney 470
        LayerNr = Doc->activeLayer();
3 paul 471
        ScaleType = true;
472
        AspectRatio = true;
473
        Reverse = false;
27 Franz 474
        NamedLStyle = "";
68 Franz 475
        DashValues.clear();
139 Franz 476
        TabValues.clear();
68 Franz 477
        DashOffset = 0;
1905 fschmid 478
        fillRule = true;
68 Franz 479
        fill_gradient = VGradient(VGradient::linear);
295 Franz 480
        fill_gradient.clearStops();
1394 cbradney 481
        if (fillColor() == "None")
1194 fschmid 482
                fill_gradient.addStop(Doc->PageColors[Doc->toolSettings.dBrush].getRGBColor(), 0.0, 0.5, 1.0, Doc->toolSettings.dBrush, 100);
304 Franz 483
        else
1394 cbradney 484
                fill_gradient.addStop(Doc->PageColors[fillColor()].getRGBColor(), 0.0, 0.5, 1.0, fillColor(), 100);
485
        if (lineColor() == "None")
1194 fschmid 486
                fill_gradient.addStop(Doc->PageColors[Doc->toolSettings.dPen].getRGBColor(), 1.0, 0.5, 1.0, Doc->toolSettings.dPen, 100);
304 Franz 487
        else
2180 fschmid 488
                fill_gradient.addStop(Doc->PageColors[lineColor()].getRGBColor(), 1.0, 0.5, 1.0, lineColor(), 100);
456 fschmid 489
        Language = Doc->Language;
1194 fschmid 490
        Cols = Doc->toolSettings.dCols;
491
        ColGap = Doc->toolSettings.dGap;
232 Franz 492
        LeftLink = 0;
493
        RightLink = 0;
494
        TopLink = 0;
495
        BottomLink = 0;
234 Franz 496
        LeftLinkID = 0;
497
        RightLinkID = 0;
498
        TopLinkID = 0;
499
        BottomLinkID = 0;
232 Franz 500
        LeftLine = 0;
501
        RightLine = false;
502
        TopLine = false;
503
        BottomLine = false;
504
        isTableItem = false;
505
        isSingleSel = false;
383 Franz 506
        Dirty = false;
456 fschmid 507
        ChangedMasterItem = false;
2434 fschmid 508
        isEmbedded = false;
1065 cbradney 509
        OnMasterPage = Doc->currentPage->PageNam;
1194 fschmid 510
        startArrowIndex = Doc->toolSettings.dStartArrow;
511
        endArrowIndex = Doc->toolSettings.dEndArrow;
1204 tsoots 512
        undoManager = UndoManager::instance();
2056 fschmid 513
        effectsInUse.clear();
1659 cbradney 514
        //Page Item Attributes
515
        pageItemAttributes.clear();
516
        for(ObjAttrVector::Iterator objAttrIt = Doc->docItemAttributes.begin() ; objAttrIt != Doc->docItemAttributes.end(); ++objAttrIt )
517
        {
518
                if (((*objAttrIt).autoaddto=="textframes" && itemTypeVal==TextFrame) ||
519
                        ((*objAttrIt).autoaddto=="imageframes" && itemTypeVal==ImageFrame)
520
                        )
521
                        pageItemAttributes.append(*objAttrIt);
522
        }
3 paul 523
}
524
 
525
/** Zeichnet das Item */
68 Franz 526
void PageItem::DrawObj(ScPainter *p, QRect e)
3 paul 527
{
2434 fschmid 528
        double sc;
1740 cbradney 529
        if (!Doc->DoDrawing)
530
        {
531
                Redrawn = true;
532
                Tinput = false;
533
                FrameOnly = false;
534
                return;
535
        }
2434 fschmid 536
        DrawObj_Pre(p, sc);
1736 cbradney 537
        switch(itemType())
538
        {
539
                case TextFrame:
3617 cbradney 540
                        DrawObj_Item(p, e, sc);
1736 cbradney 541
                        break;
3617 cbradney 542
                case ImageFrame:
1736 cbradney 543
                case PathText:
3617 cbradney 544
                        DrawObj_Item(p, sc);
1736 cbradney 545
                        break;
546
                default:
3617 cbradney 547
                        DrawObj_Item(p);
1736 cbradney 548
                        break;
549
        }
2434 fschmid 550
        DrawObj_Post(p);
1736 cbradney 551
}
552
 
2434 fschmid 553
void PageItem::DrawObj_Pre(ScPainter *p, double &sc)
1740 cbradney 554
{
2380 cbradney 555
        sc = ScApp->view->getScale();
1741 cbradney 556
        p->save();
2434 fschmid 557
        if (!isEmbedded)
558
        {
559
                p->setZoomFactor(sc);
560
                p->translate(Xpos*sc, Ypos*sc);
2955 fschmid 561
//              p->rotate(Rot);
562
        }
2434 fschmid 563
                p->rotate(Rot);
1741 cbradney 564
        p->setLineWidth(Pwidth);
565
        if (GrType != 0)
566
        {
567
                p->setFillMode(ScPainter::Gradient);
568
                p->fill_gradient = fill_gradient;
569
                QWMatrix grm;
570
                grm.rotate(Rot);
571
                FPointArray gra;
572
                switch (GrType)
573
                {
574
                        case 1:
575
                        case 2:
576
                        case 3:
577
                        case 4:
578
                        case 6:
579
                                gra.setPoints(2, GrStartX, GrStartY, GrEndX, GrEndY);
580
                                gra.map(grm);
581
                                p->setGradient(VGradient::linear, gra.point(0), gra.point(1));
582
                                break;
583
                        case 5:
584
                        case 7:
585
                                gra.setPoints(2, GrStartX, GrStartY, GrEndX, GrEndY);
586
                                p->setGradient(VGradient::radial, gra.point(0), gra.point(1), gra.point(0));
587
                                break;
588
                }
589
        }
590
        else
591
        {
592
                p->fill_gradient = VGradient(VGradient::linear);
593
                if (fillColor() != "None")
594
                {
2984 fschmid 595
                        p->setBrush(fillQColor);
1741 cbradney 596
                        p->setFillMode(ScPainter::Solid);
597
                }
598
                else
599
                        p->setFillMode(ScPainter::None);
600
        }
601
        if (lineColor() != "None")
602
        {
3625 avox 603
                if ((Pwidth == 0) && ! asLine())
1741 cbradney 604
                        p->setLineWidth(0);
605
                else
606
                {
2984 fschmid 607
                        p->setPen(strokeQColor, Pwidth, PLineArt, PLineEnd, PLineJoin);
1741 cbradney 608
                        if (DashValues.count() != 0)
609
                                p->setDash(DashValues, DashOffset);
610
                }
611
        }
612
        else
613
                p->setLineWidth(0);
614
        p->setBrushOpacity(1.0 - fillTransparency());
615
        p->setPenOpacity(1.0 - lineTransparency());
1740 cbradney 616
}
617
 
2434 fschmid 618
void PageItem::DrawObj_Post(ScPainter *p)
1740 cbradney 619
{
620
        bool doStroke=true;
3113 fschmid 621
        if (itemType()==PathText || itemType()==PolyLine || itemType()==Line)
1740 cbradney 622
                doStroke=false;
2434 fschmid 623
        if ((doStroke) && (!Doc->RePos))
1740 cbradney 624
        {
625
                if (lineColor() != "None")
626
                {
2984 fschmid 627
                        p->setPen(strokeQColor, Pwidth, PLineArt, PLineEnd, PLineJoin);
1740 cbradney 628
                        if (DashValues.count() != 0)
629
                                p->setDash(DashValues, DashOffset);
630
                }
631
                else
632
                        p->setLineWidth(0);
633
                if (!isTableItem)
634
                {
635
                        p->setupPolygon(&PoLine);
2877 cbradney 636
                        if (NamedLStyle.isEmpty())
1740 cbradney 637
                                p->strokePath();
638
                        else
639
                        {
640
                                multiLine ml = Doc->MLineStyles[NamedLStyle];
641
                                QColor tmp;
642
                                for (int it = ml.size()-1; it > -1; it--)
643
                                {
644
                                        SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
645
                                        p->setPen(tmp, ml[it].Width,
646
                                                          static_cast<PenStyle>(ml[it].Dash),
647
                                                          static_cast<PenCapStyle>(ml[it].LineEnd),
648
                                                          static_cast<PenJoinStyle>(ml[it].LineJoin));
649
                                        p->strokePath();
650
                                }
651
                        }
652
                }
653
        }
2434 fschmid 654
        if ((!isEmbedded) && (!Doc->RePos))
655
        {
2380 cbradney 656
                double scpInv = 1.0 / (QMAX(ScApp->view->getScale(), 1));
1740 cbradney 657
                if ((Frame) && (Doc->guidesSettings.framesShown) && ((itemType() == ImageFrame) || (itemType() == TextFrame)))
658
                {
1742 cbradney 659
                        p->setPen(black, scpInv, DotLine, FlatCap, MiterJoin);
1740 cbradney 660
                        if ((isBookmark) || (isAnnotation))
661
                                p->setPen(blue, scpInv, DotLine, FlatCap, MiterJoin);
662
                        if ((BackBox != 0) || (NextBox != 0))
663
                                p->setPen(red, scpInv, SolidLine, FlatCap, MiterJoin);
664
                        if (Locked)
665
                                p->setPen(darkRed, scpInv, SolidLine, FlatCap, MiterJoin);
2707 subik 666
 
1740 cbradney 667
                        p->setFillMode(0);
668
                        p->setupPolygon(&PoLine);
669
                        p->strokePath();
670
                }
671
                if ((Doc->guidesSettings.framesShown) && textFlowUsesContourLine() && (ContourLine.size() != 0))
672
                {
673
                        p->setPen(lightGray, scpInv, DotLine, FlatCap, MiterJoin);
674
                        p->setupPolygon(&ContourLine);
675
                        p->strokePath();
676
                }
2434 fschmid 677
        }
678
        Tinput = false;
679
        FrameOnly = false;
680
        p->restore();
1740 cbradney 681
}
682
 
2434 fschmid 683
void PageItem::DrawObj_Embedded(ScPainter *p, QRect e, struct ZZ *hl)
684
{
2955 fschmid 685
        QPtrList<PageItem> emG;
686
        emG.clear();
2434 fschmid 687
        if (hl->embedded != 0)
688
        {
2453 fschmid 689
                if (!Doc->DoDrawing)
690
                {
691
                        hl->embedded->Redrawn = true;
692
                        hl->embedded->Tinput = false;
693
                        hl->embedded->FrameOnly = false;
694
                        return;
695
                }
2955 fschmid 696
                emG.append(hl->embedded);
697
                if (hl->embedded->Groups.count() != 0)
2443 fschmid 698
                {
2955 fschmid 699
                        for (uint ga=0; ga<Doc->FrameItems.count(); ++ga)
700
                        {
701
                                if (Doc->FrameItems.at(ga)->Groups.count() != 0)
702
                                {
703
                                        if (Doc->FrameItems.at(ga)->Groups.top() == hl->embedded->Groups.top())
704
                                        {
705
                                                if (Doc->FrameItems.at(ga)->ItemNr != hl->embedded->ItemNr)
706
                                                {
707
                                                        if (emG.find(Doc->FrameItems.at(ga)) == -1)
708
                                                                emG.append(Doc->FrameItems.at(ga));
709
                                                }
710
                                        }
711
                                }
712
                        }
2443 fschmid 713
                }
2955 fschmid 714
                for (uint em = 0; em < emG.count(); ++em)
2451 fschmid 715
                {
2955 fschmid 716
                        PageItem* embedded = emG.at(em);
717
                        struct ParagraphStyle vg;
718
                        QValueList<ParagraphStyle> savedParagraphStyles;
719
                        for (int xxx=0; xxx<5; ++xxx)
720
                        {
721
                                vg.LineSpaMode = Doc->docParagraphStyles[xxx].LineSpaMode;
722
                                vg.BaseAdj = Doc->docParagraphStyles[xxx].BaseAdj;
723
                                vg.LineSpa = Doc->docParagraphStyles[xxx].LineSpa;
724
                                vg.FontSize = Doc->docParagraphStyles[xxx].FontSize;
725
                                vg.Indent = Doc->docParagraphStyles[xxx].Indent;
726
                                vg.First = Doc->docParagraphStyles[xxx].First;
727
                                vg.gapBefore = Doc->docParagraphStyles[xxx].gapBefore;
728
                                vg.gapAfter = Doc->docParagraphStyles[xxx].gapAfter;
729
                                savedParagraphStyles.append(vg);
730
                        }
731
                        p->save();
732
                        embedded->Xpos = Xpos + hl->xco + embedded->gXpos;
733
                        embedded->Ypos = Ypos + (hl->yco - (embedded->gHeight * (hl->scalev / 1000.0))) + embedded->gYpos;
734
                        p->translate((hl->xco + embedded->gXpos * (hl->scale / 1000.0)) * p->zoomFactor(), (hl->yco - (embedded->gHeight * (hl->scalev / 1000.0)) + embedded->gYpos * (hl->scalev / 1000.0)) * p->zoomFactor());
735
                        if (hl->base != 0)
736
                        {
737
                                p->translate(0, -embedded->gHeight * (hl->base / 1000.0) * p->zoomFactor());
738
                                embedded->Ypos -= embedded->gHeight * (hl->base / 1000.0);
739
                        }
740
                        p->scale(hl->scale / 1000.0, hl->scalev / 1000.0);
741
                        embedded->Dirty = Dirty;
742
                        double sc;
743
                        double pws = embedded->Pwidth;
744
                        embedded->DrawObj_Pre(p, sc);
745
                        switch(embedded->itemType())
746
                        {
747
                                case ImageFrame:
3617 cbradney 748
                                        //embedded->DrawObj_ImageFrame(p, sc);
749
                                        embedded->DrawObj_Item(p, sc);
2955 fschmid 750
                                        break;
751
                                case TextFrame:
3617 cbradney 752
                                        //embedded->DrawObj_TextFrame(p, e, sc);
753
                                        embedded->DrawObj_Item(p, e, sc);
2955 fschmid 754
                                        break;
755
                                case Line:
756
                                        embedded->Pwidth = pws * QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
3617 cbradney 757
                                        //embedded->DrawObj_Line(p);
758
                                        embedded->DrawObj_Item(p);
2955 fschmid 759
                                        break;
760
                                case Polygon:
3617 cbradney 761
                                        //embedded->DrawObj_Polygon(p);
762
                                        embedded->DrawObj_Item(p);
2955 fschmid 763
                                        break;
764
                                case PolyLine:
765
                                        embedded->Pwidth = pws * QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
3617 cbradney 766
                                        //embedded->DrawObj_PolyLine(p);
767
                                        embedded->DrawObj_Item(p);
2955 fschmid 768
                                        break;
769
                                case PathText:
3617 cbradney 770
                                        //embedded->DrawObj_PathText(p, sc);
771
                                        embedded->DrawObj_Item(p, sc);
2955 fschmid 772
                                        break;
773
                                default:
774
                                        break;
775
                        }
776
                        embedded->Pwidth = pws * QMIN(hl->scale / 1000.0, hl->scalev / 1000.0);
777
                        embedded->DrawObj_Post(p);
778
                        p->restore();
779
                        embedded->Pwidth = pws;
780
                        for (int xxx=0; xxx<5; ++xxx)
781
                        {
782
                                Doc->docParagraphStyles[xxx].LineSpaMode = savedParagraphStyles[xxx].LineSpaMode;
783
                                Doc->docParagraphStyles[xxx].BaseAdj = savedParagraphStyles[xxx].BaseAdj;
784
                                Doc->docParagraphStyles[xxx].LineSpa = savedParagraphStyles[xxx].LineSpa;
785
                                Doc->docParagraphStyles[xxx].FontSize = savedParagraphStyles[xxx].FontSize;
786
                                Doc->docParagraphStyles[xxx].Indent = savedParagraphStyles[xxx].Indent;
787
                                Doc->docParagraphStyles[xxx].First = savedParagraphStyles[xxx].First;
788
                                Doc->docParagraphStyles[xxx].gapBefore = savedParagraphStyles[xxx].gapBefore;
789
                                Doc->docParagraphStyles[xxx].gapAfter = savedParagraphStyles[xxx].gapAfter;
790
                        }
791
                        savedParagraphStyles.clear();
2451 fschmid 792
                }
2434 fschmid 793
        }
794
}
795
 
68 Franz 796
void PageItem::paintObj(QRect e, QPixmap *ppX)
797
{
798
        if (!Doc->DoDrawing)
167 Franz 799
        {
68 Franz 800
                Redrawn = true;
801
                Tinput = false;
802
                FrameOnly = false;
803
                return;
167 Franz 804
        }
1795 cbradney 805
        //qDebug("paintObj(QRect e, QPixmap *ppX)");
1740 cbradney 806
        QPainter p;
2380 cbradney 807
        double sc = ScApp->view->getScale();
68 Franz 808
        if (toPixmap)
809
                p.begin(ppX);
810
        else
456 fschmid 811
                p.begin(ScApp->view->viewport());
68 Franz 812
        if ((!toPixmap) && (!Doc->RePos))
167 Franz 813
        {
68 Franz 814
                if (!e.isEmpty())
815
                        p.setClipRect(e);
816
                else
456 fschmid 817
                {
818
                        int x = ScApp->view->contentsX();
819
                        int y = ScApp->view->contentsY();
820
                        QPoint out = ScApp->view->contentsToViewport(QPoint(x,y));
821
                        p.setClipRect(QRect(out.x(), out.y(), ScApp->view->visibleWidth(), ScApp->view->visibleWidth()));
822
                }
167 Franz 823
        }
2848 fschmid 824
        QPoint in  = QPoint(qRound((Xpos-Doc->minCanvasCoordinate.x())*sc), qRound((Ypos-Doc->minCanvasCoordinate.y())*sc));
456 fschmid 825
        QPoint out = ScApp->view->contentsToViewport(in);
826
        p.translate(out.x(), out.y());
827
        p.scale(sc, sc);
828
        p.rotate(Rot);
3 paul 829
        if (Sizing)
167 Franz 830
        {
3 paul 831
                p.setRasterOp(XorROP);
832
                p.setBrush(NoBrush);
833
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
834
                p.drawRect(0, 0, static_cast<int>(OldB), static_cast<int>(OldH));
835
                p.drawRect(0, 0, static_cast<int>(Width), static_cast<int>(Height));
836
                OldB = Width;
837
                OldH = Height;
167 Franz 838
        }
3 paul 839
        if ((!Tinput) && (!Doc->RePos))
167 Franz 840
        {
3 paul 841
                if (Select) // && (!Doc->EditClip))
167 Franz 842
                {
456 fschmid 843
                        if (!ScApp->view->SelItem.isEmpty())
3 paul 844
                        {
167 Franz 845
                                if (Groups.count() == 0)
3 paul 846
                                {
847
                                        QPainter pr;
456 fschmid 848
                                        pr.begin(ScApp->view->viewport());
849
                                        pr.translate(out.x(), out.y());
850
                                        pr.rotate(Rot);
3 paul 851
                                        if (Locked)
852
                                                pr.setPen(QPen(darkRed, 1, SolidLine, FlatCap, MiterJoin));
853
                                        else
854
                                                pr.setPen(QPen(red, 1, DotLine, FlatCap, MiterJoin));
855
                                        pr.setBrush(NoBrush);
456 fschmid 856
                                        pr.drawRect(-1, -1, static_cast<int>(Width*sc)+2, static_cast<int>(Height*sc)+2);
266 Franz 857
                                        pr.setPen(QPen(red, 1, SolidLine, FlatCap, MiterJoin));
858
                                        pr.setBrush(red);
859
                                        if ((!Locked) && (!LockRes))
167 Franz 860
                                        {
3625 avox 861
                                                if (! asLine())
167 Franz 862
                                                {
266 Franz 863
                                                        pr.drawRect(-1, -1, 6, 6);
456 fschmid 864
                                                        pr.drawRect(static_cast<int>(Width*sc), static_cast<int>(Height*sc), -6, -6);
865
                                                        pr.drawRect(static_cast<int>(Width*sc), -1, -6, 6);
866
                                                        pr.drawRect(-1, static_cast<int>(Height*sc), 6, -6);
266 Franz 867
                                                        if (Width > 6)
868
                                                        {
456 fschmid 869
                                                                pr.drawRect(static_cast<int>(Width/2*sc - 3), static_cast<int>(Height*sc), 6, -6);
870
                                                                pr.drawRect(static_cast<int>(Width/2*sc - 3), -1, 6, 6);
266 Franz 871
                                                        }
872
                                                        if (Height > 6)
873
                                                        {
456 fschmid 874
                                                                pr.drawRect(static_cast<int>(Width*sc), static_cast<int>(Height/2*sc - 3), -6, 6);
875
                                                                pr.drawRect(-1, static_cast<int>(Height/2*sc - 3), 6, 6);
266 Franz 876
                                                        }
167 Franz 877
                                                }
266 Franz 878
                                                else
167 Franz 879
                                                {
266 Franz 880
                                                        pr.drawRect(-3, -3, 6, 6);
456 fschmid 881
                                                        pr.drawRect(static_cast<int>(Width*sc)+3, -3, -6, 6);
3 paul 882
                                                }
167 Franz 883
                                        }
3 paul 884
                                        pr.end();
167 Franz 885
                                }
3 paul 886
                                else
167 Franz 887
                                {
3 paul 888
                                        p.setPen(QPen(darkCyan, 1, DotLine, FlatCap, MiterJoin));
889
                                        p.setBrush(NoBrush);
24 Franz 890
                                        p.drawRect(-1, -1, static_cast<int>(Width+2), static_cast<int>(Height+2));
456 fschmid 891
                                        if (ScApp->view->SelItem.count() == 1)
227 Franz 892
                                        {
893
                                                QPainter pr;
456 fschmid 894
                                                pr.begin(ScApp->view->viewport());
895
                                                pr.translate(out.x(), out.y());
896
                                                pr.rotate(Rot);
227 Franz 897
                                                pr.setPen(QPen(darkCyan, 1, SolidLine, FlatCap, MiterJoin));
898
                                                pr.setBrush(darkCyan);
899
                                                pr.drawRect(-1, -1, 6, 6);
456 fschmid 900
                                                pr.drawRect(static_cast<int>(Width*sc), static_cast<int>(Height*sc), -6, -6);
901
                                                pr.drawRect(static_cast<int>(Width*sc), -1, -6, 6);
902
                                                pr.drawRect(-1, static_cast<int>(Height*sc), 6, -6);
227 Franz 903
                                                if (Width > 6)
904
                                                {
456 fschmid 905
                                                        pr.drawRect(static_cast<int>(Width/2*sc - 3), static_cast<int>(Height*sc), 6, -6);
906
                                                        pr.drawRect(static_cast<int>(Width/2*sc - 3), -1, 6, 6);
227 Franz 907
                                                }
908
                                                if (Height > 6)
909
                                                {
456 fschmid 910
                                                        pr.drawRect(static_cast<int>(Width*sc), static_cast<int>(Height/2*sc - 3), -6, 6);
911
                                                        pr.drawRect(-1, static_cast<int>(Height/2*sc - 3), 6, 6);
227 Franz 912
                                                }
913
                                                pr.end();
914
                                        }
3 paul 915
                                }
916
                        }
917
                }
167 Franz 918
        }
3 paul 919
        Tinput = false;
920
        FrameOnly = false;
921
        p.end();
1286 tsoots 922
//      checkChanges(); // Check changes for undo actions
3 paul 923
}
924
 
925
QString PageItem::ExpandToken(uint base)
926
{
927
        uint zae = 0;
362 Franz 928
        uint za2 = base;
3617 cbradney 929
        QString chx("#");
3724 cbradney 930
        if ((!Doc->masterPageMode()) && (OwnPage != -1))
167 Franz 931
        {
362 Franz 932
                do
3 paul 933
                {
362 Franz 934
                        if (za2 == 0)
935
                                break;
936
                        za2--;
937
                }
1065 cbradney 938
                while (itemText.at(za2)->ch == QChar(30));
939
                if (itemText.at(za2)->ch != QChar(30))
362 Franz 940
                        za2++;
1065 cbradney 941
                while (itemText.at(za2+zae)->ch == QChar(30))
362 Franz 942
                {
3 paul 943
                        zae++;
1065 cbradney 944
                        if (za2+zae == itemText.count())
3 paul 945
                                break;
167 Franz 946
                }
3617 cbradney 947
                QString out("%1");
362 Franz 948
                QString out2;
3757 cbradney 949
                //CB Section numbering
950
                //out2 = out.arg(OwnPage+Doc->FirstPnum, -zae);
951
                out2=out.arg(Doc->getSectionPageNumberForPageIndex(OwnPage), -zae);
3761 cbradney 952
                //out2=out.arg(out2, -zae);
362 Franz 953
                chx = out2.mid(base-za2, 1);
167 Franz 954
        }
3 paul 955
        return chx;
956
}
957
 
958
void PageItem::SetFarbe(QColor *tmp, QString farbe, int shad)
959
{
1488 fschmid 960
        *tmp = Doc->PageColors[farbe].getShadeColorProof(shad);
3 paul 961
}
962
 
1065 cbradney 963
double PageItem::SetZeichAttr(struct ScText *hl, int *chs, QString *chx)
3 paul 964
{
157 Franz 965
        double retval = 0.0;
1789 fschmid 966
        double asce = hl->cfont->numAscent * (hl->csize / 10.0);
2185 fschmid 967
        int chst = hl->cstyle & 1919;
3 paul 968
        if (chst != 0)
167 Franz 969
        {
970
                if (chst & 1)
3 paul 971
                {
2889 cbradney 972
                        retval -= asce * Doc->typographicSettings.valueSuperScript / 100;
973
                        *chs = QMAX(static_cast<int>(hl->csize * Doc->typographicSettings.scalingSuperScript / 100), 1);
167 Franz 974
                }
3 paul 975
                if (chst & 2)
167 Franz 976
                {
2889 cbradney 977
                        retval += asce * Doc->typographicSettings.valueSubScript / 100;
978
                        *chs = QMAX(static_cast<int>(hl->csize * Doc->typographicSettings.scalingSubScript / 100), 1);
167 Franz 979
                }
2185 fschmid 980
                if (chst & 32)
981
                {
982
                        if (chx->upper() != *chx)
983
                                *chx = chx->upper();
984
                }
3 paul 985
                if (chst & 64)
167 Franz 986
                {
987
                        if (chx->upper() != *chx)
3 paul 988
                        {
2889 cbradney 989
                                *chs = QMAX(static_cast<int>(hl->csize * Doc->typographicSettings.valueSmallCaps / 100), 1);
3 paul 990
                                *chx = chx->upper();
991
                        }
992
                }
167 Franz 993
        }
157 Franz 994
        return retval;
3 paul 995
}
996
 
68 Franz 997
void PageItem::DrawZeichenS(ScPainter *p, struct ZZ *hl)
3 paul 998
{
2353 fschmid 999
        double csi = static_cast<double>(hl->Siz) / 100.0;
55 Franz 1000
        QString ccx = hl->Zeich;
2389 fschmid 1001
        if ((Doc->guidesSettings.showControls) && ((ccx == QChar(9)) || (ccx == QChar(29)) || ((ccx == QChar(26)) && (Cols > 1))|| (ccx == QChar(27)) || (ccx == QChar(32))))
2353 fschmid 1002
        {
2389 fschmid 1003
                QWMatrix chma, chma2, chma4, chma5;
2353 fschmid 1004
                FPointArray points;
1005
                if (ccx == QChar(9))
2389 fschmid 1006
                {
2353 fschmid 1007
                        points = Doc->symTab.copy();
2389 fschmid 1008
                        chma4.translate(hl->xco-((hl->Siz / 100.0) * 7.0), hl->yco-((hl->Siz / 10.0) * 0.5));
1009
                }
1010
                else if (ccx == QChar(26))
1011
                {
1012
                        points = Doc->symNewCol.copy();
1013
                        chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * 0.6));
1014
                }
1015
                else if (ccx == QChar(27))
1016
                {
1017
                        points = Doc->symNewFrame.copy();
1018
                        chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * 0.6));
1019
                }
2353 fschmid 1020
                else
2389 fschmid 1021
                {
2353 fschmid 1022
                        points = Doc->symNonBreak.copy();
2389 fschmid 1023
                        chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * 0.4));
1024
                }
2353 fschmid 1025
                chma.scale(csi, csi);
1026
                chma2.scale(hl->scale / 1000.0, hl->scalev / 1000.0);
1027
                chma5.scale(p->zoomFactor(), p->zoomFactor());
2359 fschmid 1028
                points.map(chma * chma2 * chma4 * chma5);
2353 fschmid 1029
                p->setupTextPolygon(&points);
2359 fschmid 1030
                if (ccx == QChar(32))
1031
                {
1032
                        QColor tmp = p->pen();
1033
                        p->setPen(p->brush(), 1, SolidLine, FlatCap, MiterJoin);
1034
                        p->setLineWidth(hl->Siz / 200.0);
1035
                        p->strokePath();
1036
                        p->setPen(tmp, 1, SolidLine, FlatCap, MiterJoin);
1037
                }
1038
                else
1039
                {
1040
                        p->setFillMode(1);
1041
                        p->fillPath();
1042
                }
2353 fschmid 1043
        }
2384 fschmid 1044
        if ((ccx == QChar(13)) || (ccx == QChar(9)) || (ccx == QChar(28)) || (ccx == QChar(27)) || (ccx == QChar(26)))
167 Franz 1045
                return;
55 Franz 1046
        if (ccx == QChar(29))
1047
                ccx = " ";
2407 fschmid 1048
        if (ccx == QChar(24))
1049
                ccx = "-";
55 Franz 1050
        uint chr = ccx[0].unicode();
1789 fschmid 1051
        if (hl->ZFo->CharWidth.contains(chr))
167 Franz 1052
        {
1998 fschmid 1053
                QWMatrix chma, chma2, chma3, chma4, chma5, chma6;
68 Franz 1054
                chma.scale(csi, csi);
638 fschmid 1055
                chma5.scale(p->zoomFactor(), p->zoomFactor());
1789 fschmid 1056
                FPointArray gly = hl->ZFo->GlyphArray[chr].Outlines.copy();
87 Franz 1057
                if (gly.size() > 3)
167 Franz 1058
                {
2242 fschmid 1059
                        chma2.scale(hl->scale / 1000.0, hl->scalev / 1000.0);
68 Franz 1060
                        if (Reverse)
167 Franz 1061
                        {
638 fschmid 1062
                                chma3.scale(-1, 1);
1063
                                chma3.translate(-hl->wide, 0);
2242 fschmid 1064
                                chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * (hl->scalev / 1000.0)));
167 Franz 1065
                        }
68 Franz 1066
                        else
2242 fschmid 1067
                                chma4.translate(hl->xco, hl->yco-((hl->Siz / 10.0) * (hl->scalev / 1000.0)));
2234 fschmid 1068
                        if (hl->base != 0)
2242 fschmid 1069
                                chma6.translate(0, -(hl->Siz / 10.0) * (hl->base / 1000.0) * p->zoomFactor());
2234 fschmid 1070
                        gly.map(chma * chma2 * chma3 * chma4 * chma5 * chma6);
87 Franz 1071
                        p->setFillMode(1);
1888 fschmid 1072
                        bool fr = p->fillRule();
1073
                        p->setFillRule(false);
638 fschmid 1074
                        p->setupTextPolygon(&gly);
2257 fschmid 1075
                        if ((hl->ZFo->isStroked) && ((hl->Siz * hl->outline / 10000.0) != 0))
167 Franz 1076
                        {
220 Franz 1077
                                QColor tmp = p->brush();
1078
                                p->setPen(tmp, 1, SolidLine, FlatCap, MiterJoin);
2257 fschmid 1079
                                p->setLineWidth(hl->Siz * hl->outline / 10000.0);
68 Franz 1080
                                p->strokePath();
3 paul 1081
                        }
220 Franz 1082
                        else
1083
                        {
2261 fschmid 1084
                                if ((hl->Style & 256) && (hl->Farb2 != "None"))
2229 fschmid 1085
                                {
2261 fschmid 1086
                                        p->save();
1087
                                        p->translate((hl->Siz * hl->shadowX / 10000.0) * p->zoomFactor(), -(hl->Siz * hl->shadowY / 10000.0) * p->zoomFactor());
1088
                                        QColor tmp = p->brush();
1089
                                        p->setBrush(p->pen());
3674 fschmid 1090
#ifdef HAVE_CAIRO
1091
                                        p->setupTextPolygon(&gly);
1092
#endif
220 Franz 1093
                                        p->fillPath();
2261 fschmid 1094
                                        p->setBrush(tmp);
1095
                                        p->restore();
3674 fschmid 1096
#ifdef HAVE_CAIRO
1097
                                        p->setupTextPolygon(&gly);
1098
#endif
2229 fschmid 1099
                                }
2261 fschmid 1100
                                if (hl->Farb != "None")
1101
                                        p->fillPath();
2257 fschmid 1102
                                if ((hl->Style & 4) && (hl->Farb2 != "None") && ((hl->Siz * hl->outline / 10000.0) != 0))
220 Franz 1103
                                {
2257 fschmid 1104
                                        p->setLineWidth(hl->Siz * hl->outline / 10000.0);
220 Franz 1105
                                        p->strokePath();
1106
                                }
1107
                        }
1888 fschmid 1108
                        p->setFillRule(fr);
167 Franz 1109
                }
68 Franz 1110
                if (hl->Style & 16)
167 Franz 1111
                {
2176 fschmid 1112
                        double st, lw;
2272 fschmid 1113
                        if ((hl->strikepos != -1) || (hl->strikewidth != -1))
2176 fschmid 1114
                        {
2272 fschmid 1115
                                if (hl->strikepos != -1)
1116
                                        st = (hl->strikepos / 1000.0) * (hl->ZFo->numAscent * (hl->realSiz / 10.0));
2176 fschmid 1117
                                else
2185 fschmid 1118
                                        st = hl->ZFo->strikeout_pos * (hl->realSiz / 10.0);
2272 fschmid 1119
                                if (hl->strikewidth != -1)
1120
                                        lw = (hl->strikewidth / 1000.0) * (hl->realSiz / 10.0);
2176 fschmid 1121
                                else
2185 fschmid 1122
                                        lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
2176 fschmid 1123
                        }
1124
                        else
1125
                        {
2185 fschmid 1126
                                st = hl->ZFo->strikeout_pos * (hl->realSiz / 10.0);
1127
                                lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
2176 fschmid 1128
                        }
2234 fschmid 1129
                        if (hl->base != 0)
2242 fschmid 1130
                                st += (hl->Siz / 10.0) * (hl->base / 1000.0);
68 Franz 1131
                        p->setPen(p->brush());
2176 fschmid 1132
                        p->setLineWidth(lw);
68 Franz 1133
                        p->drawLine(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st));
167 Franz 1134
                }
2188 fschmid 1135
                if ((hl->Style & 8) || ((hl->Style & 512) && (!ccx[0].isSpace())))
167 Franz 1136
                {
2174 fschmid 1137
                        double st, lw;
2262 fschmid 1138
                        if ((hl->underpos != -1) || (hl->underwidth != -1))
2174 fschmid 1139
                        {
2262 fschmid 1140
                                if (hl->underpos != -1)
1141
                                        st = (hl->underpos / 1000.0) * (hl->ZFo->numDescender * (hl->realSiz / 10.0));
2174 fschmid 1142
                                else
2185 fschmid 1143
                                        st = hl->ZFo->underline_pos * (hl->realSiz / 10.0);
2262 fschmid 1144
                                if (hl->underwidth != -1)
1145
                                        lw = (hl->underwidth / 1000.0) * (hl->realSiz / 10.0);
2174 fschmid 1146
                                else
2185 fschmid 1147
                                        lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
2174 fschmid 1148
                        }
1149
                        else
1150
                        {
2185 fschmid 1151
                                st = hl->ZFo->underline_pos * (hl->realSiz / 10.0);
1152
                                lw = QMAX(hl->ZFo->strokeWidth * (hl->realSiz / 10.0), 1);
2174 fschmid 1153
                        }
2234 fschmid 1154
                        if (hl->base != 0)
2242 fschmid 1155
                                st += (hl->Siz / 10.0) * (hl->base / 1000.0);
68 Franz 1156
                        p->setPen(p->brush());
2174 fschmid 1157
                        p->setLineWidth(lw);
265 Franz 1158
                        p->drawLine(FPoint(hl->xco-hl->kern, hl->yco-st), FPoint(hl->xco+hl->wide, hl->yco-st));
3 paul 1159
                }
167 Franz 1160
        }
68 Franz 1161
        else
167 Franz 1162
        {
68 Franz 1163
                p->setLineWidth(1);
1198 fschmid 1164
                p->setPen(red);
1165
                p->setBrush(red);
1166
                p->setFillMode(1);
2242 fschmid 1167
                p->drawRect(hl->xco, hl->yco-(hl->Siz / 10.0), (hl->Siz / 10.0)*(hl->scale / 1000.0), (hl->Siz / 10.0));
167 Franz 1168
        }
3 paul 1169
}
1170
 
27 Franz 1171
void PageItem::DrawPolyL(QPainter *p, QPointArray pts)
1172
{
1173
        QColor tmp;
3 paul 1174
        if (Segments.count() != 0)
167 Franz 1175
        {
3634 cbradney 1176
                QValueList<uint>::Iterator it2end=Segments.end();
3 paul 1177
                uint FirstVal = 0;
3634 cbradney 1178
                for (QValueList<uint>::Iterator it2 = Segments.begin(); it2 != it2end; ++it2)
167 Franz 1179
                {
2877 cbradney 1180
                        if (NamedLStyle.isEmpty())
27 Franz 1181
                                p->drawPolyline(pts, FirstVal, (*it2)-FirstVal);
1182
                        else
167 Franz 1183
                        {
27 Franz 1184
                                multiLine ml = Doc->MLineStyles[NamedLStyle];
31 Franz 1185
                                for (int it = ml.size()-1; it > -1; it--)
167 Franz 1186
                                {
27 Franz 1187
                                        SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1188
                                        p->setPen(QPen(tmp,
2380 cbradney 1189
                                                                         QMAX(static_cast<int>(ml[it].Width*ScApp->view->getScale()), 1),
27 Franz 1190
                                                                         static_cast<PenStyle>(ml[it].Dash),
1191
                                                                         static_cast<PenCapStyle>(ml[it].LineEnd),
1192
                                                                         static_cast<PenJoinStyle>(ml[it].LineJoin)));
1193
                                        p->drawPolyline(pts, FirstVal, (*it2)-FirstVal);
1194
                                }
167 Franz 1195
                        }
3 paul 1196
                        FirstVal = (*it2);
167 Franz 1197
                }
2877 cbradney 1198
                if (NamedLStyle.isEmpty())
27 Franz 1199
                        p->drawPolyline(pts, FirstVal);
1200
                else
167 Franz 1201
                {
27 Franz 1202
                        multiLine ml = Doc->MLineStyles[NamedLStyle];
31 Franz 1203
                        for (int it = ml.size()-1; it > -1; it--)
167 Franz 1204
                        {
27 Franz 1205
                                SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1206
                                p->setPen(QPen(tmp,
2380 cbradney 1207
                                                                 QMAX(static_cast<int>(ml[it].Width*ScApp->view->getScale()), 1),
27 Franz 1208
                                                                 static_cast<PenStyle>(ml[it].Dash),
1209
                                                                 static_cast<PenCapStyle>(ml[it].LineEnd),
1210
                                                                 static_cast<PenJoinStyle>(ml[it].LineJoin)));
1211
                                p->drawPolyline(pts, FirstVal);
1212
                        }
3 paul 1213
                }
167 Franz 1214
        }
3 paul 1215
        else
167 Franz 1216
        {
2877 cbradney 1217
                if (NamedLStyle.isEmpty())
27 Franz 1218
                        p->drawPolyline(pts);
1219
                else
167 Franz 1220
                {
27 Franz 1221
                        multiLine ml = Doc->MLineStyles[NamedLStyle];
31 Franz 1222
                        for (int it = ml.size()-1; it > -1; it--)
167 Franz 1223
                        {
27 Franz 1224
                                SetFarbe(&tmp, ml[it].Color, ml[it].Shade);
1225
                                p->setPen(QPen(tmp,
2380 cbradney 1226
                                                                 QMAX(static_cast<int>(ml[it].Width*ScApp->view->getScale()), 1),
27 Franz 1227
                                                                 static_cast<PenStyle>(ml[it].Dash),
1228
                                                                 static_cast<PenCapStyle>(ml[it].LineEnd),
1229
                                                                 static_cast<PenJoinStyle>(ml[it].LineJoin)));
1230
                                p->drawPolyline(pts);
3 paul 1231
                        }
1232
                }
167 Franz 1233
        }
3 paul 1234
}
1204 tsoots 1235
 
1371 tsoots 1236
QString PageItem::itemName() const
1204 tsoots 1237
{
1361 tsoots 1238
        return AnName;
1239
}
1240
 
1241
void PageItem::setItemName(const QString& newName)
1242
{
1432 tsoots 1243
        if (AnName == newName)
1244
                return; // nothing to do -> return
1357 tsoots 1245
        if (UndoManager::undoEnabled())
1246
        {
1247
                SimpleState *ss = new SimpleState(Um::Rename, QString(Um::FromTo).arg(AnName).arg(newName));
1248
                ss->set("OLD_NAME", AnName);
1249
                ss->set("NEW_NAME", newName);
1250
                undoManager->action(this, ss);
1251
        }
1204 tsoots 1252
        AnName = newName;
1238 tsoots 1253
        setUName(newName); // set the name for the UndoObject too
1204 tsoots 1254
}
1255
 
1381 cbradney 1256
QString PageItem::fillColor() const
1257
{
1394 cbradney 1258
        return fillColorVal;
1381 cbradney 1259
}
1260
 
1286 tsoots 1261
void PageItem::setFillColor(const QString &newColor)
1262
{
1432 tsoots 1263
        if (fillColorVal == newColor)
3894 cbradney 1264
        {
1265
                setFillQColor();
1266
                return;
1267
        }
1286 tsoots 1268
        if (UndoManager::undoEnabled())
1269
        {
1270
                SimpleState *ss = new SimpleState(Um::SetFill,
1394 cbradney 1271
                                                                                  QString(Um::ColorFromTo).arg(fillColorVal).arg(newColor),
1286 tsoots 1272
                                          Um::IFill);
1273
                ss->set("FILL", "fill");
1394 cbradney 1274
                ss->set("OLD_FILL", fillColorVal);
1286 tsoots 1275
                ss->set("NEW_FILL", newColor);
1276
                undoManager->action(this, ss);
1277
        }
1394 cbradney 1278
        fillColorVal = newColor;
3894 cbradney 1279
        setFillQColor();
1286 tsoots 1280
}
1281
 
1381 cbradney 1282
int PageItem::fillShade() const
1283
{
1394 cbradney 1284
        return fillShadeVal;
1381 cbradney 1285
}
1286
 
1286 tsoots 1287
void PageItem::setFillShade(int newShade)
1288
{
1432 tsoots 1289
        if (fillShadeVal == newShade)
3894 cbradney 1290
        {
1291
                setFillQColor();
1292
                return;
1293
        }
1286 tsoots 1294
        if (UndoManager::undoEnabled())
1295
        {
1296
                SimpleState *ss = new SimpleState(Um::SetShade,
1402 tsoots 1297
                                                                                  QString(Um::FromTo).arg(fillShadeVal).arg(newShade),
1286 tsoots 1298
                                                                                  Um::IShade);
1299
                ss->set("SHADE", "shade");
1394 cbradney 1300
                ss->set("OLD_SHADE", fillShadeVal);
1286 tsoots 1301
                ss->set("NEW_SHADE", newShade);
1302
                undoManager->action(this, ss);
1303
        }
1394 cbradney 1304
        fillShadeVal = newShade;
3894 cbradney 1305
        setFillQColor();
1286 tsoots 1306
}
1307
 
1381 cbradney 1308
double PageItem::fillTransparency() const
1309
{
1394 cbradney 1310
        return fillTransparencyVal;
1381 cbradney 1311
}
1312
 
1371 tsoots 1313
void PageItem::setFillTransparency(double newTransparency)
1314
{
1432 tsoots 1315
        if (fillTransparencyVal == newTransparency)
1316
                return; // nothing to do -> return
1371 tsoots 1317
        if (UndoManager::undoEnabled())
1318
        {
1319
                SimpleState *ss = new SimpleState(Um::Transparency,
1394 cbradney 1320
                                                                                  QString(Um::FromTo).arg(fillTransparencyVal).arg(newTransparency),
1371 tsoots 1321
                                                                                  Um::ITransparency);
1322
                ss->set("TRANSPARENCY", "transparency");
1394 cbradney 1323
                ss->set("OLD_TP", fillTransparencyVal);
1371 tsoots 1324
                ss->set("NEW_TP", newTransparency);
1325
                undoManager->action(this, ss);
1326
        }
1394 cbradney 1327
        fillTransparencyVal = newTransparency;
1371 tsoots 1328
}
1329
 
1381 cbradney 1330
QString PageItem::lineColor() const
1331
{
1394 cbradney 1332
        return lineColorVal;
1381 cbradney 1333
}
1334
 
1286 tsoots 1335
void PageItem::setLineColor(const QString &newColor)
1336
{
1432 tsoots 1337
        if (lineColorVal == newColor)
3894 cbradney 1338
        {
1339
                setLineQColor();
1340
                return;
1341
        }
1286 tsoots 1342
        if (UndoManager::undoEnabled())
1343
        {
1344
                SimpleState *ss = new SimpleState(Um::SetLineColor,
1394 cbradney 1345
                                                                                  QString(Um::ColorFromTo).arg(lineColorVal).arg(newColor),
1286 tsoots 1346
                                                                                  Um::IFill);
1347
                ss->set("LINE_COLOR", "line_color");
1394 cbradney 1348
                ss->set("OLD_COLOR", lineColorVal);
1286 tsoots 1349
                ss->set("NEW_COLOR", newColor);
1350
                undoManager->action(this, ss);
1351
        }
1394 cbradney 1352
        lineColorVal = newColor;
3894 cbradney 1353
        setLineQColor();
1286 tsoots 1354
}
1355
 
1381 cbradney 1356
int PageItem::lineShade() const
1357
{
1394 cbradney 1358
        return lineShadeVal;
1381 cbradney 1359
}
1360
 
1286 tsoots 1361
void PageItem::setLineShade(int newShade)
1362
{
1432 tsoots 1363
        if (lineShadeVal == newShade)
3894 cbradney 1364
        {
1365
                setLineQColor();
1366
                return;
1367
        }
1286 tsoots 1368
        if (UndoManager::undoEnabled())
1369
        {
1370
                SimpleState *ss = new SimpleState(Um::SetLineShade,
1402 tsoots 1371
                                                                                  QString(Um::FromTo).arg(lineShadeVal).arg(newShade),
1286 tsoots 1372
                                                                                  Um::IShade);
1373
                ss->set("LINE_SHADE", "line_shade");
1394 cbradney 1374
                ss->set("OLD_SHADE", lineShadeVal);
1286 tsoots 1375
                ss->set("NEW_SHADE", newShade);
1376
                undoManager->action(this, ss);
1377
        }
1394 cbradney 1378
        lineShadeVal = newShade;
3894 cbradney 1379
        setLineQColor();
1286 tsoots 1380
}
1381
 
3894 cbradney 1382
void PageItem::setLineQColor()
1383
{
1384
        if (lineColorVal != "None")
1385
                strokeQColor = Doc->PageColors[lineColorVal].getShadeColorProof(lineShadeVal);
1386
}
1381 cbradney 1387
 
3894 cbradney 1388
void PageItem::setFillQColor()
1389
{
1390
        if (fillColorVal != "None")
1391
                fillQColor = Doc->PageColors[fillColorVal].getShadeColorProof(fillShadeVal);
1392
}
1393
 
1381 cbradney 1394
double PageItem::lineTransparency() const
1395
{
1394 cbradney 1396
        return lineTransparencyVal;
1381 cbradney 1397
}
1398
 
1371 tsoots 1399
void PageItem::setLineTransparency(double newTransparency)
1400
{
1432 tsoots 1401
        if (lineTransparencyVal == newTransparency)
1402
                return; // nothing to do -> return
1371 tsoots 1403
        if (UndoManager::undoEnabled())
1404
        {
1405
                SimpleState *ss = new SimpleState(Um::LineTransparency,
1394 cbradney 1406
                                                                                  QString(Um::FromTo).arg(lineTransparencyVal).arg(newTransparency),
1371 tsoots 1407
                                                                                  Um::ITransparency);
1408
                ss->set("LINE_TRANSPARENCY", "transparency");
1394 cbradney 1409
                ss->set("OLD_TP", lineTransparencyVal);
1371 tsoots 1410
                ss->set("NEW_TP", newTransparency);
1411
                undoManager->action(this, ss);
1412
        }
1394 cbradney 1413
        lineTransparencyVal = newTransparency;
1371 tsoots 1414
}
1415
 
1394 cbradney 1416
Qt::PenStyle PageItem::lineStyle() const
1417
{
1418
        return PLineArt;
1419
}
1420
 
1383 tsoots 1421
void PageItem::setLineStyle(PenStyle newStyle)
1422
{
1432 tsoots 1423
        if (PLineArt == newStyle)
1424
                return; // nothing to do -> return
1383 tsoots 1425
        if (UndoManager::undoEnabled())
1426
        {
1427
                SimpleState *ss = new SimpleState(Um::LineStyle,"",Um::ILineStyle);
1428
                ss->set("LINE_STYLE", "line_style");
1429
                ss->set("OLD_STYLE", static_cast<int>(PLineArt));
1430
                ss->set("NEW_STYLE", static_cast<int>(newStyle));
1431
                undoManager->action(this, ss);
1432
        }
1433
        PLineArt = newStyle;
1434
}
1435
 
1394 cbradney 1436
double PageItem::lineWidth() const
1437
{
1438
        return Pwidth;
1439
}
1440
 
1385 tsoots 1441
void PageItem::setLineWidth(double newWidth)
1442
{
1432 tsoots 1443
        if (Pwidth == newWidth)
1444
                return; // nothing to do -> return
1385 tsoots 1445
        if (UndoManager::undoEnabled())
1446
        {
1447
                SimpleState *ss = new SimpleState(Um::LineWidth,
1448
                                                QString(Um::FromTo).arg(Pwidth).arg(newWidth),Um::ILineStyle);
1449
                ss->set("LINE_WIDTH", "line_width");
1450
                ss->set("OLD_WIDTH", Pwidth);
1451
                ss->set("NEW_WIDTH", newWidth);
1452
                undoManager->action(this, ss);
1453
        }
1454
        Pwidth = newWidth;
1455
}
1456
 
1394 cbradney 1457
Qt::PenCapStyle PageItem::lineEnd() const
1458
{
1459
        return PLineEnd;
1460
}
1461
 
1385 tsoots 1462
void PageItem::setLineEnd(PenCapStyle newStyle)
1463
{
1432 tsoots 1464
        if (PLineEnd == newStyle)
1465
                return; // nothing to do -> return
1385 tsoots 1466
        if (UndoManager::undoEnabled())
1467
        {
1468
                SimpleState *ss = new SimpleState(Um::LineEnd,"",Um::ILineStyle);
1469
                ss->set("LINE_END", "line_end");
1470
                ss->set("OLD_STYLE", static_cast<int>(PLineEnd));
1471
                ss->set("NEW_STYLE", static_cast<int>(newStyle));
1472
                undoManager->action(this, ss);
1473
        }
1474
        PLineEnd = newStyle;
1475
}
1476
 
1394 cbradney 1477
Qt::PenJoinStyle PageItem::lineJoin() const
1478
{
1479
        return PLineJoin;
1480
}
1481
 
1385 tsoots 1482
void PageItem::setLineJoin(PenJoinStyle newStyle)
1483
{
1432 tsoots 1484
        if (PLineJoin == newStyle)
1485
                return; // nothing to do -> return
1385 tsoots 1486
        if (UndoManager::undoEnabled())
1487
        {
1488
                SimpleState *ss = new SimpleState(Um::LineJoin,"",Um::ILineStyle);
1489
                ss->set("LINE_JOIN", "line_join");
1490
                ss->set("OLD_STYLE", static_cast<int>(PLineJoin));
1491
                ss->set("NEW_STYLE", static_cast<int>(newStyle));
1492
                undoManager->action(this, ss);
1493
        }
1494
        PLineJoin = newStyle;
1495
}
1394 cbradney 1496
QString PageItem::customLineStyle() const
1392 cbradney 1497
{
1394 cbradney 1498
        return NamedLStyle;
1392 cbradney 1499
}
1500
 
1386 tsoots 1501
void PageItem::setCustomLineStyle(const QString& newStyle)
1502
{
1432 tsoots 1503
        if (NamedLStyle == newStyle)
1504
                return; // nothing to do -> return
1386 tsoots 1505
        if (UndoManager::undoEnabled())
1506
        {
2877 cbradney 1507
                QString oldStyle = NamedLStyle.isEmpty() ? Um::NoStyle : NamedLStyle;
1508
                QString nStyle   = newStyle.isEmpty() ? Um::NoStyle : newStyle;
1509
                QString action   = newStyle.isEmpty() ? Um::NoLineStyle : Um::CustomLineStyle;
1386 tsoots 1510
                SimpleState *ss = new SimpleState(action,
1511
                                QString(Um::FromTo).arg(oldStyle).arg(nStyle),Um::ILineStyle);
1512
                ss->set("CUSTOM_LINE_STYLE", "customlinestyle");
1513
                ss->set("OLD_STYLE", NamedLStyle);
1514
                ss->set("NEW_STYLE", newStyle);
1515
                undoManager->action(this, ss);
1516
        }
1517
        NamedLStyle = newStyle;
1518
}
1519
 
1394 cbradney 1520
int PageItem::getStartArrowIndex() const
1521
{
1522
        return startArrowIndex;
1523
}
1524
 
1391 tsoots 1525
void PageItem::setStartArrowIndex(int newIndex)
1526
{
1432 tsoots 1527
        if (startArrowIndex == newIndex)
1528
                return; // nothing to do -> return
1391 tsoots 1529
        if (UndoManager::undoEnabled())
1530
        {
1531
                SimpleState *ss = new SimpleState(Um::StartArrow,"",Um::IArrow);
1532
                ss->set("START_ARROW", "startarrow");
1533
                ss->set("OLD_INDEX", startArrowIndex);
1534
                ss->set("NEW_INDEX", newIndex);
1535
                undoManager->action(this, ss);
1536
        }
1537
        startArrowIndex = newIndex;
1538
}
1539
 
1394 cbradney 1540
int PageItem::getEndArrowIndex() const
1541
{
1542
        return endArrowIndex;
1543
}
1544
 
1391 tsoots 1545
void PageItem::setEndArrowIndex(int newIndex)
1546
{
1432 tsoots 1547
        if (endArrowIndex == newIndex)
1548
                return; // nothing to do -> return
1391 tsoots 1549
        if (UndoManager::undoEnabled())
1550
        {
1551
                SimpleState *ss = new SimpleState(Um::EndArrow,"",Um::IArrow);
1552
                ss->set("END_ARROW", "endarrow");
1553
                ss->set("OLD_INDEX", endArrowIndex);
1554
                ss->set("NEW_INDEX", newIndex);
1555
                undoManager->action(this, ss);
1556
        }
1557
        endArrowIndex = newIndex;
1558
}
1559
 
1394 cbradney 1560
bool PageItem::imageFlippedH() const
1561
{
1562
        return imageIsFlippedH;
1563
}
1564
 
1565
void PageItem::setImageFlippedH(bool flipped)
1566
{
1567
        if (flipped != imageIsFlippedH)
1568
                flipImageH();
1569
}
1570
 
1287 tsoots 1571
void PageItem::flipImageH()
1572
{
1573
        if (UndoManager::undoEnabled())
1574
        {
1575
                SimpleState *ss = new SimpleState(Um::FlipH, 0, Um::IFlipH);
1576
                ss->set("IMAGEFLIPH", "imagefliph");
1577
                undoManager->action(this, ss);
1578
        }
1392 cbradney 1579
        imageIsFlippedH = !imageIsFlippedH;
1287 tsoots 1580
}
1581
 
1392 cbradney 1582
bool PageItem::imageFlippedV() const
1583
{
1584
        return imageIsFlippedV;
1585
}
1586
 
1587
void PageItem::setImageFlippedV(bool flipped)
1588
{
1589
        if (flipped != imageIsFlippedV)
1590
                flipImageV();
1591
}
1592
 
1287 tsoots 1593
void PageItem::flipImageV()
1594
{
1595
        if (UndoManager::undoEnabled())
1596
        {
1597
                SimpleState *ss = new SimpleState(Um::FlipV, 0, Um::IFlipV);
1598
                ss->set("IMAGEFLIPV", "imageflipv");
1599
                undoManager->action(this, ss);
1600
        }
1392 cbradney 1601
        imageIsFlippedV = !imageIsFlippedV;
1287 tsoots 1602
}
1603
 
1495 tsoots 1604
void PageItem::setImageScalingMode(bool freeScale, bool keepRatio)
1605
{
1606
        if (ScaleType == freeScale && AspectRatio == keepRatio)
1607
                return;
1608
        if (UndoManager::undoEnabled())
1609
        {
1610
                QString from = ScaleType ? Um::FreeScaling : Um::FrameSize;
1611
                from += ", ";
1612
                from += AspectRatio ? Um::KeepRatio : Um::BreakRatio;
1613
                QString to = freeScale ? Um::FreeScaling : Um::FrameSize;
1614
                to += ", ";
1615
                to += keepRatio ? Um::KeepRatio : Um::BreakRatio;
1998 fschmid 1616
                SimpleState *ss = new SimpleState(Um::ImageScaling, QString(Um::FromTo).arg(from).arg(to), Um::IImageScaling);
1495 tsoots 1617
                if (freeScale != ScaleType)
1618
                        ss->set("SCALE_TYPE", freeScale);
1619
                if (keepRatio != AspectRatio)
1620
                        ss->set("ASPECT_RATIO", keepRatio);
1621
                undoManager->action(this, ss);
1622
        }
1623
        ScaleType = freeScale;
1624
        AspectRatio = keepRatio;
3650 cbradney 1625
        AdjustPictScale();
1626
        //FIXME emit here instead
1627
        ScApp->propertiesPalette->setLvalue(LocalScX, LocalScY, LocalX, LocalY);
1495 tsoots 1628
        ScApp->view->RefreshItem(this);
1629
}
1630
 
1290 tsoots 1631
void PageItem::toggleLock()
1632
{
1633
        if (UndoManager::undoEnabled())
1634
        {
1635
                SimpleState *ss;
1636
                if (Locked)
1637
                        ss = new SimpleState(Um::UnLock, 0, Um::IUnLock);
1638
                else
1639
                        ss = new SimpleState(Um::Lock, 0, Um::ILock);
1640
                ss->set("LOCK", "lock");
1641
                undoManager->action(this, ss);
1642
        }
1643
        Locked = !Locked;
1644
}
1645
 
1381 cbradney 1646
bool PageItem::locked() const
1647
{
1648
        return Locked;
1649
}
1650
 
1293 tsoots 1651
void PageItem::setLocked(bool isLocked)
1652
{
1340 tsoots 1653
        if (isLocked != Locked)
1293 tsoots 1654
                toggleLock();
1655
}
1656
 
1290 tsoots 1657
void PageItem::toggleSizeLock()
1658
{
1659
        if (UndoManager::undoEnabled())
1660
        {
1661
                SimpleState *ss;
1662
                if (Locked)
1663
                        ss = new SimpleState(Um::SizeUnLock, 0, Um::IUnLock);
1664
                else
1665
                        ss = new SimpleState(Um::SizeLock, 0, Um::ILock);
1666
                ss->set("SIZE_LOCK", "size_lock");
1667
                undoManager->action(this, ss);
1668
        }
1669
        LockRes = !LockRes;
1670
}
1671
 
1381 cbradney 1672
bool PageItem::sizeLocked() const
1673
{
1674
        return LockRes;
1675
}
1676
 
1298 fschmid 1677
void PageItem::setSizeLocked(bool isLocked)
1678
{
1679
        if (isLocked == LockRes)
1680
                return; // nothing to do return
1681
        else
1682
                toggleSizeLock();
1683
}
1684
 
1422 tsoots 1685
QString PageItem::font() const
1686
{
1687
        return IFont;
1688
}
1689
 
1399 tsoots 1690
void PageItem::setFont(const QString& newFont)
1691
{
1432 tsoots 1692
        if (IFont == newFont)
1693
                return; // nothing to do -> return
1399 tsoots 1694
        if (UndoManager::undoEnabled())
1695
        {
1696
                SimpleState *ss = new SimpleState(Um::SetFont,
1400 tsoots 1697
                                                                                  QString(Um::FromTo).arg(IFont).arg(newFont), Um::IFont);
1399 tsoots 1698
                ss->set("SET_FONT", "setfont");
1699
                ss->set("OLD_FONT", IFont);
1700
                ss->set("NEW_FONT", newFont);
1701
                undoManager->action(this, ss);
1702
        }
1703
        IFont = newFont;
1704
}
1705
 
1422 tsoots 1706
int PageItem::fontSize() const
1707
{
1708
        return ISize;
1709
}
1710
 
1400 tsoots 1711
void PageItem::setFontSize(int newSize)
1712
{
1432 tsoots 1713
        if (ISize == newSize)
1714
                return; // nothing to do -> return
1400 tsoots 1715
        if (UndoManager::undoEnabled())
1716
        {
1717
                SimpleState *ss = new SimpleState(Um::SetFontSize,
1718
                                                                                  QString(Um::FromTo).arg(ISize/10.0).arg(newSize/10.0), Um::IFont);
1719
                ss->set("SET_FONT_SIZE", "setfontsize");
1720
                ss->set("OLD_SIZE", ISize);
1721
                ss->set("NEW_SIZE", newSize);
1722
                undoManager->action(this, ss);
1723
        }
1724
        ISize = newSize;
1725
}
1726
 
2230 fschmid 1727
int PageItem::fontHeight() const
1728
{
1729
        return TxtScaleV;
1730
}
1731
 
1732
void PageItem::setFontHeight(int newHeight)
1733
{
1734
        if (TxtScaleV == newHeight)
1735
                return; // nothing to do -> return
1736
        if (UndoManager::undoEnabled())
1737
        {
1738
                SimpleState *ss = new SimpleState(Um::SetFontHeight,
1739
                                                                                  QString(Um::FromTo).arg(TxtScaleV).arg(newHeight), Um::IFont);
1740
                ss->set("SET_FONT_HEIGHT", "setfontheight");
1741
                ss->set("OLD_HEIGHT", TxtScaleV);
1742
                ss->set("NEW_HEIGHT", newHeight);
1743
                undoManager->action(this, ss);
1744
        }
1745
        TxtScaleV = newHeight;
1746
}
1747
 
1422 tsoots 1748
int PageItem::fontWidth() const
1749
{
1750
        return TxtScale;
1751
}
1752
 
1400 tsoots 1753
void PageItem::setFontWidth(int newWidth)
1754
{
1432 tsoots 1755
        if (TxtScale == newWidth)
1756
                return; // nothing to do -> return
1400 tsoots 1757
        if (UndoManager::undoEnabled())
1758
        {
1759
                SimpleState *ss = new SimpleState(Um::SetFontWidth,
1760
                                                                                  QString(Um::FromTo).arg(TxtScale).arg(newWidth), Um::IFont);
1761
                ss->set("SET_FONT_WIDTH", "setfontwidth");
1762
                ss->set("OLD_WIDTH", TxtScale);
1763
                ss->set("NEW_WIDTH", newWidth);
1764
                undoManager->action(this, ss);
1765
        }
1766
        TxtScale = newWidth;
1767
}
1768
 
1422 tsoots 1769
QString PageItem::fontFillColor() const
1770
{
1771
        return TxtFill;
1772
}
1773
 
1401 tsoots 1774
void PageItem::setFontFillColor(const QString& newColor)
1775
{
1432 tsoots 1776
        if (TxtFill == newColor)
1777
                return; // nothing to do -> return
1401 tsoots 1778
        if (UndoManager::undoEnabled())
1779
        {
1780
                SimpleState *ss = new SimpleState(Um::SetFontFill,
1781
                                                                                  QString(Um::FromTo).arg(TxtFill).arg(newColor), Um::IFont);
1782
                ss->set("SET_FONT_FILL", "setfontfill");
1783
                ss->set("OLD_FILL", TxtFill);
1784
                ss->set("NEW_FILL", newColor);
1785
                undoManager->action(this, ss);
1786
        }
1787
        TxtFill = newColor;
1788
}
1789
 
1422 tsoots 1790
QString PageItem::fontStrokeColor() const
1791
{
1792
        return TxtStroke;
1793
}
1794
 
1401 tsoots 1795
void PageItem::setFontStrokeColor(const QString& newColor)
1796
{
1432 tsoots 1797
        if (TxtStroke == newColor)
1798
                return; // nothing to do -> return
1401 tsoots 1799
        if (UndoManager::undoEnabled())
1800
        {
1801
                SimpleState *ss = new SimpleState(Um::SetFontStroke,
1802
                                                                                  QString(Um::FromTo).arg(TxtStroke).arg(newColor), Um::IFont);
1803
                ss->set("SET_FONT_STROKE", "setfontstroke");
1804
                ss->set("OLD_STROKE", TxtStroke);
1805
                ss->set("NEW_STROKE", newColor);
1806
                undoManager->action(this, ss);
1807
        }
1808
        TxtStroke = newColor;
1809
}
1810
 
1422 tsoots 1811
int PageItem::fontFillShade() const
1812
{
1813
        return ShTxtFill;
1814
}
1815
 
1402 tsoots 1816
void PageItem::setFontFillShade(int newShade)
1817
{
1432 tsoots 1818
        if (ShTxtFill == newShade)
1819
                return; // nothing to do -> return
1402 tsoots 1820
        if (UndoManager::undoEnabled())
1821
        {
1822
                SimpleState *ss = new SimpleState(Um::SetFontFillShade,
1823
                                                                                  QString(Um::FromTo).arg(ShTxtFill).arg(newShade),
1824
                                                                                  Um::IFont);
1825
                ss->set("FONT_FILL_SHADE", "line_shade");
1826
                ss->set("OLD_SHADE", ShTxtFill);
1827
                ss->set("NEW_SHADE", newShade);
1828
                undoManager->action(this, ss);
1829
        }
1830
        ShTxtFill = newShade;
1831
}
1832
 
1422 tsoots 1833
int PageItem::fontStrokeShade() const
1834
{
1835
        return ShTxtStroke;
1836
}
1837
 
1402 tsoots 1838
void PageItem::setFontStrokeShade(int newShade)
1839
{
1432 tsoots 1840
        if (ShTxtStroke == newShade)
1841
                return; // nothing to do -> return
1402 tsoots 1842
        if (UndoManager::undoEnabled())
1843
        {
1844
                SimpleState *ss = new SimpleState(Um::SetFontStrokeShade,
1845
                                                                                  QString(Um::FromTo).arg(ShTxtStroke).arg(newShade),
1846
                                                                                  Um::IFont);
1847
                ss->set("FONT_STROKE_SHADE", "line_shade");
1848
                ss->set("OLD_SHADE", ShTxtStroke);
1849
                ss->set("NEW_SHADE", newShade);
1850
                undoManager->action(this, ss);
1851
        }
1852
        ShTxtStroke = newShade;
1853
}
1854
 
1422 tsoots 1855
int PageItem::fontEffects() const
1856
{
1857
        return TxTStyle;
1858
}
1415 tsoots 1859
 
1860
void PageItem::setFontEffects(int newEffects)
1861
{
1862
        if (UndoManager::undoEnabled())
1863
        {
1864
                SimpleState *ss = new SimpleState(Um::SetFontEffect, "", Um::IFont);
1865
                ss->set("FONT_EFFECTS", "fonteffects");
1866
                ss->set("OLD_EFFECT", TxTStyle);
1867
                ss->set("NEW_EFFECT", newEffects);
1868
                undoManager->action(this, ss);
1869
        }
2185 fschmid 1870
        TxTStyle &= ~1919;
1415 tsoots 1871
        TxTStyle |= newEffects;
1872
}
1873
 
2382 fschmid 1874
int PageItem::kerning() const
1422 tsoots 1875
{
1876
        return ExtraV;
1877
}
1878
 
2382 fschmid 1879
void PageItem::setKerning(int newKerning)
1403 tsoots 1880
{
1432 tsoots 1881
        if (ExtraV == newKerning)
1882
                return; // nothing to do -> return
1403 tsoots 1883
        if (UndoManager::undoEnabled())
1884
        {
1885
                SimpleState *ss = new SimpleState(Um::SetKerning,
1886
                                                                                  QString(Um::FromTo).arg(ExtraV).arg(newKerning),
1887
                                                                                  Um::IFont);
1888
                ss->set("KERNING", "kerning");
1889
                ss->set("OLD_KERNING", ExtraV);
1890
                ss->set("NEW_KERNING", newKerning);
1891
                undoManager->action(this, ss);
1892
        }
1893
        ExtraV = newKerning;
1894
}
1895
 
1422 tsoots 1896
double PageItem::lineSpacing() const
1897
{
1898
        return LineSp;
1899
}
1900
 
1403 tsoots 1901
void PageItem::setLineSpacing(double newSpacing)
1902
{
1432 tsoots 1903
        if (LineSp == newSpacing)
1904
                return; // nothing to do -> return
1403 tsoots 1905
        if (UndoManager::undoEnabled())
1906
        {
1907
                SimpleState *ss = new SimpleState(Um::SetLineSpacing,
1908
                                                                                  QString(Um::FromTo).arg(LineSp).arg(newSpacing),
1909
                                                                                  Um::IFont);
1910
                ss->set("SPACING", "spacing");
1911
                ss->set("OLD_SPACING", LineSp);
1912
                ss->set("NEW_SPACING", newSpacing);
1913
                undoManager->action(this, ss);
1914
        }
1915
        LineSp = newSpacing;
1916
}
1917
 
1422 tsoots 1918
QString PageItem::language() const
1919
{
1920
        return Language;
1921
}
1922
 
1403 tsoots 1923
void PageItem::setLanguage(const QString& newLanguage)
1924
{
1432 tsoots 1925
        if (Language == newLanguage)
1926
                return; // nothing to do -> return
1403 tsoots 1927
        if (UndoManager::undoEnabled())
1928
        {
1929
                SimpleState *ss = new SimpleState(Um::SetLanguage,
1930
                                                                                  QString(Um::FromTo).arg(Language).arg(newLanguage),
1931
                                                                                  Um::IFont);
1932
                ss->set("LANGUAGE", "lang");
1933
                ss->set("OLD_LANG", Language);
1934
                ss->set("NEW_LANG", newLanguage);
1935
                undoManager->action(this, ss);
1936
        }
1937
        Language = newLanguage;
1938
}
1939
 
1651 craig 1940
bool PageItem::textFlowsAroundFrame() const
1489 tsoots 1941
{
3634 cbradney 1942
        return textFlowsAroundFrameVal;
1651 craig 1943
}
1944
 
1945
void PageItem::setTextFlowsAroundFrame(bool isFlowing)
1946
{
1653 craig 1947
        if (textFlowsAroundFrameVal == isFlowing)
1489 tsoots 1948
                return;
1949
        if (UndoManager::undoEnabled())
1950
        {
1951
                SimpleState *ss = new SimpleState(isFlowing ? Um::TextFlow : Um::NoTextFlow, "", Um::IFont);
1952
                ss->set("TEXT_FLOW", isFlowing);
1953
                undoManager->action(this, ss);
1954
        }
1653 craig 1955
        textFlowsAroundFrameVal = isFlowing;
1489 tsoots 1956
}
1957
 
1653 craig 1958
bool PageItem::textFlowUsesBoundingBox() const
1489 tsoots 1959
{
3634 cbradney 1960
        return textFlowUsesBoundingBoxVal;
1653 craig 1961
}
1962
 
1963
void PageItem::setTextFlowUsesBoundingBox(bool useBounding)
1964
{
1965
        if (textFlowUsesBoundingBoxVal == useBounding)
1489 tsoots 1966
                return;
1967
        if (UndoManager::undoEnabled())
1968
        {
1969
                SimpleState *ss = new SimpleState(useBounding ? Um::BoundingBox : Um::NoBoundingBox, "", Um::IFont);
1653 craig 1970
                ss->set("TEXT_FLOW", textFlowsAroundFrame());
1489 tsoots 1971
                ss->set("BOUNDING_BOX", useBounding);
1972
                undoManager->action(this, ss);
1973
        }
1656 craig 1974
        if (useBounding && textFlowUsesContourLineVal)
1975
                textFlowUsesContourLineVal = false;
1653 craig 1976
        textFlowUsesBoundingBoxVal = useBounding;
1489 tsoots 1977
}
1978
 
1656 craig 1979
bool PageItem::textFlowUsesContourLine() const
1489 tsoots 1980
{
3634 cbradney 1981
        return textFlowUsesContourLineVal;
1656 craig 1982
}
1983
 
1984
void PageItem::setTextFlowUsesContourLine(bool useContour)
1985
{
1986
        if (textFlowUsesContourLineVal == useContour)
1489 tsoots 1987
                return;
1988
        if (UndoManager::undoEnabled())
1989
        {
1990
                SimpleState *ss = new SimpleState(useContour ? Um::ContourLine : Um::NoContourLine, "", Um::IFont);
1653 craig 1991
                ss->set("TEXT_FLOW", textFlowsAroundFrame());
1489 tsoots 1992
                ss->set("CONTOUR_LINE", useContour);
1993
                undoManager->action(this, ss);
1994
        }
1653 craig 1995
        if (useContour && textFlowUsesBoundingBoxVal)
1996
                textFlowUsesBoundingBoxVal = false;
1656 craig 1997
        textFlowUsesContourLineVal = useContour;
1489 tsoots 1998
}
1999
 
1460 cbradney 2000
PageItem::ItemType PageItem::itemType() const
1422 tsoots 2001
{
1460 cbradney 2002
        return itemTypeVal;
1422 tsoots 2003
}
2004
 
1460 cbradney 2005
void PageItem::convertTo(ItemType newType)
1416 tsoots 2006
{
1460 cbradney 2007
        if (itemTypeVal == newType)
1432 tsoots 2008
                return; // nothing to do -> return
1460 cbradney 2009
        assert(newType != 1);   //DEBUG CR 2005-02-06
2010
        assert(newType != 3);   //DEBUG CR 2005-02-06
1416 tsoots 2011
        QString fromType = "", toType = "";
1460 cbradney 2012
        switch (itemTypeVal)
1416 tsoots 2013
        {
1460 cbradney 2014
                case ImageFrame:
2015
                        fromType = Um::ImageFrame;
2016
                        break;
2017
                case TextFrame:
2018
                        fromType = Um::TextFrame;
2019
                        break;
2020
                case Polygon:
2021
                        fromType = Um::Polygon;
2022
                        break;
2023
                default:
2024
                        fromType = "";
2025
                        break;
1416 tsoots 2026
        }
2027
        switch (newType)
2028
        {
1460 cbradney 2029
                case ImageFrame:
1487 tsoots 2030
                        toType = Um::ImageFrame;
1416 tsoots 2031
                        setUPixmap(Um::IImageFrame);
2032
                        break;
1460 cbradney 2033
                case TextFrame:
1416 tsoots 2034
                        toType = Um::TextFrame;
2035
                        setUPixmap(Um::ITextFrame);
2036
                        break;
1460 cbradney 2037
                case Polygon:
1416 tsoots 2038
                        toType = Um::Polygon;
2039
                        setUPixmap(Um::IPolygon);
2040
                        break;
1460 cbradney 2041
                case PolyLine:
1416 tsoots 2042
                        toType = Um::Polyline;
2043
                        setUPixmap(Um::IPolyline);
2044
                        break;
1460 cbradney 2045
                default:
1487 tsoots 2046
                        toType = "";
1416 tsoots 2047
                        setUPixmap(NULL);
2048
                        break;
2049
        }
3669 cbradney 2050
        /*
1416 tsoots 2051
        if (UndoManager::undoEnabled())
2052
        {
2053
                SimpleState *ss = new SimpleState(Um::ConvertTo + " " + toType,
2054
                                                                                  QString(Um::FromTo).arg(fromType).arg(toType));
2055
                ss->set("CONVERT", "convert");
3625 avox 2056
                ss->set("PAGEITEM", reinterpret_cast<int>(this));
1460 cbradney 2057
                ss->set("OLD_TYPE", itemTypeVal);
1416 tsoots 2058
                ss->set("NEW_TYPE", newType);
2059
                undoManager->action(this, ss);
2060
        }
3669 cbradney 2061
        */
1460 cbradney 2062
        itemTypeVal = newType;
1416 tsoots 2063
}
2064
 
1688 tsoots 2065
void PageItem::setLayer(int layerId)
2066
{
2067
        if (LayerNr == layerId)
2068
                return;
2069
        if (UndoManager::undoEnabled())
2070
        {
2071
                SimpleState *ss = new SimpleState(Um::SendToLayer,
2072
                                                                                  QString(Um::FromTo).arg(LayerNr).arg(layerId),
2073
                                                                                  Um::ILayerAction);
2074
                ss->set("SEND_TO_LAYER", "send_to_layer");
2075
                ss->set("OLD_LAYER", LayerNr);
2076
                ss->set("NEW_LAYER", layerId);
2077
                undoManager->action(this, ss);
2078
        }
2079
        LayerNr = layerId;
2080
}
2081
 
1211 tsoots 2082
void PageItem::checkChanges(bool force)
2083
{
1286 tsoots 2084
        // has the item been resized
3634 cbradney 2085
        if (force || ((oldWidth != Width || oldHeight != Height) && shouldCheck()))
1286 tsoots 2086
                resizeUndoAction();
1211 tsoots 2087
        // has the item been rotated
3634 cbradney 2088
        if (force || ((oldRot != Rot) && (shouldCheck())))
1211 tsoots 2089
                rotateUndoAction();
2090
        // has the item been moved
3634 cbradney 2091
        if (force || ((oldXpos != Xpos || oldYpos != Ypos) && shouldCheck()))
1211 tsoots 2092
                moveUndoAction();
2093
}
2094
 
1238 tsoots 2095
bool PageItem::shouldCheck()
2096
{
1278 tsoots 2097
        return ((!ScApp->view->mousePressed()) &&
2098
                        (!ScApp->arrowKeyDown()) &&
1545 cbradney 2099
                        (!ScApp->propertiesPalette->userActionOn()));
1238 tsoots 2100
}
2101
 
1204 tsoots 2102
void PageItem::moveUndoAction()
2103
{
1286 tsoots 2104
        if (!shouldCheck())
2105
                return;
1211 tsoots 2106
        if (oldXpos == Xpos && oldYpos == Ypos)
2107
                return;
1204 tsoots 2108
        if (UndoManager::undoEnabled())
2109
        {
1487 tsoots 2110
                QString oldp;
2111
                QString newp;
2112
                if (oldOwnPage == -1)
2113
                        oldp = Um::ScratchSpace;
2114
                else
1490 tsoots 2115
                        oldp = QString(Um::PageNmbr).arg(ScApp->doc->FirstPnum + oldOwnPage);
1487 tsoots 2116
                if (OwnPage == -1)
2117
                        newp = Um::ScratchSpace;
2118
                else
1490 tsoots 2119
                        newp = QString(Um::PageNmbr).arg(ScApp->doc->FirstPnum + OwnPage);
1204 tsoots 2120
                SimpleState *ss = new SimpleState(Um::Move,
1487 tsoots 2121
                                          QString(Um::MoveFromTo).arg(oldXpos).arg(oldYpos).arg(oldp).
2122
                                                                  arg(Xpos).arg(Ypos).arg(newp), Um::IMove);
1204 tsoots 2123
                ss->set("OLD_XPOS", oldXpos);
2124
                ss->set("OLD_YPOS", oldYpos);
2125
                ss->set("NEW_XPOS", Xpos);
2126
                ss->set("NEW_YPOS", Ypos);
2127
                undoManager->action(this, ss);
2128
        }
2129
        oldXpos = Xpos;
2130
        oldYpos = Ypos;
1211 tsoots 2131
        oldOwnPage = OwnPage;
1204 tsoots 2132
}
2133
 
1206 tsoots 2134
void PageItem::resizeUndoAction()
2135
{
1286 tsoots 2136
        if (!shouldCheck())
2137
                return;
1211 tsoots 2138
        if (oldHeight == Height && oldWidth == Width)
2139
                return;
1206 tsoots 2140