Software Público Brasileiro

# Name:         viewer.py 
# Package:      wx.lib.pdfviewer
#
# Purpose:      A PDF report viewer class
#
# Author:       David Hughes     dfh@forestfield.co.uk
# Copyright:    Forestfield Software Ltd
# Licence:      Same as wxPython host

# History:      17 Jun 2009 Created 
#
#               08 Oct 2011 Michael Hipp    michael@redmule.com
#               Added prompt, printer_name, orientation options to
#               pdfViewer.Print(). Added option to pdfViewer.LoadFile() to
#               accept a file-like object as well as a path string
#               
#               23 Mar 2013 Werner F Bruhin werner.bruhin@free.fr
#               Added option to import PyPDF2 instead and converted
#               ShowLoadProgress and UsePrintDirect from directives
#               into settable properties
#
#               14 Jun 2013 David Hughes
#               Use mupdf library (via Python-fitz bindings) as backend PDF 
#               extraction & rendering engine if installed otherwise use
#               PyPDF2 else pyPdf. Available from
#               https://github.com/rk700/python-fitz
#               http://www.mupdf.com
#               http://knowah.github.io/PyPDF2/
#               http://pypi.python.org/pypi/pyPdf/1.12
#
#               WARNING. mupdf is GPL so be wary of distributing this in a frozen app
#                        using py2exe, py2app or similar.
#
#----------------------------------------------------------------------------

import sys, os, time, types
import copy, shutil, cStringIO
import wx

VERBOSE = False
# the following only used with pyPdf/PyPDF2
CACHE_LATE_PAGES = True
LATE_THRESHOLD = 200        # Time to render (ttr), milliseconds

try:
    import fitz
    mupdf = True
    if VERBOSE: print 'pdfviewer using Python-fitz/mupdf library (GPL)'
except ImportError:    
    mupdf = False
    try:
        import PyPDF2
        from PyPDF2 import PdfFileReader
        from PyPDF2.pdf import ContentStream, PageObject
        from PyPDF2.filters import ASCII85Decode, FlateDecode
        if VERBOSE: print 'pdfviewer using PyPDF2'
    except ImportError:
        try:
            import pyPdf
            from pyPdf import PdfFileReader
            from pyPdf.pdf import ContentStream, PageObject
            from pyPdf.filters import ASCII85Decode, FlateDecode
            if VERBOSE: print 'pdfviewer using PyPdf'
        except ImportError:
            msg = "Python-fitz (mupdf) or PyPDF2 or pyPdf package must be available"
            raise ImportError(msg)
try:
    import cairo
    from wx.lib.graphics import GraphicsContext
    have_cairo = True
    if VERBOSE: print 'pdfviewer using Cairo'
except ImportError:
    have_cairo = False
    GraphicsContext = wx.GraphicsContext
    if VERBOSE: print 'pdfviewer using wx.GraphicsContext'

if not mupdf:
    from dcgraphics import dcGraphicsContext
    # New PageObject method added by Forestfield Software
    # locate and return all commands in the order they
    # occur in the content stream
    def extractOperators(self):
        ops = []
        content = self["/Contents"].getObject()
        if not isinstance(content, ContentStream):
            content = ContentStream(content, self.pdf)
        for op in content.operations:
            ops.append(op)
        return ops
    # Inject this method into the PageObject class
    PageObject.extractOperators = extractOperators

    # If reportlab is installed, use its stringWidth metric. For justifying text,
    # where widths are cumulative, dc.GetTextExtent consistently underestimates,
    # possibly because it returns integer rather than float.
    try:
        from reportlab.pdfbase.pdfmetrics import stringWidth
        have_rlwidth = True
        if VERBOSE: print 'pdfviewer using reportlab stringWidth function'
    except ImportError:
        have_rlwidth = False

#----------------------------------------------------------------------------
    
class pdfViewer(wx.ScrolledWindow):
    """ View pdf reports in a scrolled window.  Contents are read from PDF file
        and rendered in a GraphicsContext. Show visible window contents
        as quickly as possible then read the whole file and build the set of drawing
        commands for each page. Using pyPdf this can take time for a big file or if
        there are complex drawings eg. ReportLab's colour shading inside charts and a 
        progress bar can be displayed by setting self.ShowLoadProgress = True (default)
    """
    def __init__(self, parent, id, pos, size, style):
        wx.ScrolledWindow.__init__(self, parent, id, pos, size,
                                style | wx.NO_FULL_REPAINT_ON_RESIZE)
        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)     # recommended in wxWidgets docs
        self.buttonpanel = None     # reference to panel is set by their common parent
        self._showLoadProgress = (not mupdf)
        self._usePrintDirect = (not mupdf)

        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
        self.Bind(wx.EVT_SIZE, self.OnResize)
        self.Bind(wx.EVT_SCROLLWIN, self.OnScroll)
        self.Bind(wx.EVT_IDLE, self.OnIdle)
        self.have_file = False
        self.resizing = False
        self.numpages = None
        self.zoomscale = -1     # fit page to screen width
        self.nom_page_gap = 20  # nominal inter-page gap (points) 
        self.scrollrate = 20    # pixels per scrollbar increment
        self.ClearBackground()

    def OnIdle(self, event):
        " Redraw on resize"
        if self.resizing:
            self.Render()
            self.resizing = False
        event.Skip()

    def OnEraseBackground(self, event):
        "Does this need to be handled?"
        event.Skip()

    def OnResize(self, event):
        " Buffer size change due to client area resize."
        self.resizing = True
        if hasattr(self, 'cachedpages'):
            self.cachedpages = {}
        event.Skip()

    def OnScroll(self,event):
        " Recalculate and redraw visible area. CallAfter is *essential* for coordination."
        wx.CallAfter(self.Render, force=False)
        event.Skip()

    def OnPaint(self, event):
        " Refresh visible window with bitmap contents"
        paintDC = wx.PaintDC(self)
        if hasattr(self, 'pdc'):
            paintDC.BeginDrawing()
            paintDC.Blit(0, 0, self.winwidth, self.winheight, self.pdc,
                                                     self.xshift, self.yshift)
            paintDC.EndDrawing()
        else:
            paintDC.Clear()

#----------------------------------------------------------------------------

    # This section defines the externally callable methods:
    # LoadFile, Save, Print, SetZoom, and GoPage also
    # getters and setters for ShowLoadProgress and UsePrintDirect
    # that are only needed if using pyPdf
        
    def LoadFile(self, pdf_file):
        """
        Read pdf file using pypdf. Assume all pages are same size, for now.
        
        :param `pdf_file`: can be either a string holding a filename path or
         a file-like object (pyPdf only).
        """
        if isinstance(pdf_file, types.StringTypes):
            # it must be a filename/path string, open it as a file
            fileobj = file(pdf_file, 'rb')
            self.pdfpathname = pdf_file
        else:
            # assume it is a file-like object
            fileobj = pdf_file
            self.pdfpathname = ''  # empty default file name
        self.ShowLoadProgress = True
        if mupdf:
            self.pdfdoc = mupdfProcessor(self, self.pdfpathname)
        else:
            self.pdfdoc = pypdfProcessor(self, fileobj, self.ShowLoadProgress)
            self.cachedpages = {}

        self.numpages = self.pdfdoc.numpages
        self.pagewidth = self.pdfdoc.pagewidth
        self.pageheight = self.pdfdoc.pageheight
        self.newdoc = True
        self.Scroll(0,0)                # in case this is a re-LoadFile
        self.CalculateDimensions(True)  # to get initial visible page range
        # draw and display the minimal set of pages
        self.pdfdoc.DrawFile(self.frompage, self.topage)
        self.have_file = True
        # now draw full set of pages
        wx.CallAfter(self.pdfdoc.DrawFile, 0, self.numpages-1)

    def Save(self):
        "Save a copy of the pdf file if it was originally named"
        if self.pdfpathname:
            wild = "Portable document format (*.pdf)|*.pdf"
            dlg = wx.FileDialog(self, message="Save file as ...",
                                      wildcard=wild, style=wx.SAVE|wx.OVERWRITE_PROMPT)
            if dlg.ShowModal() == wx.ID_OK:
                pathname = dlg.GetPath()
                shutil.copy(self.pdfpathname, pathname)
            dlg.Destroy()    

    def Print(self, prompt=True, printer_name=None, orientation=None):
        """
        Print the pdf.
        
        :param boolean `prompt`: show the print dialog to the user (True/False). If
         False, the print dialog will not be shown and the pdf will be printed
         immediately. Default: True.
        :param string `printer_name`: the name of the printer that is to
         receive the printout. Default: as set by the O/S.
        :param `orientation`: select the orientation (wx.PORTRAIT or
         wx.LANDSCAPE) for the printout. Default: as set by the O/S.
        """
        pdd = wx.PrintDialogData()
        pdd.SetMinPage(1)
        pdd.SetFromPage(1)
        pdd.SetMaxPage(self.numpages)
        pdd.SetToPage(self.numpages)
        pdata = pdd.GetPrintData()
        if printer_name:
            pdata.SetPrinterName(printer_name)
        if orientation:
            pdata.SetOrientation(orientation)
        # PrintData does not return actual PrintQuality - it can't as printer_name not known
        # but it defaults to wx.PRINT_QUALITY_HIGH, overriding user's own setting for the
        # printer. However calling SetQuality with a value of 0 seems to leave the printer
        # setting untouched
        pdata.SetQuality(0)
        printer = wx.Printer(pdd)
        printout = pdfPrintout('', self)
        if (not printer.Print(self, printout, prompt=prompt) and
                       printer.GetLastError() == wx.PRINTER_ERROR):
            dlg = wx.MessageDialog(self, 'Unable to perform printing',
                              'Printer' , wx.OK | wx.ICON_INFORMATION)
            dlg.ShowModal()
            dlg.Destroy()
        printout.Destroy()

    def SetZoom(self, zoomscale):
        """ Positive integer or floating zoom scale will render the file at corresponding
            size where 1.0 is "actual" point size (1/72"). 
            -1 fits page width and -2 fits page height into client area
            Redisplay the current page(s) at the new size
        """
        pagenow = self.frompage
        self.zoomscale = zoomscale
        if hasattr(self, 'cachedpages'):
            self.cachedpages = {}
        self.CalculateDimensions(True)
        self.GoPage(pagenow)

    def GoPage(self, pagenum):
        if pagenum > 0 and pagenum <= self.numpages:
            self.Scroll(0, pagenum*self.Ypagepixels/self.GetScrollPixelsPerUnit()[1])
        else:
            self.Scroll(0, 0)
        # calling Scroll sometimes doesn't raise wx.EVT_SCROLLWIN eg Windows 8 64 bit - so  
        wx.CallAfter(self.Render, force=False)
    
    @property
    def ShowLoadProgress(self):
        """Property to control if loading progress be shown."""
        return self._showLoadProgress
    
    @ShowLoadProgress.setter
    def ShowLoadProgress(self, flag):
        """Setter for showLoadProgress."""
        self._showLoadProgress = flag
       
    @property
    def UsePrintDirect(self):
        """
        Property to control to use either Cairo (via a page buffer) or
        dcGraphicsContext depending.
        """
        return self._usePrintDirect
    
    @UsePrintDirect.setter
    def UsePrintDirect(self, flag):
        """Setter for usePrintDirect."""
        self._usePrintDirect = flag
 
#----------------------------------------------------------------------------

    "This section is concerned with rendering a sub-set of drawing commands on demand"

    def CalculateDimensions(self, force):
        """ Compute the required buffer sizes to hold the viewed rectangle and
            the range of pages visible. Override force flag and set true if 
            the current set of rendered pages changes
        """
        self.frompage = 0
        self.topage = 0
        self.clientdc = dc = wx.ClientDC(self)      # dc for device scaling 
        self.device_scale = dc.GetPPI()[0]/72.0     # pixels per inch / points per inch 
        if wx.PlatformInfo[1] == 'wxMSW': 
            # for Windows only wx.GraphicsContext fonts are too big in the ratio  
            # of screen pixels per inch to points per inch 
            self.font_scale = 1.0 / self.device_scale
        else:
            self.font_scale = 1.0
                                       
        self.winwidth, self.winheight = self.GetClientSizeTuple()
        if self.winheight < 100:
            return
        self.Ypage = self.pageheight + self.nom_page_gap
        if self.zoomscale > 0.0:
            self.scale = self.zoomscale * self.device_scale
        else:
            if int(self.zoomscale) == -1:   # fit width
                self.scale = self.winwidth / self.pagewidth
            else:                           # fit page
                self.scale = self.winheight / self.pageheight
        self.Xpagepixels = int(round(self.pagewidth*self.scale))
        self.Ypagepixels = int(round(self.Ypage*self.scale))

        # adjust inter-page gap so Ypagepixels is a whole number of scroll increments
        # and page numbers change precisely on a scroll click
        idiv = self.Ypagepixels/self.scrollrate
        nlo = idiv * self.scrollrate
        nhi = (idiv + 1) * self.scrollrate
        if nhi - self.Ypagepixels < self.Ypagepixels - nlo:
            self.Ypagepixels = nhi
        else:
            self.Ypagepixels = nlo
        self.page_gap = self.Ypagepixels/self.scale - self.pageheight   

        self.maxwidth = max(self.winwidth, self.Xpagepixels)
        self.maxheight = max(self.winheight, self.numpages*self.Ypagepixels)
        self.SetVirtualSize((self.maxwidth, self.maxheight))
        self.SetScrollRate(self.scrollrate,self.scrollrate)

        xv, yv = self.GetViewStart()
        dx, dy = self.GetScrollPixelsPerUnit()
        self.x0, self.y0   = (xv * dx, yv * dy)
        self.frompage = min(self.y0/self.Ypagepixels, self.numpages-1)
        self.topage = min((self.y0+self.winheight-1)/self.Ypagepixels, self.numpages-1)
        self.pagebufferwidth = max(self.Xpagepixels, self.winwidth)
        self.pagebufferheight = (self.topage - self.frompage + 1) * self.Ypagepixels

        # Inform buttonpanel controls of any changes
        if self.buttonpanel:
            self.buttonpanel.Update(self.frompage, self.numpages,
                                      self.scale/self.device_scale)

        self.page_y0 = self.frompage * self.Ypagepixels
        self.page_x0 = 0
        self.xshift = self.x0 - self.page_x0
        self.yshift = self.y0 - self.page_y0
        if force:               # by external request 
            self.cur_frompage = self.frompage
            self.cur_topage = self.topage
        else:   # page range unchanged? whole visible area will always be inside page buffer
            if self.frompage <> self.cur_frompage or self.topage <> self.cur_topage:  
                force = True    # due to page buffer change
                self.cur_frompage = self.frompage
                self.cur_topage = self.topage
        return force

    def Render(self, force=True):
        """ Recalculate dimensions as client area may have been scrolled or resized.
            The smallest unit of rendering that can be done is the pdf page. So render
            the drawing commands for the pages in the visible rectangle into a buffer
            big enough to hold this set of pages. Force re-creating the page buffer
            only when client view moves outside it.
            With pyPdf, use gc.Translate to render each page wrt the pdf origin,
            which is at the bottom left corner of the page.
        """
        if not self.have_file:
            return
        force =  self.CalculateDimensions(force or self.newdoc)
        self.newdoc = False     # this ensured page buffer recreated if a new document
        if force:
            # Initialize the buffer bitmap. 
            self.pagebuffer = wx.EmptyBitmap(self.pagebufferwidth, self.pagebufferheight)
            self.pdc = wx.MemoryDC(self.pagebuffer)     # must persist
            gc = GraphicsContext.Create(self.pdc)       # Cairo/wx.GraphicsContext API
            # white background
            path = gc.CreatePath()
            path.AddRectangle(0, 0, self.pagebuffer.GetWidth(), self.pagebuffer.GetHeight())
            gc.SetBrush(wx.WHITE_BRUSH)
            gc.FillPath(path)

            for pageno in range(self.frompage, self.topage+1):
                self.xpageoffset = 0 - self.x0
                self.ypageoffset = pageno*self.Ypagepixels - self.page_y0
                if not mupdf and pageno in self.cachedpages:
                    self.pdc.Blit(self.xpageoffset, self.ypageoffset,
                                     self.Xpagepixels, self.Ypagepixels, 
                                       self.cachedpages[pageno], 0, 0)
                else:    
                    t1 = time.time()
                    gc.PushState()
                    if mupdf:
                        gc.Translate(self.xpageoffset, self.ypageoffset)
                        # scaling is done inside RenderPage
                    else:    

                        gc.Translate(self.xpageoffset, self.ypageoffset +
                                        self.pageheight*self.scale)
                        gc.Scale(self.scale, self.scale)
                    self.pdfdoc.RenderPage(gc, pageno, self.scale)
                    # Show inter-page gap
                    gc.SetBrush(wx.Brush(wx.Colour(180, 180, 180)))        #mid grey
                    gc.SetPen(wx.TRANSPARENT_PEN)
                    if mupdf:
                        gc.DrawRectangle(0, self.pageheight*self.scale,
                                     self.pagewidth*self.scale, self.page_gap*self.scale)
                    else:    
                        gc.DrawRectangle(0, 0, self.pagewidth, self.page_gap)
                    gc.PopState()
                    ttr = time.time()-t1 
                    if not mupdf and CACHE_LATE_PAGES and ttr * 1000 > LATE_THRESHOLD:
                        self.CachePage(pageno)      # save page out of buffer
            gc.PushState()    
            gc.Translate(0-self.x0, 0-self.page_y0)
            self.RenderPageBoundaries(gc)
            gc.PopState()

        self.Refresh(0)     # Blit appropriate area of new or existing page buffer to screen

    def RenderPageBoundaries(self, gc):
        "Show non-page areas in grey"
        gc.SetBrush(wx.Brush(wx.Colour(180, 180, 180)))        #mid grey
        gc.SetPen(wx.TRANSPARENT_PEN)
        gc.Scale(1.0, 1.0)
        extrawidth = self.winwidth - self.Xpagepixels
        if extrawidth > 0:
            gc.DrawRectangle(self.winwidth-extrawidth, 0, extrawidth, self.maxheight)
        extraheight = self.winheight - (self.numpages*self.Ypagepixels - self.y0)
        if extraheight > 0:
            gc.DrawRectangle(0, self.winheight-extraheight, self.maxwidth, extraheight)

    def CachePage(self, pageno):
        """ When page takes a 'long' time to render, save its contents out of
            self.pdc and re-use it to minimise jerky scrolling
        """
        cachebuffer = wx.EmptyBitmap(self.Xpagepixels, self.Ypagepixels)
        cdc = wx.MemoryDC(cachebuffer)
        cdc.Blit(0, 0, self.Xpagepixels, self.Ypagepixels,
                      self.pdc, self.xpageoffset, self.ypageoffset)
        self.cachedpages[pageno] = cdc
       
#============================================================================

class mupdfProcessor(object):
    """ Create an instance of this class to open a PDF file, process the contents of
        each page and render each one on demand using the GPL mupdf library, which is
        accessed via the python-fitz package bindings
    """ 
    def __init__(self, parent, pathname):
        " pathname must be Stringtype not unicode"
        self.parent = parent
        if isinstance(pathname, types.UnicodeType):
            pathname = pathname.encode('latin-1')
        self.context = fitz.Context(fitz.FZ_STORE_UNLIMITED)
        self.pdfdoc = self.context.open_document(pathname)
        self.numpages = self.pdfdoc.count_pages()
        page1 = self.pdfdoc.load_page(0)
        self.pagewidth = page1.bound_page().x1
        self.pageheight = page1.bound_page().y1
        self.pagedrawings = {}
        self.zoom_error = False     #set if memory errors during render

    def DrawFile(self, frompage, topage):
        """ Build set of drawing commands from PDF contents. This need be done only
            once for the whole file. Each page is placed in a display_list which can
            be (re)drawn many times using run_display_list()
        """  
        for pageno in range(frompage, topage+1):
            self.page = self.pdfdoc.load_page(pageno)
            self.pagedrawings[pageno] = self.context.new_display_list()
            mdev = self.pagedrawings[pageno].new_list_device()
            self.page.run_page(mdev, fitz.fz_identity, None)
            self.page_rect = self.page.bound_page()
        self.parent.GoPage(frompage)

    def RenderPage(self, gc, pageno, scale=1.0):
        " Render the set of pagedrawings into gc for specified page "
        self.trans = fitz.scale_matrix(scale, scale)
        self.rect = self.trans.transform_rect(self.page_rect) #page_rect is the unscaled one
        self.bbox = self.rect.round_rect()

        try:
            self.pix = self.context.new_pixmap_with_irect(fitz.fz_device_rgb, self.bbox)
            self.pix.clear_pixmap(255)
            width = self.pix.get_width()
            height = self.pix.get_height()
            dev = self.pix.new_draw_device()
            self.pagedrawings[pageno].run_display_list(dev, self.trans, self.rect, None)
            bmp = wx.BitmapFromBufferRGBA(width, height,self.pix.get_samples())
            gbmp = gc.CreateBitmap(bmp)
            gc.DrawBitmap(gbmp, 0, 0, width, height)
            self.zoom_error = False
        except RuntimeError, MemoryError:
            if not self.zoom_error:     # report once only
                self.zoom_error = True
                dlg = wx.MessageDialog(self, 'Out of memory. Zoom level too high',
                              'pdf viewer' , wx.OK |wx.ICON_EXCLAMATION)
                dlg.ShowModal()
                dlg.Destroy()
       
#============================================================================

class pypdfProcessor(object):
    """ Create an instance of this class to open a PDF file, process the contents of
        each page and draw each one on demand using the Python pypdf package
    """    
    def __init__(self, parent, fileobj, showloadprogress):
        self.parent = parent
        self.showloadprogress = showloadprogress
        self.pdfdoc = PdfFileReader(fileobj)
        self.numpages = self.pdfdoc.getNumPages()
        page1 = self.pdfdoc.getPage(0)
        self.pagewidth = float(page1.mediaBox.getUpperRight_x())
        self.pageheight = float(page1.mediaBox.getUpperRight_y())
        self.pagedrawings = {}
        self.unimplemented = {}
        self.formdrawings = {}

    "These methods interpret the PDF contents as a set of drawing commands"

    def Progress(self, ptype, value):
        " This function is called at regular intervals during Drawfile"
        if ptype == 'start':
            msg = 'Reading pdf file'
            self.progbar = wx.ProgressDialog('Load file', msg, value, None,  
                         wx.PD_AUTO_HIDE|
                            wx.PD_ESTIMATED_TIME|wx.PD_REMAINING_TIME)
        elif ptype == 'progress':
            self.progbar.Update(value)
        elif ptype == 'end':
            self.progbar.Destroy()

    def DrawFile(self, frompage, topage):
        """ Build set of drawing commands from PDF contents. Ideally these could be drawn
            straight into a PseudoDC and the visible section painted directly into
            scrolled window, but we need to be able to zoom and scale the output quickly
            without having to rebuild the drawing commands (slow). So roll our
            own command lists, one per page, into self.pagedrawings.
        """  
        t0 = time.time()
        numpages_generated = 0
        rp = (self.showloadprogress and frompage == 0 and topage == self.numpages-1)
        if rp: self.Progress('start', self.numpages)
        for self.pageno in range(frompage, topage+1):
            self.gstate = pdfState()    # state is reset with every new page
            self.saved_state = []
            self.page = self.pdfdoc.getPage(self.pageno)
            numpages_generated += 1
            pdf_fonts = self.FetchFonts(self.page)
            self.pagedrawings[self.pageno] = self.ProcessOperators(
                                    self.page.extractOperators(), pdf_fonts)    
            if rp: self.Progress('progress', numpages_generated)

        ## print 'Pages %d to %d. %d pages created in %.2f seconds' % (
        ##           frompage, topage, numpages_generated,(time.time()-t0))
        if rp: self.Progress('end', None)
        self.parent.GoPage(frompage)

    def RenderPage(self, gc, pageno, scale=None):
        """ Render the set of pagedrawings
            In a pdf file, bitmaps are treated as being of unit width and height and
            are scaled via a previous ConcatTransform containing the corresponding width 
            and height as scale factors. wx.GraphicsContext/Cairo appear not to respond to  
            this so scaling is removed from transform and width & height are added
            to the Drawbitmap call.
        """    
        drawdict = {'ConcatTransform': gc.ConcatTransform,
                    'PushState': gc.PushState,
                    'PopState': gc.PopState,
                    'SetFont': gc.SetFont,
                    'SetPen': gc.SetPen,
                    'SetBrush': gc.SetBrush,
                    'DrawText': gc.DrawText,
                    'DrawBitmap': gc.DrawBitmap,
                    'CreatePath': gc.CreatePath,
                    'DrawPath': gc.DrawPath }
        for drawcmd, args, kwargs in self.pagedrawings[pageno]:
            if drawcmd == 'ConcatTransform':
                cm = gc.CreateMatrix(*args, **kwargs)
                args = (cm,)
            if drawcmd == 'CreatePath':
                gp = drawdict[drawcmd](*args, **kwargs)
                continue
            elif drawcmd == 'DrawPath':
                args = (gp, args[1])
            if drawcmd in drawdict:
                drawdict[drawcmd](*args, **kwargs)
            else:
                pathdict = {'MoveToPoint': gp.MoveToPoint,
                            'AddLineToPoint': gp.AddLineToPoint,
                            'AddCurveToPoint': gp.AddCurveToPoint,
                            'AddRectangle': gp.AddRectangle,
                            'CloseSubpath': gp.CloseSubpath }
                if drawcmd in pathdict:    
                    pathdict[drawcmd](*args, **kwargs)

    def FetchFonts(self, currentobject):
        " Return the standard fonts in current page or form"
        pdf_fonts = {}
        try:
            fonts = currentobject["/Resources"].getObject()['/Font']
            for key in fonts:
                pdf_fonts[key] = fonts[key]['/BaseFont'][1:]     # remove the leading '/'
        except KeyError:
            pass
        return pdf_fonts

    def ProcessOperators(self, opslist, pdf_fonts):
        " Interpret each operation in opslist and return in drawlist"
        drawlist = []
        path = []
        for operand, operator in opslist :
            g = self.gstate
            if operator == 'cm':        # new transformation matrix
                # some operands need inverting because directions of y axis
                # in pdf and graphics context are opposite
                a, b, c, d, e, f = map(float, operand)
                drawlist.append(['ConcatTransform', (a, -b, -c, d, e, -f), {}])
            elif operator == 'q':       # save state
                self.saved_state.append(copy.deepcopy(g))
                drawlist.append(['PushState', (), {}])
            elif operator == 'Q':       # restore state
                self.gstate = self.saved_state.pop()
                drawlist.append(['PopState', (), {}])
            elif operator == 'RG':      # Stroke RGB
                rs, gs, bs = [int(v*255) for v in map(float, operand)]
                g.strokeRGB = wx.Colour(rs, gs, bs)
            elif operator == 'rg':      # Fill RGB
                rf, gf, bf = [int(v*255) for v in map(float, operand)]
                g.fillRGB = wx.Colour(rf, gf, bf)
            elif operator == 'K':       # Stroke CMYK
                rs, gs, bs = self.ConvertCMYK(operand)
                g.strokeRGB = wx.Colour(rs, gs, bs)
            elif operator == 'k':       # Fill CMYK
                rf, gf, bf = self.ConvertCMYK(operand)
                g.fillRGB = wx.Colour(rf, gf, bf)
            elif operator == 'w':       # Line width
                g.lineWidth = float(operand[0])
            elif operator == 'J':       # Line cap
                ix = float(operand[0])
                g.lineCapStyle = {0: wx.CAP_BUTT, 1: wx.CAP_ROUND,
                                              2: wx.CAP_PROJECTING}[ix]
            elif operator == 'j':       # Line join
                ix = float(operand[0])
                g.lineJoinStyle = {0: wx.JOIN_MITER, 1: wx.JOIN_ROUND,
                                              2: wx.JOIN_BEVEL}[ix]
            elif operator == 'd':       # Line dash pattern
                g.lineDashArray = map(int, operand[0])
                g.lineDashPhase = int(operand[1])
            elif operator in ('m', 'c', 'l', 're', 'v', 'y', 'h'):    # path defining ops
                path.append([map(float, operand), operator])
            elif operator in ('b', 'B', 'b*', 'B*', 'f', 'F', 'f*',
                                           's', 'S', 'n'):    # path drawing ops
                drawlist.extend(self.DrawPath(path, operator))
                path = []
            elif operator == 'BT':      # begin text object
                g.textMatrix = [1, 0, 0, 1, 0, 0]
                g.textLineMatrix = [1, 0, 0, 1, 0, 0]
            elif operator == 'ET':      # end text object
                continue
            elif operator == 'Tm':      # text matrix
                g.textMatrix = map(float, operand)
                g.textLineMatrix = map(float, operand)
            elif operator == 'TL':      # text leading
                g.leading = float(operand[0])
            #elif operator == 'Tc':     # character spacing
            #    g.charSpacing = float(operand[0])
            elif operator == 'Tw':      # word spacing
                g.wordSpacing = float(operand[0])
            elif operator == 'Ts':      # super/subscript
                g.textRise = float(operand[0])
            elif operator == 'Td':      # next line via offsets
                g.textLineMatrix[4] += float(operand[0])
                g.textLineMatrix[5] += float(operand[1])
                g.textMatrix = copy.copy(g.textLineMatrix)
            elif operator == 'T*':      # next line via leading
                g.textLineMatrix[4] += 0
                g.textLineMatrix[5] -= g.leading if g.leading is not None else 0
                g.textMatrix = copy.copy(g.textLineMatrix)
            elif operator == 'Tf':      # text font
                g.font = pdf_fonts[operand[0]]
                g.fontSize = float(operand[1])
            elif operator == 'Tj':      # show text
                drawlist.extend(self.DrawTextString(operand[0]))
            elif operator == 'Do':      # invoke named XObject
                dlist = self.InsertXObject(operand[0])
                if dlist:               # may be unimplemented decode
                    drawlist.extend(dlist)
            elif operator == 'INLINE IMAGE':    # special pyPdf case + operand is a dict
                dlist = self.InlineImage(operand)
                if dlist:               # may be unimplemented decode
                    drawlist.extend(dlist)
            else:                       # report once
                if operator not in self.unimplemented:
                    if VERBOSE: print 'PDF operator %s is not implemented' % operator
                    self.unimplemented[operator] = 1

        # Fix bitmap transform. Remove the scaling from any transform matrix that precedes
        # a DrawBitmap operation as the scaling is now done in that operation.
        for k in range(len(drawlist)-1):
            if drawlist[k][0] == 'ConcatTransform' and drawlist[k+1][0] == 'DrawBitmap':
                args = list(drawlist[k][1])
                args[0] = 1.0
                args[3] = 1.0
                drawlist[k][1] = tuple(args)
        return drawlist            

    def SetFont(self, pdfont, size):
        """ Returns wx.Font instance from supplied pdf font information """
        self.knownfont = True
        pdfont = pdfont.lower()
        if pdfont.count('courier'):
            family = wx.FONTFAMILY_MODERN 
            font = 'Courier New'
        elif pdfont.count('helvetica'):
            family = wx.FONTFAMILY_SWISS 
            font = 'Arial'
        elif pdfont.count('times'):
            family = wx.FONTFAMILY_ROMAN 
            font = 'Times New Roman'
        elif pdfont.count('symbol'):
            family = wx.FONTFAMILY_DEFAULT 
            font = 'Symbol'
        elif pdfont.count('zapfdingbats'):
            family = wx.FONTFAMILY_DEFAULT 
            font = 'Wingdings'
        else:
            if VERBOSE: print 'Unknown font %s' % pdfont
            self.knownfont = False
            family = wx.FONTFAMILY_SWISS 
            font = 'Arial'
           
        weight = wx.FONTWEIGHT_NORMAL         
        if pdfont.count('bold'):
            weight = wx.FONTWEIGHT_BOLD 
        style = wx.FONTSTYLE_NORMAL
        if pdfont.count('oblique') or pdfont.count('italic'):
            style = wx.FONTSTYLE_ITALIC
        return wx.Font(max(1,size), family, style, weight, faceName=font)

    def DrawTextString(self, text): 
        "word spacing only works for horizontal text (??)"
        dlist = []
        g = self.gstate
        f  = self.SetFont(g.font, g.fontSize*self.parent.font_scale)
        dlist.append(['SetFont', (f, g.fillRGB), {}])
        if g.wordSpacing > 0:
            textlist = text.split(' ')
        else:
            textlist = [text,]
        for item in textlist:
            dlist.append(self.DrawTextItem(item, f))
        return dlist    

    def DrawTextItem(self, textitem, f):
        dc = wx.ClientDC(self.parent)      # dummy dc for text extents 
        g = self.gstate
        x = g.textMatrix[4]
        y = g.textMatrix[5] + g.textRise
        if g.wordSpacing > 0:
            textitem += ' '
        wid, ht, descend, xlead = dc.GetFullTextExtent(textitem, f)
        if have_rlwidth and self.knownfont:   # use ReportLab stringWidth if available 
            width = stringWidth(textitem, g.font, g.fontSize)
        else:
            width = wid
        g.textMatrix[4] += (width + g.wordSpacing)  # update current x position
        return ['DrawText', (textitem, x, -y-(ht-descend)), {}]

    def DrawPath(self, path, action):
        """ Stroke and/or fill the defined path depending on operator """
        dlist = []
        g = self.gstate
        acts = {'S':  (1, 0, 0),
                's':  (1, 0, 0),
                'f':  (0, 1, wx.WINDING_RULE),
                'F':  (0, 1, wx.WINDING_RULE),
                'f*': (0, 1, wx.ODDEVEN_RULE),
                'B':  (1, 1, wx.WINDING_RULE),
                'B*': (1, 1, wx.ODDEVEN_RULE),
                'b':  (1, 1, wx.WINDING_RULE),
                'b*': (1, 1, wx.ODDEVEN_RULE),
                'n':  (0, 0, 0) }
        stroke, fill, rule = acts[action]
        if action in ('s', 'b', 'b*'):
            path.append([[], 'h'])      # close path

        if stroke:
            if g.lineDashArray:
                style = wx.USER_DASH
            else:
                style = wx.SOLID
            cpen = wx.Pen(g.strokeRGB, g.lineWidth, style)
            cpen.SetCap(g.lineCapStyle)
            cpen.SetJoin(g.lineJoinStyle)
            if g.lineDashArray:
                cpen.SetDashes(g.lineDashArray)
            dlist.append(['SetPen', (cpen,), {}])
        else:
            dlist.append(['SetPen', (wx.TRANSPARENT_PEN,), {}])

        if fill:    
            dlist.append(['SetBrush', (wx.Brush(g.fillRGB),), {}])
        else:   
            dlist.append(['SetBrush', (wx.TRANSPARENT_BRUSH,), {}])

        dlist.append(['CreatePath', (), {}]) 
        for xylist, op in path:
            if op == 'm':           # move (to) current point
                x0 = xc = xylist[0]
                y0 = yc = -xylist[1]
                dlist.append(['MoveToPoint', (x0, y0), {}])
            elif op == 'l':         # draw line
                x2 = xylist[0]
                y2 = -xylist[1]
                dlist.append(['AddLineToPoint', (x2, y2), {}])
                xc = x2
                yc = y2
            elif op == 're':        # draw rectangle (x,y at top left)
                x = xylist[0]
                y = -xylist[1]
                w = xylist[2]
                h = xylist[3]
                dlist.append(['AddRectangle', (x, y-h, w, h), {}])
            elif op in ('c', 'v', 'y'):         # draw Bezier curve
                args = []
                if op == 'v':
                    args.extend([xc, yc])
                args.extend([xylist[0], -xylist[1], 
                                xylist[2], -xylist[3]])
                if op == 'y':
                    args.extend([xylist[2], -xylist[3]])
                if op == 'c':
                    args.extend([xylist[4], -xylist[5]]) 
                dlist.append(['AddCurveToPoint', args, {}])
            elif op == 'h':
                dlist.append(['CloseSubpath', (), {}])
        dlist.append(['DrawPath', ('GraphicsPath', rule), {}]) 
        return dlist

    def InsertXObject(self, name):
        " XObject can be an image or a 'form' (an arbitrary PDF sequence) "
        dlist = []
        xobject = self.page["/Resources"].getObject()['/XObject']
        stream = xobject[name]
        if stream.get('/Subtype') == '/Form':
            # insert contents into current page drawing
            if not name in self.formdrawings:       # extract if not already done
                pdf_fonts = self.FetchFonts(stream)
                bbox = stream.get('/BBox')
                matrix = stream.get('/Matrix')
                form_ops = ContentStream(stream, self.pdfdoc).operations
                oplist = [([], 'q'), (matrix, 'cm')]    # push state & apply matrix
                oplist.extend(form_ops)                 # add form contents
                oplist.append(([], 'Q'))                # restore original state
                self.formdrawings[name] = self.ProcessOperators(oplist, pdf_fonts)
            dlist.extend(self.formdrawings[name])
        elif stream.get('/Subtype') == '/Image':
            width = stream['/Width'] 
            height = stream['/Height']
            depth = stream['/BitsPerComponent']
            filters = stream["/Filter"]
            item = self.AddBitmap(stream._data, width, height, filters)
            if item:            # may be unimplemented
                dlist.append(item)
        return dlist

    def InlineImage(self, operand):
        " operand contains an image"
        dlist = []
        data = operand.get('data')
        settings = operand.get('settings')
        width = settings['/W'] 
        height = settings['/H']
        depth = settings['/BPC']
        filters = settings['/F']
        item = self.AddBitmap(data, width, height, filters)
        if item:            # may be unimplemented
            dlist.append(item)
        return dlist

    def AddBitmap(self, data, width, height, filters):
        "Add wx.Bitmap from data, processed by filters"
        if '/A85' in filters or '/ASCII85Decode' in filters:
            data = _AsciiBase85DecodePYTHON(data)
        if '/Fl' in filters or '/FlateDecode' in filters:
            data = FlateDecode.decode(data, None)
        if '/CCF' in filters or  '/CCITTFaxDecode' in filters: 
            if VERBOSE:
                print 'PDF operation /CCITTFaxDecode is not implemented'
            return []
        if '/DCT' in filters or '/DCTDecode' in filters:
            stream = cStringIO.StringIO(data)
            image = wx.ImageFromStream(stream, wx.BITMAP_TYPE_JPEG)
            bitmap = wx.BitmapFromImage(image)
        else:    
            bitmap = wx.BitmapFromBuffer(width, height, data)
        return ['DrawBitmap', (bitmap, 0, 0-height, width, height), {}]

    def ConvertCMYK(self, operand):
        "Convert CMYK values (0 to 1.0) in operand to nearest RGB"
        c, m, y, k = operand
        r = round((1-c)*(1-k)*255)
        b = round((1-y)*(1-k)*255)
        g = round((1-m)*(1-k)*255)
        return (r, g, b)

#----------------------------------------------------------------------------

class pdfState(object):
    """ Instance holds the current pdf graphics and text state. It can be
        saved (pushed) and restored (popped) by the owning parent
    """
    def __init__ (self):
        """ Creates an instance with default values. Individual attributes 
            are modified directly not via getters and setters """
        self.lineWidth = 1.0
        self.lineCapStyle = wx.CAP_BUTT
        self.lineJoinStyle = wx.JOIN_MITER
        self.lineDashArray = []
        self.lineDashPhase = 0
        self.miterLimit = None
        self.strokeRGB = wx.Colour(0, 0, 0)
        self.fillRGB = wx.Colour(0, 0, 0)       # used for both shapes & text
        self.fillMode = None

        self.textMatrix = [1, 0, 0, 1, 0, 0]
        self.textLineMatrix = [1, 0, 0, 1, 0, 0]
        self.charSpacing = 0
        self.wordSpacing = 0
        self.horizontalScaling = None
        self.leading = None
        self.font = None
        self.fontSize = None
        self.textRenderMode = None
        self.textRise = 0

#------------------------------------------------------------------------------

class pdfPrintout(wx.Printout):
    """ Class encapsulating the functionality of printing out the document. The methods below
        over-ride those of the base class and supply document-specific information to the
        printing framework that calls them internally.
    """
    def __init__(self, title, view):
        "Pass in the instance of dpViewer to be printed"
        wx.Printout.__init__(self, title)
        self.view = view

    def HasPage(self, pageno):
        "Report whether pageno exists"
        if pageno <= self.view.numpages:
            return True
        else:
            return False

    def GetPageInfo(self):
        """ Supply maximum range of pages and the range to be printed
            These are initial values passed to Printer dialog, where they
            can be amended by user.
        """ 
        max = self.view.numpages
        return (1, max, 1, max)

    def OnPrintPage(self, page):
        """ Provide the data for page by rendering the drawing commands
            to the printer DC using either Cairo (via a page buffer) or
            dcGraphicsContext depending on self.view.usePrintDirect
        """
        if not mupdf and self.view.UsePrintDirect:
            self.PrintDirect(page)
        else:
            self.PrintViaBuffer(page)
        return True    

    def PrintDirect(self, page):
        """ Provide the data for page by rendering the drawing commands
            to the printer DC using dcGraphicsContext
        """
        pageno = page - 1       # zero based
        width = self.view.pagewidth
        height = self.view.pageheight
        self.FitThisSizeToPage(wx.Size(width, height))
        dc = self.GetDC()
        gc = dcGraphicsContext.Create(dc, height, have_cairo)
        self.view.pdfdoc.RenderPage(gc, pageno)

    def PrintViaBuffer(self, page):
        """ Provide the data for page by drawing it as a bitmap to the printer DC
            sfac needs to provide a high enough resolution bitmap for printing that
            reduces anti-aliasing blur but be kept small to minimise printing time 
        """
        sfac = 4.0
        pageno = page - 1       # zero based
        dc = self.GetDC()
        width = self.view.pagewidth*sfac
        height = self.view.pageheight*sfac
        self.FitThisSizeToPage(wx.Size(width, height))
        # Initialize the buffer bitmap. 
        abuffer = wx.EmptyBitmap(width, height)
        mdc = wx.MemoryDC(abuffer)
        gc = GraphicsContext.Create(mdc)
        # white background
        path = gc.CreatePath()
        path.AddRectangle(0, 0, width, height)
        gc.SetBrush(wx.WHITE_BRUSH)
        gc.FillPath(path)
        if mupdf:
            self.view.pdfdoc.RenderPage(gc, pageno, sfac)
        else:    
            gc.Translate(0, height)
            gc.Scale(sfac, sfac)
            self.view.pdfdoc.RenderPage(gc, pageno)
        dc.DrawBitmap(abuffer, 0, 0)

#------------------------------------------------------------------------------

""" The following has been "borrowed" from  from reportlab.pdfbase.pdfutils,
    where it is used for testing, because the equivalent function in pyPdf
    fails when attempting to decode an embedded JPEG image
"""

def _AsciiBase85DecodePYTHON(input):
    """Decodes input using ASCII-Base85 coding.

    This is not used - Acrobat Reader decodes for you
    - but a round trip is essential for testing."""
    #strip all whitespace
    stripped = ''.join(input.split())
    #check end
    assert stripped[-2:] == '~>', 'Invalid terminator for Ascii Base 85 Stream'
    stripped = stripped[:-2]  #chop off terminator

    #may have 'z' in it which complicates matters - expand them
    stripped = stripped.replace('z','!!!!!')
    # special rules apply if not a multiple of five bytes.
    whole_word_count, remainder_size = divmod(len(stripped), 5)
    #print '%d words, %d leftover' % (whole_word_count, remainder_size)
    #assert remainder_size <> 1, 'invalid Ascii 85 stream!'
    cut = 5 * whole_word_count
    body, lastbit = stripped[0:cut], stripped[cut:]

    out = [].append
    for i in xrange(whole_word_count):
        offset = i*5
        c1 = ord(body[offset]) - 33
        c2 = ord(body[offset+1]) - 33
        c3 = ord(body[offset+2]) - 33
        c4 = ord(body[offset+3]) - 33
        c5 = ord(body[offset+4]) - 33

        num = ((85L**4) * c1) + ((85**3) * c2) + ((85**2) * c3) + (85*c4) + c5

        temp, b4 = divmod(num,256)
        temp, b3 = divmod(temp,256)
        b1, b2 = divmod(temp, 256)

        assert  num == 16777216 * b1 + 65536 * b2 + 256 * b3 + b4, 'dodgy code!'
        out(chr(b1))
        out(chr(b2))
        out(chr(b3))
        out(chr(b4))

    #decode however many bytes we have as usual
    if remainder_size > 0:
        while len(lastbit) < 5:
            lastbit = lastbit + '!'
        c1 = ord(lastbit[0]) - 33
        c2 = ord(lastbit[1]) - 33
        c3 = ord(lastbit[2]) - 33
        c4 = ord(lastbit[3]) - 33
        c5 = ord(lastbit[4]) - 33
        num = (((85*c1+c2)*85+c3)*85+c4)*85L + (c5
                 +(0,0,0xFFFFFF,0xFFFF,0xFF)[remainder_size])
        temp, b4 = divmod(num,256)
        temp, b3 = divmod(temp,256)
        b1, b2 = divmod(temp, 256)
        assert  num == 16777216 * b1 + 65536 * b2 + 256 * b3 + b4, 'dodgy code!'
        #print 'decoding: %d %d %d %d %d -> %d -> %d %d %d %d' % (
        #    c1,c2,c3,c4,c5,num,b1,b2,b3,b4)

        #the last character needs 1 adding; the encoding loses
        #data by rounding the number to x bytes, and when
        #divided repeatedly we get one less
        if remainder_size == 2:
            lastword = chr(b1)
        elif remainder_size == 3:
            lastword = chr(b1) + chr(b2)
        elif remainder_size == 4:
            lastword = chr(b1) + chr(b2) + chr(b3)
        else:
            lastword = ''
        out(lastword)

    #terminator code for ascii 85
    return ''.join(out.__self__)