Subversion Repositories Scribus

Rev

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

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