Subversion Repositories Scribus

Rev

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