Subversion Repositories Scribus

Rev

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