diff --git a/generators/poppler/pdfsignatureutils.cpp b/generators/poppler/pdfsignatureutils.cpp
index 8eeecd59c..b8fc292be 100644
--- a/generators/poppler/pdfsignatureutils.cpp
+++ b/generators/poppler/pdfsignatureutils.cpp
@@ -1,215 +1,182 @@
 /***************************************************************************
  *   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"
 
 PopplerCertificateInfo::PopplerCertificateInfo( const Poppler::CertificateInfo &info )
     : Okular::CertificateInfo()
 {
     initPrivate();
 
     setVersion( info.version() );
     setIssuerName( info.issuerName() );
     setIssuerDN( info.issuerDN() );
     setSerialNumber( info.serialNumber() );
     setValidityStart( info.validityStart() );
     setValidityEnd( info.validityEnd() );
     setKeyUsages( convertToOkularKeyUsages( info.keyUsages() ) );
     setPublicKey( info.publicKey() );
     setPublicKeyStrength( info.publicKeyStrength() );
     setPublicKeyType( convertToOkularPublicKeyType( info.publicKeyType() ) );
     setCertificateData( info.certificateData() );
 }
 
 PopplerCertificateInfo::~PopplerCertificateInfo()
 {
 }
 
 PopplerCertificateInfo::KeyUsages PopplerCertificateInfo::convertToOkularKeyUsages( Poppler::CertificateInfo::KeyUsages popplerKu )
 {
     KeyUsages 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;
 }
 
 PopplerCertificateInfo::PublicKeyType PopplerCertificateInfo::convertToOkularPublicKeyType( Poppler::CertificateInfo::PublicKeyType popplerPkType )
 {
     switch ( popplerPkType )
     {
         case Poppler::CertificateInfo::RsaKey:
             return RsaKey;
         case Poppler::CertificateInfo::DsaKey:
             return DsaKey;
         case Poppler::CertificateInfo::EcKey:
             return EcKey;
         case Poppler::CertificateInfo::OtherKey:
             return OtherKey;
     }
 }
 
 
-class PopplerSignatureInfoPrivate
-{
-    public:
-        QList<qint64> rangeBounds;
-        QDateTime signingTime;
-        QByteArray signature;
-        QString subjectCN;
-        QString subjectDN;
-        int signatureStatus;
-        int certficateStatus;
-        int hashAlgorithm;
-        bool signsTotalDoc;
-};
-
 PopplerSignatureInfo::PopplerSignatureInfo( const Poppler::SignatureValidationInfo &info )
-    : d_ptr( new PopplerSignatureInfoPrivate() )
+    : m_info( new Poppler::SignatureValidationInfo( nullptr ) )
 {
-    Q_D( PopplerSignatureInfo );
-    d->signatureStatus = info.signatureStatus();
-    d->certficateStatus = info.certificateStatus();
-    d->subjectCN = info.signerName();
-    d->subjectDN = info.signerSubjectDN();
-    d->hashAlgorithm = info.hashAlgorithm();
-    d->signingTime = QDateTime::fromTime_t( info.signingTime() );
-    d->signature = info.signature();
-    d->rangeBounds = info.signedRangeBounds();
-    d->signsTotalDoc = info.signsTotalDocument();
 }
 
 PopplerSignatureInfo::~PopplerSignatureInfo()
 {
 }
 
 PopplerSignatureInfo::SignatureStatus PopplerSignatureInfo::signatureStatus() const
 {
-    Q_D( const PopplerSignatureInfo );
-    switch ( d->signatureStatus )
+    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
 {
-    Q_D( const PopplerSignatureInfo );
-    switch ( d->certficateStatus )
+    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
 {
-    Q_D( const PopplerSignatureInfo );
-    switch ( d->hashAlgorithm )
+    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;
     }
 }
 
 QString PopplerSignatureInfo::subjectName() const
 {
-    Q_D( const PopplerSignatureInfo );
-    return d->subjectCN;
+    return m_info->signerName();
 }
 QString PopplerSignatureInfo::subjectDN() const
 {
-    Q_D( const PopplerSignatureInfo );
-    return d->subjectDN;
+    return m_info->signerSubjectDN();
 }
 
 QDateTime PopplerSignatureInfo::signingTime() const
 {
-    Q_D( const PopplerSignatureInfo );
-    return d->signingTime;
+    return QDateTime::fromTime_t( m_info->signingTime() );
 }
 
 QByteArray PopplerSignatureInfo::signature() const
 {
-    Q_D( const PopplerSignatureInfo );
-    return d->signature;
+    return m_info->signature();
 }
 
 QList<qint64> PopplerSignatureInfo::signedRangeBounds() const
 {
-    Q_D( const PopplerSignatureInfo );
-    return d->rangeBounds;
+    return m_info->signedRangeBounds();
 }
 
 bool PopplerSignatureInfo::signsTotalDocument() const
 {
-    Q_D( const PopplerSignatureInfo );
-    return d->signsTotalDoc;
+    return m_info->signsTotalDocument();
 }
 
 Okular::CertificateInfo PopplerSignatureInfo::certificateInfo() const
 {
     return Okular::CertificateInfo();
 }
diff --git a/generators/poppler/pdfsignatureutils.h b/generators/poppler/pdfsignatureutils.h
index 877410d00..eb21c624d 100644
--- a/generators/poppler/pdfsignatureutils.h
+++ b/generators/poppler/pdfsignatureutils.h
@@ -1,52 +1,51 @@
 /***************************************************************************
  *   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.                                   *
  ***************************************************************************/
 
 #ifndef _OKULAR_GENERATOR_PDF_SIGNATUREINFO_H_
 #define _OKULAR_GENERATOR_PDF_SIGNATUREINFO_H_
 
 #include <poppler-form.h>
 
 #include "core/signatureutils.h"
 
 class PopplerCertificateInfo : public Okular::CertificateInfo
 {
     public:
         PopplerCertificateInfo(const Poppler::CertificateInfo &info);
         ~PopplerCertificateInfo();
 
     private:
         KeyUsages convertToOkularKeyUsages( Poppler::CertificateInfo::KeyUsages );
         PublicKeyType convertToOkularPublicKeyType( Poppler::CertificateInfo::PublicKeyType );
 };
 
 class PopplerSignatureInfoPrivate;
 
 class PopplerSignatureInfo : public Okular::SignatureInfo
 {
     public:
         PopplerSignatureInfo( const Poppler::SignatureValidationInfo &info );
         virtual ~PopplerSignatureInfo();
 
         SignatureStatus signatureStatus() const override;
         CertificateStatus certificateStatus() const override;
         QString subjectName() const override;
         QString subjectDN() const override;
         HashAlgorithm hashAlgorithm() const override;
         QDateTime signingTime() const override;
         QByteArray signature() const override;
         QList<qint64> signedRangeBounds() const override;
         bool signsTotalDocument() const override;
         Okular::CertificateInfo certificateInfo() const override;
 
     private:
-        QScopedPointer<PopplerSignatureInfoPrivate> d_ptr;
-        Q_DECLARE_PRIVATE( PopplerSignatureInfo )
+        Poppler::SignatureValidationInfo *m_info;
 };
 
 #endif