wxpoppler.cpp

Go to the documentation of this file.

/***************************************************************
 * Name:      wxpoppler.cpp
 * Purpose:   wxWidgets wrapper around libpoppler for PDF file
 *            viewing.
 * Author:    Daniel Nell (daniel.nell@nellresearch.de)
 * Created:   2008-07-08
 * Copyright: Daniel Nell (www.nellresearch.de)
 * License:
 **************************************************************/

#include <wx/filename.h>
#include <wx/filesys.h>
#include <wxpoppler.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#if wxUSE_PDF
#   include <wx/mstream.h>
#   if __WXPDFDOC__
#       include <wx/pdfdoc.h>
#   endif // __WXPDFDOC__
#endif // wxUSE_PDF

/////////////////////////////////////////////////////////////////////////////
//  Class wxPoppler
//

#if __WXPOPPLER_DYNAMIC__
// Define dynamic library.
wxDynamicLibrary wxPoppler::m_oWxPopplerDynamicLibrary;

// Define and initialize dynamic poppler-glib functions with NULL;
wxPoppler::t_poppler_document_new_from_data *wxPoppler::poppler_document_new_from_data= NULL;
wxPoppler::t_poppler_document_new_from_file *wxPoppler::poppler_document_new_from_file= NULL;
wxPoppler::t_poppler_document_get_page *wxPoppler::poppler_document_get_page= NULL;
wxPoppler::t_poppler_page_render_to_pixbuf *wxPoppler::poppler_page_render_to_pixbuf= NULL;
wxPoppler::t_poppler_page_get_size *wxPoppler::poppler_page_get_size= NULL;
wxPoppler::t_poppler_document_get_n_pages *wxPoppler::poppler_document_get_n_pages= NULL;

#endif // __WXPOPPLER_DYNAMIC__


// Initialize static members.
//
int wxPoppler::m_nGlobalDpi= 300;


// Standard constructor.
//
wxPoppler::wxPoppler()
{
    // Initialize normal members;
    m_pPdfPage= NULL;
    m_pPdfDocument= NULL;
    m_nDpi= m_nGlobalDpi;

#if __WXPOPPLER_DYNAMIC__
    if( !m_oWxPopplerDynamicLibrary.IsLoaded() )
    {
        if( m_oWxPopplerDynamicLibrary.Load( wxDynamicLibrary::CanonicalizeName( wxT( WXPOPPPLER_LIBPOPPLER ) ) ) )
        {
            poppler_document_new_from_data= (t_poppler_document_new_from_data *)m_oWxPopplerDynamicLibrary.GetSymbol( wxT( "poppler_document_new_from_data" ) );
            poppler_document_new_from_file= (t_poppler_document_new_from_file *)m_oWxPopplerDynamicLibrary.GetSymbol( wxT( "poppler_document_new_from_file" ) );
            poppler_document_get_page     = (t_poppler_document_get_page *)m_oWxPopplerDynamicLibrary.GetSymbol( wxT( "poppler_document_get_page" ) );
            poppler_page_render_to_pixbuf = (t_poppler_page_render_to_pixbuf *)m_oWxPopplerDynamicLibrary.GetSymbol( wxT( "poppler_page_render_to_pixbuf" ) );
            poppler_page_get_size         = (t_poppler_page_get_size *)m_oWxPopplerDynamicLibrary.GetSymbol( wxT( "poppler_page_get_size" ) );
            poppler_document_get_n_pages  = (t_poppler_document_get_n_pages *)m_oWxPopplerDynamicLibrary.GetSymbol( wxT( "poppler_document_get_n_pages" ) );
        }
        else
        {
            // Log error message.
            wxLogError( wxString( wxT( "wxPoppler::wxPoppler -- " ) )
                          + _( "Cannot load poppler library." ) );
        }
    }
#endif // __WXPOPPLER_DYNAMIC__
}

// Virtual destructor.
//
wxPoppler::~wxPoppler()
{
    // If exists delete the PDF page.
    if( m_pPdfPage )
    {
        g_object_unref( m_pPdfPage );
    }

    // If exists delete the PDF document.
    if( m_pPdfDocument )
    {
        g_object_unref( m_pPdfDocument );
    }
}

// Opens a PDF stream from file or memory depending on the parameterization.
//
bool wxPoppler::Open( char *pcData, const int nLength, const wxString& strFileName )
{
    GError *pGError= NULL;

    if( pcData && nLength )
    {
        m_pPdfDocument= poppler_document_new_from_data( pcData, nLength, "", &pGError );
    }
    else
    {
        wxFileName oFileName( strFileName );
        wxString strFileNameAsUri= wxFileSystem::FileNameToURL( oFileName );
//        // Add the "file://" protocol-identifier.
//        wxString strFileNameAsUri= wxT( "file://" ) + strFileName;
//
//        // Replace backslashes by slashes to confirm to the "file://" URI rules.
//        strFileNameAsUri.Replace( wxT( "\\" ), wxT( "/" ) );
//
        // Open the file.
        m_pPdfDocument= poppler_document_new_from_file( strFileNameAsUri.char_str(), "", &pGError );
    }
    if( !m_pPdfDocument )
    {
        // Log error message from poppler library.
        if( pGError )
        {
            wxLogError( wxT( "wxPoppler::Open -- GError: %s" ),
                          wxString( pGError->message, wxConvLibc ).c_str() );
            g_clear_error( &pGError );
        }

        // Signal error.
        return false;
    }
    return true;
}

// Select the given page number to render by a consecutive call to RenderPage().
//
bool wxPoppler::SelectPage( int nIndex )
{
    PopplerPage *pPdfPageTemp= poppler_document_get_page( m_pPdfDocument, nIndex );

    if( !pPdfPageTemp )
    {
        return false;
    }
    m_pPdfPage= pPdfPageTemp;
    g_object_ref( m_pPdfPage );
    return true;
}

// Render the (previously selected) PDF page and store the result in m_oImage.
//
bool wxPoppler::RenderPage()
{
    if( !m_pPdfPage )
    {
        // Signal error.
        wxLogError( wxString( wxT( "wxPoppler::RenderPage -- " ) )
                      + _( "PDF page is not valid." ) );
        return false;
    }

    double dblWidth, dblHeight;
    double dblDpiBy72= (double)m_nDpi / 72.0;

    poppler_page_get_size( m_pPdfPage, &dblWidth, &dblHeight );

    int nWidth=  (int)( dblWidth  * dblDpiBy72 );
    int nHeight= (int)( dblHeight * dblDpiBy72 );

    GdkPixbuf *pGdkPixBuf= gdk_pixbuf_new( GDK_COLORSPACE_RGB, false, 8, nWidth, nHeight );
    if( !pGdkPixBuf )
    {
        // Signal error.
        wxLogError( wxString( wxT( "wxPoppler::RenderPage -- " ) )
                      + _( "Cannot create GdkPixbuf object." ) );
        return false;
    }

    poppler_page_render_to_pixbuf( m_pPdfPage, 0, 0, nWidth, nHeight, dblDpiBy72, 0, pGdkPixBuf );
    if(
        ( gdk_pixbuf_get_colorspace( pGdkPixBuf ) != GDK_COLORSPACE_RGB )
        || ( gdk_pixbuf_get_bits_per_sample( pGdkPixBuf ) != 8 )
        || ( gdk_pixbuf_get_has_alpha( pGdkPixBuf ) )
        || ( gdk_pixbuf_get_n_channels( pGdkPixBuf ) != 3 )
      )
    {
        // Signal error.
        wxLogError( wxString( wxT( "wxPoppler::RenderPage -- " ) )
                      + _( "Got wrong bitmap format from libpoppler." ) );
        g_object_unref( pGdkPixBuf );
        return false;
    }

    int nPixBufRowSize= gdk_pixbuf_get_rowstride( pGdkPixBuf );
    guchar *pPixBufData= gdk_pixbuf_get_pixels( pGdkPixBuf );
    int nImageBufRowSize= 3 * nWidth;
    unsigned char *pImageBuf= (unsigned char *)malloc( nImageBufRowSize * nHeight );

    if( !pImageBuf )
    {
        // Signal error.
        wxLogError( wxString( wxT( "wxPoppler::RenderPage -- " ) )
                      + _( "Cannot allocate a buffer for wxImage object." ) );
        g_object_unref( pGdkPixBuf );
        return false;
    }

    unsigned char *pImageBufLine= pImageBuf;

    for( int y= 0; y < nHeight; y++ )
    {

        memcpy( pImageBufLine, pPixBufData, nImageBufRowSize );
        pPixBufData += nPixBufRowSize;
        pImageBufLine += nImageBufRowSize;
    }

    // Create an wxImage object an set resolution information.
    m_oImage= wxImage( nWidth, nHeight, pImageBuf );
    m_oImage.SetOption( wxIMAGE_OPTION_RESOLUTIONUNIT, wxIMAGE_RESOLUTION_INCHES );
    m_oImage.SetOption( wxIMAGE_OPTION_RESOLUTION, m_nDpi );
    m_oImage.SetOption( wxIMAGE_OPTION_RESOLUTIONX, m_nDpi );
    m_oImage.SetOption( wxIMAGE_OPTION_RESOLUTIONY, m_nDpi );

    g_object_unref( pGdkPixBuf );
    return true;
}



#if wxUSE_PDF
/////////////////////////////////////////////////////////////////////////////
//  Class wxPDFHandler
//
IMPLEMENT_DYNAMIC_CLASS( wxPDFHandler, wxImageHandler )

// Loads an image from a stream, putting the resulting data into image.
//
bool wxPDFHandler::LoadFile( wxImage* poImage, wxInputStream& oIStream, bool bVerbose, int nIndex )
{
    // Check if there is a valid PDF file.
    if( !CanRead( oIStream ) )
    {
        if( bVerbose )
        {
            wxLogError( wxString( wxT( "wxPDFHandler::LoadFile -- " ) )
                          + _( "PDF: This is not a PDF file." ) );
        }
        return false;
    }

    // Write the input stream to a memory buffer (by using a wxMemoryOutputStream object).
    wxFileOffset oOffset= oIStream.TellI();
    oIStream.SeekI( 0, wxFromEnd );
    wxFileOffset nSize= oIStream.TellI();
    oIStream.SeekI( 0 );
    char *pcData= new char[nSize];
    wxMemoryOutputStream oOStream( pcData, nSize );
    oIStream.Read( oOStream );
    oIStream.SeekI( oOffset );

    int bRetC= true;
    int nPage= ( nIndex >= 0 ) ? nIndex : 0;
    wxPoppler oPoppler;

    // Render an image of the selected page.
    if(    oPoppler.Open( (char *)oOStream.GetOutputStreamBuffer()->GetBufferStart(),
                          oOStream.GetOutputStreamBuffer()->GetBufferSize() )
        && oPoppler.SelectPage( nPage )
        && oPoppler.RenderPage()
      )
    {
        (*poImage)= oPoppler.GetImage();
        m_nPageCount= oPoppler.GetPageCount();
    }
    else
    {
        if( bVerbose )
        {
            wxLogError( wxString( wxT( "wxPDFHandler::LoadFile -- " ) )
                          + _( "Cannot render temporary PDF file." ) );
        }
        bRetC= false;
    }
    delete[] pcData;
    return bRetC;
}

// Saves a given image in the output stream.
//
bool wxPDFHandler::SaveFile( wxImage* poImage, wxOutputStream& oOStream, bool bVerbose )
{
#if __WXPDFDOC__
    if( poImage->HasOption( wxIMAGE_OPTION_RESOLUTIONUNIT ) )
    {
        int nResolutionUnit= poImage->GetOptionInt( wxIMAGE_OPTION_RESOLUTIONUNIT );
        int nResolution= 0;

        // Get image resolution-
        if(  poImage->HasOption( wxIMAGE_OPTION_RESOLUTION ) )
        {
            nResolution= poImage->GetOptionInt( wxIMAGE_OPTION_RESOLUTION );
        }
        else if(  poImage->HasOption( wxIMAGE_OPTION_RESOLUTIONX ) && (  poImage->HasOption( wxIMAGE_OPTION_RESOLUTIONY ) ) )
        {
            int nResolutionX= poImage->GetOptionInt( wxIMAGE_OPTION_RESOLUTIONX );
            int nResolutionY= poImage->GetOptionInt( wxIMAGE_OPTION_RESOLUTIONY );

            if( nResolutionX == nResolutionY )
            {
                nResolution= nResolutionX;
            }
        }
        if( nResolution )
        {
            // Save image in a temporary file.
            wxString strTempFileName= wxFileName::CreateTempFileName( wxEmptyString );

            poImage->SaveFile( strTempFileName, wxT( "image/jpeg" ) );

            // Create a PDF document, add a page, and put the image on it.
            wxPdfDocument oPdfDocument;

            oPdfDocument.AddPage( ( poImage->GetHeight() > poImage->GetWidth() ) ? wxPORTRAIT : wxLANDSCAPE );

            oPdfDocument.SetImageScale( (double)nResolution * ( nResolutionUnit == wxIMAGE_RESOLUTION_CM ? 2.54 : 1.0 ) / 72.0 );
            oPdfDocument.Image( strTempFileName, 0 , 0, 0, 0, wxT( "image/jpeg" ) );

            // Remove temporary file.
            ::wxRemoveFile( strTempFileName );

            // Send the PDF to the output stream.
            wxMemoryInputStream oMemoryInputStream( oPdfDocument.CloseAndGetBuffer() );

            oOStream.Write( oMemoryInputStream );

            // Signal success.
            return true;
        }
    }
#endif // __WXPDFDOC__
    // File saving not possible or not implemented.
    return false;
}

// Check if the file contains a PDF document.
//
bool wxPDFHandler::DoCanRead( wxInputStream& oIStream )
{
    unsigned char aucHeader[4];

    if ( !oIStream.Read( aucHeader, WXSIZEOF( aucHeader ) ) )
    {
        return false;
    }
    return memcmp( aucHeader, "%PDF", WXSIZEOF( aucHeader ) ) == 0;
}
#endif // wxUSE_PDF