Subversion Repositories Scribus

Rev

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

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