Ticket #1230: pdfium-poc.patch

tests/xpra/pdfium/__init__.py

@@ +1 @@
+#!/usr/bin/env python
+# This file is part of Xpra.
+# Copyright (C) 2017 Antoine Martin <antoine@devloop.org.uk>
+ No newline at end of file

tests/xpra/pdfium/pdfium.py

@@ +1 @@
+#!/usr/bin/env python
+
+import sys
+
+from tests.xpra.pdfium.print_to_hdc import hdc_print, log, error, DOCINFO, StartDocA, EndDoc, LPCSTR
+
+from xpra.platform.win32.common import GetDeviceCaps
+from xpra.platform.win32 import win32con
+from ctypes import WinDLL, c_void_p, Structure, c_int, c_uint, c_ulong, c_char_p, cast, pointer, POINTER
+from ctypes.wintypes import HDC
+
+class FPDF_LIBRARY_CONFIG(Structure):
+        _fields_ = [
+                ("m_pUserFontPaths",    c_void_p),
+                ("version",                             c_int),
+                ("m_pIsolate",                  c_void_p),
+                ("m_v8EmbedderSlot",    c_uint),
+                ]
+
+FPDF_DOCUMENT = c_void_p
+FPDF_PAGE = c_void_p
+
+pdfium = WinDLL('E:\\libpdfium.dll', use_last_error=True)
+log("pdfium=%s", pdfium)
+FPDF_DestroyLibrary = pdfium.FPDF_DestroyLibrary
+FPDF_InitLibraryWithConfig = pdfium.FPDF_InitLibraryWithConfig
+FPDF_InitLibraryWithConfig.argtypes = [POINTER(FPDF_LIBRARY_CONFIG)]
+FPDF_GetLastError = pdfium.FPDF_GetLastError
+FPDF_GetLastError.restype = c_ulong
+FPDF_GetPageCount = pdfium.FPDF_GetPageCount
+FPDF_GetPageCount.argtypes = [FPDF_DOCUMENT]
+FPDF_GetPageCount.restype = c_int
+FPDF_LoadPage = pdfium.FPDF_LoadPage
+FPDF_LoadPage.argtypes = [FPDF_DOCUMENT, c_int]
+FPDF_RenderPage = pdfium.FPDF_RenderPage
+FPDF_RenderPage.argtypes = [HDC, FPDF_PAGE, c_int, c_int, c_int, c_int, c_int, c_int]
+FPDF_LoadMemDocument = pdfium.FPDF_LoadMemDocument
+FPDF_LoadMemDocument.restype = FPDF_DOCUMENT
+FPDF_LoadMemDocument.argtypes = [c_void_p, c_int, c_void_p]
+FPDF_CloseDocument = pdfium.FPDF_CloseDocument
+FPDF_CloseDocument.argtypes = [FPDF_DOCUMENT]
+
+
+FPDF_ERR_SUCCESS = 0    # No error.
+FPDF_ERR_UNKNOWN = 1    # Unknown error.
+FPDF_ERR_FILE = 2               # File not found or could not be opened.
+FPDF_ERR_FORMAT = 3     # File not in PDF format or corrupted.
+FPDF_ERR_PASSWORD = 4   # Password required or incorrect password.
+FPDF_ERR_SECURITY = 5   # Unsupported security scheme.
+FPDF_ERR_PAGE = 6       # Page not found or content error.
+FPDF_ERR_XFALOAD = 7    # Load XFA error.
+FPDF_ERR_XFALAYOUT = 8  # Layout XFA error.
+
+ERROR_STR = {
+        #FPDF_ERR_SUCCESS : No error.
+        FPDF_ERR_UNKNOWN        : "Unknown error",
+        FPDF_ERR_FILE           : "File not found or could not be opened",
+        FPDF_ERR_FORMAT         : "File not in PDF format or corrupted",
+        FPDF_ERR_PASSWORD       : "Password required or incorrect password",
+        FPDF_ERR_SECURITY       : "Unsupported security scheme",
+        FPDF_ERR_PAGE           : "Page not found or content error",
+        FPDF_ERR_XFALOAD        : "Load XFA error",
+        FPDF_ERR_XFALAYOUT      : "Layout XFA error",
+        }
+
+FPDF_ANNOT = 0x01
+FPDF_LCD_TEXT = 0x02
+FPDF_NO_NATIVETEXT = 0x04
+FPDF_GRAYSCALE = 0x08
+FPDF_DEBUG_INFO = 0x80
+FPDF_NO_CATCH = 0x100
+FPDF_RENDER_LIMITEDIMAGECACHE = 0x200
+FPDF_RENDER_FORCEHALFTONE = 0x400
+FPDF_PRINTING = 0x800
+FPDF_RENDER_NO_SMOOTHTEXT = 0x1000
+FPDF_RENDER_NO_SMOOTHIMAGE = 0x2000
+FPDF_RENDER_NO_SMOOTHPATH = 0x4000
+FPDF_REVERSE_BYTE_ORDER = 0x10
+
+def get_error():
+        global ERROR_STR
+        v = FPDF_GetLastError()
+        return ERROR_STR.get(v, v)
+
+def print_to_hdc(hdc, title="PDF Print Test", pdf_data=None):
+        assert pdf_data, "no pdf data"
+        buf = c_char_p(pdf_data)
+        log("pdf data buffer: %s", buf)
+        log("FPDF_InitLibraryWithConfig=%s", FPDF_InitLibraryWithConfig)
+        config = FPDF_LIBRARY_CONFIG()
+        config.m_pUserFontPaths = None
+        config.version = 2
+        config.m_pIsolate = None
+        config.m_v8EmbedderSlot = 0
+        FPDF_InitLibraryWithConfig(config)
+
+        x = 0
+        y = 0
+        w = GetDeviceCaps(hdc, win32con.HORZRES)
+        h = GetDeviceCaps(hdc, win32con.VERTRES)
+        rotate = 0
+        log("printer device size: %ix%i", w, h)
+        flags = FPDF_PRINTING | FPDF_DEBUG_INFO
+        try:
+                doc = FPDF_LoadMemDocument(cast(buf, c_void_p), len(pdf_data), None)
+                if not doc:
+                        error("FPDF_LoadMemDocument failed, error: %s", get_error())
+                        return 1
+                log("FPDF_LoadMemDocument(..)=%s", doc)
+                count = FPDF_GetPageCount(doc)
+                log("FPDF_GetPageCount(%s)=%s", doc, count)
+
+                docinfo = DOCINFO()
+                docinfo.lpszDocName = LPCSTR("%s\0" % title)
+                r = StartDocA(hdc, pointer(docinfo))
+                if r<0:
+                        log("StartDocA failed: %i", r)
+                        return r
+                log("StartDocA()=%i" % r)
+
+                try:
+                        for i in range(count):
+                                page = FPDF_LoadPage(doc, i)
+                                if not page:
+                                        log("FPDF_LoadPage failed for page %i, error: %s", i, get_error())
+                                        return 1
+                                log("FPDF_LoadPage()=%s page %i loaded", page, i)
+                                FPDF_RenderPage(hdc, page, x, y, w, h, rotate, flags)
+                                log("FPDF_RenderPage page %i rendered", i)
+                finally:
+                        EndDoc(hdc)
+        finally:
+                FPDF_DestroyLibrary()
+        return 0
+
+
+def main():
+        if len(sys.argv)!=2:
+                print("usage: %s /path/to/document.pdf" % sys.argv[0])
+                return 1
+        with open(sys.argv[1], 'rb') as f:
+                pdf_data = f.read()
+
+        def print_cb(hdc):
+                print_to_hdc(hdc, pdf_data=pdf_data)
+        hdc_print(print_cb)
+
+if __name__ == "__main__":
+        sys.exit(main())

tests/xpra/pdfium/print_to_hdc.py

@@ +1 @@
+#!/usr/bin/env python
+
+import sys
+
+from xpra.platform.win32.common import CreateDCA, gdi32
+from xpra.platform.win32.printing import get_printers
+
+from ctypes import cdll, WinDLL, c_void_p, Structure, cast, c_char, c_int, pointer
+from ctypes.wintypes import POINTER, HDC
+from ctypes.wintypes import HANDLE, BOOL, BYTE, LPCSTR, DWORD, WORD
+CHAR = BYTE
+LPHANDLE = PHANDLE = POINTER(HANDLE)
+LPBYTE = POINTER(BYTE)
+LPDWORD = POINTER(DWORD)
+LPPRINTER_DEFAULTS = c_void_p
+PSECURITY_DESCRIPTOR = HANDLE
+
+msvcrt = cdll.msvcrt
+winspool = WinDLL('winspool.drv', use_last_error=True)
+OpenPrinterA = winspool.OpenPrinterA
+OpenPrinterA.restype = BOOL
+ClosePrinter = winspool.ClosePrinter
+ClosePrinter.restype = BOOL
+ClosePrinter.argtypes = [HANDLE]
+OpenPrinterA.argtypes = [LPCSTR, LPHANDLE, LPPRINTER_DEFAULTS]
+GetPrinterA = winspool.GetPrinterA
+GetPrinterA.restype = BOOL
+GetPrinterA.argtypes = [HANDLE, DWORD, c_void_p, DWORD, LPDWORD]
+
+class DOCINFO(Structure):
+        _fields_ = [
+                ("cbSize",              c_int),
+                ("lpszDocName", LPCSTR),
+                ("lpszOutput",  LPCSTR),
+                ("lpszDatatype",LPCSTR),
+                ("fwType",              DWORD),
+                ]
+
+LPDOCINFO = POINTER(DOCINFO)
+StartDocA = gdi32.StartDocA
+StartDocA.argtypes = [HDC, LPDOCINFO]
+EndDoc = gdi32.EndDoc
+EndDoc.argtypes = [HDC]
+EndDoc.restype = int
+StartPage = gdi32.StartPage
+StartPage.argtypes = [HDC]
+EndPage = gdi32.EndPage
+EndPage.argtypes = [HDC]
+TextOutA = gdi32.TextOutA
+TextOutA.restype = BOOL
+TextOutA.argtypes = [HDC, c_int, c_int, LPCSTR, c_int]
+
+CCHDEVICENAME = 32
+
+class DEVMODE(Structure):
+        _fields_ = [
+                ("dmDeviceName",        c_char*CCHDEVICENAME),
+                ("dmSpecVersion",       WORD),
+                ("dmDriverVersion",     WORD),
+                ("dmSize",                      WORD),
+                ("dmDriverExtra",       WORD),
+                ("dmFields",            DWORD), 
+                ] 
+LPDEVMODE = POINTER(DEVMODE)
+
+class PRINTER_INFO_1(Structure):
+        _fields_ = [
+                ("Flags",                       DWORD),
+                ("pDescription",        LPCSTR),
+                ("pName",                       LPCSTR),
+                ("pComment",            LPCSTR),
+                ]
+
+class PRINTER_INFO_2(Structure):
+        _fields_ = [
+                ("pServerName",                 LPCSTR),
+                ("pPrinterName",                LPCSTR),
+                ("pShareName",                  LPCSTR),
+                ("pPortName",                   LPCSTR),
+                ("pDriverName",                 LPCSTR),
+                ("pComment",                    LPCSTR),
+                ("pLocation",                   LPCSTR),
+                ("pDevMode",                    LPDEVMODE),
+                ("pSepFile",                    LPCSTR),
+                ("pPrintProcessor",             LPCSTR),
+                ("pDatatype",                   LPCSTR),
+                ("pParameters",                 LPCSTR),
+                ("pSecurityDescriptor", PSECURITY_DESCRIPTOR),
+                ("Attributes",                  DWORD),
+                ("Priority",                    DWORD),
+                ("DefaultPriority",             DWORD),
+                ("StartTime",                   DWORD),
+                ("UntilTime",                   DWORD),
+                ("Status",                              DWORD),
+                ("cJobs",                               DWORD),
+                ("AveragePPM",                  DWORD),
+                ]
+
+class PRINTER_INFO_8(Structure):
+        _fields_ = [
+                ("pDevMode",                    LPDEVMODE),
+                ]
+PRINTER_INFO_9 = PRINTER_INFO_8
+
+
+def log(msg, *args):
+        sys.stdout.write(msg % args)
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+def error(msg, *args):
+        print(("Error: "+msg) % args)
+
+
+def print_document(hdc, title="Test", print_doc_fn=None):
+        docinfo = DOCINFO()
+        docinfo.lpszDocName = LPCSTR("%s\0" % title)
+        r = StartDocA(hdc, pointer(docinfo))
+        if r<0:
+                log("StartDocA failed: %i", r)
+                return r
+        log("StartDocA()=%i" % r)
+
+        r = StartPage(hdc)
+        if r<0:
+                log("StartPage failed: %i", r)
+                return r
+
+        if print_doc_fn:
+                r = print_doc_fn(hdc)
+                if r!=0:
+                        return r
+
+        r = EndPage(hdc)
+        if r<0:
+                log("EndPage failed: %i", r)
+                return r
+
+        r = EndDoc(hdc)
+        if r<0:
+                log("EndDoc failed: %i" % r)
+                return r
+        log("EndDoc()=%i" % r)
+        return 0
+
+def print_to_hdc(hdc):
+        def print_doc_fn(hdc):
+                x = 100
+                y = 100
+                import datetime
+                s = "test: %s" % (datetime.datetime.now())
+                if not TextOutA(hdc, x, y, LPCSTR(s), len(s)):
+                        log("TextOutA failed")
+                        return 1
+                return 0
+        return print_document(hdc, print_doc_fn=print_doc_fn)
+
+
+def hdc_print(print_fn):
+        printers = get_printers()
+        log("printers: %s", printers)
+        name = LPCSTR(printers.keys()[0])
+        handle = HANDLE()
+        if not OpenPrinterA(name, pointer(handle), None):
+                error("failed to open printer %s" % name)
+                return 1
+        try:
+                log("OpenPrinter: handle=%#x" % handle.value)
+                size = DWORD()
+                GetPrinterA(handle, 1, None, 0, pointer(size))
+                log("GetPrinter: PRINTER_INFO_1 size=%i" % size.value)
+                buf = msvcrt.malloc(size.value)
+                if not GetPrinterA(handle, 1, buf, size.value, pointer(size)):
+                        error("GetPrinterA failed for %s", name)
+                        return 1
+                info = cast(buf, POINTER(PRINTER_INFO_1))
+                log(" flags=%#x" % info[0].Flags)
+                log(" name=%#s" % info[0].pName)
+                log(" description=%s" % info[0].pDescription)
+                log(" comment=%s" % info[0].pComment)
+                msvcrt.free(buf)
+        
+                GetPrinterA(handle, 2, None, 0, pointer(size))
+                log("GetPrinter: PRINTER_INFO_2 size=%i" % size.value)
+                buf = msvcrt.malloc(size.value)
+                if GetPrinterA(handle, 2, buf, size.value, pointer(size)):
+                        info = cast(buf, POINTER(PRINTER_INFO_2))
+                        log(" driver=%#s" % info[0].pDriverName)
+                msvcrt.free(buf)
+        
+                GetPrinterA(handle, 8, None, 0, pointer(size))
+                log("GetPrinter: PRINTER_INFO_8 size=%i" % size.value)
+                info8 = msvcrt.malloc(size.value)
+                devmode = None
+                try:
+                        if GetPrinterA(handle, 8, buf, size.value, pointer(size)):
+                                info = cast(buf, POINTER(PRINTER_INFO_8))
+                                devmode = cast(info[0].pDevMode, POINTER(DEVMODE))
+                                log("devmode=%s" % devmode)
+                                log("device name=%s" % devmode[0].dmDeviceName)
+        
+                        GetPrinterA(handle, 9, None, 0, pointer(size))
+                        log("GetPrinter: PRINTER_INFO_9 size=%i" % size.value)
+                        info9 = msvcrt.malloc(size.value)
+                        if GetPrinterA(handle, 9, buf, size.value, pointer(size)):
+                                info = cast(buf, POINTER(PRINTER_INFO_9))
+                                if info[0].pDevMode:
+                                        devmode = cast(info[0].pDevMode, POINTER(DEVMODE))
+                                        log("devmode=%s" % devmode)
+                                        log("device name=%s" % devmode[0].dmDeviceName)
+                        assert devmode
+        
+                        hdc = CreateDCA(None, name, None, devmode)
+                        log("CreateDCA()=%#x" % hdc)
+
+                        return print_fn(hdc)
+                finally:
+                        msvcrt.free(info8)
+                        msvcrt.free(info9)
+        finally:
+                ClosePrinter(handle)
+        return 0
+
+
+def main():
+        return hdc_print(print_to_hdc)
+
+
+if __name__ == "__main__":
+        sys.exit(main())

xpra/platform/win32/common.py

@@ -6 +6 @@
 
 import ctypes
 
-from ctypes import WinDLL, Structure, c_ulong, c_ushort, c_ubyte, c_int, c_long
+from ctypes import WinDLL, Structure, c_ulong, c_ushort, c_ubyte, c_int, c_long, c_void_p
 from ctypes.wintypes import HWND, DWORD, WPARAM, LPARAM, HDC, HMONITOR, HMODULE, SHORT, ATOM, POINTER, RECT
-from ctypes.wintypes import HANDLE, LPCWSTR, UINT, INT, WINFUNCTYPE, BOOL, HGDIOBJ, LONG, LPVOID, HBITMAP
+from ctypes.wintypes import HANDLE, LPCWSTR, UINT, INT, WINFUNCTYPE, BOOL, HGDIOBJ, LONG, LPVOID, HBITMAP, LPCSTR
 LRESULT = c_long
+DEVMODE = c_void_p
 
 kernel32 = WinDLL("kernel32", use_last_error=True)
 SetConsoleTitleA = kernel32.SetConsoleTitleA
@@ -119 +120 @@
 DeleteDC = gdi32.DeleteDC
 DeleteDC.restype = BOOL
 DeleteDC.argtypes = [HDC]
+CreateDCA = gdi32.CreateDCA
+CreateDCA.restype = HDC
+CreateDCA.argtypes = [LPCSTR, LPCSTR, LPCSTR, DEVMODE]
 
-
 #wrap EnumDisplayMonitors to hide the callback function:
 MonitorEnumProc = ctypes.WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
 _EnumDisplayMonitors = EnumDisplayMonitors

xpra/platform/win32/printing.py

@@ -163 +163 @@
 def get_printers():
     global PRINTER_ENUMS, PRINTER_ENUM_VALUES, SKIPPED_PRINTERS, PRINTER_LEVEL, GSVIEW_DIR
     printers = {}
-    if not GSVIEW_DIR:
-        #without gsprint, we can't handle printing!
-        log("get_printers() gsview is missing, not querying any printers")
-        return printers
+    #if not GSVIEW_DIR:
+    #    #without gsprint, we can't handle printing!
+    #    log("get_printers() gsview is missing, not querying any printers")
+    #    return printers
     #default_printer = GetDefaultPrinter()
     for penum in PRINTER_ENUMS:
         try:
@@ -179 +179 @@
             for p in EnumPrinters(enum_val, None, PRINTER_LEVEL):
                 flags, desc, name, comment = p
                 if name in SKIPPED_PRINTERS:
-                    log("skipped printer: %s, %s, %s, %s", flags, desc, name, comment)
+                    log("skipped printer: %#x, %s, %s, %s", flags, desc, name, comment)
                     continue
                 if name in printers:
-                    log("skipped duplicate printer: %s, %s, %s, %s", flags, desc, name, comment)
+                    log("skipped duplicate printer: %#x, %s, %s, %s", flags, desc, name, comment)
                     continue
-                log("found printer: %s, %s, %s, %s", flags, desc, name, comment)
+                log("found printer: %#x, %s, %s, %s", flags, desc, name, comment)
                 #strip duplicated and empty strings from the description:
                 desc_els = []
                 [desc_els.append(x) for x in desc.split(",") if (x and not desc_els.count(x))]