[pywin32-checkins] pywin32/com/win32comext/shell/src PyIEmptyVolumeCache.cpp, NONE, 1.1 PyIEmptyVolumeCache.h, NONE, 1.1 PyIEmptyVolumeCacheCallBack.cpp, NONE, 1.1 PyIEmptyVolumeCacheCallBack.h, NONE, 1.1 shell.cpp, 1.50, 1.51

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

Update of /cvsroot/pywin32/pywin32/com/win32comext/shell/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31039/com/win32comext/shell/src

Modified Files:
	shell.cpp 
Added Files:
	PyIEmptyVolumeCache.cpp PyIEmptyVolumeCache.h 
	PyIEmptyVolumeCacheCallBack.cpp PyIEmptyVolumeCacheCallBack.h 
Log Message:
Support for IEmptyVolumeCache, IEmptyVolumeCache2 and 
IEmptyVolumeCacheCallBack contributed by Sidnei da Silva from Enfold.


--- NEW FILE: PyIEmptyVolumeCache.h ---
// This file declares the IEmptyVolumeCache Gateway for Python.
// ---------------------------------------------------
//
// Gateway Declaration

class PyGEmptyVolumeCache : public PyGatewayBase, public IEmptyVolumeCache
{
protected:
	PyGEmptyVolumeCache(PyObject *instance) : PyGatewayBase(instance) { ; }
	PYGATEWAY_MAKE_SUPPORT2(PyGEmptyVolumeCache, IEmptyVolumeCache, IID_IEmptyVolumeCache, PyGatewayBase)

	// IEmptyVolumeCache
	STDMETHOD(Initialize)(
		HKEY hkRegKey,
		LPCWSTR pcwszVolume,
		LPWSTR * ppwszDisplayName,
		LPWSTR * ppwszDescription,
		DWORD * pdwFlags);

	STDMETHOD(GetSpaceUsed)(
		DWORDLONG * pdwlSpaceUsed,
		IEmptyVolumeCacheCallBack * picb);

	STDMETHOD(Purge)(
		DWORDLONG dwlSpaceToFree,
		IEmptyVolumeCacheCallBack * picb);

	STDMETHOD(ShowProperties)(
		HWND hwnd);

	STDMETHOD(Deactivate)(
		DWORD * pdwFlags);

};

class PyGEmptyVolumeCache2 : public PyGEmptyVolumeCache, public IEmptyVolumeCache2
{
protected:
	PyGEmptyVolumeCache2(PyObject *instance) : PyGEmptyVolumeCache(instance) { ; }
	PYGATEWAY_MAKE_SUPPORT2(PyGEmptyVolumeCache2, IEmptyVolumeCache2, IID_IEmptyVolumeCache2, PyGEmptyVolumeCache)
	// IEmptyVolumeCache

	STDMETHOD(Initialize)(
		HKEY hkRegKey,
		LPCWSTR pcwszVolume,
		LPWSTR * ppwszDisplayName,
		LPWSTR * ppwszDescription,
		DWORD * pdwFlags) {
            return PyGEmptyVolumeCache::Initialize(hkRegKey, pcwszVolume, ppwszDisplayName, ppwszDescription, pdwFlags);
        }
	STDMETHOD(GetSpaceUsed)(
		DWORDLONG * pdwlSpaceUsed,
		IEmptyVolumeCacheCallBack * picb) {
            return PyGEmptyVolumeCache::GetSpaceUsed(pdwlSpaceUsed, picb);
        }

	STDMETHOD(Purge)(
		DWORDLONG dwlSpaceToFree,
		IEmptyVolumeCacheCallBack * picb) {
            return PyGEmptyVolumeCache::Purge(dwlSpaceToFree, picb);
        }

	STDMETHOD(ShowProperties)(
		HWND hwnd) {
            return PyGEmptyVolumeCache::ShowProperties(hwnd);
        }

	STDMETHOD(Deactivate)(
		DWORD * pdwFlags) {
            return PyGEmptyVolumeCache::Deactivate(pdwFlags);
        }

	// IEmptyVolumeCache2
	STDMETHOD(InitializeEx)(
		HKEY hkRegKey,
		LPCWSTR pcwszVolume,
		LPCWSTR pcwszKeyName,
		LPWSTR * ppwszDisplayName,
		LPWSTR * ppwszDescription,
		LPWSTR * ppwszBtnText,
		DWORD * pdwFlags);
};

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

#include "shell_pch.h"
#include "EmptyVC.h"
#include "PyIEmptyVolumeCacheCallBack.h"

// @doc - This file contains autoduck documentation
// @object PyIEmptyVolumeCacheCallBack|Callback used by <o PyIEmptyVolumeCacheCallBack>
// ---------------------------------------------------
//
// Interface Implementation

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

PyIEmptyVolumeCacheCallBack::~PyIEmptyVolumeCacheCallBack()
{
}

/* static */ IEmptyVolumeCacheCallBack *PyIEmptyVolumeCacheCallBack::GetI(PyObject *self)
{
	return (IEmptyVolumeCacheCallBack *)PyIUnknown::GetI(self);
}

// @pymethod |PyIEmptyVolumeCacheCallBack|ScanProgress|Description of ScanProgress.
PyObject *PyIEmptyVolumeCacheCallBack::ScanProgress(PyObject *self, PyObject *args)
{
	IEmptyVolumeCacheCallBack *pIEVCCB = GetI(self);
	if ( pIEVCCB == NULL )
		return NULL;
	DWORDLONG dwlSpaceUsed;
	PyObject *obdwlSpaceUsed;
	// @pyparm long|dwlSpaceUsed||Description for dwlSpaceUsed
	// @pyparm int|dwFlags||Description for dwFlags
	// @pyparm unicode|pcwszStatus||Description for pcwszStatus
	PyObject *obpcwszStatus;
	DWORD dwFlags;
	LPWSTR pcwszStatus;
	if ( !PyArg_ParseTuple(args, "OkO:ScanProgress", &obdwlSpaceUsed, &dwFlags, &obpcwszStatus) )
		return NULL;
	dwlSpaceUsed = PyLong_AsUnsignedLongLong(obdwlSpaceUsed);
	if (dwlSpaceUsed == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())
		return NULL;
	if (!PyWinObject_AsWCHAR(obpcwszStatus, &pcwszStatus))
		return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIEVCCB->ScanProgress( dwlSpaceUsed, dwFlags, pcwszStatus );
	SysFreeString(pcwszStatus);
	PY_INTERFACE_POSTCALL;

	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIEVCCB, IID_IEmptyVolumeCacheCallBack );
	Py_INCREF(Py_None);
	return Py_None;
}

// @pymethod |PyIEmptyVolumeCacheCallBack|PurgeProgress|Description of PurgeProgress.
PyObject *PyIEmptyVolumeCacheCallBack::PurgeProgress(PyObject *self, PyObject *args)
{
	IEmptyVolumeCacheCallBack *pIEVCCB = GetI(self);
	if ( pIEVCCB == NULL )
		return NULL;
	DWORDLONG dwlSpaceFreed;
	PyObject *obdwlSpaceFreed;
	// @pyparm <o PyDWORDLONG>|dwlSpaceFreed||Description for dwlSpaceFreed
	DWORDLONG dwlSpaceToFree;
	PyObject *obdwlSpaceToFree;
	// @pyparm long|spaceFreed||
	// @pyparm long|spaceToFree||
	// @pyparm long|flags||
	// @pyparm unicode|status||
	PyObject *obpcwszStatus;
	DWORD dwFlags;
	LPWSTR pcwszStatus;
	if ( !PyArg_ParseTuple(args, "OOlO:PurgeProgress", &obdwlSpaceFreed, &obdwlSpaceToFree, &dwFlags, &obpcwszStatus) )
		return NULL;
	dwlSpaceFreed = PyLong_AsUnsignedLongLong(obdwlSpaceFreed);
	if (dwlSpaceFreed == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) return NULL;
	dwlSpaceToFree = PyLong_AsUnsignedLongLong(obdwlSpaceToFree);
	if (dwlSpaceToFree == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) return NULL;
	if (!PyWinObject_AsWCHAR(obpcwszStatus, &pcwszStatus))
		return NULL;
	HRESULT hr;
	PY_INTERFACE_PRECALL;
	hr = pIEVCCB->PurgeProgress( dwlSpaceFreed, dwlSpaceToFree, dwFlags, pcwszStatus );
	SysFreeString(pcwszStatus);
	PY_INTERFACE_POSTCALL;

	if ( FAILED(hr) )
		return PyCom_BuildPyException(hr, pIEVCCB, IID_IEmptyVolumeCacheCallBack );
	Py_INCREF(Py_None);
	return Py_None;
}

// @object PyIEmptyVolumeCacheCallBack|Description of the interface
static struct PyMethodDef PyIEmptyVolumeCacheCallBack_methods[] =
{
	{ "ScanProgress", PyIEmptyVolumeCacheCallBack::ScanProgress, 1 }, // @pymeth ScanProgress|Description of ScanProgress
	{ "PurgeProgress", PyIEmptyVolumeCacheCallBack::PurgeProgress, 1 }, // @pymeth PurgeProgress|Description of PurgeProgress
	{ NULL }
};

PyComTypeObject PyIEmptyVolumeCacheCallBack::type("PyIEmptyVolumeCacheCallBack",
		&PyIUnknown::type,
		sizeof(PyIEmptyVolumeCacheCallBack),
		PyIEmptyVolumeCacheCallBack_methods,
		GET_PYCOM_CTOR(PyIEmptyVolumeCacheCallBack));

--- NEW FILE: PyIEmptyVolumeCacheCallBack.h ---
// This file declares the IEmptyVolumeCacheCallBack Interface for Python.
// ---------------------------------------------------
//
// Interface Declaration

class PyIEmptyVolumeCacheCallBack : public PyIUnknown
{
public:
	MAKE_PYCOM_CTOR(PyIEmptyVolumeCacheCallBack);
	static IEmptyVolumeCacheCallBack *GetI(PyObject *self);
	static PyComTypeObject type;

	// The Python methods
	static PyObject *ScanProgress(PyObject *self, PyObject *args);
	static PyObject *PurgeProgress(PyObject *self, PyObject *args);

protected:
	PyIEmptyVolumeCacheCallBack(IUnknown *pdisp);
	~PyIEmptyVolumeCacheCallBack();
};

Index: shell.cpp
===================================================================
RCS file: /cvsroot/pywin32/pywin32/com/win32comext/shell/src/shell.cpp,v
retrieving revision 1.50
retrieving revision 1.51
diff -C2 -d -r1.50 -r1.51
*** shell.cpp	12 Feb 2007 07:38:57 -0000	1.50
--- shell.cpp	15 Feb 2007 13:11:02 -0000	1.51
***************
*** 14,17 ****
--- 14,18 ----
  
  #include "shell_pch.h"
+ #include "EmptyVC.h"
  #include "PyIShellLink.h"
  #include "PyIContextMenu.h"
***************
*** 19,22 ****
--- 20,25 ----
  #include "PyIShellExtInit.h"
  #include "PyIShellFolder.h"
+ #include "PyIEmptyVolumeCache.h"
+ #include "PyIEmptyVolumeCacheCallBack.h"
  #include "PyIEnumIDList.h"
  #include "PyICopyHook.h"
***************
*** 2318,2324 ****
--- 2321,2330 ----
  	PYCOM_INTERFACE_FULL(ColumnProvider),
  	PYCOM_INTERFACE_FULL(DropTargetHelper),
+ 	PYCOM_INTERFACE_CLIENT_ONLY(EmptyVolumeCacheCallBack),
  	PYCOM_INTERFACE_CLIENT_ONLY(QueryAssociations),
  	PYCOM_INTERFACE_SERVER_ONLY(DeskBand),
  	PYCOM_INTERFACE_SERVER_ONLY(DockingWindow),
+ 	PYCOM_INTERFACE_SERVER_ONLY(EmptyVolumeCache),
+ 	PYCOM_INTERFACE_SERVER_ONLY(EmptyVolumeCache2),
  	// IID_ICopyHook doesn't exist - hack it up
  	{ &IID_IShellCopyHook, "IShellCopyHook", "IID_IShellCopyHook", &PyICopyHook::type, GET_PYGATEWAY_CTOR(PyGCopyHook) },

--- NEW FILE: PyIEmptyVolumeCache.cpp ---
// This file implements the IEmptyVolumeCache Gateway for Python.

#include "shell_pch.h"
#include "EmptyVC.h"
#include "PyIEmptyVolumeCache.h"

// @doc - This file contains autoduck documentation
// @object PyIEmptyVolumeCache|Used for cleaning up temporary file ("disk cleanup")
// @comm This is a "gateway" object only - you can only implement this
// interface - see the shell/demos/server/empty_volume_cache.py.  The methods
// described here are the methods you must implement - you can't call them.
// <nl>Please contribute to these docs!
// @pymeth PyIEmptyVolumeCache|Initialize
// @pymeth PyIEmptyVolumeCache|GetSpaceUsed
// @pymeth PyIEmptyVolumeCache|Purge
// @pymeth PyIEmptyVolumeCache|ShowProperties
// @pymeth PyIEmptyVolumeCache2|InitializeEx
//
// ---------------------------------------------------
//
// Gateway Implementation
// @pymethod |PyIEmptyVolumeCache|Initialize|
STDMETHODIMP PyGEmptyVolumeCache::Initialize(
		/* [in] */ HKEY hkRegKey,
		/* [in] */ LPCWSTR pcwszVolume,
		/* [out] */ LPWSTR * ppwszDisplayName,
		/* [out] */ LPWSTR * ppwszDescription,
		/* [out] */ DWORD * pdwFlags)
{
	PY_GATEWAY_METHOD;
	HRESULT hr;
	BOOL bPythonIsHappy = TRUE;
	ULONG dwFlags;
	PyObject *result;
	PyObject *obppwszDisplayName; 
	PyObject *obppwszDescription;
	PyObject *obpcwszVolume = NULL;
	PyObject *obhkRegKey = PyWinObject_FromHKEY(hkRegKey);
	if (obhkRegKey==NULL) goto args_failed;
	if (!(obpcwszVolume = MakeOLECHARToObj(pcwszVolume))) goto args_failed;
	hr=InvokeViaPolicy("Initialize", &result, "NNk", obhkRegKey, obpcwszVolume, *pdwFlags);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params

	if (!PyTuple_Check(result)) {
		PyErr_Format(PyExc_TypeError, 
				"Initialize must return a tuple of (unicode, unicode, long) - got '%s'",
				result->ob_type->tp_name);
		bPythonIsHappy = FALSE;
	}
	if (bPythonIsHappy && !PyArg_ParseTuple(result, "OOl" , &obppwszDisplayName, &obppwszDescription, &dwFlags))
		bPythonIsHappy = FALSE;
	if (bPythonIsHappy && !PyWinObject_AsWCHAR(obppwszDisplayName, ppwszDisplayName)) bPythonIsHappy = FALSE;
	if (bPythonIsHappy && !PyWinObject_AsWCHAR(obppwszDescription, ppwszDescription)) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) hr = PyCom_SetAndLogCOMErrorFromPyException("Initialize", IID_IEmptyVolumeCache);
	if (pdwFlags) *pdwFlags = dwFlags;

	Py_DECREF(result);
	return hr;
args_failed:
	// only hit on error convering input args, not normal exit.
	Py_XDECREF(obhkRegKey);
	Py_XDECREF(obpcwszVolume);
	return MAKE_PYCOM_GATEWAY_FAILURE_CODE("Initialize");
}

// @pymethod |PyIEmptyVolumeCache|GetSpaceUsed|
STDMETHODIMP PyGEmptyVolumeCache::GetSpaceUsed(
		/* [out] */ DWORDLONG * pdwlSpaceUsed,
		/* [in] */ IEmptyVolumeCacheCallBack * picb)
{
	PY_GATEWAY_METHOD;
	PyObject *obpicb;
	obpicb = PyCom_PyObjectFromIUnknown(picb, IID_IEmptyVolumeCacheCallBack, TRUE);
	if (!obpicb)
		return MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetSpaceUsed");

	PyObject *result;
	HRESULT hr=InvokeViaPolicy("GetSpaceUsed", &result, "O", obpicb);
	Py_XDECREF(obpicb);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params

	if (!PyWinObject_AsUPY_LONG_LONG(result, pdwlSpaceUsed)) {
		PyErr_Format(PyExc_TypeError, 
				"GetSpaceUsed must return a long - got '%s'",
				result->ob_type->tp_name);
		hr = PyCom_SetAndLogCOMErrorFromPyException("GetSpaceUsed", IID_IEmptyVolumeCache);
	}
	Py_DECREF(result);
	return hr;
}

// @pymethod |PyIEmptyVolumeCache|Purge|
STDMETHODIMP PyGEmptyVolumeCache::Purge(
		/* [in] */ DWORDLONG dwlSpaceToFree,
		/* [in] */ IEmptyVolumeCacheCallBack * picb)
{
	PY_GATEWAY_METHOD;
	PyObject *obdwlSpaceToFree = PyLong_FromUnsignedLongLong(dwlSpaceToFree);
	if (obdwlSpaceToFree==NULL) return MAKE_PYCOM_GATEWAY_FAILURE_CODE("Purge");
	PyObject *obpicb;
	obpicb = PyCom_PyObjectFromIUnknown(picb, IID_IEmptyVolumeCacheCallBack, TRUE);
	if (!obpicb) {
		Py_DECREF(obdwlSpaceToFree);
		return MAKE_PYCOM_GATEWAY_FAILURE_CODE("Purge");
	}
	return InvokeViaPolicy("Purge", NULL, "NN", obdwlSpaceToFree, obpicb);
}

// @pymethod |PyIEmptyVolumeCache|ShowProperties|
STDMETHODIMP PyGEmptyVolumeCache::ShowProperties(
		/* [in] */ HWND hwnd)
{
	PY_GATEWAY_METHOD;
	return InvokeViaPolicy("ShowProperties", NULL, "N", PyWinLong_FromHANDLE(hwnd));
}

// @pymethod |PyIEmptyVolumeCache|Deactivate|
STDMETHODIMP PyGEmptyVolumeCache::Deactivate(
		/* [out] */ DWORD * pdwFlags)
{
	PY_GATEWAY_METHOD;
	PyObject *result;
	HRESULT hr=InvokeViaPolicy("Deactivate", &result);
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params

	BOOL bPythonIsHappy = TRUE;

	if (!PyWinObject_AsUPY_LONG_LONG(result, pdwFlags)) {
		PyErr_Format(PyExc_TypeError, 
		             "Deactivate must return a long - got '%s'",
		             result->ob_type->tp_name);
		hr = PyCom_SetAndLogCOMErrorFromPyException("Deactivate", IID_IEmptyVolumeCache);
	}
	Py_DECREF(result);
	return hr;
}

// IEmptyVolumeCache2
// @object PyIEmptyVolumeCache2|See also <o PyIEmptyVolumeCache>
// @pymeth PyIEmptyVolumeCache|Deactivate
// @pymethod |PyIEmptyVolumeCache2|InitializeEx|
STDMETHODIMP PyGEmptyVolumeCache2::InitializeEx(
		/* [in] */ HKEY hkRegKey,
		/* [in] */ LPCWSTR pcwszVolume,
		/* [in] */ LPCWSTR pcwszKeyName,
		/* [out] */ LPWSTR * ppwszDisplayName,
		/* [out] */ LPWSTR * ppwszDescription,
		/* [out] */ LPWSTR * ppwszBtnText,
		/* [out] */ DWORD * pdwFlags)
{
	PY_GATEWAY_METHOD;
	BOOL bPythonIsHappy = TRUE;
	ULONG dwFlags;
	HRESULT hr;
	PyObject *result;
	PyObject *obppwszDisplayName; 
	PyObject *obppwszDescription;
	PyObject *obppwszBtnText; 
	PyObject *obpcwszVolume = NULL;
	PyObject *obpcwszKeyName = NULL;
	PyObject *obhkRegKey = PyWinObject_FromHKEY(hkRegKey);
	if (!obhkRegKey) goto args_failed;
	if (!(obpcwszVolume = MakeOLECHARToObj(pcwszVolume))) goto args_failed;
	if (!(obpcwszKeyName = MakeOLECHARToObj(pcwszKeyName))) goto args_failed;
	hr=InvokeViaPolicy("InitializeEx", &result, "NNNk", obhkRegKey, obpcwszVolume, obpcwszKeyName, *pdwFlags);
	// NOTE: From here, do *not* exit via args_failed - the args have been cleaned up
	if (FAILED(hr)) return hr;
	// Process the Python results, and convert back to the real params

	if (!PyTuple_Check(result)) {
		PyErr_Format(PyExc_TypeError, 
				"Initialize must return a tuple of (unicode, unicode, unicode, long) - got '%s'",
				result->ob_type->tp_name);
		bPythonIsHappy = FALSE;
	}
	if (bPythonIsHappy && !PyArg_ParseTuple(result, "OOOl" , &obppwszDisplayName, &obppwszDescription, &obppwszBtnText, &dwFlags))
		bPythonIsHappy = FALSE;
	if (bPythonIsHappy && !PyWinObject_AsWCHAR(obppwszDisplayName, ppwszDisplayName)) bPythonIsHappy = FALSE;
	if (bPythonIsHappy && !PyWinObject_AsWCHAR(obppwszDescription, ppwszDescription)) bPythonIsHappy = FALSE;
	if (bPythonIsHappy && !PyWinObject_AsWCHAR(obppwszBtnText, ppwszBtnText)) bPythonIsHappy = FALSE;
	if (!bPythonIsHappy) hr = PyCom_SetAndLogCOMErrorFromPyException("InitializeEx", IID_IEmptyVolumeCache);
	if (pdwFlags) *pdwFlags = dwFlags;

	Py_DECREF(result);
	return hr;
args_failed:
	// only hit on error convering input args, not normal exit.
	Py_XDECREF(obhkRegKey);
	Py_XDECREF(obpcwszVolume);
	Py_XDECREF(obpcwszKeyName);
	return MAKE_PYCOM_GATEWAY_FAILURE_CODE("InitializeEx");
}