Subversion Repositories Scribus

Rev

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