Subversion Repositories Scribus

Rev

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