Subversion Repositories Scribus

Rev

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