Subversion Repositories Scribus

Rev

Rev 24665 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
19590 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
 
8
#include "slaoutput.h"
22513 jghali 9
 
19590 jghali 10
#include <poppler/GlobalParams.h>
11
#include <poppler/poppler-config.h>
12
#include <poppler/FileSpec.h>
13
#include <poppler/fofi/FoFiTrueType.h>
14
#include <QApplication>
15
#include <QFile>
16
#include "commonstrings.h"
17
#include "loadsaveplugin.h"
18
#include "sccolorengine.h"
19
#include "util.h"
20
#include "util_math.h"
21
#include <tiffio.h>
22
 
24374 jghali 23
//#ifndef DEBUG_TEXT_IMPORT
24
//      #define DEBUG_TEXT_IMPORT
25
//#endif
26
 
23550 jghali 27
namespace
28
{
29
        // Compute the intersection of two paths while considering the fillrule of each of them.
30
        // QPainterPath has the right interface to do the operation but is currently buggy.
31
        // See for example https://bugreports.qt.io/browse/QTBUG-83102. Thus this function
32
        // applies some heuristics to find the best result. As soon QPainterPath is fixed
33
        // one can just use a.intersected(b) wherever this function is called.
34
        // TODO: Find an alternative to QPainterPath that works for different fill rules.
35
        QPainterPath intersection(QPainterPath const &a, QPainterPath const &b)
36
        {
37
                // An empty path is treated like the whole area.
38
                if (a.elementCount() == 0)
39
                        return b;
40
                if (b.elementCount() == 0)
41
                        return a;
42
 
43
                QPainterPath ret_a = a.intersected(b);
44
                QPainterPath ret_b = b.intersected(a);
45
                // Sometimes the resulting paths are not closed even though they should.
46
                // Close them now.
47
                ret_a.closeSubpath();
48
                ret_b.closeSubpath();
49
 
50
                // Most of the time one of the two operations returns an empty path while the other
51
                // gives us the desired result. Return the non-empty one.
52
                if (ret_a.elementCount() == 0)
53
                        return ret_b;
54
                if (ret_b.elementCount() == 0)
55
                        return ret_a;
56
 
57
                // There are cases where both intersections are not empty but one of them is quite
58
                // complicated with several subpaths, etc. We return the simpler one.
59
                return (ret_a.elementCount() <= ret_b.elementCount()) ? ret_a : ret_b;
60
        }
23589 jghali 61
 
62
        // Invert preblending matte values into the color values. Assuming that c and alpha are RGBA components
63
        // between 0 and 255.
64
        int unblendMatte(int c, int alpha, int matte)
65
        {
66
                if (alpha == 0)
67
                        return matte;
68
                int ret = matte + ((c - matte) * 255) / alpha;
69
                if (ret < 0)
70
                        return 0;
71
                if (ret > 255)
72
                        return 255;
73
                return ret;
74
        }
23550 jghali 75
}
76
 
19590 jghali 77
LinkSubmitForm::LinkSubmitForm(Object *actionObj)
78
{
23377 craig 79
        if (!actionObj->isDict())
80
                return;
22738 jghali 81
 
23377 craig 82
        Object obj1 = actionObj->dictLookup("F");
83
        if (!obj1.isNull())
19590 jghali 84
        {
23377 craig 85
                if (obj1.isDict())
22154 jghali 86
                {
23377 craig 87
                        Object obj3 = obj1.dictLookup("FS");
88
                        if (!obj3.isNull())
22154 jghali 89
                        {
23377 craig 90
                                if (obj3.isName())
22154 jghali 91
                                {
23377 craig 92
                                        POPPLER_CONST char *name = obj3.getName();
93
                                        if (!strcmp(name, "URL"))
22154 jghali 94
                                        {
23377 craig 95
                                                Object obj2 = obj1.dictLookup("F");
96
                                                if (!obj2.isNull())
97
                                                        fileName = obj2.getString()->copy();
22154 jghali 98
                                        }
99
                                }
100
                        }
101
                }
102
        }
23377 craig 103
        obj1 = actionObj->dictLookup("Flags");
104
        if (!obj1.isNull())
105
        {
106
                if (obj1.isNum())
107
                        m_flags = obj1.getInt();
108
        }
19590 jghali 109
}
110
 
111
LinkSubmitForm::~LinkSubmitForm()
112
{
22609 craig 113
        delete fileName;
19590 jghali 114
}
115
 
116
LinkImportData::LinkImportData(Object *actionObj)
117
{
23377 craig 118
        if (!actionObj->isDict())
119
                return;
120
        Object obj1 = actionObj->dictLookup("F");
121
        if (obj1.isNull())
122
                return;
22738 jghali 123
 
23377 craig 124
        Object obj3 = getFileSpecNameForPlatform(&obj1);
125
        if (!obj3.isNull())
126
                fileName = obj3.getString()->copy();
19590 jghali 127
}
128
 
129
LinkImportData::~LinkImportData()
130
{
22609 craig 131
        delete fileName;
19590 jghali 132
}
133
 
134
AnoOutputDev::~AnoOutputDev()
135
{
24374 jghali 136
        delete fontName;
137
        delete itemText;
19590 jghali 138
}
139
 
140
AnoOutputDev::AnoOutputDev(ScribusDoc* doc, QStringList *importedColors)
141
{
142
        m_doc = doc;
143
        m_importedColors = importedColors;
24374 jghali 144
        currColorText = "Black";
145
        currColorFill = CommonStrings::None;
146
        currColorStroke = CommonStrings::None;
19590 jghali 147
}
148
 
149
void AnoOutputDev::eoFill(GfxState *state)
150
{
151
        int shade = 100;
24374 jghali 152
        currColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
19590 jghali 153
}
154
 
155
void AnoOutputDev::fill(GfxState *state)
156
{
157
        int shade = 100;
24374 jghali 158
        currColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
19590 jghali 159
}
160
 
161
void AnoOutputDev::stroke(GfxState *state)
162
{
163
        int shade = 100;
24374 jghali 164
        currColorStroke = getColor(state->getStrokeColorSpace(), state->getStrokeColor(), &shade);
19590 jghali 165
}
166
 
22678 jghali 167
void AnoOutputDev::drawString(GfxState *state, POPPLER_CONST GooString *s)
19590 jghali 168
{
169
        int shade = 100;
24374 jghali 170
        currColorText = getColor(state->getFillColorSpace(), state->getFillColor(), &shade);
171
        fontSize = state->getFontSize();
19590 jghali 172
        if (state->getFont())
24374 jghali 173
                fontName = state->getFont()->getName()->copy();
174
        itemText = s->copy();
19590 jghali 175
}
176
 
22741 jghali 177
QString AnoOutputDev::getColor(GfxColorSpace *color_space, POPPLER_CONST_070 GfxColor *color, int *shade)
19590 jghali 178
{
179
        QString fNam;
180
        QString namPrefix = "FromPDF";
181
        ScColor tmp;
182
        tmp.setSpotColor(false);
183
        tmp.setRegistrationColor(false);
184
        *shade = 100;
185
        if ((color_space->getMode() == csDeviceRGB) || (color_space->getMode() == csCalRGB))
186
        {
187
                GfxRGB rgb;
188
                color_space->getRGB(color, &rgb);
22212 jghali 189
                double Rc = colToDbl(rgb.r);
190
                double Gc = colToDbl(rgb.g);
191
                double Bc = colToDbl(rgb.b);
192
                tmp.setRgbColorF(Rc, Gc, Bc);
19590 jghali 193
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
194
        }
195
        else if (color_space->getMode() == csDeviceCMYK)
196
        {
197
                GfxCMYK cmyk;
198
                color_space->getCMYK(color, &cmyk);
22212 jghali 199
                double Cc = colToDbl(cmyk.c);
200
                double Mc = colToDbl(cmyk.m);
201
                double Yc = colToDbl(cmyk.y);
202
                double Kc = colToDbl(cmyk.k);
22593 jghali 203
                tmp.setCmykColorF(Cc, Mc, Yc, Kc);
19590 jghali 204
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
205
        }
206
        else if ((color_space->getMode() == csCalGray) || (color_space->getMode() == csDeviceGray))
207
        {
208
                GfxGray gray;
209
                color_space->getGray(color, &gray);
22212 jghali 210
                double Kc = 1.0 - colToDbl(gray);
22593 jghali 211
                tmp.setCmykColorF(0, 0, 0, Kc);
19590 jghali 212
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
213
        }
214
        else if (color_space->getMode() == csSeparation)
215
        {
22596 jghali 216
                GfxSeparationColorSpace* sepColorSpace = (GfxSeparationColorSpace*)color_space;
217
                GfxColorSpace* altColorSpace = sepColorSpace->getAlt();
218
                QString name = QString(sepColorSpace->getName()->getCString());
219
                bool isRegistrationColor = (name == "All");
220
                if (isRegistrationColor)
221
                {
222
                        tmp.setCmykColorF(1.0, 1.0, 1.0, 1.0);
223
                        tmp.setRegistrationColor(true);
224
                        name = "Registration";
225
                }
226
                else if ((altColorSpace->getMode() == csDeviceRGB) || (altColorSpace->getMode() == csCalRGB))
227
                {
228
                        double x = 1.0;
229
                        double comps[gfxColorMaxComps];
230
                        sepColorSpace->getFunc()->transform(&x, comps);
231
                        tmp.setRgbColorF(comps[0], comps[1], comps[2]);
232
                }
233
                else if ((altColorSpace->getMode() == csCalGray) || (altColorSpace->getMode() == csDeviceGray))
234
                {
235
                        double x = 1.0;
236
                        double comps[gfxColorMaxComps];
237
                        sepColorSpace->getFunc()->transform(&x, comps);
238
                        tmp.setCmykColorF(0.0, 0.0, 0.0, 1.0 - comps[0]);
239
                }
240
                else if (altColorSpace->getMode() == csLab)
241
                {
242
                        double x = 1.0;
243
                        double comps[gfxColorMaxComps];
244
                        sepColorSpace->getFunc()->transform(&x, comps);
245
                        tmp.setLabColor(comps[0], comps[1], comps[2]);
246
                }
247
                else
248
                {
249
                        GfxCMYK cmyk;
250
                        color_space->getCMYK(color, &cmyk);
251
                        double Cc = colToDbl(cmyk.c);
252
                        double Mc = colToDbl(cmyk.m);
253
                        double Yc = colToDbl(cmyk.y);
254
                        double Kc = colToDbl(cmyk.k);
255
                        tmp.setCmykColorF(Cc, Mc, Yc, Kc);
256
                }
257
                tmp.setSpotColor(true);
22592 jghali 258
 
22596 jghali 259
                fNam = m_doc->PageColors.tryAddColor(name, tmp);
260
                *shade = qRound(colToDbl(color->c[0]) * 100);
19590 jghali 261
        }
262
        else
263
        {
264
                GfxRGB rgb;
265
                color_space->getRGB(color, &rgb);
22212 jghali 266
                double Rc = colToDbl(rgb.r);
267
                double Gc = colToDbl(rgb.g);
268
                double Bc = colToDbl(rgb.b);
269
                tmp.setRgbColorF(Rc, Gc, Bc);
19590 jghali 270
                fNam = m_doc->PageColors.tryAddColor(namPrefix+tmp.name(), tmp);
271
        //      qDebug() << "update fill color other colorspace" << color_space->getMode() << "treating as rgb" << Rc << Gc << Bc;
272
        }
273
        if (fNam == namPrefix+tmp.name())
274
                m_importedColors->append(fNam);
275
        return fNam;
276
}
277
 
278
SlaOutputDev::SlaOutputDev(ScribusDoc* doc, QList<PageItem*> *Elements, QStringList *importedColors, int flags)
279
{
280
        m_doc = doc;
281
        m_Elements = Elements;
282
        pushGroup();
283
        m_importedColors = importedColors;
24374 jghali 284
        m_currColorStroke = "Black";
285
        m_currColorFill = "Black";
19590 jghali 286
        tmpSel = new Selection(m_doc, false);
287
        importerFlags = flags;
288
        currentLayer = m_doc->activeLayer();
289
        layersSetByOCG = false;
290
}
291
 
292
SlaOutputDev::~SlaOutputDev()
293
{
294
        m_groupStack.clear();
295
        tmpSel->clear();
296
        delete tmpSel;
297
        delete m_fontEngine;
298
}
299
 
300
/* get Actions not implemented by Poppler */
301
LinkAction* SlaOutputDev::SC_getAction(AnnotWidget *ano)
302
{
22527 craig 303
        LinkAction *linkAction = nullptr;
19590 jghali 304
        Object obj;
305
        Ref refa = ano->getRef();
22906 jghali 306
 
22154 jghali 307
        obj = xref->fetch(refa.num, refa.gen);
308
        if (obj.isDict())
309
        {
310
                Dict* adic = obj.getDict();
22906 jghali 311
                POPPLER_CONST_075 Object POPPLER_REF additionalActions = adic->lookupNF("A");
22154 jghali 312
                Object additionalActionsObject = additionalActions.fetch(pdfDoc->getXRef());
313
                if (additionalActionsObject.isDict())
314
                {
315
                        Object actionObject = additionalActionsObject.dictLookup("S");
316
                        if (actionObject.isName("ImportData"))
317
                        {
318
                                linkAction = new LinkImportData(&additionalActionsObject);
319
                        }
320
                        else if (actionObject.isName("SubmitForm"))
321
                        {
322
                                linkAction = new LinkSubmitForm(&additionalActionsObject);
323
                        }
324
                }
325
        }
19590 jghali 326
        return linkAction;
327
}
328
 
329
/* Replacement for the crippled Poppler function LinkAction* AnnotWidget::getAdditionalAction(AdditionalActionsType type) */
23478 jghali 330
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
331
std::unique_ptr<LinkAction> SlaOutputDev::SC_getAdditionalAction(const char *key, AnnotWidget *ano)
332
{
333
        std::unique_ptr<LinkAction> linkAction;
334
#else
19590 jghali 335
LinkAction* SlaOutputDev::SC_getAdditionalAction(const char *key, AnnotWidget *ano)
336
{
22527 craig 337
        LinkAction *linkAction = nullptr;
23478 jghali 338
#endif
19590 jghali 339
        Object obj;
340
        Ref refa = ano->getRef();
22154 jghali 341
 
342
        obj = xref->fetch(refa.num, refa.gen);
343
        if (obj.isDict())
344
        {
345
                Dict* adic = obj.getDict();
22906 jghali 346
                POPPLER_CONST_075 Object POPPLER_REF additionalActions = adic->lookupNF("AA");
22154 jghali 347
                Object additionalActionsObject = additionalActions.fetch(pdfDoc->getXRef());
348
                if (additionalActionsObject.isDict())
349
                {
350
                        Object actionObject = additionalActionsObject.dictLookup(key);
351
                        if (actionObject.isDict())
352
                                linkAction = LinkAction::parseAction(&actionObject, pdfDoc->getCatalog()->getBaseURI());
353
                }
354
        }
19590 jghali 355
        return linkAction;
356
}
357
 
358
GBool SlaOutputDev::annotations_callback(Annot *annota, void *user_data)
359
{
360
        SlaOutputDev *dev = (SlaOutputDev*)user_data;
361
        PDFRectangle *box = annota->getRect();
362
        double xCoor = dev->m_doc->currentPage()->xOffset() + box->x1 - dev->cropOffsetX;
363
        double yCoor = dev->m_doc->currentPage()->yOffset() + dev->m_doc->currentPage()->height() - box->y2 + dev->cropOffsetY;
364
        double width = box->x2 - box->x1;
365
        double height = box->y2 - box->y1;
366
        if (dev->rotate == 90)
367
        {
368
                xCoor = dev->m_doc->currentPage()->xOffset() - dev->cropOffsetX + box->y2;
369
                yCoor = dev->m_doc->currentPage()->yOffset() + dev->cropOffsetY + box->x1;
370
        }
371
        else if (dev->rotate == 180)
372
        {
373
                xCoor = dev->m_doc->currentPage()->xOffset() - dev->cropOffsetX + dev->m_doc->currentPage()->width() - box->x1;
374
                yCoor = dev->m_doc->currentPage()->yOffset() + dev->cropOffsetY + box->y2;
375
        }
376
        else if (dev->rotate == 270)
377
        {
378
                xCoor = dev->m_doc->currentPage()->xOffset() - dev->cropOffsetX + dev->m_doc->currentPage()->width() - box->y2;
379
                yCoor = dev->m_doc->currentPage()->yOffset() + dev->cropOffsetY + dev->m_doc->currentPage()->height() - box->x1;
380
        }
381
        bool retVal = true;
382
        if (annota->getType() == Annot::typeText)
383
                retVal = !dev->handleTextAnnot(annota, xCoor, yCoor, width, height);
384
        else if (annota->getType() == Annot::typeLink)
385
                retVal = !dev->handleLinkAnnot(annota, xCoor, yCoor, width, height);
386
        else if (annota->getType() == Annot::typeWidget)
387
                retVal = !dev->handleWidgetAnnot(annota, xCoor, yCoor, width, height);
388
        return retVal;
389
}
390
 
391
bool SlaOutputDev::handleTextAnnot(Annot* annota, double xCoor, double yCoor, double width, double height)
392
{
393
        AnnotText *anl = (AnnotText*)annota;
20561 jghali 394
        int z = m_doc->itemAdd(PageItem::TextFrame, PageItem::Rectangle, xCoor, yCoor, width, height, 0, CommonStrings::None, CommonStrings::None);
19590 jghali 395
        PageItem *ite = m_doc->Items->at(z);
396
        int flg = annota->getFlags();
397
        if (!(flg & 16))
398
                ite->setRotation(rotate, true);
399
        ite->ClipEdited = true;
400
        ite->FrameType = 3;
401
        ite->setFillEvenOdd(false);
23040 jghali 402
        ite->Clip = flattenPath(ite->PoLine, ite->Segments);
19590 jghali 403
        ite->ContourLine = ite->PoLine.copy();
404
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
405
        m_Elements->append(ite);
406
        if (m_groupStack.count() != 0)
407
        {
408
                m_groupStack.top().Items.append(ite);
409
                applyMask(ite);
410
        }
411
        ite->setIsAnnotation(true);
412
        ite->AutoName = false;
413
        ite->annotation().setType(Annotation::Text);
414
        ite->annotation().setActionType(Annotation::Action_None);
415
        ite->annotation().setAnOpen(anl->getOpen());
416
        QString iconName = UnicodeParsedString(anl->getIcon());
417
        if (iconName == "Note")
418
                ite->annotation().setIcon(Annotation::Icon_Note);
419
        else if (iconName == "Comment")
420
                ite->annotation().setIcon(Annotation::Icon_Comment);
421
        else if (iconName == "Key")
422
                ite->annotation().setIcon(Annotation::Icon_Key);
423
        else if (iconName == "Help")
424
                ite->annotation().setIcon(Annotation::Icon_Help);
425
        else if (iconName == "NewParagraph")
426
                ite->annotation().setIcon(Annotation::Icon_NewParagraph);
427
        else if (iconName == "Paragraph")
428
                ite->annotation().setIcon(Annotation::Icon_Paragraph);
429
        else if (iconName == "Insert")
430
                ite->annotation().setIcon(Annotation::Icon_Insert);
431
        else if (iconName == "Cross")
432
                ite->annotation().setIcon(Annotation::Icon_Cross);
433
        else if (iconName == "Circle")
434
                ite->annotation().setIcon(Annotation::Icon_Circle);
435
        else
436
                ite->annotation().setIcon(Annotation::Icon_Note);
437
        ite->setItemName( CommonStrings::itemName_TextAnnotation + QString("%1").arg(m_doc->TotalItems));
438
        ite->itemText.insertChars(UnicodeParsedString(annota->getContents()));
439
        ite->itemText.trim();
440
        return true;
441
}
442
 
443
bool SlaOutputDev::handleLinkAnnot(Annot* annota, double xCoor, double yCoor, double width, double height)
444
{
445
        AnnotLink *anl = (AnnotLink*)annota;
446
        LinkAction *act = anl->getAction();
447
        if (!act)
448
                return false;
449
        bool validLink = false;
450
        int pagNum = 0;
451
        int xco = 0;
452
        int yco = 0;
453
        QString fileName = "";
454
        if (act->getKind() == actionGoTo)
455
        {
22513 jghali 456
                LinkGoTo *gto = (LinkGoTo*) act;
457
                POPPLER_CONST LinkDest *dst = gto->getDest();
19590 jghali 458
                if (dst)
459
                {
460
                        if (dst->getKind() == destXYZ)
461
                        {
462
                                if (dst->isPageRef())
463
                                {
464
                                        Ref dstr = dst->getPageRef();
22975 jghali 465
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 76, 0)
466
                                        pagNum = pdfDoc->findPage(dstr);
467
#else
19590 jghali 468
                                        pagNum = pdfDoc->findPage(dstr.num, dstr.gen);
22975 jghali 469
#endif
19590 jghali 470
                                }
471
                                else
472
                                        pagNum = dst->getPageNum();
473
                                xco = dst->getLeft();
474
                                yco = dst->getTop();
475
                                validLink = true;
476
                        }
477
                }
478
                else
479
                {
22513 jghali 480
                        POPPLER_CONST GooString *ndst = gto->getNamedDest();
19590 jghali 481
                        if (ndst)
482
                        {
23478 jghali 483
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
484
                                std::unique_ptr<LinkDest> dstn = pdfDoc->findDest(ndst);
485
#else
19590 jghali 486
                                LinkDest *dstn = pdfDoc->findDest(ndst);
23478 jghali 487
#endif
19590 jghali 488
                                if (dstn)
489
                                {
490
                                        if (dstn->getKind() == destXYZ)
491
                                        {
492
                                                if (dstn->isPageRef())
493
                                                {
494
                                                        Ref dstr = dstn->getPageRef();
22975 jghali 495
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 76, 0)
496
                                                        pagNum = pdfDoc->findPage(dstr);
497
#else
19590 jghali 498
                                                        pagNum = pdfDoc->findPage(dstr.num, dstr.gen);
22975 jghali 499
#endif
19590 jghali 500
                                                }
501
                                                else
502
                                                        pagNum = dstn->getPageNum();
503
                                                xco = dstn->getLeft();
504
                                                yco = dstn->getTop();
505
                                                validLink = true;
506
                                        }
507
                                }
508
                        }
509
                }
510
        }
511
        else if (act->getKind() == actionGoToR)
512
        {
513
                LinkGoToR *gto = (LinkGoToR*)act;
514
                fileName = UnicodeParsedString(gto->getFileName());
22513 jghali 515
                POPPLER_CONST LinkDest *dst = gto->getDest();
19590 jghali 516
                if (dst)
517
                {
518
                        if (dst->getKind() == destXYZ)
519
                        {
520
                                pagNum = dst->getPageNum();
521
                                xco = dst->getLeft();
522
                                yco = dst->getTop();
523
                                validLink = true;
524
                        }
525
                }
526
                else
527
                {
22513 jghali 528
                        POPPLER_CONST GooString *ndst = gto->getNamedDest();
19590 jghali 529
                        if (ndst)
530
                        {
23478 jghali 531
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
532
                                std::unique_ptr<LinkDest> dstn = pdfDoc->findDest(ndst);
533
#else
19590 jghali 534
                                LinkDest *dstn = pdfDoc->findDest(ndst);
23478 jghali 535
#endif
19590 jghali 536
                                if (dstn)
537
                                {
538
                                        if (dstn->getKind() == destXYZ)
539
                                        {
540
                                                pagNum = dstn->getPageNum();
541
                                                xco = dstn->getLeft();
542
                                                yco = dstn->getTop();
543
                                                validLink = true;
544
                                        }
545
                                }
546
                        }
547
                }
548
        }
549
        else if (act->getKind() == actionURI)
550
        {
551
                LinkURI *gto = (LinkURI*)act;
552
                validLink = true;
553
                fileName = UnicodeParsedString(gto->getURI());
554
        }
555
        if (validLink)
556
        {
20561 jghali 557
                int z = m_doc->itemAdd(PageItem::TextFrame, PageItem::Rectangle, xCoor, yCoor, width, height, 0, CommonStrings::None, CommonStrings::None);
19590 jghali 558
                PageItem *ite = m_doc->Items->at(z);
559
                int flg = annota->getFlags();
560
                if (!(flg & 16))
561
                        ite->setRotation(rotate, true);
562
                ite->ClipEdited = true;
563
                ite->FrameType = 3;
564
                ite->setFillEvenOdd(false);
23040 jghali 565
                ite->Clip = flattenPath(ite->PoLine, ite->Segments);
19590 jghali 566
                ite->ContourLine = ite->PoLine.copy();
567
                ite->setTextFlowMode(PageItem::TextFlowDisabled);
568
                m_Elements->append(ite);
569
                if (m_groupStack.count() != 0)
570
                {
571
                        m_groupStack.top().Items.append(ite);
572
                        applyMask(ite);
573
                }
574
                ite->setIsAnnotation(true);
575
                ite->AutoName = false;
576
                if (act->getKind() == actionGoTo)
577
                {
21458 jghali 578
                        ite->annotation().setZiel((pagNum > 0) ? (pagNum - 1) : (m_actPage - 1));
19590 jghali 579
                        ite->annotation().setAction(QString("%1 %2").arg(xco).arg(yco));
580
                        ite->annotation().setActionType(2);
581
                }
582
                else if (act->getKind() == actionGoToR)
583
                {
21458 jghali 584
                        ite->annotation().setZiel((pagNum > 0) ? (pagNum - 1) : (m_actPage - 1));
19590 jghali 585
                        ite->annotation().setExtern(fileName);
586
                        ite->annotation().setAction(QString("%1 %2").arg(xco).arg(yco));
587
                        ite->annotation().setActionType(9);
588
                }
589
                else if (act->getKind() == actionURI)
590
                {
591
                        ite->annotation().setAction("");
592
                        ite->annotation().setExtern(fileName);
593
                        ite->annotation().setActionType(8);
594
                }
595
                ite->annotation().setType(Annotation::Link);
596
                ite->setItemName( CommonStrings::itemName_LinkAnnotation + QString("%1").arg(m_doc->TotalItems));
597
        }
598
        return validLink;
599
}
600
 
601
bool SlaOutputDev::handleWidgetAnnot(Annot* annota, double xCoor, double yCoor, double width, double height)
602
{
603
        bool retVal = false;
604
        bool found = false;
605
 
606
        if (!m_formWidgets)
607
                return false;
608
 
609
        int formcount = m_formWidgets->getNumWidgets();
610
        for (int i = 0; i < formcount; ++i)
611
        {
612
                FormWidget *fm = m_formWidgets->getWidget(i);
613
                if (!fm)
614
                        continue;
615
                AnnotWidget *ano = fm->getWidgetAnnotation();
616
                if (!ano)
617
                        continue;
618
                if (ano != (AnnotWidget*) annota)
619
                        continue;
620
                found = true;
621
                int wtyp = -1;
622
                if (fm->getType() == formButton)
623
                {
624
                        FormWidgetButton *btn = (FormWidgetButton*)fm;
625
                        if (btn)
626
                        {
627
                                if (btn->getButtonType() == formButtonCheck)
628
                                {
629
                                        wtyp = Annotation::Checkbox;
630
                                        retVal = true;
631
                                }
632
                                else if (btn->getButtonType() == formButtonPush)
633
                                {
634
                                        wtyp = Annotation::Button;
635
                                        retVal = true;
636
                                }
637
                                else if (btn->getButtonType() == formButtonRadio)
638
                                {
639
                                        wtyp = Annotation::RadioButton;
640
                                        retVal = true;
641
                                }
642
                        }
643
                }
644
                else if (fm->getType() == formText)
645
                {
646
                        wtyp = Annotation::Textfield;
647
                        retVal = true;
648
                }
649
                else if (fm->getType() == formChoice)
650
                {
651
                        FormWidgetChoice *btn = (FormWidgetChoice*)fm;
652
                        if (btn)
653
                        {
654
                                if (btn->isCombo())
655
                                {
656
                                        wtyp = Annotation::Combobox;
657
                                        retVal = true;
658
                                }
659
                                else if (btn->isListBox())
660
                                {
661
                                        wtyp = Annotation::Listbox;
662
                                        retVal = true;
663
                                }
664
                        }
665
                }
666
                if (retVal)
667
                {
668
                        AnnotAppearanceCharacs *achar = ano->getAppearCharacs();
669
                        bool fgFound = false;
670
                        bool bgFound = false;
671
                        if (achar)
672
                        {
22513 jghali 673
                                POPPLER_CONST AnnotColor *bgCol = achar->getBackColor();
19590 jghali 674
                                if (bgCol)
675
                                {
676
                                        bgFound = true;
24374 jghali 677
                                        m_currColorFill = getAnnotationColor(bgCol);
19590 jghali 678
                                }
679
                                else
24374 jghali 680
                                        m_currColorFill = CommonStrings::None;
22513 jghali 681
                                POPPLER_CONST AnnotColor *fgCol = achar->getBorderColor();
19590 jghali 682
                                if (fgCol)
683
                                {
684
                                        fgFound = true;
24374 jghali 685
                                        m_currColorStroke = getAnnotationColor(fgCol);
19590 jghali 686
                                }
687
                                else
688
                                {
689
                                        fgCol = achar->getBackColor();
690
                                        if (fgCol)
24374 jghali 691
                                                m_currColorStroke = getAnnotationColor(fgCol);
19590 jghali 692
                                        else
24374 jghali 693
                                                m_currColorStroke = CommonStrings::None;
19590 jghali 694
                                }
695
                        }
24374 jghali 696
                        QString m_currColorText = "Black";
19590 jghali 697
                        double fontSize = 12;
698
                        QString fontName = "";
699
                        QString itemText = "";
700
                        AnnotAppearance *apa = annota->getAppearStreams();
701
                        if (apa || !achar)
702
                        {
24374 jghali 703
                                AnoOutputDev *annotOutDev = new AnoOutputDev(m_doc, m_importedColors);
704
                                Gfx *gfx = new Gfx(pdfDoc, annotOutDev, pdfDoc->getPage(m_actPage)->getResourceDict(), annota->getRect(), nullptr);
19590 jghali 705
                                ano->draw(gfx, false);
706
                                if (!bgFound)
24374 jghali 707
                                        m_currColorFill = annotOutDev->currColorFill;
19590 jghali 708
                                if (!fgFound)
24374 jghali 709
                                        m_currColorStroke = annotOutDev->currColorStroke;
710
                                m_currColorText = annotOutDev->currColorText;
711
                                fontSize = annotOutDev->fontSize;
712
                                fontName = UnicodeParsedString(annotOutDev->fontName);
713
                                itemText = UnicodeParsedString(annotOutDev->itemText);
19590 jghali 714
                                delete gfx;
24374 jghali 715
                                delete annotOutDev;
19590 jghali 716
                        }
24374 jghali 717
                        int z = m_doc->itemAdd(PageItem::TextFrame, PageItem::Rectangle, xCoor, yCoor, width, height, 0, m_currColorFill, CommonStrings::None);
19590 jghali 718
                        PageItem *ite = m_doc->Items->at(z);
719
                        int flg = annota->getFlags();
720
                        if (!(flg & 16))
721
                                ite->setRotation(rotate, true);
722
                        ite->ClipEdited = true;
723
                        ite->FrameType = 3;
724
                        ite->setFillEvenOdd(false);
23040 jghali 725
                        ite->Clip = flattenPath(ite->PoLine, ite->Segments);
19590 jghali 726
                        ite->ContourLine = ite->PoLine.copy();
727
                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
728
                        m_Elements->append(ite);
729
                        if (m_groupStack.count() != 0)
730
                        {
731
                                m_groupStack.top().Items.append(ite);
732
                                applyMask(ite);
733
                        }
734
                        ite->setIsAnnotation(true);
735
                        ite->AutoName = false;
736
                        AnnotBorder *brd = annota->getBorder();
737
                        if (brd)
738
                        {
739
                                int bsty = brd->getStyle();
740
                                if (bsty == AnnotBorder::borderDashed)
741
                                        bsty = 1;
742
                                else if (bsty == AnnotBorder::borderBeveled)
743
                                        bsty = 3;
744
                                else if (bsty == AnnotBorder::borderInset)
745
                                        bsty = 4;
746
                                else if (bsty == AnnotBorder::borderUnderlined)
747
                                        bsty = 2;
22748 jghali 748
                                ite->annotation().setBorderStyle(bsty);
24374 jghali 749
                                ite->annotation().setBorderColor(m_currColorStroke);
22748 jghali 750
                                ite->annotation().setBorderWidth(qRound(brd->getWidth()));
19590 jghali 751
                        }
752
                        else
753
                        {
22748 jghali 754
                                ite->annotation().setBorderStyle(0);
19590 jghali 755
                                ite->annotation().setBorderColor(CommonStrings::None);
22748 jghali 756
                                ite->annotation().setBorderWidth(0);
19590 jghali 757
                        }
758
                        QString tmTxt = "";
759
                        tmTxt = UnicodeParsedString(fm->getPartialName());
760
                        if (!tmTxt.isEmpty())
761
                                ite->setItemName(tmTxt);
762
                        tmTxt = "";
763
                        tmTxt = UnicodeParsedString(fm->getAlternateUiName());
764
                        if (!tmTxt.isEmpty())
765
                                ite->annotation().setToolTip(tmTxt);
766
                        tmTxt = "";
767
                        if (achar)
768
                        {
769
                                tmTxt = UnicodeParsedString(achar->getRolloverCaption());
770
                                if (!tmTxt.isEmpty())
771
                                        ite->annotation().setRollOver(tmTxt);
772
                                tmTxt = "";
773
                                tmTxt = UnicodeParsedString(achar->getAlternateCaption());
774
                                if (!tmTxt.isEmpty())
775
                                        ite->annotation().setDown(tmTxt);
776
                        }
777
                        ite->annotation().setType(wtyp);
778
                        ite->annotation().setFlag(0);
779
                        if (flg & 2)
780
                                ite->annotation().setVis(1);
781
                        if (flg & 32)
782
                                ite->annotation().setVis(3);
783
                        if (wtyp == Annotation::Button)
784
                        {
24374 jghali 785
                                ite->setFillColor(m_currColorFill);
19590 jghali 786
                                if (achar)
787
                                        ite->itemText.insertChars(UnicodeParsedString(achar->getNormalCaption()));
788
                                else
789
                                        ite->itemText.insertChars(itemText);
24374 jghali 790
                                applyTextStyle(ite, fontName, m_currColorText, fontSize);
19590 jghali 791
                                ite->annotation().addToFlag(Annotation::Flag_PushButton);
792
                                FormWidgetButton *btn = (FormWidgetButton*)fm;
793
                                if (!btn->isReadOnly())
794
                                        ite->annotation().addToFlag(Annotation::Flag_Edit);
795
                                handleActions(ite, ano);
796
                        }
797
                        else if (wtyp == Annotation::Textfield)
798
                        {
799
                                FormWidgetText *btn = (FormWidgetText*)fm;
800
                                if (btn)
801
                                {
802
                                        ite->itemText.insertChars(UnicodeParsedString(btn->getContent()));
24374 jghali 803
                                        applyTextStyle(ite, fontName, m_currColorText, fontSize);
19590 jghali 804
                                        ite->itemText.trim();
805
                                        if (btn->isMultiline())
806
                                                ite->annotation().addToFlag(Annotation::Flag_Multiline);
807
                                        if (btn->isPassword())
808
                                                ite->annotation().addToFlag(Annotation::Flag_Password);
809
                                        if (btn->noSpellCheck())
810
                                                ite->annotation().addToFlag(Annotation::Flag_DoNotSpellCheck);
811
                                        if (btn->noScroll())
812
                                                ite->annotation().addToFlag(Annotation::Flag_DoNotScroll);
813
                                        int mxLen = btn->getMaxLen();
814
                                        if (mxLen > 0)
815
                                                ite->annotation().setMaxChar(mxLen);
816
                                        else
817
                                                ite->annotation().setMaxChar(-1);
818
                                        if (!btn->isReadOnly())
819
                                                ite->annotation().addToFlag(Annotation::Flag_Edit);
820
                                        handleActions(ite, ano);
821
                                }
822
                        }
823
                        else if (wtyp == Annotation::Checkbox)
824
                        {
825
                                FormWidgetButton *btn = (FormWidgetButton*)fm;
826
                                if (btn)
827
                                {
828
                                        ite->annotation().setIsChk(btn->getState());
829
                                        ite->annotation().setCheckState(ite->annotation().IsChk());
830
                                        handleActions(ite, ano);
831
                                        if (itemText == "4")
832
                                                ite->annotation().setChkStil(0);
833
                                        else if (itemText == "5")
834
                                                ite->annotation().setChkStil(1);
835
                                        else if (itemText == "F")
836
                                                ite->annotation().setChkStil(2);
837
                                        else if (itemText == "l")
838
                                                ite->annotation().setChkStil(3);
839
                                        else if (itemText == "H")
840
                                                ite->annotation().setChkStil(4);
841
                                        else if (itemText == "n")
842
                                                ite->annotation().setChkStil(5);
843
                                        else
844
                                                ite->annotation().setChkStil(0);
845
                                        if (!btn->isReadOnly())
846
                                                ite->annotation().addToFlag(Annotation::Flag_Edit);
847
                                }
848
                        }
849
                        else if ((wtyp == Annotation::Combobox) || (wtyp == Annotation::Listbox))
850
                        {
851
                                FormWidgetChoice *btn = (FormWidgetChoice*)fm;
852
                                if (btn)
853
                                {
854
                                        if (wtyp == 5)
855
                                                ite->annotation().addToFlag(Annotation::Flag_Combo);
856
                                        int co = btn->getNumChoices();
857
                                        if (co > 0)
858
                                        {
859
                                                QString inh = UnicodeParsedString(btn->getChoice(0));
860
                                                for (int a = 1; a < co; a++)
861
                                                {
862
                                                        inh += "\n" + UnicodeParsedString(btn->getChoice(a));
863
                                                }
864
                                                ite->itemText.insertChars(inh);
865
                                        }
24374 jghali 866
                                        applyTextStyle(ite, fontName, m_currColorText, fontSize);
19590 jghali 867
                                        if (!btn->isReadOnly())
868
                                                ite->annotation().addToFlag(Annotation::Flag_Edit);
869
                                        handleActions(ite, ano);
870
                                }
871
                        }
872
                        else if (wtyp == Annotation::RadioButton)
873
                        {
874
                                FormWidgetButton *btn = (FormWidgetButton*)fm;
875
                                if (btn)
876
                                {
877
                                        ite->setItemName( CommonStrings::itemName_RadioButton + QString("%1").arg(m_doc->TotalItems));
878
                                        ite->annotation().setIsChk(btn->getState());
879
                                        ite->annotation().setCheckState(ite->annotation().IsChk());
880
                                        handleActions(ite, ano);
881
                                        m_radioButtons.insert(annota->getRef().num, ite);
882
                                }
883
                        }
884
                }
885
                break;
886
        }
887
        if (!found)
888
        {
889
                Object obj1;
890
                Ref refa = annota->getRef();
22154 jghali 891
                obj1 = xref->fetch(refa.num, refa.gen);
892
                if (obj1.isDict())
893
                {
894
                        Dict* dict = obj1.getDict();
895
                        Object obj2 = dict->lookup("Kids");
896
                        //childs
897
                        if (obj2.isArray())
898
                        {
899
                                // Load children
900
                                QList<int> radList;
901
                                for (int i = 0; i < obj2.arrayGetLength(); i++)
902
                                {
22906 jghali 903
                                        POPPLER_CONST_075 Object POPPLER_REF childRef = obj2.arrayGetNF(i);
22154 jghali 904
                                        if (!childRef.isRef())
905
                                                continue;
906
                                        Object childObj = obj2.arrayGet(i);
907
                                        if (!childObj.isDict())
908
                                                continue;
909
                                        const Ref ref = childRef.getRef();
910
                                        radList.append(ref.num);
911
                                }
912
                                QString tmTxt = UnicodeParsedString(annota->getName());
913
                                m_radioMap.insert(tmTxt, radList);
914
                        }
915
                }
19590 jghali 916
        }
917
        return retVal;
918
}
919
 
22609 craig 920
void SlaOutputDev::applyTextStyle(PageItem* ite, const QString& fontName, const QString& textColor, double fontSize)
19590 jghali 921
{
922
        CharStyle newStyle;
923
        newStyle.setFillColor(textColor);
924
        newStyle.setFontSize(fontSize * 10);
925
        if (!fontName.isEmpty())
926
        {
927
                SCFontsIterator it(*m_doc->AllFonts);
928
                for ( ; it.hasNext() ; it.next())
929
                {
930
                        ScFace& face(it.current());
931
                        if ((face.psName() == fontName) && (face.usable()) && (face.type() == ScFace::TTF))
932
                        {
933
                                newStyle.setFont(face);
934
                                break;
935
                        }
22609 craig 936
                        if ((face.family() == fontName) && (face.usable()) && (face.type() == ScFace::TTF))
19590 jghali 937
                        {
938
                                newStyle.setFont(face);
939
                                break;
940
                        }
22609 craig 941
                        if ((face.scName() == fontName) && (face.usable()) && (face.type() == ScFace::TTF))
19590 jghali 942
                        {
943
                                newStyle.setFont(face);
944
                                break;
945
                        }
946
                }
947
        }
948
        ParagraphStyle dstyle(ite->itemText.defaultStyle());
949
        dstyle.charStyle().applyCharStyle(newStyle);
950
        ite->itemText.setDefaultStyle(dstyle);
951
        ite->itemText.applyCharStyle(0, ite->itemText.length(), newStyle);
952
        ite->invalid = true;
953
}
954
 
955
void SlaOutputDev::handleActions(PageItem* ite, AnnotWidget *ano)
956
{
957
        LinkAction *Lact = ano->getAction();
958
        if (Lact)
959
        {
960
                if (Lact->getKind() == actionJavaScript)
961
                {
962
                        LinkJavaScript *jsa = (LinkJavaScript*)Lact;
963
                        if (jsa->isOk())
964
                        {
965
                                ite->annotation().setActionType(1);
966
                                ite->annotation().setAction(UnicodeParsedString(jsa->getScript()));
967
                        }
968
                }
969
                else if (Lact->getKind() == actionGoTo)
970
                {
971
                        int pagNum = 0;
972
                        int xco = 0;
973
                        int yco = 0;
974
                        LinkGoTo *gto = (LinkGoTo*)Lact;
22513 jghali 975
                        POPPLER_CONST LinkDest *dst = gto->getDest();
19590 jghali 976
                        if (dst)
977
                        {
978
                                if (dst->getKind() == destXYZ)
979
                                {
980
                                        if (dst->isPageRef())
981
                                        {
982
                                                Ref dstr = dst->getPageRef();
22975 jghali 983
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 76, 0)
984
                                                pagNum = pdfDoc->findPage(dstr);
985
#else
19590 jghali 986
                                                pagNum = pdfDoc->findPage(dstr.num, dstr.gen);
22975 jghali 987
#endif
19590 jghali 988
                                        }
989
                                        else
990
                                                pagNum = dst->getPageNum();
991
                                        xco = dst->getLeft();
992
                                        yco = dst->getTop();
21458 jghali 993
                                        ite->annotation().setZiel((pagNum > 0) ? (pagNum - 1) : (m_actPage - 1));
19590 jghali 994
                                        ite->annotation().setAction(QString("%1 %2").arg(xco).arg(yco));
995
                                        ite->annotation().setActionType(2);
996
                                }
997
                        }
998
                        else
999
                        {
22513 jghali 1000
                                POPPLER_CONST GooString *ndst = gto->getNamedDest();
19590 jghali 1001
                                if (ndst)
1002
                                {
23478 jghali 1003
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1004
                                        std::unique_ptr<LinkDest> dstn = pdfDoc->findDest(ndst);
1005
#else
19590 jghali 1006
                                        LinkDest *dstn = pdfDoc->findDest(ndst);
23478 jghali 1007
#endif
19590 jghali 1008
                                        if (dstn)
1009
                                        {
1010
                                                if (dstn->getKind() == destXYZ)
1011
                                                {
1012
                                                        if (dstn->isPageRef())
1013
                                                        {
1014
                                                                Ref dstr = dstn->getPageRef();
22975 jghali 1015
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 76, 0)
1016
                                                                pagNum = pdfDoc->findPage(dstr);
1017
#else
19590 jghali 1018
                                                                pagNum = pdfDoc->findPage(dstr.num, dstr.gen);
22975 jghali 1019
#endif
19590 jghali 1020
                                                        }
1021
                                                        else
1022
                                                                pagNum = dstn->getPageNum();
1023
                                                        xco = dstn->getLeft();
1024
                                                        yco = dstn->getTop();
21458 jghali 1025
                                                        ite->annotation().setZiel((pagNum > 0) ? (pagNum - 1) : (m_actPage - 1));
19590 jghali 1026
                                                        ite->annotation().setAction(QString("%1 %2").arg(xco).arg(yco));
1027
                                                        ite->annotation().setActionType(2);
1028
                                                }
1029
                                        }
1030
                                }
1031
                        }
1032
                }
1033
                else if (Lact->getKind() == actionGoToR)
1034
                {
1035
                        int pagNum = 0;
1036
                        int xco = 0;
1037
                        int yco = 0;
1038
                        LinkGoToR *gto = (LinkGoToR*)Lact;
1039
                        QString fileName = UnicodeParsedString(gto->getFileName());
22513 jghali 1040
                        POPPLER_CONST LinkDest *dst = gto->getDest();
19590 jghali 1041
                        if (dst)
1042
                        {
1043
                                if (dst->getKind() == destXYZ)
1044
                                {
1045
                                        pagNum = dst->getPageNum();
1046
                                        xco = dst->getLeft();
1047
                                        yco = dst->getTop();
21458 jghali 1048
                                        ite->annotation().setZiel((pagNum > 0) ? (pagNum - 1) : (m_actPage - 1));
19590 jghali 1049
                                        ite->annotation().setExtern(fileName);
1050
                                        ite->annotation().setAction(QString("%1 %2").arg(xco).arg(yco));
1051
                                        ite->annotation().setActionType(9);
1052
                                }
1053
                        }
1054
                        else
1055
                        {
22513 jghali 1056
                                POPPLER_CONST GooString *ndst = gto->getNamedDest();
19590 jghali 1057
                                if (ndst)
1058
                                {
23478 jghali 1059
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1060
                                        std::unique_ptr<LinkDest> dstn = pdfDoc->findDest(ndst);
1061
#else
19590 jghali 1062
                                        LinkDest *dstn = pdfDoc->findDest(ndst);
23478 jghali 1063
#endif
19590 jghali 1064
                                        if (dstn)
1065
                                        {
1066
                                                if (dstn->getKind() == destXYZ)
1067
                                                {
1068
                                                        pagNum = dstn->getPageNum();
1069
                                                        xco = dstn->getLeft();
1070
                                                        yco = dstn->getTop();
21458 jghali 1071
                                                        ite->annotation().setZiel((pagNum > 0) ? (pagNum - 1) : (m_actPage - 1));
19590 jghali 1072
                                                        ite->annotation().setExtern(fileName);
1073
                                                        ite->annotation().setAction(QString("%1 %2").arg(xco).arg(yco));
1074
                                                        ite->annotation().setActionType(9);
1075
                                                }
1076
                                        }
1077
                                }
1078
                        }
1079
                }
1080
                else if (Lact->getKind() == actionUnknown)
1081
                {
1082
                        LinkUnknown *uno = (LinkUnknown*)Lact;
1083
                        QString actString = UnicodeParsedString(uno->getAction());
1084
                        if (actString == "ResetForm")
1085
                        {
1086
                                ite->annotation().setActionType(4);
1087
                        }
1088
                        else
1089
                        {
1090
                                LinkAction* scact = SC_getAction(ano);
1091
                                if (scact)
1092
                                {
1093
                                        if (actString == "ImportData")
1094
                                        {
1095
                                                LinkImportData *impo = (LinkImportData*)scact;
1096
                                                if (impo->isOk())
1097
                                                {
1098
                                                        ite->annotation().setActionType(5);
1099
                                                        ite->annotation().setAction(UnicodeParsedString(impo->getFileName()));
1100
                                                }
1101
                                        }
1102
                                        else if (actString == "SubmitForm")
1103
                                        {
1104
                                                LinkSubmitForm *impo = (LinkSubmitForm*)scact;
1105
                                                if (impo->isOk())
1106
                                                {
1107
                                                        ite->annotation().setActionType(3);
1108
                                                        ite->annotation().setAction(UnicodeParsedString(impo->getFileName()));
1109
                                                        int fl = impo->getFlags();
1110
                                                        if (fl == 0)
1111
                                                                ite->annotation().setHTML(0);
1112
                                                        else if (fl == 4)
1113
                                                                ite->annotation().setHTML(1);
1114
                                                        else if (fl == 64)
1115
                                                                ite->annotation().setHTML(2);
1116
                                                        else if (fl == 512)
1117
                                                                ite->annotation().setHTML(3);
1118
                                                }
1119
                                        }
1120
                                }
1121
                        }
1122
                }
1123
                else if (Lact->getKind() == actionNamed)
1124
                {
1125
                        LinkNamed *uno = (LinkNamed*)Lact;
1126
                        ite->annotation().setActionType(10);
1127
                        ite->annotation().setAction(UnicodeParsedString(uno->getName()));
1128
                }
1129
                else
1130
                        qDebug() << "Found unsupported Action of type" << Lact->getKind();
1131
        }
23478 jghali 1132
        auto Aact = SC_getAdditionalAction("D", ano);
19590 jghali 1133
        if (Aact)
1134
        {
1135
                if (Aact->getKind() == actionJavaScript)
1136
                {
23478 jghali 1137
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1138
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1139
#else
1140
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1141
#endif
19590 jghali 1142
                        if (jsa->isOk())
1143
                        {
1144
                                ite->annotation().setD_act(UnicodeParsedString(jsa->getScript()));
1145
                                ite->annotation().setAAact(true);
1146
                        }
1147
                }
23478 jghali 1148
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1149
                Aact.reset();
1150
#else
22527 craig 1151
                Aact = nullptr;
23478 jghali 1152
#endif
19590 jghali 1153
        }
1154
        Aact = SC_getAdditionalAction("E", ano);
1155
        if (Aact)
1156
        {
1157
                if (Aact->getKind() == actionJavaScript)
1158
                {
23478 jghali 1159
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1160
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1161
#else
1162
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1163
#endif
19590 jghali 1164
                        if (jsa->isOk())
1165
                        {
1166
                                ite->annotation().setE_act(UnicodeParsedString(jsa->getScript()));
1167
                                ite->annotation().setAAact(true);
1168
                        }
1169
                }
23478 jghali 1170
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1171
                Aact.reset();
1172
#else
22527 craig 1173
                Aact = nullptr;
23478 jghali 1174
#endif
19590 jghali 1175
        }
1176
        Aact = SC_getAdditionalAction("X", ano);
1177
        if (Aact)
1178
        {
1179
                if (Aact->getKind() == actionJavaScript)
1180
                {
23478 jghali 1181
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1182
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1183
#else
1184
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1185
#endif
19590 jghali 1186
                        if (jsa->isOk())
1187
                        {
1188
                                ite->annotation().setX_act(UnicodeParsedString(jsa->getScript()));
1189
                                ite->annotation().setAAact(true);
1190
                        }
1191
                }
23478 jghali 1192
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1193
                Aact.reset();
1194
#else
22527 craig 1195
                Aact = nullptr;
23478 jghali 1196
#endif
19590 jghali 1197
        }
1198
        Aact = SC_getAdditionalAction("Fo", ano);
1199
        if (Aact)
1200
        {
1201
                if (Aact->getKind() == actionJavaScript)
1202
                {
23478 jghali 1203
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1204
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1205
#else
1206
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1207
#endif
19590 jghali 1208
                        if (jsa->isOk())
1209
                        {
1210
                                ite->annotation().setFo_act(UnicodeParsedString(jsa->getScript()));
1211
                                ite->annotation().setAAact(true);
1212
                        }
1213
                }
23478 jghali 1214
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1215
                Aact.reset();
1216
#else
22527 craig 1217
                Aact = nullptr;
23478 jghali 1218
#endif
19590 jghali 1219
        }
1220
        Aact = SC_getAdditionalAction("Bl", ano);
1221
        if (Aact)
1222
        {
1223
                if (Aact->getKind() == actionJavaScript)
1224
                {
23478 jghali 1225
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1226
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1227
#else
1228
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1229
#endif
19590 jghali 1230
                        if (jsa->isOk())
1231
                        {
1232
                                ite->annotation().setBl_act(UnicodeParsedString(jsa->getScript()));
1233
                                ite->annotation().setAAact(true);
1234
                        }
1235
                }
23478 jghali 1236
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1237
                Aact.reset();
1238
#else
22527 craig 1239
                Aact = nullptr;
23478 jghali 1240
#endif
19590 jghali 1241
        }
1242
        Aact = SC_getAdditionalAction("C", ano);
1243
        if (Aact)
1244
        {
1245
                if (Aact->getKind() == actionJavaScript)
1246
                {
23478 jghali 1247
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1248
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1249
#else
1250
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1251
#endif
19590 jghali 1252
                        if (jsa->isOk())
1253
                        {
1254
                                ite->annotation().setC_act(UnicodeParsedString(jsa->getScript()));
1255
                                ite->annotation().setAAact(true);
1256
                        }
1257
                }
23478 jghali 1258
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1259
                Aact.reset();
1260
#else
22527 craig 1261
                Aact = nullptr;
23478 jghali 1262
#endif
19590 jghali 1263
        }
1264
        Aact = SC_getAdditionalAction("F", ano);
1265
        if (Aact)
1266
        {
1267
                if (Aact->getKind() == actionJavaScript)
1268
                {
23478 jghali 1269
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1270
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1271
#else
1272
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1273
#endif
19590 jghali 1274
                        if (jsa->isOk())
1275
                        {
1276
                                ite->annotation().setF_act(UnicodeParsedString(jsa->getScript()));
1277
                                ite->annotation().setAAact(true);
1278
                                ite->annotation().setFormat(5);
1279
                        }
1280
                }
23478 jghali 1281
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1282
                Aact.reset();
1283
#else
22527 craig 1284
                Aact = nullptr;
23478 jghali 1285
#endif
19590 jghali 1286
        }
1287
        Aact = SC_getAdditionalAction("K", ano);
1288
        if (Aact)
1289
        {
1290
                if (Aact->getKind() == actionJavaScript)
1291
                {
23478 jghali 1292
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1293
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1294
#else
1295
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1296
#endif
19590 jghali 1297
                        if (jsa->isOk())
1298
                        {
1299
                                ite->annotation().setK_act(UnicodeParsedString(jsa->getScript()));
1300
                                ite->annotation().setAAact(true);
1301
                                ite->annotation().setFormat(5);
1302
                        }
1303
                }
23478 jghali 1304
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1305
                Aact.reset();
1306
#else
22527 craig 1307
                Aact = nullptr;
23478 jghali 1308
#endif
19590 jghali 1309
        }
1310
        Aact = SC_getAdditionalAction("V", ano);
1311
        if (Aact)
1312
        {
1313
                if (Aact->getKind() == actionJavaScript)
1314
                {
23478 jghali 1315
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1316
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact.get();
1317
#else
1318
                        LinkJavaScript *jsa = (LinkJavaScript*) Aact;
1319
#endif
19590 jghali 1320
                        if (jsa->isOk())
1321
                        {
1322
                                ite->annotation().setV_act(UnicodeParsedString(jsa->getScript()));
1323
                                ite->annotation().setAAact(true);
1324
                        }
1325
                }
23478 jghali 1326
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 86, 0)
1327
                Aact.reset();
1328
#else
22527 craig 1329
                Aact = nullptr;
23478 jghali 1330
#endif
19590 jghali 1331
        }
1332
}
1333
 
1334
void SlaOutputDev::startDoc(PDFDoc *doc, XRef *xrefA, Catalog *catA)
1335
{
1336
        xref = xrefA;
1337
        catalog = catA;
1338
        pdfDoc = doc;
1339
        updateGUICounter = 0;
23429 jghali 1340
#if POPPLER_ENCODED_VERSION >= POPPLER_VERSION_ENCODE(0, 84, 0)
23431 jghali 1341
        m_fontEngine = new SplashFontEngine(true, false, false, true);
23479 jghali 1342
#else
23431 jghali 1343
        m_fontEngine = new SplashFontEngine(globalParams->getEnableFreeType(), false, false, true);
19590 jghali 1344
#endif
1345
}
1346
 
19595 jghali 1347
void SlaOutputDev::startPage(int pageNum, GfxState *, XRef *)
19590 jghali 1348
{
1349
        m_formWidgets = pdfDoc->getPage(pageNum)->getFormWidgets();
1350
        m_radioMap.clear();
1351
        m_radioButtons.clear();
1352
        m_actPage = pageNum;
20011 fschmid 1353
        m_groupStack.clear();
1354
        pushGroup();
23536 jghali 1355
        m_currentClipPath = QPainterPath();
20011 fschmid 1356
        m_clipPaths.clear();
19590 jghali 1357
}
1358
 
1359
void SlaOutputDev::endPage()
1360
{
1361
        if (!m_radioMap.isEmpty())
1362
        {
22509 jghali 1363
                for (auto it = m_radioMap.begin(); it != m_radioMap.end(); ++it)
19590 jghali 1364
                {
1365
                        tmpSel->clear();
1366
                        QList<int> refList = it.value();
1367
                        for (int a = 0; a < refList.count(); a++)
1368
                        {
1369
                                if (m_radioButtons.contains(refList[a]))
1370
                                {
1371
                                        tmpSel->addItem(m_radioButtons[refList[a]], true);
1372
                                        m_Elements->removeAll(m_radioButtons[refList[a]]);
1373
                                }
1374
                        }
1375
                        if (!tmpSel->isEmpty())
1376
                        {
1377
                                PageItem *ite = m_doc->groupObjectsSelection(tmpSel);
1378
                                ite->setItemName(it.key());
1379
                                m_Elements->append(ite);
1380
                                if (m_groupStack.count() != 0)
1381
                                        m_groupStack.top().Items.append(ite);
1382
                        }
1383
                }
1384
        }
1385
        m_radioMap.clear();
1386
        m_radioButtons.clear();
1387
//      qDebug() << "ending page";
1388
}
1389
 
1390
void SlaOutputDev::saveState(GfxState *state)
1391
{
20011 fschmid 1392
        m_clipPaths.push(m_currentClipPath);
1393
        pushGroup();
19590 jghali 1394
}
1395
 
1396
void SlaOutputDev::restoreState(GfxState *state)
1397
{
1398
        if (m_groupStack.count() != 0)
1399
        {
20011 fschmid 1400
                groupEntry gElements = m_groupStack.pop();
1401
                if (gElements.Items.count() > 0)
19590 jghali 1402
                {
20625 fschmid 1403
                        if ((gElements.Items.count() > 1) && (checkClip()))
19590 jghali 1404
                        {
20011 fschmid 1405
                                tmpSel->clear();
1406
                                for (int dre = 0; dre < gElements.Items.count(); ++dre)
19590 jghali 1407
                                {
20011 fschmid 1408
                                        tmpSel->addItem(gElements.Items.at(dre), true);
1409
                                        m_Elements->removeAll(gElements.Items.at(dre));
19590 jghali 1410
                                }
20011 fschmid 1411
                                PageItem *ite = m_doc->groupObjectsSelection(tmpSel);
20625 fschmid 1412
                                if (ite)
19590 jghali 1413
                                {
23536 jghali 1414
                                        QPainterPath clippath = m_currentClipPath;
1415
                                        clippath.translate(m_doc->currentPage()->xOffset(), m_doc->currentPage()->yOffset());
1416
                                        clippath.translate(-ite->xPos(), -ite->yPos());
1417
                                        ite->PoLine.fromQPainterPath(clippath, true);
23319 jghali 1418
                                        ite->ClipEdited = true;
1419
                                        ite->FrameType = 3;
20625 fschmid 1420
                                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
23319 jghali 1421
                                        // Comment out temporarily, there are some bad interactions between adjustItemSize() and
1422
                                        // resizeGroupToContents() since fixing resizing of multiple selections
1423
                                        //m_doc->adjustItemSize(ite, true);
20625 fschmid 1424
                                        m_doc->resizeGroupToContents(ite);
1425
                                        ite->OldB2 = ite->width();
1426
                                        ite->OldH2 = ite->height();
1427
                                        m_Elements->append(ite);
1428
                                        if (m_groupStack.count() != 0)
1429
                                        {
1430
                                                applyMask(ite);
1431
                                                m_groupStack.top().Items.append(ite);
1432
                                        }
19590 jghali 1433
                                }
20628 fschmid 1434
                                else
1435
                                {
1436
                                        if (m_groupStack.count() != 0)
1437
                                        {
1438
                                                for (int dre = 0; dre < gElements.Items.count(); ++dre)
1439
                                                {
1440
                                                        PageItem *ite = gElements.Items.at(dre);
1441
                                                        applyMask(ite);
1442
                                                        m_groupStack.top().Items.append(ite);
1443
                                                }
1444
                                        }
1445
                                }
20011 fschmid 1446
                                tmpSel->clear();
19590 jghali 1447
                        }
20011 fschmid 1448
                        else
1449
                        {
1450
                                if (m_groupStack.count() != 0)
1451
                                {
1452
                                        for (int dre = 0; dre < gElements.Items.count(); ++dre)
1453
                                        {
1454
                                                PageItem *ite = gElements.Items.at(dre);
1455
                                                applyMask(ite);
1456
                                                m_groupStack.top().Items.append(ite);
1457
                                        }
1458
                                }
1459
                        }
19590 jghali 1460
                }
1461
        }
20011 fschmid 1462
        if (m_clipPaths.count() != 0)
1463
                m_currentClipPath = m_clipPaths.pop();
19590 jghali 1464
}
20011 fschmid 1465
 
22916 jghali 1466
void SlaOutputDev::beginTransparencyGroup(GfxState *state, POPPLER_CONST_070 double *bbox, GfxColorSpace * /*blendingColorSpace*/, GBool isolated, GBool knockout, GBool forSoftMask)
19590 jghali 1467
{
23550 jghali 1468
//      qDebug() << "SlaOutputDev::beginTransparencyGroup isolated:" << isolated << "knockout:" << knockout << "forSoftMask:" << forSoftMask;
20011 fschmid 1469
        pushGroup("", forSoftMask);
20125 fschmid 1470
        m_groupStack.top().isolated = isolated;
19590 jghali 1471
}
20011 fschmid 1472
 
22916 jghali 1473
void SlaOutputDev::paintTransparencyGroup(GfxState *state, POPPLER_CONST_070 double *bbox)
19590 jghali 1474
{
23550 jghali 1475
//      qDebug() << "SlaOutputDev::paintTransparencyGroup";
20011 fschmid 1476
        if (m_groupStack.count() != 0)
1477
        {
1478
                if ((m_groupStack.top().Items.count() != 0) && (!m_groupStack.top().forSoftMask))
1479
                {
1480
                        PageItem *ite = m_groupStack.top().Items.last();
1481
                        ite->setFillTransparency(1.0 - state->getFillOpacity());
1482
                        ite->setFillBlendmode(getBlendMode(state));
1483
                }
1484
        }
19590 jghali 1485
}
1486
 
1487
void SlaOutputDev::endTransparencyGroup(GfxState *state)
1488
{
23550 jghali 1489
//      qDebug() << "SlaOutputDev::endTransparencyGroup";
22991 jghali 1490
        if (m_groupStack.count() <= 0)
1491
                return;
1492
 
1493
        tmpSel->clear();
1494
 
1495
        groupEntry gElements = m_groupStack.pop();
1496
        if (gElements.Items.count() <= 0)
1497
                return;
1498
 
1499
        if (gElements.forSoftMask)
19590 jghali 1500
        {
22991 jghali 1501
                for (int dre = 0; dre < gElements.Items.count(); ++dre)
19590 jghali 1502
                {
22991 jghali 1503
                        tmpSel->addItem(gElements.Items.at(dre), true);
1504
                        m_Elements->removeAll(gElements.Items.at(dre));
19590 jghali 1505
                }
22991 jghali 1506
                PageItem *ite = m_doc->groupObjectsSelection(tmpSel);
1507
                ite->setFillTransparency(1.0 - state->getFillOpacity());
1508
                ite->setFillBlendmode(getBlendMode(state));
24744 jghali 1509
                ScPattern pat(m_doc);
22991 jghali 1510
                m_doc->DoDrawing = true;
1511
                pat.pattern = ite->DrawObj_toImage(qMin(qMax(ite->width(), ite->height()), 500.0));
1512
                pat.xoffset = 0;
1513
                pat.yoffset = 0;
1514
                m_doc->DoDrawing = false;
1515
                pat.width = ite->width();
1516
                pat.height = ite->height();
23550 jghali 1517
                m_currentMaskPosition = QPointF(ite->xPos(), ite->yPos());
22991 jghali 1518
                ite->gXpos = 0;
1519
                ite->gYpos = 0;
1520
                ite->setXYPos(ite->gXpos, ite->gYpos, true);
1521
                pat.items.append(ite);
1522
                m_doc->Items->removeAll(ite);
1523
                QString id = QString("Pattern_from_PDF_%1S").arg(m_doc->docPatterns.count() + 1);
1524
                m_doc->addPattern(id, pat);
1525
                m_currentMask = id;
19590 jghali 1526
                tmpSel->clear();
22991 jghali 1527
                return;
19590 jghali 1528
        }
22991 jghali 1529
        PageItem *ite;
1530
        for (int dre = 0; dre < gElements.Items.count(); ++dre)
1531
        {
1532
                tmpSel->addItem(gElements.Items.at(dre), true);
1533
                m_Elements->removeAll(gElements.Items.at(dre));
1534
        }
1535
        if ((gElements.Items.count() != 1) || (gElements.isolated))
1536
                ite = m_doc->groupObjectsSelection(tmpSel);
1537
        else
1538
                ite = gElements.Items.first();
1539
        if (ite->isGroup())
1540
        {
1541
                ite->ClipEdited = true;
1542
                ite->FrameType = 3;
1543
                if (checkClip())
1544
                {
23536 jghali 1545
                        QPainterPath clippath = m_currentClipPath;
1546
                        clippath.translate(m_doc->currentPage()->xOffset(), m_doc->currentPage()->yOffset());
1547
                        clippath.translate(-ite->xPos(), -ite->yPos());
1548
                        ite->PoLine.fromQPainterPath(clippath, true);
23319 jghali 1549
                        ite->ClipEdited = true;
1550
                        ite->FrameType = 3;
22991 jghali 1551
                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
23319 jghali 1552
                        // Comment out temporarily, there are some bad interactions between adjustItemSize() and
1553
                        // resizeGroupToContents() since fixing resizing of multiple selections
1554
                        //m_doc->adjustItemSize(ite, true);
22991 jghali 1555
                        m_doc->resizeGroupToContents(ite);
1556
                        ite->OldB2 = ite->width();
1557
                        ite->OldH2 = ite->height();
1558
                }
1559
        }
1560
        ite->setFillTransparency(1.0 - state->getFillOpacity());
1561
        ite->setFillBlendmode(getBlendMode(state));
1562
        m_Elements->append(ite);
1563
        if (m_groupStack.count() != 0)
1564
        {
1565
                applyMask(ite);
1566
                m_groupStack.top().Items.append(ite);
1567
        }
1568
 
1569
        tmpSel->clear();
19590 jghali 1570
}
1571
 
23525 jghali 1572
void SlaOutputDev::setSoftMask(GfxState * /*state*/, POPPLER_CONST_070 double * bbox, GBool alpha, Function *transferFunc, GfxColor * /*backdropColor*/)
19590 jghali 1573
{
22991 jghali 1574
        if (m_groupStack.count() <= 0)
1575
                return;
1576
 
1577
        double lum = 0;
1578
        double lum2 = 0;
1579
        if (transferFunc)
1580
                transferFunc->transform(&lum, &lum2);
1581
        else
1582
                lum2 = lum;
24257 jghali 1583
        m_groupStack.top().inverted = (lum != lum2);
22991 jghali 1584
        m_groupStack.top().maskName = m_currentMask;
23550 jghali 1585
        // Remember the mask's position as it might not align with the image to which the mask is later assigned.
1586
        m_groupStack.top().maskPos = m_currentMaskPosition;
22991 jghali 1587
        m_groupStack.top().alpha = alpha;
1588
        if (m_groupStack.top().Items.count() != 0)
1589
                applyMask(m_groupStack.top().Items.last());
19590 jghali 1590
}
1591
 
1592
void SlaOutputDev::clearSoftMask(GfxState * /*state*/)
1593
{
1594
        if (m_groupStack.count() != 0)
1595
                m_groupStack.top().maskName = "";
1596
}
1597
 
1598
void SlaOutputDev::updateFillColor(GfxState *state)
1599
{
24374 jghali 1600
        m_currFillShade = 100;
1601
        m_currColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &m_currFillShade);
19590 jghali 1602
}
1603
 
1604
void SlaOutputDev::updateStrokeColor(GfxState *state)
1605
{
24374 jghali 1606
        m_currStrokeShade = 100;
1607
        m_currColorStroke = getColor(state->getStrokeColorSpace(), state->getStrokeColor(), &m_currStrokeShade);
19590 jghali 1608
}
1609
 
1610
void SlaOutputDev::clip(GfxState *state)
1611
{
1612
//      qDebug() << "Clip";
23536 jghali 1613
        adjustClip(state, Qt::WindingFill);
1614
}
1615
 
1616
void SlaOutputDev::eoClip(GfxState *state)
1617
{
1618
//      qDebug() << "EoClip";
1619
        adjustClip(state, Qt::OddEvenFill);
1620
}
1621
 
1622
void SlaOutputDev::adjustClip(GfxState *state, Qt::FillRule fillRule)
1623
{
1624
        const double *ctm = state->getCTM();
19590 jghali 1625
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1626
        QString output = convertPath(state->getPath());
22991 jghali 1627
        if (output.isEmpty())
1628
                return;
19590 jghali 1629
        FPointArray out;
22991 jghali 1630
        out.parseSVG(output);
1631
        out.svgClosePath();
1632
        out.map(m_ctm);
1633
        if (checkClip())
19590 jghali 1634
        {
23536 jghali 1635
                // "clip" (WindingFill) and "eoClip" (OddEvenFill) only the determine
1636
                // the fill rule of the new clipping path. The new clip should be the
1637
                // intersection of the old and new area. QPainterPath determines on
1638
                // its own which fill rule to use for the result. We should not loose
1639
                // this information.
1640
                QPainterPath pathN = out.toQPainterPath(false);
1641
                pathN.setFillRule(fillRule);
23550 jghali 1642
                m_currentClipPath = intersection(pathN, m_currentClipPath);
19590 jghali 1643
        }
22991 jghali 1644
        else
23536 jghali 1645
                m_currentClipPath = out.toQPainterPath(false);
19590 jghali 1646
}
1647
 
1648
void SlaOutputDev::stroke(GfxState *state)
1649
{
1650
//      qDebug() << "Stroke";
22741 jghali 1651
        const double *ctm;
19590 jghali 1652
        ctm = state->getCTM();
1653
        double xCoor = m_doc->currentPage()->xOffset();
1654
        double yCoor = m_doc->currentPage()->yOffset();
1655
        QString output = convertPath(state->getPath());
1656
        getPenState(state);
1657
        if ((m_Elements->count() != 0) && (output == Coords))                   // Path is the same as in last fill
1658
        {
1659
                PageItem* ite = m_Elements->last();
24374 jghali 1660
                ite->setLineColor(m_currColorStroke);
1661
                ite->setLineShade(m_currStrokeShade);
1662
                ite->setLineEnd(m_lineEnd);
1663
                ite->setLineJoin(m_lineJoin);
19590 jghali 1664
                ite->setLineWidth(state->getTransformedLineWidth());
1665
                ite->setDashes(DashValues);
1666
                ite->setDashOffset(DashOffset);
1667
                ite->setLineTransparency(1.0 - state->getStrokeOpacity());
1668
        }
1669
        else
1670
        {
1671
                FPointArray out;
1672
                out.parseSVG(output);
1673
                m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1674
                out.map(m_ctm);
23038 jghali 1675
                FPoint wh = out.widthHeight();
19590 jghali 1676
                if ((out.size() > 3) && ((wh.x() != 0.0) || (wh.y() != 0.0)))
1677
                {
24374 jghali 1678
                        m_currColorStroke = getColor(state->getStrokeColorSpace(), state->getStrokeColor(), &m_currStrokeShade);
19590 jghali 1679
                        int z;
1680
                        if (pathIsClosed)
24374 jghali 1681
                                z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, state->getTransformedLineWidth(), CommonStrings::None, m_currColorStroke);
19590 jghali 1682
                        else
24374 jghali 1683
                                z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, xCoor, yCoor, 10, 10, state->getTransformedLineWidth(), CommonStrings::None, m_currColorStroke);
19590 jghali 1684
                        PageItem* ite = m_doc->Items->at(z);
1685
                        ite->PoLine = out.copy();
1686
                        ite->ClipEdited = true;
1687
                        ite->FrameType = 3;
23289 jghali 1688
                        ite->setWidthHeight(wh.x(), wh.y());
20694 craig 1689
                        m_doc->adjustItemSize(ite);
19590 jghali 1690
                        if (m_Elements->count() != 0)
1691
                        {
1692
                                PageItem* lItem = m_Elements->last();
1693
                                if ((lItem->lineColor() == CommonStrings::None) && (lItem->PoLine == ite->PoLine))
1694
                                {
24374 jghali 1695
                                        lItem->setLineColor(m_currColorStroke);
19590 jghali 1696
                                        lItem->setLineWidth(state->getTransformedLineWidth());
24374 jghali 1697
                                        lItem->setLineShade(m_currStrokeShade);
19590 jghali 1698
                                        lItem->setLineTransparency(1.0 - state->getStrokeOpacity());
1699
                                        lItem->setLineBlendmode(getBlendMode(state));
24374 jghali 1700
                                        lItem->setLineEnd(m_lineEnd);
1701
                                        lItem->setLineJoin(m_lineJoin);
19590 jghali 1702
                                        lItem->setDashes(DashValues);
1703
                                        lItem->setDashOffset(DashOffset);
1704
                                        lItem->setTextFlowMode(PageItem::TextFlowDisabled);
1705
                                        m_doc->Items->removeAll(ite);
1706
                                }
1707
                                else
1708
                                {
24374 jghali 1709
                                        ite->setLineShade(m_currStrokeShade);
19590 jghali 1710
                                        ite->setLineTransparency(1.0 - state->getStrokeOpacity());
1711
                                        ite->setLineBlendmode(getBlendMode(state));
24374 jghali 1712
                                        ite->setLineEnd(m_lineEnd);
1713
                                        ite->setLineJoin(m_lineJoin);
19590 jghali 1714
                                        ite->setDashes(DashValues);
1715
                                        ite->setDashOffset(DashOffset);
1716
                                        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1717
                                        m_Elements->append(ite);
1718
                                        if (m_groupStack.count() != 0)
1719
                                                m_groupStack.top().Items.append(ite);
1720
                                }
1721
                        }
1722
                        else
1723
                        {
24374 jghali 1724
                                ite->setLineShade(m_currStrokeShade);
19590 jghali 1725
                                ite->setLineTransparency(1.0 - state->getStrokeOpacity());
1726
                                ite->setLineBlendmode(getBlendMode(state));
24374 jghali 1727
                                ite->setLineEnd(m_lineEnd);
1728
                                ite->setLineJoin(m_lineJoin);
19590 jghali 1729
                                ite->setDashes(DashValues);
1730
                                ite->setDashOffset(DashOffset);
1731
                                ite->setTextFlowMode(PageItem::TextFlowDisabled);
1732
                                m_Elements->append(ite);
1733
                                if (m_groupStack.count() != 0)
1734
                                        m_groupStack.top().Items.append(ite);
1735
                        }
1736
                }
1737
        }
1738
}
1739
 
1740
void SlaOutputDev::fill(GfxState *state)
1741
{
1742
//      qDebug() << "Fill";
23536 jghali 1743
        createFillItem(state, Qt::WindingFill);
19590 jghali 1744
}
1745
 
1746
void SlaOutputDev::eoFill(GfxState *state)
1747
{
1748
//      qDebug() << "EoFill";
23536 jghali 1749
        createFillItem(state, Qt::OddEvenFill);
1750
}
1751
 
1752
void SlaOutputDev::createFillItem(GfxState *state, Qt::FillRule fillRule)
1753
{
22741 jghali 1754
        const double *ctm;
19590 jghali 1755
        ctm = state->getCTM();
23550 jghali 1756
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
19590 jghali 1757
        double xCoor = m_doc->currentPage()->xOffset();
1758
        double yCoor = m_doc->currentPage()->yOffset();
1759
        FPointArray out;
1760
        QString output = convertPath(state->getPath());
1761
        out.parseSVG(output);
1762
        out.map(m_ctm);
23536 jghali 1763
 
1764
        // Clip the new path first and only add it if it is not empty.
1765
        QPainterPath path = out.toQPainterPath(false);
1766
        path.setFillRule(fillRule);
23550 jghali 1767
        QPainterPath clippedPath = intersection(m_currentClipPath, path);
23536 jghali 1768
 
23550 jghali 1769
        // Undo the rotation of the clipping path as it is rotated together with the item.
1770
        double angle = m_ctm.map(QLineF(0, 0, 1, 0)).angle();
1771
        QTransform mm;
1772
        mm.rotate(angle);
1773
        clippedPath = mm.map(clippedPath);
1774
 
19590 jghali 1775
        Coords = output;
23536 jghali 1776
        QRectF bbox = clippedPath.boundingRect();
1777
        if (!clippedPath.isEmpty() && !bbox.isNull())
19590 jghali 1778
        {
24374 jghali 1779
                m_currColorFill = getColor(state->getFillColorSpace(), state->getFillColor(), &m_currFillShade);
19590 jghali 1780
                int z;
1781
                if (pathIsClosed)
24374 jghali 1782
                        z = m_doc->itemAdd(PageItem::Polygon, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, m_currColorFill, CommonStrings::None);
19590 jghali 1783
                else
24374 jghali 1784
                        z = m_doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, xCoor, yCoor, 10, 10, 0, m_currColorFill, CommonStrings::None);
19590 jghali 1785
                PageItem* ite = m_doc->Items->at(z);
23536 jghali 1786
                ite->PoLine.fromQPainterPath(clippedPath, true);
19590 jghali 1787
                ite->ClipEdited = true;
1788
                ite->FrameType = 3;
24374 jghali 1789
                ite->setFillShade(m_currFillShade);
19590 jghali 1790
                ite->setLineShade(100);
23550 jghali 1791
                ite->setRotation(-angle);
23536 jghali 1792
                // Only the new path has to be interpreted according to fillRule. QPainterPath
1793
                // could decide to create a final path according to the other rule. Thus
1794
                // we have to set this from the final path.
1795
                ite->setFillEvenOdd(clippedPath.fillRule() == Qt::OddEvenFill);
19590 jghali 1796
                ite->setFillTransparency(1.0 - state->getFillOpacity());
1797
                ite->setFillBlendmode(getBlendMode(state));
24374 jghali 1798
                ite->setLineEnd(m_lineEnd);
1799
                ite->setLineJoin(m_lineJoin);
23536 jghali 1800
                ite->setWidthHeight(bbox.width(),bbox.height());
19590 jghali 1801
                ite->setTextFlowMode(PageItem::TextFlowDisabled);
20694 craig 1802
                m_doc->adjustItemSize(ite);
19590 jghali 1803
                m_Elements->append(ite);
1804
                if (m_groupStack.count() != 0)
1805
                {
1806
                        m_groupStack.top().Items.append(ite);
1807
                        applyMask(ite);
1808
                }
1809
        }
1810
}
1811
 
1812
GBool SlaOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax)
1813
{
23536 jghali 1814
//      qDebug() << "SlaOutputDev::axialShadedFill";
19590 jghali 1815
        double GrStartX;
1816
        double GrStartY;
1817
        double GrEndX;
1818
        double GrEndY;
1819
        int shade = 100;
22741 jghali 1820
        POPPLER_CONST_070 Function *func = shading->getFunc(0);
19590 jghali 1821
        VGradient FillGradient = VGradient(VGradient::linear);
1822
        FillGradient.clearStops();
1823
        GfxColorSpace *color_space = shading->getColorSpace();
1824
        if (func->getType() == 3)
1825
        {
1826
                StitchingFunction *stitchingFunc = (StitchingFunction*)func;
22741 jghali 1827
                const double *bounds = stitchingFunc->getBounds();
19590 jghali 1828
                int num_funcs = stitchingFunc->getNumFuncs();
22978 jghali 1829
                double domain_min = stitchingFunc->getDomainMin(0);
1830
                double domain_max = stitchingFunc->getDomainMax(0);
1831
                if (fabs(domain_max - domain_min) < 1e-6)
1832
                {
1833
                        domain_min = 0.0;
1834
                        domain_max = 1.0;
1835
                }
19590 jghali 1836
                // Add stops from all the stitched functions
22978 jghali 1837
                for (int i = 0 ; i <= num_funcs ; i++)
19590 jghali 1838
                {
1839
                        GfxColor temp;
22978 jghali 1840
                        shading->getColor(bounds[i], &temp);
19590 jghali 1841
                        QString stopColor = getColor(color_space, &temp, &shade);
22978 jghali 1842
                        double stopPoint = (bounds[i] - domain_min) / (domain_max - domain_min);
1843
                        FillGradient.addStop( ScColorEngine::getShadeColor(m_doc->PageColors[stopColor], m_doc, shade), stopPoint, 0.5, 1.0, stopColor, shade );
19590 jghali 1844
                }
1845
        }
1846
        else if ((func->getType() == 2) || (func->getType() == 0))
1847
        {
1848
                GfxColor stop1;
22978 jghali 1849
                shading->getColor(0.0, &stop1);
19590 jghali 1850
                QString stopColor1 = getColor(color_space, &stop1, &shade);
1851
                FillGradient.addStop( ScColorEngine::getShadeColor(m_doc->PageColors[stopColor1], m_doc, shade), 0.0, 0.5, 1.0, stopColor1, shade );
1852
                GfxColor stop2;
22978 jghali 1853
                shading->getColor(1.0, &stop2);
19590 jghali 1854
                QString stopColor2 = getColor(color_space, &stop2, &shade);
1855
                FillGradient.addStop( ScColorEngine::getShadeColor(m_doc->PageColors[stopColor2], m_doc, shade), 1.0, 0.5, 1.0, stopColor2, shade );
1856
        }
22978 jghali 1857
        shading->getCoords(&GrStartX, &GrStartY, &GrEndX, &GrEndY);
19590 jghali 1858
        double xmin, ymin, xmax, ymax;
1859
        // get the clip region bbox
1860
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
1861
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
1862
        crect = crect.normalized();
23588 jghali 1863
        QPainterPath out;
1864
        out.addRect(crect);
1865
        if (checkClip())
1866
        {
1867
                // Apply the clip path early to adjust the gradient vector to the
1868
                // smaller boundign box.
1869
                out = intersection(m_currentClipPath, out);
1870
                crect = out.boundingRect();
1871
        }
22741 jghali 1872
        const double *ctm = state->getCTM();
19590 jghali 1873
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
1874
        FPointArray gr;
1875
        gr.addPoint(GrStartX, GrStartY);
1876
        gr.addPoint(GrEndX, GrEndY);
1877
        gr.map(m_ctm);
23588 jghali 1878
        gr.translate(-crect.x(), -crect.y());
1879
 
1880
        // Undo the rotation and translation of the gradient vector.
1881
        double angle = m_ctm.map(QLineF(0, 0, 1, 0)).angle();
1882
        QTransform mm;
1883
        mm.rotate(angle);
1884
        out.translate(-crect.x(), -crect.y());
1885
        out = mm.map(out);
1886
        QRectF bb = out.boundingRect();
1887
        gr.map(mm);
1888
        gr.translate(-bb.left(), -bb.top());
1889
        GrStartX = gr.point(0).x();
1890
        GrStartY = gr.point(0).y();
1891
        GrEndX = gr.point(1).x();
1892
        GrEndY = gr.point(1).y();
1893
 
19590 jghali 1894
        double xCoor = m_doc->currentPage()->xOffset();
1895
        double yCoor = m_doc->currentPage()->yOffset();
1896
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
1897
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
1898
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
1899
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
1900
        output += QString("L %1 %2").arg(0.0).arg(0.0);
1901
        output += QString("Z");
1902
        pathIsClosed = true;
1903
        Coords = output;
24374 jghali 1904
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), bb.width(), bb.height(), 0, m_currColorFill, CommonStrings::None);
19590 jghali 1905
        PageItem* ite = m_doc->Items->at(z);
20011 fschmid 1906
        if (checkClip())
1907
        {
23536 jghali 1908
                ite->PoLine.fromQPainterPath(out, true);
1909
                ite->setFillEvenOdd(out.fillRule() == Qt::OddEvenFill);
20011 fschmid 1910
        }
23588 jghali 1911
        ite->setRotation(-angle);
19590 jghali 1912
        ite->ClipEdited = true;
1913
        ite->FrameType = 3;
24374 jghali 1914
        ite->setFillShade(m_currFillShade);
19590 jghali 1915
        ite->setLineShade(100);
1916
        ite->setFillTransparency(1.0 - state->getFillOpacity());
1917
        ite->setFillBlendmode(getBlendMode(state));
24374 jghali 1918
        ite->setLineEnd(m_lineEnd);
1919
        ite->setLineJoin(m_lineJoin);
19590 jghali 1920
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
1921
        ite->GrType = 6;
1922
        if (!shading->getExtend0() || !shading->getExtend1())
1923
        {
1924
                FillGradient.setRepeatMethod(VGradient::none);
1925
                ite->setGradientExtend(VGradient::none);
1926
        }
1927
        else
1928
        {
1929
                FillGradient.setRepeatMethod(VGradient::pad);
1930
                ite->setGradientExtend(VGradient::pad);
1931
        }
1932
        ite->fill_gradient = FillGradient;
1933
        ite->setGradientVector(GrStartX, GrStartY, GrEndX, GrEndY, 0, 0, 1, 0);
20694 craig 1934
        m_doc->adjustItemSize(ite);
19590 jghali 1935
        m_Elements->append(ite);
1936
        if (m_groupStack.count() != 0)
1937
        {
1938
                m_groupStack.top().Items.append(ite);
1939
                applyMask(ite);
1940
        }
1941
        return gTrue;
1942
}
1943
 
1944
GBool SlaOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax)
1945
{
23536 jghali 1946
//      qDebug() << "SlaOutputDev::radialShadedFill";
19590 jghali 1947
        double GrStartX;
1948
        double GrStartY;
1949
        double GrEndX;
1950
        double GrEndY;
1951
        int shade = 100;
22741 jghali 1952
        POPPLER_CONST_070 Function *func = shading->getFunc(0);
19590 jghali 1953
        VGradient FillGradient = VGradient(VGradient::linear);
1954
        FillGradient.clearStops();
1955
        GfxColorSpace *color_space = shading->getColorSpace();
1956
        if (func->getType() == 3)
1957
        {
1958
                StitchingFunction *stitchingFunc = (StitchingFunction*)func;
22741 jghali 1959
                const double *bounds = stitchingFunc->getBounds();
19590 jghali 1960
                int num_funcs = stitchingFunc->getNumFuncs();
22978 jghali 1961
                double domain_min = stitchingFunc->getDomainMin(0);
1962
                double domain_max = stitchingFunc->getDomainMax(0);
1963
                if (fabs(domain_max - domain_min) < 1e-6)
1964
                {
1965
                        domain_min = 0.0;
1966
                        domain_max = 1.0;
1967
                }
19590 jghali 1968
                // Add stops from all the stitched functions
22978 jghali 1969
                for (int i = 0 ; i <= num_funcs ; i++)
19590 jghali 1970
                {
1971
                        GfxColor temp;
22978 jghali 1972
                        shading->getColor(bounds[i], &temp);
19590 jghali 1973
                        QString stopColor = getColor(color_space, &temp, &shade);
22978 jghali 1974
                        double stopPoint = (bounds[i] - domain_min) / (domain_max - domain_min);
1975
                        FillGradient.addStop( ScColorEngine::getShadeColor(m_doc->PageColors[stopColor], m_doc, shade), stopPoint, 0.5, 1.0, stopColor, shade );
19590 jghali 1976
                }
1977
        }
1978
        else if ((func->getType() == 2) || (func->getType() == 0))
1979
        {
1980
                GfxColor stop1;
22978 jghali 1981
                shading->getColor(0.0, &stop1);
19590 jghali 1982
                QString stopColor1 = getColor(color_space, &stop1, &shade);
1983
                FillGradient.addStop( ScColorEngine::getShadeColor(m_doc->PageColors[stopColor1], m_doc, shade), 0.0, 0.5, 1.0, stopColor1, shade );
1984
                GfxColor stop2;
22978 jghali 1985
                shading->getColor(1.0, &stop2);
19590 jghali 1986
                QString stopColor2 = getColor(color_space, &stop2, &shade);
1987
                FillGradient.addStop( ScColorEngine::getShadeColor(m_doc->PageColors[stopColor2], m_doc, shade), 1.0, 0.5, 1.0, stopColor2, shade );
1988
        }
1989
        double r0, x1, y1, r1;
22978 jghali 1990
        shading->getCoords(&GrStartX, &GrStartY, &r0, &x1, &y1, &r1);
19590 jghali 1991
        double xmin, ymin, xmax, ymax;
1992
        // get the clip region bbox
1993
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
1994
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
1995
        crect = crect.normalized();
1996
        double GrFocalX = x1;
1997
        double GrFocalY = y1;
1998
        GrEndX = GrFocalX + r1;
1999
        GrEndY = GrFocalY;
22741 jghali 2000
        const double *ctm = state->getCTM();
19590 jghali 2001
        m_ctm = QTransform(ctm[0], ctm[1], ctm[2], ctm[3], ctm[4], ctm[5]);
2002
        FPointArray gr;
2003
        gr.addPoint(GrStartX, GrStartY);
2004
        gr.addPoint(GrEndX, GrEndY);
2005
        gr.addPoint(GrFocalX, GrFocalY);
2006
        gr.map(m_ctm);
2007
        GrStartX = gr.point(0).x() - crect.x();
2008
        GrStartY = gr.point(0).y() - crect.y();
2009
        GrEndX = gr.point(1).x() - crect.x();
2010
        GrEndY = gr.point(1).y() - crect.y();
2011
        GrFocalX = gr.point(2).x() - crect.x();
2012
        GrFocalY = gr.point(2).y() - crect.y();
2013
        double xCoor = m_doc->currentPage()->xOffset();
2014
        double yCoor = m_doc->currentPage()->yOffset();
2015
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
2016
        output += QString("L %1 %2").arg(crect.width()).arg(0.0);
2017
        output += QString("L %1 %2").arg(crect.width()).arg(crect.height());
2018
        output += QString("L %1 %2").arg(0.0).arg(crect.height());
2019
        output += QString("L %1 %2").arg(0.0).arg(0.0);
2020
        output += QString("Z");
2021
        pathIsClosed = true;
2022
        Coords = output;
24374 jghali 2023
        int z = m_doc->itemAdd(PageItem::Polygon, PageItem::Rectangle, xCoor + crect.x(), yCoor + crect.y(), crect.width(), crect.height(), 0, m_currColorFill, CommonStrings::None);
19590 jghali 2024
        PageItem* ite = m_doc->Items->at(z);
20011 fschmid 2025
        if (checkClip())
2026
        {
23536 jghali 2027
                QPainterPath out = m_currentClipPath;
23319 jghali 2028
                out.translate(m_doc->currentPage()->xOffset(), m_doc->currentPage()->yOffset());
2029
                out.translate(-ite->xPos(), -ite->yPos());
23536 jghali 2030
                ite->PoLine.fromQPainterPath(out, true);
2031
                ite->setFillEvenOdd(out.fillRule() == Qt::OddEvenFill);
20011 fschmid 2032
        }
19590 jghali 2033
        ite->ClipEdited = true;
2034
        ite->FrameType = 3;
24374 jghali 2035
        ite->setFillShade(m_currFillShade);
19590 jghali 2036
        ite->setLineShade(100);
2037
        ite->setFillTransparency(1.0 - state->getFillOpacity());
2038
        ite->setFillBlendmode(getBlendMode(state));
24374 jghali 2039
        ite->setLineEnd(m_lineEnd);
2040
        ite->setLineJoin(m_lineJoin);
19590 jghali 2041
        ite->setTextFlowMode(PageItem::TextFlowDisabled);
2042
        ite->GrType = 7;
2043
        if (!shading->getExtend0() || !shading->getExtend1())
2044
        {
2045
                FillGradient.setRepeatMethod(VGradient::none);
2046
                ite->setGradientExtend(VGradient::none);
2047
        }
2048
        else
2049
        {
2050
                FillGradient.setRepeatMethod(VGradient::pad);
2051
                ite->setGradientExtend(VGradient::pad);
2052
        }
2053
        ite->fill_gradient = FillGradient;
2054
        ite->setGradientVector(GrStartX, GrStartY, GrEndX, GrEndY, GrFocalX, GrFocalY, 1, 0);
20694 craig 2055
        m_doc->adjustItemSize(ite);
19590 jghali 2056
        m_Elements->append(ite);
2057
        if (m_groupStack.count() != 0)
2058
        {
2059
                m_groupStack.top().Items.append(ite);
2060
                applyMask(ite);
2061
        }
2062
        return gTrue;
2063
}
2064
 
2065
GBool SlaOutputDev::gouraudTriangleShadedFill(GfxState *state, GfxGouraudTriangleShading *shading)
2066
{
23536 jghali 2067
//      qDebug() << "SlaOutputDev::gouraudTriangleShadedFill";
19590 jghali 2068
        double xCoor = m_doc->currentPage()->xOffset();
2069
        double yCoor = m_doc->currentPage()->yOffset();
2070
        double xmin, ymin, xmax, ymax;
2071
        // get the clip region bbox
2072
        state->getClipBBox(&xmin, &ymin, &xmax, &ymax);
2073
        QRectF crect = QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
2074
        crect = crect.normalized();
2075
        QString output = QString("M %1 %2").arg(0.0).arg(0.0);
2076
        output +