diff --git a/generators/poppler/CMakeLists.txt b/generators/poppler/CMakeLists.txt
index 37d3ffed2..d3b95ef52 100644
--- a/generators/poppler/CMakeLists.txt
+++ b/generators/poppler/CMakeLists.txt
@@ -1,169 +1,178 @@
 remove_definitions(-DTRANSLATION_DOMAIN="okular")
 add_definitions(-DTRANSLATION_DOMAIN="okular_poppler")
 
 add_subdirectory( conf )
 
 if (Poppler_VERSION VERSION_GREATER "0.23.99")
   set (HAVE_POPPLER_0_24 1)
 endif()
 
 if (Poppler_VERSION VERSION_GREATER "0.27.99")
   set (HAVE_POPPLER_0_28 1)
 endif()
 
 if (Poppler_VERSION VERSION_GREATER "0.35.99")
   set (HAVE_POPPLER_0_36 1)
 endif()
 
 if (Poppler_VERSION VERSION_GREATER "0.36.99")
   set (HAVE_POPPLER_0_37 1)
 endif()
 
 set(CMAKE_REQUIRED_LIBRARIES Poppler::Qt5 Qt5::Core Qt5::Gui)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 int main()
 {
   Poppler::LinkOCGState *l = 0;
   return 0;
 }
 " HAVE_POPPLER_0_50)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <poppler-form.h>
 int main()
 {
   Poppler::SignatureValidationInfo *l = 0;
   return 0;
 }
 " HAVE_POPPLER_0_51)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <poppler-form.h>
 int main()
 {
   Poppler::FormFieldButton *ff = 0;
   Poppler::Link *l = ff->additionalAction(Poppler::FormField::CalculateField);
   return 0;
 }
 " HAVE_POPPLER_0_53)
 
+check_cxx_source_compiles("
+#include <poppler-qt5.h>
+#include <poppler-form.h>
+int main()
+{
+  auto s = &Poppler::SignatureValidationInfo::signsTotalDocument;
+}
+" HAVE_POPPLER_0_58)
+
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 int main()
 {
   Poppler::Document::RenderHint hint = Poppler::Document::HideAnnotations;
   return 0;
 }
 " HAVE_POPPLER_0_60)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <QImage>
 int main()
 {
   Poppler::Page *p;
   p->renderToImage(0, 0, 0, 0, 0, 0, Poppler::Page::Rotate0, nullptr, nullptr, QVariant());
   return 0;
 }
 " HAVE_POPPLER_0_62)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <QImage>
 int main()
 {
   Poppler::Page *p;
   p->renderToImage(0, 0, 0, 0, 0, 0, Poppler::Page::Rotate0, nullptr, nullptr, nullptr, QVariant());
   return 0;
 }
 " HAVE_POPPLER_0_63)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <poppler-form.h>
 #include <poppler-link.h>
 int main()
 {
   Poppler::FormField *f;
   f->setReadOnly(true);
   f->setVisible(true);
   Poppler::Link *l;
   l->nextLinks();
 }
 " HAVE_POPPLER_0_64)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <poppler-form.h>
 int main()
 {
   Poppler::FormField *f;
   f->additionalAction(Poppler::Annotation::CursorEnteringAction);
 }
 " HAVE_POPPLER_0_65)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <poppler-form.h>
 int main()
 {
   auto f = &Poppler::SignatureValidationInfo::reason;
 }
 " HAVE_POPPLER_0_68)
 
 check_cxx_source_compiles("
 #include <poppler-qt5.h>
 #include <QColor>
 int main()
 {
     Poppler::TextAnnotation *annot = new Poppler::TextAnnotation( Poppler::TextAnnotation::InPlace );
     annot->setTextColor( Qt::blue );
     return 0;
 }
 " HAVE_POPPLER_0_69)
 
 check_cxx_source_compiles("
 #include <poppler-version.h>
 int main()
 {
     QString s = Poppler::Version::string();
     return 0;
 }
 " HAVE_POPPLER_0_73)
 
 configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/config-okular-poppler.h.cmake
    ${CMAKE_CURRENT_BINARY_DIR}/config-okular-poppler.h
 )
 
 include_directories(
    ${CMAKE_CURRENT_SOURCE_DIR}/../..
 )
 
 ########### next target ###############
 
 set(okularGenerator_poppler_PART_SRCS
    generator_pdf.cpp
    formfields.cpp
    annots.cpp
    pdfsignatureutils.cpp
 )
 
 ki18n_wrap_ui(okularGenerator_poppler_PART_SRCS
    conf/pdfsettingswidget.ui
 )
 
 kconfig_add_kcfg_files(okularGenerator_poppler_PART_SRCS conf/pdfsettings.kcfgc )
 
 okular_add_generator(okularGenerator_poppler ${okularGenerator_poppler_PART_SRCS})
 
 target_link_libraries(okularGenerator_poppler okularcore KF5::I18n KF5::Completion Poppler::Qt5 Qt5::Xml)
 
 ########### install files ###############
 install( FILES okularPoppler.desktop  DESTINATION  ${KDE_INSTALL_KSERVICES5DIR} )
 install( PROGRAMS okularApplication_pdf.desktop org.kde.mobile.okular_pdf.desktop  DESTINATION  ${KDE_INSTALL_APPDIR} )
 install( FILES org.kde.okular-poppler.metainfo.xml DESTINATION ${KDE_INSTALL_METAINFODIR} )
diff --git a/generators/poppler/config-okular-poppler.h.cmake b/generators/poppler/config-okular-poppler.h.cmake
index e0af894b1..bbd2b823b 100644
--- a/generators/poppler/config-okular-poppler.h.cmake
+++ b/generators/poppler/config-okular-poppler.h.cmake
@@ -1,44 +1,47 @@
 /* Defined if we have the 0.24 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_24 1
 
 /* Defined if we have the 0.28 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_28 1
 
 /* Defined if we have the 0.36 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_36 1
 
 /* Defined if we have the 0.37 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_37 1
 
 /* Defined if we have the 0.50 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_50 1
 
 /* Defined if we have the 0.51 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_51 1
 
 /* Defined if we have the 0.53 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_53 1
 
+/* Defined if we have the 0.58 version of the Poppler library */
+#cmakedefine HAVE_POPPLER_0_58 1
+
 /* Defined if we have the 0.60 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_60 1
 
 /* Defined if we have the 0.62 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_62 1
 
 /* Defined if we have the 0.63 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_63 1
 
 /* Defined if we have the 0.64 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_64 1
 
 /* Defined if we have the 0.65 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_65 1
 
 /* Defined if we have the 0.68 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_68 1
 
 /* Defined if we have the 0.69 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_69 1
 
 /* Defined if we have the 0.73 version of the Poppler library */
 #cmakedefine HAVE_POPPLER_0_73 1
diff --git a/generators/poppler/formfields.cpp b/generators/poppler/formfields.cpp
index 0de6ef529..f5b41110c 100644
--- a/generators/poppler/formfields.cpp
+++ b/generators/poppler/formfields.cpp
@@ -1,448 +1,452 @@
 /***************************************************************************
  *   Copyright (C) 2007 by Pino Toscano <pino@kde.org>                     *
  *   Copyright (C) 2018 by Intevation GmbH <intevation@intevation.de>      *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 
 #include "formfields.h"
 
 #include "core/action.h"
 
 #include "pdfsignatureutils.h"
 
 #include <poppler-qt5.h>
 
 #include <config-okular-poppler.h>
 
 extern Okular::Action* createLinkFromPopplerLink(const Poppler::Link *popplerLink, bool deletePopplerLink = true);
 #ifdef HAVE_POPPLER_0_65
 # define SET_ANNOT_ACTIONS \
     setAdditionalAction( Okular::Annotation::CursorEntering, createLinkFromPopplerLink( field->additionalAction( Poppler::Annotation::CursorEnteringAction ) ) ); \
     setAdditionalAction( Okular::Annotation::CursorLeaving, createLinkFromPopplerLink( field->additionalAction( Poppler::Annotation::CursorLeavingAction ) ) ); \
     setAdditionalAction( Okular::Annotation::MousePressed, createLinkFromPopplerLink( field->additionalAction( Poppler::Annotation::MousePressedAction ) ) ); \
     setAdditionalAction( Okular::Annotation::MouseReleased, createLinkFromPopplerLink( field->additionalAction( Poppler::Annotation::MouseReleasedAction ) ) ); \
     setAdditionalAction( Okular::Annotation::FocusIn, createLinkFromPopplerLink( field->additionalAction( Poppler::Annotation::FocusInAction ) ) ); \
     setAdditionalAction( Okular::Annotation::FocusOut, createLinkFromPopplerLink( field->additionalAction( Poppler::Annotation::FocusOutAction ) ) );
 #else
 # define SET_ANNOT_ACTIONS
 #endif
 
 #ifdef HAVE_POPPLER_0_53
 #define SET_ACTIONS \
     setActivationAction( createLinkFromPopplerLink( field->activationAction() ) ); \
     setAdditionalAction( Okular::FormField::FieldModified, createLinkFromPopplerLink( field->additionalAction( Poppler::FormField::FieldModified ) ) ); \
     setAdditionalAction( Okular::FormField::FormatField, createLinkFromPopplerLink( field->additionalAction( Poppler::FormField::FormatField ) ) ); \
     setAdditionalAction( Okular::FormField::ValidateField, createLinkFromPopplerLink( field->additionalAction( Poppler::FormField::ValidateField ) ) ); \
     setAdditionalAction( Okular::FormField::CalculateField, createLinkFromPopplerLink( field->additionalAction( Poppler::FormField::CalculateField ) ) ); \
     SET_ANNOT_ACTIONS
 #else
 #define SET_ACTIONS \
     setActivationAction( createLinkFromPopplerLink( field->activationAction() ) );
 #endif
 
 PopplerFormFieldButton::PopplerFormFieldButton( Poppler::FormFieldButton * field )
     : Okular::FormFieldButton(), m_field( field )
 {
     m_rect = Okular::NormalizedRect::fromQRectF( m_field->rect() );
     m_id = m_field->id();
     SET_ACTIONS
 }
 
 PopplerFormFieldButton::~PopplerFormFieldButton()
 {
     delete m_field;
 }
 
 Okular::NormalizedRect PopplerFormFieldButton::rect() const
 {
     return m_rect;
 }
 
 int PopplerFormFieldButton::id() const
 {
     return m_id;
 }
 
 QString PopplerFormFieldButton::name() const
 {
     return m_field->name();
 }
 
 QString PopplerFormFieldButton::uiName() const
 {
     return m_field->uiName();
 }
 
 bool PopplerFormFieldButton::isReadOnly() const
 {
     return m_field->isReadOnly();
 }
 
 void PopplerFormFieldButton::setReadOnly( bool value )
 {
 #ifdef HAVE_POPPLER_0_64
     m_field->setReadOnly( value );
 #else
     Q_UNUSED( value );
 #endif
 }
 
 bool PopplerFormFieldButton::isVisible() const
 {
     return m_field->isVisible();
 }
 
 void PopplerFormFieldButton::setVisible( bool value )
 {
 #ifdef HAVE_POPPLER_0_64
     m_field->setVisible( value );
 #else
     Q_UNUSED( value );
 #endif
 }
 
 Okular::FormFieldButton::ButtonType PopplerFormFieldButton::buttonType() const
 {
     switch ( m_field->buttonType() )
     {
         case Poppler::FormFieldButton::Push:
             return Okular::FormFieldButton::Push;
         case Poppler::FormFieldButton::CheckBox:
             return Okular::FormFieldButton::CheckBox;
         case Poppler::FormFieldButton::Radio:
             return Okular::FormFieldButton::Radio;
     }
     return Okular::FormFieldButton::Push;
 }
 
 QString PopplerFormFieldButton::caption() const
 {
     return m_field->caption();
 }
 
 bool PopplerFormFieldButton::state() const
 {
     return m_field->state();
 }
 
 void PopplerFormFieldButton::setState( bool state )
 {
     m_field->setState( state );
 }
 
 QList< int > PopplerFormFieldButton::siblings() const
 {
     return m_field->siblings();
 }
 
 
 PopplerFormFieldText::PopplerFormFieldText( Poppler::FormFieldText * field )
     : Okular::FormFieldText(), m_field( field )
 {
     m_rect = Okular::NormalizedRect::fromQRectF( m_field->rect() );
     m_id = m_field->id();
     SET_ACTIONS
 }
 
 PopplerFormFieldText::~PopplerFormFieldText()
 {
     delete m_field;
 }
 
 Okular::NormalizedRect PopplerFormFieldText::rect() const
 {
     return m_rect;
 }
 
 int PopplerFormFieldText::id() const
 {
     return m_id;
 }
 
 QString PopplerFormFieldText::name() const
 {
     return m_field->name();
 }
 
 QString PopplerFormFieldText::uiName() const
 {
     return m_field->uiName();
 }
 
 bool PopplerFormFieldText::isReadOnly() const
 {
     return m_field->isReadOnly();
 }
 
 void PopplerFormFieldText::setReadOnly( bool value )
 {
 #ifdef HAVE_POPPLER_0_64
     m_field->setReadOnly( value );
 #else
     Q_UNUSED( value );
 #endif
 }
 
 bool PopplerFormFieldText::isVisible() const
 {
     return m_field->isVisible();
 }
 
 void PopplerFormFieldText::setVisible( bool value )
 {
 #ifdef HAVE_POPPLER_0_64
     m_field->setVisible( value );
 #else
     Q_UNUSED( value );
 #endif
 }
 
 Okular::FormFieldText::TextType PopplerFormFieldText::textType() const
 {
     switch ( m_field->textType() )
     {
         case Poppler::FormFieldText::Normal:
             return Okular::FormFieldText::Normal;
         case Poppler::FormFieldText::Multiline:
             return Okular::FormFieldText::Multiline;
         case Poppler::FormFieldText::FileSelect:
             return Okular::FormFieldText::FileSelect;
     }
     return Okular::FormFieldText::Normal;
 }
 
 QString PopplerFormFieldText::text() const
 {
     return m_field->text();
 }
 
 void PopplerFormFieldText::setText( const QString& text )
 {
     m_field->setText( text );
 }
 
 bool PopplerFormFieldText::isPassword() const
 {
     return m_field->isPassword();
 }
 
 bool PopplerFormFieldText::isRichText() const
 {
     return m_field->isRichText();
 }
 
 int PopplerFormFieldText::maximumLength() const
 {
     return m_field->maximumLength();
 }
 
 Qt::Alignment PopplerFormFieldText::textAlignment() const
 {
     return Qt::AlignTop | m_field->textAlignment();
 }
 
 bool PopplerFormFieldText::canBeSpellChecked() const
 {
     return m_field->canBeSpellChecked();
 }
 
 
 PopplerFormFieldChoice::PopplerFormFieldChoice( Poppler::FormFieldChoice * field )
     : Okular::FormFieldChoice(), m_field( field )
 {
     m_rect = Okular::NormalizedRect::fromQRectF( m_field->rect() );
     m_id = m_field->id();
     SET_ACTIONS
 }
 
 PopplerFormFieldChoice::~PopplerFormFieldChoice()
 {
     delete m_field;
 }
 
 Okular::NormalizedRect PopplerFormFieldChoice::rect() const
 {
     return m_rect;
 }
 
 int PopplerFormFieldChoice::id() const
 {
     return m_id;
 }
 
 QString PopplerFormFieldChoice::name() const
 {
     return m_field->name();
 }
 
 QString PopplerFormFieldChoice::uiName() const
 {
     return m_field->uiName();
 }
 
 bool PopplerFormFieldChoice::isReadOnly() const
 {
     return m_field->isReadOnly();
 }
 
 void PopplerFormFieldChoice::setReadOnly( bool value )
 {
 #ifdef HAVE_POPPLER_0_64
     m_field->setReadOnly( value );
 #else
     Q_UNUSED( value );
 #endif
 }
 
 bool PopplerFormFieldChoice::isVisible() const
 {
     return m_field->isVisible();
 }
 
 void PopplerFormFieldChoice::setVisible( bool value )
 {
 #ifdef HAVE_POPPLER_0_64
     m_field->setVisible( value );
 #else
     Q_UNUSED( value );
 #endif
 }
 
 Okular::FormFieldChoice::ChoiceType PopplerFormFieldChoice::choiceType() const
 {
     switch ( m_field->choiceType() )
     {
         case Poppler::FormFieldChoice::ComboBox:
             return Okular::FormFieldChoice::ComboBox;
         case Poppler::FormFieldChoice::ListBox:
             return Okular::FormFieldChoice::ListBox;
     }
     return Okular::FormFieldChoice::ListBox;
 }
 
 QStringList PopplerFormFieldChoice::choices() const
 {
     return m_field->choices();
 }
 
 bool PopplerFormFieldChoice::isEditable() const
 {
     return m_field->isEditable();
 }
 
 bool PopplerFormFieldChoice::multiSelect() const
 {
     return m_field->multiSelect();
 }
 
 QList<int> PopplerFormFieldChoice::currentChoices() const
 {
     return m_field->currentChoices();
 }
 
 void PopplerFormFieldChoice::setCurrentChoices( const QList<int>& choices )
 {
     m_field->setCurrentChoices( choices );
 }
 
 QString PopplerFormFieldChoice::editChoice() const
 {
     return m_field->editChoice();
 }
 
 void PopplerFormFieldChoice::setEditChoice( const QString& text )
 {
     m_field->setEditChoice( text );
 }
 
 Qt::Alignment PopplerFormFieldChoice::textAlignment() const
 {
     return Qt::AlignTop | m_field->textAlignment();
 }
 
 bool PopplerFormFieldChoice::canBeSpellChecked() const
 {
     return m_field->canBeSpellChecked();
 }
 
 #ifndef HAVE_POPPLER_0_51
 
 class DummySignatureInfo : public Okular::SignatureInfo
 {
 };
 
 #endif
 
 
 PopplerFormFieldSignature::PopplerFormFieldSignature( Poppler::FormFieldSignature * field )
     : Okular::FormFieldSignature(), m_field( field )
 {
     m_rect = Okular::NormalizedRect::fromQRectF( m_field->rect() );
     m_id = m_field->id();
 #ifdef HAVE_POPPLER_0_51
     m_info = new PopplerSignatureInfo( m_field->validate( Poppler::FormFieldSignature::ValidateVerifyCertificate ) );
 #else
     m_info = new DummySignatureInfo();
 #endif
     SET_ACTIONS
 }
 
 PopplerFormFieldSignature::~PopplerFormFieldSignature()
 {
     delete m_field;
     delete m_info;
 }
 
 Okular::NormalizedRect PopplerFormFieldSignature::rect() const
 {
     return m_rect;
 }
 
 int PopplerFormFieldSignature::id() const
 {
     return m_id;
 }
 
 QString PopplerFormFieldSignature::name() const
 {
     return m_field->name();
 }
 
 QString PopplerFormFieldSignature::uiName() const
 {
     return m_field->uiName();
 }
 
 bool PopplerFormFieldSignature::isReadOnly() const
 {
     return m_field->isReadOnly();
 }
 
 bool PopplerFormFieldSignature::isVisible() const
 {
     return m_field->isVisible();
 }
 
 PopplerFormFieldSignature::SignatureType PopplerFormFieldSignature::signatureType() const
 {
+#ifdef HAVE_POPPLER_0_58
     switch ( m_field->signatureType() )
     {
         case Poppler::FormFieldSignature::AdbePkcs7sha1:
             return Okular::FormFieldSignature::AdbePkcs7sha1;
         case Poppler::FormFieldSignature::AdbePkcs7detached:
             return Okular::FormFieldSignature::AdbePkcs7detached;
         case Poppler::FormFieldSignature::EtsiCAdESdetached:
             return Okular::FormFieldSignature::EtsiCAdESdetached;
         default:
             return Okular::FormFieldSignature::UnknownType;
     }
+#else
+    return Okular::FormFieldSignature::UnknownType;
+#endif
 }
 
 const Okular::SignatureInfo &PopplerFormFieldSignature::signatureInfo() const
 {
     return *m_info;
 }
diff --git a/generators/poppler/pdfsignatureutils.cpp b/generators/poppler/pdfsignatureutils.cpp
index ca1d79ea6..da8a4c696 100644
--- a/generators/poppler/pdfsignatureutils.cpp
+++ b/generators/poppler/pdfsignatureutils.cpp
@@ -1,270 +1,290 @@
 /***************************************************************************
  *   Copyright (C) 2018 by Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>  *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 
 #include "pdfsignatureutils.h"
 
 #include <KLocalizedString>
 #include <QDebug>
 
 #ifdef HAVE_POPPLER_0_73
 
 PopplerCertificateInfo::PopplerCertificateInfo( const Poppler::CertificateInfo &info )
     : m_info( info )
 {
 }
 
 PopplerCertificateInfo::~PopplerCertificateInfo()
 {
 }
 
 bool PopplerCertificateInfo::isNull() const
 {
     return m_info.isNull();
 }
 
 int PopplerCertificateInfo::version() const
 {
     return m_info.version();
 }
 
 QByteArray PopplerCertificateInfo::serialNumber() const
 {
     return m_info.serialNumber();
 }
 
 QString PopplerCertificateInfo::issuerInfo( PopplerCertificateInfo::EntityInfoKey key ) const
 {
     QString str = m_info.issuerInfo(static_cast<Poppler::CertificateInfo::EntityInfoKey>( key ));
     return !str.isEmpty() ? str : i18n("Not Available");
 }
 
 QString PopplerCertificateInfo::subjectInfo( PopplerCertificateInfo::EntityInfoKey key ) const
 {
     QString str = m_info.subjectInfo(static_cast<Poppler::CertificateInfo::EntityInfoKey>( key ));
     return !str.isEmpty() ? str : i18n("Not Available");
 }
 
 QDateTime PopplerCertificateInfo::validityStart() const
 {
     return m_info.validityStart();
 }
 
 QDateTime PopplerCertificateInfo::validityEnd() const
 {
     return m_info.validityEnd();
 }
 
 PopplerCertificateInfo::KeyUsageExtensions PopplerCertificateInfo::keyUsageExtensions() const
 {
     Poppler::CertificateInfo::KeyUsageExtensions popplerKu = m_info.keyUsageExtensions();
     KeyUsageExtensions ku = KuNone;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuDigitalSignature ) )
         ku |= KuDigitalSignature;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuNonRepudiation ) )
         ku |= KuNonRepudiation;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuKeyEncipherment ) )
         ku |= KuKeyEncipherment;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuDataEncipherment ) )
         ku |= KuDataEncipherment;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuKeyAgreement ) )
         ku |= KuKeyAgreement;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuKeyCertSign ) )
         ku |= KuKeyCertSign;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuClrSign ) )
         ku |= KuClrSign;
     if ( popplerKu.testFlag( Poppler::CertificateInfo::KuEncipherOnly ) )
         ku |= KuEncipherOnly;
     return ku;
 }
 
 QByteArray PopplerCertificateInfo::publicKey() const
 {
     return m_info.publicKey();
 }
 
 PopplerCertificateInfo::PublicKeyType PopplerCertificateInfo::publicKeyType() const
 {
     switch ( m_info.publicKeyType() )
     {
         case Poppler::CertificateInfo::RsaKey:
             return RsaKey;
         case Poppler::CertificateInfo::DsaKey:
             return DsaKey;
         case Poppler::CertificateInfo::EcKey:
             return EcKey;
         case Poppler::CertificateInfo::OtherKey:
             return OtherKey;
     }
 
     return OtherKey;
 }
 
 int PopplerCertificateInfo::publicKeyStrength() const
 {
     return m_info.publicKeyStrength();
 }
 
 bool PopplerCertificateInfo::isSelfSigned() const
 {
     return m_info.isSelfSigned();
 }
 
 QByteArray PopplerCertificateInfo::certificateData() const
 {
     return m_info.certificateData();
 }
 
 #else
 
 class DummyCertificateInfo : public Okular::CertificateInfo
 {
 };
 
 #endif
 
 #ifdef HAVE_POPPLER_0_51
 
 PopplerSignatureInfo::PopplerSignatureInfo( const Poppler::SignatureValidationInfo &info )
     : m_info( info )
 {
 #ifdef HAVE_POPPLER_0_73
     m_certfiticateInfo = new PopplerCertificateInfo( m_info.certificateInfo() );
 #else
     m_certfiticateInfo = new DummyCertificateInfo();
 #endif
 }
 
 PopplerSignatureInfo::~PopplerSignatureInfo()
 {
     delete m_certfiticateInfo;
 }
 
 PopplerSignatureInfo::SignatureStatus PopplerSignatureInfo::signatureStatus() const
 {
     switch ( m_info.signatureStatus() )
     {
         case Poppler::SignatureValidationInfo::SignatureValid:
             return SignatureValid;
         case Poppler::SignatureValidationInfo::SignatureInvalid:
             return SignatureInvalid;
         case Poppler::SignatureValidationInfo::SignatureDigestMismatch:
             return SignatureDigestMismatch;
         case Poppler::SignatureValidationInfo::SignatureDecodingError:
             return SignatureDecodingError;
         case Poppler::SignatureValidationInfo::SignatureGenericError:
             return SignatureGenericError;
         case Poppler::SignatureValidationInfo::SignatureNotFound:
             return SignatureNotFound;
         case Poppler::SignatureValidationInfo::SignatureNotVerified:
             return SignatureNotVerified;
         default:
             return SignatureStatusUnknown;
     }
 }
 
 PopplerSignatureInfo::CertificateStatus PopplerSignatureInfo::certificateStatus() const
 {
     switch ( m_info.certificateStatus() )
     {
         case Poppler::SignatureValidationInfo::CertificateTrusted:
             return CertificateTrusted;
         case Poppler::SignatureValidationInfo::CertificateUntrustedIssuer:
             return CertificateUntrustedIssuer;
         case Poppler::SignatureValidationInfo::CertificateUnknownIssuer:
             return CertificateUnknownIssuer;
         case Poppler::SignatureValidationInfo::CertificateRevoked:
             return CertificateRevoked;
         case Poppler::SignatureValidationInfo::CertificateExpired:
             return CertificateExpired;
         case Poppler::SignatureValidationInfo::CertificateGenericError:
             return CertificateGenericError;
         case Poppler::SignatureValidationInfo::CertificateNotVerified:
             return CertificateNotVerified;
         default:
             return CertificateStatusUnknown;
     }
 }
 
 PopplerSignatureInfo::HashAlgorithm PopplerSignatureInfo::hashAlgorithm() const
 {
+#ifdef HAVE_POPPLER_0_58
     switch ( m_info.hashAlgorithm() )
     {
         case Poppler::SignatureValidationInfo::HashAlgorithmMd2:
             return HashAlgorithmMd2;
         case Poppler::SignatureValidationInfo::HashAlgorithmMd5:
             return HashAlgorithmMd5;
         case Poppler::SignatureValidationInfo::HashAlgorithmSha1:
             return HashAlgorithmSha1;
         case Poppler::SignatureValidationInfo::HashAlgorithmSha256:
             return HashAlgorithmSha256;
         case Poppler::SignatureValidationInfo::HashAlgorithmSha384:
             return HashAlgorithmSha384;
         case Poppler::SignatureValidationInfo::HashAlgorithmSha512:
             return HashAlgorithmSha512;
         case Poppler::SignatureValidationInfo::HashAlgorithmSha224:
             return HashAlgorithmSha224;
         default:
             return HashAlgorithmUnknown;
     }
+#else
+    return HashAlgorithmUnknown;
+#endif
 }
 
 QString PopplerSignatureInfo::signerName() const
 {
     return m_info.signerName();
 }
 
 QString PopplerSignatureInfo::signerSubjectDN() const
 {
+#ifdef HAVE_POPPLER_0_58
     return m_info.signerSubjectDN();
+#else
+    return {};
+#endif
 }
 
 QString PopplerSignatureInfo::location() const
 {
 #ifdef HAVE_POPPLER_0_68
     return m_info.location();
 #else
     return {};
 #endif
 }
 
 QString PopplerSignatureInfo::reason() const
 {
 #ifdef HAVE_POPPLER_0_68
     return m_info.reason();
 #else
     return {};
 #endif
 }
 
 QDateTime PopplerSignatureInfo::signingTime() const
 {
     return QDateTime::fromTime_t( m_info.signingTime() );
 }
 
 QByteArray PopplerSignatureInfo::signature() const
 {
+#ifdef HAVE_POPPLER_0_58
     return m_info.signature();
+#else
+    return {};
+#endif
 }
 
 QList<qint64> PopplerSignatureInfo::signedRangeBounds() const
 {
+#ifdef HAVE_POPPLER_0_58
     return m_info.signedRangeBounds();
+#else
+    return {};
+#endif
 }
 
 bool PopplerSignatureInfo::signsTotalDocument() const
 {
+ #ifdef HAVE_POPPLER_0_58
     return m_info.signsTotalDocument();
+#else
+    return false;
+#endif
 }
 
 const Okular::CertificateInfo &PopplerSignatureInfo::certificateInfo() const
 {
     return *m_certfiticateInfo;
 }
 
 #endif