Subversion Repositories Scribus

Rev

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