Subversion Repositories Scribus

Rev

Rev 22088 | Rev 22154 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
16729 fschmid 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 <QByteArray>
9
#include <QCursor>
10
#include <QDrag>
11
#include <QFile>
17851 fschmid 12
#include <QInputDialog>
16729 fschmid 13
#include <QList>
14
#include <QMimeData>
15
#include <QRegExp>
16
#include <QStack>
17
#include <QDebug>
18
#include "slaoutput.h"
17869 fschmid 19
#include <poppler/ErrorCodes.h>
20
#include <poppler/GlobalParams.h>
20125 fschmid 21
#include <poppler/OptionalContent.h>
17869 fschmid 22
#include <poppler/PageTransition.h>
23
#include <poppler/ViewerPreferences.h>
24
#include <poppler/poppler-config.h>
25
#include <poppler/SplashOutputDev.h>
26
#include <poppler/splash/SplashBitmap.h>
16729 fschmid 27
 
28
#include "importpdf.h"
29
 
30
#include <cstdlib>
31
 
32
#include "commonstrings.h"
33
#include "loadsaveplugin.h"
34
#include "pagesize.h"
17880 fschmid 35
#include "pdfimportoptions.h"
17849 fschmid 36
#include "pdfoptions.h"
16729 fschmid 37
#include "prefscontext.h"
38
#include "prefsfile.h"
39
#include "prefsmanager.h"
40
#include "prefstable.h"
41
#include "rawimage.h"
42
#include "scclocale.h"
43
#include "sccolorengine.h"
44
#include "scconfig.h"
45
#include "scmimedata.h"
46
#include "scpaths.h"
47
#include "scribus.h"
48
#include "scribusXml.h"
49
#include "scribuscore.h"
50
#include "sctextstream.h"
51
#include "selection.h"
52
#include "undomanager.h"
53
#include "util.h"
54
#include "util_formats.h"
55
#include "util_math.h"
56
 
17031 jghali 57
#include "ui/customfdialog.h"
58
#include "ui/missing.h"
59
#include "ui/multiprogressdialog.h"
60
#include "ui/propertiespalette.h"
16729 fschmid 61
 
62
PdfPlug::PdfPlug(ScribusDoc* doc, int flags)
63
{
64
        tmpSele = new Selection(this, false);
65
        m_Doc = doc;
66
        importerFlags = flags;
67
        interactive = (flags & LoadSavePlugin::lfInteractive);
16773 fschmid 68
        progressDialog = NULL;
17880 fschmid 69
        m_pdfDoc = NULL;
16729 fschmid 70
}
71
 
72
QImage PdfPlug::readThumbnail(QString fName)
73
{
17869 fschmid 74
        QString pdfFile = QDir::toNativeSeparators(fName);
75
        globalParams = new GlobalParams();
76
        if (globalParams)
77
        {
78
                GooString *fname = new GooString(QFile::encodeName(pdfFile).data());
79
                globalParams->setErrQuiet(gTrue);
80
                PDFDoc *pdfDoc = new PDFDoc(fname, NULL, NULL, NULL);
81
                if (pdfDoc)
82
                {
83
                        if (pdfDoc->getErrorCode() == errEncrypted)
84
                        {
85
                                delete pdfDoc;
86
                                delete globalParams;
87
                                return QImage();
88
                        }
89
                        if (pdfDoc->isOk())
90
                        {
91
                                double h = pdfDoc->getPageMediaHeight(1);
92
                                double w = pdfDoc->getPageMediaWidth(1);
93
                                double scale = qMin(500.0 / h, 500.0 / w);
94
                                double hDPI = 72.0 * scale;
95
                                double vDPI = 72.0 * scale;
96
                                SplashColor bgColor;
97
                                bgColor[0] = 255;
98
                                bgColor[1] = 255;
99
                                bgColor[2] = 255;
19806 jghali 100
                                SplashOutputDev *dev = new SplashOutputDev(splashModeXBGR8, 4, gFalse, bgColor, gTrue);
17869 fschmid 101
                                dev->setVectorAntialias(gTrue);
102
                                dev->setFreeTypeHinting(gTrue, gFalse);
103
                                dev->startDoc(pdfDoc);
104
                                pdfDoc->displayPage(dev, 1, hDPI, vDPI, 0, gTrue, gFalse, gFalse);
105
                                SplashBitmap *bitmap = dev->getBitmap();
106
                                int bw = bitmap->getWidth();
107
                                int bh = bitmap->getHeight();
17870 fschmid 108
                                SplashColorPtr dataPtr = bitmap->getDataPtr();
109
                                if (QSysInfo::BigEndian == QSysInfo::ByteOrder)
17869 fschmid 110
                                {
17870 fschmid 111
                                        uchar c;
112
                                        int count = bw * bh * 4;
113
                                        for (int k = 0; k < count; k += 4)
17869 fschmid 114
                                        {
17870 fschmid 115
                                                c = dataPtr[k];
116
                                                dataPtr[k] = dataPtr[k+3];
117
                                                dataPtr[k+3] = c;
118
                                                c = dataPtr[k+1];
119
                                                dataPtr[k+1] = dataPtr[k+2];
120
                                                dataPtr[k+2] = c;
17869 fschmid 121
                                        }
122
                                }
17870 fschmid 123
                                // construct a qimage SHARING the raw bitmap data in memory
124
                                QImage tmpimg( dataPtr, bw, bh, QImage::Format_ARGB32 );
125
                                QImage image = tmpimg.copy();
126
                                image.setText("XSize", QString("%1").arg(w));
127
                                image.setText("YSize", QString("%1").arg(h));
128
                                delete dev;
129
                                delete pdfDoc;
130
                                delete globalParams;
131
                                return image;
17869 fschmid 132
                        }
133
                        else
134
                        {
135
                                delete pdfDoc;
136
                                delete globalParams;
137
                                return QImage();
138
                        }
139
                }
140
                else
141
                        return QImage();
142
        }
143
        return QImage();
144
}
145
/*      Old Code to be backed up
16729 fschmid 146
        QString tmp, cmd1, cmd2;
147
        QString pdfFile = QDir::toNativeSeparators(fName);
21527 craig 148
        QString tmpFile = QDir::toNativeSeparators(ScPaths::tempFileDir() + "sc.png");
16729 fschmid 149
        int ret = -1;
150
        tmp.setNum(1);
151
        QStringList args;
152
        args.append("-r72");
153
        args.append("-sOutputFile="+tmpFile);
154
        args.append("-dFirstPage="+tmp);
155
        args.append("-dLastPage="+tmp);
156
        args.append(pdfFile);
157
        ret = callGS(args);
158
        if (ret == 0)
159
        {
160
                QImage image;
161
                image.load(tmpFile);
162
                QFile::remove(tmpFile);
163
                image.setText("XSize", QString("%1").arg(image.width()));
164
                image.setText("YSize", QString("%1").arg(image.height()));
165
                return image;
166
        }
167
        return QImage();
17869 fschmid 168
*/
16729 fschmid 169
 
170
bool PdfPlug::import(QString fNameIn, const TransactionSettings& trSettings, int flags, bool showProgress)
171
{
19809 craig 172
#ifdef Q_OS_OSX
173
        #if QT_VERSION >= 0x050300
174
                showProgress = false;
175
        #endif
176
#endif
16729 fschmid 177
        QString fName = fNameIn;
178
        bool success = false;
179
        interactive = (flags & LoadSavePlugin::lfInteractive);
180
        importerFlags = flags;
181
        cancel = false;
17635 jghali 182
        double b, h;
16729 fschmid 183
        bool ret = false;
184
        QFileInfo fi = QFileInfo(fName);
185
        if ( !ScCore->usingGUI() )
186
        {
187
                interactive = false;
188
                showProgress = false;
189
        }
190
        baseFile = QDir::cleanPath(QDir::toNativeSeparators(fi.absolutePath()+"/"));
191
        if ( showProgress )
192
        {
21961 craig 193
                ScribusMainWindow* mw = (m_Doc==0) ? ScCore->primaryMainWindow() : m_Doc->scMW();
16729 fschmid 194
                progressDialog = new MultiProgressDialog( tr("Importing: %1").arg(fi.fileName()), CommonStrings::tr_Cancel, mw );
195
                QStringList barNames, barTexts;
196
                barNames << "GI";
197
                barTexts << tr("Analyzing File:");
198
                QList<bool> barsNumeric;
199
                barsNumeric << false;
200
                progressDialog->addExtraProgressBars(barNames, barTexts, barsNumeric);
201
                progressDialog->setOverallTotalSteps(3);
202
                progressDialog->setOverallProgress(0);
203
                progressDialog->setProgress("GI", 0);
204
                progressDialog->show();
205
                connect(progressDialog, SIGNAL(canceled()), this, SLOT(cancelRequested()));
206
                qApp->processEvents();
207
        }
208
        else
209
                progressDialog = NULL;
210
/* Set default Page to size defined in Preferences */
211
        b = 0.0;
212
        h = 0.0;
213
        if (progressDialog)
214
        {
215
                progressDialog->setOverallProgress(1);
216
                qApp->processEvents();
217
        }
218
        if (b == 0.0)
219
                b = PrefsManager::instance()->appPrefs.docSetupPrefs.pageWidth;
220
        if (h == 0.0)
221
                h = PrefsManager::instance()->appPrefs.docSetupPrefs.pageHeight;
222
        docWidth = b;
223
        docHeight = h;
224
        baseX = 0;
225
        baseY = 0;
226
        if (!interactive || (flags & LoadSavePlugin::lfInsertPage))
227
        {
228
                m_Doc->setPage(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, false);
229
                m_Doc->addPage(0);
230
                m_Doc->view()->addPage(0, true);
231
                baseX = 0;
232
                baseY = 0;
233
        }
234
        else
235
        {
236
                if (!m_Doc || (flags & LoadSavePlugin::lfCreateDoc))
237
                {
17078 fschmid 238
                        m_Doc=ScCore->primaryMainWindow()->doFileNew(docWidth, docHeight, 0, 0, 0, 0, 0, 0, false, 0, 0, 0, 0, 1, "Custom", true);
16729 fschmid 239
                        ScCore->primaryMainWindow()->HaveNewDoc();
240
                        ret = true;
241
                        baseX = 0;
242
                        baseY = 0;
243
                        baseX = m_Doc->currentPage()->xOffset();
244
                        baseY = m_Doc->currentPage()->yOffset();
245
                }
246
        }
247
        if ((!ret) && (interactive))
248
        {
249
                baseX = m_Doc->currentPage()->xOffset();
250
                baseY = m_Doc->currentPage()->yOffset();
251
        }
252
        if ((ret) || (!interactive))
253
        {
254
                if (docWidth > docHeight)
255
                        m_Doc->setPageOrientation(1);
256
                else
257
                        m_Doc->setPageOrientation(0);
258
                m_Doc->setPageSize("Custom");
259
        }
19856 fschmid 260
        if ((!(flags & LoadSavePlugin::lfLoadAsPattern)) && (m_Doc->view() != NULL))
261
                m_Doc->view()->Deselect();
16729 fschmid 262
        Elements.clear();
263
        m_Doc->setLoading(true);
264
        m_Doc->DoDrawing = false;
19856 fschmid 265
        if ((!(flags & LoadSavePlugin::lfLoadAsPattern)) && (m_Doc->view() != NULL))
16729 fschmid 266
                m_Doc->view()->updatesOn(false);
267
        m_Doc->scMW()->setScriptRunning(true);
18181 fschmid 268
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
16729 fschmid 269
        QString CurDirP = QDir::currentPath();
270
        QDir::setCurrent(fi.path());
271
        if (convert(fName))
272
        {
273
                tmpSele->clear();
274
                QDir::setCurrent(CurDirP);
17905 fschmid 275
                if ((Elements.count() == 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
276
                {
277
                        PageItem *gr = Elements[0];
18514 fschmid 278
                        if (gr->isGroup())
279
                                m_Doc->resizeGroupToContents(gr);
17905 fschmid 280
                }
16729 fschmid 281
                if ((Elements.count() > 1) && (!(importerFlags & LoadSavePlugin::lfCreateDoc)))
17905 fschmid 282
                {
283
                        PageItem *gr = m_Doc->groupObjectsList(Elements);
284
                        m_Doc->resizeGroupToContents(gr);
285
                }
16729 fschmid 286
                m_Doc->DoDrawing = true;
287
                m_Doc->scMW()->setScriptRunning(false);
288
                m_Doc->setLoading(false);
289
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
290
                if ((Elements.count() > 0) && (!ret) && (interactive))
291
                {
292
                        if (flags & LoadSavePlugin::lfScripted)
293
                        {
294
                                bool loadF = m_Doc->isLoading();
295
                                m_Doc->setLoading(false);
296
                                m_Doc->changed();
297
                                m_Doc->setLoading(loadF);
298
                                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
299
                                {
300
                                        m_Doc->m_Selection->delaySignalsOn();
301
                                        for (int dre=0; dre<Elements.count(); ++dre)
302
                                        {
303
                                                m_Doc->m_Selection->addItem(Elements.at(dre), true);
304
                                        }
305
                                        m_Doc->m_Selection->delaySignalsOff();
306
                                        m_Doc->m_Selection->setGroupRect();
19856 fschmid 307
                                        if (m_Doc->view() != NULL)
308
                                                m_Doc->view()->updatesOn(true);
16729 fschmid 309
                                }
310
                        }
311
                        else
312
                        {
313
                                m_Doc->DragP = true;
314
                                m_Doc->DraggedElem = 0;
315
                                m_Doc->DragElements.clear();
316
                                m_Doc->m_Selection->delaySignalsOn();
317
                                for (int dre=0; dre<Elements.count(); ++dre)
318
                                {
319
                                        tmpSele->addItem(Elements.at(dre), true);
320
                                }
321
                                tmpSele->setGroupRect();
18028 jghali 322
                                ScElemMimeData* md = ScriXmlDoc::WriteToMimeData(m_Doc, tmpSele);
16729 fschmid 323
                                m_Doc->itemSelection_DeleteItem(tmpSele);
324
                                m_Doc->view()->updatesOn(true);
325
                                m_Doc->m_Selection->delaySignalsOff();
326
                                // We must copy the TransationSettings object as it is owned
327
                                // by handleObjectImport method afterwards
328
                                TransactionSettings* transacSettings = new TransactionSettings(trSettings);
329
                                m_Doc->view()->handleObjectImport(md, transacSettings);
330
                                m_Doc->DragP = false;
331
                                m_Doc->DraggedElem = 0;
332
                                m_Doc->DragElements.clear();
333
                        }
334
                }
335
                else
336
                {
337
                        m_Doc->changed();
338
                        m_Doc->reformPages();
339
                        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
340
                                m_Doc->view()->updatesOn(true);
341
                }
342
                success = true;
343
        }
344
        else
345
        {
346
                QDir::setCurrent(CurDirP);
347
                m_Doc->DoDrawing = true;
348
                m_Doc->scMW()->setScriptRunning(false);
349
                if (!(flags & LoadSavePlugin::lfLoadAsPattern))
350
                        m_Doc->view()->updatesOn(true);
351
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
18076 fschmid 352
                success = false;
16729 fschmid 353
        }
354
        if (interactive)
355
                m_Doc->setLoading(false);
356
        //CB If we have a gui we must refresh it if we have used the progressbar
357
        if (!(flags & LoadSavePlugin::lfLoadAsPattern))
358
        {
359
                if ((showProgress) && (!interactive))
360
                        m_Doc->view()->DrawNew();
361
        }
18181 fschmid 362
        qApp->restoreOverrideCursor();
16729 fschmid 363
        return success;
364
}
365
 
366
PdfPlug::~PdfPlug()
367
{
368
        if (progressDialog)
369
                delete progressDialog;
370
        delete tmpSele;
371
}
372
 
21958 craig 373
bool PdfPlug::convert(const QString& fn)
16729 fschmid 374
{
17448 fschmid 375
        bool firstPg = true;
376
        int currentLayer = m_Doc->activeLayer();
17498 fschmid 377
        int baseLayer = m_Doc->activeLayer();
16729 fschmid 378
        importedColors.clear();
19489 jghali 379
        if (progressDialog)
16729 fschmid 380
        {
381
                progressDialog->setOverallProgress(2);
382
                progressDialog->setLabel("GI", tr("Generating Items"));
383
                qApp->processEvents();
384
        }
385
        QFile f(fn);
386
        oldDocItemCount = m_Doc->Items->count();
387
        if (progressDialog)
388
        {
389
                progressDialog->setBusyIndicator("GI");
390
                qApp->processEvents();
391
        }
392
 
393
        globalParams = new GlobalParams();
17851 fschmid 394
        GooString *userPW = NULL;
16729 fschmid 395
        if (globalParams)
396
        {
397
                GooString *fname = new GooString(QFile::encodeName(fn).data());
398
                globalParams->setErrQuiet(gTrue);
17448 fschmid 399
                GBool hasOcg = gFalse;
400
                QList<OptionalContentGroup*> ocgGroups;
16729 fschmid 401
//              globalParams->setPrintCommands(gTrue);
17851 fschmid 402
                PDFDoc *pdfDoc = new PDFDoc(fname, NULL, NULL, NULL);
16729 fschmid 403
                if (pdfDoc)
404
                {
17851 fschmid 405
                        if (pdfDoc->getErrorCode() == errEncrypted)
406
                        {
407
                                delete pdfDoc;
408
                                pdfDoc = NULL;
409
                                if (progressDialog)
410
                                        progressDialog->hide();
411
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
21961 craig 412
                                ScribusMainWindow* mw = m_Doc->scMW();
17851 fschmid 413
                                bool ok;
414
                                QString text = QInputDialog::getText(mw, tr("Open PDF-File"), tr("Password"), QLineEdit::Normal, "", &ok);
415
                                if (ok && !text.isEmpty())
416
                                {
417
                                        fname = new GooString(QFile::encodeName(fn).data());
418
                                        userPW = new GooString(text.toLocal8Bit().data());
419
                                        pdfDoc = new PDFDoc(fname, userPW, userPW, NULL);
420
                                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
421
                                }
422
                                if ((!pdfDoc) || (pdfDoc->getErrorCode() != errNone))
423
                                {
424
                                        if (progressDialog)
425
                                                progressDialog->close();
426
                                        delete pdfDoc;
427
                                        delete globalParams;
428
                                        return false;
429
                                }
430
                                if (progressDialog)
431
                                        progressDialog->show();
432
                        }
16729 fschmid 433
                        if (pdfDoc->isOk())
434
                        {
17880 fschmid 435
                                std::vector<int> pageNs;
436
                                QString pageString = "*";
437
                                m_pdfDoc = pdfDoc;
16729 fschmid 438
                                double hDPI = 72.0;
439
                                double vDPI = 72.0;
440
                                int firstPage = 1;
441
                                int lastPage = pdfDoc->getNumPages();
18004 fschmid 442
                                GBool useMediaBox = gTrue;
20125 fschmid 443
                                GBool crop = gTrue;
18004 fschmid 444
                                GBool printing = gFalse;
445
                                PDFRectangle *mediaBox = pdfDoc->getPage(1)->getMediaBox();
446
                                QRectF mediaRect = QRectF(QPointF(mediaBox->x1, mediaBox->y1), QPointF(mediaBox->x2, mediaBox->y2)).normalized();
447
                                bool boxesAreDifferent = false;
448
                                if (getCBox(Crop_Box, 1) != mediaRect)
449
                                        boxesAreDifferent = true;
450
                                else if (getCBox(Trim_Box, 1) != mediaRect)
451
                                        boxesAreDifferent = true;
452
                                else if (getCBox(Bleed_Box, 1) != mediaRect)
453
                                        boxesAreDifferent = true;
454
                                else if (getCBox(Art_Box, 1) != mediaRect)
455
                                        boxesAreDifferent = true;
456
                                bool cropped = false;
457
                                int contentRect = Media_Box;
458
                                if (((interactive) || (importerFlags & LoadSavePlugin::lfCreateDoc)) && ((lastPage > 1) || boxesAreDifferent))
17880 fschmid 459
                                {
460
                                        if (progressDialog)
461
                                                progressDialog->hide();
462
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
463
                                        PdfImportOptions *optImp = new PdfImportOptions(ScCore->primaryMainWindow());
17885 fschmid 464
                                        QFileInfo fi = QFileInfo(fn);
18006 fschmid 465
                                        optImp->setUpOptions(fi.fileName(), firstPage, lastPage, interactive, boxesAreDifferent, this);
17880 fschmid 466
                                        if (!optImp->exec())
467
                                        {
468
                                                if (progressDialog)
469
                                                        progressDialog->close();
470
                                                delete optImp;
471
                                                delete pdfDoc;
472
                                                delete globalParams;
473
                                                return false;
474
                                        }
475
                                        pageString = optImp->getPagesString();
20125 fschmid 476
                                        contentRect = optImp->getCropBox();
477
                                        cropped = optImp->croppingEnabled();
478
                                        if (!cropped)
479
                                                crop = cropped;
480
                                        if (contentRect != Media_Box)
481
                                                useMediaBox = gFalse;
482
                                /*      if (cb > Media_Box)
18004 fschmid 483
                                        {
484
                                                cropped = true;
485
                                                contentRect = cb;
20125 fschmid 486
                                        } */
17880 fschmid 487
                                        delete optImp;
488
                                        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
489
                                        if (progressDialog)
490
                                                progressDialog->show();
491
                                }
492
                                parsePagesString(pageString, &pageNs, lastPage);
493
                                firstPage = pageNs[0];
17448 fschmid 494
                                SlaOutputDev *dev = new SlaOutputDev(m_Doc, &Elements, &importedColors, importerFlags);
495
                                if (dev->isOk())
17444 fschmid 496
                                {
17448 fschmid 497
                                        OCGs* ocg = pdfDoc->getOptContentConfig();
498
                                        if (ocg)
17444 fschmid 499
                                        {
17448 fschmid 500
                                                hasOcg = ocg->hasOCGs();
501
                                                if (hasOcg)
17444 fschmid 502
                                                {
17498 fschmid 503
 
504
                                                        QStringList ocgNames;
17448 fschmid 505
                                                        Array *order = ocg->getOrderArray();
506
                                                        if (order)
17444 fschmid 507
                                                        {
17448 fschmid 508
                                                                for (int i = 0; i < order->getLength (); ++i)
17444 fschmid 509
                                                                {
17448 fschmid 510
                                                                        Object orderItem;
511
                                                                        order->get(i, &orderItem);
512
                                                                        if (orderItem.isDict())
17444 fschmid 513
                                                                        {
17448 fschmid 514
                                                                                Object ref;
515
                                                                                order->getNF(i, &ref);
516
                                                                                if (ref.isRef())
517
                                                                                {
518
                                                                                        OptionalContentGroup *oc = ocg->findOcgByRef(ref.getRef());
17498 fschmid 519
                                                                                        QString ocgName = UnicodeParsedString(oc->getName());
520
                                                                                        if (!ocgNames.contains(ocgName))
521
                                                                                        {
522
                                                                                                ocgGroups.prepend(oc);
523
                                                                                                ocgNames.append(ocgName);
524
                                                                                        }
17448 fschmid 525
                                                                                }
526
                                                                                ref.free();
17444 fschmid 527
                                                                        }
17498 fschmid 528
                                                                        else
529
                                                                        {
530
                                                                                GooList *ocgs;
531
                                                                                int i;
532
                                                                                ocgs = ocg->getOCGs ();
533
                                                                                for (i = 0; i < ocgs->getLength (); ++i)
534
                                                                                {
535
                                                                                        OptionalContentGroup *oc = (OptionalContentGroup *)ocgs->get(i);
536
                                                                                        QString ocgName = UnicodeParsedString(oc->getName());
537
                                                                                        if (!ocgNames.contains(ocgName))
538
                                                                                        {
539
                                                                                                ocgGroups.prepend(oc);
540
                                                                                                ocgNames.append(ocgName);
541
                                                                                        }
542
                                                                                }
543
                                                                        }
17444 fschmid 544
                                                                }
545
                                                        }
17448 fschmid 546
                                                        else
17444 fschmid 547
                                                        {
17448 fschmid 548
                                                                GooList *ocgs;
549
                                                                int i;
550
                                                                ocgs = ocg->getOCGs ();
551
                                                                for (i = 0; i < ocgs->getLength (); ++i)
552
                                                                {
553
                                                                        OptionalContentGroup *oc = (OptionalContentGroup *)ocgs->get(i);
17498 fschmid 554
                                                                        QString ocgName = UnicodeParsedString(oc->getName());
555
                                                                        if (!ocgNames.contains(ocgName))
556
                                                                        {
557
                                                                                ocgGroups.prepend(oc);
558
                                                                                ocgNames.append(ocgName);
559
                                                                        }
17448 fschmid 560
                                                                }
17444 fschmid 561
                                                        }
562
                                                }
563
                                        }
18000 fschmid 564
                                        bool rotated = false;
17419 fschmid 565
                                        dev->startDoc(pdfDoc, pdfDoc->getXRef(), pdfDoc->getCatalog());
16729 fschmid 566
                                        int rotate = pdfDoc->getPageRotate(firstPage);
18000 fschmid 567
                                        if ((rotate == 90) || (rotate == 270))
568
                                                rotated = true;
18018 fschmid 569
                                        dev->rotate = rotate;
18000 fschmid 570
                                        rotate = 0;
16729 fschmid 571
                                        if (importerFlags & LoadSavePlugin::lfCreateDoc)
572
                                        {
17498 fschmid 573
// POPPLER_VERSION appeared in 0.19.0 first
574
#ifdef POPPLER_VERSION
17448 fschmid 575
                                                if (hasOcg)
576
                                                {
17498 fschmid 577
                                                        QString actL = m_Doc->activeLayerName();
17448 fschmid 578
                                                        for (int a = 0; a < ocgGroups.count(); a++)
579
                                                        {
580
                                                                OptionalContentGroup *oc = ocgGroups[a];
17498 fschmid 581
                                                                if (actL != UnicodeParsedString(oc->getName()))
582
                                                                        currentLayer = m_Doc->addLayer(UnicodeParsedString(oc->getName()), false);
17448 fschmid 583
                                                                else
17498 fschmid 584
                                                                        currentLayer = m_Doc->layerIDFromName(UnicodeParsedString(oc->getName()));
20125 fschmid 585
                                                                if (oc->getState() == OptionalContentGroup::On)
17448 fschmid 586
                                                                        m_Doc->setLayerVisible(currentLayer, true);
20125 fschmid 587
                                                                else if (oc->getViewState() == OptionalContentGroup::ocUsageOn)
588
                                                                        m_Doc->setLayerVisible(currentLayer, true);
17448 fschmid 589
                                                                else
590
                                                                        m_Doc->setLayerVisible(currentLayer, false);
591
                                                                if ((oc->getPrintState() == OptionalContentGroup::ocUsageOn) || (oc->getPrintState() == OptionalContentGroup::ocUsageUnset))
592
                                                                        m_Doc->setLayerPrintable(currentLayer, true);
593
                                                                else
594
                                                                        m_Doc->setLayerPrintable(currentLayer, false);
595
                                                                oc->setState(OptionalContentGroup::Off);
596
                                                        }
597
                                                        dev->layersSetByOCG = true;
598
                                                }
17498 fschmid 599
#endif
16729 fschmid 600
                                                Object info;
601
                                                pdfDoc->getDocInfo(&info);
602
                                                if (info.isDict())
603
                                                {
604
                                                        Object obj;
19728 fschmid 605
                                                //      GooString *s1;
16729 fschmid 606
                                                        Dict *infoDict = info.getDict();
16732 fschmid 607
                                                        if (infoDict->lookup((char*)"Title", &obj )->isString())
16729 fschmid 608
                                                        {
19728 fschmid 609
                                                //              s1 = obj.getString();
16729 fschmid 610
                                                                m_Doc->documentInfo().setTitle(UnicodeParsedString(obj.getString()));
611
                                                                obj.free();
612
                                                        }
16732 fschmid 613
                                                        if (infoDict->lookup((char*)"Author", &obj )->isString())
16729 fschmid 614
                                                        {
19728 fschmid 615
                                                //              s1 = obj.getString();
16729 fschmid 616
                                                                m_Doc->documentInfo().setAuthor(UnicodeParsedString(obj.getString()));
617
                                                                obj.free();
618
                                                        }
16732 fschmid 619
                                                        if (infoDict->lookup((char*)"Subject", &obj )->isString())
16729 fschmid 620
                                                        {
19728 fschmid 621
                                                //              s1 = obj.getString();
16729 fschmid 622
                                                                m_Doc->documentInfo().setSubject(UnicodeParsedString(obj.getString()));
623
                                                                obj.free();
624
                                                        }
16732 fschmid 625
                                                        if (infoDict->lookup((char*)"Keywords", &obj )->isString())
16729 fschmid 626
                                                        {
19728 fschmid 627
                                                //              s1 = obj.getString();
16729 fschmid 628
                                                                m_Doc->documentInfo().setKeywords(UnicodeParsedString(obj.getString()));
629
                                                                obj.free();
630
                                                        }
631
                                                }
632
                                                info.free();
18004 fschmid 633
                                                if (cropped)
17885 fschmid 634
                                                {
18004 fschmid 635
                                                        QRectF crBox = getCBox(contentRect, pageNs[0]);
18000 fschmid 636
                                                        if (rotated)
637
                                                        {
18004 fschmid 638
                                                                m_Doc->setPageWidth(crBox.height());
639
                                                                m_Doc->setPageHeight(crBox.width());
18000 fschmid 640
                                                        }
641
                                                        else
642
                                                        {
18004 fschmid 643
                                                                m_Doc->setPageHeight(crBox.height());
644
                                                                m_Doc->setPageWidth(crBox.width());
18000 fschmid 645
                                                        }
17885 fschmid 646
                                                }
647
                                                else
648
                                                {
18000 fschmid 649
                                                        if (rotated)
650
                                                        {
651
                                                                m_Doc->setPageWidth(pdfDoc->getPageMediaHeight(pageNs[0]));
652
                                                                m_Doc->setPageHeight(pdfDoc->getPageMediaWidth(pageNs[0]));
653
                                                        }
654
                                                        else
655
                                                        {
656
                                                                m_Doc->setPageHeight(pdfDoc->getPageMediaHeight(pageNs[0]));
657
                                                                m_Doc->setPageWidth(pdfDoc->getPageMediaWidth(pageNs[0]));
658
                                                        }
17885 fschmid 659
                                                }
17838 fschmid 660
                                                m_Doc->setPageSize("Custom");
18394 fschmid 661
                                        //      m_Doc->pdfOptions().PresentVals.clear();
17880 fschmid 662
                                                for (uint ap = 0; ap < pageNs.size(); ++ap)
17448 fschmid 663
                                                {
17880 fschmid 664
                                                        int pp = pageNs[ap];
17498 fschmid 665
                                                        m_Doc->setActiveLayer(baseLayer);
17448 fschmid 666
                                                        if (firstPg)
667
                                                                firstPg = false;
668
                                                        else
17880 fschmid 669
                                                                m_Doc->addPage(ap);
22089 jghali 670
                                                        QRectF mdBox = getCBox(0, pp);
18004 fschmid 671
                                                        QRectF crBox = getCBox(contentRect, pp);
672
                                                        if (cropped)
17885 fschmid 673
                                                        {
18000 fschmid 674
                                                                if (rotated)
675
                                                                {
18004 fschmid 676
                                                                        m_Doc->currentPage()->setInitialWidth(crBox.height());
677
                                                                        m_Doc->currentPage()->setInitialHeight(crBox.width());
678
                                                                        m_Doc->currentPage()->setWidth(crBox.height());
679
                                                                        m_Doc->currentPage()->setHeight(crBox.width());
680
                                                                        dev->cropOffsetX = crBox.y();
681
                                                                        dev->cropOffsetY = crBox.x();
18000 fschmid 682
                                                                }
683
                                                                else
684
                                                                {
18004 fschmid 685
                                                                        m_Doc->currentPage()->setInitialHeight(crBox.height());
686
                                                                        m_Doc->currentPage()->setInitialWidth(crBox.width());
687
                                                                        m_Doc->currentPage()->setHeight(crBox.height());
688
                                                                        m_Doc->currentPage()->setWidth(crBox.width());
689
                                                                        dev->cropOffsetX = crBox.x();
690
                                                                        dev->cropOffsetY = crBox.y();
18000 fschmid 691
                                                                }
17885 fschmid 692
                                                        }
693
                                                        else
694
                                                        {
18000 fschmid 695
                                                                if (rotated)
696
                                                                {
697
                                                                        m_Doc->currentPage()->setInitialWidth(pdfDoc->getPageMediaHeight(pp));
698
                                                                        m_Doc->currentPage()->setInitialHeight(pdfDoc->getPageMediaWidth(pp));
699
                                                                        m_Doc->currentPage()->setWidth(pdfDoc->getPageMediaHeight(pp));
700
                                                                        m_Doc->currentPage()->setHeight(pdfDoc->getPageMediaWidth(pp));
701
                                                                }
702
                                                                else
703
                                                                {
704
                                                                        m_Doc->currentPage()->setInitialHeight(pdfDoc->getPageMediaHeight(pp));
705
                                                                        m_Doc->currentPage()->setInitialWidth(pdfDoc->getPageMediaWidth(pp));
706
                                                                        m_Doc->currentPage()->setHeight(pdfDoc->getPageMediaHeight(pp));
707
                                                                        m_Doc->currentPage()->setWidth(pdfDoc->getPageMediaWidth(pp));
708
                                                                }
17885 fschmid 709
                                                        }
17448 fschmid 710
                                                        m_Doc->currentPage()->MPageNam = CommonStrings::trMasterPageNormal;
711
                                                        m_Doc->currentPage()->m_pageSize = "Custom";
712
                                                        m_Doc->reformPages(true);
713
                                                        if (hasOcg)
714
                                                        {
20125 fschmid 715
                                                        //      int numObj = m_Doc->Items->count();
716
                                                        //      if (cropped)
717
                                                        //              pdfDoc->displayPageSlice(dev, pp, hDPI, vDPI, rotate, useMediaBox, crop, printing, crBox.x(), crBox.y(), crBox.width(), crBox.height(), NULL, NULL, dev->annotations_callback, dev);
718
                                                        //      else
719
                                                        //              pdfDoc->displayPage(dev, pp, hDPI, vDPI, rotate, useMediaBox, crop, printing, NULL, NULL, dev->annotations_callback, dev);
720
                                                        //      int numObj2 = m_Doc->Items->count();
721
                                                        //      int countObj = numObj2 - numObj;
17448 fschmid 722
                                                                for (int a = 0; a < ocgGroups.count(); a++)
723
                                                                {
724
                                                                        OptionalContentGroup *oc = ocgGroups[a];
20125 fschmid 725
                                                        //              m_Doc->setActiveLayer(UnicodeParsedString(oc->getName()));
726
                                                        //              currentLayer = m_Doc->activeLayer();
17448 fschmid 727
                                                                        oc->setState(OptionalContentGroup::On);
20125 fschmid 728
                                                                        if (cropped)
22089 jghali 729
                                                                                pdfDoc->displayPageSlice(dev, pp, hDPI, vDPI, rotate, useMediaBox, crop, printing, crBox.x() - mdBox.x(), mdBox.bottom() - crBox.bottom(), crBox.width(), crBox.height(), NULL, NULL, dev->annotations_callback, dev);
20125 fschmid 730
                                                                        else
731
                                                                                pdfDoc->displayPage(dev, pp, hDPI, vDPI, rotate, useMediaBox, crop, printing, NULL, NULL, dev->annotations_callback, dev);
732
                                                                        oc->setState(OptionalContentGroup::Off);
733
                                                        //              for (int dd = 0; dd < countObj; dd++)
734
                                                        //              {
735
                                                        //                      PageItem *iteD = m_Doc->Items->takeAt(numObj2);
736
                                                        //                      delete iteD;
737
                                                        //              }
738
                                                        //              numObj2 = m_Doc->Items->count();
17448 fschmid 739
                                                                }
740
                                                        }
741
                                                        else
18004 fschmid 742
                                                        {
743
                                                                if (cropped)
22089 jghali 744
                                                                        pdfDoc->displayPageSlice(dev, pp, hDPI, vDPI, rotate, useMediaBox, crop, printing, crBox.x() - mdBox.x(), mdBox.bottom() - crBox.bottom(), crBox.width(), crBox.height(), NULL, NULL, dev->annotations_callback, dev);
18004 fschmid 745
                                                                else
746
                                                                        pdfDoc->displayPage(dev, pp, hDPI, vDPI, rotate, useMediaBox, crop, printing, NULL, NULL, dev->annotations_callback, dev);
747
                                                        }
17859 fschmid 748
                                                        PDFPresentationData ef;
749
                                                        Object trans;
17880 fschmid 750
                                                        Object *transi = pdfDoc->getPage(pp)->getTrans(&trans);
17859 fschmid 751
                                                        if (transi->isDict())
752
                                                        {
753
                                                                m_Doc->pdfOptions().PresentMode = true;
754
                                                                PageTransition *pgTrans = new PageTransition(transi);
18394 fschmid 755
                                                                ef.pageViewDuration = pdfDoc->getPage(pp)->getDuration();
17859 fschmid 756
                                                                ef.pageEffectDuration = pgTrans->getDuration();
757
                                                                ef.Dm = pgTrans->getAlignment() == transitionHorizontal ? 0 : 1;
758
                                                                ef.M = pgTrans->getDirection() == transitionInward ? 0 : 1;
759
                                                                int ang = pgTrans->getAngle();
760
                                                                if (ang == 0)
761
                                                                        ef.Di = 0;
762
                                                                else if (ang == 270)
763
                                                                        ef.Di = 1;
764
                                                                else if (ang == 90)
765
                                                                        ef.Di = 2;
766
                                                                else if (ang == 180)
767
                                                                        ef.Di = 3;
768
                                                                else if (ang == 315)
769
                                                                        ef.Di = 4;
770
                                                                PageTransitionType trType = pgTrans->getType();
771
                                                                if (trType == transitionReplace)
772
                                                                        ef.effectType = 0;
773
                                                                else if (trType == transitionBlinds)
774
                                                                        ef.effectType = 1;
775
                                                                else if (trType == transitionBox)
776
                                                                        ef.effectType = 2;
777
                                                                else if (trType == transitionDissolve)
778
                                                                        ef.effectType = 3;
779
                                                                else if (trType == transitionGlitter)
780
                                                                        ef.effectType = 4;
781
                                                                else if (trType == transitionSplit)
782
                                                                        ef.effectType = 5;
783
                                                                else if (trType == transitionWipe)
784
                                                                        ef.effectType = 6;
785
                                                                else if (trType == transitionPush)
786
                                                                        ef.effectType = 7;
787
                                                                else if (trType == transitionCover)
788
                                                                        ef.effectType = 8;
789
                                                                else if (trType == transitionUncover)
790
                                                                        ef.effectType = 9;
791
                                                                else if (trType == transitionFade)
792
                                                                        ef.effectType = 10;
793
                                                                delete pgTrans;
794
                                                        }
18394 fschmid 795
                                                        m_Doc->currentPage()->PresentVals = ef;
17859 fschmid 796
                                                        trans.free();
797
                                                        transi->free();
17448 fschmid 798
                                                }
17847 fschmid 799
                                                int numjs = pdfDoc->getCatalog()->numJS();
800
                                                if (numjs > 0)
801
                                                {
802
                                                        NameTree *jsNameTreeP = new NameTree();
803
                                                        Object catDict;
804
                                                        pdfDoc->getXRef()->getCatalog(&catDict);
805
                                                        if (catDict.isDict())
806
                                                        {
17857 fschmid 807
                                                                Object names;
17847 fschmid 808
                                                                catDict.dictLookup("Names", &names);
809
                                                                if (names.isDict())
810
                                                                {
811
                                                                        Object obj;
812
                                                                        names.dictLookup("JavaScript", &obj);
813
                                                                        jsNameTreeP->init(pdfDoc->getXRef(), &obj);
814
                                                                        obj.free();
815
                                                                }
816
                                                                for (int a = 0; a < numjs; a++)
817
                                                                {
818
                                                                        m_Doc->JavaScripts.insert(UnicodeParsedString(jsNameTreeP->getName(a)), UnicodeParsedString(pdfDoc->getCatalog()->getJS(a)));
819
                                                                }
820
                                                                names.free();
17857 fschmid 821
                                                                catDict.dictLookup("OpenAction", &names);
822
                                                                if (names.isDict())
823
                                                                {
824
                                                                        LinkAction *linkAction = NULL;
825
                                                                        linkAction = LinkAction::parseAction(&names, pdfDoc->getCatalog()->getBaseURI());
826
                                                                        if (linkAction)
827
                                                                        {
828
                                                                                LinkJavaScript *jsa = (LinkJavaScript*)linkAction;
829
                                                                                if (jsa->isOk())
830
                                                                                {
831
                                                                                        QString script = UnicodeParsedString(jsa->getScript());
832
                                                                                        if (script.startsWith("this."))
833
                                                                                        {
834
                                                                                                script.remove(0, 5);
835
                                                                                                script.remove("()");
836
                                                                                                if (m_Doc->JavaScripts.contains(script))
837
                                                                                                        m_Doc->pdfOptions().openAction = script;
838
                                                                                        }
839
                                                                                }
840
                                                                        }
841
                                                                }
842
                                                                names.free();
17847 fschmid 843
                                                        }
844
                                                        catDict.free();
845
                                                        delete jsNameTreeP;
846
                                                }
17849 fschmid 847
                                                m_Doc->pdfOptions().Version = (PDFOptions::PDFVersion)qMin(15, qMax(13, pdfDoc->getPDFMajorVersion() * 10 + pdfDoc->getPDFMinorVersion()));
848
                                                ViewerPreferences *viewPrefs = pdfDoc->getCatalog()->getViewerPreferences();
849
                                                if (viewPrefs)
850
                                                {
851
                                                        m_Doc->pdfOptions().Binding = viewPrefs->getDirection() == ViewerPreferences::directionL2R ? 0 : 1;
852
                                                        m_Doc->pdfOptions().hideMenuBar = viewPrefs->getHideMenubar();
853
                                                        m_Doc->pdfOptions().hideToolBar = viewPrefs->getHideToolbar();
854
                                                        m_Doc->pdfOptions().fitWindow = viewPrefs->getFitWindow();
855
                                                }
856
                                                Catalog::PageMode pgm = pdfDoc->getCatalog()->getPageMode();
857
                                                m_Doc->pdfOptions().displayFullscreen = (pgm == Catalog::pageModeFullScreen);
858
                                                m_Doc->pdfOptions().displayThumbs = (pgm == Catalog::pageModeThumbs);
859
                                                m_Doc->pdfOptions().displayBookmarks = (pgm == Catalog::pageModeOutlines);
860
                                                m_Doc->pdfOptions().displayLayers = (pgm == Catalog::pageModeOC);
861
                                                Catalog::PageLayout pgl = pdfDoc->getCatalog()->getPageLayout();
862
                                                if (pgl == Catalog::pageLayoutSinglePage)
863
                                                        m_Doc->pdfOptions().PageLayout = PDFOptions::SinglePage;
864
                                                else if (pgl == Catalog::pageLayoutOneColumn)
865
                                                        m_Doc->pdfOptions().PageLayout = PDFOptions::OneColumn;
20300 fschmid 866
                                                else if ((pgl == Catalog::pageLayoutTwoColumnLeft) || (pgl == Catalog::pageLayoutTwoPageLeft))
867
                                                {
868
                                                        m_Doc->resetPage(1);
869
                                                        m_Doc->setPageSetFirstPage(1, 0);
17849 fschmid 870
                                                        m_Doc->pdfOptions().PageLayout = PDFOptions::TwoColumnLeft;
20300 fschmid 871
                                                }
872
                                                else if ((pgl == Catalog::pageLayoutTwoColumnRight) || (pgl == Catalog::pageLayoutTwoPageRight))
873
                                                {
874
                                                        m_Doc->resetPage(1);
875
                                                        m_Doc->setPageSetFirstPage(1, 1);
17849 fschmid 876
                                                        m_Doc->pdfOptions().PageLayout = PDFOptions::TwoColumnRight;
20300 fschmid 877
                                                }
16729 fschmid 878
                                        }
879
                                        else
17448 fschmid 880
                                        {
881
                                                if (hasOcg)
882
                                                {
883
                                                        for (int a = 0; a < ocgGroups.count(); a++)
884
                                                        {
885
                                                                ocgGroups[a]->setState(OptionalContentGroup::On);
886
                                                        }
887
                                                }
17837 fschmid 888
                                                pdfDoc->displayPage(dev, firstPage, hDPI, vDPI, rotate, useMediaBox, crop, printing, NULL, NULL, dev->annotations_callback, dev);
17448 fschmid 889
                                        }
16729 fschmid 890
                                }
891
                                delete dev;
892
                        }
893
                }
894
                delete pdfDoc;
895
        }
896
        delete globalParams;
897
        globalParams = 0;
898
 
899
//      qDebug() << "converting finished";
900
//      qDebug() << "Imported" << Elements.count() << "Elements";
901
 
902
        if (Elements.count() == 0)
903
        {
904
                if (importedColors.count() != 0)
905
                {
906
                        for (int cd = 0; cd < importedColors.count(); cd++)
907
                        {
908
                                m_Doc->PageColors.remove(importedColors[cd]);
909
                        }
910
                }
911
        }
912
 
913
        if (progressDialog)
914
                progressDialog->close();
915
        return true;
916
}
917
 
18004 fschmid 918
QImage PdfPlug::readPreview(int pgNum, int width, int height, int box)
17880 fschmid 919
{
920
        if (!m_pdfDoc)
921
                return QImage();
22088 jghali 922
 
17880 fschmid 923
        double h = m_pdfDoc->getPageMediaHeight(pgNum);
924
        double w = m_pdfDoc->getPageMediaWidth(pgNum);
925
        double scale = qMin(height / h, width / w);
926
        double hDPI = 72.0 * scale;
927
        double vDPI = 72.0 * scale;
928
        SplashColor bgColor;
929
        bgColor[0] = 255;
930
        bgColor[1] = 255;
931
        bgColor[2] = 255;
19806 jghali 932
        SplashOutputDev *dev = new SplashOutputDev(splashModeXBGR8, 4, gFalse, bgColor, gTrue);
17880 fschmid 933
        dev->setVectorAntialias(gTrue);
934
        dev->setFreeTypeHinting(gTrue, gFalse);
935
        dev->startDoc(m_pdfDoc);
936
        m_pdfDoc->displayPage(dev, pgNum, hDPI, vDPI, 0, gTrue, gFalse, gFalse);
937
        SplashBitmap *bitmap = dev->getBitmap();
938
        int bw = bitmap->getWidth();
939
        int bh = bitmap->getHeight();
940
        SplashColorPtr dataPtr = bitmap->getDataPtr();
941
        if (QSysInfo::BigEndian == QSysInfo::ByteOrder)
942
        {
943
                uchar c;
944
                int count = bw * bh * 4;
945
                for (int k = 0; k < count; k += 4)
946
                {
947
                        c = dataPtr[k];
948
                        dataPtr[k] = dataPtr[k+3];
949
                        dataPtr[k+3] = c;
950
                        c = dataPtr[k+1];
951
                        dataPtr[k+1] = dataPtr[k+2];
952
                        dataPtr[k+2] = c;
953
                }
954
        }
955
        // construct a qimage SHARING the raw bitmap data in memory
956
        QImage tmpimg( dataPtr, bw, bh, QImage::Format_ARGB32 );
957
        QImage image = tmpimg.copy();
958
        image.setText("XSize", QString("%1").arg(w));
959
        image.setText("YSize", QString("%1").arg(h));
18004 fschmid 960
        if (box > Media_Box)
961
        {
962
                QRectF cRect = getCBox(box, pgNum);
22088 jghali 963
                QRectF mediaRect = getCBox(0, pgNum);
964
                cRect.moveTo(cRect.x() - mediaRect.x(), cRect.y() - mediaRect.y());
18004 fschmid 965
                QPainter pp;
966
                pp.begin(&image);
967
                pp.setBrush(Qt::NoBrush);
968
                pp.setPen(QPen(Qt::red, 1.0));
969
                pp.translate(0, bh);
970
                pp.scale(scale, -scale);
971
                pp.drawRect(cRect);
972
                pp.end();
973
        }
17880 fschmid 974
        delete dev;
975
        return image;
976
}
977
 
18004 fschmid 978
QRectF PdfPlug::getCBox(int box, int pgNum)
979
{
18060 jghali 980
        PDFRectangle *cBox = NULL;
981
        if (box == Media_Box)
982
                cBox = m_pdfDoc->getPage(pgNum)->getMediaBox();
983
        else if (box == Bleed_Box)
18004 fschmid 984
                cBox = m_pdfDoc->getPage(pgNum)->getBleedBox();
985
        else if (box == Trim_Box)
986
                cBox = m_pdfDoc->getPage(pgNum)->getTrimBox();
987
        else if (box == Crop_Box)
988
                cBox = m_pdfDoc->getPage(pgNum)->getCropBox();
989
        else if (box == Art_Box)
990
                cBox = m_pdfDoc->getPage(pgNum)->getArtBox();
991
        QRectF cRect = QRectF(QPointF(cBox->x1, cBox->y1), QPointF(cBox->x2, cBox->y2)).normalized();
992
        return cRect;
993
}
994
 
16729 fschmid 995
QString PdfPlug::UnicodeParsedString(GooString *s1)
996
{
997
        if ( !s1 || s1->getLength() == 0 )
998
                return QString();
999
        GBool isUnicode;
1000
        int i;
1001
        Unicode u;
1002
        QString result;
1003
        if ((s1->getChar(0) & 0xff) == 0xfe && (s1->getLength() > 1 && (s1->getChar(1) & 0xff) == 0xff))
1004
        {
1005
                isUnicode = gTrue;
1006
                i = 2;
1007
                result.reserve((s1->getLength() - 2) / 2);
1008
        }
1009
        else
1010
        {
1011
                isUnicode = gFalse;
1012
                i = 0;
1013
                result.reserve(s1->getLength());
1014
        }
1015
        while (i < s1->getLength())
1016
        {
1017
                if (isUnicode)
1018
                {
1019
                        u = ((s1->getChar(i) & 0xff) << 8) | (s1->getChar(i+1) & 0xff);
1020
                        i += 2;
1021
                }
1022
                else
1023
                {
1024
                        u = s1->getChar(i) & 0xff;
1025
                        ++i;
1026
                }
1027
                result += QChar( u );
1028
        }
1029
        return result;
1030
}