Subversion Repositories Scribus

Rev

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