So far I've found two different ways to access what I believe are equivalent versions of the Printer DevMode from a wxPython User Interface:
window = wx.GetTopLevelWindows()[0].GetHandle()
name = self.itemMap['device'].GetValue() # returns a valid printer name.
handle = win32print.OpenPrinter(name)
dmin = None
dmout = pywintypes.DEVMODEType()
mode = DM_IN_BUFFER | DM_OUT_BUFFER | DM_IN_PROMPT
res = win32print.DocumentProperties(window, handle, name, dmout, dmin, mode)
if res == 1:
print dmout.DriverData
and also
dlg = wx.PrintDialog(self, dgData)
res = dlg.ShowModal()
if res == wx.ID_OK:
print dlg.GetPrintDialogData().PrintData.GetPrivData()
These to binary structures appear to contain the necessary information to control the device output behavior. This is fine and well, except that it can't be directly used to reload the PrintSetup dialogs with this stored devmode data. In the first case the PyDEVMODE object contains dozens of individual properties that need to be manually set (PyDEVMODE Reference). In the second case there are a handful of Getter / Setter methods that control some of the properties, but not all of them (wxPrintData Reference). Is anyone aware of a way to create a Python Devmode Object (I'll take either approach, the differences are trivial) from the actual DevMode (the binary data)? I'd like to avoid having to manually store / reset each individual attribute in order for the dialogs to re-open in the correct state every time.
It appears that at this point there's no elegant way to achieve this directly in Python. The closest I was able to come up with was a dll written in c++ that I'm able to call into. I end up with the full binary DevMode Structure, and can reload from it. The code for that c++ dll looks like this:
#include "stdafx.h"
#include <iobind/base64_policy.hpp>
#include <string>
#ifdef _UNICODE
typedef std::wstring string_t;
#else
typedef std::string string_t;
#endif
typedef std::string cstring;
extern "C" BOOL WINAPI DllMain( HMODULE hModule, DWORD dwReason, LPVOID lpReserved ) {
switch ( dwReason ){
case DLL_PROCESS_ATTACH:
DisableThreadLibraryCalls( hModule );
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
extern "C" DOEXPORT int CleanupA( char *output ) {
if ( output ) {
free( output );
output = NULL;
}
return 0;
}
extern "C" DOEXPORT int CleanupW( wchar_t *output ) {
if ( output ) {
free( output );
output = NULL;
}
return 0;
}
extern "C" DOEXPORT int printer_setup(
void *handle, const TCHAR *printer_in, const char *input,
int local_only, TCHAR **printer, char **output )
{
HWND hwnd = (HWND)handle;
HRESULT hResult = 0;
LPPRINTDLG pPD = NULL;
LPPRINTPAGERANGE pPageRanges = NULL;
// Allocate structure.
pPD = (LPPRINTDLG)GlobalAlloc(GPTR, sizeof(PRINTDLG));
if (!pPD) return E_OUTOFMEMORY;
// Initialize structure.
pPD->lStructSize = sizeof(PRINTDLG);
pPD->hwndOwner = hwnd;
pPD->hDevMode = NULL;
if ( input ){
std::string dec = iobind::encode( input, iobind::from_base64_p );
if ( !dec.empty() ) {
HGLOBAL devmode = pPD->hDevMode = ::GlobalAlloc(GPTR, dec.size());
if ( devmode ){
LPDEVMODE src = (LPDEVMODE)&dec[0];
memcpy( devmode, src, dec.size() );
}
}
}
pPD->hDevNames = NULL;
if ( printer_in ){
HGLOBAL printer = pPD->hDevNames = ::GlobalAlloc(GPTR, sizeof(DEVNAMES)+_tcslen(printer_in)*sizeof(TCHAR)+sizeof(TCHAR));
if ( printer ){
LPDEVNAMES dv = (LPDEVNAMES)printer;
dv->wDefault = 0;
dv->wDriverOffset = 0;
dv->wOutputOffset = 0;
dv->wDeviceOffset = sizeof(DEVNAMES)/sizeof(TCHAR);
TCHAR *dest = (TCHAR *)(unsigned long)dv + dv->wDeviceOffset;
_tcscpy( dest, printer_in );
}
}
pPD->hDC = NULL;
pPD->Flags = PD_PRINTSETUP;
if ( local_only ) {
pPD->Flags |= /*PD_ENABLESETUPHOOK |*/ PD_NONETWORKBUTTON;
}
pPD->nMinPage = 1;
pPD->nMaxPage = 1000;
pPD->nCopies = 1;
pPD->hInstance = 0;
pPD->lpPrintTemplateName = NULL;
// Invoke the Print property sheet.
hResult = PrintDlg(pPD);
if ( hResult != 0 ) {
if ( pPD->hDevMode ) {
LPDEVMODE devmode = (LPDEVMODE)::GlobalLock( pPD->hDevMode );
size_t size = devmode->dmSize + devmode->dmDriverExtra;
if ( output ) {
std::string tmp;
tmp.resize( size );
memcpy( &tmp[0], devmode, tmp.size() );
std::string enc = iobind::encode( tmp, iobind::to_base64_p );
*output = _strdup( enc.c_str() );
}
::GlobalUnlock( pPD->hDevMode );
}
if ( pPD->hDevNames ) {
LPDEVNAMES devnames = (LPDEVNAMES)::GlobalLock( pPD->hDevNames );
TCHAR *device = (TCHAR *)(unsigned long)devnames + devnames->wDeviceOffset;
*printer = _tcsdup(device);
::GlobalUnlock( pPD->hDevNames );
}
}
else {
DWORD dlgerr = ::CommDlgExtendedError();
hResult = dlgerr;
}
if (pPD->hDC != NULL) {
DeleteDC( pPD->hDC );
}
if (pPD->hDevMode != NULL) {
GlobalFree( pPD->hDevMode );
}
if (pPD->hDevNames != NULL) {
GlobalFree( pPD->hDevNames );
}
return hResult;
}
In Python, it's called into like so:
client = ctypes.cdll.LoadLibrary(os.path.join(myDir, 'rpmclient.dll'))
client.printer_setup.argtypes = [ctypes.c_void_p,
ctypes.c_wchar_p,
ctypes.c_char_p,
ctypes.c_int32,
ctypes.POINTER(ctypes.c_wchar_p),
ctypes.POINTER(ctypes.c_char_p)]
client.printer_setup.restype = ctypes.c_int32
client.CleanupA.argtypes = [ctypes.c_char_p]
client.CleanupA.restype = ctypes.c_int32
client.CleanupW.argtypes = [ctypes.c_wchar_p]
client.CleanupW.restype = ctypes.c_int32
p_in = ctypes.c_wchar_p(self.itemMap['device'].GetValue())
p_out = ctypes.c_wchar_p()
d_in = ctypes.c_char_p(getattr(self, 'devmode', ''))
d_out = ctypes.c_char_p()
res = client.printer_setup(self.GetHandle(),
p_in,
d_in,
False,
p_out,
d_out)
if res == 0:
return
if res > 1:
# Error display code here.
return
self.devmode = d_out.value