Subversion Repositories Scribus

Rev

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