// @pymethod int|PyIDropTarget|DragEnter|Called when an object is initially dragged into a window
// @rdesc Your implementation of this function should return a shellcon.DROPEFFECT_* value indicating if the object can be accepted
PyObject *PyIDropTarget::DragEnter(PyObject *self, PyObject *args)
{
IDropTarget *pIDT = GetI(self);
if ( pIDT == NULL )
return NULL;
// @pyparm <o PyIDataObject>|pDataObj||IDataObject interface that contains the object being dragged
// @pyparm int|grfKeyState||Combination of win32con.MK_* flags containing keyboard modifier state
POINTL pt;
PyObject *obpt;
// @pyparm (int, int)|pt||(x,y) Screen coordinates of cursor
PyObject *obpDataObj;
IDataObject *pDataObj;
DWORD grfKeyState;
DWORD dwEffect;
// @pyparm int|pdwEffect||shellcon.DROPEFFECT_* value
if ( !PyArg_ParseTuple(args, "OlOl:DragEnter", &obpDataObj, &grfKeyState, &obpt, &dwEffect) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpDataObj, IID_IDataObject, (void **)&pDataObj, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (bPythonIsHappy && !PyObject_AsPOINTL( obpt, &pt )) bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDT->DragEnter( pDataObj, grfKeyState, pt, &dwEffect );
if (pDataObj) pDataObj->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDT, IID_IDropTarget );
return PyInt_FromLong(dwEffect);
}
// @pymethod |PyIDebugApplication|HandleRuntimeError|Description of HandleRuntimeError.
PyObject *PyIDebugApplication::HandleRuntimeError(PyObject *self, PyObject *args)
{
IDebugApplication *pIDA = GetI(self);
if ( pIDA == NULL )
return NULL;
// @pyparm <o PyIActiveScriptErrorDebug>|pErrorDebug||Description for pErrorDebug
// @pyparm <o PyIActiveScriptSite>|pScriptSite||Description for pScriptSite
PyObject *obpErrorDebug;
PyObject *obpScriptSite;
IActiveScriptErrorDebug * pErrorDebug;
IActiveScriptSite * pScriptSite;
BREAKRESUMEACTION pbra;
ERRORRESUMEACTION perra;
BOOL pfCallOnScriptError;
if ( !PyArg_ParseTuple(args, "OO:HandleRuntimeError", &obpErrorDebug, &obpScriptSite) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpErrorDebug, IID_IActiveScriptErrorDebug, (void **)&pErrorDebug, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpScriptSite, IID_IActiveScriptSite, (void **)&pScriptSite, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDA->HandleRuntimeError( pErrorDebug, pScriptSite, &pbra, &perra, &pfCallOnScriptError );
if (pErrorDebug) pErrorDebug->Release();
if (pScriptSite) pScriptSite->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
PyObject *pyretval = Py_BuildValue("iii", pbra, perra, pfCallOnScriptError);
return pyretval;
}
// @pymethod (int, <o PyIShellItem>|PyITransferSource|RecycleItem|Moves an item to the recycle bin
PyObject *PyITransferSource::RecycleItem(PyObject *self, PyObject *args)
{
ITransferSource *pITS = GetI(self);
if ( pITS == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Source||The item to be recycled
// @pyparm <o PyIShellItem>|ParentDest||Shell item representing the recycle bin
TRANSFER_SOURCE_FLAGS flags;
// @pyparm int|flags||Combination of shellcon.TSF_* flags
PyObject *obpsiSource;
PyObject *obpsiParentDest;
IShellItem * psiSource;
IShellItem * psiParentDest;
IShellItem * ppsiNewDest;
if ( !PyArg_ParseTuple(args, "OOi:RecycleItem", &obpsiSource, &obpsiParentDest, &flags) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiSource, IID_IShellItem, (void **)&psiSource, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiParentDest, IID_IShellItem, (void **)&psiParentDest, FALSE)){
PYCOM_RELEASE(psiSource);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pITS->RecycleItem( psiSource, psiParentDest, flags, &ppsiNewDest );
psiSource->Release();
psiParentDest->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pITS, IID_ITransferSource );
return Py_BuildValue("lO", hr, PyCom_PyObjectFromIUnknown(ppsiNewDest, IID_IShellItem, FALSE));
}
STDMETHODIMP PyGEnumDebugStackFrames::Next(
/* [in] */ ULONG celt,
/* [length_is][size_is][out] */ DebugStackFrameDescriptor __RPC_FAR *rgVar,
/* [out] */ ULONG __RPC_FAR *pCeltFetched)
{
PY_GATEWAY_METHOD;
PyObject *result;
Py_ssize_t len;
HRESULT hr = InvokeViaPolicy("Next", &result, "i", celt);
if ( FAILED(hr) )
return hr;
if ( !PySequence_Check(result) )
goto error;
len = PyObject_Length(result);
if ( len == -1 )
goto error;
if ( len > (Py_ssize_t)celt)
len = celt;
if ( pCeltFetched )
*pCeltFetched = PyWin_SAFE_DOWNCAST(len, Py_ssize_t, ULONG);
Py_ssize_t i;
for ( i = 0; i < len; ++i )
{
PyObject *ob = PySequence_GetItem(result, i);
if ( ob == NULL )
goto error;
if (!PyTuple_Check(ob)) {
Py_DECREF(ob);
PyErr_SetString(PyExc_TypeError, "PyIEnumDebugStackFrames::Next must return a tuple.");
goto error;
}
PyObject *obEnum, *obUnk;
if (!PyArg_ParseTuple(ob, "OiiiO", &obEnum, &rgVar[i].dwMin, &rgVar[i].dwLim, &rgVar[i].fFinal, &obUnk)) {
Py_DECREF(ob);
goto error;
}
if ( !PyCom_InterfaceFromPyInstanceOrObject(obEnum, IID_IDebugStackFrame, (void **)&rgVar[i].pdsf, FALSE) ||
!PyCom_InterfaceFromPyInstanceOrObject(obUnk, IID_IUnknown, (void **)&rgVar[i].punkFinal, TRUE) )
{
Py_DECREF(ob);
Py_DECREF(result);
return PyCom_SetCOMErrorFromPyException(IID_IEnumDebugStackFrames);
}
Py_DECREF(ob);
}
Py_DECREF(result);
return len < (Py_ssize_t)celt ? S_FALSE : S_OK;
error:
hr = PyErr_Occurred() ? PyCom_SetCOMErrorFromPyException(IID_IEnumDebugStackFrames)
: PyCom_SetCOMErrorFromSimple(E_FAIL, IID_IEnumDebugStackFrames);
Py_DECREF(result);
return hr;
}
// @pymethod |PyINameSpaceTreeControl|AppendRoot|Description of AppendRoot.
PyObject *PyINameSpaceTreeControl::AppendRoot(PyObject *self, PyObject *args)
{
INameSpaceTreeControl *pINSTC = GetI(self);
if ( pINSTC == NULL )
return NULL;
// @pyparm <o PyIShellItem>|psiRoot||Description for psiRoot
// @pyparm int|grfEnumFlags||Description for grfEnumFlags
// @pyparm int|grfRootStyle||Description for grfRootStyle
// @pyparm <o PyIShellItemFilter>|pif||Description for pif
PyObject *obpsiRoot;
PyObject *obpif;
IShellItem * psiRoot;
DWORD grfEnumFlags;
DWORD grfRootStyle;
IShellItemFilter * pif;
if ( !PyArg_ParseTuple(args, "OkkO:AppendRoot", &obpsiRoot, &grfEnumFlags, &grfRootStyle, &obpif) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsiRoot, IID_IShellItem, (void **)&psiRoot, TRUE /* bNoneOK */))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpif, IID_IShellItemFilter, (void **)&pif, TRUE /* bNoneOK */)) {
if (pif) pif->Release();
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pINSTC->AppendRoot( psiRoot, grfEnumFlags, grfRootStyle, pif );
if (psiRoot) psiRoot->Release();
if (pif) pif->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pINSTC, IID_INameSpaceTreeControl );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod <o PyIUnknown>|PyIMoniker|BindToStorage|Retrieves an interface object to the storage that contains the object identified by the moniker.
PyObject *PyIMoniker::BindToStorage(PyObject *self, PyObject *args)
{
// @pyparm <o PyIBindCtx>|bindCtx||bind context object to be used.
// @pyparm <o PyIMoniker>|moniker||If the moniker is part of a composite moniker, otherwise None
// @pyparm <o IID>|iidResult||IID of the result object.
PyObject *obBindCtx;
PyObject *obMoniker;
PyObject *obIID;
if (!PyArg_ParseTuple(args, "OOO:BindToStorage", &obBindCtx, &obMoniker, &obIID))
return NULL;
IMoniker *pMy = GetI(self);
if (pMy==NULL) return NULL;
IBindCtx *pBindCtx;
if (!PyCom_InterfaceFromPyInstanceOrObject(obBindCtx, IID_IBindCtx, (void **)&pBindCtx, FALSE))
return NULL;
IMoniker *pMonLeft = NULL;
if (obMoniker!=Py_None) {
if (!PyCom_InterfaceFromPyInstanceOrObject(obMoniker, IID_IMoniker, (void **)&pMonLeft, FALSE)) {
PY_INTERFACE_PRECALL;
pBindCtx->Release();
PY_INTERFACE_POSTCALL;
return NULL;
}
}
IID iid;
if (!PyWinObject_AsIID(obIID, &iid)) {
PY_INTERFACE_PRECALL;
pBindCtx->Release();
if (pMonLeft) pMonLeft->Release();
PY_INTERFACE_POSTCALL;
return NULL;
}
void *pResult = NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pMy->BindToStorage(pBindCtx, pMonLeft, iid, &pResult );
pBindCtx->Release();
if (pMonLeft) pMonLeft->Release();
PY_INTERFACE_POSTCALL;
if (S_OK!=hr) // S_OK only acceptable
return PyCom_BuildPyException(hr, pMy, IID_IMoniker);
return PyCom_PyObjectFromIUnknown((IUnknown *)pResult, iid, FALSE );
}
// @pymethod |PyIFileOperation|CopyItem|Adds a copy operation to the configuration
PyObject *PyIFileOperation::CopyItem(PyObject *self, PyObject *args)
{
IFileOperation *pIFO = GetI(self);
if ( pIFO == NULL )
return NULL;
// @pyparm <o PyIShellItem>|Item||Item to be copied
// @pyparm <o PyIShellItem>|DestinationFolder||Folder into which it will be copied
// @pyparm str|CopyName|None|New name for the copied file, use None to keep original name
// @pyparm <o PyGFileOperationProgressSink>|Sink|None|Progress sink for just this operation
PyObject *obItem;
PyObject *obDestinationFolder;
PyObject *obCopyName = Py_None;
PyObject *obSink = Py_None;
IShellItem * pItem;
IShellItem * pDestinationFolder;
TmpWCHAR CopyName;
IFileOperationProgressSink * pSink;
if (!PyArg_ParseTuple(args, "OO|OO:CopyItem", &obItem, &obDestinationFolder, &obCopyName, &obSink))
return NULL;
if (!PyWinObject_AsWCHAR(obCopyName, &CopyName, TRUE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obItem, IID_IShellItem, (void **)&pItem, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obDestinationFolder, IID_IShellItem, (void **)&pDestinationFolder, FALSE)) {
PYCOM_RELEASE(pItem);
return NULL;
}
if (!PyCom_InterfaceFromPyInstanceOrObject(obSink, IID_IFileOperationProgressSink, (void **)&pSink, TRUE)) {
PYCOM_RELEASE(pItem);
PYCOM_RELEASE(pDestinationFolder);
return NULL;
}
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIFO->CopyItem( pItem, pDestinationFolder, CopyName, pSink);
pItem->Release();
pDestinationFolder->Release();
if (pSink)
pSink->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIFO, IID_IFileOperation );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIDebugApplication|FireDebuggerEvent|Fire a generic event to the IApplicationDebugger (if any)
PyObject *PyIDebugApplication::FireDebuggerEvent(PyObject *self, PyObject *args)
{
PY_INTERFACE_METHOD;
IDebugApplication *pIDA = GetI(self);
if ( pIDA == NULL )
return NULL;
// @pyparm <o PyIIID>|guid||A GUID.
// @pyparm <o PyIUnknown>|unknown||An unknown object.
PyObject *obguid, *obunk;
if ( !PyArg_ParseTuple(args, "OO:FireDebuggerEvent", &obguid, &obunk) )
return NULL;
BOOL bPythonIsHappy = TRUE;
IUnknown *punk;
IID iid;
if (!PyWinObject_AsIID(obguid, &iid))
bPythonIsHappy = FALSE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obunk, IID_IUnknown, (void **)&punk, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pIDA->FireDebuggerEvent( iid, punk );
punk->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod int|PyIDebugApplication|AddStackFrameSniffer|Adds a stack frame sniffer to this application.
PyObject *PyIDebugApplication::AddStackFrameSniffer(PyObject *self, PyObject *args)
{
PY_INTERFACE_METHOD;
// @comm Generally called by a language engine
// to expose its stack frames to the debugger. It is possible for other entities to
// expose stack frames.
IDebugApplication *pIDA = GetI(self);
if ( pIDA == NULL )
return NULL;
// @pyparm <o PyIDebugStackFrameSniffer>|pdsfs||Description for pdsfs
PyObject *obpdsfs;
IDebugStackFrameSniffer *pdsfs;
DWORD pdwCookie;
if ( !PyArg_ParseTuple(args, "O:AddStackFrameSniffer", &obpdsfs) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpdsfs, IID_IDebugStackFrameSniffer, (void **)&pdsfs, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pIDA->AddStackFrameSniffer( pdsfs, &pdwCookie );
pdsfs->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
PyObject *pyretval = Py_BuildValue("i", pdwCookie);
return pyretval;
// @rdesc The result is an integer cookie, to be passed to <om PyIDebugApplication.RemoveStackFrameSniffer>
}
// @pymethod interface|PyIShellItem|BindToHandler|Creates an instance of one of the item's handlers
PyObject *PyIShellItem::BindToHandler(PyObject *self, PyObject *args)
{
IShellItem *pISI = GetI(self);
if ( pISI == NULL )
return NULL;
// @pyparm <o PyIBindCtx>|pbc||Used to pass parameters that influence the binding operation, can be None
// @pyparm <o PyIID>|bhid||GUID that identifies a handler (shell.BHID_*)
// @pyparm <o PyIID>|riid||The interface to return
PyObject *obpbc;
PyObject *obbhid;
PyObject *obriid;
IBindCtx *pbc;
IID bhid;
IID riid;
void *pv;
if ( !PyArg_ParseTuple(args, "OOO:BindToHandler", &obpbc, &obbhid, &obriid) )
return NULL;
if (!PyWinObject_AsIID(obbhid, &bhid))
return NULL;
if (!PyWinObject_AsIID(obriid, &riid))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpbc, IID_IBindCtx, (void **)&pbc, TRUE /* bNoneOK */))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pISI->BindToHandler( pbc, bhid, riid, &pv );
if (pbc) pbc->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISI, IID_IShellItem );
return PyCom_PyObjectFromIUnknown((IUnknown *)pv, riid, FALSE);
}
// @pymethod int|PyIShellItem|Compare|Compares another shell item with this item
// @rdesc Returns 0 if items compare as equal, nonzero otherwise
PyObject *PyIShellItem::Compare(PyObject *self, PyObject *args)
{
IShellItem *pISI = GetI(self);
if ( pISI == NULL )
return NULL;
// @pyparm <o PyIShellItem>|psi||A shell item to be compared with this item
SICHINTF hint;
// @pyparm int|hint||shellcon.SICHINT_* value indicating how the comparison is to be performed
PyObject *obpsi;
IShellItem *psi;
if ( !PyArg_ParseTuple(args, "Oi:Compare", &obpsi, &hint) )
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsi, IID_IShellItem, (void **)&psi, FALSE))
return NULL;
HRESULT hr;
int iOrder;
PY_INTERFACE_PRECALL;
hr = pISI->Compare( psi, hint, &iOrder );
psi->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISI, IID_IShellItem );
return PyInt_FromLong(iOrder);
}
// @pymethod int|PyIConnectionPoint|Advise|Establishes a connection between the connection point object and the client's sink.
PyObject *PyIConnectionPoint::Advise(PyObject *self, PyObject *args)
{
PyObject *obUnk;
// @pyparm <o PyIUnknown>|unk||The client's advise sink
if ( !PyArg_ParseTuple(args, "O:Advise", &obUnk) )
return NULL;
IUnknown *pUnk;
if (!PyCom_InterfaceFromPyInstanceOrObject(obUnk, IID_IUnknown, (void **)&pUnk, FALSE))
return NULL;
IConnectionPoint *pICP = GetI(self);
if ( pICP == NULL )
return NULL;
DWORD cookie;
PY_INTERFACE_PRECALL;
HRESULT hr = pICP->Advise( pUnk, &cookie );
pUnk->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
// @rdesc The result is the connection point identifier used by <om PyIConnectionPoint::Unadvise>
return PyInt_FromLong(cookie);
}
// @pymethod |PyIMachineDebugManager|AddApplication|Description of AddApplication.
PyObject *PyIMachineDebugManager::AddApplication(PyObject *self, PyObject *args)
{
IMachineDebugManager *pIMDM = GetI(self);
if ( pIMDM == NULL )
return NULL;
// @pyparm <o PyIRemoteDebugApplication>|pda||Description for pda
PyObject *obpda;
if ( !PyArg_ParseTuple(args, "O:AddApplication", &obpda) )
return NULL;
IRemoteDebugApplication *pda;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpda, IID_IRemoteDebugApplication, (void **)&pda, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
DWORD dwAppCookie;
PY_INTERFACE_PRECALL;
HRESULT hr = pIMDM->AddApplication( pda, &dwAppCookie );
pda->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
PyObject *pyretval = Py_BuildValue("i", dwAppCookie);
return pyretval;
}
// @pymethod |PyIPersistStream|Load|Initializes an object from the stream where it was previously saved.
PyObject *PyIPersistStream::Load(PyObject *self, PyObject *args)
{
IPersistStream *pMy = GetI(self);
if (pMy==NULL) return NULL;
PyObject *obStream;
// @pyparm <o PyIStream>|stream||Stream object to load from.
if (!PyArg_ParseTuple(args, "O:Load", &obStream))
return NULL;
IStream *pStream;
if (!PyCom_InterfaceFromPyInstanceOrObject(obStream, IID_IStream, (void **)&pStream, FALSE /*bNoneOK*/))
return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pMy->Load(pStream);
pStream->Release();
PY_INTERFACE_POSTCALL;
if (FAILED(hr))
return PyCom_BuildPyException(hr, pMy, IID_IPersistStream);
Py_INCREF(Py_None);
return Py_None;
// @comm This method loads an object from its associated stream. The seek pointer is set as it was in the most recent <om PyIPersistStream.Save> method. This method can seek and read from the stream, but cannot write to it.
// @comm On exit, the seek pointer must be in the same position it was in on entry, immediately past the end of the data.
}
// @pymethod |PyIRemoteDebugApplicationEvents|OnBreakFlagChange|Description of OnBreakFlagChange.
PyObject *PyIRemoteDebugApplicationEvents::OnBreakFlagChange(PyObject *self, PyObject *args)
{
IRemoteDebugApplicationEvents *pIRDAE = GetI(self);
if ( pIRDAE == NULL )
return NULL;
// @pyparm int|abf||Description for abf
// @pyparm <o PyIRemoteDebugApplicationThread>|prdatSteppingThread||Description for prdatSteppingThread
PyObject *obprdatSteppingThread;
APPBREAKFLAGS abf;
IRemoteDebugApplicationThread *prdatSteppingThread;
if ( !PyArg_ParseTuple(args, "iO:OnBreakFlagChange", &abf, &obprdatSteppingThread) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obprdatSteppingThread, IID_IRemoteDebugApplicationThread, (void **)&prdatSteppingThread, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pIRDAE->OnBreakFlagChange( abf, prdatSteppingThread );
prdatSteppingThread->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod int|PyIDataObject|DAdvise|Connects the object to an interface that will receive notifications when its data changes
// @rdesc Returns a unique number that is used to identify the connection
PyObject *PyIDataObject::DAdvise(PyObject *self, PyObject *args)
{
IDataObject *pIDO = GetI(self);
if ( pIDO == NULL )
return NULL;
FORMATETC formatetc;
PyObject *obpformatetc;
// @pyparm <o PyFORMATETC>|pformatetc||Defines the type of data for which the sink will receive notifications.
// @pyparm int|advf||Combination of values from ADVF enum. (which currently do not appear in any of the constants modules!)
// @pyparm <o PyIAdviseSink>|pAdvSink||Currently this interface is not wrapped.
PyObject *obpAdvSink;
DWORD advf;
IAdviseSink *pAdvSink;
if ( !PyArg_ParseTuple(args, "OlO:DAdvise", &obpformatetc, &advf, &obpAdvSink) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyObject_AsFORMATETC( obpformatetc, &formatetc )) bPythonIsHappy = FALSE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpAdvSink, IID_IAdviseSink, (void **)&pAdvSink, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
DWORD dwConnection;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDO->DAdvise( &formatetc, advf, pAdvSink, &dwConnection );
PY_INTERFACE_POSTCALL;
if (pAdvSink) pAdvSink->Release();
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
return PyInt_FromLong(dwConnection);
}
// @pymethod |PyIContext|SetProperty|Sets a property on the context
PyObject *PyIContext::SetProperty(PyObject *self, PyObject *args)
{
IContext *pIC = GetI(self);
if ( pIC == NULL )
return NULL;
// @pyparm <o PyIID>|rpolicyId||GUID identifying the property to be set
// @pyparm int|flags||Reserved, use only 0
// @pyparm <o PyIUnknown>|pUnk||The property value
CPFLAGS flags;
PyObject *obrpolicyId;
PyObject *obUnk;
IID rpolicyId;
IUnknown * pUnk;
if ( !PyArg_ParseTuple(args, "OkO:SetProperty", &obrpolicyId, &flags, &obUnk) )
return NULL;
if (!PyWinObject_AsIID(obrpolicyId, &rpolicyId))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obUnk, IID_IUnknown, (void **)&pUnk, FALSE))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIC->SetProperty( rpolicyId, flags, pUnk );
pUnk->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIC, IID_IContext );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyICustomDestinationList|AppendCategory|Adds a custom category to the jump list
PyObject *PyICustomDestinationList::AppendCategory(PyObject *self, PyObject *args)
{
ICustomDestinationList *pICDL = GetI(self);
if ( pICDL == NULL )
return NULL;
TmpWCHAR Category;
PyObject *obCategory, *obItems;
IObjectArray *Items;
// @pyparm str|Category||Display name of the category, can also be a dll and resource id for localization
// @pyparm <o PyIObjectArray>|Items||Collection of IShellItem and/or IShellLink interfaces
if ( !PyArg_ParseTuple(args, "OO:AppendCategory", &obCategory, &obItems))
return NULL;
if (!PyWinObject_AsWCHAR(obCategory, &Category, FALSE))
return NULL;
if (!PyCom_InterfaceFromPyInstanceOrObject(obItems, IID_IObjectArray, (void **)&Items, FALSE))
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pICDL->AppendCategory(Category, Items);
Items->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pICDL, IID_ICustomDestinationList );
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod <o PyIMoniker>|PyIMoniker|ComposeWith|Combines the current moniker with another moniker, creating a new composite moniker.
PyObject *PyIMoniker::ComposeWith(PyObject *self, PyObject *args)
{
// @pyparm <o PyIMoniker>|mkRight||The IMoniker interface on the moniker to compose onto the end of this moniker.
// @pyparm int|fOnlyIfNotGeneric||If TRUE, the caller requires a non-generic composition, so the operation should proceed only if pmkRight is a moniker class that this moniker can compose with in some way other than forming a generic composite. If FALSE, the method can create a generic composite if necessary.
PyObject *obmkRight;
int bOnlyIfNotGeneric;
if (!PyArg_ParseTuple(args, "Oi:ComposeWith", &obmkRight, &bOnlyIfNotGeneric))
return NULL;
IMoniker *pMy = GetI(self);
if (pMy==NULL) return NULL;
IMoniker *pmkRight;
if (!PyCom_InterfaceFromPyInstanceOrObject(obmkRight, IID_IMoniker, (void **)&pmkRight, FALSE))
return NULL;
IMoniker *pResult = NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pMy->ComposeWith(pmkRight, bOnlyIfNotGeneric, &pResult);
pmkRight->Release();
PY_INTERFACE_POSTCALL;
if (S_OK!=hr) // S_OK only acceptable
return PyCom_BuildPyException(hr, pMy, IID_IMoniker);
return PyCom_PyObjectFromIUnknown(pResult, IID_IMoniker, FALSE );
}
// @pymethod int|PyIExplorerCommand|GetState|Description of GetState.
PyObject *PyIExplorerCommand::GetState(PyObject *self, PyObject *args)
{
IExplorerCommand *pIEC = GetI(self);
if ( pIEC == NULL )
return NULL;
// @pyparm <o PyIShellItemArray>|psiItemArray||Description for psiItemArray
// @pyparm int|fOkToBeSlow||Description for fOkToBeSlow
PyObject *obpsiItemArray;
IShellItemArray* psiItemArray;
BOOL fOkToBeSlow;
if ( !PyArg_ParseTuple(args, "Oi:GetState", &obpsiItemArray, &fOkToBeSlow) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpsiItemArray, IID_IShellItemArray, (void **)&psiItemArray, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
DWORD cmdState;
PY_INTERFACE_PRECALL;
hr = pIEC->GetState(psiItemArray, fOkToBeSlow, &cmdState );
if (psiItemArray) psiItemArray->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIEC, IID_IExplorerCommand );
return PyLong_FromUnsignedLong(cmdState);
}
// @pymethod |PyIDebugDocumentText|GetPositionOfContext|Description of GetPositionOfContext.
PyObject *PyIDebugDocumentText::GetPositionOfContext(PyObject *self, PyObject *args)
{
IDebugDocumentText *pIDDT = GetI(self);
if ( pIDDT == NULL )
return NULL;
// @pyparm <o PyIDebugDocumentContext>|psc||Description for psc
PyObject *obpsc;
IDebugDocumentContext *psc;
ULONG pcCharacterPosition;
ULONG cNumChars;
if ( !PyArg_ParseTuple(args, "O:GetPositionOfContext", &obpsc) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsc, IID_IDebugDocumentContext, (void **)&psc, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pIDDT->GetPositionOfContext( psc, &pcCharacterPosition, &cNumChars );
psc->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
PyObject *pyretval = Py_BuildValue("ii", pcCharacterPosition, cNumChars);
return pyretval;
}
// @pymethod unicode|PyIExplorerCommand|GetToolTip|Description of GetToolTip.
PyObject *PyIExplorerCommand::GetToolTip(PyObject *self, PyObject *args)
{
IExplorerCommand *pIEC = GetI(self);
if ( pIEC == NULL )
return NULL;
// @pyparm <o PyIShellItemArray>|psiItemArray||Description for psiItemArray
PyObject *obpsiItemArray;
IShellItemArray * psiItemArray;
if ( !PyArg_ParseTuple(args, "O:GetToolTip", &obpsiItemArray) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obpsiItemArray, IID_IShellItemArray, (void **)&psiItemArray, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
WCHAR *psz = 0;
PY_INTERFACE_PRECALL;
hr = pIEC->GetToolTip(psiItemArray, &psz);
if (psiItemArray) psiItemArray->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pIEC, IID_IExplorerCommand );
PyObject *ret = PyWinObject_FromWCHAR(psz);
CoTaskMemFree(psz);
return ret;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGShellItem::BindToHandler(
/* [unique][in] */ IBindCtx * pbc,
/* [in] */ REFGUID bhid,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void ** ppv)
{
PY_GATEWAY_METHOD;
PyObject *obpbc;
PyObject *obbhid;
PyObject *obriid;
obpbc = PyCom_PyObjectFromIUnknown(pbc, IID_IBindCtx, TRUE);
obbhid = PyWinObject_FromIID(bhid);
obriid = PyWinObject_FromIID(riid);
PyObject *result;
HRESULT hr=InvokeViaPolicy("BindToHandler", &result, "OOO", obpbc, obbhid, obriid);
Py_XDECREF(obpbc);
Py_XDECREF(obbhid);
Py_XDECREF(obriid);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
PyObject *obppv;
if (!PyArg_Parse(result, "O" , &obppv))
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("BindToHandler");
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppv, riid, (void **)ppv, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("BindToHandler");
Py_DECREF(result);
return hr;
}
// @pymethod |PyIOleObject|SetMoniker|Description of SetMoniker.
PyObject *PyIOleObject::SetMoniker(PyObject *self, PyObject *args)
{
IOleObject *pIOO = GetI(self);
if ( pIOO == NULL )
return NULL;
// @pyparm int|dwWhichMoniker||Description for dwWhichMoniker
// @pyparm <o PyIMoniker>|pmk||Description for pmk
PyObject *obpmk;
DWORD dwWhichMoniker;
IMoniker * pmk;
if ( !PyArg_ParseTuple(args, "iO:SetMoniker", &dwWhichMoniker, &obpmk) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpmk, IID_IMoniker, (void **)&pmk, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIOO->SetMoniker( dwWhichMoniker, pmk );
if (pmk) pmk->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIDebugApplication|CreateAsyncDebugOperation|Creates an IDebugAsyncOperation object to wrap a provided <o PyIDebugSyncOperation> object.
PyObject *PyIDebugApplication::CreateAsyncDebugOperation(PyObject *self, PyObject *args)
{
PY_INTERFACE_METHOD;
// @comm This provides a mechanism for language engines to implement asynchronous expression and
// evaluation, etc. without having to know the details of synchronization with the
// debugger thread. See the descriptions for <o PyIDebugSyncOperation> and <o PyIDebugAsyncOperation>
// for more details.
IDebugApplication *pIDA = GetI(self);
if ( pIDA == NULL )
return NULL;
// @pyparm <o PyIDebugSyncOperation>|psdo||Description for psdo
PyObject *obpsdo;
IDebugSyncOperation *psdo;
IDebugAsyncOperation *ppado;
if ( !PyArg_ParseTuple(args, "O:CreateAsyncDebugOperation", &obpsdo) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpsdo, IID_IDebugSyncOperation, (void **)&psdo, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pIDA->CreateAsyncDebugOperation( psdo, &ppado );
psdo->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
return PyCom_PyObjectFromIUnknown(ppado, IID_IDebugAsyncOperation, FALSE);
}
// @pymethod |PyIOleObject|InitFromData|Description of InitFromData.
PyObject *PyIOleObject::InitFromData(PyObject *self, PyObject *args)
{
IOleObject *pIOO = GetI(self);
if ( pIOO == NULL )
return NULL;
// @pyparm <o PyIDataObject>|pDataObject||Description for pDataObject
// @pyparm int|fCreation||Description for fCreation
// @pyparm int|dwReserved||Description for dwReserved
PyObject *obpDataObject;
IDataObject * pDataObject;
BOOL fCreation;
DWORD dwReserved;
if ( !PyArg_ParseTuple(args, "Oii:InitFromData", &obpDataObject, &fCreation, &dwReserved) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpDataObject, IID_IDataObject, (void **)&pDataObject, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIOO->InitFromData( pDataObject, fCreation, dwReserved );
if (pDataObject) pDataObject->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIDebugApplication|SynchronousCallInDebuggerThread|Provides a mechanism for the caller to run code in the debugger thread.
PyObject *PyIDebugApplication::SynchronousCallInDebuggerThread(PyObject *self, PyObject *args)
{
PY_INTERFACE_METHOD;
// @comm This is generally
// used so that language engines and hosts can implement free threaded objects on top
// of their single threaded implementations.
IDebugApplication *pIDA = GetI(self);
if ( pIDA == NULL )
return NULL;
// @pyparm <o PyIDebugThreadCall>|pptc||Description for pptc
// @pyparm int|dwParam1||Description for dwParam1
// @pyparm int|dwParam2||Description for dwParam2
// @pyparm int|dwParam3||Description for dwParam3
PyObject *obpptc;
IDebugThreadCall *pptc;
DWORD dwParam1;
DWORD dwParam2;
DWORD dwParam3;
if ( !PyArg_ParseTuple(args, "Oiii:SynchronousCallInDebuggerThread", &obpptc, &dwParam1, &dwParam2, &dwParam3) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpptc, IID_IDebugThreadCall, (void **)&pptc, FALSE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = pIDA->SynchronousCallInDebuggerThread( pptc, dwParam1, dwParam2, dwParam3 );
pptc->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return SetPythonCOMError(self,hr);
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIOleObject|SetClientSite|Description of SetClientSite.
PyObject *PyIOleObject::SetClientSite(PyObject *self, PyObject *args)
{
IOleObject *pIOO = GetI(self);
if ( pIOO == NULL )
return NULL;
// @pyparm <o PyIOleClientSite>|pClientSite||Description for pClientSite
PyObject *obpClientSite;
IOleClientSite * pClientSite;
if ( !PyArg_ParseTuple(args, "O:SetClientSite", &obpClientSite) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpClientSite, IID_IOleClientSite, (void **)&pClientSite, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIOO->SetClientSite( pClientSite );
if (pClientSite) pClientSite->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
Py_INCREF(Py_None);
return Py_None;
}
// @pymethod |PyIDebugApplication|AddGlobalExpressionContextProvider|Description of AddGlobalExpressionContextProvider.
PyObject *PyIDebugApplication::AddGlobalExpressionContextProvider(PyObject *self, PyObject *args)
{
IDebugApplication *pIDA = GetI(self);
if ( pIDA == NULL )
return NULL;
// @pyparm <o PyIProvideExpressionContexts>|pdsfs||Description for pdsfs
PyObject *obpdsfs;
IProvideExpressionContexts * pdsfs;
#ifdef _WIN64
DWORDLONG pdwCookie;
#else
DWORD pdwCookie;
#endif
if ( !PyArg_ParseTuple(args, "O:AddGlobalExpressionContextProvider", &obpdsfs) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpdsfs, IID_IProvideExpressionContexts, (void **)&pdsfs, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIDA->AddGlobalExpressionContextProvider( pdsfs, &pdwCookie );
if (pdsfs) pdsfs->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
PyObject *pyretval = Py_BuildValue("i", pdwCookie);
return pyretval;
}
// @pymethod |PyIOleObject|Advise|Description of Advise.
PyObject *PyIOleObject::Advise(PyObject *self, PyObject *args)
{
IOleObject *pIOO = GetI(self);
if ( pIOO == NULL )
return NULL;
// @pyparm <o PyIAdviseSink>|pAdvSink||Description for pAdvSink
PyObject *obpAdvSink;
IAdviseSink * pAdvSink;
DWORD pdwConnection;
if ( !PyArg_ParseTuple(args, "O:Advise", &obpAdvSink) )
return NULL;
BOOL bPythonIsHappy = TRUE;
if (!PyCom_InterfaceFromPyInstanceOrObject(obpAdvSink, IID_IAdviseSink, (void **)&pAdvSink, TRUE /* bNoneOK */))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy) return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIOO->Advise( pAdvSink, &pdwConnection );
if (pAdvSink) pAdvSink->Release();
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return OleSetOleError(hr);
PyObject *pyretval = Py_BuildValue("i", pdwConnection);
return pyretval;
}
