Subversion Repositories Scribus

Rev

Rev 9390 | Details | Compare with Previous | Last modification | View Log | RSS feed

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