Subversion Repositories Scribus

Rev

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