Subversion Repositories Scribus

Rev

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