Subversion Repositories Scribus

Rev

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