Subversion Repositories Scribus

Rev

Rev 3820 | Rev 3870 | 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)
1264
                return; // nothing to do -> return
1286 tsoots 1265
        if (UndoManager::undoEnabled())
1266
        {
1267
                SimpleState *ss = new SimpleState(Um::SetFill,
1394 cbradney 1268
                                                                                  QString(Um::ColorFromTo).arg(fillColorVal).arg(newColor),
1286 tsoots 1269
                                          Um::IFill);
1270
                ss->set("FILL", "fill");
1394 cbradney 1271
                ss->set("OLD_FILL", fillColorVal);
1286 tsoots 1272
                ss->set("NEW_FILL", newColor);
1273
                undoManager->action(this, ss);
1274
        }
1394 cbradney 1275
        fillColorVal = newColor;
1286 tsoots 1276
}
1277
 
1381 cbradney 1278
int PageItem::fillShade() const
1279
{
1394 cbradney 1280
        return fillShadeVal;
1381 cbradney 1281
}
1282
 
1286 tsoots 1283
void PageItem::setFillShade(int newShade)
1284
{
1432 tsoots 1285
        if (fillShadeVal == newShade)
1286
                return; // nothing to do -> return
1286 tsoots 1287
        if (UndoManager::undoEnabled())
1288
        {
1289
                SimpleState *ss = new SimpleState(Um::SetShade,
1402 tsoots 1290
                                                                                  QString(Um::FromTo).arg(fillShadeVal).arg(newShade),
1286 tsoots 1291
                                                                                  Um::IShade);
1292
                ss->set("SHADE", "shade");
1394 cbradney 1293
                ss->set("OLD_SHADE", fillShadeVal);
1286 tsoots 1294
                ss->set("NEW_SHADE", newShade);
1295
                undoManager->action(this, ss);
1296
        }
1394 cbradney 1297
        fillShadeVal = newShade;
1286 tsoots 1298
}
1299
 
1381 cbradney 1300
double PageItem::fillTransparency() const
1301
{
1394 cbradney 1302
        return fillTransparencyVal;
1381 cbradney 1303
}
1304
 
1371 tsoots 1305
void PageItem::setFillTransparency(double newTransparency)
1306
{
1432 tsoots 1307
        if (fillTransparencyVal == newTransparency)
1308
                return; // nothing to do -> return
1371 tsoots 1309
        if (UndoManager::undoEnabled())
1310
        {
1311
                SimpleState *ss = new SimpleState(Um::Transparency,
1394 cbradney 1312
                                                                                  QString(Um::FromTo).arg(fillTransparencyVal).arg(newTransparency),
1371 tsoots 1313
                                                                                  Um::ITransparency);
1314
                ss->set("TRANSPARENCY", "transparency");
1394 cbradney 1315
                ss->set("OLD_TP", fillTransparencyVal);
1371 tsoots 1316
                ss->set("NEW_TP", newTransparency);
1317
                undoManager->action(this, ss);
1318
        }
1394 cbradney 1319
        fillTransparencyVal = newTransparency;
1371 tsoots 1320
}
1321
 
1381 cbradney 1322
QString PageItem::lineColor() const
1323
{
1394 cbradney 1324
        return lineColorVal;
1381 cbradney 1325
}
1326
 
1286 tsoots 1327
void PageItem::setLineColor(const QString &newColor)
1328
{
1432 tsoots 1329
        if (lineColorVal == newColor)
1330
                return; // nothing to do -> return
1286 tsoots 1331
        if (UndoManager::undoEnabled())
1332
        {
1333
                SimpleState *ss = new SimpleState(Um::SetLineColor,
1394 cbradney 1334
                                                                                  QString(Um::ColorFromTo).arg(lineColorVal).arg(newColor),
1286 tsoots 1335
                                                                                  Um::IFill);
1336
                ss->set("LINE_COLOR", "line_color");
1394 cbradney 1337
                ss->set("OLD_COLOR", lineColorVal);
1286 tsoots 1338
                ss->set("NEW_COLOR", newColor);
1339
                undoManager->action(this, ss);
1340
        }
1394 cbradney 1341
        lineColorVal = newColor;
1286 tsoots 1342
}
1343
 
1381 cbradney 1344
int PageItem::lineShade() const
1345
{
1394 cbradney 1346
        return lineShadeVal;
1381 cbradney 1347
}
1348
 
1286 tsoots 1349
void PageItem::setLineShade(int newShade)
1350
{
1432 tsoots 1351
        if (lineShadeVal == newShade)
1352
                return; // nothing to do -> return
1286 tsoots 1353
        if (UndoManager::undoEnabled())
1354
        {
1355
                SimpleState *ss = new SimpleState(Um::SetLineShade,
1402 tsoots 1356
                                                                                  QString(Um::FromTo).arg(lineShadeVal).arg(newShade),
1286 tsoots 1357
                                                                                  Um::IShade);
1358
                ss->set("LINE_SHADE", "line_shade");
1394 cbradney 1359
                ss->set("OLD_SHADE", lineShadeVal);
1286 tsoots 1360
                ss->set("NEW_SHADE", newShade);
1361
                undoManager->action(this, ss);
1362
        }
1394 cbradney 1363
        lineShadeVal = newShade;
1286 tsoots 1364
}
1365
 
1381 cbradney 1366
 
1367
double PageItem::lineTransparency() const
1368
{
1394 cbradney 1369
        return lineTransparencyVal;
1381 cbradney 1370
}
1371
 
1371 tsoots 1372
void PageItem::setLineTransparency(double newTransparency)
1373
{
1432 tsoots 1374
        if (lineTransparencyVal == newTransparency)
1375
                return; // nothing to do -> return
1371 tsoots 1376
        if (UndoManager::undoEnabled())
1377
        {
1378
                SimpleState *ss = new SimpleState(Um::LineTransparency,
1394 cbradney 1379
                                                                                  QString(Um::FromTo).arg(lineTransparencyVal).arg(newTransparency),
1371 tsoots 1380
                                                                                  Um::ITransparency);
1381
                ss->set("LINE_TRANSPARENCY", "transparency");
1394 cbradney 1382
                ss->set("OLD_TP", lineTransparencyVal);
1371 tsoots 1383
                ss->set("NEW_TP", newTransparency);
1384
                undoManager->action(this, ss);
1385
        }
1394 cbradney 1386
        lineTransparencyVal = newTransparency;
1371 tsoots 1387
}
1388
 
1394 cbradney 1389
Qt::PenStyle PageItem::lineStyle() const
1390
{
1391
        return PLineArt;
1392
}
1393
 
1383 tsoots 1394
void PageItem::setLineStyle(PenStyle newStyle)
1395
{
1432 tsoots 1396
        if (PLineArt == newStyle)
1397
                return; // nothing to do -> return
1383 tsoots 1398
        if (UndoManager::undoEnabled())
1399
        {
1400
                SimpleState *ss = new SimpleState(Um::LineStyle,"",Um::ILineStyle);
1401
                ss->set("LINE_STYLE", "line_style");
1402
                ss->set("OLD_STYLE", static_cast<int>(PLineArt));
1403
                ss->set("NEW_STYLE", static_cast<int>(newStyle));
1404
                undoManager->action(this, ss);
1405
        }
1406
        PLineArt = newStyle;
1407
}
1408
 
1394 cbradney 1409
double PageItem::lineWidth() const
1410
{
1411
        return Pwidth;
1412
}
1413
 
1385 tsoots 1414
void PageItem::setLineWidth(double newWidth)
1415
{
1432 tsoots 1416
        if (Pwidth == newWidth)
1417
                return; // nothing to do -> return
1385 tsoots 1418
        if (UndoManager::undoEnabled())
1419
        {
1420
                SimpleState *ss = new SimpleState(Um::LineWidth,
1421
                                                QString(Um::FromTo).arg(Pwidth).arg(newWidth),Um::ILineStyle);
1422
                ss->set("LINE_WIDTH", "line_width");
1423
                ss->set("OLD_WIDTH", Pwidth);
1424
                ss->set("NEW_WIDTH", newWidth);
1425
                undoManager->action(this, ss);
1426
        }
1427
        Pwidth = newWidth;
1428
}
1429
 
1394 cbradney 1430
Qt::PenCapStyle PageItem::lineEnd() const
1431
{
1432
        return PLineEnd;
1433
}
1434
 
1385 tsoots 1435
void PageItem::setLineEnd(PenCapStyle newStyle)
1436
{
1432 tsoots 1437
        if (PLineEnd == newStyle)
1438
                return; // nothing to do -> return
1385 tsoots 1439
        if (UndoManager::undoEnabled())
1440
        {
1441
                SimpleState *ss = new SimpleState(Um::LineEnd,"",Um::ILineStyle);
1442
                ss->set("LINE_END", "line_end");
1443
                ss->set("OLD_STYLE", static_cast<int>(PLineEnd));
1444
                ss->set("NEW_STYLE", static_cast<int>(newStyle));
1445
                undoManager->action(this, ss);
1446
        }
1447
        PLineEnd = newStyle;
1448
}
1449
 
1394 cbradney 1450
Qt::PenJoinStyle PageItem::lineJoin() const
1451
{
1452
        return PLineJoin;
1453
}
1454
 
1385 tsoots 1455
void PageItem::setLineJoin(PenJoinStyle newStyle)
1456
{
1432 tsoots 1457
        if (PLineJoin == newStyle)
1458
                return; // nothing to do -> return
1385 tsoots 1459
        if (UndoManager::undoEnabled())
1460
        {
1461
                SimpleState *ss = new SimpleState(Um::LineJoin,"",Um::ILineStyle);
1462
                ss->set("LINE_JOIN", "line_join");
1463
                ss->set("OLD_STYLE", static_cast<int>(PLineJoin));
1464
                ss->set("NEW_STYLE", static_cast<int>(newStyle));
1465
                undoManager->action(this, ss);
1466
        }
1467
        PLineJoin = newStyle;
1468
}
1394 cbradney 1469
QString PageItem::customLineStyle() const
1392 cbradney 1470
{
1394 cbradney 1471
        return NamedLStyle;
1392 cbradney 1472
}
1473
 
1386 tsoots 1474
void PageItem::setCustomLineStyle(const QString& newStyle)
1475
{
1432 tsoots 1476
        if (NamedLStyle == newStyle)
1477
                return; // nothing to do -> return
1386 tsoots 1478
        if (UndoManager::undoEnabled())
1479
        {
2877 cbradney 1480
                QString oldStyle = NamedLStyle.isEmpty() ? Um::NoStyle : NamedLStyle;
1481
                QString nStyle   = newStyle.isEmpty() ? Um::NoStyle : newStyle;
1482
                QString action   = newStyle.isEmpty() ? Um::NoLineStyle : Um::CustomLineStyle;
1386 tsoots 1483
                SimpleState *ss = new SimpleState(action,
1484
                                QString(Um::FromTo).arg(oldStyle).arg(nStyle),Um::ILineStyle);
1485
                ss->set("CUSTOM_LINE_STYLE", "customlinestyle");
1486
                ss->set("OLD_STYLE", NamedLStyle);
1487
                ss->set("NEW_STYLE", newStyle);
1488
                undoManager->action(this, ss);
1489
        }
1490
        NamedLStyle = newStyle;
1491
}
1492
 
1394 cbradney 1493
int PageItem::getStartArrowIndex() const
1494
{
1495
        return startArrowIndex;
1496
}
1497
 
1391 tsoots 1498
void PageItem::setStartArrowIndex(int newIndex)
1499
{
1432 tsoots 1500
        if (startArrowIndex == newIndex)
1501
                return; // nothing to do -> return
1391 tsoots 1502
        if (UndoManager::undoEnabled())
1503
        {
1504
                SimpleState *ss = new SimpleState(Um::StartArrow,"",Um::IArrow);
1505
                ss->set("START_ARROW", "startarrow");
1506
                ss->set("OLD_INDEX", startArrowIndex);
1507
                ss->set("NEW_INDEX", newIndex);
1508
                undoManager->action(this, ss);
1509
        }
1510
        startArrowIndex = newIndex;
1511
}
1512
 
1394 cbradney 1513
int PageItem::getEndArrowIndex() const
1514
{
1515
        return endArrowIndex;
1516
}
1517
 
1391 tsoots 1518
void PageItem::setEndArrowIndex(int newIndex)
1519
{
1432 tsoots 1520
        if (endArrowIndex == newIndex)
1521
                return; // nothing to do -> return
1391 tsoots 1522
        if (UndoManager::undoEnabled())
1523
        {
1524
                SimpleState *ss = new SimpleState(Um::EndArrow,"",Um::IArrow);
1525
                ss->set("END_ARROW", "endarrow");
1526
                ss->set("OLD_INDEX", endArrowIndex);
1527
                ss->set("NEW_INDEX", newIndex);
1528
                undoManager->action(this, ss);
1529
        }
1530
        endArrowIndex = newIndex;
1531
}
1532
 
1394 cbradney 1533
bool PageItem::imageFlippedH() const
1534
{
1535
        return imageIsFlippedH;
1536
}
1537
 
1538
void PageItem::setImageFlippedH(bool flipped)
1539
{
1540
        if (flipped != imageIsFlippedH)
1541
                flipImageH();
1542
}
1543
 
1287 tsoots 1544
void PageItem::flipImageH()
1545
{
1546
        if (UndoManager::undoEnabled())
1547
        {
1548
                SimpleState *ss = new SimpleState(Um::FlipH, 0, Um::IFlipH);
1549
                ss->set("IMAGEFLIPH", "imagefliph");
1550
                undoManager->action(this, ss);
1551
        }
1392 cbradney 1552
        imageIsFlippedH = !imageIsFlippedH;
1287 tsoots 1553
}
1554
 
1392 cbradney 1555
bool PageItem::imageFlippedV() const
1556
{
1557
        return imageIsFlippedV;
1558
}
1559
 
1560
void PageItem::setImageFlippedV(bool flipped)
1561
{
1562
        if (flipped != imageIsFlippedV)
1563
                flipImageV();
1564
}
1565
 
1287 tsoots 1566
void PageItem::flipImageV()
1567
{
1568
        if (UndoManager::undoEnabled())
1569
        {
1570
                SimpleState *ss = new SimpleState(Um::FlipV, 0, Um::IFlipV);
1571
                ss->set("IMAGEFLIPV", "imageflipv");
1572
                undoManager->action(this, ss);
1573
        }
1392 cbradney 1574
        imageIsFlippedV = !imageIsFlippedV;
1287 tsoots 1575
}
1576
 
1495 tsoots 1577
void PageItem::setImageScalingMode(bool freeScale, bool keepRatio)
1578
{
1579
        if (ScaleType == freeScale && AspectRatio == keepRatio)
1580
                return;
1581
        if (UndoManager::undoEnabled())
1582
        {
1583
                QString from = ScaleType ? Um::FreeScaling : Um::FrameSize;
1584
                from += ", ";
1585
                from += AspectRatio ? Um::KeepRatio : Um::BreakRatio;
1586
                QString to = freeScale ? Um::FreeScaling : Um::FrameSize;
1587
                to += ", ";
1588
                to += keepRatio ? Um::KeepRatio : Um::BreakRatio;
1998 fschmid 1589
                SimpleState *ss = new SimpleState(Um::ImageScaling, QString(Um::FromTo).arg(from).arg(to), Um::IImageScaling);
1495 tsoots 1590
                if (freeScale != ScaleType)
1591
                        ss->set("SCALE_TYPE", freeScale);
1592
                if (keepRatio != AspectRatio)
1593
                        ss->set("ASPECT_RATIO", keepRatio);
1594
                undoManager->action(this, ss);
1595
        }
1596
        ScaleType = freeScale;
1597
        AspectRatio = keepRatio;
3650 cbradney 1598
        AdjustPictScale();
1599
        //FIXME emit here instead
1600
        ScApp->propertiesPalette->setLvalue(LocalScX, LocalScY, LocalX, LocalY);
1495 tsoots 1601
        ScApp->view->RefreshItem(this);
1602
}
1603
 
1290 tsoots 1604
void PageItem::toggleLock()
1605
{
1606
        if (UndoManager::undoEnabled())
1607
        {
1608
                SimpleState *ss;
1609
                if (Locked)
1610
                        ss = new SimpleState(Um::UnLock, 0, Um::IUnLock);
1611
                else
1612
                        ss = new SimpleState(Um::Lock, 0, Um::ILock);
1613
                ss->set("LOCK", "lock");
1614
                undoManager->action(this, ss);
1615
        }
1616
        Locked = !Locked;
1617
}
1618
 
1381 cbradney 1619
bool PageItem::locked() const
1620
{
1621
        return Locked;
1622
}
1623
 
1293 tsoots 1624
void PageItem::setLocked(bool isLocked)
1625
{
1340 tsoots 1626
        if (isLocked != Locked)
1293 tsoots 1627
                toggleLock();
1628
}
1629
 
1290 tsoots 1630
void PageItem::toggleSizeLock()
1631
{
1632
        if (UndoManager::undoEnabled())
1633
        {
1634
                SimpleState *ss;
1635
                if (Locked)
1636
                        ss = new SimpleState(Um::SizeUnLock, 0, Um::IUnLock);
1637
                else
1638
                        ss = new SimpleState(Um::SizeLock, 0, Um::ILock);
1639
                ss->set("SIZE_LOCK", "size_lock");
1640
                undoManager->action(this, ss);
1641
        }
1642
        LockRes = !LockRes;
1643
}
1644
 
1381 cbradney 1645
bool PageItem::sizeLocked() const
1646
{
1647
        return LockRes;
1648
}
1649
 
1298 fschmid 1650
void PageItem::setSizeLocked(bool isLocked)
1651
{
1652
        if (isLocked == LockRes)
1653
                return; // nothing to do return
1654
        else
1655
                toggleSizeLock();
1656
}
1657
 
1422 tsoots 1658
QString PageItem::font() const
1659
{
1660
        return IFont;
1661
}
1662
 
1399 tsoots 1663
void PageItem::setFont(const QString& newFont)
1664
{
1432 tsoots 1665
        if (IFont == newFont)
1666
                return; // nothing to do -> return
1399 tsoots 1667
        if (UndoManager::undoEnabled())
1668
        {
1669
                SimpleState *ss = new SimpleState(Um::SetFont,
1400 tsoots 1670
                                                                                  QString(Um::FromTo).arg(IFont).arg(newFont), Um::IFont);
1399 tsoots 1671
                ss->set("SET_FONT", "setfont");
1672
                ss->set("OLD_FONT", IFont);
1673
                ss->set("NEW_FONT", newFont);
1674
                undoManager->action(this, ss);
1675
        }
1676
        IFont = newFont;
1677
}
1678
 
1422 tsoots 1679
int PageItem::fontSize() const
1680
{
1681
        return ISize;
1682
}
1683
 
1400 tsoots 1684
void PageItem::setFontSize(int newSize)
1685
{
1432 tsoots 1686
        if (ISize == newSize)
1687
                return; // nothing to do -> return
1400 tsoots 1688
        if (UndoManager::undoEnabled())
1689
        {
1690
                SimpleState *ss = new SimpleState(Um::SetFontSize,
1691
                                                                                  QString(Um::FromTo).arg(ISize/10.0).arg(newSize/10.0), Um::IFont);
1692
                ss->set("SET_FONT_SIZE", "setfontsize");
1693
                ss->set("OLD_SIZE", ISize);
1694
                ss->set("NEW_SIZE", newSize);
1695
                undoManager->action(this, ss);
1696
        }
1697
        ISize = newSize;
1698
}
1699
 
2230 fschmid 1700
int PageItem::fontHeight() const
1701
{
1702
        return TxtScaleV;
1703
}
1704
 
1705
void PageItem::setFontHeight(int newHeight)
1706
{
1707
        if (TxtScaleV == newHeight)
1708
                return; // nothing to do -> return
1709
        if (UndoManager::undoEnabled())
1710
        {
1711
                SimpleState *ss = new SimpleState(Um::SetFontHeight,
1712
                                                                                  QString(Um::FromTo).arg(TxtScaleV).arg(newHeight), Um::IFont);
1713
                ss->set("SET_FONT_HEIGHT", "setfontheight");
1714
                ss->set("OLD_HEIGHT", TxtScaleV);
1715
                ss->set("NEW_HEIGHT", newHeight);
1716
                undoManager->action(this, ss);
1717
        }
1718
        TxtScaleV = newHeight;
1719
}
1720
 
1422 tsoots 1721
int PageItem::fontWidth() const
1722
{
1723
        return TxtScale;
1724
}
1725
 
1400 tsoots 1726
void PageItem::setFontWidth(int newWidth)
1727
{
1432 tsoots 1728
        if (TxtScale == newWidth)
1729
                return; // nothing to do -> return
1400 tsoots 1730
        if (UndoManager::undoEnabled())
1731
        {
1732
                SimpleState *ss = new SimpleState(Um::SetFontWidth,
1733
                                                                                  QString(Um::FromTo).arg(TxtScale).arg(newWidth), Um::IFont);
1734
                ss->set("SET_FONT_WIDTH", "setfontwidth");
1735
                ss->set("OLD_WIDTH", TxtScale);
1736
                ss->set("NEW_WIDTH", newWidth);
1737
                undoManager->action(this, ss);
1738
        }
1739
        TxtScale = newWidth;
1740
}
1741
 
1422 tsoots 1742
QString PageItem::fontFillColor() const
1743
{
1744
        return TxtFill;
1745
}
1746
 
1401 tsoots 1747
void PageItem::setFontFillColor(const QString& newColor)
1748
{
1432 tsoots 1749
        if (TxtFill == newColor)
1750
                return; // nothing to do -> return
1401 tsoots 1751
        if (UndoManager::undoEnabled())
1752
        {
1753
                SimpleState *ss = new SimpleState(Um::SetFontFill,
1754
                                                                                  QString(Um::FromTo).arg(TxtFill).arg(newColor), Um::IFont);
1755
                ss->set("SET_FONT_FILL", "setfontfill");
1756
                ss->set("OLD_FILL", TxtFill);
1757
                ss->set("NEW_FILL", newColor);
1758
                undoManager->action(this, ss);
1759
        }
1760
        TxtFill = newColor;
1761
}
1762
 
1422 tsoots 1763
QString PageItem::fontStrokeColor() const
1764
{
1765
        return TxtStroke;
1766
}
1767
 
1401 tsoots 1768
void PageItem::setFontStrokeColor(const QString& newColor)
1769
{
1432 tsoots 1770
        if (TxtStroke == newColor)
1771
                return; // nothing to do -> return
1401 tsoots 1772
        if (UndoManager::undoEnabled())
1773
        {
1774
                SimpleState *ss = new SimpleState(Um::SetFontStroke,
1775
                                                                                  QString(Um::FromTo).arg(TxtStroke).arg(newColor), Um::IFont);
1776
                ss->set("SET_FONT_STROKE", "setfontstroke");
1777
                ss->set("OLD_STROKE", TxtStroke);
1778
                ss->set("NEW_STROKE", newColor);
1779
                undoManager->action(this, ss);
1780
        }
1781
        TxtStroke = newColor;
1782
}
1783
 
1422 tsoots 1784
int PageItem::fontFillShade() const
1785
{
1786
        return ShTxtFill;
1787
}
1788
 
1402 tsoots 1789
void PageItem::setFontFillShade(int newShade)
1790
{
1432 tsoots 1791
        if (ShTxtFill == newShade)
1792
                return; // nothing to do -> return
1402 tsoots 1793
        if (UndoManager::undoEnabled())
1794
        {
1795
                SimpleState *ss = new SimpleState(Um::SetFontFillShade,
1796
                                                                                  QString(Um::FromTo).arg(ShTxtFill).arg(newShade),
1797
                                                                                  Um::IFont);
1798
                ss->set("FONT_FILL_SHADE", "line_shade");
1799
                ss->set("OLD_SHADE", ShTxtFill);
1800
                ss->set("NEW_SHADE", newShade);
1801
                undoManager->action(this, ss);
1802
        }
1803
        ShTxtFill = newShade;
1804
}
1805
 
1422 tsoots 1806
int PageItem::fontStrokeShade() const
1807
{
1808
        return ShTxtStroke;
1809
}
1810
 
1402 tsoots 1811
void PageItem::setFontStrokeShade(int newShade)
1812
{
1432 tsoots 1813
        if (ShTxtStroke == newShade)
1814
                return; // nothing to do -> return
1402 tsoots 1815
        if (UndoManager::undoEnabled())
1816
        {
1817
                SimpleState *ss = new SimpleState(Um::SetFontStrokeShade,
1818
                                                                                  QString(Um::FromTo).arg(ShTxtStroke).arg(newShade),
1819
                                                                                  Um::IFont);
1820
                ss->set("FONT_STROKE_SHADE", "line_shade");
1821
                ss->set("OLD_SHADE", ShTxtStroke);
1822
                ss->set("NEW_SHADE", newShade);
1823
                undoManager->action(this, ss);
1824
        }
1825
        ShTxtStroke = newShade;
1826
}
1827
 
1422 tsoots 1828
int PageItem::fontEffects() const
1829
{
1830
        return TxTStyle;
1831
}
1415 tsoots 1832
 
1833
void PageItem::setFontEffects(int newEffects)
1834
{
1835
        if (UndoManager::undoEnabled())
1836
        {
1837
                SimpleState *ss = new SimpleState(Um::SetFontEffect, "", Um::IFont);
1838
                ss->set("FONT_EFFECTS", "fonteffects");
1839
                ss->set("OLD_EFFECT", TxTStyle);
1840
                ss->set("NEW_EFFECT", newEffects);
1841
                undoManager->action(this, ss);
1842
        }
2185 fschmid 1843
        TxTStyle &= ~1919;
1415 tsoots 1844
        TxTStyle |= newEffects;
1845
}
1846
 
2382 fschmid 1847
int PageItem::kerning() const
1422 tsoots 1848
{
1849
        return ExtraV;
1850
}
1851
 
2382 fschmid 1852
void PageItem::setKerning(int newKerning)
1403 tsoots 1853
{
1432 tsoots 1854
        if (ExtraV == newKerning)
1855
                return; // nothing to do -> return
1403 tsoots 1856
        if (UndoManager::undoEnabled())
1857
        {
1858
                SimpleState *ss = new SimpleState(Um::SetKerning,
1859
                                                                                  QString(Um::FromTo).arg(ExtraV).arg(newKerning),
1860
                                                                                  Um::IFont);
1861
                ss->set("KERNING", "kerning");
1862
                ss->set("OLD_KERNING", ExtraV);
1863
                ss->set("NEW_KERNING", newKerning);
1864
                undoManager->action(this, ss);
1865
        }
1866
        ExtraV = newKerning;
1867
}
1868
 
1422 tsoots 1869
double PageItem::lineSpacing() const
1870
{
1871
        return LineSp;
1872
}
1873
 
1403 tsoots 1874
void PageItem::setLineSpacing(double newSpacing)
1875
{
1432 tsoots 1876
        if (LineSp == newSpacing)
1877
                return; // nothing to do -> return
1403 tsoots 1878
        if (UndoManager::undoEnabled())
1879
        {
1880
                SimpleState *ss = new SimpleState(Um::SetLineSpacing,
1881
                                                                                  QString(Um::FromTo).arg(LineSp).arg(newSpacing),
1882
                                                                                  Um::IFont);
1883
                ss->set("SPACING", "spacing");
1884
                ss->set("OLD_SPACING", LineSp);
1885
                ss->set("NEW_SPACING", newSpacing);
1886
                undoManager->action(this, ss);
1887
        }
1888
        LineSp = newSpacing;
1889
}
1890
 
1422 tsoots 1891
QString PageItem::language() const
1892
{
1893
        return Language;
1894
}
1895
 
1403 tsoots 1896
void PageItem::setLanguage(const QString& newLanguage)
1897
{
1432 tsoots 1898
        if (Language == newLanguage)
1899
                return; // nothing to do -> return
1403 tsoots 1900
        if (UndoManager::undoEnabled())
1901
        {
1902
                SimpleState *ss = new SimpleState(Um::SetLanguage,
1903
                                                                                  QString(Um::FromTo).arg(Language).arg(newLanguage),
1904
                                                                                  Um::IFont);
1905
                ss->set("LANGUAGE", "lang");
1906
                ss->set("OLD_LANG", Language);
1907
                ss->set("NEW_LANG", newLanguage);
1908
                undoManager->action(this, ss);
1909
        }
1910
        Language = newLanguage;
1911
}
1912
 
1651 craig 1913
bool PageItem::textFlowsAroundFrame() const
1489 tsoots 1914
{
3634 cbradney 1915
        return textFlowsAroundFrameVal;
1651 craig 1916
}
1917
 
1918
void PageItem::setTextFlowsAroundFrame(bool isFlowing)
1919
{
1653 craig 1920
        if (textFlowsAroundFrameVal == isFlowing)
1489 tsoots 1921
                return;
1922
        if (UndoManager::undoEnabled())
1923
        {
1924
                SimpleState *ss = new SimpleState(isFlowing ? Um::TextFlow : Um::NoTextFlow, "", Um::IFont);
1925
                ss->set("TEXT_FLOW", isFlowing);
1926
                undoManager->action(this, ss);
1927
        }
1653 craig 1928
        textFlowsAroundFrameVal = isFlowing;
1489 tsoots 1929
}
1930
 
1653 craig 1931
bool PageItem::textFlowUsesBoundingBox() const
1489 tsoots 1932
{
3634 cbradney 1933
        return textFlowUsesBoundingBoxVal;
1653 craig 1934
}
1935
 
1936
void PageItem::setTextFlowUsesBoundingBox(bool useBounding)
1937
{
1938
        if (textFlowUsesBoundingBoxVal == useBounding)
1489 tsoots 1939
                return;
1940
        if (UndoManager::undoEnabled())
1941
        {
1942
                SimpleState *ss = new SimpleState(useBounding ? Um::BoundingBox : Um::NoBoundingBox, "", Um::IFont);
1653 craig 1943
                ss->set("TEXT_FLOW", textFlowsAroundFrame());
1489 tsoots 1944
                ss->set("BOUNDING_BOX", useBounding);
1945
                undoManager->action(this, ss);
1946
        }
1656 craig 1947
        if (useBounding && textFlowUsesContourLineVal)
1948
                textFlowUsesContourLineVal = false;
1653 craig 1949
        textFlowUsesBoundingBoxVal = useBounding;
1489 tsoots 1950
}
1951
 
1656 craig 1952
bool PageItem::textFlowUsesContourLine() const
1489 tsoots 1953
{
3634 cbradney 1954
        return textFlowUsesContourLineVal;
1656 craig 1955
}
1956
 
1957
void PageItem::setTextFlowUsesContourLine(bool useContour)
1958
{
1959
        if (textFlowUsesContourLineVal == useContour)
1489 tsoots 1960
                return;
1961
        if (UndoManager::undoEnabled())
1962
        {
1963
                SimpleState *ss = new SimpleState(useContour ? Um::ContourLine : Um::NoContourLine, "", Um::IFont);
1653 craig 1964
                ss->set("TEXT_FLOW", textFlowsAroundFrame());
1489 tsoots 1965
                ss->set("CONTOUR_LINE", useContour);
1966
                undoManager->action(this, ss);
1967
        }
1653 craig 1968
        if (useContour && textFlowUsesBoundingBoxVal)
1969
                textFlowUsesBoundingBoxVal = false;
1656 craig 1970
        textFlowUsesContourLineVal = useContour;
1489 tsoots 1971
}
1972
 
1460 cbradney 1973
PageItem::ItemType PageItem::itemType() const
1422 tsoots 1974
{
1460 cbradney 1975
        return itemTypeVal;
1422 tsoots 1976
}
1977
 
1460 cbradney 1978
void PageItem::convertTo(ItemType newType)
1416 tsoots 1979
{
1460 cbradney 1980
        if (itemTypeVal == newType)
1432 tsoots 1981
                return; // nothing to do -> return
1460 cbradney 1982
        assert(newType != 1);   //DEBUG CR 2005-02-06
1983
        assert(newType != 3);   //DEBUG CR 2005-02-06
1416 tsoots 1984
        QString fromType = "", toType = "";
1460 cbradney 1985
        switch (itemTypeVal)
1416 tsoots 1986
        {
1460 cbradney 1987
                case ImageFrame:
1988
                        fromType = Um::ImageFrame;
1989
                        break;
1990
                case TextFrame:
1991
                        fromType = Um::TextFrame;
1992
                        break;
1993
                case Polygon:
1994
                        fromType = Um::Polygon;
1995
                        break;
1996
                default:
1997
                        fromType = "";
1998
                        break;
1416 tsoots 1999
        }
2000
        switch (newType)
2001
        {
1460 cbradney 2002
                case ImageFrame:
1487 tsoots 2003
                        toType = Um::ImageFrame;
1416 tsoots 2004
                        setUPixmap(Um::IImageFrame);
2005
                        break;
1460 cbradney 2006
                case TextFrame:
1416 tsoots 2007
                        toType = Um::TextFrame;
2008
                        setUPixmap(Um::ITextFrame);
2009
                        break;
1460 cbradney 2010
                case Polygon:
1416 tsoots 2011
                        toType = Um::Polygon;
2012
                        setUPixmap(Um::IPolygon);
2013
                        break;
1460 cbradney 2014
                case PolyLine:
1416 tsoots 2015
                        toType = Um::Polyline;
2016
                        setUPixmap(Um::IPolyline);
2017
                        break;
1460 cbradney 2018
                default:
1487 tsoots 2019
                        toType = "";
1416 tsoots 2020
                        setUPixmap(NULL);
2021
                        break;
2022
        }
3669 cbradney 2023
        /*
1416 tsoots 2024
        if (UndoManager::undoEnabled())
2025
        {
2026
                SimpleState *ss = new SimpleState(Um::ConvertTo + " " + toType,
2027
                                                                                  QString(Um::FromTo).arg(fromType).arg(toType));
2028
                ss->set("CONVERT", "convert");
3625 avox 2029
                ss->set("PAGEITEM", reinterpret_cast<int>(this));
1460 cbradney 2030
                ss->set("OLD_TYPE", itemTypeVal);
1416 tsoots 2031
                ss->set("NEW_TYPE", newType);
2032
                undoManager->action(this, ss);
2033
        }
3669 cbradney 2034
        */
1460 cbradney 2035
        itemTypeVal = newType;
1416 tsoots 2036
}
2037
 
1688 tsoots 2038
void PageItem::setLayer(int layerId)
2039
{
2040
        if (LayerNr == layerId)
2041
                return;
2042
        if (UndoManager::undoEnabled())
2043
        {
2044
                SimpleState *ss = new SimpleState(Um::SendToLayer,
2045
                                                                                  QString(Um::FromTo).arg(LayerNr).arg(layerId),
2046
                                                                                  Um::ILayerAction);
2047
                ss->set("SEND_TO_LAYER", "send_to_layer");
2048
                ss->set("OLD_LAYER", LayerNr);
2049
                ss->set("NEW_LAYER", layerId);
2050
                undoManager->action(this, ss);
2051
        }
2052
        LayerNr = layerId;
2053
}
2054
 
1211 tsoots 2055
void PageItem::checkChanges(bool force)
2056
{
1286 tsoots 2057
        // has the item been resized
3634 cbradney 2058
        if (force || ((oldWidth != Width || oldHeight != Height) && shouldCheck()))
1286 tsoots 2059
                resizeUndoAction();
1211 tsoots 2060
        // has the item been rotated
3634 cbradney 2061
        if (force || ((oldRot != Rot) && (shouldCheck())))
1211 tsoots 2062
                rotateUndoAction();
2063
        // has the item been moved
3634 cbradney 2064
        if (force || ((oldXpos != Xpos || oldYpos != Ypos) && shouldCheck()))
1211 tsoots 2065
                moveUndoAction();
2066
}
2067
 
1238 tsoots 2068
bool PageItem::shouldCheck()
2069
{
1278 tsoots 2070
        return ((!ScApp->view->mousePressed()) &&
2071
                        (!ScApp->arrowKeyDown()) &&
1545 cbradney 2072
                        (!ScApp->propertiesPalette->userActionOn()));
1238 tsoots 2073
}
2074
 
1204 tsoots 2075
void PageItem::moveUndoAction()
2076
{
1286 tsoots 2077
        if (!shouldCheck())
2078
                return;
1211 tsoots 2079
        if (oldXpos == Xpos && oldYpos == Ypos)
2080
                return;
1204 tsoots 2081
        if (UndoManager::undoEnabled())
2082
        {
1487 tsoots 2083
                QString oldp;
2084
                QString newp;
2085
                if (oldOwnPage == -1)
2086
                        oldp = Um::ScratchSpace;
2087
                else
1490 tsoots 2088
                        oldp = QString(Um::PageNmbr).arg(ScApp->doc->FirstPnum + oldOwnPage);
1487 tsoots 2089
                if (OwnPage == -1)
2090
                        newp = Um::ScratchSpace;
2091
                else
1490 tsoots 2092
                        newp = QString(Um::PageNmbr).arg(ScApp->doc->FirstPnum + OwnPage);
1204 tsoots 2093
                SimpleState *ss = new SimpleState(Um::Move,
1487 tsoots 2094
                                          QString(Um::MoveFromTo).arg(oldXpos).arg(oldYpos).arg(oldp).
2095
                                                                  arg(Xpos).arg(Ypos).arg(newp), Um::IMove);
1204 tsoots 2096
                ss->set("OLD_XPOS", oldXpos);
2097
                ss->set("OLD_YPOS", oldYpos);
2098
                ss->set("NEW_XPOS", Xpos);
2099
                ss->set("NEW_YPOS", Ypos);
2100
                undoManager->action(this, ss);
2101
        }
2102
        oldXpos = Xpos;
2103
        oldYpos = Ypos;
1211 tsoots 2104
        oldOwnPage = OwnPage;
1204 tsoots 2105
}
2106
 
1206 tsoots 2107
void PageItem::resizeUndoAction()
2108
{
1286 tsoots 2109
        if (!shouldCheck())
2110
                return;
1211 tsoots 2111
        if (oldHeight == Height && oldWidth == Width)
2112
                return;
1206 tsoots 2113
        if (UndoManager::undoEnabled())
2114
        {
1487 tsoots 2115
                SimpleState *ss = new SimpleState(Um::Resize,
1211 tsoots 2116
                           QString(Um::ResizeFromTo).arg(oldWidth).arg(oldHeight).arg(Width).arg(Height),
1250 tsoots 2117
                                          Um::IResize);
1206 tsoots 2118
                ss->set("OLD_WIDTH", oldWidth);
2119
                ss->set("OLD_HEIGHT", oldHeight);
2120
                ss->set("NEW_WIDTH", Width);
2121
                ss->set("NEW_HEIGHT", Height);
2122
                ss->set("OLD_RXPOS", oldXpos);
2123
                ss->set("OLD_RYPOS", oldYpos);
2124
                ss->set("NEW_RXPOS", Xpos);
2125
                ss->set("NEW_RYPOS", Ypos);
1286 tsoots 2126
                ss->set("OLD_RROT", oldRot);
2127
                ss->set("NEW_RROT", Rot);
1206 tsoots 2128
                undoManager->action(this, ss);
2129
        }
2130
        oldXpos = Xpos;
2131
        oldYpos = Ypos;
2132
        oldHeight = Height;
2133
        oldWidth = Width;