|
From: Roger U. <ru...@us...> - 2008-02-06 18:37:46
|
Update of /cvsroot/pywin32/pywin32/win32/src In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6719 Modified Files: PyDEVMODE.cpp PyUnicode.cpp PyWinObjects.h PyWinTypes.h PyWinTypesmodule.cpp Log Message: Changes for unicode build Index: PyWinObjects.h =================================================================== RCS file: /cvsroot/pywin32/pywin32/win32/src/PyWinObjects.h,v retrieving revision 1.12 retrieving revision 1.13 diff -C2 -d -r1.12 -r1.13 *** PyWinObjects.h 24 May 2007 06:01:05 -0000 1.12 --- PyWinObjects.h 6 Feb 2008 18:37:46 -0000 1.13 *************** *** 255,256 **** --- 255,290 ---- ~PyDEVMODE(); }; + + // Unicode version of DEVMODE + class PYWINTYPES_EXPORT PyDEVMODEW : public PyObject + { + public: + #ifdef _MSC_VER + #pragma warning( disable : 4251 ) + #endif // _MSC_VER + static struct PyMemberDef members[]; + static struct PyMethodDef methods[]; + #ifdef _MSC_VER + #pragma warning( default : 4251 ) + #endif // _MSC_VER + + static void deallocFunc(PyObject *ob); + PyDEVMODEW(PDEVMODEW); + PyDEVMODEW(void); + PyDEVMODEW(USHORT); + static PyObject *getattro(PyObject *self, PyObject *name); + static int setattro(PyObject *self, PyObject *obname, PyObject *obvalue); + static PyObject *Clear(PyObject *self, PyObject *args); + static PyObject *tp_new(PyTypeObject *, PyObject *, PyObject *); + // use this where a function modifies a passed-in PyDEVMODE to make changes visible to Python + void modify_in_place(void) + {memcpy(&devmode, pdevmode, pdevmode->dmSize);} + PDEVMODEW GetDEVMODE(void); + PyObject *obdummy; + protected: + // Pointer to variable length DEVMODE with dmDriverExtra bytes allocated at end, always use this externally + PDEVMODEW pdevmode; + // copy of fixed portion of DEVMODE for structmember api to access + DEVMODEW devmode; + ~PyDEVMODEW(); + }; Index: PyDEVMODE.cpp =================================================================== RCS file: /cvsroot/pywin32/pywin32/win32/src/PyDEVMODE.cpp,v retrieving revision 1.6 retrieving revision 1.7 diff -C2 -d -r1.6 -r1.7 *** PyDEVMODE.cpp 24 May 2007 06:01:05 -0000 1.6 --- PyDEVMODE.cpp 6 Feb 2008 18:37:46 -0000 1.7 *************** *** 68,72 **** {"Collate", T_SHORT, OFF(devmode.dmCollate), 0, "DMCOLLATE_TRUE or DMCOLLATE_FALSE"}, // @prop str|FormName|Name of form as returned by <om win32print.EnumForms>, at most 32 chars ! {"FormName", T_OBJECT, OFF(obdummy), 0, "Name of form as returned by EnumForms, at most 32 chars"}, // same semantics as DeviceName // @prop int|LogPixels|Pixels per inch (only for display devices {"LogPixels", T_USHORT, OFF(devmode.dmLogPixels), 0, "Pixels per inch (only for display devices)"}, --- 68,72 ---- {"Collate", T_SHORT, OFF(devmode.dmCollate), 0, "DMCOLLATE_TRUE or DMCOLLATE_FALSE"}, // @prop str|FormName|Name of form as returned by <om win32print.EnumForms>, at most 32 chars ! {"FormName", T_OBJECT, OFF(obdummy), 0, "Name of form as returned by EnumForms, at most 32 chars"}, // @prop int|LogPixels|Pixels per inch (only for display devices {"LogPixels", T_USHORT, OFF(devmode.dmLogPixels), 0, "Pixels per inch (only for display devices)"}, *************** *** 162,166 **** PyErr_Format(PyExc_MemoryError, "PyDEVMODE::PyDEVMODE - Unable to allocate DEVMODE of size %d", pdm->dmSize + pdm->dmDriverExtra); ! else; memcpy(pdevmode, pdm, pdm->dmSize + pdm->dmDriverExtra); obdummy=NULL; --- 162,166 ---- PyErr_Format(PyExc_MemoryError, "PyDEVMODE::PyDEVMODE - Unable to allocate DEVMODE of size %d", pdm->dmSize + pdm->dmDriverExtra); ! else memcpy(pdevmode, pdm, pdm->dmSize + pdm->dmDriverExtra); obdummy=NULL; *************** *** 381,382 **** --- 381,771 ---- return ret; } + + + // DEVMODEW support + // @object PyDEVMODEW|Unicode version of <o PyDEVMODE> object + /* PyDEVMODEW is only needed when win32api, win32gui, or win32print + are built with UNICODE defined. Currently, you must explicitely ask + for the unicode version. + */ + + struct PyMethodDef PyDEVMODEW::methods[] = { + {"Clear", PyDEVMODEW::Clear, 1}, // @pymeth Clear|Resets all members of the structure + {NULL} + }; + + #define OFFW(e) offsetof(PyDEVMODEW, e) + struct PyMemberDef PyDEVMODEW::members[] = { + // DeviceName is a dummy so it will show up in property list, get and set handle manually + // @prop <o PyUnicode>|DeviceName|String of at most 32 chars + {"DeviceName", T_OBJECT, OFFW(obdummy), 0, "String of at most 32 chars"}, + // @prop int|SpecVersion|Should always be set to DM_SPECVERSION + {"SpecVersion", T_USHORT, OFFW(devmode.dmSpecVersion), 0, "Should always be set to DM_SPECVERSION"}, + // @prop int|DriverVersion|Version nbr assigned to printer driver by vendor + {"DriverVersion", T_USHORT, OFFW(devmode.dmDriverVersion), 0, "Version nbr assigned to printer driver by vendor"}, + // @prop int|Size|Size of structure + {"Size", T_USHORT, OFFW(devmode.dmSize), READONLY, "Size of structure"}, + // @prop int|DriverExtra|Number of extra bytes allocated for driver data, can only be set when new object is created + {"DriverExtra", T_USHORT, OFFW(devmode.dmDriverExtra), READONLY, + "Number of extra bytes allocated for driver data, can only be set when new object is created"}, + // @prop int|Fields|Bitmask of win32con.DM_* constants indicating which members are set + {"Fields", T_ULONG, OFFW(devmode.dmFields), 0, "Bitmask of win32con.DM_* constants indicating which members are set"}, + // @prop int|Orientation|Only applies to printers, DMORIENT_PORTRAIT or DMORIENT_LANDSCAPE + {"Orientation", T_SHORT, OFFW(devmode.dmOrientation), 0, "Only applies to printers, DMORIENT_PORTRAIT or DMORIENT_LANDSCAPE"}, + // @prop int|PaperSize|Use 0 if PaperWidth and PaperLength are set, otherwise win32con.DMPAPER_* constant + {"PaperSize", T_SHORT, OFFW(devmode.dmPaperSize), 0, "Use 0 if PaperWidth and PaperLength are set, otherwise win32con.DMPAPER_* constant"}, + // @prop int|PaperLength|Specified in 1/10 millimeters + {"PaperLength", T_SHORT, OFFW(devmode.dmPaperLength), 0, "Specified in 1/10 millimeters"}, + // @prop int|PaperWidth|Specified in 1/10 millimeters + {"PaperWidth", T_SHORT, OFFW(devmode.dmPaperWidth), 0, "Specified in 1/10 millimeters"}, + #ifndef MS_WINCE + // @prop int|Position_x|Position of display relative to desktop + {"Position_x", T_LONG, OFFW(devmode.dmPosition.x), 0, "Position of display relative to desktop"}, + // @prop int|Position_y|Position of display relative to desktop + {"Position_y", T_LONG, OFFW(devmode.dmPosition.y), 0, "Position of display relative to desktop"}, + #endif + // @prop int|DisplayOrientation|Display rotation: DMDO_DEFAULT,DMDO_90, DMDO_180, DMDO_270 + {"DisplayOrientation",T_ULONG,OFFW(devmode.dmDisplayOrientation), 0, "Display rotation: DMDO_DEFAULT,DMDO_90, DMDO_180, DMDO_270"}, + // @prop int|DisplayFixedOutput|DMDFO_DEFAULT, DMDFO_CENTER, DMDFO_STRETCH + {"DisplayFixedOutput",T_ULONG,OFFW(devmode.dmDisplayFixedOutput), 0, "DMDFO_DEFAULT, DMDFO_CENTER, DMDFO_STRETCH"}, + // @prop int|Scale|Specified as percentage, eg 50 means half size of original + {"Scale", T_SHORT, OFFW(devmode.dmScale), 0, "Specified as percentage, eg 50 means half size of original"}, + // @prop int|Copies|Nbr of copies to print + {"Copies", T_SHORT, OFFW(devmode.dmCopies), 0, "Nbr of copies to print"}, + // @prop int|DefaultSource|DMBIN_* constant, or can be a printer-specific value + {"DefaultSource", T_SHORT, OFFW(devmode.dmDefaultSource), 0, "DMBIN_* constant, or can be a printer-specific value"}, + // @prop int|PrintQuality|DMRES_* constant, interpreted as DPI if positive + {"PrintQuality", T_SHORT, OFFW(devmode.dmPrintQuality), 0, "DMRES_* constant, interpreted as DPI if positive"}, + // @prop int|Color|DMCOLOR_COLOR or DMCOLOR_MONOCHROME + {"Color", T_SHORT, OFFW(devmode.dmColor), 0, "DMCOLOR_COLOR or DMCOLOR_MONOCHROME"}, + // @prop int|Duplex|For printers that do two-sided printing: DMDUP_SIMPLEX, DMDUP_HORIZONTAL, DMDUP_VERTICAL + {"Duplex", T_SHORT, OFFW(devmode.dmDuplex), 0, "For printers that do two-sided printing: DMDUP_SIMPLEX, DMDUP_HORIZONTAL, DMDUP_VERTICAL"}, + // @prop int|YResolution|Vertical printer resolution in DPI - if this is set, PrintQuality indicates horizontal DPI + {"YResolution", T_SHORT, OFFW(devmode.dmYResolution), 0, "Vertical printer resolution in DPI - if this is set, PrintQuality indicates horizontal DPI"}, + // @prop int|TTOption|TrueType options: DMTT_BITMAP, DMTT_DOWNLOAD, DMTT_DOWNLOAD_OUTLINE, DMTT_SUBDEV + {"TTOption", T_SHORT, OFFW(devmode.dmTTOption), 0, "TrueType options: DMTT_BITMAP, DMTT_DOWNLOAD, DMTT_DOWNLOAD_OUTLINE, DMTT_SUBDEV"}, + // @prop int|Collate|DMCOLLATE_TRUE or DMCOLLATE_FALSE + {"Collate", T_SHORT, OFFW(devmode.dmCollate), 0, "DMCOLLATE_TRUE or DMCOLLATE_FALSE"}, + // @prop <o PyUnicode>|FormName|Name of form as returned by <om win32print.EnumForms>, at most 32 chars + {"FormName", T_OBJECT, OFFW(obdummy), 0, "Name of form as returned by EnumForms, at most 32 chars"}, + // @prop int|LogPixels|Pixels per inch (only for display devices + {"LogPixels", T_USHORT, OFFW(devmode.dmLogPixels), 0, "Pixels per inch (only for display devices)"}, + // @prop int|BitsPerPel|Color resolution in bits per pixel + {"BitsPerPel", T_ULONG, OFFW(devmode.dmBitsPerPel), 0, "Color resolution in bits per pixel"}, + // @prop int|PelsWidth|Pixel width of display + {"PelsWidth", T_ULONG, OFFW(devmode.dmPelsWidth), 0, "Pixel width of display"}, + // @prop int|PelsHeight|Pixel height of display + {"PelsHeight", T_ULONG, OFFW(devmode.dmPelsHeight), 0, "Pixel height of display"}, + // @prop int|DisplayFlags|Combination of DM_GRAYSCALE and DM_INTERLACED + {"DisplayFlags", T_ULONG, OFFW(devmode.dmDisplayFlags), 0, "Combination of DM_GRAYSCALE and DM_INTERLACED"}, + // @prop int|DisplayFrequency|Refresh rate + {"DisplayFrequency",T_ULONG, OFFW(devmode.dmDisplayFrequency), 0, "Refresh rate"}, + #ifdef MS_WINCE + // @prop int|DisplayOrientation|Display rotation: DMDO_DEFAULT,DMDO_90, DMDO_180, DMDO_270 + {"DisplayOrientation",T_ULONG,OFFW(devmode.dmDisplayOrientation), 0, "Display rotation: DMDO_DEFAULT,DMDO_90, DMDO_180, DMDO_270"}, + #else + // @prop int|ICMMethod|Indicates where ICM is performed, one of win32con.DMICMMETHOD_* values + {"ICMMethod", T_ULONG, OFFW(devmode.dmICMMethod), 0, "Indicates where ICM is performed, one of win32con.DMICMMETHOD_* values"}, + // @prop int|ICMIntent|Intent of ICM, one of win32con.DMICM_* values + {"ICMIntent", T_ULONG, OFFW(devmode.dmICMIntent), 0, "Intent of ICM, one of win32con.DMICM_* values"}, + // @prop int|MediaType|win32con.DMMEDIA_*, can also be a printer-specific value greater then DMMEDIA_USER + {"MediaType", T_ULONG, OFFW(devmode.dmMediaType), 0, "win32con.DMMEDIA_*, can also be a printer-specific value greater then DMMEDIA_USER"}, + // @prop int|DitherType|Dithering option, win32con.DMDITHER_* + {"DitherType", T_ULONG, OFFW(devmode.dmDitherType), 0, "Dithering options, win32con.DMDITHER_*"}, + // @prop int|Reserved1|Reserved, use only 0 + {"Reserved1", T_ULONG, OFFW(devmode.dmReserved1), 0, "Reserved, use only 0"}, + // @prop int|Reserved2|Reserved, use only 0 + {"Reserved2", T_ULONG, OFFW(devmode.dmReserved2), 0, "Reserved, use only 0"}, + // @prop str|DriverData|Driver data appended to end of structure + {"DriverData", T_OBJECT, OFFW(obdummy), 0, "Driver data appended to end of structure"}, + #if WINVER >= 0x0500 + // @prop int|Nup|Controls printing of multiple logical pages per physical page, DMNUP_SYSTEM or DMNUP_ONEUP + {"Nup", T_ULONG, OFFW(devmode.dmNup), 0, "Controls printing of multiple logical pages per physical page, DMNUP_SYSTEM or DMNUP_ONEUP"}, + // @prop int|PanningWidth|Not used, leave as 0 + {"PanningWidth", T_ULONG, OFFW(devmode.dmPanningWidth), 0, "Not used, leave as 0"}, + // @prop int|PanningHeight|Not used, leave as 0 + {"PanningHeight", T_ULONG, OFFW(devmode.dmPanningHeight), 0, "Not used, leave as 0"}, + #endif // WINVER >= 0x0500 + #endif // !MS_WINCE + {NULL} + }; + + PYWINTYPES_EXPORT PyTypeObject PyDEVMODEWType = + { + PyObject_HEAD_INIT(&PyType_Type) + 0, + "PyDEVMODEW", + sizeof(PyDEVMODEW), + 0, + PyDEVMODEW::deallocFunc, + 0, // tp_print; + 0, // tp_getattr + 0, // tp_setattr + 0, // tp_compare + 0, // tp_repr + 0, // tp_as_number + 0, // tp_as_sequence + 0, // tp_as_mapping + 0, + 0, /* tp_call */ + 0, /* tp_str */ + PyDEVMODEW::getattro, // PyObject_GenericGetAttr + PyDEVMODEW::setattro, // PyObject_GenericSetAttr + 0, // tp_as_buffer; + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags; + 0, // tp_doc; /* Documentation string */ + 0, // traverseproc tp_traverse; + 0, // tp_clear; + 0, // tp_richcompare; + 0, // tp_weaklistoffset; + 0, // tp_iter + 0, // iternextfunc tp_iternext + PyDEVMODEW::methods, + PyDEVMODEW::members, + 0, // tp_getset; + 0, // tp_base; + 0, // tp_dict; + 0, // tp_descr_get; + 0, // tp_descr_set; + 0, // tp_dictoffset; + 0, // tp_init; + 0, // tp_alloc; + PyDEVMODEW::tp_new // newfunc tp_new; + }; + + PyDEVMODEW::PyDEVMODEW(PDEVMODEW pdm) + { + ob_type = &PyDEVMODEWType; + memcpy(&devmode, pdm, pdm->dmSize); + pdevmode=(PDEVMODEW)malloc(pdm->dmSize + pdm->dmDriverExtra); + if (pdevmode==NULL) + PyErr_Format(PyExc_MemoryError, "PyDEVMODE::PyDEVMODE - Unable to allocate DEVMODE of size %d", + pdm->dmSize + pdm->dmDriverExtra); + else + memcpy(pdevmode, pdm, pdm->dmSize + pdm->dmDriverExtra); + obdummy=NULL; + _Py_NewReference(this); + } + + PyDEVMODEW::PyDEVMODEW(void) + { + ob_type = &PyDEVMODEWType; + static WORD dmSize=sizeof(DEVMODEW); + pdevmode=(PDEVMODEW)malloc(dmSize); + ZeroMemory(pdevmode,dmSize); + pdevmode->dmSize=dmSize; + pdevmode->dmSpecVersion=DM_SPECVERSION; + ZeroMemory(&devmode,dmSize); + devmode.dmSize=dmSize; + devmode.dmSpecVersion=DM_SPECVERSION; + obdummy=NULL; + _Py_NewReference(this); + } + + PyDEVMODEW::PyDEVMODEW(USHORT dmDriverExtra) + { + ob_type = &PyDEVMODEWType; + static WORD dmSize=sizeof(DEVMODEW); + pdevmode=(PDEVMODEW)malloc(dmSize+dmDriverExtra); + ZeroMemory(pdevmode,dmSize+dmDriverExtra); + pdevmode->dmSize=dmSize; + pdevmode->dmSpecVersion=DM_SPECVERSION; + pdevmode->dmDriverExtra=dmDriverExtra; + ZeroMemory(&devmode,dmSize); + devmode.dmSize=dmSize; + devmode.dmSpecVersion=DM_SPECVERSION; + devmode.dmDriverExtra=dmDriverExtra; + obdummy=NULL; + _Py_NewReference(this); + } + + PyDEVMODEW::~PyDEVMODEW() + { + if (pdevmode!=NULL) + free(pdevmode); + } + + BOOL PyDEVMODEW_Check(PyObject *ob) + { + if (ob->ob_type!=&PyDEVMODEWType){ + PyErr_SetString(PyExc_TypeError,"Object must be a PyDEVMODEW"); + return FALSE; + } + return TRUE; + } + + void PyDEVMODEW::deallocFunc(PyObject *ob) + { + delete (PyDEVMODEW *)ob; + } + + PDEVMODEW PyDEVMODEW::GetDEVMODE(void) + { + return pdevmode; + } + + // @pymethod |PyDEVMODE|Clear|Resets all members of the structure + PyObject *PyDEVMODEW::Clear(PyObject *self, PyObject *args) + { + PDEVMODEW pdevmode=((PyDEVMODEW *)self)->pdevmode; + USHORT dmDriverExtra=pdevmode->dmDriverExtra; + WORD dmSize=pdevmode->dmSize; + DWORD totalsize=dmSize + dmDriverExtra; + ZeroMemory(pdevmode, totalsize); + pdevmode->dmDriverExtra=dmDriverExtra; + pdevmode->dmSize=dmSize; + pdevmode->dmSpecVersion=DM_SPECVERSION; + + pdevmode=&((PyDEVMODEW *)self)->devmode; + ZeroMemory(pdevmode, dmSize); + pdevmode->dmDriverExtra=dmDriverExtra; + pdevmode->dmSize=dmSize; + pdevmode->dmSpecVersion=DM_SPECVERSION; + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *PyDEVMODEW::getattro(PyObject *self, PyObject *obname) + { + PDEVMODEW pdevmode=((PyDEVMODEW *)self)->pdevmode; + char *name=PyString_AsString(obname); + if (name==NULL) + return NULL; + if (strcmp(name,"DeviceName")==0) + if (pdevmode->dmDeviceName[CCHDEVICENAME-1]==0) // in case DeviceName fills space and has no trailing NULL + return PyWinObject_FromWCHAR(pdevmode->dmDeviceName); + else + return PyWinObject_FromWCHAR(pdevmode->dmDeviceName, CCHDEVICENAME); + + if (strcmp(name,"FormName")==0) + if (pdevmode->dmFormName[CCHFORMNAME-1]==0) // If dmFormName occupies whole 32 chars, trailing NULL not present + return PyWinObject_FromWCHAR(pdevmode->dmFormName); + else + return PyWinObject_FromWCHAR(pdevmode->dmFormName, CCHFORMNAME); + + if (strcmp(name,"DriverData")==0) + if (pdevmode->dmDriverExtra==0){ // No extra space allocated + Py_INCREF(Py_None); + return Py_None; + } + else + return PyString_FromStringAndSize((char *)((ULONG_PTR)pdevmode + pdevmode->dmSize), pdevmode->dmDriverExtra); + + return PyObject_GenericGetAttr(self,obname); + } + + int PyDEVMODEW::setattro(PyObject *self, PyObject *obname, PyObject *obvalue) + { + char *name; + name=PyString_AsString(obname); + if (name==NULL) + return -1; + if (strcmp(name,"DeviceName")==0){ + WCHAR *devicename; + DWORD cch; + if (!PyWinObject_AsWCHAR(obvalue, &devicename, FALSE, &cch)) + return -1; + if (cch > CCHDEVICENAME){ + PyErr_Format(PyExc_ValueError,"DeviceName must be a string of length %d or less", CCHDEVICENAME); + PyWinObject_FreeWCHAR(devicename); + return -1; + } + PDEVMODEW pdevmode=&((PyDEVMODEW *)self)->devmode; + ZeroMemory(&pdevmode->dmDeviceName, sizeof(pdevmode->dmDeviceName)); + memcpy(&pdevmode->dmDeviceName, devicename, cch * sizeof(WCHAR)); + // update variable length DEVMODE with same value + memcpy(((PyDEVMODEW *)self)->pdevmode, pdevmode, pdevmode->dmSize); + PyWinObject_FreeWCHAR(devicename); + return 0; + } + + if (strcmp(name,"FormName")==0){ + WCHAR *formname; + DWORD cch; + if (!PyWinObject_AsWCHAR(obvalue, &formname, FALSE, &cch)) + return -1; + if (cch > CCHFORMNAME){ + PyErr_Format(PyExc_ValueError,"FormName must be a string of length %d or less", CCHFORMNAME); + PyWinObject_FreeWCHAR(formname); + return -1; + } + PDEVMODEW pdevmode=&((PyDEVMODEW *)self)->devmode; + ZeroMemory(&pdevmode->dmFormName, sizeof(pdevmode->dmFormName)); + memcpy(&pdevmode->dmFormName, formname, cch * sizeof(WCHAR)); + // update variable length PDEVMODE with same value + memcpy(((PyDEVMODEW *)self)->pdevmode, pdevmode, pdevmode->dmSize); + PyWinObject_FreeWCHAR(formname); + return 0; + } + + if (strcmp(name,"DriverData")==0){ + char *value; + Py_ssize_t valuelen; + if (PyString_AsStringAndSize(obvalue, &value, &valuelen)==-1) + return -1; + PDEVMODEW pdevmode=((PyDEVMODEW *)self)->pdevmode; + if (valuelen > pdevmode->dmDriverExtra){ + PyErr_Format(PyExc_ValueError,"Length of DriverData cannot be longer that DriverExtra (%d bytes)", pdevmode->dmDriverExtra); + return -1; + } + // This is not a real struct member, calculate address after end of fixed part of structure + char *driverdata=(char *)((ULONG_PTR)pdevmode + pdevmode->dmSize); + ZeroMemory(driverdata, pdevmode->dmDriverExtra); + memcpy(driverdata, value, valuelen); + return 0; + } + + int ret=PyObject_GenericSetAttr(self, obname, obvalue); + // Propagate changes to the externally usable structure + if (ret==0) + memcpy(((PyDEVMODEW *)self)->pdevmode, &((PyDEVMODEW *)self)->devmode, ((PyDEVMODEW *)self)->devmode.dmSize); + return ret; + } + + PyObject *PyDEVMODEW::tp_new(PyTypeObject *typ, PyObject *args, PyObject *kwargs) + { + USHORT DriverExtra=0; + static char *keywords[]={"DriverExtra", NULL}; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|H", keywords, &DriverExtra)) + return NULL; + return new PyDEVMODEW(DriverExtra); + } + + BOOL PyWinObject_AsDEVMODE(PyObject *ob, PDEVMODEW *ppDEVMODE, BOOL bNoneOk) + { + if (ob==Py_None) + if (bNoneOk){ + *ppDEVMODE=NULL; + return TRUE; + } + else{ + PyErr_SetString(PyExc_ValueError,"PyDEVMODE cannot be None in this context"); + return FALSE; + } + if (!PyDEVMODEW_Check(ob)) + return FALSE; + *ppDEVMODE=((PyDEVMODEW *)ob)->GetDEVMODE(); + return TRUE; + } + + PyObject *PyWinObject_FromDEVMODE(PDEVMODEW pDEVMODE) + { + static WORD dmSize=sizeof(DEVMODEW); + if (pDEVMODE==NULL){ + Py_INCREF(Py_None); + return Py_None; + } + + // make sure we can't overflow the fixed size DEVMODE in PyDEVMODE + if (pDEVMODE->dmSize>dmSize){ + PyErr_Format(PyExc_WindowsError,"DEVMODE structure of size %d greater than supported size of %d", pDEVMODE->dmSize, dmSize); + return NULL; + } + PyObject *ret=new PyDEVMODEW(pDEVMODE); + // check that variable sized pdevmode is allocated + if (((PyDEVMODEW *)ret)->GetDEVMODE()==NULL){ + Py_DECREF(ret); + ret=NULL; + } + return ret; + } Index: PyWinTypesmodule.cpp =================================================================== RCS file: /cvsroot/pywin32/pywin32/win32/src/PyWinTypesmodule.cpp,v retrieving revision 1.36 retrieving revision 1.37 diff -C2 -d -r1.36 -r1.37 *** PyWinTypesmodule.cpp 30 Oct 2007 09:53:32 -0000 1.36 --- PyWinTypesmodule.cpp 6 Feb 2008 18:37:46 -0000 1.37 *************** *** 919,922 **** --- 919,923 ---- PyDict_SetItemString(dict, "OVERLAPPEDType", (PyObject *)&PyOVERLAPPEDType); PyDict_SetItemString(dict, "DEVMODEType", (PyObject *)&PyDEVMODEType); + PyDict_SetItemString(dict, "DEVMODEWType", (PyObject *)&PyDEVMODEWType); PyDict_SetItemString(dict, "WAVEFORMATEXType", (PyObject *)&PyWAVEFORMATEXType); Index: PyWinTypes.h =================================================================== RCS file: /cvsroot/pywin32/pywin32/win32/src/PyWinTypes.h,v retrieving revision 1.49 retrieving revision 1.50 diff -C2 -d -r1.49 -r1.50 *** PyWinTypes.h 12 Oct 2007 00:35:09 -0000 1.49 --- PyWinTypes.h 6 Feb 2008 18:37:46 -0000 1.50 *************** *** 216,221 **** #define PyWinObject_AsTCHAR PyWinObject_AsString #define PyWinObject_FreeTCHAR PyWinObject_FreeString ! inline PyObject *PyWinObject_FromTCHAR( TCHAR *str ) {return PyString_FromString(str);} ! inline PyObject *PyWinObject_FromTCHAR( TCHAR *str, int numChars ) {return PyString_FromStringAndSize(str, numChars);} #define PyString_FromTCHAR PyString_FromString #endif --- 216,235 ---- #define PyWinObject_AsTCHAR PyWinObject_AsString #define PyWinObject_FreeTCHAR PyWinObject_FreeString ! inline PyObject *PyWinObject_FromTCHAR( TCHAR *str ) ! { ! if (str==NULL){ ! Py_INCREF(Py_None); ! return Py_None; ! } ! return PyString_FromString(str); ! } ! inline PyObject *PyWinObject_FromTCHAR( TCHAR *str, int numChars ) ! { ! if (str==NULL){ ! Py_INCREF(Py_None); ! return Py_None; ! } ! return PyString_FromStringAndSize(str, numChars); ! } #define PyString_FromTCHAR PyString_FromString #endif *************** *** 228,238 **** // Converts a sequence of str/unicode objects into a series of consecutive null-terminated // wide character strings with extra terminating null ! PYWINTYPES_EXPORT BOOL PyWinObject_AsMultipleString(PyObject *ob, WCHAR **pmultistring, BOOL bNoneOK=TRUE); PYWINTYPES_EXPORT void PyWinObject_FreeMultipleString(WCHAR *pmultistring); // Convert a sequence of strings to an array of WCHAR pointers PYWINTYPES_EXPORT void PyWinObject_FreeWCHARArray(LPWSTR *wchars, DWORD str_cnt); PYWINTYPES_EXPORT BOOL PyWinObject_AsWCHARArray(PyObject *str_seq, LPWSTR **wchars, DWORD *str_cnt, BOOL bNoneOK = FALSE); PYWINTYPES_EXPORT PyObject *PyString_FromUnicode( const OLECHAR *str ); PYWINTYPES_EXPORT PyObject *PyUnicodeObject_FromString(const char *string); --- 242,261 ---- // Converts a sequence of str/unicode objects into a series of consecutive null-terminated // wide character strings with extra terminating null ! PYWINTYPES_EXPORT BOOL PyWinObject_AsMultipleString(PyObject *ob, WCHAR **pmultistring, BOOL bNoneOK=TRUE, DWORD *chars_returned=NULL); PYWINTYPES_EXPORT void PyWinObject_FreeMultipleString(WCHAR *pmultistring); + // Converts a sequence of str/unicode objects into a series of consecutive character strings + // terminated by double null + PYWINTYPES_EXPORT BOOL PyWinObject_AsMultipleString(PyObject *ob, char **pmultistring, BOOL bNoneOK=TRUE, DWORD *chars_returned=NULL); + PYWINTYPES_EXPORT void PyWinObject_FreeMultipleString(char *pmultistring); + // Convert a sequence of strings to an array of WCHAR pointers PYWINTYPES_EXPORT void PyWinObject_FreeWCHARArray(LPWSTR *wchars, DWORD str_cnt); PYWINTYPES_EXPORT BOOL PyWinObject_AsWCHARArray(PyObject *str_seq, LPWSTR **wchars, DWORD *str_cnt, BOOL bNoneOK = FALSE); + // Convert a sequence of string or unicode objects to an array of char * + PYWINTYPES_EXPORT void PyWinObject_FreeCharArray(char **pchars, DWORD str_cnt); + PYWINTYPES_EXPORT BOOL PyWinObject_AsCharArray(PyObject *str_seq, char ***pchars, DWORD *str_cnt, BOOL bNoneOK = FALSE); + PYWINTYPES_EXPORT PyObject *PyString_FromUnicode( const OLECHAR *str ); PYWINTYPES_EXPORT PyObject *PyUnicodeObject_FromString(const char *string); *************** *** 454,463 **** #define PySECURITY_ATTRIBUTES_Check(ob) ((ob)->ob_type == &PySECURITY_ATTRIBUTESType) extern PYWINTYPES_EXPORT PyTypeObject PyDEVMODEType; PYWINTYPES_EXPORT PyObject *PyWinMethod_NewSECURITY_ATTRIBUTES(PyObject *self, PyObject *args); PYWINTYPES_EXPORT BOOL PyWinObject_AsSECURITY_ATTRIBUTES(PyObject *ob, SECURITY_ATTRIBUTES **ppSECURITY_ATTRIBUTES, BOOL bNoneOK = TRUE); PYWINTYPES_EXPORT PyObject *PyWinObject_FromSECURITY_ATTRIBUTES(const SECURITY_ATTRIBUTES &sa); ! PYWINTYPES_EXPORT BOOL PyWinObject_AsDEVMODE(PyObject *ob, PDEVMODE * ppDEVMODE, BOOL bNoneOK = TRUE); ! PYWINTYPES_EXPORT PyObject *PyWinObject_FromDEVMODE(PDEVMODE); /* --- 477,489 ---- #define PySECURITY_ATTRIBUTES_Check(ob) ((ob)->ob_type == &PySECURITY_ATTRIBUTESType) extern PYWINTYPES_EXPORT PyTypeObject PyDEVMODEType; + extern PYWINTYPES_EXPORT PyTypeObject PyDEVMODEWType; PYWINTYPES_EXPORT PyObject *PyWinMethod_NewSECURITY_ATTRIBUTES(PyObject *self, PyObject *args); PYWINTYPES_EXPORT BOOL PyWinObject_AsSECURITY_ATTRIBUTES(PyObject *ob, SECURITY_ATTRIBUTES **ppSECURITY_ATTRIBUTES, BOOL bNoneOK = TRUE); PYWINTYPES_EXPORT PyObject *PyWinObject_FromSECURITY_ATTRIBUTES(const SECURITY_ATTRIBUTES &sa); ! PYWINTYPES_EXPORT BOOL PyWinObject_AsDEVMODE(PyObject *ob, PDEVMODEA * ppDEVMODE, BOOL bNoneOK = TRUE); ! PYWINTYPES_EXPORT BOOL PyWinObject_AsDEVMODE(PyObject *ob, PDEVMODEW * ppDEVMODE, BOOL bNoneOK); ! PYWINTYPES_EXPORT PyObject *PyWinObject_FromDEVMODE(PDEVMODEA); ! PYWINTYPES_EXPORT PyObject *PyWinObject_FromDEVMODE(PDEVMODEW); /* Index: PyUnicode.cpp =================================================================== RCS file: /cvsroot/pywin32/pywin32/win32/src/PyUnicode.cpp,v retrieving revision 1.25 retrieving revision 1.26 diff -C2 -d -r1.25 -r1.26 *** PyUnicode.cpp 12 Aug 2007 08:10:28 -0000 1.25 --- PyUnicode.cpp 6 Feb 2008 18:37:46 -0000 1.26 *************** *** 1092,1096 **** // Converts a sequence of str/unicode objects into a series of consecutive null-terminated // wide character strings with extra terminating null ! BOOL PyWinObject_AsMultipleString(PyObject *ob, WCHAR **pmultistring, BOOL bNoneOK) { DWORD numStrings, i; --- 1092,1138 ---- // Converts a sequence of str/unicode objects into a series of consecutive null-terminated // wide character strings with extra terminating null ! BOOL PyWinObject_AsMultipleString(PyObject *ob, char **pmultistring, BOOL bNoneOK, DWORD *chars_returned) ! { ! DWORD numStrings, i; ! char **pchars; ! BOOL rc=FALSE; ! ! *pmultistring=NULL; ! if (chars_returned) ! *chars_returned=0; ! if (!PyWinObject_AsCharArray(ob, &pchars, &numStrings, bNoneOK)) ! return FALSE; ! // Shortcut for None ! if (pchars==NULL) ! return TRUE; ! ! size_t len=numStrings+1; // One null for each string plus extra terminating null ! // Need to loop twice - once to get the buffer length ! for (i=0;i<numStrings;i++) ! len += strlen(pchars[i]); ! ! // Allocate the buffer ! *pmultistring = (char *)malloc(len * sizeof(char)); ! if (*pmultistring == NULL) ! PyErr_NoMemory(); ! else{ ! char *p = *pmultistring; ! for (i=0;i<numStrings;i++) { ! strcpy(p, pchars[i]); ! p += strlen(pchars[i]); ! *p++ = '\0'; ! } ! *p = '\0'; // Add second terminator. ! rc = TRUE; ! if (chars_returned) ! *chars_returned=len; ! } ! PyWinObject_FreeCharArray(pchars, numStrings); ! return rc; ! } ! ! // Converts a sequence of str/unicode objects into a series of consecutive null-terminated ! // char strings with extra terminating null ! BOOL PyWinObject_AsMultipleString(PyObject *ob, WCHAR **pmultistring, BOOL bNoneOK, DWORD *chars_returned) { DWORD numStrings, i; *************** *** 1099,1102 **** --- 1141,1146 ---- *pmultistring=NULL; + if (chars_returned) + *chars_returned=0; if (!PyWinObject_AsWCHARArray(ob, &wchars, &numStrings, bNoneOK)) return FALSE; *************** *** 1123,1126 **** --- 1167,1172 ---- *p = L'\0'; // Add second terminator. rc = TRUE; + if (chars_returned) + *chars_returned=len; } PyWinObject_FreeWCHARArray(wchars, numStrings); *************** *** 1134,1137 **** --- 1180,1189 ---- } + void PyWinObject_FreeMultipleString(char *pmultistring) + { + if (pmultistring) + free (pmultistring); + } + // Converts a aequence of string or unicode objects into an array of WCHAR void PyWinObject_FreeWCHARArray(LPWSTR *wchars, DWORD str_cnt) *************** *** 1177,1178 **** --- 1229,1274 ---- return ret; } + + // Converts a aequence of string or unicode objects into an array of char pointers + void PyWinObject_FreeCharArray(char **pchars, DWORD str_cnt) + { + if (pchars!=NULL){ + for (DWORD pchar_index=0; pchar_index<str_cnt; pchar_index++) + PyWinObject_FreeString(pchars[pchar_index]); + free(pchars); + } + } + + BOOL PyWinObject_AsCharArray(PyObject *str_seq, char ***pchars, DWORD *str_cnt, BOOL bNoneOK) + { + BOOL ret=FALSE; + PyObject *str_tuple=NULL, *tuple_item; + DWORD bufsize, tuple_index; + *pchars=NULL; + *str_cnt=0; + + if (bNoneOK && str_seq==Py_None) + return TRUE; + if ((str_tuple=PyWinSequence_Tuple(str_seq, str_cnt))==NULL) + return FALSE; + bufsize=*str_cnt * sizeof(char *); + *pchars=(char **)malloc(bufsize); + if (*pchars==NULL){ + PyErr_Format(PyExc_MemoryError, "Unable to allocate %d bytes", bufsize); + goto done; + } + ZeroMemory(*pchars, bufsize); + for (tuple_index=0;tuple_index<*str_cnt;tuple_index++){ + tuple_item=PyTuple_GET_ITEM(str_tuple, tuple_index); + if (!PyWinObject_AsString(tuple_item, &((*pchars)[tuple_index]), FALSE)){ + PyWinObject_FreeCharArray(*pchars, *str_cnt); + *pchars=NULL; + *str_cnt=0; + goto done; + } + } + ret=TRUE; + done: + Py_DECREF(str_tuple); + return ret; + } |
