Subversion Repositories Scribus

Rev

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