Subversion Repositories Scribus

Rev

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