wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/pdfviewer/viewer.py

@@ -0,0 +1,1077 @@
+# 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:      Created 17 Jun 2009
+#
+#               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
+#
+# Tags:         phoenix-port, documented, unittest
+#
+#----------------------------------------------------------------------------
+
+"""
+
+This module provides the :class:`~wx.lib.pdfviewer.viewer.pdfViewer` to view PDF
+files.
+"""
+
+import sys
+import os
+import time
+import types
+import copy
+import shutil
+from six import BytesIO, string_types
+
+import wx
+
+VERBOSE = True
+
+try:
+    # see http://pythonhosted.org/PyMuPDF - documentation & installation
+    import fitz
+    mupdf = True
+    if VERBOSE: print('pdfviewer using PyMuPDF (GPL)')
+except ImportError:
+    mupdf = False
+    try:
+        # see http://pythonhosted.org/PyPDF2
+        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:
+        msg = "PyMuPDF or PyPDF2 must be available to use pdfviewer"
+        raise ImportError(msg)
+
+GraphicsContext = wx.GraphicsContext
+have_cairo = False
+if not mupdf:
+    try:
+        import wx.lib.wxcairo as wxcairo
+        import cairo
+        from wx.lib.graphics import GraphicsContext
+        have_cairo = True
+        if VERBOSE: print('pdfviewer using Cairo')
+    except ImportError:
+        if VERBOSE: print('pdfviewer using wx.GraphicsContext')
+
+    # New PageObject method added by Forestfield Software
+    def extractOperators(self):
+        """
+        Locate and return all commands in the order they
+        occur in the content stream
+        """
+        ops = []
+        content = self["/Contents"].getObject()
+        if not isinstance(content, ContentStream):
+            content = ContentStream(content, self.pdf)
+        for op in content.operations:
+            if type(op[1] == bytes):
+                op = (op[0], op[1].decode())
+            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 file in a scrolled window.  Contents are read from PDF file
+    and rendered in a GraphicsContext. Show visible window contents
+    as quickly as possible then, when using pyPDF, read the whole file and build
+    the set of drawing commands for each page. 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, nid, pos, size, style):
+        """
+        Default class constructor.
+
+        :param wx.Window `parent`: parent window. Must not be ``None``;
+        :param integer `nid`: window identifier. A value of -1 indicates a default value;
+        :param `pos`: the control position. A value of (-1, -1) indicates a default position,
+         chosen by either the windowing system or wxPython, depending on platform;
+        :type `pos`: tuple or :class:`wx.Point`
+        :param `size`: the control size. A value of (-1, -1) indicates a default size,
+         chosen by either the windowing system or wxPython, depending on platform;
+        :type `size`: tuple or :class:`wx.Size`
+        :param integer `style`: the button style (unused);
+
+        """
+        wx.ScrolledWindow.__init__(self, parent, nid, 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.Bind(wx.EVT_PAINT, self.OnPaint)
+        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.page_buffer_valid = False
+        self.page_after_zoom_change = None
+        self.ClearBackground()
+
+    def OnIdle(self, event):
+        """
+        Redraw on resize.
+        """
+        if self.resizing:
+            self.page_buffer_valid = False
+            self.Render()
+            self.resizing = False
+        event.Skip()
+
+    def OnResize(self, event):
+        """
+        Buffer size change due to client area resize.
+        """
+        self.resizing = True
+        event.Skip()
+
+    def OnScroll(self, event):
+        """
+        Recalculate and redraw visible area. CallAfter is *essential*
+        for coordination.
+        """
+        wx.CallAfter(self.Render)
+        event.Skip()
+
+    def OnPaint(self, event):
+        """
+        Refresh visible window with bitmap contents.
+        """
+        paintDC = wx.PaintDC(self)
+        paintDC.Clear()         # in case buffer now smaller than visible window
+        if hasattr(self, 'pdc'):
+            paintDC.Blit(0, 0, self.winwidth, self.winheight, self.pdc,
+                                                     self.xshift, self.yshift)
+
+#----------------------------------------------------------------------------
+
+    # This section defines the externally callable methods:
+    # LoadFile, Save, Print, SetZoom, and GoPage
+    # also the getter and setter for ShowLoadProgress
+    # that is only applicable if using PyPDF2
+
+    def LoadFile(self, pdf_file):
+        """
+        Read pdf file. 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.
+        """
+        def create_fileobject(filename):
+            """
+            Create and return a file object with the contents of filename,
+            only used for testing.
+            """
+            with open(filename, 'rb') as f:
+                stream = f.read()
+            return BytesIO(stream)
+
+        self.pdfpathname = ''
+        if isinstance(pdf_file, string_types):
+            # a filename/path string, save its name
+            self.pdfpathname = pdf_file
+            # remove comment from next line to test using a file-like object
+            # pdf_file = create_fileobject(pdf_file)
+        if mupdf:
+            self.pdfdoc = mupdfProcessor(self, pdf_file)
+        else:
+            self.pdfdoc = pypdfProcessor(self, pdf_file, self.ShowLoadProgress)
+
+        self.numpages = self.pdfdoc.numpages
+        self.pagewidth = self.pdfdoc.pagewidth
+        self.pageheight = self.pdfdoc.pageheight
+        self.page_buffer_valid = False
+        self.Scroll(0, 0)               # in case this is a re-LoadFile
+        self.CalculateDimensions()      # 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.FD_SAVE | wx.FD_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 (:class:`wx.PORTRAIT` or
+         :class:`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
+
+        :param `zoomscale`: an integer or float
+
+        """
+        pagenow = self.frompage
+        self.zoomscale = zoomscale
+        self.page_buffer_valid = False
+        # calling GoPage now will trigger rendering at the new size but the page location
+        # will be calculated based on the old zoom scale - so save the required page number
+        # and call GoPage again *after* rendering at the new size
+        self.page_after_zoom_change = pagenow
+        self.GoPage(pagenow)
+
+    def GoPage(self, pagenum):
+        """
+        Go to page
+
+        :param integer `pagenum`: go to the provided page number if it is valid
+
+        """
+        if pagenum > 0 and pagenum <= self.numpages:
+            self.Scroll(0, pagenum*self.Ypagepixels/self.GetScrollPixelsPerUnit()[1] + 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)
+
+    @property
+    def ShowLoadProgress(self):
+        """Property to control if file reading progress is shown (PyPDF2 only)"""
+        return self._showLoadProgress
+
+    @ShowLoadProgress.setter
+    def ShowLoadProgress(self, flag):
+        """Setter for showLoadProgress."""
+        self._showLoadProgress = flag
+
+#----------------------------------------------------------------------------
+
+    # This section is concerned with rendering a sub-set of drawing commands on demand
+
+    def CalculateDimensions(self):
+        """
+        Compute the required buffer sizes to hold the viewed rectangle and
+        the range of pages visible. Set self.page_buffer_valid = False if
+        the current set of rendered pages changes
+        """
+        self.frompage = 0
+        self.topage = 0
+        device_scale = wx.ClientDC(self).GetPPI()[0]/72.0   # pixels per inch/points per inch
+        self.font_scale_metrics =  1.0
+        self.font_scale_size = 1.0
+        # for Windows only with wx.GraphicsContext the rendered font size is too big
+        # in the ratio of screen pixels per inch to points per inch
+        # and font metrics are too big in the same ratio for both for Cairo and wx.GC
+        if wx.PlatformInfo[1] == 'wxMSW':
+            self.font_scale_metrics = 1.0 / device_scale
+            if not have_cairo:
+                self.font_scale_size = 1.0 / device_scale
+
+        self.winwidth, self.winheight = self.GetClientSize()
+        self.Ypage = self.pageheight + self.nom_page_gap
+        if self.zoomscale > 0.0:
+            self.scale = self.zoomscale * 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
+        if self.scale == 0.0: # this could happen if the window was not yet initialized
+            self.scale = 1.0
+        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 = int(min(self.y0/self.Ypagepixels, self.numpages-1))
+        self.topage = int(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/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 not self.page_buffer_valid:  # via external setting
+            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:
+                self.page_buffer_valid = False    # due to page buffer change
+                self.cur_frompage = self.frompage
+                self.cur_topage = self.topage
+        return
+
+    def Render(self):
+        """
+        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 PyPDF2, 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
+        self.CalculateDimensions()
+        if not self.page_buffer_valid:
+            # Initialize the buffer bitmap.
+            self.pagebuffer = wx.Bitmap(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
+                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, scale=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()
+            gc.PushState()
+            gc.Translate(0-self.x0, 0-self.page_y0)
+            self.RenderPageBoundaries(gc)
+            gc.PopState()
+
+        self.page_buffer_valid = True
+        self.Refresh(0) # Blit appropriate area of new or existing page buffer to screen
+
+        # ensure we stay on the same page after zoom scale is changed
+        if self.page_after_zoom_change:
+            self.GoPage(self.page_after_zoom_change)
+            self.page_after_zoom_change = None
+
+    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)
+
+#============================================================================
+
+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 (version 1.9.1 or later)
+    """
+    def __init__(self, parent, pdf_file):
+        """
+        :param `pdf_file`: a File object or an object that supports the standard
+        read and seek methods similar to a File object.
+        Could also be a string representing a path to a PDF file.
+        """
+        self.parent = parent
+        if isinstance(pdf_file, string_types):
+            # a filename/path string, pass the name to fitz.open
+            pathname = pdf_file
+            self.pdfdoc = fitz.open(pathname)
+        else:
+            # assume it is a file-like object, pass the stream content to fitz.open
+            # and a '.pdf' extension in pathname to identify the stream type
+            pathname = 'fileobject.pdf'
+            if pdf_file.tell() > 0:     # not positioned at start
+                pdf_file.seek(0)
+            stream = bytearray(pdf_file.read())
+            self.pdfdoc = fitz.open(pathname, stream)
+
+        self.numpages = self.pdfdoc.pageCount
+        page = self.pdfdoc.loadPage(0)
+        self.pagewidth = page.bound().width
+        self.pageheight = page.bound().height
+        self.page_rect = page.bound()
+        self.zoom_error = False     #set if memory errors during render
+
+    def DrawFile(self, frompage, topage):
+        """
+        This is a no-op for mupdf. Each page is scaled and drawn on
+        demand during RenderPage directly via a call to page.getPixmap()
+        """
+        self.parent.GoPage(frompage)
+
+    def RenderPage(self, gc, pageno, scale=1.0):
+        " Render the set of pagedrawings into gc for specified page "
+        page = self.pdfdoc.loadPage(pageno)
+        matrix = fitz.Matrix(scale, scale)
+        try:
+            pix = page.getPixmap(matrix=matrix, alpha=False)   # MUST be keyword arg(s)
+            bmp = wx.Bitmap.FromBuffer(pix.width, pix.height, pix.samples)
+            gc.DrawBitmap(bmp, 0, 0, pix.width, pix.height)
+            self.zoom_error = False
+        except (RuntimeError, MemoryError):
+            if not self.zoom_error:     # report once only
+                self.zoom_error = True
+                dlg = wx.MessageDialog(self.parent, '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
+    every page using PyPDF2 then render each one on demand
+    """
+    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 = {}
+        self.page = None
+        self.gstate = None
+        self.saved_state = None
+        self.knownfont = False
+        self.progbar = None
+
+    # 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':
+            pmsg = 'Reading pdf file'
+            self.progbar = wx.ProgressDialog('Load file', pmsg, 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 build our
+        own command lists, one per page, into self.pagedrawings.
+        """
+        numpages_generated = 0
+        rp = (self.showloadprogress and frompage == 0 and topage == self.numpages-1)
+        if rp: self.Progress('start', self.numpages)
+        for pageno in range(frompage, topage+1):
+            self.gstate = pdfState()    # state is reset with every new page
+            self.saved_state = []
+            self.page = self.pdfdoc.getPage(pageno)
+            numpages_generated += 1
+            pdf_fonts = self.FetchFonts(self.page)
+            self.pagedrawings[pageno] = self.ProcessOperators(
+                                    self.page.extractOperators(), pdf_fonts)
+            if rp: self.Progress('progress', numpages_generated)
+
+        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]:
+            # scale font if requested by printer DC
+            if drawcmd == 'SetFont' and hasattr(gc, 'font_scale'):
+                args[0].Scale(gc.font_scale)
+            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)
+                # reset font scaling in case RenderPage call is repeated
+                if drawcmd == 'SetFont' and hasattr(gc, 'font_scale'):
+                    args[0].Scale(1.0/gc.font_scale)
+            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' and operand:        # 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 = [float(n) for n in 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(float(n)*255) for n in operand]
+                g.strokeRGB = wx.Colour(rs, gs, bs)
+            elif operator == 'rg':      # Fill RGB
+                rf, gf, bf = [int(float(n)*255) for n in 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 = max(float(operand[0]), 1.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 = [int(n) for n in operand[0]]
+                g.lineDashPhase = int(operand[1])
+            elif operator in ('m', 'c', 'l', 're', 'v', 'y', 'h'):    # path defining ops
+                path.append([[float(n) for n in 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 = [float(n) for n in operand]
+                g.textLineMatrix = [float(n) for n in 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].original_bytes.decode('latin-1')))
+            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. Move the scaling from any transform matrix that precedes
+        # a DrawBitmap operation into the op itself - the width and height extracted from
+        # the bitmap is the size of the original PDF image not the size it is to be drawn
+        for k in range(len(drawlist)-1):
+            if drawlist[k][0] == 'ConcatTransform' and drawlist[k+1][0] == 'DrawBitmap':
+                ctargs = list(drawlist[k][1])
+                bmargs = list(drawlist[k+1][1])
+                bmargs[2] = -ctargs[3]          # y position
+                bmargs[3] = ctargs[0]           # width
+                bmargs[4] = ctargs[3]           # height
+                ctargs[0] = 1.0
+                ctargs[3] = 1.0
+                drawlist[k][1] = tuple(ctargs)
+                drawlist[k+1][1] = tuple(bmargs)
+        return drawlist
+
+    def SetFont(self, pdfont, size):
+        """
+        Returns :class:`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):
+        """
+        Draw a text string. Word spacing only works for horizontal text.
+
+        :param string `text`: the text to draw
+
+        """
+        dlist = []
+        g = self.gstate
+        f0  = self.SetFont(g.font, g.fontSize)
+        f0.Scale(self.parent.font_scale_metrics)
+        f1  = self.SetFont(g.font, g.fontSize)
+        f1.Scale(self.parent.font_scale_size)
+        dlist.append(['SetFont', (f1, g.fillRGB), {}])
+        if g.wordSpacing > 0:
+            textlist = text.split(' ')
+        else:
+            textlist = [text,]
+        for item in textlist:
+            dlist.append(self.DrawTextItem(item, f0))
+        return dlist
+
+    def DrawTextItem(self, textitem, f):
+        """
+        Draw a text item.
+
+        :param `textitem`: the item to draw
+        :param `f`: the font to use for text extent measuring
+
+        """
+        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, x_lead = 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.PENSTYLE_USER_DASH
+            else:
+                style = wx.PENSTYLE_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 = xylist[0]
+                y = -xylist[1]
+                w = xylist[2]
+                h = xylist[3]
+                retuple = (x, y-h, w, h)
+                if h < 0.0:
+                    retuple = (x, y, w, -h)
+                dlist.append(['AddRectangle', retuple, {}])
+            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)
+                x_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']
+            x_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']
+        x_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 = ASCII85Decode.decode(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 = BytesIO(data)
+            image = wx.Image(stream, wx.BITMAP_TYPE_JPEG)
+            bitmap = wx.Bitmap(image)
+        else:
+            try:
+                bitmap = wx.Bitmap.FromBuffer(width, height, data)
+            except:
+                return []       # any error
+        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.BLACK
+        self.fillRGB = wx.BLACK  # 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.
+        """
+        maxnum = self.view.numpages
+        return (1, maxnum, 1, maxnum)
+
+    def OnPrintPage(self, page):
+        """
+        Provide the data for page by rendering the drawing commands
+        to the printer DC, MuPDF returns the page content from an internally
+        generated bitmap and sfac sets it to a high enough resolution that
+        reduces anti-aliasing blur but keeps it small to minimise printing time
+        """
+        sfac = 1.0
+        if mupdf:
+            sfac = 4.0
+        pageno = page - 1       # zero based
+        width = self.view.pagewidth
+        height = self.view.pageheight
+        self.FitThisSizeToPage(wx.Size(width*sfac, height*sfac))
+        dc = self.GetDC()
+        gc = wx.GraphicsContext.Create(dc)
+        if not mupdf:
+            gc.Translate(0, height)
+        if wx.PlatformInfo[1] == 'wxMSW' and have_cairo:
+            device_scale = wx.ClientDC(self.view).GetPPI()[0]/72.0   # pixels per inch/ppi
+            gc.font_scale = 1.0 / device_scale
+
+        self.view.pdfdoc.RenderPage(gc, pageno, sfac)
+        return True