Subversion Repositories Scribus

Rev

Rev 16732 | Rev 16745 | 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
 
658
GBool SlaOutputDev::patchMeshShadedFill(GfxState *state, GfxPatchMeshShading *shading)
659
{
660
//      qDebug() << "mesh shaded fill";
661
        double xCoor = m_doc->currentPage()->xOffset();
662
        double yCoor = m_doc->currentPage()->yOffset();
663
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor());
664
        double xmin, ymin, xmax, ymax;
665
        // get the clip region bbox
666
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
667
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
668
        crect = crect.normalized();
669
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
670
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
671
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
672
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
673
        output += QString("L %1 %2").arg(0.0).arg(0.0);
674
        output += QString("Z");
675
        pathIsClosed = true;
676
        Coords = output;
677
        double *ctm;
678
        ctm = state->getCTM();
679
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
680
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
681
        PageItem* ite = m_doc->Items->at(z);
682
        ite->ClipEdited = true;
683
        ite->FrameType = 3;
684
        ite->setFillShade(100);
685
        ite->setLineShade(100);
686
        ite->setFillEvenOdd(false);
687
        ite->setFillTransparency(1.0 - state->getFillOpacity());
688
        ite->setFillBlendmode(getBlendMode(state));
689
        ite->setLineEnd(PLineEnd);
690
        ite->setLineJoin(PLineJoin);
691
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
692
        m_doc->AdjustItemSize(ite);
693
        m_Elements->append(ite);
694
        if (m_groupStack.count() != 0)
695
        {
696
                m_groupStack.top().Items.append(ite);
16732 fschmid 697
                applyMask(ite);
16729 fschmid 698
        }
699
//      qDebug() << "Mesh of" << shading->getNPatches() << "Patches";
700
        for (int i = 0; i < shading->getNPatches(); i++)
701
        {
702
                GfxPatch *patch = shading->getPatch(i);
703
                GfxColor color;
704
                meshGradientPatch patchM;
705
                meshPoint mp1;
706
                meshPoint mp2;
707
                meshPoint mp3;
708
                meshPoint mp4;
709
                int u, v;
710
                patchM.BL.resetTo(FPoint(patch->x[0][0], patch->y[0][0]));
711
                patchM.BL.controlTop = FPoint(patch->x[0][1], patch->y[0][1]);
712
                patchM.BL.controlRight = FPoint(patch->x[1][0], patch->y[1][0]);
713
                u = 0;
714
                v = 0;
715
                if (shading->isParameterized())
716
                {
717
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
718
                }
719
                else
720
                {
721
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
722
                        {
723
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
724
                        }
725
                }
726
                patchM.BL.colorName = getColor(shading->getColorSpace(), &color);
727
                patchM.BL.shade = 100;
728
                patchM.BL.transparency = 1.0;
729
                const ScColor& col1 = m_doc->PageColors[patchM.BL.colorName];
730
                patchM.BL.color = ScColorEngine::getShadeColorProof(col1, m_doc, 100);
731
 
732
                u = 0;
733
                v = 1;
734
                patchM.TL.resetTo(FPoint(patch->x[0][3], patch->y[0][3]));
735
                patchM.TL.controlRight = FPoint(patch->x[1][3], patch->y[1][3]);
736
                patchM.TL.controlBottom = FPoint(patch->x[0][2], patch->y[0][2]);
737
                if (shading->isParameterized())
738
                {
739
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
740
                }
741
                else
742
                {
743
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
744
                        {
745
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
746
                        }
747
                }
748
                patchM.TL.colorName = getColor(shading->getColorSpace(), &color);
749
                patchM.TL.shade = 100;
750
                patchM.TL.transparency = 1.0;
751
                const ScColor& col2 = m_doc->PageColors[patchM.TL.colorName];
752
                patchM.TL.color = ScColorEngine::getShadeColorProof(col2, m_doc, 100);
753
 
754
                u = 1;
755
                v = 1;
756
                patchM.TR.resetTo(FPoint(patch->x[3][3], patch->y[3][3]));
757
                patchM.TR.controlBottom = FPoint(patch->x[3][2], patch->y[3][2]);
758
                patchM.TR.controlLeft = FPoint(patch->x[2][3], patch->y[2][3]);
759
                if (shading->isParameterized())
760
                {
761
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
762
                }
763
                else
764
                {
765
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
766
                        {
767
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
768
                        }
769
                }
770
                patchM.TR.colorName = getColor(shading->getColorSpace(), &color);
771
                patchM.TR.shade = 100;
772
                patchM.TR.transparency = 1.0;
773
                const ScColor& col4 = m_doc->PageColors[patchM.TR.colorName];
774
                patchM.TR.color = ScColorEngine::getShadeColorProof(col4, m_doc, 100);
775
 
776
                u = 1;
777
                v = 0;
778
                patchM.BR.resetTo(FPoint(patch->x[3][0], patch->y[3][0]));
779
                patchM.BR.controlLeft = FPoint(patch->x[2][0], patch->y[2][0]);
780
                patchM.BR.controlTop = FPoint(patch->x[3][1], patch->y[3][1]);
781
                if (shading->isParameterized())
782
                {
783
                        shading->getParameterizedColor (patch->color[u][v].c[0], &color);
784
                }
785
                else
786
                {
787
                        for (int k = 0; k < shading->getColorSpace()->getNComps(); k++)
788
                        {
789
                                color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
790
                        }
791
                }
792
                patchM.BR.colorName = getColor(shading->getColorSpace(), &color);
793
                patchM.BR.shade = 100;
794
                patchM.BR.transparency = 1.0;
795
                const ScColor& col3 = m_doc->PageColors[patchM.BR.colorName];
796
                patchM.BR.color = ScColorEngine::getShadeColorProof(col3, m_doc, 100);
797
 
798
                patchM.TL.transform(m_ctm);
799
                patchM.TL.moveRel(-crect.x(), -crect.y());
800
                patchM.TR.transform(m_ctm);
801
                patchM.TR.moveRel(-crect.x(), -crect.y());
802
                patchM.BR.transform(m_ctm);
803
                patchM.BR.moveRel(-crect.x(), -crect.y());
804
                patchM.BL.transform(m_ctm);
805
                patchM.BL.moveRel(-crect.x(), -crect.y());
806
                ite->meshGradientPatches.append(patchM);
807
        }
808
        ite->GrType = 12;
809
        return gTrue;
810
}
811
 
812
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)
813
{
814
        PDFRectangle box;
815
        Gfx *gfx;
816
        QString id;
817
        PageItem *ite;
818
        groupEntry gElements;
819
        gElements.forSoftMask = gFalse;
820
        gElements.alpha = gFalse;
16732 fschmid 821
        gElements.inverted = false;
16729 fschmid 822
        gElements.maskName = "";
823
        gElements.Items.clear();
824
        m_groupStack.push(gElements);
825
        double width, height;
826
        width = bbox[2] - bbox[0];
827
        height = bbox[3] - bbox[1];
828
        if (xStep != width || yStep != height)
829
                return gFalse;
830
        box.x1 = bbox[0];
831
        box.y1 = bbox[1];
832
        box.x2 = bbox[2];
833
        box.y2 = bbox[3];
834
        double *ctm;
835
        ctm = state->getCTM();
836
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
837
        QTransform mm = QTransform(mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
838
        QTransform mmx = mm * m_ctm;
839
        gfx = new Gfx(xref, this, resDict, catalog, &box, NULL);
840
        gfx->display(str);
841
        gElements = m_groupStack.pop();
842
        tmpSel->clear();
843
        double pwidth = 0;
844
        double pheight = 0;
845
        if (gElements.Items.count() > 0)
846
        {
847
                for (int dre = 0; dre < gElements.Items.count(); ++dre)
848
                {
849
                        tmpSel->addItem(gElements.Items.at(dre), true);
850
                        m_Elements->removeAll(gElements.Items.at(dre));
851
                }
852
                ite = m_doc->groupObjectsSelection(tmpSel);
853
                ite->setFillTransparency(1.0 - state->getFillOpacity());
854
                ite->setFillBlendmode(getBlendMode(state));
855
                m_doc->m_Selection->addItem(ite, true);
856
                m_doc->itemSelection_FlipV();
857
                m_doc->m_Selection->clear();
858
                ScPattern pat = ScPattern();
859
                pat.setDoc(m_doc);
860
                m_doc->DoDrawing = true;
861
                pat.pattern = ite->DrawObj_toImage(qMax(ite->width(), ite->height()));
862
                pat.xoffset = 0;
863
                pat.yoffset = 0;
864
                m_doc->DoDrawing = false;
865
                pat.width = ite->width();
866
                pat.height = ite->height();
867
                pwidth = ite->width();
868
                pheight = ite->height();
869
                pat.items.append(ite);
870
                m_doc->Items->removeAll(ite);
871
                id = QString("Pattern_from_PDF_%1").arg(m_doc->docPatterns.count() + 1);
872
                m_doc->addPattern(id, pat);
873
                tmpSel->clear();
874
        }
875
        double xCoor = m_doc->currentPage()->xOffset();
876
        double yCoor = m_doc->currentPage()->yOffset();
877
        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor());
878
        double xmin, ymin, xmax, ymax;
879
        // get the clip region bbox
880
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
881
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
882
        crect = crect.normalized();
883
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
884
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
885
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
886
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
887
        output += QString("L %1 %2").arg(0.0).arg(0.0);
888
        output += QString("Z");
889
        pathIsClosed = true;
890
        Coords = output;
891
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, CurrColorFill, CommonStrings::None, true);
892
        ite = m_doc->Items->at(z);
893
        ite->ClipEdited = true;
894
        ite->FrameType = 3;
895
        ite->setFillShade(100);
896
        ite->setLineShade(100);
897
        ite->setFillEvenOdd(false);
898
        ite->setFillTransparency(1.0 - state->getFillOpacity());
899
        ite->setFillBlendmode(getBlendMode(state));
900
        ite->setLineEnd(PLineEnd);
901
        ite->setLineJoin(PLineJoin);
902
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
903
        ite->GrType = 8;
904
        ite->setPattern(id);
905
        ite->setPatternTransform(fabs(pmat[0]) * 100, fabs(pmat[3]) * 100, mmx.dx() - ctm[4], mmx.dy() - ctm[5], 0, -1 * pmat[1], pmat[2]);
906
        m_doc->AdjustItemSize(ite);
907
        m_Elements->append(ite);
908
        if (m_groupStack.count() != 0)
909
        {
910
                m_groupStack.top().Items.append(ite);
16732 fschmid 911
                applyMask(ite);
16729 fschmid 912
        }
913
        delete gfx;
914
        return gTrue;
915
}
916
 
917
void SlaOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, Stream *maskStr, int maskWidth, int maskHeight,
918
                                   GfxImageColorMap *maskColorMap, GBool maskInterpolate)
919
{
920
        double *ctm;
921
        ctm = state->getCTM();
922
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
923
        ImageStream * imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(), colorMap->getBits());
924
        imgStr->reset();
925
        unsigned int *dest = 0;
926
        unsigned char * buffer = new unsigned char[width * height * 4];
927
        QImage * image = 0;
928
        for (int y = 0; y < height; y++)
929
        {
930
                dest = (unsigned int *)(buffer + y * 4 * width);
931
                Guchar * pix = imgStr->getLine();
932
                colorMap->getRGBLine(pix, dest, width);
933
        }
934
        image = new QImage(buffer, width, height, QImage::Format_RGB32);
935
        if (image == NULL || image->isNull())
936
        {
937
                delete imgStr;
938
                delete[] buffer;
939
                delete image;
940
                return;
941
        }
942
        ImageStream *mskStr = new ImageStream(maskStr, maskWidth, maskColorMap->getNumPixelComps(), maskColorMap->getBits());
943
        mskStr->reset();
944
        Guchar *mdest = 0;
945
        unsigned char * mbuffer = new unsigned char[maskWidth * maskHeight];
946
        for (int y = 0; y < maskHeight; y++)
947
        {
948
                mdest = (Guchar *)(mbuffer + y * maskWidth);
949
                Guchar * pix = mskStr->getLine();
950
                maskColorMap->getGrayLine(pix, mdest, maskWidth);
951
        }
952
        if ((maskWidth != width) || (maskHeight != height))
953
        {
954
                delete imgStr;
955
                delete[] buffer;
956
                delete image;
957
                delete mskStr;
958
                delete[] mbuffer;
959
                return;
960
        }
961
        QImage res = image->convertToFormat(QImage::Format_ARGB32);
962
        unsigned char cc, cm, cy, ck;
963
        int s = 0;
964
        for( int yi=0; yi < res.height(); ++yi )
965
        {
966
                QRgb *t = (QRgb*)(res.scanLine( yi ));
967
                for(int xi=0; xi < res.width(); ++xi )
968
                {
969
                        cc = qRed(*t);
970
                        cm = qGreen(*t);
971
                        cy = qBlue(*t);
972
                        ck = mbuffer[s];
973
                        (*t) = qRgba(cc, cm, cy, ck);
974
                        s++;
975
                        t++;
976
                }
977
        }
978
        double xCoor = m_doc->currentPage()->xOffset();
979
        double yCoor = m_doc->currentPage()->yOffset();
980
        double sx = ctm[0] / width;
981
        double sy = ctm[3] / height;
982
        if (sx < 0)
983
                xCoor = xCoor + ctm[4] - (fabs(sx) * width);
984
        else
985
                xCoor = xCoor + ctm[4];
986
        if (sy < 0)
987
                yCoor = yCoor + ctm[5] - (fabs(sy) * height);
988
        else
989
                yCoor = yCoor + ctm[5];
16732 fschmid 990
        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 991
        PageItem* ite = m_doc->Items->at(z);
992
        ite->SetRectFrame();
993
        m_doc->setRedrawBounding(ite);
994
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
995
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
996
        ite->setFillShade(100);
997
        ite->setLineShade(100);
998
        ite->setFillEvenOdd(false);
999
        ite->setFillTransparency(1.0 - state->getFillOpacity());
1000
        ite->setFillBlendmode(getBlendMode(state));
1001
        ite->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_pdf_XXXXXX.png");
1002
        ite->tempImageFile->open();
1003
        QString fileName = getLongPathName(ite->tempImageFile->fileName());
1004
        ite->tempImageFile->close();
1005
        ite->isInlineImage = true;
1006
        res.save(fileName, "PNG");
1007
        m_doc->LoadPict(fileName, z);
1008
        ite->setImageScalingMode(false, true);
1009
        if (sx < 0)
1010
                ite->setImageFlippedH(true);
1011
        if (sy > 0)
1012
                ite->setImageFlippedV(true);
1013
        m_doc->AdjustItemSize(ite);
1014
        m_Elements->append(ite);
1015
        if (m_groupStack.count() != 0)
1016
        {
1017
                m_groupStack.top().Items.append(ite);
16732 fschmid 1018
                applyMask(ite);
16729 fschmid 1019
        }
1020
        delete imgStr;
1021
        delete[] buffer;
1022
        delete image;
1023
        delete mskStr;
1024
        delete[] mbuffer;
1025
}
1026
 
1027
void SlaOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, int *maskColors, GBool inlineImg)
1028
{
1029
        double *ctm;
1030
        ctm = state->getCTM();
1031
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1032
        ImageStream * imgStr = new ImageStream(str, width, colorMap->getNumPixelComps(), colorMap->getBits());
1033
        imgStr->reset();
1034
        unsigned int *dest = 0;
1035
        unsigned char * buffer = new unsigned char[width * height * 4];
1036
        QImage * image = 0;
1037
        if (maskColors)
1038
        {
1039
                for (int y = 0; y < height; y++)
1040
                {
1041
                        dest = (unsigned int *)(buffer + y * 4 * width);
1042
                        Guchar * pix = imgStr->getLine();
1043
                        colorMap->getRGBLine(pix, dest, width);
1044
                        for (int x = 0; x < width; x++)
1045
                        {
1046
                                for (int i = 0; i < colorMap->getNumPixelComps(); ++i)
1047
                                {
1048
                                        if (pix[i] < maskColors[2*i] * 255 || pix[i] > maskColors[2*i+1] * 255)
1049
                                        {
1050
                                                *dest = *dest | 0xff000000;
1051
                                                break;
1052
                                        }
1053
                                }
1054
                                pix += colorMap->getNumPixelComps();
1055
                                dest++;
1056
                        }
1057
                }
1058
                image = new QImage(buffer, width, height, QImage::Format_ARGB32);
1059
        }
1060
        else
1061
        {
1062
                for (int y = 0; y < height; y++)
1063
                {
1064
                        dest = (unsigned int *)(buffer + y * 4 * width);
1065
                        Guchar * pix = imgStr->getLine();
1066
                        colorMap->getRGBLine(pix, dest, width);
1067
                }
1068
                image = new QImage(buffer, width, height, QImage::Format_RGB32);
1069
        }
1070
        if (image == NULL || image->isNull())
1071
        {
1072
                delete imgStr;
1073
                delete[] buffer;
1074
                delete image;
1075
                return;
1076
        }
1077
        double xCoor = m_doc->currentPage()->xOffset();
1078
        double yCoor = m_doc->currentPage()->yOffset();
1079
        double sx = ctm[0] / width;
1080
        double sy = ctm[3] / height;
1081
        if (sx < 0)
1082
                xCoor = xCoor + ctm[4] - (fabs(sx) * width);
1083
        else
1084
                xCoor = xCoor + ctm[4];
1085
        if (sy < 0)
1086
                yCoor = yCoor + ctm[5] - (fabs(sy) * height);
1087
        else
1088
                yCoor = yCoor + ctm[5];
16732 fschmid 1089
        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 1090
        PageItem* ite = m_doc->Items->at(z);
1091
        ite->SetRectFrame();
1092
        m_doc->setRedrawBounding(ite);
1093
        ite->Clip = FlattenPath(ite->PoLine, ite->Segments);
1094
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1095
        ite->setFillShade(100);
1096
        ite->setLineShade(100);
1097
        ite->setFillEvenOdd(false);
1098
        ite->setFillTransparency(1.0 - state->getFillOpacity());
1099
        ite->setFillBlendmode(getBlendMode(state));
1100
        ite->tempImageFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_pdf_XXXXXX.png");
1101
        ite->tempImageFile->open();
1102
        QString fileName = getLongPathName(ite->tempImageFile->fileName());
1103
        ite->tempImageFile->close();
1104
        ite->isInlineImage = true;
1105
        image->save(fileName, "PNG");
1106
        m_doc->LoadPict(fileName, z);
1107
        ite->setImageScalingMode(false, true);
1108
        if (sx < 0)
1109
                ite->setImageFlippedH(true);
1110
        if (sy > 0)
1111
                ite->setImageFlippedV(true);
1112
        m_doc->AdjustItemSize(ite);
1113
        m_Elements->append(ite);
1114
        if (m_groupStack.count() != 0)
1115
        {
1116
                m_groupStack.top().Items.append(ite);
16732 fschmid 1117
                applyMask(ite);
16729 fschmid 1118
        }
1119
        delete imgStr;
1120
        delete[] buffer;
1121
        delete image;
1122
}
1123
 
1124
void SlaOutputDev::beginMarkedContent(char *name, Dict *properties)
1125
{
1126
//      qDebug() << "Begin Marked Content with Name " << QString(name);
1127
        if (importerFlags & LoadSavePlugin::lfCreateDoc)
1128
        {
1129
                if (QString(name) == "Layer")           // Handle Adobe Illustrator Layer command
1130
                {
1131
                        layerNum++;
1132
                        if (!firstLayer)
1133
                                currentLayer = m_doc->addLayer(QString("Layer_%1").arg(layerNum), true);
1134
                        firstLayer = false;
1135
                        Object obj;
1136
                        if (properties->lookup((char*)"Title", &obj))
1137
                        {
1138
                                if (obj.isString())
1139
                                {
1140
                                        QString lName =  QString(obj.getString()->getCString());
1141
                                        m_doc->changeLayerName(currentLayer, lName);
1142
                                }
1143
                                obj.free();
1144
                        }
1145
                        if (properties->lookup((char*)"Visible", &obj))
1146
                        {
1147
                                if (obj.isBool())
1148
                                        m_doc->setLayerVisible(currentLayer, obj.getBool());
1149
                                obj.free();
1150
                        }
1151
                        if (properties->lookup((char*)"Editable", &obj))
1152
                        {
1153
                                if (obj.isBool())
1154
                                        m_doc->setLayerLocked(currentLayer, !obj.getBool());
1155
                                obj.free();
1156
                        }
1157
                        if (properties->lookup((char*)"Printed", &obj))
1158
                        {
1159
                                if (obj.isBool())
1160
                                        m_doc->setLayerPrintable(currentLayer, obj.getBool());
1161
                                obj.free();
1162
                        }
1163
                        if (properties->lookup((char*)"Color", &obj))
1164
                        {
1165
                                if (obj.isArray())
1166
                                {
1167
                                        Object obj1;
1168
                                        obj.arrayGet(0, &obj1);
1169
                                        int r = obj1.getNum() / 256;
1170
                                        obj1.free();
1171
                                        obj.arrayGet(1, &obj1);
1172
                                        int g = obj1.getNum() / 256;
1173
                                        obj1.free();
1174
                                        obj.arrayGet(2, &obj1);
1175
                                        int b = obj1.getNum() / 256;
1176
                                        obj1.free();
1177
                                        m_doc->setLayerMarker(currentLayer, QColor(r, g, b));
1178
                                }
1179
                                obj.free();
1180
                        }
1181
                }
1182
        }
1183
}
1184
 
1185
void SlaOutputDev::endMarkedContent(GfxState *state)
1186
{
1187
//      qDebug() << "End Marked Content";
1188
}
1189
 
1190
void SlaOutputDev::updateFont(GfxState *state)
1191
{
1192
        GfxFont *gfxFont;
1193
        GfxFontType fontType;
1194
        SplashOutFontFileID *id;
1195
        SplashFontFile *fontFile;
1196
        SplashFontSrc *fontsrc = NULL;
1197
        FoFiTrueType *ff;
1198
        Ref embRef;
1199
        Object refObj, strObj;
1200
        GooString *fileName;
1201
        char *tmpBuf;
1202
        int tmpBufLen;
1203
        Gushort *codeToGID;
1204
        DisplayFontParam *dfp;
1205
        double *textMat;
1206
        double m11, m12, m21, m22, fontSize;
1207
        SplashCoord mat[4];
1208
        int n;
1209
        int faceIndex = 0;
1210
        SplashCoord matrix[6];
1211
 
1212
        m_font = NULL;
1213
        fileName = NULL;
1214
        tmpBuf = NULL;
1215
 
1216
        if (!(gfxFont = state->getFont()))
1217
                goto err1;
1218
        fontType = gfxFont->getType();
1219
        if (fontType == fontType3)
1220
                goto err1;
1221
 
1222
  // check the font file cache
1223
        id = new SplashOutFontFileID(gfxFont->getID());
1224
        if ((fontFile = m_fontEngine->getFontFile(id)))
1225
        {
1226
                delete id;
1227
        }
1228
        else
1229
        {
1230
                // if there is an embedded font, write it to disk
1231
                if (gfxFont->getEmbeddedFontID(&embRef))
1232
                {
1233
                        tmpBuf = gfxFont->readEmbFontFile(xref, &tmpBufLen);
1234
                        if (!tmpBuf)
1235
                                goto err2;
1236
                // if there is an external font file, use it
1237
                }
1238
                else if (!(fileName = gfxFont->getExtFontFile()))
1239
                {
1240
          // look for a display font mapping or a substitute font
1241
                        dfp = NULL;
1242
                        if (gfxFont->getName())
1243
                        {
1244
                                dfp = globalParams->getDisplayFont(gfxFont);
1245
                        }
1246
                        if (!dfp)
1247
                        {
1248
                //              error(-1, "Couldn't find a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1249
                                goto err2;
1250
                        }
1251
                        switch (dfp->kind)
1252
                        {
1253
                                case displayFontT1:
1254
                                        fileName = dfp->t1.fileName;
1255
                                        fontType = gfxFont->isCIDFont() ? fontCIDType0 : fontType1;
1256
                                        break;
1257
                                case displayFontTT:
1258
                                        fileName = dfp->tt.fileName;
1259
                                        fontType = gfxFont->isCIDFont() ? fontCIDType2 : fontTrueType;
1260
                                        faceIndex = dfp->tt.faceIndex;
1261
                                        break;
1262
                        }
1263
                }
1264
                fontsrc = new SplashFontSrc;
1265
                if (fileName)
1266
                        fontsrc->setFile(fileName, gFalse);
1267
                else
1268
                        fontsrc->setBuf(tmpBuf, tmpBufLen, gTrue);
1269
        // load the font file
1270
                switch (fontType)
1271
                {
1272
                        case fontType1:
1273
                                if (!(fontFile = m_fontEngine->loadType1Font( id, fontsrc, ((Gfx8BitFont *)gfxFont)->getEncoding())))
1274
                                {
1275
                        //              error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1276
                                        goto err2;
1277
                                }
1278
                                break;
1279
                        case fontType1C:
1280
                                if (!(fontFile = m_fontEngine->loadType1CFont( id, fontsrc, ((Gfx8BitFont *)gfxFont)->getEncoding())))
1281
                                {
1282
                //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1283
                                        goto err2;
1284
                                }
1285
                                break;
1286
                        case fontType1COT:
1287
                                if (!(fontFile = m_fontEngine->loadOpenTypeT1CFont( id, fontsrc, ((Gfx8BitFont *)gfxFont)->getEncoding())))
1288
                                {
1289
                //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1290
                                        goto err2;
1291
                                }
1292
                                break;
1293
                        case fontTrueType:
1294
                        case fontTrueTypeOT:
1295
                                if (fileName)
1296
                                        ff = FoFiTrueType::load(fileName->getCString());
1297
                                else
1298
                                        ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
1299
                                if (ff)
1300
                                {
1301
                                        codeToGID = ((Gfx8BitFont *)gfxFont)->getCodeToGIDMap(ff);
1302
                                        n = 256;
1303
                                        delete ff;
1304
                                }
1305
                                else
1306
                                {
1307
                                        codeToGID = NULL;
1308
                                        n = 0;
1309
                                }
1310
                                if (!(fontFile = m_fontEngine->loadTrueTypeFont( id, fontsrc, codeToGID, n)))
1311
                                {
1312
        //                              error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1313
                                        goto err2;
1314
                                }
1315
                        break;
1316
                case fontCIDType0:
1317
                case fontCIDType0C:
1318
                        if (!(fontFile = m_fontEngine->loadCIDFont( id, fontsrc)))
1319
                        {
1320
        //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1321
                                goto err2;
1322
                        }
1323
                        break;
1324
                case fontCIDType0COT:
1325
                        if (!(fontFile = m_fontEngine->loadOpenTypeCFFFont( id, fontsrc)))
1326
                        {
1327
        //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1328
                                goto err2;
1329
                        }
1330
                        break;
1331
                case fontCIDType2:
1332
                case fontCIDType2OT:
1333
                        codeToGID = NULL;
1334
                        n = 0;
1335
                        if (((GfxCIDFont *)gfxFont)->getCIDToGID())
1336
                        {
1337
                                n = ((GfxCIDFont *)gfxFont)->getCIDToGIDLen();
1338
                                if (n)
1339
                                {
1340
                                        codeToGID = (Gushort *)gmallocn(n, sizeof(Gushort));
1341
                                        memcpy(codeToGID, ((GfxCIDFont *)gfxFont)->getCIDToGID(), n * sizeof(Gushort));
1342
                                }
1343
                        }
1344
                        else
1345
                        {
1346
                                if (fileName)
1347
                                        ff = FoFiTrueType::load(fileName->getCString());
1348
                                else
1349
                                        ff = FoFiTrueType::make(tmpBuf, tmpBufLen);
1350
                                if (!ff)
1351
                                        goto err2;
1352
                                codeToGID = ((GfxCIDFont *)gfxFont)->getCodeToGIDMap(ff, &n);
1353
                                delete ff;
1354
                        }
1355
                        if (!(fontFile = m_fontEngine->loadTrueTypeFont( id, fontsrc, codeToGID, n, faceIndex)))
1356
                        {
1357
        //                      error(-1, "Couldn't create a font for '%s'", gfxFont->getName() ? gfxFont->getName()->getCString() : "(unnamed)");
1358
                                goto err2;
1359
                        }
1360
                        break;
1361
                default:
1362
          // this shouldn't happen
1363
                        goto err2;
1364
                }
1365
        }
1366
        // get the font matrix
1367
        textMat = state->getTextMat();
1368
        fontSize = state->getFontSize();
1369
        m11 = textMat[0] * fontSize * state->getHorizScaling();
1370
        m12 = textMat[1] * fontSize * state->getHorizScaling();
1371
        m21 = textMat[2] * fontSize;
1372
        m22 = textMat[3] * fontSize;
1373
        matrix[0] = 1;
1374
        matrix[1] = 0;
1375
        matrix[2] = 0;
1376
        matrix[3] = 1;
1377
        matrix[4] = 0;
1378
        matrix[5] = 0;
1379
  // create the scaled font
1380
        mat[0] = m11;
1381
        mat[1] = -m12;
1382
        mat[2] = m21;
1383
        mat[3] = -m22;
1384
        m_font = m_fontEngine->getFont(fontFile, mat, matrix);
1385
        if (fontsrc && !fontsrc->isFile)
1386
                fontsrc->unref();
1387
        return;
1388
 
1389
err2:
1390
        delete id;
1391
err1:
1392
        if (fontsrc && !fontsrc->isFile)
1393
                fontsrc->unref();
1394
        return;
1395
}
1396
 
1397
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)
1398
{
1399
        double x1, y1, x2, y2;
1400
        int render;
1401
        updateFont(state);
1402
        if (!m_font)
1403
                return;
1404
  // check for invisible text -- this is used by Acrobat Capture
1405
        render = state->getRender();
1406
        if (render == 3)
1407
                return;
1408
        if (!(render & 1))
1409
        {
1410
                SplashPath * fontPath;
1411
                fontPath = m_font->getGlyphPath(code);
1412
                if (fontPath)
1413
                {
1414
                        QPainterPath qPath;
1415
                        qPath.setFillRule(Qt::WindingFill);
1416
                        for (int i = 0; i < fontPath->getLength(); ++i)
1417
                        {
1418
                                Guchar f;
1419
                                fontPath->getPoint(i, &x1, &y1, &f);
1420
                                if (f & splashPathFirst)
1421
                                        qPath.moveTo(x1,y1);
1422
                                else if (f & splashPathCurve)
1423
                                {
1424
                                        double x3, y3;
1425
                                        ++i;
1426
                                        fontPath->getPoint(i, &x2, &y2, &f);
1427
                                        ++i;
1428
                                        fontPath->getPoint(i, &x3, &y3, &f);
1429
                                        qPath.cubicTo(x1,y1,x2,y2,x3,y3);
1430
                                }
1431
                                else
1432
                                        qPath.lineTo(x1,y1);
1433
                                if (f & splashPathLast)
1434
                                        qPath.closeSubpath();
1435
                        }
1436
                        double *ctm;
1437
                        ctm = state->getCTM();
1438
                        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1439
                        double xCoor = m_doc->currentPage()->xOffset();
1440
                        double yCoor = m_doc->currentPage()->yOffset();
1441
                        CurrColorFill = getColor(state->getFillColorSpace(), state->getFillColor());
1442
                        FPointArray textPath;
1443
                        textPath.fromQPainterPath(qPath);
1444
                        FPoint wh = textPath.WidthHeight();
1445
                        if ((textPath.size() > 3) && ((wh.x() != 0.0) || (wh.y() != 0.0)))
1446
                        {
1447
                                int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, CurrColorFill, CommonStrings::None, true);
1448
                                PageItem* ite = m_doc->Items->at(z);
1449
                                FPoint tp2(getMinClipF(&textPath));
1450
                                QTransform mm;
1451
                                mm.scale(1, -1);
1452
                                mm.translate(x, -y);
1453
                                textPath.map(mm);
1454
                                textPath.map(m_ctm);
1455
                                ite->PoLine = textPath.copy();
1456
                                ite->ClipEdited = true;
1457
                                ite->FrameType = 3;
1458
                                ite->setFillShade(100);
1459
                                ite->setLineShade(100);
1460
                                ite->setFillEvenOdd(false);
1461
                                ite->setFillTransparency(1.0 - state->getFillOpacity());
1462
                                ite->setFillBlendmode(getBlendMode(state));
1463
                                ite->setLineEnd(PLineEnd);
1464
                                ite->setLineJoin(PLineJoin);
1465
                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
1466
                                m_doc->AdjustItemSize(ite);
1467
                                if ((render & 3) == 1 || (render & 3) == 2)
1468
                                {
1469
                                        CurrColorStroke = getColor(state->getStrokeColorSpace(), state->getStrokeColor());
1470
                                        ite->setLineColor(CurrColorStroke);
1471
                                        ite->setLineWidth(state->getTransformedLineWidth());
1472
                                        ite->setLineTransparency(1.0 - state->getStrokeOpacity());
1473
                                        ite->setLineBlendmode(getBlendMode(state));
1474
                                }
1475
                                m_Elements->append(ite);
1476
                                if (m_groupStack.count() != 0)
1477
                                {
1478
                                        m_groupStack.top().Items.append(ite);
16732 fschmid 1479
                                        applyMask(ite);
16729 fschmid 1480
                                }
1481
                                delete fontPath;
1482
                        }
1483
                }
1484
        }
1485
}
1486
 
1487
void SlaOutputDev::beginTextObject(GfxState *state)
1488
{
1489
//      qDebug() << "Begin Text Object";
16732 fschmid 1490
        pushGroup();
16729 fschmid 1491
}
1492
 
1493
void SlaOutputDev::endTextObject(GfxState *state)
1494
{
1495
//      qDebug() << "End Text Object";
1496
        if (m_groupStack.count() != 0)
1497
        {
1498
                groupEntry gElements = m_groupStack.pop();
1499
                tmpSel->clear();
1500
                if (gElements.Items.count() > 0)
1501
                {
1502
                        for (int dre = 0; dre < gElements.Items.count(); ++dre)
1503
                        {
1504
                                tmpSel->addItem(gElements.Items.at(dre), true);
1505
                                m_Elements->removeAll(gElements.Items.at(dre));
1506
                        }
1507
                        PageItem *ite = m_doc->groupObjectsSelection(tmpSel);
1508
                        ite->setFillTransparency(1.0 - state->getFillOpacity());
1509
                        ite->setFillBlendmode(getBlendMode(state));
1510
                        for (int as = 0; as < tmpSel->count(); ++as)
1511
                        {
1512
                                m_Elements->append(tmpSel->itemAt(as));
1513
                        }
1514
                        if (m_groupStack.count() != 0)
16732 fschmid 1515
                                applyMask(ite);
16729 fschmid 1516
                }
1517
                if (m_groupStack.count() != 0)
1518
                {
1519
                        for (int as = 0; as < tmpSel->count(); ++as)
1520
                        {
1521
                                m_groupStack.top().Items.append(tmpSel->itemAt(as));
1522
                        }
1523
                }
1524
                tmpSel->clear();
1525
        }
1526
}
1527
 
1528
QString SlaOutputDev::getColor(GfxColorSpace *color_space, GfxColor *color)
1529
{
1530
        QString fNam;
1531
        QString namPrefix = "FromPDF";
1532
        ScColor tmp;
1533
        tmp.setSpotColor(false);
1534
        tmp.setRegistrationColor(false);
1535
        if ((color_space->getMode() == csDeviceRGB) || (color_space->getMode() == csCalRGB))
1536
        {
1537
                GfxRGB rgb;
1538
                color_space->getRGB(color, &rgb);
1539
                int Rc = qRound(colToDbl(rgb.r) * 255);
1540
                int Gc = qRound(colToDbl(rgb.g) * 255);
1541
                int Bc = qRound(colToDbl(rgb.b) * 255);
1542
                tmp.setColorRGB(Rc, Gc, Bc);
1543
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
1544
        }
1545
        else if (color_space->getMode() == csDeviceCMYK)
1546
        {
1547
                GfxCMYK cmyk;
1548
                color_space->getCMYK(color, &cmyk);
1549
                int Cc = qRound(colToDbl(cmyk.c) * 255);
1550
                int Mc = qRound(colToDbl(cmyk.m) * 255);
1551
                int Yc = qRound(colToDbl(cmyk.y) * 255);
1552
                int Kc = qRound(colToDbl(cmyk.k) * 255);
1553
                tmp.setColor(Cc, Mc, Yc, Kc);
1554
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
1555
        }
1556
        else if ((color_space->getMode() == csCalGray) || (color_space->getMode() == csDeviceGray))
1557
        {
1558
                GfxGray gray;
1559
                color_space->getGray(color, &gray);
1560
                int Kc = 255 - qRound(colToDbl(gray) * 255);
1561
                tmp.setColor(0, 0, 0, Kc);
1562
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
1563
        }
1564
        else if (color_space->getMode() == csSeparation)
1565
        {
1566
                GfxCMYK cmyk;
1567
                color_space->getCMYK(color, &cmyk);
1568
                int Cc = qRound(colToDbl(cmyk.c) * 255);
1569
                int Mc = qRound(colToDbl(cmyk.m) * 255);
1570
                int Yc = qRound(colToDbl(cmyk.y) * 255);
1571
                int Kc = qRound(colToDbl(cmyk.k) * 255);
1572
                tmp.setColor(Cc, Mc, Yc, Kc);
1573
                tmp.setSpotColor(true);
1574
                QString nam = QString(((GfxSeparationColorSpace*)color_space)->getName()->getCString());
1575
                fNam = m_doc->PageColors.tryAddColor(nam, tmp);
1576
        }
1577
        else
1578
        {
1579
                GfxRGB rgb;
1580
                color_space->getRGB(color, &rgb);
1581
                int Rc = qRound(colToDbl(rgb.r) * 255);
1582
                int Gc = qRound(colToDbl(rgb.g) * 255);
1583
                int Bc = qRound(colToDbl(rgb.b) * 255);
1584
                tmp.setColorRGB(Rc, Gc, Bc);
1585
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
1586
        //      qDebug() << "update fill color other colorspace" << color_space->getMode() << "treating as rgb" << Rc << Gc << Bc;
1587
        }
1588
        if (fNam == namPrefix+tmp.name())
1589
                m_importedColors->append(fNam);
1590
        return fNam;
1591
}
1592
 
1593
QString SlaOutputDev::convertPath(GfxPath *path)
1594
{
1595
    if (! path)
1596
                return QString();
1597
 
1598
    QString output;
1599
        pathIsClosed = false;
1600
 
1601
        for (int i = 0; i < path->getNumSubpaths(); ++i)
1602
        {
1603
        GfxSubpath * subpath = path->getSubpath(i);
1604
                if (subpath->getNumPoints() > 0)
1605
                {
1606
                        output += QString("M %1 %2").arg(subpath->getX(0)).arg(subpath->getY(0));
1607
            int j = 1;
1608
                        while (j < subpath->getNumPoints())
1609
                        {
1610
                                if (subpath->getCurve(j))
1611
                                {
1612
                                        output += QString("C %1 %2 %3 %4 %5 %6")
1613
                              .arg(subpath->getX(j)).arg(subpath->getY(j))
1614
                              .arg(subpath->getX(j + 1)).arg(subpath->getY(j + 1))
1615
                              .arg(subpath->getX(j + 2)).arg(subpath->getY(j + 2));
1616
                    j += 3;
1617
                                }
1618
                                else
1619
                                {
1620
                                        output += QString("L %1 %2").arg(subpath->getX(j)).arg(subpath->getY(j));
1621
                    ++j;
1622
                }
1623
            }
1624
                        if (subpath->isClosed())
1625
                        {
1626
                output += QString("Z");
1627
                                pathIsClosed = true;
1628
            }
1629
        }
1630
        }
1631
        return output;
1632
}
1633
 
1634
void SlaOutputDev::getPenState(GfxState *state)
1635
{
1636
        switch (state->getLineCap())
1637
        {
1638
                case 0:
1639
                        PLineEnd = Qt::FlatCap;
1640
                        break;
1641
                case 1:
1642
                        PLineEnd = Qt::RoundCap;
1643
                        break;
1644
                case 2:
1645
                        PLineEnd = Qt::SquareCap;
1646
                        break;
1647
        }
1648
        switch (state->getLineJoin())
1649
        {
1650
                case 0:
1651
                        PLineJoin = Qt::MiterJoin;
1652
                        break;
1653
                case 1:
1654
                        PLineJoin = Qt::RoundJoin;
1655
                        break;
1656
                case 2:
1657
                        PLineJoin = Qt::BevelJoin;
1658
                        break;
1659
        }
1660
        double *dashPattern;
1661
        int dashLength;
1662
        state->getLineDash(&dashPattern, &dashLength, &DashOffset);
1663
        QVector<double> pattern(dashLength);
1664
        for (int i = 0; i < dashLength; ++i)
1665
        {
1666
                pattern[i] = dashPattern[i];
1667
        }
1668
        DashValues = pattern;
1669
}
1670
 
1671
int SlaOutputDev::getBlendMode(GfxState *state)
1672
{
1673
        int mode = 0;
1674
        switch (state->getBlendMode())
1675
        {
1676
                default:
1677
                case gfxBlendNormal:
1678
                        mode = 0;
1679
                        break;
1680
                case gfxBlendDarken:
1681
                        mode = 1;
1682
                        break;
1683
                case gfxBlendLighten:
1684
                        mode = 2;
1685
                        break;
1686
                case gfxBlendMultiply:
1687
                        mode = 3;
1688
                        break;
1689
                case gfxBlendScreen:
1690
                        mode = 4;
1691
                        break;
1692
                case gfxBlendOverlay:
1693
                        mode = 5;
1694
                        break;
1695
                case gfxBlendHardLight:
1696
                        mode = 6;
1697
                        break;
1698
                case gfxBlendSoftLight:
1699
                        mode = 7;
1700
                        break;
1701
                case gfxBlendDifference:
1702
                        mode = 8;
1703
                        break;
1704
                case gfxBlendExclusion:
1705
                        mode = 9;
1706
                        break;
1707
                case gfxBlendColorDodge:
1708
                        mode = 10;
1709
                        break;
1710
                case gfxBlendColorBurn:
1711
                        mode = 11;
1712
                        break;
1713
                case gfxBlendHue:
1714
                        mode = 12;
1715
                        break;
1716
                case gfxBlendSaturation:
1717
                        mode = 13;
1718
                        break;
1719
                case gfxBlendColor:
1720
                        mode = 14;
1721
                        break;
1722
                case gfxBlendLuminosity:
1723
                        mode = 15;
1724
                        break;
1725
        }
1726
        return mode;
1727
}
1728
 
16732 fschmid 1729
void SlaOutputDev::applyMask(PageItem *ite)
1730
{
1731
        if (m_groupStack.count() != 0)
1732
        {
1733
                if (!m_groupStack.top().maskName.isEmpty())
1734
                {
1735
                        ite->setPatternMask(m_groupStack.top().maskName);
1736
                        if (m_groupStack.top().alpha)
1737
                        {
1738
                                if (m_groupStack.top().inverted)
1739
                                        ite->setMaskType(8);
1740
                                else
1741
                                        ite->setMaskType(3);
1742
                        }
1743
                        else
1744
                        {
1745
                                if (m_groupStack.top().inverted)
1746
                                        ite->setMaskType(7);
1747
                                else
1748
                                        ite->setMaskType(6);
1749
                        }
1750
                }
1751
        }
1752
}
1753
 
1754
void SlaOutputDev::pushGroup(QString maskName, GBool forSoftMask, GBool alpha, bool inverted)
1755
{
1756
        groupEntry gElements;
1757
        gElements.forSoftMask = forSoftMask;
1758
        gElements.alpha = alpha;
1759
        gElements.inverted = inverted;
1760
        gElements.maskName = maskName;
1761
        m_groupStack.push(gElements);
1762
}