Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
16729 fschmid 1
#include "slaoutput.h"
2
#include <GlobalParams.h>
17419 fschmid 3
#include <poppler-config.h>
16774 fschmid 4
#include <QApplication>
16729 fschmid 5
#include <QFile>
6
#include "commonstrings.h"
7
#include "loadsaveplugin.h"
8
#include "sccolorengine.h"
9
#include "util.h"
10
#include "util_math.h"
11
 
12
 
13
SlaOutputDev::SlaOutputDev(ScribusDoc* doc, QList<PageItem*> *Elements, QStringList *importedColors, int flags)
14
{
15
        m_doc = doc;
16
        m_Elements = Elements;
17
        m_groupStack.clear();
16732 fschmid 18
        pushGroup();
16729 fschmid 19
        m_clipStack.clear();
20
        m_currentMask = "";
21
        m_importedColors = importedColors;
22
        CurrColorStroke = "Black";
23
        CurrColorFill = "Black";
24
        Coords = "";
25
        pathIsClosed = false;
26
        tmpSel = new Selection(m_doc, false);
27
        grStackDepth = 0;
28
        firstLayer = true;
29
        layerNum = 1;
30
        importerFlags = flags;
31
        currentLayer = m_doc->activeLayer();
32
        xref = NULL;
33
        m_fontEngine = 0;
34
        m_font = 0;
16774 fschmid 35
        updateGUICounter = 0;
17448 fschmid 36
        layersSetByOCG = false;
16729 fschmid 37
}
38
 
39
SlaOutputDev::~SlaOutputDev()
40
{
41
        m_groupStack.clear();
42
        tmpSel->clear();
43
        delete tmpSel;
44
        delete m_fontEngine;
45
}
46
 
47
 
17419 fschmid 48
void SlaOutputDev::startDoc(PDFDoc *doc, XRef *xrefA, Catalog *catA)
16729 fschmid 49
{
50
        xref = xrefA;
51
        catalog = catA;
17419 fschmid 52
        pdfDoc = doc;
16774 fschmid 53
        updateGUICounter = 0;
16729 fschmid 54
        m_fontEngine = new SplashFontEngine(
55
#if HAVE_T1LIB_H
56
        globalParams->getEnableT1lib(),
57
#endif
58
#if HAVE_FREETYPE_H
59
        globalParams->getEnableFreeType(),
60
        true,
61
        true,
62
#endif
63
        true);
64
}
65
 
17448 fschmid 66
void SlaOutputDev::startPage(int, GfxState *)
16729 fschmid 67
{
68
}
69
 
70
void SlaOutputDev::endPage()
71
{
72
//      qDebug() << "ending page";
73
}
74
 
75
void SlaOutputDev::saveState(GfxState *state)
76
{
77
//      qDebug() << "saveState" << grStackDepth;
78
        grStackDepth++;
79
}
80
 
81
void SlaOutputDev::restoreState(GfxState *state)
82
{
83
//      qDebug() << "restoreState" << grStackDepth;
84
        grStackDepth--;
85
        if (m_groupStack.count() != 0)
86
                m_groupStack.top().maskName = "";
87
        if (m_clipStack.count() != 0)
88
        {
89
                while (m_clipStack.top().grStackDepth > grStackDepth)
90
                {
91
                        clipEntry clp = m_clipStack.pop();
92
                        PageItem *ite = clp.ClipItem;
93
                        if (m_groupStack.count() != 0)
94
                        {
95
                                groupEntry gElements = m_groupStack.pop();
96
                                if (gElements.Items.count() > 0)
97
                                {
98
                                        for (int d = 0; d < gElements.Items.count(); d++)
99
                                        {
100
                                                m_Elements->removeAll(gElements.Items.at(d));
101
                                        }
102
                                        m_doc->groupObjectsToItem(ite, gElements.Items);
103
                                        ite->setFillTransparency(1.0 - state->getFillOpacity());
104
                                        ite->setFillBlendmode(getBlendMode(state));
105
                                }
106
                                else
107
                                {
108
                                        m_Elements->removeAll(ite);
109
                                        m_doc->Items->removeAll(ite);
110
                                        m_groupStack.top().Items.removeAll(ite);
111
                                }
112
                        }
113
                        if (m_clipStack.count() == 0)
114
                                break;
115
                }
116
        }
117
}
16764 fschmid 118
/*
16729 fschmid 119
void SlaOutputDev::updateFillColor(GfxState *state)
120
{
16746 fschmid 121
        int shade = 100;
122
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 123
}
16764 fschmid 124
*/
16729 fschmid 125
void SlaOutputDev::beginTransparencyGroup(GfxState *state, double *bbox, GfxColorSpace * /*blendingColorSpace*/, GBool /*isolated*/, GBool /*knockout*/, GBool forSoftMask)
126
{
127
//      qDebug() << "Start Group";
16732 fschmid 128
        pushGroup("", forSoftMask);
16729 fschmid 129
}
130
 
131
void SlaOutputDev::endTransparencyGroup(GfxState *state)
132
{
133
//      qDebug() << "End Group";
134
        if (m_groupStack.count() != 0)
135
        {
136
                groupEntry gElements = m_groupStack.pop();
137
                tmpSel->clear();
138
                if (gElements.Items.count() > 0)
139
                {
140
                        for (int dre = 0; dre < gElements.Items.count(); ++dre)
141
                        {
142
                                tmpSel->addItem(gElements.Items.at(dre), true);
143
                                m_Elements->removeAll(gElements.Items.at(dre));
144
                        }
145
                        PageItem *ite = m_doc->groupObjectsSelection(tmpSel);
146
                        ite->setFillTransparency(1.0 - state->getFillOpacity());
147
                        ite->setFillBlendmode(getBlendMode(state));
148
                        if (gElements.forSoftMask)
149
                        {
150
                                ScPattern pat = ScPattern();
151
                                pat.setDoc(m_doc);
152
                                m_doc->DoDrawing = true;
153
                                pat.pattern = ite->DrawObj_toImage(qMax(ite->width(), ite->height()));
154
                                pat.xoffset = 0;
155
                                pat.yoffset = 0;
156
                                m_doc->DoDrawing = false;
157
                                pat.width = ite->width();
158
                                pat.height = ite->height();
17374 fschmid 159
                                ite->gXpos = 0;
160
                                ite->gYpos = 0;
161
                                ite->setXYPos(ite->gXpos, ite->gYpos, true);
16729 fschmid 162
                                pat.items.append(ite);
163
                                m_doc->Items->removeAll(ite);
164
                                QString id = QString("Pattern_from_PDF_%1S").arg(m_doc->docPatterns.count() + 1);
165
                                m_doc->addPattern(id, pat);
166
                                m_currentMask = id;
167
                                tmpSel->clear();
168
                                return;
169
                        }
170
                        else
171
                        {
172
                                for (int as = 0; as < tmpSel->count(); ++as)
173
                                {
174
                                        m_Elements->append(tmpSel->itemAt(as));
175
                                }
176
                        }
177
                        if (m_groupStack.count() != 0)
16732 fschmid 178
                                applyMask(ite);
16729 fschmid 179
                }
180
                if (m_groupStack.count() != 0)
181
                {
182
                        for (int as = 0; as < tmpSel->count(); ++as)
183
                        {
184
                                m_groupStack.top().Items.append(tmpSel->itemAt(as));
185
                        }
186
                }
187
                tmpSel->clear();
188
        }
189
}
190
 
16732 fschmid 191
void SlaOutputDev::setSoftMask(GfxState * /*state*/, double * /*bbox*/, GBool alpha, Function *transferFunc, GfxColor * /*backdropColor*/)
16729 fschmid 192
{
193
        if (m_groupStack.count() != 0)
194
        {
16732 fschmid 195
                double lum = 0;
196
                double lum2 = 0;
197
                if (transferFunc)
198
                        transferFunc->transform(&lum, &lum2);
199
                else
200
                        lum2 = lum;
201
                if (lum == lum2)
202
                        m_groupStack.top().inverted = false;
203
                else
204
                        m_groupStack.top().inverted = true;
205
//              qDebug() << "Inverted Softmask" << m_groupStack.top().inverted;
16729 fschmid 206
                m_groupStack.top().maskName = m_currentMask;
207
                m_groupStack.top().alpha = alpha;
208
        }
209
}
210
 
211
void SlaOutputDev::clearSoftMask(GfxState * /*state*/)
212
{
213
        if (m_groupStack.count() != 0)
214
        {
215
                m_groupStack.top().maskName = "";
216
        }
217
}
218
 
219
void SlaOutputDev::clip(GfxState *state)
220
{
221
//      qDebug() << "Clip";
222
        double *ctm;
223
        ctm = state->getCTM();
224
        QString output = convertPath(state->getPath());
225
        FPointArray out;
226
        out.parseSVG(output);
227
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
228
        out.map(m_ctm);
229
        double xmin, ymin, xmax, ymax;
230
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
231
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
232
        crect = crect.normalized();
233
        int z = m_doc->itemAdd(PageItem::Group, PageItem::Rectangle, crect.x() + m_doc->currentPage()->xOffset(), crect.y() + m_doc->currentPage()->yOffset(), crect.width(), crect.height(), 0, CommonStrings::None, CommonStrings::None, true);
234
        PageItem *ite = m_doc->Items->at(z);
235
        FPoint wh(getMinClipF(&out));
236
        out.translate(-wh.x(), -wh.y());
237
        ite->PoLine = out.copy();  //FIXME: try to avoid copy if FPointArray when properly shared
238
        ite->ClipEdited = true;
239
        ite->FrameType = 3;
16744 fschmid 240
        ite->setFillEvenOdd(false);
16729 fschmid 241
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
242
        ite->ContourLine = ite->PoLine.copy();
243
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
244
        m_doc->AdjustItemSize(ite);
245
        m_Elements->append(ite);
246
        if (m_groupStack.count() != 0)
247
        {
248
                m_groupStack.top().Items.append(ite);
16732 fschmid 249
                applyMask(ite);
16729 fschmid 250
        }
251
        clipEntry clp;
252
        clp.ClipCoords = out.copy();
253
        clp.ClipItem = ite;
254
        clp.grStackDepth = grStackDepth;
255
        m_clipStack.push(clp);
256
        m_doc->GroupCounter++;
16732 fschmid 257
        pushGroup();
16729 fschmid 258
}
259
 
260
void SlaOutputDev::eoClip(GfxState *state)
261
{
262
//      qDebug() << "EoClip";
263
        double *ctm;
264
        ctm = state->getCTM();
265
        QString output = convertPath(state->getPath());
266
        FPointArray out;
267
        out.parseSVG(output);
268
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
269
        out.map(m_ctm);
270
        double xmin, ymin, xmax, ymax;
271
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
272
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
273
        crect = crect.normalized();
274
        int z = m_doc->itemAdd(PageItem::Group, PageItem::Rectangle, crect.x() + m_doc->currentPage()->xOffset(), crect.y() + m_doc->currentPage()->yOffset(), crect.width(), crect.height(), 0, CommonStrings::None, CommonStrings::None, true);
275
        PageItem *ite = m_doc->Items->at(z);
276
        FPoint wh(getMinClipF(&out));
277
        out.translate(-wh.x(), -wh.y());
278
        ite->PoLine = out.copy();  //FIXME: try to avoid copy if FPointArray when properly shared
279
        ite->ClipEdited = true;
280
        ite->FrameType = 3;
16744 fschmid 281
        ite->setFillEvenOdd(true);
16729 fschmid 282
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
283
        ite->ContourLine = ite->PoLine.copy();
284
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
285
        m_doc->AdjustItemSize(ite);
286
        m_Elements->append(ite);
287
        if (m_groupStack.count() != 0)
288
        {
289
                m_groupStack.top().Items.append(ite);
16732 fschmid 290
                applyMask(ite);
16729 fschmid 291
        }
292
        clipEntry clp;
293
        clp.ClipCoords = out.copy();
294
        clp.ClipItem = ite;
295
        clp.grStackDepth = grStackDepth;
296
        m_clipStack.push(clp);
297
        m_doc->GroupCounter++;
16732 fschmid 298
        pushGroup();
16729 fschmid 299
}
300
 
301
void SlaOutputDev::stroke(GfxState *state)
302
{
303
//      qDebug() << "Stroke";
304
        double *ctm;
305
        ctm = state->getCTM();
306
        double xCoor = m_doc->currentPage()->xOffset();
307
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 308
        int shade = 100;
309
        CurrColorStroke = getColor(state->getStrokeColorSpace(), state->getStrokeColor(), &shade);
16729 fschmid 310
        QString output = convertPath(state->getPath());
311
        getPenState(state);
312
        if ((m_Elements->count() != 0) && (output == Coords))                   // Path is the same as in last fill
313
        {
17295 jghali 314
                PageItem* ite = m_Elements->last();
16729 fschmid 315
                ite->setLineColor(CurrColorStroke);
16746 fschmid 316
                ite->setLineShade(shade);
16729 fschmid 317
                ite->setLineEnd(PLineEnd);
318
                ite->setLineJoin(PLineJoin);
319
                ite->setLineWidth(state->getTransformedLineWidth());
320
                ite->setDashes(DashValues);
321
                ite->setDashOffset(DashOffset);
322
                ite->setLineTransparency(1.0 - state->getStrokeOpacity());
323
        }
324
        else
325
        {
326
                FPointArray out;
327
                out.parseSVG(output);
328
                m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
329
                out.map(m_ctm);
330
                FPoint wh = out.WidthHeight();
331
                if ((out.size() > 3) && ((wh.x() != 0.0) || (wh.y() != 0.0)))
332
                {
333
                        int z;
334
                        if (pathIsClosed)
335
                                z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, state->getTransformedLineWidth(), CommonStrings::None, CurrColorStroke, true);
336
                        else
337
                                z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, xCoor, yCoor, 10, 10, state->getTransformedLineWidth(), CommonStrings::None, CurrColorStroke, true);
338
                        PageItem* ite = m_doc->Items->at(z);
339
                        ite->PoLine = out.copy();
340
                        ite->ClipEdited = true;
341
                        ite->FrameType = 3;
16746 fschmid 342
                        ite->setLineShade(shade);
16729 fschmid 343
                        ite->setLineTransparency(1.0 - state->getStrokeOpacity());
344
                        ite->setLineBlendmode(getBlendMode(state));
345
                        ite->setLineEnd(PLineEnd);
346
                        ite->setLineJoin(PLineJoin);
347
                        ite->setDashes(DashValues);
348
                        ite->setDashOffset(DashOffset);
349
                        ite->setWidthHeight(wh.x(),wh.y());
350
                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
351
                        m_doc->AdjustItemSize(ite);
352
                        m_Elements->append(ite);
353
                        if (m_groupStack.count() != 0)
354
                                m_groupStack.top().Items.append(ite);
355
                }
356
        }
357
}
358
 
359
void SlaOutputDev::fill(GfxState *state)
360
{
361
//      qDebug() << "Fill";
362
        double *ctm;
363
        ctm = state->getCTM();
364
        double xCoor = m_doc->currentPage()->xOffset();
365
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 366
        int shade = 100;
367
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 368
        FPointArray out;
369
        QString output = convertPath(state->getPath());
370
        out.parseSVG(output);
371
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
372
        out.map(m_ctm);
373
        Coords = output;
374
        FPoint wh = out.WidthHeight();
375
        if ((out.size() > 3) && ((wh.x() != 0.0) || (wh.y() != 0.0)))
376
        {
377
                int z;
378
                if (pathIsClosed)
379
                        z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, CurrColorFill, CommonStrings::None, true);
380
                else
381
                        z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, CurrColorFill, CommonStrings::None, true);
382
                PageItem* ite = m_doc->Items->at(z);
383
                ite->PoLine = out.copy();
384
                ite->ClipEdited = true;
385
                ite->FrameType = 3;
16746 fschmid 386
                ite->setFillShade(shade);
16729 fschmid 387
                ite->setLineShade(100);
388
                ite->setFillEvenOdd(false);
389
                ite->setFillTransparency(1.0 - state->getFillOpacity());
390
                ite->setFillBlendmode(getBlendMode(state));
391
                ite->setLineEnd(PLineEnd);
392
                ite->setLineJoin(PLineJoin);
393
                ite->setWidthHeight(wh.x(),wh.y());
394
                ite->setTextFlowMode(PageItem::TextFlowDisabled);
395
                m_doc->AdjustItemSize(ite);
396
                m_Elements->append(ite);
397
                if (m_groupStack.count() != 0)
398
                {
399
                        m_groupStack.top().Items.append(ite);
16732 fschmid 400
                        applyMask(ite);
16729 fschmid 401
                }
402
        }
403
}
404
 
405
void SlaOutputDev::eoFill(GfxState *state)
406
{
407
//      qDebug() << "EoFill";
408
        double *ctm;
409
        ctm = state->getCTM();
410
        double xCoor = m_doc->currentPage()->xOffset();
411
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 412
        int shade = 100;
413
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 414
        FPointArray out;
415
        QString output = convertPath(state->getPath());
416
        out.parseSVG(output);
417
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
418
        out.map(m_ctm);
419
        Coords = output;
420
        FPoint wh = out.WidthHeight();
421
        if ((out.size() > 3) && ((wh.x() != 0.0) || (wh.y() != 0.0)))
422
        {
423
                int z;
424
                if (pathIsClosed)
425
                        z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, CurrColorFill, CommonStrings::None, true);
426
                else
427
                        z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, CurrColorFill, CommonStrings::None, true);
428
                PageItem* ite = m_doc->Items->at(z);
429
                ite->PoLine = out.copy();
430
                ite->ClipEdited = true;
431
                ite->FrameType = 3;
16746 fschmid 432
                ite->setFillShade(shade);
16729 fschmid 433
                ite->setLineShade(100);
434
                ite->setFillEvenOdd(true);
435
                ite->setFillTransparency(1.0 - state->getFillOpacity());
436
                ite->setFillBlendmode(getBlendMode(state));
437
                ite->setLineEnd(PLineEnd);
438
                ite->setLineJoin(PLineJoin);
439
                ite->setWidthHeight(wh.x(),wh.y());
440
                ite->setTextFlowMode(PageItem::TextFlowDisabled);
441
                m_doc->AdjustItemSize(ite);
442
                m_Elements->append(ite);
443
                if (m_groupStack.count() != 0)
444
                {
445
                        m_groupStack.top().Items.append(ite);
16732 fschmid 446
                        applyMask(ite);
16729 fschmid 447
                }
448
        }
449
}
450
 
451
GBool SlaOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax)
452
{
453
        double GrStartX;
454
        double GrStartY;
455
        double GrEndX;
456
        double GrEndY;
16746 fschmid 457
        int shade = 100;
16729 fschmid 458
        Function *func = shading->getFunc(0);
459
        VGradient FillGradient = VGradient(VGradient::linear);
460
        FillGradient.clearStops();
461
        GfxColorSpace *color_space = shading->getColorSpace();
462
        if (func->getType() == 3)
463
        {
464
                StitchingFunction *stitchingFunc = (StitchingFunction*)func;
465
                double *bounds = stitchingFunc->getBounds();
466
                int num_funcs = stitchingFunc->getNumFuncs();
467
                // Add stops from all the stitched functions
468
                for ( int i = 0 ; i < num_funcs ; i++ )
469
                {
470
                        GfxColor temp;
471
                        ((GfxAxialShading*)shading)->getColor(bounds[i], &temp);
16746 fschmid 472
                        QString stopColor = getColor(color_space, &temp, &shade);
473
                        FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor], m_doc), bounds[i], 0.5, 1.0, stopColor, shade );
16729 fschmid 474
                        if (i == num_funcs - 1)
475
                        {
476
                                ((GfxAxialShading*)shading)->getColor(bounds[i+1], &temp);
16746 fschmid 477
                                QString stopColor = getColor(color_space, &temp, &shade);
478
                                FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor], m_doc), bounds[i+1], 0.5, 1.0, stopColor, shade );
16729 fschmid 479
                        }
480
                }
481
        }
17291 fschmid 482
        else if ((func->getType() == 2) || (func->getType() == 0))
16729 fschmid 483
        {
484
                GfxColor stop1;
485
                ((GfxAxialShading*)shading)->getColor(0.0, &stop1);
16746 fschmid 486
                QString stopColor1 = getColor(color_space, &stop1, &shade);
487
                FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor1], m_doc), 0.0, 0.5, 1.0, stopColor1, shade );
16729 fschmid 488
                GfxColor stop2;
489
                ((GfxAxialShading*)shading)->getColor(1.0, &stop2);
16746 fschmid 490
                QString stopColor2 = getColor(color_space, &stop2, &shade);
491
                FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor2], m_doc), 1.0, 0.5, 1.0, stopColor2, shade );
16729 fschmid 492
        }
493
        ((GfxAxialShading*)shading)->getCoords(&GrStartX, &GrStartY, &GrEndX, &GrEndY);
494
        double xmin, ymin, xmax, ymax;
495
        // get the clip region bbox
496
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
497
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
498
        crect = crect.normalized();
499
        double *ctm;
500
        ctm = state->getCTM();
501
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
502
        FPointArray gr;
503
        gr.addPoint(GrStartX, GrStartY);
504
        gr.addPoint(GrEndX, GrEndY);
505
        gr.map(m_ctm);
506
        GrStartX = gr.point(0).x() - crect.x();
507
        GrStartY = gr.point(0).y() - crect.y();
508
        GrEndX = gr.point(1).x() - crect.x();
509
        GrEndY = gr.point(1).y() - crect.y();
510
        double xCoor = m_doc->currentPage()->xOffset();
511
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 512
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 513
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
514
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
515
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
516
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
517
        output += QString("L %1 %2").arg(0.0).arg(0.0);
518
        output += QString("Z");
519
        pathIsClosed = true;
520
        Coords = output;
521
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
522
        PageItem* ite = m_doc->Items->at(z);
523
        ite->ClipEdited = true;
524
        ite->FrameType = 3;
16746 fschmid 525
        ite->setFillShade(shade);
16729 fschmid 526
        ite->setLineShade(100);
527
        ite->setFillEvenOdd(false);
528
        ite->setFillTransparency(1.0 - state->getFillOpacity());
529
        ite->setFillBlendmode(getBlendMode(state));
530
        ite->setLineEnd(PLineEnd);
531
        ite->setLineJoin(PLineJoin);
532
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
533
        ite->GrType = 6;
534
        ite->fill_gradient = FillGradient;
535
        ite->setGradientVector(GrStartX, GrStartY, GrEndX, GrEndY, 0, 0, 1, 0);
536
        m_doc->AdjustItemSize(ite);
537
        m_Elements->append(ite);
538
        if (m_groupStack.count() != 0)
539
        {
540
                m_groupStack.top().Items.append(ite);
16732 fschmid 541
                applyMask(ite);
16729 fschmid 542
        }
543
        return gTrue;
544
}
545
 
546
GBool SlaOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax)
547
{
548
        double GrStartX;
549
        double GrStartY;
550
        double GrEndX;
551
        double GrEndY;
16746 fschmid 552
        int shade = 100;
16729 fschmid 553
        Function *func = shading->getFunc(0);
554
        VGradient FillGradient = VGradient(VGradient::linear);
555
        FillGradient.clearStops();
556
        GfxColorSpace *color_space = shading->getColorSpace();
557
        if (func->getType() == 3)
558
        {
559
                StitchingFunction *stitchingFunc = (StitchingFunction*)func;
560
                double *bounds = stitchingFunc->getBounds();
561
                int num_funcs = stitchingFunc->getNumFuncs();
562
                // Add stops from all the stitched functions
563
                for ( int i = 0 ; i < num_funcs ; i++ )
564
                {
565
                        GfxColor temp;
566
                        ((GfxRadialShading*)shading)->getColor(bounds[i], &temp);
16746 fschmid 567
                        QString stopColor = getColor(color_space, &temp, &shade);
568
                        FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor], m_doc), bounds[i], 0.5, 1.0, stopColor, shade );
16729 fschmid 569
                        if (i == num_funcs - 1)
570
                        {
571
                                ((GfxRadialShading*)shading)->getColor(bounds[i+1], &temp);
16746 fschmid 572
                                QString stopColor = getColor(color_space, &temp, &shade);
573
                                FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor], m_doc), bounds[i+1], 0.5, 1.0, stopColor, shade );
16729 fschmid 574
                        }
575
                }
576
        }
17291 fschmid 577
        else if ((func->getType() == 2) || (func->getType() == 0))
16729 fschmid 578
        {
579
                GfxColor stop1;
580
                ((GfxRadialShading*)shading)->getColor(0.0, &stop1);
16746 fschmid 581
                QString stopColor1 = getColor(color_space, &stop1, &shade);
582
                FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor1], m_doc), 0.0, 0.5, 1.0, stopColor1, shade );
16729 fschmid 583
                GfxColor stop2;
584
                ((GfxRadialShading*)shading)->getColor(1.0, &stop2);
16746 fschmid 585
                QString stopColor2 = getColor(color_space, &stop2, &shade);
586
                FillGradient.addStop( ScColorEngine::getRGBColor(m_doc->PageColors[stopColor2], m_doc), 1.0, 0.5, 1.0, stopColor2, shade );
16729 fschmid 587
        }
588
        double r0, x1, y1, r1;
589
        ((GfxRadialShading*)shading)->getCoords(&GrStartX, &GrStartY, &r0, &x1, &y1, &r1);
590
        double xmin, ymin, xmax, ymax;
591
        // get the clip region bbox
592
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
593
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
594
        crect = crect.normalized();
595
        double GrFocalX = x1;
596
        double GrFocalY = y1;
597
        GrEndX = GrFocalX + r1;
598
        GrEndY = GrFocalY;
599
        double *ctm;
600
        ctm = state->getCTM();
601
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
602
        FPointArray gr;
603
        gr.addPoint(GrStartX, GrStartY);
604
        gr.addPoint(GrEndX, GrEndY);
605
        gr.addPoint(GrFocalX, GrFocalY);
606
        gr.map(m_ctm);
607
        GrStartX = gr.point(0).x() - crect.x();
608
        GrStartY = gr.point(0).y() - crect.y();
609
        GrEndX = gr.point(1).x() - crect.x();
610
        GrEndY = gr.point(1).y() - crect.y();
611
        GrFocalX = gr.point(2).x() - crect.x();
612
        GrFocalY = gr.point(2).y() - crect.y();
613
        double xCoor = m_doc->currentPage()->xOffset();
614
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 615
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 616
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
617
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
618
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
619
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
620
        output += QString("L %1 %2").arg(0.0).arg(0.0);
621
        output += QString("Z");
622
        pathIsClosed = true;
623
        Coords = output;
624
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
625
        PageItem* ite = m_doc->Items->at(z);
626
        ite->ClipEdited = true;
627
        ite->FrameType = 3;
16746 fschmid 628
        ite->setFillShade(shade);
16729 fschmid 629
        ite->setLineShade(100);
630
        ite->setFillEvenOdd(false);
631
        ite->setFillTransparency(1.0 - state->getFillOpacity());
632
        ite->setFillBlendmode(getBlendMode(state));
633
        ite->setLineEnd(PLineEnd);
634
        ite->setLineJoin(PLineJoin);
635
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
636
        ite->GrType = 7;
637
        ite->fill_gradient = FillGradient;
638
        ite->setGradientVector(GrStartX, GrStartY, GrEndX, GrEndY, GrFocalX, GrFocalY, 1, 0);
639
        m_doc->AdjustItemSize(ite);
640
        m_Elements->append(ite);
641
        if (m_groupStack.count() != 0)
642
        {
643
                m_groupStack.top().Items.append(ite);
16732 fschmid 644
                applyMask(ite);
16729 fschmid 645
        }
646
        return gTrue;
647
}
648
 
16745 fschmid 649
GBool SlaOutputDev::gouraudTriangleShadedFill(GfxState *state, GfxGouraudTriangleShading *shading)
650
{
651
        double xCoor = m_doc->currentPage()->xOffset();
652
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 653
        int shade = 100;
654
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16745 fschmid 655
        double xmin, ymin, xmax, ymax;
656
        // get the clip region bbox
657
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
658
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
659
        crect = crect.normalized();
660
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
661
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
662
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
663
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
664
        output += QString("L %1 %2").arg(0.0).arg(0.0);
665
        output += QString("Z");
666
        pathIsClosed = true;
667
        Coords = output;
668
        double *ctm;
669
        ctm = state->getCTM();
670
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
671
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
672
        PageItem* ite = m_doc->Items->at(z);
673
        ite->ClipEdited = true;
674
        ite->FrameType = 3;
675
        ite->setFillShade(100);
676
        ite->setLineShade(100);
677
        ite->setFillEvenOdd(false);
678
        ite->setFillTransparency(1.0 - state->getFillOpacity());
679
        ite->setFillBlendmode(getBlendMode(state));
680
        ite->setLineEnd(PLineEnd);
681
        ite->setLineJoin(PLineJoin);
682
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
683
        m_doc->AdjustItemSize(ite);
684
        m_Elements->append(ite);
685
        if (m_groupStack.count() != 0)
686
        {
687
                m_groupStack.top().Items.append(ite);
688
                applyMask(ite);
689
        }
690
        GfxColor color[3];
691
        double x0, y0, x1, y1, x2, y2;
692
        for (int i = 0; i < shading->getNTriangles(); i++)
693
        {
694
                meshGradientPatch patchM;
695
                shading->getTriangle(i, &x0, &y0, &color[0],  &x1, &y1, &color[1],  &x2, &y2, &color[2]);
696
                patchM.BL.resetTo(FPoint(x0, y0));
697
                patchM.BL.shade = 100;
698
                patchM.BL.transparency = 1.0;
16746 fschmid 699
                patchM.BL.colorName = getColor(shading->getColorSpace(), &color[0], &shade);
700
                patchM.BL.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.BL.colorName], m_doc, shade);
16745 fschmid 701
                patchM.TL.resetTo(FPoint(x1, y1));
702
                patchM.TL.shade = 100;
703
                patchM.TL.transparency = 1.0;
16746 fschmid 704
                patchM.TL.colorName = getColor(shading->getColorSpace(), &color[1], &shade);
705
                patchM.TL.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.TL.colorName], m_doc, shade);
16745 fschmid 706
                patchM.TR.resetTo(FPoint(x2, y2));
707
                patchM.TR.shade = 100;
708
                patchM.TR.transparency = 1.0;
16746 fschmid 709
                patchM.TR.colorName = getColor(shading->getColorSpace(), &color[2], &shade);
710
                patchM.TR.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.TR.colorName], m_doc, shade);
16745 fschmid 711
                patchM.BR.resetTo(FPoint(x0, y0));
712
                patchM.BR.shade = 100;
713
                patchM.BR.transparency = 1.0;
16746 fschmid 714
                patchM.BR.colorName = getColor(shading->getColorSpace(), &color[0], &shade);
715
                patchM.BR.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.BR.colorName], m_doc, shade);
16745 fschmid 716
                patchM.TL.transform(m_ctm);
717
                patchM.TL.moveRel(-crect.x(), -crect.y());
718
                patchM.TR.transform(m_ctm);
719
                patchM.TR.moveRel(-crect.x(), -crect.y());
720
                patchM.BR.transform(m_ctm);
721
                patchM.BR.moveRel(-crect.x(), -crect.y());
722
                patchM.BL.transform(m_ctm);
723
                patchM.BL.moveRel(-crect.x(), -crect.y());
724
                ite->meshGradientPatches.append(patchM);
725
        }
726
        ite->GrType = 12;
727
        return gTrue;
728
}
729
 
16729 fschmid 730
GBool SlaOutputDev::patchMeshShadedFill(GfxState *state, GfxPatchMeshShading *shading)
731
{
732
//      qDebug() << "mesh shaded fill";
733
        double xCoor = m_doc->currentPage()->xOffset();
734
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 735
        int shade = 100;
736
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 737
        double xmin, ymin, xmax, ymax;
738
        // get the clip region bbox
739
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
740
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
741
        crect = crect.normalized();
742
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
743
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
744
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
745
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
746
        output += QString("L %1 %2").arg(0.0).arg(0.0);
747
        output += QString("Z");
748
        pathIsClosed = true;
749
        Coords = output;
750
        double *ctm;
751
        ctm = state->getCTM();
752
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
753
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
754
        PageItem* ite = m_doc->Items->at(z);
755
        ite->ClipEdited = true;
756
        ite->FrameType = 3;
16746 fschmid 757
        ite->setFillShade(shade);
16729 fschmid 758
        ite->setLineShade(100);
759
        ite->setFillEvenOdd(false);
760
        ite->setFillTransparency(1.0 - state->getFillOpacity());
761
        ite->setFillBlendmode(getBlendMode(state));
762
        ite->setLineEnd(PLineEnd);
763
        ite->setLineJoin(PLineJoin);
764
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
765
        m_doc->AdjustItemSize(ite);
766
        m_Elements->append(ite);
767
        if (m_groupStack.count() != 0)
768
        {
769
                m_groupStack.top().Items.append(ite);
16732 fschmid 770
                applyMask(ite);
16729 fschmid 771
        }
772
//      qDebug() << "Mesh of" << shading->getNPatches() << "Patches";
16869 fschmid 773
        ite->meshGradientPatches.clear();
16729 fschmid 774
        for (int i = 0; i < shading->getNPatches(); i++)
775
        {
776
                GfxPatch *patch = shading->getPatch(i);
777
                GfxColor color;
778
                meshGradientPatch patchM;
779
                int u, v;
780
                patchM.BL.resetTo(FPoint(patch->x[0][0], patch->y[0][0]));
781
                patchM.BL.controlTop = FPoint(patch->x[0][1], patch->y[0][1]);
782
                patchM.BL.controlRight = FPoint(patch->x[1][0], patch->y[1][0]);
16869 fschmid 783
                patchM.BL.controlColor = FPoint(patch->x[1][1], patch->y[1][1]);
16729 fschmid 784
                u = 0;
785
                v = 0;
786
                if (shading->isParameterized())
787
                {
788
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
789
                }
790
                else
791
                {
792
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
793
                        {
794
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
795
                        }
796
                }
16746 fschmid 797
                patchM.BL.colorName = getColor(shading->getColorSpace(), &color, &shade);
16729 fschmid 798
                patchM.BL.shade = 100;
799
                patchM.BL.transparency = 1.0;
16746 fschmid 800
                patchM.BL.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.BL.colorName], m_doc, shade);
16729 fschmid 801
 
802
                u = 0;
803
                v = 1;
804
                patchM.TL.resetTo(FPoint(patch->x[0][3], patch->y[0][3]));
805
                patchM.TL.controlRight = FPoint(patch->x[1][3], patch->y[1][3]);
806
                patchM.TL.controlBottom = FPoint(patch->x[0][2], patch->y[0][2]);
16869 fschmid 807
                patchM.TL.controlColor = FPoint(patch->x[1][2], patch->y[1][2]);
16729 fschmid 808
                if (shading->isParameterized())
809
                {
810
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
811
                }
812
                else
813
                {
814
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
815
                        {
816
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
817
                        }
818
                }
16746 fschmid 819
                patchM.TL.colorName = getColor(shading->getColorSpace(), &color, &shade);
16729 fschmid 820
                patchM.TL.shade = 100;
821
                patchM.TL.transparency = 1.0;
16746 fschmid 822
                patchM.TL.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.TL.colorName], m_doc, shade);
16729 fschmid 823
 
824
                u = 1;
825
                v = 1;
826
                patchM.TR.resetTo(FPoint(patch->x[3][3], patch->y[3][3]));
827
                patchM.TR.controlBottom = FPoint(patch->x[3][2], patch->y[3][2]);
828
                patchM.TR.controlLeft = FPoint(patch->x[2][3], patch->y[2][3]);
16869 fschmid 829
                patchM.TR.controlColor = FPoint(patch->x[2][2], patch->y[2][2]);
16729 fschmid 830
                if (shading->isParameterized())
831
                {
832
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
833
                }
834
                else
835
                {
836
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
837
                        {
838
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
839
                        }
840
                }
16746 fschmid 841
                patchM.TR.colorName = getColor(shading->getColorSpace(), &color, &shade);
16729 fschmid 842
                patchM.TR.shade = 100;
843
                patchM.TR.transparency = 1.0;
16746 fschmid 844
                patchM.TR.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.TR.colorName], m_doc, shade);
16729 fschmid 845
 
846
                u = 1;
847
                v = 0;
848
                patchM.BR.resetTo(FPoint(patch->x[3][0], patch->y[3][0]));
849
                patchM.BR.controlLeft = FPoint(patch->x[2][0], patch->y[2][0]);
850
                patchM.BR.controlTop = FPoint(patch->x[3][1], patch->y[3][1]);
16869 fschmid 851
                patchM.BR.controlColor = FPoint(patch->x[2][1], patch->y[2][1]);
16729 fschmid 852
                if (shading->isParameterized())
853
                {
854
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
855
                }
856
                else
857
                {
858
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
859
                        {
860
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
861
                        }
862
                }
16746 fschmid 863
                patchM.BR.colorName = getColor(shading->getColorSpace(), &color, &shade);
16729 fschmid 864
                patchM.BR.shade = 100;
865
                patchM.BR.transparency = 1.0;
16746 fschmid 866
                patchM.BR.color = ScColorEngine::getShadeColorProof(m_doc->PageColors[patchM.BR.colorName], m_doc, shade);
16729 fschmid 867
 
868
                patchM.TL.transform(m_ctm);
869
                patchM.TL.moveRel(-crect.x(), -crect.y());
870
                patchM.TR.transform(m_ctm);
871
                patchM.TR.moveRel(-crect.x(), -crect.y());
872
                patchM.BR.transform(m_ctm);
873
                patchM.BR.moveRel(-crect.x(), -crect.y());
874
                patchM.BL.transform(m_ctm);
875
                patchM.BL.moveRel(-crect.x(), -crect.y());
876
                ite->meshGradientPatches.append(patchM);
877
        }
878
        ite->GrType = 12;
879
        return gTrue;
880
}
881
 
882
GBool SlaOutputDev::tilingPatternFill(GfxState *state, Catalog *cat, Object *str, double *pmat, int paintType, Dict *resDict, double *mat, double *bbox, int x0, int y0, int x1, int y1, double xStep, double yStep)
883
{
884
        PDFRectangle box;
885
        Gfx *gfx;
886
        QString id;
887
        PageItem *ite;
888
        groupEntry gElements;
889
        gElements.forSoftMask = gFalse;
890
        gElements.alpha = gFalse;
16732 fschmid 891
        gElements.inverted = false;
16729 fschmid 892
        gElements.maskName = "";
893
        gElements.Items.clear();
894
        m_groupStack.push(gElements);
895
        double width, height;
896
        width = bbox[2] - bbox[0];
897
        height = bbox[3] - bbox[1];
898
        if (xStep != width || yStep != height)
899
                return gFalse;
900
        box.x1 = bbox[0];
901
        box.y1 = bbox[1];
902
        box.x2 = bbox[2];
903
        box.y2 = bbox[3];
904
        double *ctm;
905
        ctm = state->getCTM();
906
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
907
        QTransform mm = QTransform(mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
908
        QTransform mmx = mm * m_ctm;
17419 fschmid 909
#ifdef POPPLER_VERSION
910
        gfx = new Gfx(pdfDoc, this, resDict, &box, NULL);
911
#else
16729 fschmid 912
        gfx = new Gfx(xref, this, resDict, catalog, &box, NULL);
17419 fschmid 913
#endif
16729 fschmid 914
        gfx->display(str);
915
        gElements = m_groupStack.pop();
916
        tmpSel->clear();
917
        double pwidth = 0;
918
        double pheight = 0;
919
        if (gElements.Items.count() > 0)
920
        {
921
                for (int dre = 0; dre < gElements.Items.count(); ++dre)
922
                {
923
                        tmpSel->addItem(gElements.Items.at(dre), true);
924
                        m_Elements->removeAll(gElements.Items.at(dre));
925
                }
926
                ite = m_doc->groupObjectsSelection(tmpSel);
927
                ite->setFillTransparency(1.0 - state->getFillOpacity());
928
                ite->setFillBlendmode(getBlendMode(state));
929
                m_doc->m_Selection->addItem(ite, true);
930
                m_doc->itemSelection_FlipV();
931
                m_doc->m_Selection->clear();
932
                ScPattern pat = ScPattern();
933
                pat.setDoc(m_doc);
934
                m_doc->DoDrawing = true;
935
                pat.pattern = ite->DrawObj_toImage(qMax(ite->width(), ite->height()));
936
                pat.xoffset = 0;
937
                pat.yoffset = 0;
938
                m_doc->DoDrawing = false;
939
                pat.width = ite->width();
940
                pat.height = ite->height();
941
                pwidth = ite->width();
942
                pheight = ite->height();
17374 fschmid 943
                ite->gXpos = 0;
944
                ite->gYpos = 0;
945
                ite->setXYPos(ite->gXpos, ite->gYpos, true);
16729 fschmid 946
                pat.items.append(ite);
947
                m_doc->Items->removeAll(ite);
948
                id = QString("Pattern_from_PDF_%1").arg(m_doc->docPatterns.count() + 1);
949
                m_doc->addPattern(id, pat);
950
                tmpSel->clear();
951
        }
952
        double xCoor = m_doc->currentPage()->xOffset();
953
        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 954
        int shade = 100;
955
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 956
        double xmin, ymin, xmax, ymax;
957
        // get the clip region bbox
958
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
959
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
960
        crect = crect.normalized();
961
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
962
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
963
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
964
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
965
        output += QString("L %1 %2").arg(0.0).arg(0.0);
966
        output += QString("Z");
967
        pathIsClosed = true;
968
        Coords = output;
969
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
970
        ite = m_doc->Items->at(z);
971
        ite->ClipEdited = true;
972
        ite->FrameType = 3;
16746 fschmid 973
        ite->setFillShade(shade);
16729 fschmid 974
        ite->setLineShade(100);
975
        ite->setFillEvenOdd(false);
976
        ite->setFillTransparency(1.0 - state->getFillOpacity());
977
        ite->setFillBlendmode(getBlendMode(state));
978
        ite->setLineEnd(PLineEnd);
979
        ite->setLineJoin(PLineJoin);
980
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
981
        ite->GrType = 8;
982
        ite->setPattern(id);
983
        ite->setPatternTransform(fabs(pmat[0]) * 100, fabs(pmat[3]) * 100, mmx.dx() - ctm[4], mmx.dy() - ctm[5], 0, -1 * pmat[1], pmat[2]);
984
        m_doc->AdjustItemSize(ite);
985
        m_Elements->append(ite);
986
        if (m_groupStack.count() != 0)
987
        {
988
                m_groupStack.top().Items.append(ite);
16732 fschmid 989
                applyMask(ite);
16729 fschmid 990
        }
991
        delete gfx;
992
        return gTrue;
993
}
994
 
16751 fschmid 995
void SlaOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool interpolate, GBool inlineImg)
996
{
997
//      qDebug() << "Draw Image Mask";
998
        QImage * image = 0;
999
        int invert_bit;
1000
        int row_stride;
1001
        int x, y, i, bit;
1002
        unsigned char *dest = 0;
1003
        unsigned char *buffer;
1004
        Guchar *pix;
1005
        ImageStream * imgStr = new ImageStream(str, width, 1, 1);
1006
        imgStr->reset();
1007
#ifdef WORDS_BIGENDIAN
1008
        image = new QImage(width, height, QImage::Format_Mono);
1009
#else
1010
        image = new QImage(width, height, QImage::Format_MonoLSB);
1011
#endif
16764 fschmid 1012
        if (image == NULL || image->isNull())
1013
        {
1014
                delete imgStr;
1015
                delete image;
1016
                return;
1017
        }
16751 fschmid 1018
        invert_bit = invert ? 1 : 0;
1019
        buffer = image->bits();
1020
        row_stride = image->bytesPerLine();
1021
        for (y = 0; y < height; y++)
1022
        {
1023
                pix = imgStr->getLine();
1024
                dest = buffer + y * row_stride;
1025
                i = 0;
1026
                bit = 0;
1027
                for (x = 0; x < width; x++)
1028
                {
1029
                        if (bit == 0)
1030
                                dest[i] = 0;
1031
                        if (!(pix[x] ^ invert_bit))
1032
                        {
1033
#ifdef WORDS_BIGENDIAN
1034
                                dest[i] |= (1 << (7 - bit));
1035
#else
1036
                                dest[i] |= (1 << bit);
1037
#endif
1038
                        }
1039
                        bit++;
1040
                        if (bit > 7)
1041
                        {
1042
                                bit = 0;
1043
                                i++;
1044
                        }
1045
                }
1046
        }
16764 fschmid 1047
        int shade = 100;
1048
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
1049
        QColor backColor = ScColorEngine::getShadeColorProof(m_doc->PageColors[CurrColorFill], m_doc, shade);
1050
        QImage res = QImage(width, height, QImage::Format_ARGB32);
1051
        res.fill(backColor.rgb());
1052
        unsigned char cc, cm, cy, ck;
1053
        for( int yi = 0; yi < res.height(); ++yi )
1054
        {
1055
                QRgb *t = (QRgb*)(res.scanLine( yi ));
1056
                for(int xi = 0; xi < res.width(); ++xi )
1057
                {
1058
                        cc = qRed(*t);
1059
                        cm = qGreen(*t);
1060
                        cy = qBlue(*t);
1061
                        ck = image->pixel(xi, yi);
1062
                        if (ck == 0)
1063
                                (*t) = qRgba(cc, cm, cy, 0);
1064
                        else
1065
                                (*t) = qRgba(cc, cm, cy, 255);
1066
                        t++;
1067
                }
1068
        }
16751 fschmid 1069
        double *ctm;
1070
        ctm = state->getCTM();
1071
        double xCoor = m_doc->currentPage()->xOffset();
1072
        double yCoor = m_doc->currentPage()->yOffset();
1073
        QRectF crect = QRectF(0, 0, width, height);
1074
        m_ctm = QTransform(ctm[0] / width, ctm[1] / width, -ctm[2] / height, -ctm[3] / height, ctm[2] + ctm[4], ctm[3] + ctm[5]);
1075
        QLineF cline = QLineF(0, 0, width, 0);
1076
        QLineF tline = m_ctm.map(cline);
1077
        QRectF trect = m_ctm.mapRect(crect);
1078
        double sx = m_ctm.m11();
1079
        double sy = m_ctm.m22();
1080
        QTransform mm = QTransform(ctm[0] / width, ctm[1] / width, -ctm[2] / height, -ctm[3] / height, 0, 0);
1081
        if ((mm.type() == QTransform::TxShear) || (mm.type() == QTransform::TxRotate))
1082
        {
1083
                mm.reset();
1084
                mm.rotate(-tline.angle());
1085
        }
1086
        else
1087
        {
1088
                mm.reset();
1089
                if (sx < 0)
1090
                        mm.scale(-1, 1);
1091
                if (sy < 0)
1092
                        mm.scale(1, -1);
1093
        }
16764 fschmid 1094
        res = res.transformed(mm);
1095
        if (res.isNull())
1096
        {
1097
                delete imgStr;
1098
                delete image;
1099
                return;
1100
        }
16751 fschmid 1101
        int z = m_doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, xCoor + trect.x(), yCoor + trect.y(), trect.width(), trect.height(), 0, CommonStrings::None, CommonStrings::None, true);
1102
        PageItem* ite = m_doc->Items->at(z);
1103
        ite->SetRectFrame();
1104
        m_doc->setRedrawBounding(ite);
1105
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1106
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1107
        ite->setFillShade(100);
1108
        ite->setLineShade(100);
1109
        ite->setFillEvenOdd(false);
1110
        ite->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_pdf_XXXXXX.png");
16774 fschmid 1111
        if (ite->tempImageFile->open())
16764 fschmid 1112
        {
16774 fschmid 1113
                QString fileName = getLongPathName(ite->tempImageFile->fileName());
1114
                if (!fileName.isEmpty())
1115
                {
1116
                        ite->tempImageFile->close();
1117
                        ite->isInlineImage = true;
1118
                        res.save(fileName, "PNG");
16943 fschmid 1119
                        m_doc->loadPict(fileName, ite);
16774 fschmid 1120
                        ite->setImageScalingMode(false, true);
1121
                        m_doc->AdjustItemSize(ite);
1122
                        m_Elements->append(ite);
1123
                        if (m_groupStack.count() != 0)
1124
                        {
1125
                                m_groupStack.top().Items.append(ite);
1126
                                applyMask(ite);
1127
                        }
1128
                }
1129
                else
1130
                        m_doc->Items->removeAll(ite);
16764 fschmid 1131
        }
16774 fschmid 1132
        else
1133
                m_doc->Items->removeAll(ite);
16751 fschmid 1134
        imgStr->close();
1135
        delete imgStr;
1136
        delete image;
1137
}
1138
 
16729 fschmid 1139
void SlaOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, Stream *maskStr, int maskWidth, int maskHeight,
1140
                                   GfxImageColorMap *maskColorMap, GBool maskInterpolate)
1141
{
1142
        ImageStream * imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(), colorMap->getBits());
1143
        imgStr->reset();
1144
        unsigned int *dest = 0;
1145
        unsigned char * buffer = new unsigned char[width * height * 4];
1146
        QImage * image = 0;
1147
        for (int y = 0; y < height; y++)
1148
        {
1149
                dest = (unsigned int *)(buffer + y * 4 * width);
1150
                Guchar * pix = imgStr->getLine();
1151
                colorMap->getRGBLine(pix, dest, width);
1152
        }
1153
        image = new QImage(buffer, width, height, QImage::Format_RGB32);
1154
        if (image == NULL || image->isNull())
1155
        {
1156
                delete imgStr;
1157
                delete[] buffer;
1158
                delete image;
1159
                return;
1160
        }
1161
        ImageStream *mskStr = new ImageStream(maskStr, maskWidth, maskColorMap->getNumPixelComps(), maskColorMap->getBits());
1162
        mskStr->reset();
1163
        Guchar *mdest = 0;
1164
        unsigned char * mbuffer = new unsigned char[maskWidth * maskHeight];
1165
        for (int y = 0; y < maskHeight; y++)
1166
        {
1167
                mdest = (Guchar *)(mbuffer + y * maskWidth);
1168
                Guchar * pix = mskStr->getLine();
1169
                maskColorMap->getGrayLine(pix, mdest, maskWidth);
1170
        }
1171
        if ((maskWidth != width) || (maskHeight != height))
1172
        {
1173
                delete imgStr;
1174
                delete[] buffer;
1175
                delete image;
1176
                delete mskStr;
1177
                delete[] mbuffer;
1178
                return;
1179
        }
1180
        QImage res = image->convertToFormat(QImage::Format_ARGB32);
1181
        unsigned char cc, cm, cy, ck;
1182
        int s = 0;
1183
        for( int yi=0; yi < res.height(); ++yi )
1184
        {
1185
                QRgb *t = (QRgb*)(res.scanLine( yi ));
1186
                for(int xi=0; xi < res.width(); ++xi )
1187
                {
1188
                        cc = qRed(*t);
1189
                        cm = qGreen(*t);
1190
                        cy = qBlue(*t);
1191
                        ck = mbuffer[s];
1192
                        (*t) = qRgba(cc, cm, cy, ck);
1193
                        s++;
1194
                        t++;
1195
                }
1196
        }
16751 fschmid 1197
        double *ctm;
1198
        ctm = state->getCTM();
16729 fschmid 1199
        double xCoor = m_doc->currentPage()->xOffset();
1200
        double yCoor = m_doc->currentPage()->yOffset();
16751 fschmid 1201
        QRectF crect = QRectF(0, 0, width, height);
1202
        m_ctm = QTransform(ctm[0] / width, ctm[1] / width, -ctm[2] / height, -ctm[3] / height, ctm[2] + ctm[4], ctm[3] + ctm[5]);
1203
        QLineF cline = QLineF(0, 0, width, 0);
1204
        QLineF tline = m_ctm.map(cline);
1205
        QRectF trect = m_ctm.mapRect(crect);
1206
        double sx = m_ctm.m11();
1207
        double sy = m_ctm.m22();
1208
        QTransform mm = QTransform(ctm[0] / width, ctm[1] / width, -ctm[2] / height, -ctm[3] / height, 0, 0);
1209
        if ((mm.type() == QTransform::TxShear) || (mm.type() == QTransform::TxRotate))
1210
        {
1211
                mm.reset();
1212
                mm.rotate(-tline.angle());
1213
        }
16729 fschmid 1214
        else
16751 fschmid 1215
        {
1216
                mm.reset();
1217
                if (sx < 0)
1218
                        mm.scale(-1, 1);
1219
                if (sy < 0)
1220
                        mm.scale(1, -1);
1221
        }
16764 fschmid 1222
        res = res.transformed(mm);
16751 fschmid 1223
        int z = m_doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, xCoor + trect.x(), yCoor + trect.y(), trect.width(), trect.height(), 0, CommonStrings::None, CommonStrings::None, true);
16729 fschmid 1224
        PageItem* ite = m_doc->Items->at(z);
1225
        ite->SetRectFrame();
1226
        m_doc->setRedrawBounding(ite);
1227
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1228
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1229
        ite->setFillShade(100);
1230
        ite->setLineShade(100);
1231
        ite->setFillEvenOdd(false);
1232
        ite->setFillTransparency(1.0 - state->getFillOpacity());
1233
        ite->setFillBlendmode(getBlendMode(state));
1234
        ite->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_pdf_XXXXXX.png");
16774 fschmid 1235
        if (ite->tempImageFile->open())
16729 fschmid 1236
        {
16774 fschmid 1237
                QString fileName = getLongPathName(ite->tempImageFile->fileName());
1238
                if (!fileName.isEmpty())
1239
                {
1240
                        ite->tempImageFile->close();
1241
                        ite->isInlineImage = true;
1242
                        res.save(fileName, "PNG");
16943 fschmid 1243
                        m_doc->loadPict(fileName, ite);
16774 fschmid 1244
                        ite->setImageScalingMode(false, true);
1245
                        m_doc->AdjustItemSize(ite);
1246
                        m_Elements->append(ite);
1247
                        if (m_groupStack.count() != 0)
1248
                        {
1249
                                m_groupStack.top().Items.append(ite);
1250
                                applyMask(ite);
1251
                        }
1252
                }
1253
                else
1254
                        m_doc->Items->removeAll(ite);
16729 fschmid 1255
        }
16774 fschmid 1256
        else
1257
                m_doc->Items->removeAll(ite);
16729 fschmid 1258
        delete imgStr;
1259
        delete[] buffer;
1260
        delete image;
1261
        delete mskStr;
1262
        delete[] mbuffer;
1263
}
1264
 
1265
void SlaOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, int *maskColors, GBool inlineImg)
1266
{
1267
        ImageStream * imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(), colorMap->getBits());
1268
        imgStr->reset();
1269
        unsigned int *dest = 0;
1270
        unsigned char * buffer = new unsigned char[width * height * 4];
1271
        QImage * image = 0;
1272
        if (maskColors)
1273
        {
1274
                for (int y = 0; y < height; y++)
1275
                {
1276
                        dest = (unsigned int *)(buffer + y * 4 * width);
1277
                        Guchar * pix = imgStr->getLine();
1278
                        colorMap->getRGBLine(pix, dest, width);
1279
                        for (int x = 0; x < width; x++)
1280
                        {
1281
                                for (int i = 0; i < colorMap->getNumPixelComps(); ++i)
1282
                                {
1283
                                        if (pix[i] < maskColors[2*i] * 255 || pix[i] > maskColors[2*i+1] * 255)
1284
                                        {
1285
                                                *dest = *dest | 0xff000000;
1286
                                                break;
1287
                                        }
1288
                                }
1289
                                pix += colorMap->getNumPixelComps();
1290
                                dest++;
1291
                        }
1292
                }
1293
                image = new QImage(buffer, width, height, QImage::Format_ARGB32);
1294
        }
1295
        else
1296
        {
1297
                for (int y = 0; y < height; y++)
1298
                {
1299
                        dest = (unsigned int *)(buffer + y * 4 * width);
1300
                        Guchar * pix = imgStr->getLine();
1301
                        colorMap->getRGBLine(pix, dest, width);
1302
                }
1303
                image = new QImage(buffer, width, height, QImage::Format_RGB32);
1304
        }
1305
        if (image == NULL || image->isNull())
1306
        {
1307
                delete imgStr;
1308
                delete[] buffer;
1309
                delete image;
1310
                return;
1311
        }
16751 fschmid 1312
        double *ctm;
1313
        ctm = state->getCTM();
16729 fschmid 1314
        double xCoor = m_doc->currentPage()->xOffset();
1315
        double yCoor = m_doc->currentPage()->yOffset();
16751 fschmid 1316
        QRectF crect = QRectF(0, 0, width, height);
1317
        m_ctm = QTransform(ctm[0] / width, ctm[1] / width, -ctm[2] / height, -ctm[3] / height, ctm[2] + ctm[4], ctm[3] + ctm[5]);
1318
        QLineF cline = QLineF(0, 0, width, 0);
1319
        QLineF tline = m_ctm.map(cline);
1320
        QRectF trect = m_ctm.mapRect(crect);
1321
        double sx = m_ctm.m11();
1322
        double sy = m_ctm.m22();
1323
        QTransform mm = QTransform(ctm[0] / width, ctm[1] / width, -ctm[2] / height, -ctm[3] / height, 0, 0);
1324
        if ((mm.type() == QTransform::TxShear) || (mm.type() == QTransform::TxRotate))
1325
        {
1326
                mm.reset();
1327
                mm.rotate(-tline.angle());
1328
        }
16729 fschmid 1329
        else
16751 fschmid 1330
        {
1331
                mm.reset();
1332
                if (sx < 0)
1333
                        mm.scale(-1, 1);
1334
                if (sy < 0)
1335
                        mm.scale(1, -1);
1336
        }
1337
        QImage img = image->transformed(mm);
1338
        int z = m_doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, xCoor + trect.x(), yCoor + trect.y(), trect.width(), trect.height(), 0, CommonStrings::None, CommonStrings::None, true);
16729 fschmid 1339
        PageItem* ite = m_doc->Items->at(z);
1340
        ite->SetRectFrame();
1341
        m_doc->setRedrawBounding(ite);
1342
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1343
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1344
        ite->setFillShade(100);
1345
        ite->setLineShade(100);
1346
        ite->setFillEvenOdd(false);
1347
        ite->setFillTransparency(1.0 - state->getFillOpacity());
1348
        ite->setFillBlendmode(getBlendMode(state));
1349
        ite->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_pdf_XXXXXX.png");
16774 fschmid 1350
        if (ite->tempImageFile->open())
16729 fschmid 1351
        {
16774 fschmid 1352
                QString fileName = getLongPathName(ite->tempImageFile->fileName());
1353
                if (!fileName.isEmpty())
1354
                {
1355
                        ite->tempImageFile->close();
1356
                        ite->isInlineImage = true;
1357
                        img.save(fileName, "PNG");
16943 fschmid 1358
                        m_doc->loadPict(fileName, ite);
16774 fschmid 1359
                        ite->setImageScalingMode(false, true);
1360
                        m_doc->AdjustItemSize(ite);
1361
                        m_Elements->append(ite);
1362
                        if (m_groupStack.count() != 0)
1363
                        {
1364
                                m_groupStack.top().Items.append(ite);
1365
                                applyMask(ite);
1366
                        }
1367
                }
1368
                else
1369
                        m_doc->Items->removeAll(ite);
16729 fschmid 1370
        }
16774 fschmid 1371
        else
1372
                m_doc->Items->removeAll(ite);
16729 fschmid 1373
        delete imgStr;
1374
        delete[] buffer;
1375
        delete image;
1376
}
1377
 
1378
void SlaOutputDev::beginMarkedContent(char *name, Dict *properties)
1379
{
1380
//      qDebug() << "Begin Marked Content with Name " << QString(name);
1381
        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1382
        {
1383
                if (QString(name) == "Layer")           // Handle Adobe Illustrator Layer command
1384
                {
17448 fschmid 1385
                        if (layersSetByOCG)
1386
                                return;
16729 fschmid 1387
                        Object obj;
17439 fschmid 1388
                        QString lName = QString("Layer_%1").arg(layerNum + 1);
16729 fschmid 1389
                        if (properties->lookup((char*)"Title", &obj))
1390
                        {
1391
                                if (obj.isString())
17439 fschmid 1392
                                        lName =  QString(obj.getString()->getCString());
1393
                                obj.free();
1394
                        }
1395
                        for (ScLayers::iterator it = m_doc->Layers.begin(); it != m_doc->Layers.end(); ++it)
1396
                        {
1397
                                if (it->Name == lName)
16729 fschmid 1398
                                {
17439 fschmid 1399
                                        m_doc->setActiveLayer(lName);
1400
                                        return;
16729 fschmid 1401
                                }
1402
                        }
17439 fschmid 1403
                        layerNum++;
1404
                        if (!firstLayer)
1405
                                currentLayer = m_doc->addLayer(lName, true);
1406
                        firstLayer = false;
16729 fschmid 1407
                        if (properties->lookup((char*)"Visible", &obj))
1408
                        {
1409
                                if (obj.isBool())
1410
                                        m_doc->setLayerVisible(currentLayer, obj.getBool());
1411
                                obj.free();
1412
                        }
1413
                        if (properties->lookup((char*)"Editable", &obj))
1414
                        {
1415
                                if (obj.isBool())
1416
                                        m_doc->setLayerLocked(currentLayer, !obj.getBool());
1417
                                obj.free();
1418
                        }
1419
                        if (properties->lookup((char*)"Printed", &obj))
1420
                        {
1421
                                if (obj.isBool())
1422
                                        m_doc->setLayerPrintable(currentLayer, obj.getBool());
1423
                                obj.free();
1424
                        }
1425
                        if (properties->lookup((char*)"Color", &obj))
1426
                        {
1427
                                if (obj.isArray())
1428
                                {
1429
                                        Object obj1;
1430
                                        obj.arrayGet(0, &obj1);
1431
                                        int r = obj1.getNum() / 256;
1432
                                        obj1.free();
1433
                                        obj.arrayGet(1, &obj1);
1434
                                        int g = obj1.getNum() / 256;
1435
                                        obj1.free();
1436
                                        obj.arrayGet(2, &obj1);
1437
                                        int b = obj1.getNum() / 256;
1438
                                        obj1.free();
1439
                                        m_doc->setLayerMarker(currentLayer, QColor(r, g, b));
1440
                                }
1441
                                obj.free();
1442
                        }
1443
                }
1444
        }
1445
}
1446
 
1447
void SlaOutputDev::endMarkedContent(GfxState *state)
1448
{
1449
//      qDebug() << "End Marked Content";
1450
}
1451
 
17439 fschmid 1452
void SlaOutputDev::markPoint(char *name)
1453
{
1454
//      qDebug() << "Begin Marked Point with Name " << QString(name);
1455
}
1456
 
1457
void SlaOutputDev::markPoint(char *name, Dict *properties)
1458
{
1459
//      qDebug() << "Begin Marked Point with Name " << QString(name) << "and Properties";
1460
        beginMarkedContent(name, properties);
1461
}
1462
 
17419 fschmid 1463
// POPPLER_VERSION appeared in 0.19.0 first
1464
#ifdef POPPLER_VERSION
16729 fschmid 1465
void SlaOutputDev::updateFont(GfxState *state)
1466
{
17419 fschmid 1467
  GfxFont *gfxFont;
1468
  GfxFontLoc *fontLoc;
1469
  GfxFontType fontType;
1470
  SplashOutFontFileID *id;
1471
  SplashFontFile *fontFile;
1472
  SplashFontSrc *fontsrc = NULL;
1473
  FoFiTrueType *ff;
1474
  Object refObj, strObj;
1475
  GooString *fileName;
1476
  char *tmpBuf;
1477
  int tmpBufLen;
1478
  int *codeToGID;
1479
  double *textMat;
1480
  double m11, m12, m21, m22, fontSize;
1481
  SplashCoord mat[4];
1482
  int n;
1483
  int faceIndex = 0;
1484
  SplashCoord matrix[6];
1485
 
1486
  m_font = NULL;
1487
  fileName = NULL;
1488
  tmpBuf = NULL;
1489
  fontLoc = NULL;
1490
 
1491
  if (!(gfxFont = state->getFont())) {
1492
        goto err1;
1493
  }
1494
  fontType = gfxFont->getType();
1495
  if (fontType == fontType3) {
1496
        goto err1;
1497
  }
1498
 
1499
  // check the font file cache
1500
  id = new SplashOutFontFileID(gfxFont->getID());
1501
  if ((fontFile = m_fontEngine->getFontFile(id))) {
1502
        delete id;
1503
 
1504
  } else {
1505
 
1506
        if (!(fontLoc = gfxFont->locateFont(xref, gFalse))) {
1507
          error(errSyntaxError, -1, "Couldn't find a font for '{0:s}'",
1508
                gfxFont->getName() ? gfxFont->getName()->getCString()
1509
                                                   : "(unnamed)");
1510
          goto err2;
1511
        }
1512
 
1513
        // embedded font
1514
        if (fontLoc->locType == gfxFontLocEmbedded) {
1515
          // if there is an embedded font, read it to memory
1516
          tmpBuf = gfxFont->readEmbFontFile(xref, &tmpBufLen);
1517
          if (! tmpBuf)
1518
        goto err2;
1519
 
1520
        // external font
1521
        } else { // gfxFontLocExternal
1522
          fileName = fontLoc->path;
1523
          fontType = fontLoc->fontType;
1524
        }
1525
 
1526
        fontsrc = new SplashFontSrc;
1527
        if (fileName)
1528
          fontsrc->setFile(fileName, gFalse);
1529
        else
1530
          fontsrc->setBuf(tmpBuf, tmpBufLen, gTrue);
1531
 
1532
        // load the font file
1533
        switch (fontType) {
1534
        case fontType1:
1535
          if (!(fontFile = m_fontEngine->loadType1Font(
1536
                           id,
1537
                           fontsrc,
1538
                           (const char **)((Gfx8BitFont *)gfxFont)->getEncoding()))) {
1539
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1540
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1541
                                                         : "(unnamed)");
1542
        goto err2;
1543
          }
1544
          break;
1545
        case fontType1C:
1546
          if (!(fontFile = m_fontEngine->loadType1CFont(
1547
                           id,
1548
                           fontsrc,
1549
                           (const char **)((Gfx8BitFont *)gfxFont)->getEncoding()))) {
1550
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1551
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1552
                                                         : "(unnamed)");
1553
        goto err2;
1554
          }
1555
          break;
1556
        case fontType1COT:
1557
          if (!(fontFile = m_fontEngine->loadOpenTypeT1CFont(
1558
                           id,
1559
                           fontsrc,
1560
                           (const char **)((Gfx8BitFont *)gfxFont)->getEncoding()))) {
1561
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1562
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1563
                                                         : "(unnamed)");
1564
        goto err2;
1565
          }
1566
          break;
1567
        case fontTrueType:
1568
        case fontTrueTypeOT:
1569
        if (fileName)
1570
         ff = FoFiTrueType::load(fileName->getCString());
1571
        else
1572
        ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
1573
          if (ff) {
1574
        codeToGID = ((Gfx8BitFont *)gfxFont)->getCodeToGIDMap(ff);
1575
        n = 256;
1576
        delete ff;
1577
          } else {
1578
        codeToGID = NULL;
1579
        n = 0;
1580
          }
1581
          if (!(fontFile = m_fontEngine->loadTrueTypeFont(
1582
                           id,
1583
                           fontsrc,
1584
                           codeToGID, n))) {
1585
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1586
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1587
                                                         : "(unnamed)");
1588
        goto err2;
1589
          }
1590
          break;
1591
        case fontCIDType0:
1592
        case fontCIDType0C:
1593
          if (!(fontFile = m_fontEngine->loadCIDFont(
1594
                           id,
1595
                           fontsrc))) {
1596
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1597
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1598
                                                         : "(unnamed)");
1599
        goto err2;
1600
          }
1601
          break;
1602
        case fontCIDType0COT:
1603
          if (((GfxCIDFont *)gfxFont)->getCIDToGID()) {
1604
        n = ((GfxCIDFont *)gfxFont)->getCIDToGIDLen();
1605
        codeToGID = (int *)gmallocn(n, sizeof(int));
1606
        memcpy(codeToGID, ((GfxCIDFont *)gfxFont)->getCIDToGID(),
1607
                   n * sizeof(int));
1608
          } else {
1609
        codeToGID = NULL;
1610
        n = 0;
1611
          }
1612
          if (!(fontFile = m_fontEngine->loadOpenTypeCFFFont(
1613
                           id,
1614
                           fontsrc,
1615
                           codeToGID, n))) {
1616
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1617
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1618
                                                         : "(unnamed)");
1619
        goto err2;
1620
          }
1621
          break;
1622
        case fontCIDType2:
1623
        case fontCIDType2OT:
1624
          codeToGID = NULL;
1625
          n = 0;
1626
          if (((GfxCIDFont *)gfxFont)->getCIDToGID()) {
1627
        n = ((GfxCIDFont *)gfxFont)->getCIDToGIDLen();
1628
        if (n) {
1629
          codeToGID = (int *)gmallocn(n, sizeof(int));
1630
          memcpy(codeToGID, ((GfxCIDFont *)gfxFont)->getCIDToGID(),
1631
                  n * sizeof(Gushort));
1632
        }
1633
          } else {
1634
        if (fileName)
1635
          ff = FoFiTrueType::load(fileName->getCString());
1636
        else
1637
          ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
1638
        if (! ff)
1639
          goto err2;
1640
        codeToGID = ((GfxCIDFont *)gfxFont)->getCodeToGIDMap(ff, &n);
1641
        delete ff;
1642
          }
1643
          if (!(fontFile = m_fontEngine->loadTrueTypeFont(
1644
                           id,
1645
                           fontsrc,
1646
                           codeToGID, n, faceIndex))) {
1647
        error(errSyntaxError, -1, "Couldn't create a font for '{0:s}'",
1648
                  gfxFont->getName() ? gfxFont->getName()->getCString()
1649
                                                         : "(unnamed)");
1650
        goto err2;
1651
          }
1652
          break;
1653
        default:
1654
          // this shouldn't happen
1655
          goto err2;
1656
        }
1657
  }
1658
 
1659
  // get the font matrix
1660
  textMat = state->getTextMat();
1661
  fontSize = state->getFontSize();
1662
  m11 = textMat[0] * fontSize * state->getHorizScaling();
1663
  m12 = textMat[1] * fontSize * state->getHorizScaling();
1664
  m21 = textMat[2] * fontSize;
1665
  m22 = textMat[3] * fontSize;
1666
  matrix[0] = 1;
1667
  matrix[1] = 0;
1668
  matrix[2] = 0;
1669
  matrix[3] = 1;
1670
  matrix[4] = 0;
1671
  matrix[5] = 0;
1672
// create the scaled font
1673
  mat[0] = m11;
1674
  mat[1] = -m12;
1675
  mat[2] = m21;
1676
  mat[3] = -m22;
1677
  m_font = m_fontEngine->getFont(fontFile, mat, matrix);
1678
 
1679
  delete fontLoc;
1680
  if (fontsrc && !fontsrc->isFile)
1681
          fontsrc->unref();
1682
  return;
1683
 
1684
 err2:
1685
  delete id;
1686
  delete fontLoc;
1687
 err1:
1688
  if (fontsrc && !fontsrc->isFile)
1689
          fontsrc->unref();
1690
  return;
1691
}
1692
#else
1693
void SlaOutputDev::updateFont(GfxState *state)
1694
{
16729 fschmid 1695
        GfxFont *gfxFont;
1696
        GfxFontType fontType;
1697
        SplashOutFontFileID *id;
1698
        SplashFontFile *fontFile;
1699
        SplashFontSrc *fontsrc = NULL;
1700
        FoFiTrueType *ff;
1701
        Ref embRef;
1702
        Object refObj, strObj;
1703
        GooString *fileName;
1704
        char *tmpBuf;
1705
        int tmpBufLen;
1706
        Gushort *codeToGID;
1707
        DisplayFontParam *dfp;
1708
        double *textMat;
1709
        double m11, m12, m21, m22, fontSize;
1710
        SplashCoord mat[4];
1711
        int n;
1712
        int faceIndex = 0;
1713
        SplashCoord matrix[6];
1714
 
1715
        m_font = NULL;
1716
        fileName = NULL;
1717
        tmpBuf = NULL;
1718
 
1719
        if (!(gfxFont = state->getFont()))
1720
                goto err1;
1721
        fontType = gfxFont->getType();
1722
        if (fontType == fontType3)
1723
                goto err1;
1724
 
1725
  // check the font file cache
1726
        id = new SplashOutFontFileID(gfxFont->getID());
1727
        if ((fontFile = m_fontEngine->getFontFile(id)))
1728
        {
1729
                delete id;
1730
        }
1731
        else
1732
        {
1733
                // if there is an embedded font, write it to disk
1734
                if (gfxFont->getEmbeddedFontID(&embRef))
1735
                {
1736
                        tmpBuf = gfxFont->readEmbFontFile(xref, &tmpBufLen);
1737
                        if (!tmpBuf)
1738
                                goto err2;
1739
                // if there is an external font file, use it
1740
                }
1741
                else if (!(fileName = gfxFont->getExtFontFile()))
1742
                {
1743
          // look for a display font mapping or a substitute font
1744
                        dfp = NULL;
1745
                        if (gfxFont->getName())
1746
                        {
1747
                                dfp = globalParams->getDisplayFont(gfxFont);
1748
                        }
1749
                        if (!dfp)
1750
                        {
1751
                //              error(-1, "Couldn't find a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1752
                                goto err2;
1753
                        }
1754
                        switch (dfp->kind)
1755
                        {
1756
                                case displayFontT1:
1757
                                        fileName = dfp->t1.fileName;
1758
                                        fontType = gfxFont->isCIDFont() ? fontCIDType0 : fontType1;
1759
                                        break;
1760
                                case displayFontTT:
1761
                                        fileName = dfp->tt.fileName;
1762
                                        fontType = gfxFont->isCIDFont() ? fontCIDType2 : fontTrueType;
1763
                                        faceIndex = dfp->tt.faceIndex;
1764
                                        break;
1765
                        }
1766
                }
1767
                fontsrc = new SplashFontSrc;
1768
                if (fileName)
1769
                        fontsrc->setFile(fileName, gFalse);
1770
                else
1771
                        fontsrc->setBuf(tmpBuf, tmpBufLen, gTrue);
1772
        // load the font file
1773
                switch (fontType)
1774
                {
1775
                        case fontType1:
1776
                                if (!(fontFile = m_fontEngine->loadType1Font( id, fontsrc, ((Gfx8BitFont *)gfxFont)->getEncoding())))
1777
                                {
1778
                        //              error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1779
                                        goto err2;
1780
                                }
1781
                                break;
1782
                        case fontType1C:
1783
                                if (!(fontFile = m_fontEngine->loadType1CFont( id, fontsrc, ((Gfx8BitFont *)gfxFont)->getEncoding())))
1784
                                {
1785
                //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1786
                                        goto err2;
1787
                                }
1788
                                break;
1789
                        case fontType1COT:
1790
                                if (!(fontFile = m_fontEngine->loadOpenTypeT1CFont( id, fontsrc, ((Gfx8BitFont *)gfxFont)->getEncoding())))
1791
                                {
1792
                //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1793
                                        goto err2;
1794
                                }
1795
                                break;
1796
                        case fontTrueType:
1797
                        case fontTrueTypeOT:
1798
                                if (fileName)
1799
                                        ff = FoFiTrueType::load(fileName->getCString());
1800
                                else
1801
                                        ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
1802
                                if (ff)
1803
                                {
1804
                                        codeToGID = ((Gfx8BitFont *)gfxFont)->getCodeToGIDMap(ff);
1805
                                        n = 256;
1806
                                        delete ff;
1807
                                }
1808
                                else
1809
                                {
1810
                                        codeToGID = NULL;
1811
                                        n = 0;
1812
                                }
1813
                                if (!(fontFile = m_fontEngine->loadTrueTypeFont( id, fontsrc, codeToGID, n)))
1814
                                {
1815
        //                              error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1816
                                        goto err2;
1817
                                }
1818
                        break;
1819
                case fontCIDType0:
1820
                case fontCIDType0C:
1821
                        if (!(fontFile = m_fontEngine->loadCIDFont( id, fontsrc)))
1822
                        {
1823
        //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1824
                                goto err2;
1825
                        }
1826
                        break;
1827
                case fontCIDType0COT:
1828
                        if (!(fontFile = m_fontEngine->loadOpenTypeCFFFont( id, fontsrc)))
1829
                        {
1830
        //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1831
                                goto err2;
1832
                        }
1833
                        break;
1834
                case fontCIDType2:
1835
                case fontCIDType2OT:
1836
                        codeToGID = NULL;
1837
                        n = 0;
1838
                        if (((GfxCIDFont *)gfxFont)->getCIDToGID())
1839
                        {
1840
                                n = ((GfxCIDFont *)gfxFont)->getCIDToGIDLen();
1841
                                if (n)
1842
                                {
1843
                                        codeToGID = (Gushort *)gmallocn(n, sizeof(Gushort));
1844
                                        memcpy(codeToGID, ((GfxCIDFont *)gfxFont)->getCIDToGID(), n * sizeof(Gushort));
1845
                                }
1846
                        }
1847
                        else
1848
                        {
1849
                                if (fileName)
1850
                                        ff = FoFiTrueType::load(fileName->getCString());
1851
                                else
1852
                                        ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
1853
                                if (!ff)
1854
                                        goto err2;
1855
                                codeToGID = ((GfxCIDFont *)gfxFont)->getCodeToGIDMap(ff, &n);
1856
                                delete ff;
1857
                        }
1858
                        if (!(fontFile = m_fontEngine->loadTrueTypeFont( id, fontsrc, codeToGID, n, faceIndex)))
1859
                        {
1860
        //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1861
                                goto err2;
1862
                        }
1863
                        break;
1864
                default:
1865
          // this shouldn't happen
1866
                        goto err2;
1867
                }
1868
        }
1869
        // get the font matrix
1870
        textMat = state->getTextMat();
1871
        fontSize = state->getFontSize();
1872
        m11 = textMat[0] * fontSize * state->getHorizScaling();
1873
        m12 = textMat[1] * fontSize * state->getHorizScaling();
1874
        m21 = textMat[2] * fontSize;
1875
        m22 = textMat[3] * fontSize;
1876
        matrix[0] = 1;
1877
        matrix[1] = 0;
1878
        matrix[2] = 0;
1879
        matrix[3] = 1;
1880
        matrix[4] = 0;
1881
        matrix[5] = 0;
1882
  // create the scaled font
1883
        mat[0] = m11;
1884
        mat[1] = -m12;
1885
        mat[2] = m21;
1886
        mat[3] = -m22;
1887
        m_font = m_fontEngine->getFont(fontFile, mat, matrix);
1888
        if (fontsrc && !fontsrc->isFile)
1889
                fontsrc->unref();
1890
        return;
1891
 
1892
err2:
1893
        delete id;
1894
err1:
1895
        if (fontsrc && !fontsrc->isFile)
1896
                fontsrc->unref();
1897
        return;
1898
}
17419 fschmid 1899
#endif
16729 fschmid 1900
 
1901
void SlaOutputDev::drawChar(GfxState *state, double x, double y, double dx, double dy, double originX, double originY, CharCode code, int nBytes, Unicode *u, int uLen)
1902
{
1903
        double x1, y1, x2, y2;
1904
        int render;
1905
        updateFont(state);
1906
        if (!m_font)
1907
                return;
1908
  // check for invisible text -- this is used by Acrobat Capture
1909
        render = state->getRender();
1910
        if (render == 3)
1911
                return;
1912
        if (!(render & 1))
1913
        {
1914
                SplashPath * fontPath;
1915
                fontPath = m_font->getGlyphPath(code);
1916
                if (fontPath)
1917
                {
1918
                        QPainterPath qPath;
1919
                        qPath.setFillRule(Qt::WindingFill);
1920
                        for (int i = 0; i < fontPath->getLength(); ++i)
1921
                        {
1922
                                Guchar f;
1923
                                fontPath->getPoint(i, &x1, &y1, &f);
1924
                                if (f & splashPathFirst)
1925
                                        qPath.moveTo(x1,y1);
1926
                                else if (f & splashPathCurve)
1927
                                {
1928
                                        double x3, y3;
1929
                                        ++i;
1930
                                        fontPath->getPoint(i, &x2, &y2, &f);
1931
                                        ++i;
1932
                                        fontPath->getPoint(i, &x3, &y3, &f);
1933
                                        qPath.cubicTo(x1,y1,x2,y2,x3,y3);
1934
                                }
1935
                                else
1936
                                        qPath.lineTo(x1,y1);
1937
                                if (f & splashPathLast)
1938
                                        qPath.closeSubpath();
1939
                        }
1940
                        double *ctm;
1941
                        ctm = state->getCTM();
1942
                        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1943
                        double xCoor = m_doc->currentPage()->xOffset();
1944
                        double yCoor = m_doc->currentPage()->yOffset();
16746 fschmid 1945
                        int shade = 100;
1946
                        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16729 fschmid 1947
                        FPointArray textPath;
1948
                        textPath.fromQPainterPath(qPath);
1949
                        FPoint wh = textPath.WidthHeight();
1950
                        if ((textPath.size() > 3) && ((wh.x() != 0.0) || (wh.y() != 0.0)))
1951
                        {
1952
                                int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, CurrColorFill, CommonStrings::None, true);
1953
                                PageItem* ite = m_doc->Items->at(z);
1954
                                FPoint tp2(getMinClipF(&textPath));
1955
                                QTransform mm;
1956
                                mm.scale(1, -1);
1957
                                mm.translate(x, -y);
1958
                                textPath.map(mm);
1959
                                textPath.map(m_ctm);
1960
                                ite->PoLine = textPath.copy();
1961
                                ite->ClipEdited = true;
1962
                                ite->FrameType = 3;
16746 fschmid 1963
                                ite->setFillShade(shade);
16729 fschmid 1964
                                ite->setFillEvenOdd(false);
1965
                                ite->setFillTransparency(1.0 - state->getFillOpacity());
1966
                                ite->setFillBlendmode(getBlendMode(state));
1967
                                ite->setLineEnd(PLineEnd);
1968
                                ite->setLineJoin(PLineJoin);
1969
                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
1970
                                m_doc->AdjustItemSize(ite);
1971
                                if ((render & 3) == 1 || (render & 3) == 2)
1972
                                {
16746 fschmid 1973
                                        CurrColorStroke = getColor(state->getStrokeColorSpace(), state->getStrokeColor(), &shade);
16729 fschmid 1974
                                        ite->setLineColor(CurrColorStroke);
1975
                                        ite->setLineWidth(state->getTransformedLineWidth());
1976
                                        ite->setLineTransparency(1.0 - state->getStrokeOpacity());
1977
                                        ite->setLineBlendmode(getBlendMode(state));
16746 fschmid 1978
                                        ite->setLineShade(shade);
16729 fschmid 1979
                                }
1980
                                m_Elements->append(ite);
1981
                                if (m_groupStack.count() != 0)
1982
                                {
1983
                                        m_groupStack.top().Items.append(ite);
16732 fschmid 1984
                                        applyMask(ite);
16729 fschmid 1985
                                }
1986
                                delete fontPath;
1987
                        }
1988
                }
1989
        }
1990
}
1991
 
16766 fschmid 1992
GBool SlaOutputDev::beginType3Char(GfxState *state, double x, double y, double dx, double dy, CharCode code, Unicode *u, int uLen)
1993
{
16767 fschmid 1994
//      qDebug() << "beginType3Char";
16766 fschmid 1995
        double *ctm;
1996
        ctm = state->getCTM();
1997
        QTransform orig_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1998
        GfxFont *gfxFont;
1999
        GfxFontType fontType;
2000
        if (!(gfxFont = state->getFont()))
2001
                return gTrue;
2002
        fontType = gfxFont->getType();
2003
        if (fontType != fontType3)
2004
                return gTrue;
2005
        Ref* fref = gfxFont->getID();
2006
        QString fRefID = QString("Font_%1_%2").arg(fref->num).arg(code);
2007
        if (m_Font_Pattern_Map.contains(fRefID))
2008
        {
2009
                QLineF cline = QLineF(0, 0, 1, 0);
2010
                QLineF tline = orig_ctm.map(cline);
2011
                double xCoor = m_doc->currentPage()->xOffset();
2012
                double yCoor = m_doc->currentPage()->yOffset();
16767 fschmid 2013
                ScPattern pat = m_doc->docPatterns[m_Font_Pattern_Map[fRefID].pattern];
16766 fschmid 2014
                QTransform mm;
2015
                mm.translate(0, -pat.height * tline.length());
2016
                mm = orig_ctm * mm;
2017
                int shade = 100;
2018
                CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
16767 fschmid 2019
                int z = 0;
2020
                if (m_Font_Pattern_Map[fRefID].colored)
2021
                        z = m_doc->itemAdd(PageItem::Symbol, PageItem::Unspecified, xCoor + mm.dx(), yCoor + mm.dy(), pat.width * tline.length(), pat.height * tline.length(), 0, CommonStrings::None, CommonStrings::None, true);
2022
                else
2023
                        z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + mm.dx(), yCoor + mm.dy(), pat.width * tline.length(), pat.height * tline.length(), 0, CurrColorFill, CommonStrings::None, true);
16766 fschmid 2024
                PageItem *b = m_doc->Items->at(z);
2025
                b->setWidth(pat.width * tline.length());
2026
                b->setHeight(pat.height * tline.length());
2027
                b->OldB2 = b->width();
2028
                b->OldH2 = b->height();
2029
                m_doc->RotMode(3);
2030
                m_doc->RotateItem(-tline.angle(), b);
2031
                m_doc->RotMode(0);
2032
                b->setFillShade(shade);
2033
                b->setFillEvenOdd(false);
2034
                b->setFillTransparency(1.0 - state->getFillOpacity());
2035
                b->setFillBlendmode(getBlendMode(state));
2036
                b->setLineEnd(PLineEnd);
2037
                b->setLineJoin(PLineJoin);
2038
                b->setTextFlowMode(PageItem::TextFlowDisabled);
16767 fschmid 2039
                if (m_Font_Pattern_Map[fRefID].colored)
2040
                        b->setPattern(m_Font_Pattern_Map[fRefID].pattern);
2041
                else
2042
                {
2043
                        b->setFillShade(shade);
2044
                        b->setPatternMask(m_Font_Pattern_Map[fRefID].pattern);
2045
                        b->setMaskTransform(b->width() / pat.width * 100, b->height() / pat.height * 100, 0, 0, 0, 0, 0);
2046
                        b->setMaskType(3);
2047
                }
16766 fschmid 2048
                m_Elements->append(b);
2049
                if (m_groupStack.count() != 0)
2050
                {
2051
                        m_groupStack.top().Items.append(b);
2052
                }
2053
                return gTrue;
2054
        }
2055
        else
2056
        {
2057
                F3Entry f3e;
2058
                f3e.ctm = orig_ctm;
2059
                f3e.glyphRef = fRefID;
16767 fschmid 2060
                f3e.colored = false;
16766 fschmid 2061
                m_F3Stack.push(f3e);
2062
                ctm = state->getTextMat();
2063
                state->setCTM(ctm[0], ctm[1], ctm[2], ctm[3], 0, 0);
2064
                pushGroup();
2065
                return gFalse;
2066
        }
2067
}
2068
 
2069
void SlaOutputDev::endType3Char(GfxState *state)
2070
{
16767 fschmid 2071
//      qDebug() << "endType3Char";
16766 fschmid 2072
        double *ctm;
2073
        ctm = state->getCTM();
2074
        groupEntry gElements = m_groupStack.pop();
2075
        tmpSel->clear();
2076
        if (gElements.Items.count() > 0)
2077
        {
2078
                for (int dre = 0; dre < gElements.Items.count(); ++dre)
2079
                {
2080
                        tmpSel->addItem(gElements.Items.at(dre), true);
2081
                        m_Elements->removeAll(gElements.Items.at(dre));
2082
                }
2083
                PageItem *ite = m_doc->groupObjectsSelection(tmpSel);
2084
                ite->setFillTransparency(1.0 - state->getFillOpacity());
2085
                ite->setFillBlendmode(getBlendMode(state));
2086
                m_doc->m_Selection->addItem(ite, true);
2087
                m_doc->itemSelection_FlipV();
2088
                m_doc->m_Selection->clear();
2089
                ScPattern pat = ScPattern();
2090
                pat.setDoc(m_doc);
2091
                m_doc->DoDrawing = true;
2092
                pat.pattern = ite->DrawObj_toImage(qMax(ite->width(), ite->height()));
2093
                pat.xoffset = 0;
2094
                pat.yoffset = 0;
2095
                m_doc->DoDrawing = false;
2096
                pat.width = ite->width();
2097
                pat.height = ite->height();
17374 fschmid 2098
                ite->gXpos = 0;
2099
                ite->gYpos = 0;
2100
                ite->setXYPos(ite->gXpos, ite->gYpos, true);
16766 fschmid 2101
                pat.items.append(ite);
2102
                m_doc->Items->removeAll(ite);
2103
                QString id = QString("Pattern_from_PDF_%1T").arg(m_doc->docPatterns.count() + 1);
2104
                m_doc->addPattern(id, pat);
2105
                tmpSel->clear();
2106
                if (m_F3Stack.count() > 0)
2107
                {
2108
                        F3Entry f3e = m_F3Stack.pop();
2109
                        state->setCTM(f3e.ctm.m11(), f3e.ctm.m12(), f3e.ctm.m21(), f3e.ctm.m22(), f3e.ctm.dx(), f3e.ctm.dy());
2110
                        QLineF cline = QLineF(0, 0, 1, 0);
2111
                        QLineF tline = f3e.ctm.map(cline);
2112
                        double xCoor = m_doc->currentPage()->xOffset();
2113
                        double yCoor = m_doc->currentPage()->yOffset();
2114
                        QTransform mm;
2115
                        mm.translate(0, -pat.height * tline.length());
21