[pywin32-checkins] pywin32/com/win32com/src/extensions PyIDataObject.cpp,NONE,1.1 PyIEnumFORMATETC.cpp,NONE,1.1 PySTGMEDIUM.cpp,NONE,1.1

[<mha...@us...>]

Update of /cvsroot/pywin32/pywin32/com/win32com/src/extensions
In directory sc8-pr-cvs1:/tmp/cvs-serv13856/extensions

Added Files:
	PyIDataObject.cpp PyIEnumFORMATETC.cpp PySTGMEDIUM.cpp 
Log Message:
Add IDataFormat and support for FORMATETC and STGMEDIUM


--- NEW FILE: PyIDataObject.cpp ---
// This file implements the IDataObject Interface and Gateway for Python.
// Generated by makegw.py

#include "stdafx.h"
#include "PythonCOM.h"
#include "PythonCOMServer.h"
#include "PyIDataObject.h"
#include "PyComTypeObjects.h"

BOOL PyObject_AsFORMATETC(PyObject *ob, FORMATETC *petc)
{
	PyObject *obtd;
	if (!PyArg_ParseTuple(ob, "iOiii", 
			&petc->cfFormat,
			&obtd,
			&petc->dwAspect,
			&petc->lindex,
			&petc->tymed))
			return FALSE;
	if (obtd!=Py_None) {
		PyErr_SetString(PyExc_ValueError, "td must be None");
		return FALSE;
	}
	petc->ptd = NULL;
	return TRUE;
}

PyObject *PyObject_FromFORMATETC(FORMATETC *petc)
{
	return Py_BuildValue("iziii",
			petc->cfFormat,
			NULL,
			petc->dwAspect,
			petc->lindex,
			petc->tymed);
}

BOOL PyObject_AsPySTGMEDIUM(PyObject *obmedium, PySTGMEDIUM **pp)
{
	if (!PySTGMEDIUM_Check(obmedium)) {
		PyErr_Format(PyExc_TypeError, "Object must be a PySTGMEDIUM (not a '%s')", obmedium->ob_type->tp_name);
		return FALSE;
	}
	*pp = (PySTGMEDIUM *)obmedium;
	return TRUE;
}

// @doc - This file contains autoduck documentation
// ---------------------------------------------------
//
// Interface Implementation

PyIDataObject::PyIDataObject(IUnknown *pdisp):
	PyIUnknown(pdisp)
{
	ob_type = &type;
}

PyIDataObject::~PyIDataObject()
{
}

/* static */ IDataObject *PyIDataObject::GetI(PyObject *self)
{
	return (IDataObject *)PyIUnknown::GetI(self);
}

// @pymethod |PyIDataObject|GetData|Description of GetData.
PyObject *PyIDataObject::GetData(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	FORMATETC formatetcIn;
	PyObject *obpformatetcIn;
	// @pyparm <o PyFORMATETC>|pformatetcIn||Description for pformatetcIn
	if ( !PyArg_ParseTuple(args, "O:GetData", &obpformatetcIn) )
		return NULL;

	PySTGMEDIUM *pymedium = PyObject_FromSTGMEDIUM();
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyObject_AsFORMATETC( obpformatetcIn, &formatetcIn )) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->GetData( &formatetcIn, &pymedium->medium);
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) ) {
		Py_DECREF(pymedium);
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	}
	return pymedium;
}

// @pymethod |PyIDataObject|GetDataHere|Description of GetDataHere.
PyObject *PyIDataObject::GetDataHere(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	FORMATETC formatetc;
	PyObject *obpformatetc;
	// @pyparm <o PyFORMATETC>|pformatetcIn||Description for pformatetcIn
	if ( !PyArg_ParseTuple(args, "O:GetDataHere", &obpformatetc) )
		return NULL;
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyObject_AsFORMATETC( obpformatetc, &formatetc )) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) return NULL;
	PySTGMEDIUM *pymedium = PyObject_FromSTGMEDIUM();
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->GetDataHere( &formatetc, &pymedium->medium);
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) ) {
		Py_DECREF(pymedium);
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	}
	return pymedium;
}

// @pymethod |PyIDataObject|QueryGetData|Description of QueryGetData.
PyObject *PyIDataObject::QueryGetData(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	FORMATETC formatetc;
	PyObject *obpformatetc;
	// @pyparm <o PyFORMATETC>|pformatetc||Description for pformatetc
	if ( !PyArg_ParseTuple(args, "O:QueryGetData", &obpformatetc) )
		return NULL;
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyObject_AsFORMATETC( obpformatetc, &formatetc )) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->QueryGetData( &formatetc );
	PY_INTERFACE_POSTCALL;

	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	Py_INCREF(Py_None);
	return Py_None;

}

// @pymethod |PyIDataObject|GetCanonicalFormatEtc|Description of GetCanonicalFormatEtc.
PyObject *PyIDataObject::GetCanonicalFormatEtc(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	FORMATETC formatectIn;
	PyObject *obpformatectIn;
	// @pyparm <o PyFORMATETC *>|pformatectIn||Description for pformatectIn
	if ( !PyArg_ParseTuple(args, "O:GetCanonicalFormatEtc", &obpformatectIn) )
		return NULL;
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyObject_AsFORMATETC( obpformatectIn, &formatectIn )) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) return NULL;
	FORMATETC formatetcOut;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->GetCanonicalFormatEtc( &formatectIn, &formatetcOut );
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	return PyObject_FromFORMATETC(&formatetcOut);
	Py_INCREF(Py_None);
	return Py_None;

}

// @pymethod |PyIDataObject|SetData|Description of SetData.
PyObject *PyIDataObject::SetData(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	FORMATETC formatetc;
	PyObject *obpformatetc;
	// @pyparm <o PyFORMATETC>|pformatetc||Description for pformatetc
	PyObject *obmedium;
	PySTGMEDIUM *pymedium;
	// @pyparm <o PySTGMEDIUM *>|pmedium||Description for pmedium
	// @pyparm int|fRelease||Description for fRelease
	BOOL fRelease;
	if ( !PyArg_ParseTuple(args, "OOi:SetData", &obpformatetc, &obmedium, &fRelease) )
		return NULL;
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyObject_AsFORMATETC( obpformatetc, &formatetc )) bPythonIsHappy = FALSE;
	if (bPythonIsHappy && !PyObject_AsPySTGMEDIUM( obmedium, &pymedium )) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->SetData( &formatetc, &pymedium->medium, fRelease );
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	if (fRelease)
		pymedium->DropOwnership();
	Py_INCREF(Py_None);
	return Py_None;
}

// @pymethod |PyIDataObject|EnumFormatEtc|Description of EnumFormatEtc.
PyObject *PyIDataObject::EnumFormatEtc(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	// @pyparm int|dwDirection|DATADIR_GET|Description for dwDirection
	DWORD dwDirection = DATADIR_GET;
	IEnumFORMATETC * ppenumFormatEtc;
	if ( !PyArg_ParseTuple(args, "|l:EnumFormatEtc", &dwDirection) )
		return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->EnumFormatEtc( dwDirection, &ppenumFormatEtc );
	PY_INTERFACE_POSTCALL;

	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	return PyCom_PyObjectFromIUnknown(ppenumFormatEtc, IID_IEnumFORMATETC, FALSE);
}

// @pymethod |PyIDataObject|DAdvise|Description of DAdvise.
PyObject *PyIDataObject::DAdvise(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	FORMATETC formatetc;
	PyObject *obpformatetc;
	// @pyparm <o PyFORMATETC>|pformatetc||Description for pformatetc
	// @pyparm int|advf||Description for advf
	// @pyparm <o PyIAdviseSink *>|pAdvSink||Description for pAdvSink
	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 |PyIDataObject|DUnadvise|Description of DUnadvise.
PyObject *PyIDataObject::DUnadvise(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	// @pyparm int|dwConnection||Description for dwConnection
	DWORD dwConnection;
	if ( !PyArg_ParseTuple(args, "l:DUnadvise", &dwConnection) )
		return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->DUnadvise( dwConnection );
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	Py_INCREF(Py_None);
	return Py_None;
}

// @pymethod |PyIDataObject|EnumDAdvise|Description of EnumDAdvise.
PyObject *PyIDataObject::EnumDAdvise(PyObject *self, PyObject *args)
{
	IDataObject *pIDO = GetI(self);
	if ( pIDO == NULL )
		return NULL;
	IEnumSTATDATA *ppenumAdvise;
	if ( !PyArg_ParseTuple(args, ":EnumDAdvise") )
		return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIDO->EnumDAdvise( &ppenumAdvise );
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIDO, IID_IDataObject );
	return PyCom_PyObjectFromIUnknown(ppenumAdvise, IID_IEnumSTATDATA, FALSE);
}

// @object PyIDataObject|Description of the interface
static struct PyMethodDef PyIDataObject_methods[] =
{
	{ "GetData", PyIDataObject::GetData, 1 }, // @pymeth GetData|Description of GetData
	{ "GetDataHere", PyIDataObject::GetDataHere, 1 }, // @pymeth GetDataHere|Description of GetDataHere
	{ "QueryGetData", PyIDataObject::QueryGetData, 1 }, // @pymeth QueryGetData|Description of QueryGetData
	{ "GetCanonicalFormatEtc", PyIDataObject::GetCanonicalFormatEtc, 1 }, // @pymeth GetCanonicalFormatEtc|Description of GetCanonicalFormatEtc
	{ "SetData", PyIDataObject::SetData, 1 }, // @pymeth SetData|Description of SetData
	{ "EnumFormatEtc", PyIDataObject::EnumFormatEtc, 1 }, // @pymeth EnumFormatEtc|Description of EnumFormatEtc
	{ "DAdvise", PyIDataObject::DAdvise, 1 }, // @pymeth DAdvise|Description of DAdvise
	{ "DUnadvise", PyIDataObject::DUnadvise, 1 }, // @pymeth DUnadvise|Description of DUnadvise
	{ "EnumDAdvise", PyIDataObject::EnumDAdvise, 1 }, // @pymeth EnumDAdvise|Description of EnumDAdvise
	{ NULL }
};

PyComTypeObject PyIDataObject::type("PyIDataObject",
		&PyIUnknown::type,
		sizeof(PyIDataObject),
		PyIDataObject_methods,
		GET_PYCOM_CTOR(PyIDataObject));
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGDataObject::GetData(
		/* [unique][in] */ FORMATETC * pformatetcIn,
		/* [out] */ STGMEDIUM * pmedium)
{
	PY_GATEWAY_METHOD;
	PyObject *obpformatetcIn = PyObject_FromFORMATETC(pformatetcIn);
	if (obpformatetcIn==NULL) return PyCom_HandlePythonFailureToCOM();
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("GetData", &result, "O", obpformatetcIn);
	Py_DECREF(obpformatetcIn);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params
	if (PySTGMEDIUM_Check(result)) {
		PySTGMEDIUM *pym = (PySTGMEDIUM *)result;
		memcpy(pmedium, &pym->medium, sizeof(STGMEDIUM));
		pym->DropOwnership();
	}
	hr = PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);
	Py_DECREF(result);
	return hr;
}

STDMETHODIMP PyGDataObject::GetDataHere(
		/* [unique][in] */ FORMATETC * pformatetc,
		/* [out][in] */ STGMEDIUM * pmedium)
{
	PY_GATEWAY_METHOD;
	PyObject *obpformatetc = PyObject_FromFORMATETC(pformatetc);
	if (obpformatetc==NULL) return PyCom_HandlePythonFailureToCOM();
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("GetDataHere", &result, "O", obpformatetc);
	Py_DECREF(obpformatetc);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params
	if (PySTGMEDIUM_Check(result)) {
		PySTGMEDIUM *pym = (PySTGMEDIUM *)result;
		memcpy(pmedium, &pym->medium, sizeof(STGMEDIUM));
		pym->DropOwnership();
	}
	hr = PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);
	Py_DECREF(result);
	return hr;
}

STDMETHODIMP PyGDataObject::QueryGetData(
		/* [unique][in] */ FORMATETC * pformatetc)
{
	PY_GATEWAY_METHOD;
	PyObject *obpformatetc = PyObject_FromFORMATETC(pformatetc);
	if (obpformatetc==NULL) return PyCom_HandlePythonFailureToCOM();
	HRESULT hr=InvokeViaPolicy("QueryGetData", NULL, "O", obpformatetc);
	Py_DECREF(obpformatetc);
	return hr;
}

STDMETHODIMP PyGDataObject::GetCanonicalFormatEtc(
		/* [unique][in] */ FORMATETC * pformatectIn,
		/* [out] */ FORMATETC * pformatetcOut)
{
	PY_GATEWAY_METHOD;
	PyObject *obpformatectIn = PyObject_FromFORMATETC(pformatectIn);
	if (obpformatectIn==NULL) return PyCom_HandlePythonFailureToCOM();
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("GetCanonicalFormatEtc", &result, "O", obpformatectIn);
	Py_DECREF(obpformatectIn);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params
	PyObject_AsFORMATETC(result, pformatetcOut);
	Py_DECREF(result);
	return hr;
}

STDMETHODIMP PyGDataObject::SetData(
		/* [unique][in] */ FORMATETC * pformatetc,
		/* [unique][in] */ STGMEDIUM * pmedium,
		/* [in] */ BOOL fRelease)
{
	PY_GATEWAY_METHOD;
	PyObject *obpformatetc = PyObject_FromFORMATETC(pformatetc);
	if (obpformatetc==NULL) return PyCom_HandlePythonFailureToCOM();
	PySTGMEDIUM *obmedium = PyObject_FromSTGMEDIUM(pmedium);
	if (obmedium==NULL) return PyCom_HandlePythonFailureToCOM();
	HRESULT hr=InvokeViaPolicy("SetData", NULL, "OOi", obpformatetc, obmedium, fRelease);
	if (!fRelease)
		obmedium->DropOwnership();
	Py_DECREF(obpformatetc);
	Py_DECREF(obmedium);
	return hr;
}

STDMETHODIMP PyGDataObject::EnumFormatEtc(
		/* [in] */ DWORD dwDirection,
		/* [out] */ IEnumFORMATETC ** ppenumFormatEtc)
{
	PY_GATEWAY_METHOD;
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("EnumFormatEtc", &result, "l", dwDirection);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params
	PyObject *obppenumFormatEtc;
	if (!PyArg_Parse(result, "O" , &obppenumFormatEtc)) return PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppenumFormatEtc, IID_IEnumFORMATETC, (void **)ppenumFormatEtc, TRUE /* bNoneOK */))
		 bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) hr = PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);
	Py_DECREF(result);
	return hr;
}

STDMETHODIMP PyGDataObject::DAdvise(
		/* [in] */ FORMATETC * pformatetc,
		/* [in] */ DWORD advf,
		/* [unique][in] */ IAdviseSink * pAdvSink,
		/* [out] */ DWORD * pdwConnection)
{
	PY_GATEWAY_METHOD;
	PyObject *obpformatetc = PyObject_FromFORMATETC(pformatetc);
	if (obpformatetc==NULL) return PyCom_HandlePythonFailureToCOM();
	PyObject *obpAdvSink;
	obpAdvSink = PyCom_PyObjectFromIUnknown(pAdvSink, IID_IAdviseSink, TRUE);
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("DAdvise", &result, "OlO", obpformatetc, advf, obpAdvSink);
	Py_DECREF(obpformatetc);
	Py_XDECREF(obpAdvSink);
	if (FAILED(hr)) return hr;
	*pdwConnection = PyInt_AsLong(result);
	Py_DECREF(result);
	return hr;
}

STDMETHODIMP PyGDataObject::DUnadvise(
		/* [in] */ DWORD dwConnection)
{
	PY_GATEWAY_METHOD;
	HRESULT hr=InvokeViaPolicy("DUnadvise", NULL, "l", dwConnection);
	return hr;
}

STDMETHODIMP PyGDataObject::EnumDAdvise(
		/* [out] */ IEnumSTATDATA ** ppenumAdvise)
{
	PY_GATEWAY_METHOD;
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("EnumDAdvise", &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 PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);
	BOOL bPythonIsHappy = TRUE;
	if (bPythonIsHappy && !PyCom_InterfaceFromPyInstanceOrObject(obppenumAdvise, IID_IEnumSTATDATA, (void **)ppenumAdvise, TRUE /* bNoneOK */))
		 bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) hr = PyCom_HandlePythonFailureToCOM(/*pexcepinfo*/);
	Py_DECREF(result);
	return hr;
}


--- NEW FILE: PyIEnumFORMATETC.cpp ---
// This file implements the IEnumFORMATETC Interface and Gateway for Python.
// Generated by makegw.py

#include "stdafx.h"
#include "PythonCOM.h"
#include "PythonCOMServer.h"
#include "PyIEnumFORMATETC.h"

extern BOOL PyObject_AsFORMATETC(PyObject *ob, FORMATETC *petc);
extern PyObject *PyObject_FromFORMATETC(FORMATETC *petc);

// @doc - This file contains autoduck documentation
// ---------------------------------------------------
//
// Interface Implementation

PyIEnumFORMATETC::PyIEnumFORMATETC(IUnknown *pdisp):
	PyIUnknown(pdisp)
{
	ob_type = &type;
}

PyIEnumFORMATETC::~PyIEnumFORMATETC()
{
}

/* static */ IEnumFORMATETC *PyIEnumFORMATETC::GetI(PyObject *self)
{
	return (IEnumFORMATETC *)PyIUnknown::GetI(self);
}

PyObject *
PyIEnumFORMATETC::iter()
{
	Py_INCREF(this);
	return this;
}

PyObject *
PyIEnumFORMATETC::iternext()
{
	ULONG celtFetched = 0;
	FORMATETC ret;;
	IEnumFORMATETC *peidl = GetI(this);
	if ( peidl == NULL )
		return NULL;
	PY_INTERFACE_PRECALL;
	HRESULT hr = peidl->Next(1, &ret, &celtFetched);
	PY_INTERFACE_POSTCALL;
	if (  HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS && FAILED(hr) )
		return PyCom_BuildPyException(hr,peidl, IID_IEnumFORMATETC);
	if (celtFetched==0) {
		PyErr_SetNone(PyExc_StopIteration);
		return NULL;
	}
	return PyObject_FromFORMATETC(&ret);
}

// @pymethod object|PyIEnumFORMATETC|Next|Retrieves a specified number of items in the enumeration sequence.
PyObject *PyIEnumFORMATETC::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;

	IEnumFORMATETC *peidl = GetI(self);
	if ( peidl == NULL )
		return NULL;

	FORMATETC *rgVar = new FORMATETC[celt];
	if ( rgVar == NULL ) {
		PyErr_SetString(PyExc_MemoryError, "allocating result FORMATETCs");
		return NULL;
	}

	memset(rgVar, 0, sizeof(FORMATETC)*celt);
	ULONG celtFetched = 0;
	PY_INTERFACE_PRECALL;
	HRESULT hr = peidl->Next(celt, rgVar, &celtFetched);
	PY_INTERFACE_POSTCALL;
	if (  HRESULT_CODE(hr) != ERROR_NO_MORE_ITEMS && FAILED(hr) )
	{
		delete [] rgVar;
		return PyCom_BuildPyException(hr,peidl, IID_IEnumFORMATETC);
	}

	PyObject *result = PyList_New(celtFetched);
	int i;
	if ( result != NULL )
	{
		for ( i = celtFetched; i--; )
		{
			PyObject *ob = PyObject_FromFORMATETC(rgVar+i);
			if ( ob == NULL )
			{
				Py_DECREF(result);
				result = NULL;
				break;
			}
			PyList_SET_ITEM(result, i, ob);
		}
	}
	delete [] rgVar;
	return result;
}

// @pymethod |PyIEnumFORMATETC|Skip|Skips over the next specified elementes.
PyObject *PyIEnumFORMATETC::Skip(PyObject *self, PyObject *args)
{
	long celt;
	if ( !PyArg_ParseTuple(args, "l:Skip", &celt) )
		return NULL;

	IEnumFORMATETC *peidl = GetI(self);
	if ( peidl == NULL )
		return NULL;

	PY_INTERFACE_PRECALL;
	HRESULT hr = peidl->Skip(celt);
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, peidl, IID_IEnumFORMATETC);

	Py_INCREF(Py_None);
	return Py_None;
}

// @pymethod |PyIEnumFORMATETC|Reset|Resets the enumeration sequence to the beginning.
PyObject *PyIEnumFORMATETC::Reset(PyObject *self, PyObject *args)
{
	if ( !PyArg_ParseTuple(args, ":Reset") )
		return NULL;

	IEnumFORMATETC *peidl = GetI(self);
	if ( peidl == NULL )
		return NULL;

	PY_INTERFACE_PRECALL;
	HRESULT hr = peidl->Reset();
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, peidl, IID_IEnumFORMATETC);

	Py_INCREF(Py_None);
	return Py_None;
}

// @pymethod <o PyIEnumFORMATETC>|PyIEnumFORMATETC|Clone|Creates another enumerator that contains the same enumeration state as the current one
PyObject *PyIEnumFORMATETC::Clone(PyObject *self, PyObject *args)
{
	if ( !PyArg_ParseTuple(args, ":Clone") )
		return NULL;

	IEnumFORMATETC *peidl = GetI(self);
	if ( peidl == NULL )
		return NULL;

	IEnumFORMATETC *pClone;
	PY_INTERFACE_PRECALL;
	HRESULT hr = peidl->Clone(&pClone);
	PY_INTERFACE_POSTCALL;
	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, peidl, IID_IEnumFORMATETC);

	return PyCom_PyObjectFromIUnknown(pClone, IID_IEnumFORMATETC, FALSE);
}

// @object PyIEnumFORMATETC|A Python interface to IEnumFORMATETC
static struct PyMethodDef PyIEnumFORMATETC_methods[] =
{
	{ "Next", PyIEnumFORMATETC::Next, 1 },    // @pymeth Next|Retrieves a specified number of items in the enumeration sequence.
	{ "Skip", PyIEnumFORMATETC::Skip, 1 },	// @pymeth Skip|Skips over the next specified elementes.
	{ "Reset", PyIEnumFORMATETC::Reset, 1 },	// @pymeth Reset|Resets the enumeration sequence to the beginning.
	{ "Clone", PyIEnumFORMATETC::Clone, 1 },	// @pymeth Clone|Creates another enumerator that contains the same enumeration state as the current one.
	{ NULL }
};

PyComTypeObject PyIEnumFORMATETC::type("PyIEnumFORMATETC",
		&PyIUnknown::type,
		sizeof(PyIEnumFORMATETC),
		PyIEnumFORMATETC_methods,
		GET_PYCOM_CTOR(PyIEnumFORMATETC));

// ---------------------------------------------------
//
// Gateway Implementation

STDMETHODIMP PyGEnumFORMATETC::Next( 
            /* [in] */ ULONG celt,
            /* [length_is][size_is][out] */ FORMATETC *pi,
            /* [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;
	int len;
	len = PyObject_Length(result);
	if ( len == -1 )
		goto error;
	if ( len > (int)celt)
		len = celt;

	if ( pCeltFetched )
		*pCeltFetched = len;

	int i;
	for ( i = 0; i < len; ++i )
	{
		PyObject *ob = PySequence_GetItem(result, i);
		if ( ob == NULL )
			goto error;

		if ( !PyObject_AsFORMATETC(ob, &pi[i] ))
		{
			Py_DECREF(result);
			return PyCom_SetCOMErrorFromPyException(IID_IEnumFORMATETC);
		}
	}

	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_IEnumFORMATETC, "Next() did not return a sequence of objects");
}

STDMETHODIMP PyGEnumFORMATETC::Skip( 
            /* [in] */ ULONG celt)
{
	PY_GATEWAY_METHOD;
	return InvokeViaPolicy("Skip", NULL, "i", celt);
}

STDMETHODIMP PyGEnumFORMATETC::Reset(void)
{
	PY_GATEWAY_METHOD;
	return InvokeViaPolicy("Reset");
}

STDMETHODIMP PyGEnumFORMATETC::Clone( 
            /* [out] */ IEnumFORMATETC __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_IEnumFORMATETC);
	}

	/*
	** 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_IEnumFORMATETC);
	}

	/*
	** Get the interface we want. note it is returned with a refcount.
	** This QI is actually going to instantiate a PyGEnumFORMATETC.
	*/
	Py_BEGIN_ALLOW_THREADS
	hr = punk->QueryInterface(IID_IEnumFORMATETC, (LPVOID *)ppEnum);
	Py_END_ALLOW_THREADS

	/* done with the result; this DECREF is also for <punk> */
	Py_DECREF(result);

	return PyCom_SetCOMErrorFromSimple(hr, IID_IEnumFORMATETC, "Python could not convert the result from Next() into the required COM interface");
}

--- NEW FILE: PySTGMEDIUM.cpp ---

#include "stdafx.h"
#include "PythonCOM.h"
#include "structmember.h"
#include "PyComTypeObjects.h"

// @pymethod <o STGMEDIUM>|pythoncom|STGMEDIUM|Creates a new STGMEDIUM object
PyObject *Py_NewSTGMEDIUM(PyObject *self, PyObject *args)
{
	if (!PyArg_ParseTuple(args, ""))
		return NULL;
	return new PySTGMEDIUM();
}

PySTGMEDIUM *PyObject_FromSTGMEDIUM(STGMEDIUM *desc /* = NULL*/)
{
	return new PySTGMEDIUM(desc);
}

PyObject *PySet(PyObject *self, PyObject *args)
{
	int tymed;
	PyObject *ob;
	if (!PyArg_ParseTuple(args, "iO:set", &tymed, &ob))
		return NULL;

	PySTGMEDIUM *ps = (PySTGMEDIUM *)self;
	ps->Close(); // ensure any old data clean
	switch (tymed) {
		case TYMED_GDI:
			if (!PyInt_Check(ob) || !PyLong_Check(ob))
				return PyErr_Format(PyExc_TypeError, "tymed value of %d requires an integer handle", tymed);
			ps->medium.hBitmap = (HBITMAP)PyInt_AsLong(ob);
			break;
		case TYMED_MFPICT:
			if (!PyInt_Check(ob) || !PyLong_Check(ob))
				return PyErr_Format(PyExc_TypeError, "tymed value of %d requires an integer handle", tymed);
			ps->medium.hMetaFilePict = (HMETAFILEPICT)PyInt_AsLong(ob);
			break;
		case TYMED_ENHMF:
			if (!PyInt_Check(ob) || !PyLong_Check(ob))
				return PyErr_Format(PyExc_TypeError, "tymed value of %d requires an integer handle", tymed);
			ps->medium.hEnhMetaFile = (HENHMETAFILE)PyInt_AsLong(ob);
			break;
		case TYMED_HGLOBAL: {
			// todo: support buffer
			if (!PyString_Check(ob))
				return PyErr_Format(PyExc_TypeError, "tymed value of %d requires a string", tymed);
			ps->medium.hGlobal = GlobalAlloc(GMEM_FIXED, PyString_Size(ob));
			if (!ps->medium.hGlobal)
				return PyErr_NoMemory();
			memcpy( (void *)ps->medium.hGlobal, PyString_AsString(ob), PyString_Size(ob));
			break;
		}
		case TYMED_FILE: 
			if (!PyWinObject_AsTaskAllocatedWCHAR(ob, &ps->medium.lpszFileName, FALSE, NULL))
				return FALSE;
			break;
		case TYMED_ISTREAM:
			if (!PyCom_InterfaceFromPyInstanceOrObject(ob, IID_IStream, (void **)&ps->medium.pstm, FALSE/* bNoneOK */))
				return FALSE;
			break;
		case TYMED_ISTORAGE:
			if (!PyCom_InterfaceFromPyInstanceOrObject(ob, IID_IStorage, (void **)&ps->medium.pstg, FALSE/* bNoneOK */))
				return FALSE;
			break;
		default:
			PyErr_Format(PyExc_ValueError, "Unknown tymed value '%d'", tymed);
			return NULL;
	}
	ps->medium.tymed = tymed;
	Py_INCREF(Py_None);
	return Py_None;
}

// @object STGMEDIUM|A STGMEDIUM object represents a COM STGMEDIUM structure.
static struct PyMethodDef PySTGMEDIUM_methods[] = {
	{"set", PySet, 1}, // @pymeth set|Sets the type and data of the object
	{NULL}
};

PyTypeObject PySTGMEDIUM::Type =
{
	PyObject_HEAD_INIT(&PyType_Type)
	0,
	"PySTGMEDIUM",
	sizeof(PySTGMEDIUM),
	0,
	PySTGMEDIUM::deallocFunc,		/* tp_dealloc */
	0,		/* tp_print */
	PySTGMEDIUM::getattr,				/* tp_getattr */
	0,				/* tp_setattr */
	0,	/* tp_compare */
	0,						/* tp_repr */
	0,						/* tp_as_number */
	0,	/* tp_as_sequence */
	0,						/* tp_as_mapping */
	0,
	0,						/* tp_call */
	0,		/* tp_str */
};

#define OFF(e) offsetof(PySTGMEDIUM, e)

PySTGMEDIUM::PySTGMEDIUM(STGMEDIUM *pm)
{
	ob_type = &PySTGMEDIUM::Type;
	_Py_NewReference(this);
	if (pm)
		memcpy(&medium, pm, sizeof(medium));
	else
		memset(&medium, 0, sizeof(medium));
}

PySTGMEDIUM::~PySTGMEDIUM()
{
	Close();
}

void PySTGMEDIUM::DropOwnership()
{
	memset(&medium, 0, sizeof(medium));
}

void PySTGMEDIUM::Close()
{
	if (medium.tymed) {
		ReleaseStgMedium(&medium);
		memset(&medium, 0, sizeof(medium));
		assert(!medium.tymed);
	}
}

PyObject *PySTGMEDIUM::getattr(PyObject *self, char *name)
{
	PyObject *res;
	PySTGMEDIUM *ps = (PySTGMEDIUM *)self;
	res = Py_FindMethod(PySTGMEDIUM_methods, self, name);
	if (res != NULL)
		return res;
	PyErr_Clear();
	if (strcmp(name, "tymed")==0)
		return PyInt_FromLong(ps->medium.tymed);
	if (strcmp(name, "data")==0) {
		switch (ps->medium.tymed) {
			case TYMED_GDI:
				return PyLong_FromVoidPtr(ps->medium.hBitmap);
			case TYMED_MFPICT:
				return PyLong_FromVoidPtr(ps->medium.hMetaFilePict);
			case TYMED_ENHMF:
				return PyLong_FromVoidPtr(ps->medium.hEnhMetaFile);
			case TYMED_HGLOBAL: {
				PyObject *ret;
				void *p = GlobalLock(ps->medium.hGlobal);
				if (p) {
					ret = PyString_FromStringAndSize( (char *)p, GlobalSize(ps->medium.hGlobal));
					GlobalUnlock(ps->medium.hGlobal);
				} else {
					ret = Py_None;
					Py_INCREF(Py_None);
				}
				return ret;
			}
			case TYMED_FILE: 
				return PyWinObject_FromWCHAR(ps->medium.lpszFileName);
			case TYMED_ISTREAM:
				return PyCom_PyObjectFromIUnknown(ps->medium.pstm, IID_IStream, TRUE);
			case TYMED_ISTORAGE:
				return PyCom_PyObjectFromIUnknown(ps->medium.pstg, IID_IStorage, TRUE);
			case TYMED_NULL:
				PyErr_SetString(PyExc_ValueError, "This STGMEDIUM has no data");
				return NULL;
			default:
				PyErr_SetString(PyExc_RuntimeError, "Unknown tymed");
				return NULL;
		}
	}
	return PyErr_Format(PyExc_AttributeError, "STGMEDIUM objects have no attribute '%s'", name);
}

/*static*/ void PySTGMEDIUM::deallocFunc(PyObject *ob)
{
	delete (PySTGMEDIUM *)ob;
}