Subversion Repositories Scribus

Rev

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

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