Subversion Repositories Scribus

Rev

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