Subversion Repositories Scribus

Rev

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