Subversion Repositories Scribus

Rev

Rev 22741 | Rev 22906 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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