Update of /cvsroot/pywin32/pywin32/com/win32comext/shell/src In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21396/src Modified Files: PyIColumnProvider.cpp PyIPersistFolder.h PyIShellItemArray.cpp shell.cpp shell_pch.h Added Files: PyICategorizer.cpp PyICategorizer.h PyICategoryProvider.cpp PyICategoryProvider.h PyIDefaultExtractIconInit.cpp PyIDefaultExtractIconInit.h PyIEnumExplorerCommand.cpp PyIEnumExplorerCommand.h PyIExplorerCommandProvider.cpp PyIExplorerCommandProvider.h PyIPersistFolder2.cpp PyIShellFolder2.cpp PyIShellFolder2.h Removed Files: PyIExplorerInterfaces.h Log Message: * Many new vista shell interfaces (ICategorizer, ICategoryProvider, IDefaultExtractIconInit, IEnumExplorerCommand, IExplorerCommandProvider) and a couple other older ones we were missing (IShellFolder2, IPersistFolder2) * New vista shell functions (AssocCreateForClasses, SHCreateDataObject, SHCreateDefaultContextMenu, SHCreateDefaultExtractIcon, SHCreateShellFolderView, SHCreateShellItemArray, SHCreateShellItemArrayFromDataObject, SHCreateShellItemArrayFromIDLists, SHCreateShellItemArrayFromShellItem, SHGetNameFromIDList * Remove hacks now we can build with Vista SDK * New demo using a default shell view and Vista explorer interfaces (but it doesn't quite work!) Index: PyIShellItemArray.cpp =================================================================== RCS file: /cvsroot/pywin32/pywin32/com/win32comext/shell/src/PyIShellItemArray.cpp,v retrieving revision 1.1 retrieving revision 1.2 diff -C2 -d -r1.1 -r1.2 *** PyIShellItemArray.cpp 8 Jan 2008 00:41:03 -0000 1.1 --- PyIShellItemArray.cpp 7 Feb 2008 05:42:01 -0000 1.2 *************** *** 9,15 **** // // Interface Implementation - extern BOOL PyObject_AsSHCOLUMNID(PyObject *ob, SHCOLUMNID *p); - extern PyObject *PyObject_FromSHCOLUMNID(LPCSHCOLUMNID p); - PyIShellItemArray::PyIShellItemArray(IUnknown *pdisp): --- 9,12 ---- *************** *** 110,114 **** HRESULT hr; PY_INTERFACE_PRECALL; ! hr = pISIA->GetPropertyDescriptionList( &keyType, riid, &pv ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) --- 107,111 ---- HRESULT hr; PY_INTERFACE_PRECALL; ! hr = pISIA->GetPropertyDescriptionList( keyType, riid, &pv ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) *************** *** 281,288 **** { PY_GATEWAY_METHOD; ! // *** The input argument keyType of type "REFPROPERTYKEY" was not processed *** ! // - Please ensure this conversion function exists, and is appropriate ! // - The type 'REFPROPERTYKEY' (keyType) is unknown. ! PyObject *obkeyType = PyObject_FromSHCOLUMNID(keyType); if (obkeyType==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetPropertyDescriptionList"); PyObject *obriid; --- 278,282 ---- { PY_GATEWAY_METHOD; ! PyObject *obkeyType = PyObject_FromSHCOLUMNID(&keyType); if (obkeyType==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetPropertyDescriptionList"); PyObject *obriid; Index: PyIPersistFolder.h =================================================================== RCS file: /cvsroot/pywin32/pywin32/com/win32comext/shell/src/PyIPersistFolder.h,v retrieving revision 1.1 retrieving revision 1.2 diff -C2 -d -r1.1 -r1.2 *** PyIPersistFolder.h 8 Oct 2003 23:34:41 -0000 1.1 --- PyIPersistFolder.h 7 Feb 2008 05:42:01 -0000 1.2 *************** *** 38,39 **** --- 38,81 ---- }; + + // IPersistFolder2 + // + // Interface Declaration + + class PyIPersistFolder2 : public PyIPersistFolder + { + public: + MAKE_PYCOM_CTOR(PyIPersistFolder2); + static IPersistFolder2 *GetI(PyObject *self); + static PyComTypeObject type; + + // The Python methods + static PyObject *GetCurFolder(PyObject *self, PyObject *args); + + protected: + PyIPersistFolder2(IUnknown *pdisp); + ~PyIPersistFolder2(); + }; + // --------------------------------------------------- + // + // Gateway Declaration + + class PyGPersistFolder2 : public PyGPersistFolder, public IPersistFolder2 + { + protected: + PyGPersistFolder2(PyObject *instance) : PyGPersistFolder(instance) { ; } + PYGATEWAY_MAKE_SUPPORT2(PyGPersistFolder2, IPersistFolder2, IID_IPersistFolder2, PyGPersistFolder) + + // IPersist + STDMETHOD(GetClassID)( + /* [out] */ CLSID __RPC_FAR *pClassID); + + // IPersistFolder + STDMETHOD(Initialize)( + LPCITEMIDLIST pidl); + + // IPersistFolder2 + STDMETHOD(GetCurFolder)( + PIDLIST_ABSOLUTE * ppidl); + + }; Index: shell_pch.h =================================================================== RCS file: /cvsroot/pywin32/pywin32/com/win32comext/shell/src/shell_pch.h,v retrieving revision 1.8 retrieving revision 1.9 diff -C2 -d -r1.8 -r1.9 *** shell_pch.h 8 Jan 2008 00:41:03 -0000 1.8 --- shell_pch.h 7 Feb 2008 05:42:01 -0000 1.9 *************** *** 1,5 **** // shell_pch.h : header file for PCH generation for the shell COM extension ! #define _WIN32_IE 0x0601 #include <windows.h> #include <oleauto.h> --- 1,5 ---- // shell_pch.h : header file for PCH generation for the shell COM extension ! #define _WIN32_IE _WIN32_IE_IE70 #include <windows.h> #include <oleauto.h> *************** *** 36,42 **** PyObject *PyObject_FromRECT(const RECT *r); - // For the Vista IExplorer* interfaces - #include "PyIExplorerInterfaces.h" - BOOL PyObject_AsEXPLORER_BROWSER_OPTIONS(PyObject *, EXPLORER_BROWSER_OPTIONS *); PyObject *PyObject_FromEXPLORER_BROWSER_OPTIONS(EXPLORER_BROWSER_OPTIONS); --- 36,39 ---- *************** *** 45,48 **** --- 42,61 ---- PyObject *PyObject_FromEXPLORER_BROWSER_FILL_FLAGS(EXPLORER_BROWSER_FILL_FLAGS); + BOOL PyObject_AsSHCOLUMNID(PyObject *ob, SHCOLUMNID *p); + PyObject *PyObject_FromSHCOLUMNID(LPCSHCOLUMNID p); + + BOOL PyObject_AsSHCOLUMNINIT(PyObject *, SHCOLUMNINIT *); + PyObject *PyObject_FromSHCOLUMNINIT(LPCSHCOLUMNINIT); + + BOOL PyObject_AsSHCOLUMNINFO(PyObject *, SHCOLUMNINFO *); + PyObject *PyObject_FromSHCOLUMNINFO(LPCSHCOLUMNINFO); + + BOOL PyObject_AsSHCOLUMNDATA(PyObject *, SHCOLUMNDATA *); + void PyObject_FreeSHCOLUMNDATA(SHCOLUMNDATA *p); + PyObject *PyObject_FromSHCOLUMNDATA(LPCSHCOLUMNDATA); + + PyObject *PyObject_FromFOLDERSETTINGS( const FOLDERSETTINGS *pf); + BOOL PyObject_AsFOLDERSETTINGS( PyObject *ob, FOLDERSETTINGS *pf); + extern void *PyShell_AllocMem(ULONG cb); --- NEW FILE: PyIEnumExplorerCommand.cpp --- // This file implements the IEnumExplorerCommand Interface and Gateway for Python. // Generated by makegw.py #include "shell_pch.h" #include "PyIEnumExplorerCommand.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation PyIEnumExplorerCommand::PyIEnumExplorerCommand(IUnknown *pdisp): PyIUnknown(pdisp) { ob_type = &type; } PyIEnumExplorerCommand::~PyIEnumExplorerCommand() { } /* static */ IEnumExplorerCommand *PyIEnumExplorerCommand::GetI(PyObject *self) { return (IEnumExplorerCommand *)PyIUnknown::GetI(self); } // @pymethod object|PyIEnumExplorerCommand|Next|Retrieves a specified number of items in the enumeration sequence. PyObject *PyIEnumExplorerCommand::Next(PyObject *self, PyObject *args) { long celt = 1; // @pyparm int|num|1|Number of items to retrieve. if ( !PyArg_ParseTuple(args, "|l:Next", &celt) ) return NULL; IEnumExplorerCommand *pIEExplorerCommand = GetI(self); if ( pIEExplorerCommand == NULL ) return NULL; IExplorerCommand **rgVar = new IExplorerCommand *[celt]; if ( rgVar == NULL ) { PyErr_SetString(PyExc_MemoryError, "allocating result ExplorerCommands"); return NULL; } int i; /* for ( i = celt; i--; ) // *** possibly init each structure element??? */ ULONG celtFetched = 0; PY_INTERFACE_PRECALL; HRESULT hr = pIEExplorerCommand->Next(celt, rgVar, &celtFetched); PY_INTERFACE_POSTCALL; if ( HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS && FAILED(hr) ) { delete [] rgVar; return PyCom_BuildPyException(hr, pIEExplorerCommand, IID_IEnumExplorerCommand); } PyObject *result = PyTuple_New(celtFetched); if ( result != NULL ) { for ( i = celtFetched; i--; ) { PyObject *ob = PyCom_PyObjectFromIUnknown(rgVar[i], IID_IExplorerCommand, FALSE); if ( ob == NULL ) { Py_DECREF(result); result = NULL; break; } PyTuple_SET_ITEM(result, i, ob); } } /* for ( i = celtFetched; i--; ) // *** possibly cleanup each structure element??? */ delete [] rgVar; return result; } // @pymethod |PyIEnumExplorerCommand|Skip|Skips over the next specified elementes. PyObject *PyIEnumExplorerCommand::Skip(PyObject *self, PyObject *args) { long celt; if ( !PyArg_ParseTuple(args, "l:Skip", &celt) ) return NULL; IEnumExplorerCommand *pIEExplorerCommand = GetI(self); if ( pIEExplorerCommand == NULL ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIEExplorerCommand->Skip(celt); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIEExplorerCommand, IID_IEnumExplorerCommand); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIEnumExplorerCommand|Reset|Resets the enumeration sequence to the beginning. PyObject *PyIEnumExplorerCommand::Reset(PyObject *self, PyObject *args) { if ( !PyArg_ParseTuple(args, ":Reset") ) return NULL; IEnumExplorerCommand *pIEExplorerCommand = GetI(self); if ( pIEExplorerCommand == NULL ) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pIEExplorerCommand->Reset(); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIEExplorerCommand, IID_IEnumExplorerCommand); Py_INCREF(Py_None); return Py_None; } // @pymethod <o PyIEnumExplorerCommand>|PyIEnumExplorerCommand|Clone|Creates another enumerator that contains the same enumeration state as the current one PyObject *PyIEnumExplorerCommand::Clone(PyObject *self, PyObject *args) { if ( !PyArg_ParseTuple(args, ":Clone") ) return NULL; IEnumExplorerCommand *pIEExplorerCommand = GetI(self); if ( pIEExplorerCommand == NULL ) return NULL; IEnumExplorerCommand *pClone; PY_INTERFACE_PRECALL; HRESULT hr = pIEExplorerCommand->Clone(&pClone); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIEExplorerCommand, IID_IEnumExplorerCommand); return PyCom_PyObjectFromIUnknown(pClone, IID_IEnumExplorerCommand, FALSE); } // @object PyIEnumExplorerCommand|A Python interface to IEnumExplorerCommand static struct PyMethodDef PyIEnumExplorerCommand_methods[] = { { "Next", PyIEnumExplorerCommand::Next, 1 }, // @pymeth Next|Retrieves a specified number of items in the enumeration sequence. { "Skip", PyIEnumExplorerCommand::Skip, 1 }, // @pymeth Skip|Skips over the next specified elementes. { "Reset", PyIEnumExplorerCommand::Reset, 1 }, // @pymeth Reset|Resets the enumeration sequence to the beginning. { "Clone", PyIEnumExplorerCommand::Clone, 1 }, // @pymeth Clone|Creates another enumerator that contains the same enumeration state as the current one. { NULL } }; PyComTypeObject PyIEnumExplorerCommand::type("PyIEnumExplorerCommand", &PyIUnknown::type, sizeof(PyIEnumExplorerCommand), PyIEnumExplorerCommand_methods, GET_PYCOM_CTOR(PyIEnumExplorerCommand)); // --------------------------------------------------- // // Gateway Implementation // Std delegation /* STDMETHODIMP_(ULONG) PyGEnumExplorerCommand::AddRef(void) {return PyGatewayBase::AddRef();} STDMETHODIMP_(ULONG) PyGEnumExplorerCommand::Release(void) {return PyGatewayBase::Release();} STDMETHODIMP PyGEnumExplorerCommand::QueryInterface(REFIID iid, void ** obj) {return PyGatewayBase::QueryInterface(iid, obj);} STDMETHODIMP PyGEnumExplorerCommand::GetTypeInfoCount(UINT FAR* pctInfo) {return PyGatewayBase::GetTypeInfoCount(pctInfo);} STDMETHODIMP PyGEnumExplorerCommand::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo FAR* FAR* pptInfo) {return PyGatewayBase::GetTypeInfo(itinfo, lcid, pptInfo);} STDMETHODIMP PyGEnumExplorerCommand::GetIDsOfNames(REFIID refiid, OLECHAR FAR* FAR* rgszNames, UINT cNames, LCID lcid, DISPID FAR* rgdispid) {return PyGatewayBase::GetIDsOfNames( refiid, rgszNames, cNames, lcid, rgdispid);} STDMETHODIMP PyGEnumExplorerCommand::Invoke(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR* params, VARIANT FAR* pVarResult, EXCEPINFO FAR* pexcepinfo, UINT FAR* puArgErr) {return PyGatewayBase::Invoke( dispid, riid, lcid, wFlags, params, pVarResult, pexcepinfo, puArgErr);} */ STDMETHODIMP PyGEnumExplorerCommand::Next( /* [in] */ ULONG celt, /* [length_is][size_is][out] */ IExplorerCommand __RPC_FAR * __RPC_FAR *rgVar, /* [out] */ ULONG __RPC_FAR *pCeltFetched) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr = InvokeViaPolicy("Next", &result, "i", celt); if ( FAILED(hr) ) return hr; if ( !PySequence_Check(result) ) goto error; Py_ssize_t len = PyObject_Length(result); if ( len == -1 ) goto error; if ( len > (int)celt) len = celt; if ( pCeltFetched ) *pCeltFetched = (ULONG)len; int i; for ( i = 0; i < len; ++i ) { PyObject *ob = PySequence_GetItem(result, i); if ( ob == NULL ) goto error; if ( !PyCom_InterfaceFromPyObject(ob, IID_IExplorerCommand, (void **)&rgVar[i], FALSE) ) { Py_DECREF(result); return MAKE_PYCOM_GATEWAY_FAILURE_CODE("Next"); } } Py_DECREF(result); return len < (int)celt ? S_FALSE : S_OK; error: PyErr_Clear(); // just in case Py_DECREF(result); return PyCom_SetCOMErrorFromSimple(E_FAIL, IID_IEnumExplorerCommand, "Next() did not return a sequence of objects"); } STDMETHODIMP PyGEnumExplorerCommand::Skip( /* [in] */ ULONG celt) { PY_GATEWAY_METHOD; return InvokeViaPolicy("Skip", NULL, "i", celt); } STDMETHODIMP PyGEnumExplorerCommand::Reset(void) { PY_GATEWAY_METHOD; return InvokeViaPolicy("Reset"); } STDMETHODIMP PyGEnumExplorerCommand::Clone( /* [out] */ IEnumExplorerCommand __RPC_FAR *__RPC_FAR *ppEnum) { PY_GATEWAY_METHOD; PyObject * result; HRESULT hr = InvokeViaPolicy("Clone", &result); if ( FAILED(hr) ) return hr; /* ** Make sure we have the right kind of object: we should have some kind ** of IUnknown subclass wrapped into a PyIUnknown instance. */ if ( !PyIBase::is_object(result, &PyIUnknown::type) ) { /* the wrong kind of object was returned to us */ Py_DECREF(result); return PyCom_SetCOMErrorFromSimple(E_FAIL, IID_IEnumExplorerCommand); } /* ** Get the IUnknown out of the thing. note that the Python ob maintains ** a reference, so we don't have to explicitly AddRef() here. */ IUnknown *punk = ((PyIUnknown *)result)->m_obj; if ( !punk ) { /* damn. the object was released. */ Py_DECREF(result); return PyCom_SetCOMErrorFromSimple(E_FAIL, IID_IEnumExplorerCommand); } /* ** Get the interface we want. note it is returned with a refcount. ** This QI is actually going to instantiate a PyGEnumExplorerCommand. */ hr = punk->QueryInterface(IID_IEnumExplorerCommand, (LPVOID *)ppEnum); /* done with the result; this DECREF is also for <punk> */ Py_DECREF(result); return PyCom_SetCOMErrorFromSimple(hr, IID_IEnumExplorerCommand, "Python could not convert the result from Next() into the required COM interface"); } --- NEW FILE: PyIDefaultExtractIconInit.cpp --- // This file implements the IDefaultExtractIconInit Interface and Gateway for Python. // Generated by makegw.py #include "shell_pch.h" #include "PyIDefaultExtractIconInit.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation PyIDefaultExtractIconInit::PyIDefaultExtractIconInit(IUnknown *pdisp): PyIUnknown(pdisp) { ob_type = &type; } PyIDefaultExtractIconInit::~PyIDefaultExtractIconInit() { } /* static */ IDefaultExtractIconInit *PyIDefaultExtractIconInit::GetI(PyObject *self) { return (IDefaultExtractIconInit *)PyIUnknown::GetI(self); } // @pymethod |PyIDefaultExtractIconInit|SetFlags|Description of SetFlags. PyObject *PyIDefaultExtractIconInit::SetFlags(PyObject *self, PyObject *args) { IDefaultExtractIconInit *pIDEII = GetI(self); if ( pIDEII == NULL ) return NULL; // @pyparm int|uFlags||Description for uFlags UINT uFlags; if ( !PyArg_ParseTuple(args, "i:SetFlags", &uFlags) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIDEII->SetFlags( uFlags ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIDEII, IID_IDefaultExtractIconInit ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIDefaultExtractIconInit|SetKey|Description of SetKey. PyObject *PyIDefaultExtractIconInit::SetKey(PyObject *self, PyObject *args) { IDefaultExtractIconInit *pIDEII = GetI(self); if ( pIDEII == NULL ) return NULL; HKEY hkey; PyObject *obhkey; // @pyparm <o PyHKEY>|hkey||Description for hkey if ( !PyArg_ParseTuple(args, "O:SetKey", &obhkey) ) return NULL; if (!PyWinObject_AsHKEY(obhkey, &hkey)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIDEII->SetKey( hkey ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIDEII, IID_IDefaultExtractIconInit ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIDefaultExtractIconInit|SetNormalIcon|Description of SetNormalIcon. PyObject *PyIDefaultExtractIconInit::SetNormalIcon(PyObject *self, PyObject *args) { IDefaultExtractIconInit *pIDEII = GetI(self); if ( pIDEII == NULL ) return NULL; // @pyparm <o unicode>|pszFile||Description for pszFile // @pyparm int|iIcon||Description for iIcon PyObject *obpszFile; LPWSTR pszFile; int iIcon; if ( !PyArg_ParseTuple(args, "Oi:SetNormalIcon", &obpszFile, &iIcon) ) return NULL; if (!PyWinObject_AsBstr(obpszFile, &pszFile)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIDEII->SetNormalIcon( pszFile, iIcon ); SysFreeString(pszFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIDEII, IID_IDefaultExtractIconInit ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIDefaultExtractIconInit|SetOpenIcon|Description of SetOpenIcon. PyObject *PyIDefaultExtractIconInit::SetOpenIcon(PyObject *self, PyObject *args) { IDefaultExtractIconInit *pIDEII = GetI(self); if ( pIDEII == NULL ) return NULL; // @pyparm <o unicode>|pszFile||Description for pszFile // @pyparm int|iIcon||Description for iIcon PyObject *obpszFile; LPWSTR pszFile; int iIcon; if ( !PyArg_ParseTuple(args, "Oi:SetOpenIcon", &obpszFile, &iIcon) ) return NULL; if (!PyWinObject_AsBstr(obpszFile, &pszFile)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIDEII->SetOpenIcon( pszFile, iIcon ); SysFreeString(pszFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIDEII, IID_IDefaultExtractIconInit ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIDefaultExtractIconInit|SetShortcutIcon|Description of SetShortcutIcon. PyObject *PyIDefaultExtractIconInit::SetShortcutIcon(PyObject *self, PyObject *args) { IDefaultExtractIconInit *pIDEII = GetI(self); if ( pIDEII == NULL ) return NULL; // @pyparm <o unicode>|pszFile||Description for pszFile // @pyparm int|iIcon||Description for iIcon PyObject *obpszFile; LPWSTR pszFile; int iIcon; if ( !PyArg_ParseTuple(args, "Oi:SetShortcutIcon", &obpszFile, &iIcon) ) return NULL; if (!PyWinObject_AsBstr(obpszFile, &pszFile)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIDEII->SetShortcutIcon( pszFile, iIcon ); SysFreeString(pszFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIDEII, IID_IDefaultExtractIconInit ); Py_INCREF(Py_None); return Py_None; } // @pymethod |PyIDefaultExtractIconInit|SetDefaultIcon|Description of SetDefaultIcon. PyObject *PyIDefaultExtractIconInit::SetDefaultIcon(PyObject *self, PyObject *args) { IDefaultExtractIconInit *pIDEII = GetI(self); if ( pIDEII == NULL ) return NULL; // @pyparm <o unicode>|pszFile||Description for pszFile // @pyparm int|iIcon||Description for iIcon PyObject *obpszFile; LPWSTR pszFile; int iIcon; if ( !PyArg_ParseTuple(args, "Oi:SetDefaultIcon", &obpszFile, &iIcon) ) return NULL; if (!PyWinObject_AsBstr(obpszFile, &pszFile)) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIDEII->SetDefaultIcon( pszFile, iIcon ); SysFreeString(pszFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIDEII, IID_IDefaultExtractIconInit ); Py_INCREF(Py_None); return Py_None; } // @object PyIDefaultExtractIconInit|Description of the interface static struct PyMethodDef PyIDefaultExtractIconInit_methods[] = { { "SetFlags", PyIDefaultExtractIconInit::SetFlags, 1 }, // @pymeth SetFlags|Description of SetFlags { "SetKey", PyIDefaultExtractIconInit::SetKey, 1 }, // @pymeth SetKey|Description of SetKey { "SetNormalIcon", PyIDefaultExtractIconInit::SetNormalIcon, 1 }, // @pymeth SetNormalIcon|Description of SetNormalIcon { "SetOpenIcon", PyIDefaultExtractIconInit::SetOpenIcon, 1 }, // @pymeth SetOpenIcon|Description of SetOpenIcon { "SetShortcutIcon", PyIDefaultExtractIconInit::SetShortcutIcon, 1 }, // @pymeth SetShortcutIcon|Description of SetShortcutIcon { "SetDefaultIcon", PyIDefaultExtractIconInit::SetDefaultIcon, 1 }, // @pymeth SetDefaultIcon|Description of SetDefaultIcon { NULL } }; PyComTypeObject PyIDefaultExtractIconInit::type("PyIDefaultExtractIconInit", &PyIUnknown::type, sizeof(PyIDefaultExtractIconInit), PyIDefaultExtractIconInit_methods, GET_PYCOM_CTOR(PyIDefaultExtractIconInit)); Index: shell.cpp =================================================================== RCS file: /cvsroot/pywin32/pywin32/com/win32comext/shell/src/shell.cpp,v retrieving revision 1.60 retrieving revision 1.61 diff -C2 -d -r1.60 -r1.61 *** shell.cpp 8 Jan 2008 00:41:03 -0000 1.60 --- shell.cpp 7 Feb 2008 05:42:01 -0000 1.61 *************** *** 19,29 **** --- 19,34 ---- #include "EmptyVC.h" #include "PyIShellLink.h" + #include "PyICategorizer.h" + #include "PyICategoryProvider.h" #include "PyIContextMenu.h" + #include "PyIDefaultExtractIconInit.h" #include "PyIExtractIcon.h" #include "PyIExtractIconW.h" #include "PyIShellExtInit.h" #include "PyIShellFolder.h" + #include "PyIShellFolder2.h" #include "PyIEmptyVolumeCache.h" #include "PyIEmptyVolumeCacheCallBack.h" + #include "PyIEnumExplorerCommand.h" #include "PyIEnumIDList.h" #include "PyICopyHook.h" *************** *** 51,54 **** --- 56,60 ---- #include "PyIExplorerBrowserEvents.h" #include "PyIExplorerCommand.h" + #include "PyIExplorerCommandProvider.h" #include "PyIShellItem.h" #include "PyIShellItemArray.h" *************** *** 59,71 **** #define OleSetOleError PyCom_BuildPyException - #if (WINVER < 0x600) - const IID IID_IExplorerBrowser = __uuidof(IExplorerBrowser); - const IID IID_IExplorerBrowserEvents = __uuidof(IExplorerBrowserEvents); - const IID IID_IExplorerCommand = __uuidof(IExplorerCommand); - const IID IID_IShellItemArray = __uuidof(IShellItemArray); - const IID IID_IEnumExplorerCommand = __uuidof(IEnumExplorerCommand); - const IID IID_IEnumShellItems = __uuidof(IEnumShellItems); - #endif - static HMODULE shell32 = NULL; static HMODULE shfolder = NULL; --- 65,68 ---- *************** *** 102,105 **** --- 99,105 ---- static PFNAssocCreate pfnAssocCreate = NULL; + typedef HRESULT (WINAPI * PFNAssocCreateForClasses)(const ASSOCIATIONELEMENT *, ULONG cClasses, REFIID riid, void **ppv); + static PFNAssocCreateForClasses pfnAssocCreateForClasses = NULL; + typedef LRESULT (WINAPI *PFNSHShellFolderView_Message)(HWND, UINT, LPARAM); static PFNSHShellFolderView_Message pfnSHShellFolderView_Message = NULL; *************** *** 108,115 **** static PFNIsUserAnAdmin pfnIsUserAnAdmin = NULL; void PyShell_FreeMem(void *p) { ! if (p!=NULL) ! CoTaskMemFree(p); } --- 108,144 ---- static PFNIsUserAnAdmin pfnIsUserAnAdmin = NULL; + typedef BOOL (WINAPI *PFNSHGetNameFromIDList)(PCIDLIST_ABSOLUTE, SIGDN, PWSTR *); + static PFNSHGetNameFromIDList pfnSHGetNameFromIDList = NULL; + + typedef BOOL (WINAPI *PFNSHCreateShellFolderView)(const SFV_CREATE *, IShellView **ppsv); + static PFNSHCreateShellFolderView pfnSHCreateShellFolderView = NULL; + + typedef BOOL (WINAPI *PFNSHCreateDefaultExtractIcon)(REFIID riid, void **ppv); + static PFNSHCreateDefaultExtractIcon pfnSHCreateDefaultExtractIcon = NULL; + + typedef BOOL (WINAPI *PFNSHCreateDataObject)(PCIDLIST_ABSOLUTE, UINT, PCUITEMID_CHILD_ARRAY, IDataObject *, REFIID, void **); + static PFNSHCreateDataObject pfnSHCreateDataObject = NULL; + + typedef BOOL (WINAPI *PFNSHCreateShellItemArray)(PCIDLIST_ABSOLUTE, IShellFolder *, UINT, PCUITEMID_CHILD_ARRAY, IShellItemArray **); + static PFNSHCreateShellItemArray pfnSHCreateShellItemArray = NULL; + + typedef BOOL (WINAPI *PFNSHCreateShellItemArrayFromDataObject)(IDataObject *pdo, REFIID, void **); + static PFNSHCreateShellItemArrayFromDataObject pfnSHCreateShellItemArrayFromDataObject = NULL; + + typedef BOOL (WINAPI *PFNSHCreateShellItemArrayFromIDLists)(UINT, PCIDLIST_ABSOLUTE_ARRAY, IShellItemArray **); + static PFNSHCreateShellItemArrayFromIDLists pfnSHCreateShellItemArrayFromIDLists = NULL; + + typedef BOOL (WINAPI *PFNSHCreateShellItemArrayFromShellItem)(IShellItem *, REFIID riid, void **); + static PFNSHCreateShellItemArrayFromShellItem pfnSHCreateShellItemArrayFromShellItem = NULL; + + typedef BOOL (WINAPI *PFNSHCreateDefaultContextMenu)(const DEFCONTEXTMENU *, REFIID, void **); + static PFNSHCreateDefaultContextMenu pfnSHCreateDefaultContextMenu = NULL; + void PyShell_FreeMem(void *p) { ! // NOTE: CoTaskMemFree documents NULL is an OK param - so we no ! // longer check for that - and given the new 'propsys' module, these ! // are screaming to become macros (and/or die!) ! CoTaskMemFree(p); } *************** *** 785,788 **** --- 814,872 ---- } + // Note - 'cleanup' as we don't free the object itself, just a couple of + // pointers inside it. + void PyObject_CleanupDEFCONTEXTMENU(DEFCONTEXTMENU *dcm) + { + PY_INTERFACE_PRECALL; // so all ->Releases() happen with GIL released. + if (dcm->pcmcb) + dcm->pcmcb->Release(); + if (dcm->psf) + dcm->psf->Release(); + if (dcm->punkAssociationInfo) + dcm->punkAssociationInfo->Release(); + if (dcm->pidlFolder) + PyObject_FreePIDL(dcm->pidlFolder); + if (dcm->apidl) + PyObject_FreePIDLArray(dcm->cidl, dcm->apidl); + PY_INTERFACE_POSTCALL + } + + // @object DEFCONTENTMENU|A tuple representing a DEFCONTEXTMENU structure. + BOOL PyObject_AsDEFCONTEXTMENU(PyObject *ob, DEFCONTEXTMENU *dcm) + { + BOOL ok = FALSE; + memset(dcm, 0, sizeof(*dcm)); + PyObject *obhwnd, *obcb, *obpidlFolder, *obsf, *obpidlChildren, *obai=Py_None, *obkeys=Py_None; + if (!PyArg_ParseTuple(ob, "OOOOO|OO", &obhwnd, &obcb, &obpidlFolder, &obsf, &obpidlChildren, &obai, &obkeys)) + return NULL; + // @pyparm <o PyHANDLE>|hwnd|| + if (!PyWinObject_AsHANDLE(obhwnd, (HANDLE *)&dcm->hwnd)) + goto done; + // @pyparm <o PyIContextMenuCB>|callback||May be None + if (!PyCom_InterfaceFromPyInstanceOrObject(obcb, IID_IContextMenuCB, (void **)&dcm->pcmcb, TRUE/* bNoneOK */)) + goto done; + // @pyparm <o PIDL>|pidlFolder||May be None + if (!PyObject_AsPIDL(obpidlFolder, (LPITEMIDLIST *)&dcm->pidlFolder, TRUE)) + goto done; + // @pyparm <o PyIShellFolder>|sf||The Shell data source object that is the parent of the child items specified in children. If parent is specified, this parameter can be NULL. + if (!PyCom_InterfaceFromPyInstanceOrObject(obsf, IID_IShellFolder, (void **)&dcm->psf, TRUE/* bNoneOK */)) + goto done; + // @pyparm [<o PIDL>, ...]|children|| + if (!PyObject_AsPIDLArray(obpidlChildren, &dcm->cidl, &dcm->apidl)) + goto done; + // @pyparm <o PyIUnknown>|unkAssocInfo||May be None + if (!PyCom_InterfaceFromPyInstanceOrObject(obsf, IID_IUnknown, (void **)&dcm->punkAssociationInfo, TRUE/* bNoneOK */)) + goto done; + if (obkeys != Py_None) { + PyErr_SetString(PyExc_ValueError, "Only None is supported for obKeys"); + goto done; + } + ok = TRUE; + done: + if (!ok) + PyObject_CleanupDEFCONTEXTMENU(dcm); + return ok; + } + // @object PyLPOLEMENUGROUPWIDTHS|Tuple containing 6 ints indicating nbr of options in each menu group BOOL PyObject_AsOLEMENUGROUPWIDTHS( PyObject *oblpMenuWidths, OLEMENUGROUPWIDTHS *pWidths) *************** *** 898,901 **** --- 982,1033 ---- } + void PyObject_FreeASSOCIATIONELEMENTs(ULONG celems, ASSOCIATIONELEMENT *a) + { + for(ULONG i=0;i<celems;i++) + if (a[i].pszClass) + PyWinObject_FreeWCHAR((PWSTR)a[i].pszClass); + free(a); + } + + BOOL PyObject_AsASSOCIATIONELEMENTs(PyObject *ob, ULONG *num, ASSOCIATIONELEMENT **ret) + { + BOOL ok = FALSE; + if (!PySequence_Check(ob)) { + PyErr_Format(PyExc_TypeError, "ASSOCIATIONELEMENTs arg must be a sequence of tuples"); + return FALSE; + } + *num = (ULONG)PySequence_Length(ob); + ASSOCIATIONELEMENT *elts; + elts = *ret = (ASSOCIATIONELEMENT *)malloc(*num * sizeof(ASSOCIATIONELEMENT)); + if (!elts) { + PyErr_NoMemory(); + return FALSE; + } + memset(elts, 0, *num * sizeof(ASSOCIATIONELEMENT)); + PyObject *klass = NULL; + for (ULONG i=0;i<*num;i++) { + Py_XDECREF(klass); // for prev time around the loop + klass = PySequence_GetItem(ob, i); + PyObject *obname, *obhk; + if (!klass) + goto done; + if (!PyArg_ParseTuple(klass, "kOO", &elts[i].ac, &obhk, &obname)) + goto done; + if (!PyWinObject_AsHKEY(obhk, &elts[i].hkClass)) + goto done; + if (!PyWinObject_AsWCHAR(obname, (PWSTR *)&elts[i].pszClass, TRUE)) + goto done; + } + ok = TRUE; + done: + Py_XDECREF(klass); + if (!ok && elts) { + PyObject_FreeASSOCIATIONELEMENTs(*num, elts); + *ret = NULL; + *num = 0; + } + return ok; + } + #if (PY_VERSION_HEX >= 0x02030000) // PyGILState only in 2.3+ *************** *** 2131,2135 **** &obVerb, // @pyparm string|lpVerb|| &obFile, // @pyparm string|lpFile|| ! &obParams, // @pyparm string|lpParams|| &obDirectory, // @pyparm string|lpDirectory|| &info.nShow, // @pyparm int|nShow|0| --- 2263,2267 ---- &obVerb, // @pyparm string|lpVerb|| &obFile, // @pyparm string|lpFile|| ! &obParams, // @pyparm string|lpParameters|| &obDirectory, // @pyparm string|lpDirectory|| &info.nShow, // @pyparm int|nShow|0| *************** *** 2231,2234 **** --- 2363,2401 ---- } + // @pymethod <o PyIUnknown>|shell|AssocCreateForClasses|Retrieves an object that implements an IQueryAssociations interface. + static PyObject *PyAssocCreateForClasses(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnAssocCreateForClasses==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obClasses, *obiid; + if (!PyArg_ParseTuple(args, "OO:AssocCreateForClasses", &obClasses, &obiid)) + return NULL; + ASSOCIATIONELEMENT *elts = NULL; + ULONG nclasses = 0; + IID iid; + if (!PyWinObject_AsIID(obiid, &iid)) + goto done; + if (!PyObject_AsASSOCIATIONELEMENTs(obClasses, &nclasses, &elts)) + goto done; + HRESULT hr; + void *v; + PY_INTERFACE_PRECALL; + hr = (*pfnAssocCreateForClasses)(elts, nclasses, iid, &v); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + ret = PyCom_PyObjectFromIUnknown((IUnknown *)v, iid, FALSE); + done: + if (elts) + PyObject_FreeASSOCIATIONELEMENTs(nclasses, elts); + return ret; + } + // @pymethod <o PyIPropertyBag>|shell|SHGetViewStatePropertyBag|Retrieves an interface for the view state of a folder // @comm This function will also return IPropertyBag2, but we don't have a python implementation of this interface yet *************** *** 2314,2317 **** --- 2481,2846 ---- } + // @pymethod (o PyIShellView|shell|SHCreateShellFolderView| + static PyObject *PySHCreateShellFolderView(PyObject *self, PyObject *args) + { + if (pfnSHCreateShellFolderView==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obsf; + PyObject *obouter = Py_None; + PyObject *obevents = Py_None; + // @pyparm <o PyIShellFolder>|sf|| + // @pyparm <o PyIShellView>|viewOuter|None| + // @pyparm <o PyIShellFolderViewCB>|callbacks|None| + if(!PyArg_ParseTuple(args, "O|OO:SHCreateShellFolderView", &obsf, &obouter, &obevents)) + return NULL; + SFV_CREATE create; + memset(&create, 0, sizeof(create)); + create.cbSize = sizeof(create); + if (!PyCom_InterfaceFromPyInstanceOrObject(obsf, IID_IShellFolder, (void **)&create.pshf, FALSE/* bNoneOK */)) + goto done; + if (!PyCom_InterfaceFromPyInstanceOrObject(obouter, IID_IShellView, (void **)&create.psvOuter, TRUE/* bNoneOK */)) + goto done; + if (!PyCom_InterfaceFromPyInstanceOrObject(obevents, IID_IShellFolderViewCB, (void **)&create.psfvcb, TRUE/* bNoneOK */)) + goto done; + IShellView *view = NULL; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateShellFolderView)(&create, &view); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) + PyCom_BuildPyException(hr); + else + ret = PyCom_PyObjectFromIUnknown(view, IID_IShellView, FALSE); + // ref on view consumed by ret object. + done: + { + PY_INTERFACE_PRECALL; + if (create.pshf) create.pshf->Release(); + if (create.psvOuter) create.psvOuter->Release(); + if (create.psfvcb) create.psfvcb->Release(); + PY_INTERFACE_POSTCALL; + } + return ret; + } + + // @pymethod <o PyIDefaultExtractIconInit>|shell|SHCreateDefaultExtractIcon|Creates a standard icon extractor, whose defaults can be further configured via the IDefaultExtractIconInit interface. + static PyObject *PySHCreateDefaultExtractIcon(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateDefaultExtractIcon==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + // be lazy - don't take IID as a param! + if(!PyArg_ParseTuple(args, ":SHCreateDefaultExtractIcon")) + return NULL; + IDefaultExtractIconInit *ret = NULL; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateDefaultExtractIcon)(IID_IDefaultExtractIconInit, (void **)&ret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) + return PyCom_BuildPyException(hr); + // ref on view consumed by ret object. + return PyCom_PyObjectFromIUnknown(ret, IID_IDefaultExtractIconInit, FALSE); + } + + // @pymethod <o PyIUnknown>|shell|SHCreateDataObject| + static PyObject *PySHCreateDataObject(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateDataObject==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obParent; + PyObject *obChildren; + PyObject *obdo; + PyObject *obiid = Py_None; + PIDLIST_ABSOLUTE parent = NULL; + PCUITEMID_CHILD_ARRAY children = NULL; + IDataObject *do_inner = NULL; + void *do_ret = NULL; + IID iid = IID_IDataObject; + UINT nchildren; + if(!PyArg_ParseTuple(args, "OOO|O:SHCreateDataObject", &obParent, &obChildren, &obdo, &obiid)) + return NULL; + // @pyparm PIDL|parent|| + if (!PyObject_AsPIDL(obParent, &parent)) + goto done; + // @pyparm [PIDL, ...]|children|| + if (!PyObject_AsPIDLArray(obChildren, &nchildren, &children)) + goto done; + // @pyparm <o PyIDataObject>|do_inner||The inner data object, or None + if (!PyCom_InterfaceFromPyInstanceOrObject(obdo, IID_IDataObject, (void **)&do_inner, TRUE/* bNoneOK */)) + goto done; + // @pyparm <o PyIID>|iid|IID_IDataObject|The IID to query for + if (obiid != Py_None && !PyWinObject_AsIID(obiid, &iid)) + goto done; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateDataObject)(parent, nchildren, children, do_inner, iid, &do_ret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyCom_PyObjectFromIUnknown((IUnknown *)do_ret, iid, FALSE); + done: + if (parent) + PyObject_FreePIDL(parent); + if (children) + PyObject_FreePIDLArray(nchildren, children); + if (do_inner) { + PY_INTERFACE_PRECALL; + do_inner->Release(); + PY_INTERFACE_POSTCALL; + } + return ret; + } + + // @pymethod <o PyIUnknown>|shell|SHCreateDefaultContextMenu| + static PyObject *PySHCreateDefaultContextMenu(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateDefaultContextMenu==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obdcm, *obiid; + IID iid = IID_IContextMenu; + if(!PyArg_ParseTuple(args, "O|O:SHCreateDefaultContextMenu", &obdcm, &obiid)) + return NULL; + void *iret = NULL; + DEFCONTEXTMENU dcm; + // @pyparm <o DEFAULTCONTEXTMENU>|dcm|| + if (!PyObject_AsDEFCONTEXTMENU(obdcm, &dcm)) + goto done; + // @pyparm <o PyIID>|iid|IID_IContextMenu|The IID to query for + if (obiid != Py_None && !PyWinObject_AsIID(obiid, &iid)) + goto done; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateDefaultContextMenu)(&dcm, iid, &iret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyCom_PyObjectFromIUnknown((IUnknown *)iret, iid, FALSE); + done: + PyObject_CleanupDEFCONTEXTMENU(&dcm); + return ret; + } + + // @pymethod unicode|shell|SHGetNameFromIDList|Retrieves the display name of an item from an ID list. + static PyObject *PySHGetNameFromIDList(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHGetNameFromIDList==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + PyObject *ret = NULL; + PyObject *obpidl; + SIGDN flags; + WCHAR *strret = NULL; + PIDLIST_ABSOLUTE pidl = NULL; + if(!PyArg_ParseTuple(args, "Ok:SHGetNameFromIDList", &obpidl, &flags)) + return NULL; + // @pyparm PIDL|parent|| + // @pyparm int|flags|| + if (!PyObject_AsPIDL(obpidl, &pidl)) + goto done; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHGetNameFromIDList)(pidl, flags, &strret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyWinObject_FromWCHAR(strret); + done: + if (pidl) + PyObject_FreePIDL(pidl); + if (strret) + CoTaskMemFree(strret); + return ret; + } + + // @pymethod <o PyIShellItemArray>|shell|SHCreateShellItemArray| + static PyObject *PySHCreateShellItemArray(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateShellItemArray==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obParent; + PyObject *obChildren; + PyObject *obsf; + PIDLIST_ABSOLUTE parent = NULL; + PCUITEMID_CHILD_ARRAY children = NULL; + UINT nchildren; + IShellFolder *sf = NULL; + IShellItemArray *sia_ret = NULL; + if(!PyArg_ParseTuple(args, "OOO:SHCreateShellItemArray", &obParent, &obsf, &obChildren)) + return NULL; + // @pyparm PIDL|parent|| + if (!PyObject_AsPIDL(obParent, &parent, TRUE)) + goto done; + // @pyparm <o PyIShellFolder>|sf||The Shell data source object that is the parent of the child items specified in children. If parent is specified, this parameter can be NULL. + if (!PyCom_InterfaceFromPyInstanceOrObject(obsf, IID_IShellFolder, (void **)&sf, TRUE/* bNoneOK */)) + goto done; + // @pyparm [PIDL, ...]|children|| + if (!PyObject_AsPIDLArray(obChildren, &nchildren, &children)) + goto done; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateShellItemArray)(parent, sf, nchildren, children, &sia_ret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyCom_PyObjectFromIUnknown(sia_ret, IID_IShellItemArray, FALSE); + done: + if (parent) + PyObject_FreePIDL(parent); + if (children) + PyObject_FreePIDLArray(nchildren, children); + if (sf) { + PY_INTERFACE_PRECALL; + sf->Release(); + PY_INTERFACE_POSTCALL; + } + return ret; + } + + // @pymethod <o PyIUnknown>|shell|SHCreateShellItemArray| + static PyObject *PySHCreateShellItemArrayFromDataObject(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateShellItemArrayFromDataObject==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obdo; + PyObject *obiid = Py_None; + IID iid = IID_IShellItemArray; + IDataObject *ido = NULL; + void *iret = NULL; + if(!PyArg_ParseTuple(args, "O|O:SHCreateShellItemArrayFromDataObject", &obdo, &obiid)) + return NULL; + // @pyparm <o PyIDataObject>|do|| + if (!PyCom_InterfaceFromPyInstanceOrObject(obdo, IID_IDataObject, (void **)&ido, FALSE/* bNoneOK */)) + goto done; + // @pyparm <o PyIID>|iid|IID_IDataObject|The IID to query for + if (obiid != Py_None && !PyWinObject_AsIID(obiid, &iid)) + goto done; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateShellItemArrayFromDataObject)(ido, iid, &iret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyCom_PyObjectFromIUnknown((IUnknown *)iret, iid, FALSE); + done: + if (ido) { + PY_INTERFACE_PRECALL; + ido->Release(); + PY_INTERFACE_POSTCALL; + } + return ret; + } + + // @pymethod <o PyIShellItemArray>|shell|SHCreateShellItemArrayFromIDLists| + static PyObject *PySHCreateShellItemArrayFromIDLists(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateShellItemArrayFromIDLists==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obpidls; + PCIDLIST_ABSOLUTE_ARRAY pidls = NULL; + UINT npidls; + if(!PyArg_ParseTuple(args, "O:SHCreateShellItemArray", &obpidls)) + return NULL; + // @pyparm [PIDL, ...]|pidls|| + if (!PyObject_AsPIDLArray(obpidls, &npidls, &pidls)) + goto done; + HRESULT hr; + IShellItemArray *iret = NULL; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateShellItemArrayFromIDLists)(npidls, pidls, &iret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyCom_PyObjectFromIUnknown(iret, IID_IShellItemArray, FALSE); + done: + if (pidls) + PyObject_FreePIDLArray(npidls, pidls); + return ret; + } + + // @pymethod <o PyIUnknown>|shell|SHCreateShellItemArrayFromShellItem| + static PyObject *PySHCreateShellItemArrayFromShellItem(PyObject *self, PyObject *args) + { + // @comm This function is only available on Vista and later; a + // COM exception with E_NOTIMPL will be thrown if the function can't be located. + if (pfnSHCreateShellItemArrayFromShellItem==NULL) + return PyCom_BuildPyException(E_NOTIMPL); + + PyObject *ret = NULL; + PyObject *obsi; + PyObject *obiid = Py_None; + IShellItem *isi = NULL; + IID iid = IID_IShellItemArray; + void *iret = NULL; + if(!PyArg_ParseTuple(args, "O|O:SHCreateShellItemArrayFromShellItem", &obsi, &obiid)) + return NULL; + // @pyparm <o PyIDataObject>|do|| + if (!PyCom_InterfaceFromPyInstanceOrObject(obsi, IID_IShellItem, (void **)&isi, FALSE/* bNoneOK */)) + goto done; + // @pyparm <o PyIID>|iid|IID_IShellItem|The IID to query for + if (obiid != Py_None && !PyWinObject_AsIID(obiid, &iid)) + goto done; + HRESULT hr; + PY_INTERFACE_PRECALL; + hr = (*pfnSHCreateShellItemArrayFromShellItem)(isi, iid, &iret); + PY_INTERFACE_POSTCALL; + if (FAILED(hr)) { + PyCom_BuildPyException(hr); + goto done; + } + // ref on view consumed by ret object. + ret = PyCom_PyObjectFromIUnknown((IUnknown *)iret, iid, FALSE); + done: + if (isi) { + PY_INTERFACE_PRECALL; + isi->Release(); + PY_INTERFACE_POSTCALL; + } + return ret; + } + /* List of module functions */ *************** *** 2320,2327 **** --- 2849,2865 ---- { { "AssocCreate", PyAssocCreate, 1 }, // @pymeth AssocCreate|Creates a <o PyIQueryAssociations> object + { "AssocCreateForClasses", PyAssocCreateForClasses, 1}, // @pymeth AssocCreateForClasses|Retrieves an object that implements an IQueryAssociations interface."} { "DragQueryFile", PyDragQueryFile, 1 }, // @pymeth DragQueryFile|Retrieves the file names of dropped files that have resulted from a successful drag-and-drop operation. { "DragQueryFileW", PyDragQueryFileW, 1 }, // @pymeth DragQueryFileW|Retrieves the file names of dropped files that have resulted from a successful drag-and-drop operation. { "DragQueryPoint", PyDragQueryPoint, 1}, // @pymeth DragQueryPoint|Retrieves the position of the mouse pointer at the time a file was dropped during a drag-and-drop operation. { "IsUserAnAdmin", PyIsUserAnAdmin, METH_VARARGS}, // @pymeth IsUserAnAdmin|Tests whether the current user is a member of the Administrator's group. + { "SHCreateDataObject", PySHCreateDataObject, 1}, // @pymeth SHCreateDataObject|Creates a data object in a parent folder. + { "SHCreateDefaultContextMenu", PySHCreateDefaultContextMenu, 1}, // @pymeth SHCreateDefaultContextMenu| + { "SHCreateDefaultExtractIcon", PySHCreateDefaultExtractIcon, 1}, // @pymeth SHCreateDefaultExtractIcon|Creates a standard icon extractor, whose defaults can be further configured via the IDefaultExtractIconInit interface. + { "SHCreateShellFolderView", PySHCreateShellFolderView, 1}, // @pymeth SHCreateShellFolderView| + { "SHCreateShellItemArray", PySHCreateShellItemArray, 1}, // @pymeth SHCreateShellItemArray| + { "SHCreateShellItemArrayFromDataObject", PySHCreateShellItemArrayFromDataObject, 1}, // @pymeth SHCreateShellItemArrayFromDataObject| + { "SHCreateShellItemArrayFromIDLists", PySHCreateShellItemArrayFromIDLists, 1}, // @pymeth SHCreateShellItemArrayFromIDLists| + { "SHCreateShellItemArrayFromShellItem", PySHCreateShellItemArrayFromIDLists, 1}, // @pymeth SHCreateShellItemArrayFromIDLists| { "SHGetPathFromIDList", PySHGetPathFromIDList, 1 }, // @pymeth SHGetPathFromIDList|Converts an <o PyIDL> to a path. { "SHGetPathFromIDListW", PySHGetPathFromIDListW, 1 }, // @pymeth SHGetPathFromIDListW|Converts an <o PyIDL> to a unicode path. *************** *** 2331,2334 **** --- 2869,2873 ---- { "SHSetFolderPath", PySHSetFolderPath, 1 }, // @pymeth SHSetFolderPath|Sets the location of a special folder { "SHGetFolderLocation", PySHGetFolderLocation, 1 }, // @pymeth SHGetFolderLocation|Retrieves the <o PyIDL> of a folder. + { "SHGetNameFromIDList", PySHGetNameFromIDList, 1}, // @pymeth SHGetNameFromIDList|Retrieves the display name of an item from an ID list. { "SHGetSpecialFolderPath", PySHGetSpecialFolderPath, 1 }, // @pymeth SHGetSpecialFolderPath|Retrieves the path of a special folder. { "SHGetSpecialFolderLocation", PySHGetSpecialFolderLocation, 1 }, // @pymeth SHGetSpecialFolderLocation|Retrieves the <o PyIDL> of a special folder. *************** *** 2372,2375 **** --- 2911,2915 ---- PYCOM_INTERFACE_FULL(ShellExtInit), PYCOM_INTERFACE_FULL(ShellFolder), + PYCOM_INTERFACE_FULL(ShellFolder2), PYCOM_INTERFACE_FULL(ShellIcon), PYCOM_INTERFACE_FULL(ShellIconOverlay), *************** *** 2379,2385 **** --- 2919,2930 ---- PYCOM_INTERFACE_FULL(ShellBrowser), PYCOM_INTERFACE_FULL(EnumIDList), + PYCOM_INTERFACE_FULL(EnumExplorerCommand), PYCOM_INTERFACE_FULL(BrowserFrameOptions), PYCOM_INTERFACE_FULL(PersistFolder), + PYCOM_INTERFACE_FULL(PersistFolder2), + PYCOM_INTERFACE_SERVER_ONLY(Categorizer), + PYCOM_INTERFACE_FULL(CategoryProvider), PYCOM_INTERFACE_FULL(ColumnProvider), + PYCOM_INTERFACE_CLIENT_ONLY(DefaultExtractIconInit), PYCOM_INTERFACE_FULL(DropTargetHelper), PYCOM_INTERFACE_CLIENT_ONLY(EmptyVolumeCacheCallBack), *************** *** 2392,2395 **** --- 2937,2941 ---- PYCOM_INTERFACE_FULL(ExplorerBrowserEvents), PYCOM_INTERFACE_FULL(ExplorerCommand), + PYCOM_INTERFACE_SERVER_ONLY(ExplorerCommandProvider), // IID_ICopyHook doesn't exist - hack it up { &IID_IShellCopyHook, "IShellCopyHook", "IID_IShellCopyHook", &PyICopyHook::type, GET_PYGATEWAY_CTOR(PyGCopyHook) }, *************** *** 2459,2462 **** --- 3005,3018 ---- pfnSHShellFolderView_Message=(PFNSHShellFolderView_Message)GetProcAddress(shell32, "SHShellFolderView_Message"); pfnIsUserAnAdmin=(PFNIsUserAnAdmin)GetProcAddress(shell32, "IsUserAnAdmin"); + pfnSHCreateShellFolderView=(PFNSHCreateShellFolderView)GetProcAddress(shell32, "SHCreateShellFolderView"); + pfnSHCreateDefaultExtractIcon=(PFNSHCreateDefaultExtractIcon)GetProcAddress(shell32, "SHCreateDefaultExtractIcon"); + pfnSHGetNameFromIDList=(PFNSHGetNameFromIDList)GetProcAddress(shell32, "SHGetNameFromIDList"); + pfnAssocCreateForClasses=(PFNAssocCreateForClasses)GetProcAddress(shell32, "AssocCreateForClasses"); + pfnSHCreateShellItemArray=(PFNSHCreateShellItemArray)GetProcAddress(shell32, "SHCreateShellItemArray"); + pfnSHCreateShellItemArrayFromDataObject=(PFNSHCreateShellItemArrayFromDataObject)GetProcAddress(shell32, "SHCreateShellItemArrayFromDataObject"); + pfnSHCreateShellItemArrayFromIDLists=(PFNSHCreateShellItemArrayFromIDLists)GetProcAddress(shell32, "SHCreateShellItemArrayFromIDLists"); + pfnSHCreateShellItemArrayFromShellItem=(PFNSHCreateShellItemArrayFromShellItem)GetProcAddress(shell32, "SHCreateShellItemArrayFromShellItem"); + pfnSHCreateDefaultContextMenu=(PFNSHCreateDefaultContextMenu)GetProcAddress(shell32, "SHCreateDefaultContextMenu"); + pfnSHCreateDataObject=(PFNSHCreateDataObject)GetProcAddress(shell32, "SHCreateDataObject"); } // SHGetFolderPath comes from shfolder.dll on older systems --- NEW FILE: PyICategorizer.h --- // This file declares the ICategorizer Interface and Gateway for Python. // Generated by makegw.py // --------------------------------------------------- // // Gateway Declaration class PyGCategorizer : public PyGatewayBase, public ICategorizer { protected: PyGCategorizer(PyObject *instance) : PyGatewayBase(instance) { ; } PYGATEWAY_MAKE_SUPPORT2(PyGCategorizer, ICategorizer, IID_ICategorizer, PyGatewayBase) // ICategorizer STDMETHOD(GetDescription)( __RPC__out_ecount_full_string(cch) LPWSTR pszDesc, UINT cch); STDMETHOD(GetCategory)( UINT cidl, __RPC__in_ecount_full(cidl) PCUITEMID_CHILD_ARRAY apidl, __RPC__out_ecount_full(cidl) DWORD * rgCategoryIds); STDMETHOD(GetCategoryInfo)( DWORD dwCategoryId, __RPC__out CATEGORY_INFO * pci); STDMETHOD(CompareCategory)( CATSORT_FLAGS csfFlags, DWORD dwCategoryId1, DWORD dwCategoryId2); }; --- NEW FILE: PyIPersistFolder2.cpp --- // This file implements the IPersistFolder2 Interface and Gateway for Python. // Generated by makegw.py #include "shell_pch.h" #include "PyIPersist.h" #include "PyIPersistFolder.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation PyIPersistFolder2::PyIPersistFolder2(IUnknown *pdisp): PyIPersistFolder(pdisp) { ob_type = &type; } PyIPersistFolder2::~PyIPersistFolder2() { } /* static */ IPersistFolder2 *PyIPersistFolder2::GetI(PyObject *self) { return (IPersistFolder2 *)PyIPersistFolder::GetI(self); } // @pymethod |PyIPersistFolder2|GetCurFolder|Description of GetCurFolder. PyObject *PyIPersistFolder2::GetCurFolder(PyObject *self, PyObject *args) { IPersistFolder2 *pIPF2 = GetI(self); if ( pIPF2 == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":GetCurFolder") ) return NULL; HRESULT hr; PIDLIST_ABSOLUTE pidl; PY_INTERFACE_PRECALL; hr = pIPF2->GetCurFolder( &pidl ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIPF2, IID_IPersistFolder2 ); return PyObject_FromPIDL(pidl, TRUE); } // @object PyIPersistFolder2|Description of the interface static struct PyMethodDef PyIPersistFolder2_methods[] = { { "GetCurFolder", PyIPersistFolder2::GetCurFolder, 1 }, // @pymeth GetCurFolder|Description of GetCurFolder { NULL } }; PyComTypeObject PyIPersistFolder2::type("PyIPersistFolder2", &PyIPersistFolder::type, sizeof(PyIPersistFolder2), PyIPersistFolder2_methods, GET_PYCOM_CTOR(PyIPersistFolder2)); // --------------------------------------------------- // // Gateway Implementation STDMETHODIMP PyGPersistFolder2::GetClassID(CLSID __RPC_FAR *pClassID) {return PyGPersistFolder::GetClassID(pClassID);} STDMETHODIMP PyGPersistFolder2::Initialize(LPCITEMIDLIST pidl) {return PyGPersistFolder::Initialize(pidl);} STDMETHODIMP PyGPersistFolder2::GetCurFolder( /* [out] */ PIDLIST_ABSOLUTE * ppidl) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr=InvokeViaPolicy("GetCurFolder", &result); if (FAILED(hr)) return hr; // Process the Python results, and convert back to the real params if (!PyObject_AsPIDL(result, ppidl, TRUE)) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCurFolder"); else hr = *ppidl ? S_OK : S_FALSE; // this is what the docs say! Py_DECREF(result); return hr; } --- NEW FILE: PyIExplorerCommandProvider.h --- // This file declares the IExplorerCommandProvider Interface and Gateway for Python. // Generated by makegw.py // --------------------------------------------------- // // Gateway Declaration class PyGExplorerCommandProvider : public PyGatewayBase, public IExplorerCommandProvider { protected: PyGExplorerCommandProvider(PyObject *instance) : PyGatewayBase(instance) { ; } PYGATEWAY_MAKE_SUPPORT2(PyGExplorerCommandProvider, IExplorerCommandProvider, IID_IExplorerCommandProvider, PyGatewayBase) // IExplorerCommandProvider STDMETHOD(GetCommands)( __RPC__in_opt IUnknown * punkSite, __RPC__in REFIID riid, __RPC__deref_out_opt void ** ppv); STDMETHOD(GetCommand)( __RPC__in REFGUID rguidCommandId, __RPC__in REFIID riid, __RPC__deref_out_opt void ** ppv); }; --- NEW FILE: PyIExplorerCommandProvider.cpp --- // This file implements the IExplorerCommandProvider Interface and Gateway for Python. // Generated by makegw.py #include "shell_pch.h" #include "PyIExplorerCommandProvider.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Gateway Implementation STDMETHODIMP PyGExplorerCommandProvider::GetCommands( /* [in] */ __RPC__in_opt IUnknown * punkSite, /* [in] */ __RPC__in REFIID riid, /* [iid_is][out] */ __RPC__deref_out_opt void ** ppv) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr=InvokeViaPolicy("GetCommands", &result, "NN", PyCom_PyObjectFromIUnknown(punkSite, IID_IUnknown, TRUE), PyWinObject_FromIID(riid)); if (FAILED(hr)) return hr; // Process the Python results, and convert back to the real params if (!PyCom_InterfaceFromPyInstanceOrObject(result, riid, ppv, FALSE /* bNoneOK */)) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCommands"); Py_DECREF(result); return hr; } STDMETHODIMP PyGExplorerCommandProvider::GetCommand( /* [in] */ __RPC__in REFGUID rguidCommandId, /* [in] */ __RPC__in REFIID riid, /* [iid_is][out] */ __RPC__deref_out_opt void ** ppv) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr=InvokeViaPolicy("GetCommand", &result, "NN", PyWinObject_FromIID(rguidCommandId), PyWinObject_FromIID(riid)); if (FAILED(hr)) return hr; if (!PyCom_InterfaceFromPyInstanceOrObject(result, riid, ppv, FALSE /* bNoneOK */)) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCommand"); Py_DECREF(result); return hr; } --- NEW FILE: PyICategorizer.cpp --- // This file implements the ICategorizer Interface and Gateway for Python. // Generated by makegw.py #include "shell_pch.h" #include "PyICategorizer.h" // @doc - This file contains autoduck documentation // --------------------------------------------------- // // Interface Implementation // --------------------------------------------------- // // Gateway Implementation STDMETHODIMP PyGCategorizer::GetDescription( /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPWSTR pszDesc, /* [in] */ UINT cch) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr=InvokeViaPolicy("GetDescription", &result, "i", cch); if (FAILED(hr)) return hr; // ack - should be a function to convert directly into a buffer. WCHAR *allocd_result; if (!PyWinObject_AsWCHAR(result, &allocd_result, FALSE)) { hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetDescription"); } else { wcsncpy(pszDesc, allocd_result, cch); PyWinObject_FreeWCHAR(allocd_result); } Py_DECREF(result); return hr; } STDMETHODIMP PyGCategorizer::GetCategory( /* [in] */ UINT cidl, /* [size_is][in] */ __RPC__in_ecount_full(cidl) PCUITEMID_CHILD_ARRAY apidl, /* [size_is][out] */ __RPC__out_ecount_full(cidl) DWORD * rgCategoryIds) { static const char *method_name = "GetCategory"; PY_GATEWAY_METHOD; PyObject *obapidl = PyList_New(cidl); if (!obapidl) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name); for (UINT i=0;i<cidl;i++) { PyObject *obpidl = PyObject_FromPIDL(apidl[i], FALSE); if (obpidl) { Py_DECREF(obapidl); return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name); } PyList_SET_ITEM(obapidl, i, obpidl); } PyObject *result; HRESULT hr=InvokeViaPolicy("GetCategory", &result, "O", obapidl); Py_DECREF(obapidl); if (FAILED(hr)) return hr; PyObject *dwords_tuple; DWORD ret_cnt; if ((dwords_tuple=PyWinSequence_Tuple(result, &ret_cnt))==NULL) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name); else { if (ret_cnt != cidl) { PyErr_Format(PyExc_ValueError, "expecting sequence of length %d, got %d", cidl, ret_cnt); hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name); } else { for (DWORD tuple_index=0; tuple_index<cidl; tuple_index++){ PyObject *tuple_item=PyTuple_GET_ITEM(dwords_tuple,tuple_index); rgCategoryIds[tuple_index]=PyInt_AsLong(tuple_item); if ((rgCategoryIds[tuple_index]==-1) && PyErr_Occurred()){ hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name); break; } } } } Py_DECREF(result); return hr; } STDMETHODIMP PyGCategorizer::GetCategoryInfo( /* [in] */ DWORD dwCategoryId, /* [out] */ __RPC__out CATEGORY_INFO * pci) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr=InvokeViaPolicy("GetCategoryInfo", &result, "l", dwCategoryId); if (FAILED(hr)) return hr; PyObject *obName; if (!PyArg_ParseTuple(result, "iO", &pci->cif, &obName)) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCategory"); else { WCHAR *allocd_result; if (!PyWinObject_AsWCHAR(obName, &allocd_result, FALSE)) { hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCategoryInfo"); } else { wcsncpy(pci->wszName, allocd_result, sizeof(pci->wszName)/sizeof(pci->wszName[0])); PyWinObject_FreeWCHAR(allocd_result); } } // Process the Python results, and convert back to the real params Py_DECREF(result); return hr; } STDMETHODIMP PyGCategorizer::CompareCategory( /* [in] */ CATSORT_FLAGS csfFlags, /* [in] */ DWORD dwCategoryId1, /* [in] */ DWORD dwCategoryId2) { PY_GATEWAY_METHOD; PyObject *result; HRESULT hr=InvokeViaPolicy("CompareCategory", &result, "lll", csfFlags, dwCategoryId1, dwCategoryId2); if (FAILED(hr)) return hr; if (!PyInt_Check(result)) { PyErr_Format(PyExc_TypeError, "CompareCategory expects an int, got a %s", result->ob_type->tp_name); hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCategory"); } else { hr = MAKE_HRESULT(SEVERITY_SUCCESS, 0, (USHORT)PyInt_AsLong(result)); } Py_DECREF(result); return hr; } --- NEW FILE: PyIDefaultExtractIconInit.h --- // This file declares the IDefaultExtractIconInit Interface and Gateway for Python. // Generated by makegw.py // --------------------------------------------------- // // Interface Declaration class PyIDefaultExtractIconInit : public PyIUnknown { public: MAKE_PYCOM_CTOR(PyIDefaultExtractIconInit); static IDefaultExtractIconInit *GetI(PyObject *self); static PyComTypeObject type; // The Python methods static PyObject *SetFlags(PyObject *self, PyObject *args); static PyObject *SetKey(PyObject *self, PyObject *args); static PyObject *Se... [truncated message content] |
