Subversion Repositories Scribus

Rev

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