// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP_(UINT) PyGCopyHookW::CopyCallback(
/* [unique][in] */ HWND hwnd,
/* [unique][in] */ UINT wFunc,
/* [unique][in] */ UINT wFlags,
/* [unique][in] */ LPCWSTR srcFile,
/* [unique][in] */ DWORD srcAttribs,
/* [unique][in] */ LPCWSTR destFile,
/* [unique][in] */ DWORD destAttribs)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("CopyCallback", &result, "NiiNlNl",
PyWinLong_FromHANDLE(hwnd),
wFunc,
wFlags,
PyWinObject_FromWCHAR(srcFile),
srcAttribs,
PyWinObject_FromWCHAR(destFile),
destAttribs);
if (FAILED(hr)) return hr;
hr = PyInt_AsLong(result);
if ((hr==-1) && PyErr_Occurred())
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("CopyCallBack");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGCategoryProvider::GetCategoryForSCID(
/* [in] */ __RPC__in const SHCOLUMNID * pscid,
/* [out] */ __RPC__out GUID * pguid)
{
PY_GATEWAY_METHOD;
PyObject *obpscid = PyObject_FromSHCOLUMNID(pscid);
if (obpscid==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCategoryForSCID");
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetCategoryForSCID", &result, "(O)", obpscid);
Py_DECREF(obpscid);
if (FAILED(hr)) return hr;
if (!PyWinObject_AsIID(result, pguid))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCategoryForSCID");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGPropertyStorage::WritePropertyNames(
/* [in] */ ULONG cpropid,
/* [size_is][in] */ const PROPID rgpropid[],
/* [size_is][in] */ const LPOLESTR rglpwstrName[])
{
PY_GATEWAY_METHOD;
{ // Scope so Tmp objects are DECREF'ed before lock released
TmpPyObject obpropids = PyWinObject_FromPROPIDs(rgpropid, cpropid);
if (obpropids==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("WritePropertyNames");
TmpPyObject obnames = PyWinObject_FromWCHARArray(rglpwstrName, cpropid);
if (obnames==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("WritePropertyNames");
return InvokeViaPolicy("WritePropertyNames", NULL, "OO", obpropids, obnames);
}
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGExtractIcon::Extract(
/* [unique][in] */ LPCSTR pszFile,
/* [unique][in] */ UINT nIconIndex,
/* [out] */ HICON * phiconLarge,
/* [out] */ HICON * phiconSmall,
/* [unique][in] */ UINT nIconSize)
{
PY_GATEWAY_METHOD;
PyObject *obpszFile;
obpszFile = PyString_FromString(pszFile);
PyObject *result;
HRESULT hr=InvokeViaPolicy("Extract", &result, "Oii", obpszFile, nIconIndex, nIconSize);
Py_XDECREF(obpszFile);
if (FAILED(hr)) return hr;
if (PyInt_Check(result) || PyLong_Check(result))
hr = PyInt_AsLong(result);
else {
PyObject *oblarge, *obsmall;
if (PyArg_ParseTuple(result, "OO", &oblarge, &obsmall) &&
PyWinObject_AsHANDLE(oblarge, (HANDLE *)phiconLarge) &&
PyWinObject_AsHANDLE(obsmall, (HANDLE *)phiconSmall)) {
// we worked - no error should be present!
assert(!PyErr_Occurred());
}
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("Extract");
}
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGExtractIcon::GetIconLocation(
/* [unique][in] */ UINT uFlags,
/* [unique][out] */ LPSTR szIconFile,
/* [unique][in] */ UINT cchMax,
/* [unique][out] */ LPINT piIndex,
/* [unique][out] */ UINT *pflags)
{
PY_GATEWAY_METHOD;
if (cchMax && szIconFile)
szIconFile[0] = 0;
*piIndex = 0;
*pflags = 0;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetIconLocation", &result, "i", uFlags);
if (FAILED(hr)) return hr;
PyObject *obFileName;
// Process the Python results, and convert back to the real params
if (PyInt_Check(result) || PyLong_Check(result))
hr = PyInt_AsLong(result);
else {
if (PyArg_ParseTuple(result, "Oii", &obFileName, piIndex, pflags)) {
char *filename;
if (PyWinObject_AsString(obFileName, &filename)) {
strncpy(szIconFile, filename, cchMax);
PyWinObject_FreeString(filename);
}
}
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetIconLocation");
}
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGLockBytes::ReadAt(
/* [in] */ ULARGE_INTEGER ulOffset,
/* [in] */ void __RPC_FAR * pv,
/* [in] */ ULONG cb,
/* [out] */ ULONG __RPC_FAR * pcbRead)
{
if (pv==NULL) return E_POINTER;
if (pcbRead) *pcbRead = 0;
PY_GATEWAY_METHOD;
PyObject *obulOffset = PyWinObject_FromULARGE_INTEGER(ulOffset);
PyObject *result;
HRESULT hr=InvokeViaPolicy("ReadAt", &result, "Oi", obulOffset, cb);
Py_XDECREF(obulOffset);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
// Length of returned object must fit in buffer !
DWORD resultlen;
VOID *buf;
if (PyWinObject_AsReadBuffer(result, &buf, &resultlen, FALSE)){
if (resultlen > cb)
PyErr_SetString(PyExc_ValueError,"PyGLockBytes::ReadAt: returned data longer than requested");
else{
memcpy(pv, buf, resultlen);
if (pcbRead)
*pcbRead = resultlen;
hr = S_OK;
}
}
Py_DECREF(result);
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("Read");
}
STDMETHODIMP PyGShellItemResources::GetResourceDescription(
/* [in] */ const SHELL_ITEM_RESOURCE * pcsir,
/* [out] */ LPWSTR * ppszDescription)
{
PY_GATEWAY_METHOD;
PyObject *obpcsir = PyWinObject_FromSHELL_ITEM_RESOURCE(pcsir);
if (obpcsir==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetResourceDescription");
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetResourceDescription", &result, "O", obpcsir);
Py_DECREF(obpcsir);
if (FAILED(hr)) return hr;
// ??? Docs do not specify memory semantics, but this seems to work ... ???
if (!PyWinObject_AsTaskAllocatedWCHAR(result, ppszDescription, FALSE))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetResourceDescription");
Py_DECREF(result);
return hr;
}
ULONG PyGMAPIAdviseSink::OnNotify(ULONG cNotif, LPNOTIFICATION lpNotifications )
{
PY_GATEWAY_METHOD;
PyObject *arg = PyList_New(cNotif);
if (!arg)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("OnNotify");
ULONG i;
for (i=0;i<cNotif;i++) {
PyObject *sub = PyObject_FromNOTIFICATION(lpNotifications+i);
if (!sub) {
Py_DECREF(arg);
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("OnNotify");
}
PyList_SET_ITEM(arg, i, sub);
}
return InvokeViaPolicy("OnNotify", NULL, "(N)", arg);
}
STDMETHODIMP PyGShellBrowser::QueryActiveShellView(
/* [out] */ IShellView ** ppshv)
{
static const char *method_name = "QueryActiveShellView";
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy(method_name, &result);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppshv;
if (!PyArg_Parse(result, "O" , &obppshv)) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppshv, IID_IShellView, (void **)ppshv, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
Py_DECREF(result);
return hr;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGPropertyStoreCapabilities::IsPropertyWritable(REFPROPERTYKEY key)
{
PY_GATEWAY_METHOD;
PyObject *obkey = PyWinObject_FromPROPERTYKEY(key);
if (obkey==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("IsPropertyWritable");
HRESULT hr=InvokeViaPolicy("IsPropertyWritable", NULL, "(O)", obkey);
Py_DECREF(obkey);
return hr;
}
STDMETHODIMP PyGShellItem::GetParent(
/* [out] */ IShellItem ** ppsi)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetParent", &result);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppsi;
if (!PyArg_Parse(result, "O" , &obppsi))
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetParent");
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppsi, IID_IShellItem, (void **)ppsi, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetParent");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGPropertyDescriptionList::GetAt(
UINT iElem,
REFIID riid,
void ** ppv)
{
PY_GATEWAY_METHOD;
PyObject *obriid = PyWinObject_FromIID(riid);
if (obriid==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetAt");
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetAt", &result, "kO", iElem, obriid);
Py_DECREF(obriid);
if (FAILED(hr)) return hr;
if (!PyCom_InterfaceFromPyObject(result, riid, ppv, FALSE))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetAt");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGDataObject::EnumDAdvise(
/* [out] */ IEnumSTATDATA ** ppenumAdvise)
{
static const char *method_name = "EnumDAdvise";
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy(method_name, &result);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppenumAdvise;
if (!PyArg_Parse(result, "O" , &obppenumAdvise)) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppenumAdvise, IID_IEnumSTATDATA, (void **)ppenumAdvise, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGInternetSecurityManager::GetZoneMappings(
/* [in] */ DWORD dwZone,
/* [out] */ IEnumString ** ppenumString,
/* [in] */ DWORD dwFlags)
{
PY_GATEWAY_METHOD;
if (ppenumString==NULL) return E_POINTER;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetZoneMappings", &result, "ll", dwZone, dwFlags);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppenumString;
if (!PyArg_Parse(result, "O" , &obppenumString))
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetZoneMappings");
if (!PyCom_InterfaceFromPyInstanceOrObject(obppenumString, IID_IEnumString, (void **)ppenumString, TRUE /* bNoneOK */))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetZoneMappings");
Py_DECREF(result);
return hr;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGPropertyStorage::ReadMultiple(
/* [in] */ ULONG cpspec,
/* [size_is][in] */ const PROPSPEC rgpspec[],
/* [size_is][out] */ PROPVARIANT rgpropvar[])
{
PY_GATEWAY_METHOD;
PyObject *obpropspecs = PyWinObject_FromPROPSPECs(rgpspec, cpspec);
if (obpropspecs==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("ReadMultiple");
PyObject *result;
HRESULT hr=InvokeViaPolicy("ReadMultiple", &result, "(O)", obpropspecs);
Py_DECREF(obpropspecs);
if (FAILED(hr))
return hr;
if (!PyObject_AsPreallocatedPROPVARIANTs(result, rgpropvar, cpspec))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("ReadMultiple");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGPropertyStorage::WriteMultiple(
/* [in] */ ULONG cpspec,
/* [size_is][in] */ const PROPSPEC rgpspec[],
/* [size_is][in] */ const PROPVARIANT rgpropvar[],
/* [in] */ PROPID propidNameFirst)
{
PY_GATEWAY_METHOD;
HRESULT hr;
{
TmpPyObject obpropspecs = PyWinObject_FromPROPSPECs(rgpspec, cpspec);
if (obpropspecs==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("WriteMultiple");
TmpPyObject obpropvars = PyObject_FromPROPVARIANTs((PROPVARIANT *)rgpropvar, cpspec);
if (obpropvars==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("WriteMultiple");
hr=InvokeViaPolicy("WriteMultiple", NULL, "OOk", obpropspecs, obpropvars, propidNameFirst);
}
return hr;
}
STDMETHODIMP PyGShellItemResources::SupportsResource(
/* [in] */ const SHELL_ITEM_RESOURCE * pcsir)
{
PY_GATEWAY_METHOD;
PyObject *obpcsir = PyWinObject_FromSHELL_ITEM_RESOURCE(pcsir);
if (obpcsir==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("SupportsResource");
HRESULT hr=InvokeViaPolicy("SupportsResource", NULL, "O", obpcsir);
Py_DECREF(obpcsir);
return hr;
}
STDMETHODIMP PyGShellBrowser::GetViewStateStream(
/* [in] */ DWORD grfMode,
/* [out] */ IStream ** ppStrm)
{
static const char *method_name = "GetViewStateStream";
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy(method_name, &result, "l", grfMode);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppStrm;
if (!PyArg_Parse(result, "O" , &obppStrm)) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppStrm, IID_IStream, (void **)ppStrm, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGDataObject::SetData(
/* [unique][in] */ FORMATETC * pformatetc,
/* [unique][in] */ STGMEDIUM * pmedium,
/* [in] */ BOOL fRelease)
{
static const char *method_name = "SetData";
PY_GATEWAY_METHOD;
PyObject *obpformatetc = PyObject_FromFORMATETC(pformatetc);
if (obpformatetc==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
PySTGMEDIUM *obmedium = PyObject_FromSTGMEDIUM(pmedium);
if (obmedium==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
// PySTGMEDIUM should be the exact same pointer as PyObject
assert((void *)(PyObject *)obmedium==(void *)obmedium);
HRESULT hr=InvokeViaPolicy(method_name, NULL, "OOi", obpformatetc, (PyObject *)obmedium, fRelease);
if (!fRelease)
obmedium->DropOwnership();
Py_DECREF(obpformatetc);
Py_DECREF(obmedium);
return hr;
}
STDMETHODIMP PyGDataObject::QueryGetData(
/* [unique][in] */ FORMATETC * pformatetc)
{
static const char *method_name = "QueryGetData";
PY_GATEWAY_METHOD;
PyObject *obpformatetc = PyObject_FromFORMATETC(pformatetc);
if (obpformatetc==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
HRESULT hr=InvokeViaPolicy(method_name, NULL, "(O)", obpformatetc);
Py_DECREF(obpformatetc);
return hr;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGInitializeWithFile::Initialize(
LPCWSTR pszFilePath,
DWORD grfMode)
{
PY_GATEWAY_METHOD;
PyObject *obpath = PyWinObject_FromWCHAR(pszFilePath);
if (obpath==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("Initialize");
HRESULT hr=InvokeViaPolicy("Initialize", NULL, "Ok", obpath, grfMode);
Py_DECREF(obpath);
return hr;
}
STDMETHODIMP PyGPropertyStorage::ReadPropertyNames(
/* [in] */ ULONG cpropid,
/* [size_is][in] */ const PROPID rgpropid[],
/* [size_is][out] */ LPOLESTR rglpwstrName[])
{
PY_GATEWAY_METHOD;
PyObject *obpropids = PyWinObject_FromPROPIDs(rgpropid, cpropid);
if (obpropids==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("ReadPropertyNames");
PyObject *result;
HRESULT hr=InvokeViaPolicy("ReadPropertyNames", &result, "O", obpropids);
Py_DECREF(obpropids);
if (FAILED(hr))
return hr;
// Process the Python results, and convert back to the real params
if (!PyWinObject_AsTaskAllocatedWCHARArray(result, rglpwstrName, cpropid))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("ReadPropertyNames");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGShellView::GetCurrentInfo(
/* [out] */ LPFOLDERSETTINGS pfs)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetCurrentInfo", &result);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject_AsFOLDERSETTINGS(result, pfs);
Py_DECREF(result);
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCurrentInfo");
}
STDMETHODIMP PyGShellBrowser::TranslateAcceleratorSB(
/* [in] */ MSG * pmsg,
/* [in] */ WORD wID)
{
static const char *method_name = "TranslateAcceleratorSB";
PY_GATEWAY_METHOD;
PyObject *obpmsg = PyObject_FromMSG(pmsg);
if (obpmsg==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE(method_name);
HRESULT hr=InvokeViaPolicy(method_name, NULL, "OH", obpmsg, wID);
Py_DECREF(obpmsg);
return hr;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGRelatedItem::GetItemIDList(
/* [out] */ PIDLIST_ABSOLUTE * ppidl)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetItemIDList", &result);
if (FAILED(hr)) return hr;
if (!PyObject_AsPIDL(result, ppidl, FALSE))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetItemIDList");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGPropertyStorage::DeleteMultiple(
/* [in] */ ULONG cpspec,
/* [size_is][in] */ const PROPSPEC rgpspec[])
{
PY_GATEWAY_METHOD;
PyObject *obpropspecs = PyWinObject_FromPROPSPECs(rgpspec, cpspec);
if (obpropspecs==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("DeleteMultiple");
HRESULT hr=InvokeViaPolicy("DeleteMultiple", NULL, "O", cpspec);
Py_DECREF(obpropspecs);
return hr;
}
STDMETHODIMP PyGCategoryProvider::GetDefaultCategory(
/* [out] */ __RPC__out GUID * pguid,
/* [out] */ __RPC__out SHCOLUMNID * pscid)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetDefaultCategory", &result);
if (FAILED(hr)) return hr;
// GUID is documented by MSDN as unused - but the FolderView MSDN
// only sets *pguid (it sets 'pscid' - without the '*' - which has
// no effect!
PyObject *obguid, *obscid;
if (!PyArg_ParseTuple(result, "OO:GetDefaultCategory result", &obguid, &obscid))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetDefaultCategory");
else {
if (!PyWinObject_AsIID(obguid , pguid) || !PyObject_AsSHCOLUMNID(obscid, pscid))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetDefaultCategory");
}
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGPropertyStorage::DeletePropertyNames(
/* [in] */ ULONG cpropid,
/* [size_is][in] */ const PROPID rgpropid[])
{
PY_GATEWAY_METHOD;
PyObject *obpropids = PyWinObject_FromPROPIDs(rgpropid, cpropid);
if (obpropids==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("DeletePropertyNames");
HRESULT hr=InvokeViaPolicy("DeletePropertyNames", NULL, "O", obpropids);
Py_DECREF(obpropids);
return hr;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGPropertyDescriptionList::GetCount(UINT * pcElem)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetCount", &result);
if (FAILED(hr)) return hr;
*pcElem = PyLong_AsUnsignedLong(result);
if (*pcElem == (UINT)-1 && PyErr_Occurred())
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCount");
Py_DECREF(result);
return hr;
}
STDMETHODIMP PyGShellItemResources::CreateResource(
/* [in] */ const SHELL_ITEM_RESOURCE * pcsir,
/* [in] */ REFIID riid,
/* [out] */ void ** ppv)
{
PY_GATEWAY_METHOD;
PyObject *obpcsir = PyWinObject_FromSHELL_ITEM_RESOURCE(pcsir);
if (obpcsir==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("CreateResource");
if (ppv==NULL) return E_POINTER;
PyObject *obriid;
obriid = PyWinObject_FromIID(riid);
PyObject *result;
HRESULT hr=InvokeViaPolicy("CreateResource", &result, "OO", obpcsir, obriid);
Py_DECREF(obpcsir);
Py_XDECREF(obriid);
if (FAILED(hr)) return hr;
if (!PyCom_InterfaceFromPyObject(result, riid, ppv, FALSE))
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("OpenResource");
Py_DECREF(result);
return hr;
}
