Subversion Repositories Scribus

Rev

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