diff --git a/autotests/pdfdocumenttest.cpp b/autotests/pdfdocumenttest.cpp
index 4a5850b..21f141d 100644
--- a/autotests/pdfdocumenttest.cpp
+++ b/autotests/pdfdocumenttest.cpp
@@ -1,85 +1,83 @@
 /*
     Copyright (C) 2018 Volker Krause <vkrause@kde.org>
 
     This program is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This program is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include <KItinerary/PdfDocument>
 #include <config-kitinerary.h>
 
 #include <QDebug>
 #include <QFile>
 #include <QImage>
 #include <QObject>
 #include <QTest>
 
 using namespace KItinerary;
 
 class PdfDocumentTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void testPdfDocument()
     {
         QFile f(QStringLiteral(SOURCE_DIR "/misc/test.pdf"));
         QVERIFY(f.open(QFile::ReadOnly));
 #ifdef HAVE_POPPLER
         std::unique_ptr<PdfDocument> doc(PdfDocument::fromData(f.readAll()));
         QVERIFY(doc);
         QCOMPARE(doc->text(), QStringLiteral("This is the first page.\nIt contains a PDF 417 barcode.\nThis is the second page.\nIt contains an Aztec code.\n"));
-        QCOMPARE(doc->imageCount(), 2);
         QCOMPARE(doc->pageCount(), 2);
         QCOMPARE(doc->property("pages").toList().size(), 2);
-        QCOMPARE(doc->property("images").toList().size(), 2);
 
         auto page = doc->page(0);
         QCOMPARE(page.text(), QStringLiteral("This is the first page.\nIt contains a PDF 417 barcode.\n"));
         QCOMPARE(page.imageCount(), 1);
         QCOMPARE(PdfPage::staticMetaObject.property(1).readOnGadget(&page).toList().size(), 1);
 
         QCOMPARE(page.textInRect(0, 0, 1, 0.5), QStringLiteral("This is the first page.\nIt contains a PDF 417 barcode.\n"));
         QCOMPARE(page.textInRect(0, 0.5, 1, 1), QString());
 
         auto img = page.image(0);
         QCOMPARE(img.width(), 350);
         QCOMPARE(img.height(), 152);
         QCOMPARE(img.image().width(), img.width());
         QCOMPARE(img.image().height(), img.height());
 
         page = doc->page(1);
         QCOMPARE(page.text(), QStringLiteral("This is the second page.\nIt contains an Aztec code.\n"));
         QCOMPARE(page.imageCount(), 1);
         img = page.image(0);
         QCOMPARE(img.width(), 276);
         QCOMPARE(img.height(), 276);
 
         QVERIFY(page.imagesInRect(0, 0, 0.5, 1).isEmpty());
         QCOMPARE(page.imagesInRect(0, 0.5, 1, 1).size(), 1);
 #endif
     }
 
     void testInvalidPdfDocument()
     {
         QVERIFY(!PdfDocument::fromData(QByteArray()));
         QVERIFY(!PdfDocument::fromData(QByteArray("HELLO")));
 
         QFile f(QStringLiteral(SOURCE_DIR "/misc/test.pdf"));
         QVERIFY(f.open(QFile::ReadOnly));
         QVERIFY(!PdfDocument::fromData(f.readAll().left(f.size() / 2)));
     }
 };
 
 QTEST_GUILESS_MAIN(PdfDocumentTest)
 
 #include "pdfdocumenttest.moc"
diff --git a/src/pdfdocument.cpp b/src/pdfdocument.cpp
index c5ea039..52080a9 100644
--- a/src/pdfdocument.cpp
+++ b/src/pdfdocument.cpp
@@ -1,481 +1,463 @@
 /*
     Copyright (C) 2018 Volker Krause <vkrause@kde.org>
 
     This program is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This program is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "config-kitinerary.h"
 #include "pdfdocument.h"
 
 #include <QDebug>
 #include <QImage>
 #include <QScopedValueRollback>
 
 #ifdef HAVE_POPPLER
 #include <GlobalParams.h>
 #include <PDFDoc.h>
 #include <Stream.h>
 #include <TextOutputDev.h>
 #endif
 
 #include <cmath>
 
 using namespace KItinerary;
 
 namespace KItinerary {
 class PdfImagePrivate : public QSharedData {
 public:
 #ifdef HAVE_POPPLER
     void load(Stream *str, GfxImageColorMap *colorMap);
 
     std::unique_ptr<GfxImageColorMap> m_colorMap;
 #endif
 
     int m_refNum = -1;
     int m_refGen = -1;
     PdfPagePrivate *m_page = nullptr;
     QImage m_img;
     double m_x = NAN;
     double m_y = NAN;
     int m_width = 0;
     int m_height = 0;
     int m_sourceWidth = 0;
     int m_sourceHeight = 0;
     QImage::Format m_format = QImage::Format_Invalid;
 };
 
 class PdfPagePrivate : public QSharedData {
 public:
     int m_pageNum = -1;
     QString m_text;
     std::vector<PdfImage> m_images;
     PdfDocumentPrivate *m_doc;
 };
 
 class PdfDocumentPrivate {
 public:
     QByteArray m_pdfData; // needs to be kept alive as long as the Poppler::PdfDoc instance lives
     std::vector<PdfImage> m_images;
     std::vector<PdfPage> m_pages;
 #ifdef HAVE_POPPLER
     std::unique_ptr<PDFDoc> m_popplerDoc;
 #endif
 };
 
 #ifdef HAVE_POPPLER
 static std::unique_ptr<GlobalParams> s_globalParams;
 static GlobalParams* popplerGlobalParams()
 {
     if (!s_globalParams) {
         s_globalParams.reset(new GlobalParams);
     }
     return s_globalParams.get();
 }
 
 class ExtractorOutputDevice : public TextOutputDev
 {
 public:
     ExtractorOutputDevice(PdfDocumentPrivate *dd);
     GBool needNonText() override { return true; }
     void drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, int *maskColors, GBool inlineImg) override;
 
     std::vector<PdfImage> m_images;
 
 private:
     PdfDocumentPrivate *d;
 };
 
 #ifndef HAVE_POPPLER_0_69
 class ImageLoaderOutputDevice : public OutputDev
 {
 public:
     ImageLoaderOutputDevice(PdfImagePrivate *dd);
 
     GBool interpretType3Chars() override { return false; }
     GBool needNonText() override { return true; }
     GBool upsideDown() override { return false; }
     GBool useDrawChar() override { return false; }
 
     void drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, int *maskColors, GBool inlineImg) override;
 
 private:
     PdfImagePrivate *d;
 };
 #endif
 #endif
 
 }
 
 #ifdef HAVE_POPPLER
 void PdfImagePrivate::load(Stream* str, GfxImageColorMap* colorMap)
 {
     m_img = QImage(m_sourceWidth, m_sourceHeight, m_format);
     const auto bytesPerPixel = colorMap->getNumPixelComps();
     std::unique_ptr<ImageStream> imgStream(new ImageStream(str, m_sourceWidth, bytesPerPixel, colorMap->getBits()));
     imgStream->reset();
 
     switch (m_format) {
         case QImage::Format_RGB888:
             for (int i = 0; i < m_sourceHeight; ++i) {
                 const auto row = imgStream->getLine();
                 auto imgData = m_img.scanLine(i);
                 GfxRGB rgb;
                 for (int j = 0; j < m_sourceWidth; ++j) {
                     colorMap->getRGB(row + (j * bytesPerPixel), &rgb);
                     *imgData++ = colToByte(rgb.r);
                     *imgData++ = colToByte(rgb.g);
                     *imgData++ = colToByte(rgb.b);
                 }
             }
             break;
         case QImage::Format_Grayscale8:
             for (int i = 0; i < m_sourceHeight; ++i) {
                 const auto row = imgStream->getLine();
                 auto imgData = m_img.scanLine(i);
                 GfxGray gray;
                 for (int j = 0; j < m_sourceWidth; ++j) {
                     colorMap->getGray(row + j, &gray);
                     *imgData++ = colToByte(gray);
                 }
             }
             break;
         default:
             break;
     }
     imgStream->close();
 
     if (m_width != m_sourceWidth || m_height != m_sourceHeight) {
         m_img = m_img.scaled(m_width, m_height);
     }
 }
 
 
 ExtractorOutputDevice::ExtractorOutputDevice(PdfDocumentPrivate *dd)
     : TextOutputDev(nullptr, false, 0, false, false)
     , d(dd)
 {
 }
 
 void ExtractorOutputDevice::drawImage(GfxState* state, Object* ref, Stream* str, int width, int height, GfxImageColorMap* colorMap, GBool interpolate, int* maskColors, GBool inlineImg)
 {
     Q_UNUSED(str);
     Q_UNUSED(interpolate);
     Q_UNUSED(maskColors);
     Q_UNUSED(inlineImg);
 
     if (!colorMap || !colorMap->isOk() || !ref) {
         return;
     }
 
     // check for duplicate occurancies of ref->getRef().num
     if (ref->isRef()) {
         auto it = std::find_if(d->m_images.begin(), d->m_images.end(), [ref](const PdfImage &other) {
             return other.d->m_refNum == ref->getRef().num;
         });
         if (it != d->m_images.end()) {
             m_images.push_back(*it);
             return;
         }
     }
 
     QImage::Format format;
     if (colorMap->getColorSpace()->getMode() == csIndexed) {
         format = QImage::Format_RGB888;
     } else if (colorMap->getNumPixelComps() == 1 && (colorMap->getBits() >= 1 && colorMap->getBits() <= 8)) {
         format = QImage::Format_Grayscale8;
     } else if (colorMap->getNumPixelComps() == 3 && colorMap->getBits() == 8) {
         format = QImage::Format_RGB888;
     } else {
         return;
     }
 
     PdfImage pdfImg;
     if (ref->isRef()) {
         pdfImg.d->m_refNum = ref->getRef().num;
         pdfImg.d->m_refGen = ref->getRef().gen;
     }
 
 #ifdef HAVE_POPPLER_0_69
     pdfImg.d->m_colorMap.reset(colorMap->copy());
 #endif
     pdfImg.d->m_sourceHeight = height;
     pdfImg.d->m_sourceWidth = width;
     pdfImg.d->m_width = width;
     pdfImg.d->m_height = height;
     // deal with aspect-ratio changing scaling
     const auto sourceAspectRatio = (double)width / (double)height;
     const auto targetAspectRatio = state->getCTM()[0] / -state->getCTM()[3];
     if (!qFuzzyCompare(sourceAspectRatio, targetAspectRatio) && qFuzzyIsNull(state->getCTM()[1]) && qFuzzyIsNull(state->getCTM()[2])) {
         if (targetAspectRatio > sourceAspectRatio) {
             pdfImg.d->m_width = height * state->getCTM()[0] / -state->getCTM()[3];
         } else {
             pdfImg.d->m_height = width * -state->getCTM()[3] / state->getCTM()[0];
         }
     }
     pdfImg.d->m_x = state->getCTM()[4];
     pdfImg.d->m_y = state->getCTM()[5];
     pdfImg.d->m_format = format;
     m_images.push_back(pdfImg);
 }
 
 #ifndef HAVE_POPPLER_0_69
 ImageLoaderOutputDevice::ImageLoaderOutputDevice(PdfImagePrivate* dd)
     : d(dd)
 {
 }
 
 void ImageLoaderOutputDevice::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool interpolate, int *maskColors, GBool inlineImg)
 {
     Q_UNUSED(state);
     Q_UNUSED(height);
     Q_UNUSED(width);
     Q_UNUSED(interpolate);
     Q_UNUSED(maskColors);
     Q_UNUSED(inlineImg);
 
     if (!colorMap || !colorMap->isOk() || !ref) {
         return;
     }
 
     if (ref->isRef() && d->m_refNum != ref->getRef().num) {
         return;
     }
 
     d->load(str, colorMap);
 }
 #endif
 #endif
 
 PdfImage::PdfImage()
     : d(new PdfImagePrivate)
 {
 }
 
 PdfImage::PdfImage(const PdfImage&) = default;
 PdfImage::~PdfImage() = default;
 PdfImage& PdfImage::operator=(const PdfImage&) = default;
 
 int PdfImage::height() const
 {
     return d->m_height;
 }
 
 int PdfImage::width() const
 {
     return d->m_width;
 }
 
 QImage PdfImage::image() const
 {
     if (!d->m_img.isNull() || d->m_refNum < 0) {
         return d->m_img;
     }
 
 #ifdef HAVE_POPPLER
     QScopedValueRollback<GlobalParams*> globalParamResetter(globalParams, popplerGlobalParams());
 
 #ifdef HAVE_POPPLER_0_69
     const auto xref = d->m_page->m_doc->m_popplerDoc->getXRef();
     const auto obj = xref->fetch(d->m_refNum, d->m_refGen);
     d->load(obj.getStream(), d->m_colorMap.get());
 #else
     std::unique_ptr<ImageLoaderOutputDevice> device(new ImageLoaderOutputDevice(d.data()));
     d->m_page->m_doc->m_popplerDoc->displayPageSlice(device.get(), d->m_page->m_pageNum + 1, 72, 72, 0, false, true, false, -1, -1, -1, -1);
 #endif
 #endif
     return d->m_img;
 }
 
 
 PdfPage::PdfPage()
     : d(new PdfPagePrivate)
 {
 }
 
 PdfPage::PdfPage(const PdfPage&) = default;
 PdfPage::~PdfPage() = default;
 PdfPage& PdfPage::operator=(const PdfPage&) = default;
 
 QString PdfPage::text() const
 {
     return d->m_text;
 }
 
 #ifdef HAVE_POPPLER
 static double ratio(double begin, double end, double ratio)
 {
     return begin + (end - begin) * ratio;
 }
 #endif
 
 QString PdfPage::textInRect(double left, double top, double right, double bottom) const
 {
 #ifdef HAVE_POPPLER
     QScopedValueRollback<GlobalParams*> globalParamResetter(globalParams, popplerGlobalParams());
 
     std::unique_ptr<ExtractorOutputDevice> device(new ExtractorOutputDevice(d->m_doc));
     d->m_doc->m_popplerDoc->displayPageSlice(device.get(), d->m_pageNum + 1, 72, 72, 0, false, true, false, -1, -1, -1, -1);
     const auto pageRect = d->m_doc->m_popplerDoc->getPage(d->m_pageNum + 1)->getCropBox();
     std::unique_ptr<GooString> s(device->getText(ratio(pageRect->x1, pageRect->x2, left), ratio(pageRect->y1, pageRect->y2, top),
                                                  ratio(pageRect->x1, pageRect->x2, right), ratio(pageRect->y1, pageRect->y2, bottom)));
     return QString::fromUtf8(s->getCString());
 #else
     Q_UNUSED(left);
     Q_UNUSED(top);
     Q_UNUSED(right);
     Q_UNUSED(bottom);
     return {};
 #endif
 }
 
 int PdfPage::imageCount() const
 {
     return d->m_images.size();
 }
 
 PdfImage PdfPage::image(int index) const
 {
     return d->m_images[index];
 }
 
 QVariantList PdfPage::imagesVariant() const
 {
     QVariantList l;
     l.reserve(imageCount());
     std::for_each(d->m_images.begin(), d->m_images.end(), [&l](const PdfImage& img) { l.push_back(QVariant::fromValue(img)); });
     return l;
 }
 
 QVariantList PdfPage::imagesInRect(double left, double top, double right, double bottom) const
 {
     QVariantList l;
 #ifdef HAVE_POPPLER
     QScopedValueRollback<GlobalParams*> globalParamResetter(globalParams, popplerGlobalParams());
     const auto pageRect = d->m_doc->m_popplerDoc->getPage(d->m_pageNum + 1)->getCropBox();
 
     for (const auto &img : d->m_images) {
         if ((img.d->m_x >= ratio(pageRect->x1, pageRect->x2, left) && img.d->m_x <= ratio(pageRect->x1, pageRect->x2, right)) &&
             (img.d->m_y >= ratio(pageRect->y1, pageRect->y2, top)  && img.d->m_y <= ratio(pageRect->y1, pageRect->y2, bottom)))
         {
             l.push_back(QVariant::fromValue(img));
         }
     }
 #else
     Q_UNUSED(left);
     Q_UNUSED(top);
     Q_UNUSED(right);
     Q_UNUSED(bottom);
 #endif
     return l;
 }
 
 
 PdfDocument::PdfDocument(QObject *parent)
     : QObject(parent)
     , d(new PdfDocumentPrivate)
 {
 }
 
 PdfDocument::~PdfDocument() = default;
 
 QString PdfDocument::text() const
 {
     QString text;
     std::for_each(d->m_pages.begin(), d->m_pages.end(), [&text](const PdfPage &p) { text += p.text(); });
     return text;
 }
 
-int PdfDocument::imageCount() const
-{
-    return d->m_images.size();
-}
-
-PdfImage PdfDocument::image(int index) const
-{
-    return d->m_images[index];
-}
-
-QVariantList PdfDocument::imagesVariant() const
-{
-    QVariantList l;
-    l.reserve(imageCount());
-    std::for_each(d->m_images.begin(), d->m_images.end(), [&l](const PdfImage& img) { l.push_back(QVariant::fromValue(img)); });
-    return l;
-}
-
 int PdfDocument::pageCount() const
 {
     return d->m_pages.size();
 }
 
 PdfPage PdfDocument::page(int index) const
 {
     return d->m_pages[index];
 }
 
 QVariantList PdfDocument::pagesVariant() const
 {
     QVariantList l;
     l.reserve(pageCount());
     std::for_each(d->m_pages.begin(), d->m_pages.end(), [&l](const PdfPage& p) { l.push_back(QVariant::fromValue(p)); });
     return l;
 }
 
 PdfDocument* PdfDocument::fromData(const QByteArray &data, QObject *parent)
 {
 #ifdef HAVE_POPPLER
     QScopedValueRollback<GlobalParams*> globalParamResetter(globalParams, popplerGlobalParams());
 
     std::unique_ptr<PdfDocument> doc(new PdfDocument(parent));
     doc->d->m_pdfData = data;
     // PDFDoc takes ownership of stream
 #ifdef HAVE_POPPLER_0_58
     auto stream = new MemStream(const_cast<char*>(doc->d->m_pdfData.constData()), 0, doc->d->m_pdfData.size(), Object());
 #else
     Object obj;
     obj.initNull();
     auto stream = new MemStream(const_cast<char*>(doc->d->m_pdfData.constData()), 0, doc->d->m_pdfData.size(), &obj);
 #endif
     std::unique_ptr<PDFDoc> popplerDoc(new PDFDoc(stream, nullptr, nullptr));
     if (!popplerDoc->isOk()) {
         return nullptr;
     }
 
     std::unique_ptr<ExtractorOutputDevice> device(new ExtractorOutputDevice(doc->d.get()));
     doc->d->m_pages.reserve(popplerDoc->getNumPages());
     for (int i = 0; i < popplerDoc->getNumPages(); ++i) {
         popplerDoc->displayPageSlice(device.get(), i + 1, 72, 72, 0, false, true, false, -1, -1, -1, -1);
         const auto pageRect = popplerDoc->getPage(i + 1)->getCropBox();
         std::unique_ptr<GooString> s(device->getText(pageRect->x1, pageRect->y1, pageRect->x2, pageRect->y2));
         std::copy(device->m_images.begin(), device->m_images.end(), std::back_inserter(doc->d->m_images));
 
         PdfPage page;
         page.d->m_pageNum = i;
         page.d->m_doc = doc->d.get();
         page.d->m_text = QString::fromUtf8(s->getCString());
         page.d->m_images = std::move(device->m_images);
         for (auto it = page.d->m_images.begin(); it != page.d->m_images.end(); ++it) {
             (*it).d->m_page = page.d.data();
         }
         doc->d->m_pages.push_back(page);
     }
 
     doc->d->m_popplerDoc = std::move(popplerDoc);
     return doc.release();
 #else
     Q_UNUSED(data);
     Q_UNUSED(parent);
     return nullptr;
 #endif
 }
diff --git a/src/pdfdocument.h b/src/pdfdocument.h
index eab9c24..6b54f98 100644
--- a/src/pdfdocument.h
+++ b/src/pdfdocument.h
@@ -1,153 +1,144 @@
 /*
     Copyright (C) 2018 Volker Krause <vkrause@kde.org>
 
     This program is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This program is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef KITINERARY_PDFDOCUMENT_H
 #define KITINERARY_PDFDOCUMENT_H
 
 #include "kitinerary_export.h"
 
 #include <QExplicitlySharedDataPointer>
 #include <QObject>
 #include <QVariant>
 
 #include <memory>
 
 class QImage;
 
 namespace KItinerary {
 
 class PdfImagePrivate;
 
 /** An image in a PDF document.
  */
 class KITINERARY_EXPORT PdfImage
 {
     Q_GADGET
     Q_PROPERTY(int width READ width)
     Q_PROPERTY(int height READ height)
 public:
     PdfImage();
     PdfImage(const PdfImage&);
     ~PdfImage();
     PdfImage& operator=(const PdfImage&);
 
     int width() const;
     int height() const;
     QImage image() const;
 
 private:
     friend class ExtractorOutputDevice;
     friend class PdfDocument;
     friend class PdfPage;
     QExplicitlySharedDataPointer<PdfImagePrivate> d;
 };
 
 
 class PdfPagePrivate;
 
 /** A page in a PDF document.
  */
 class KITINERARY_EXPORT PdfPage
 {
     Q_GADGET
     Q_PROPERTY(QString text READ text)
     Q_PROPERTY(QVariantList images READ imagesVariant)
 public:
     PdfPage();
     PdfPage(const PdfPage&);
     ~PdfPage();
     PdfPage& operator=(const PdfPage&);
 
     /** The entire text on this page. */
     QString text() const;
 
     /** Returns the text in the specified sub-rect of this page.
      *  All parameters are relative values between @c 0 and @c 1 of the entire page size.
      */
     Q_INVOKABLE QString textInRect(double left, double top, double right, double bottom) const;
 
     /** The number of images found in this document. */
     int imageCount() const;
 
     /** The n-th image found in this document. */
     PdfImage image(int index) const;
 
     /** Returns the images in the specified sub-rect of this page.
      *  All parameters are relative values between @c 0 and @c 1 of the entire page size.
      */
     Q_INVOKABLE QVariantList imagesInRect(double left, double top, double right, double bottom) const;
 
 private:
     QVariantList imagesVariant() const;
 
     friend class PdfDocument;
     QExplicitlySharedDataPointer<PdfPagePrivate> d;
 };
 
 
 class PdfDocumentPrivate;
 
 /** PDF document for extraction.
  *  This is used as input for ExtractorEngine and the JS extractor scripts.
  *  @note This class is only functional if Poppler is available as a dependency,
  *  otherwise all methods return empty values.
  */
 class KITINERARY_EXPORT PdfDocument : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString text READ text CONSTANT)
-    Q_PROPERTY(int imageCount READ imageCount CONSTANT)
-    Q_PROPERTY(QVariantList images READ imagesVariant)
     Q_PROPERTY(int pageCount READ pageCount CONSTANT)
     Q_PROPERTY(QVariantList pages READ pagesVariant CONSTANT)
 public:
     explicit PdfDocument(QObject *parent = nullptr);
     ~PdfDocument();
 
     /** The entire text extracted from the PDF document. */
     QString text() const;
 
-    /** The number of images found in this document. */
-    int imageCount() const;
-
-    /** The n-th image found in this document. */
-    PdfImage image(int index) const;
-
     /** The number of pages in this document. */
     int pageCount() const;
 
     /** The n-thj page in this document. */
     PdfPage page(int index) const;
 
     /** Creates a PdfDocument from the given raw data.
      *  @returns @c nullptr if loading fails or Poppler was not found.
      */
     static PdfDocument* fromData(const QByteArray &data, QObject *parent = nullptr);
 
 private:
-    QVariantList imagesVariant() const;
     QVariantList pagesVariant() const;
 
     std::unique_ptr<PdfDocumentPrivate> d;
 };
 
 }
 
 Q_DECLARE_METATYPE(KItinerary::PdfImage)
 Q_DECLARE_METATYPE(KItinerary::PdfPage)
 
 #endif // KITINERARY_PDFDOCUMENT_H