Subversion Repositories Scribus

Rev

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