Subversion Repositories Scribus

Rev

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