STDMETHODIMP PyGShellItemResources::SetTimes(
/* [in] */ const FILETIME * pftCreation,
/* [in] */ const FILETIME * pftWrite,
/* [in] */ const FILETIME * pftAccess)
{
PY_GATEWAY_METHOD;
HRESULT hr=InvokeViaPolicy("SetTimes", NULL, "NNN",
PyWinObject_FromFILETIME(*pftCreation),
PyWinObject_FromFILETIME(*pftWrite),
PyWinObject_FromFILETIME(*pftAccess));
return hr;
}
PyObject *PyObject_FromWIN32_FIND_DATAW(WIN32_FIND_DATAW *pData)
{
return Py_BuildValue("lNNNNNNNuu",
pData->dwFileAttributes,
PyWinObject_FromFILETIME(pData->ftCreationTime),
PyWinObject_FromFILETIME(pData->ftLastAccessTime),
PyWinObject_FromFILETIME(pData->ftLastWriteTime),
PyLong_FromUnsignedLong(pData->nFileSizeHigh),
PyLong_FromUnsignedLong(pData->nFileSizeLow),
PyLong_FromUnsignedLong(pData->dwReserved0),
PyLong_FromUnsignedLong(pData->dwReserved1),
pData->cFileName,
pData->cAlternateFileName);
}
PyObject *PyObject_FromWIN32_FIND_DATAA(WIN32_FIND_DATAA *pData)
{
// @object WIN32_FIND_DATA|A tuple representing a WIN32_FIND_DATA structure.
return Py_BuildValue("lNNNNNNNss",
pData->dwFileAttributes, // @tupleitem 0|int|attributes|File Attributes. A combination of the win32com.FILE_ATTRIBUTE_* flags.
PyWinObject_FromFILETIME(pData->ftCreationTime), // @tupleitem 1|<o PyTime>|createTime|File creation time.
PyWinObject_FromFILETIME(pData->ftLastAccessTime), // @tupleitem 2|<o PyTime>|accessTime|File access time.
PyWinObject_FromFILETIME(pData->ftLastWriteTime), // @tupleitem 3|<o PyTime>|writeTime|Time of last file write
PyLong_FromUnsignedLong(pData->nFileSizeHigh), // @tupleitem 4|int|nFileSizeHigh|high order DWORD of file size.
PyLong_FromUnsignedLong(pData->nFileSizeLow), // @tupleitem 5|int|nFileSizeLow|low order DWORD of file size.
PyLong_FromUnsignedLong(pData->dwReserved0), // @tupleitem 6|int|reserved0|Contains reparse tag if path is a reparse point
PyLong_FromUnsignedLong(pData->dwReserved1), // @tupleitem 7|int|reserved1|Reserved.
pData->cFileName, // @tupleitem 8|str/unicode|fileName|The name of the file.
pData->cAlternateFileName); // @tupleitem 9|str/unicode|alternateFilename|Alternative name of the file, expressed in 8.3 format.
}
PyObject *MakeTimeOrNone(const FILETIME &t)
{
if (t.dwLowDateTime==0 && t.dwHighDateTime==0) {
Py_INCREF(Py_None);
return Py_None;
}
return PyWinObject_FromFILETIME(t);
}
// @pymethod <o PyTime>|pywintypes|DosDateTimeToTime|Converts an MS-DOS Date/Time to a standard Time object.
static PyObject *PyWin_DosDateTimeToTime(PyObject *self, PyObject *args)
{
WORD wFatDate, wFatTime;
if (!PyArg_ParseTuple(args, "hh", (WORD *)&wFatDate, (WORD *)&wFatTime))
return NULL;
FILETIME fd;
if (!DosDateTimeToFileTime(wFatDate, wFatTime, &fd))
return PyWin_SetAPIError("DosDateTimeToFileTime");
return PyWinObject_FromFILETIME(fd);
}
STDMETHODIMP PyGPropertyStorage::SetTimes(
/* [in] */ const FILETIME * pctime,
/* [in] */ const FILETIME * patime,
/* [in] */ const FILETIME * pmtime)
{
PY_GATEWAY_METHOD;
HRESULT hr;
{
TmpPyObject obctime, obatime, obmtime;
if (pctime){
obctime = PyWinObject_FromFILETIME(*pctime);
if (obctime==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("SetTimes");
}
else{
Py_INCREF(Py_None);
obctime = Py_None;
}
if (patime){
obatime = PyWinObject_FromFILETIME(*patime);
if (obatime==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("SetTimes");
}
else{
Py_INCREF(Py_None);
obatime = Py_None;
}
if (pmtime){
obmtime = PyWinObject_FromFILETIME(*pmtime);
if (obmtime==NULL)
return MAKE_PYCOM_GATEWAY_FAILURE_CODE("SetTimes");
}
else{
Py_INCREF(Py_None);
obmtime = Py_None;
}
hr =InvokeViaPolicy("SetTimes", NULL, "OOO", obctime, obatime, obmtime);
}
return hr;
}
// @pymethod |PyIShellItemResources|GetTimes|Description of GetTimes.
PyObject *PyIShellItemResources::GetTimes(PyObject *self, PyObject *args)
{
IShellItemResources *pISIR = GetI(self);
if ( pISIR == NULL )
return NULL;
FILETIME ftCreation;
FILETIME ftWrite;
FILETIME ftAccess;
if ( !PyArg_ParseTuple(args, ":GetTimes") )
return NULL;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pISIR->GetTimes( &ftCreation, &ftWrite, &ftAccess );
PY_INTERFACE_POSTCALL;
if ( FAILED(hr) )
return PyCom_BuildPyException(hr, pISIR, IID_IShellItemResources );
return Py_BuildValue("NNN",
PyWinObject_FromFILETIME(ftCreation),
PyWinObject_FromFILETIME(ftWrite),
PyWinObject_FromFILETIME(ftAccess));
}
PyObject *PyObject_FromPROPVARIANT( PROPVARIANT *pVar )
{
switch (pVar->vt) {
case VT_EMPTY:
case VT_NULL:
case VT_ILLEGAL:
Py_INCREF(Py_None);
return Py_None;
case VT_I1:
return PyInt_FromLong(pVar->cVal);
case VT_I1|VT_VECTOR:
return VectorToSeq(pVar->cac.pElems, pVar->cac.cElems, PyWinObject_FromCHAR);
case VT_UI1:
return PyInt_FromLong(pVar->bVal);
case VT_UI1|VT_VECTOR:
return VectorToSeq(pVar->caub.pElems, pVar->caub.cElems, PyWinObject_FromUCHAR);
case VT_I2:
return PyInt_FromLong(pVar->iVal);
case VT_I2|VT_VECTOR:
return VectorToSeq(pVar->cai.pElems, pVar->cai.cElems, PyWinObject_FromSHORT);
case VT_UI2:
return PyInt_FromLong(pVar->uiVal);
case VT_UI2|VT_VECTOR:
return VectorToSeq(pVar->caui.pElems, pVar->caui.cElems, PyWinObject_FromUSHORT);
case VT_I4:
return PyInt_FromLong(pVar->lVal);
case VT_I4|VT_VECTOR:
return VectorToSeq(pVar->cal.pElems, pVar->cal.cElems, PyInt_FromLong);
case VT_INT:
return PyInt_FromLong(pVar->intVal);
case VT_UI4:
return PyLong_FromUnsignedLong(pVar->ulVal);
case VT_UI4|VT_VECTOR:
return VectorToSeq(pVar->caul.pElems, pVar->caul.cElems, PyLong_FromUnsignedLong);
case VT_UINT:
return PyLong_FromUnsignedLong(pVar->uintVal);
case VT_I8:
return PyWinObject_FromLARGE_INTEGER(pVar->hVal);
case VT_I8|VT_VECTOR:
return VectorToSeq<LARGE_INTEGER>(pVar->cah.pElems, pVar->cah.cElems, PyWinObject_FromLARGE_INTEGER);
case VT_UI8:
return PyWinObject_FromULARGE_INTEGER(pVar->uhVal);
case VT_UI8|VT_VECTOR:
return VectorToSeq<ULARGE_INTEGER>(pVar->cauh.pElems, pVar->cauh.cElems, PyWinObject_FromULARGE_INTEGER);
case VT_R4:
return PyFloat_FromDouble(pVar->fltVal);
case VT_R4|VT_VECTOR:
return VectorToSeq(pVar->caflt.pElems, pVar->caflt.cElems, PyWinObject_FromFLOAT);
case VT_R8:
return PyFloat_FromDouble(pVar->dblVal);
case VT_R8|VT_VECTOR:
return VectorToSeq(pVar->cadbl.pElems, pVar->cadbl.cElems, PyFloat_FromDouble);
case VT_CY:
return PyObject_FromCurrency(pVar->cyVal);
case VT_CY|VT_VECTOR:
return VectorToSeq<CY>(pVar->cacy.pElems, pVar->cacy.cElems, PyObject_FromCurrency);
case VT_DATE:
return PyWinObject_FromDATE(pVar->date);
case VT_DATE|VT_VECTOR:
return VectorToSeq(pVar->cadate.pElems, pVar->cadate.cElems, PyWinObject_FromDATE);
case VT_BSTR:
return PyWinObject_FromBstr(pVar->bstrVal);
case VT_BSTR|VT_VECTOR:
return VectorToSeq(pVar->cabstr.pElems, pVar->cabstr.cElems, PyWinObject_FromVT_BSTR);
case VT_BOOL:
return PyWinObject_FromVARIANT_BOOL(pVar->boolVal);
case VT_BOOL|VT_VECTOR:
return VectorToSeq(pVar->cabool.pElems, pVar->cabool.cElems, PyWinObject_FromVARIANT_BOOL);
case VT_ERROR:
return PyInt_FromLong(pVar->scode);
case VT_ERROR|VT_VECTOR:
return VectorToSeq(pVar->cascode.pElems, pVar->cascode.cElems, PyInt_FromLong);
case VT_FILETIME:
return PyWinObject_FromFILETIME(pVar->filetime);
case VT_FILETIME|VT_VECTOR:
return VectorToSeq<FILETIME>(pVar->cafiletime.pElems, pVar->cafiletime.cElems, PyWinObject_FromFILETIME);
case VT_LPSTR:
if (pVar->pszVal == NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return PyWinCoreString_FromString(pVar->pszVal);
case VT_LPSTR|VT_VECTOR:
{
PyObject *ret = PyList_New(pVar->calpstr.cElems);
if (ret==NULL) return NULL;
for (ULONG i=0; i<pVar->calpstr.cElems;i++){
PyObject *elem=PyWinCoreString_FromString(pVar->calpstr.pElems[i]);
if (elem==NULL){
Py_DECREF(ret);
return NULL;
}
PyList_SET_ITEM(ret, i, elem);
}
return ret;
}
case VT_LPWSTR:
return PyWinObject_FromOLECHAR(pVar->pwszVal);
case VT_LPWSTR|VT_VECTOR:
{
PyObject *ret = PyList_New(pVar->calpwstr.cElems);
if (ret==NULL) return NULL;
for (ULONG i=0; i<pVar->calpwstr.cElems;i++){
PyObject *elem=PyWinObject_FromWCHAR(pVar->calpwstr.pElems[i]);
if (elem==NULL){
Py_DECREF(ret);
return NULL;
}
PyList_SET_ITEM(ret, i, elem);
}
return ret;
}
case VT_CLSID:
return PyWinObject_FromIID(*pVar->puuid);
case VT_CLSID|VT_VECTOR:
return VectorToSeq<CLSID>(pVar->cauuid.pElems, pVar->cauuid.cElems, PyWinObject_FromIID);
case VT_STREAM:
case VT_STREAMED_OBJECT:
return PyCom_PyObjectFromIUnknown(pVar->pStream, IID_IStream, TRUE);
case VT_STORAGE:
case VT_STORED_OBJECT:
return PyCom_PyObjectFromIUnknown(pVar->pStorage, IID_IStorage, TRUE);
case VT_VECTOR | VT_VARIANT:
return PyObject_FromPROPVARIANTs(pVar->capropvar.pElems, pVar->capropvar.cElems);
case VT_BLOB:
case VT_BLOB_OBJECT:
return PyString_FromStringAndSize((const char *)pVar->blob.pBlobData,
pVar->blob.cbSize);
// case VT_UNKNOWN:
// return PyCom_PyObjectFromIUnknown(pVar->punkVal, IID_IUnknown, TRUE);
// case VT_DISPATCH:
// return PyCom_PyObjectFromIUnknown(pVar->pdispVal, IID_IDispatch, TRUE);
/*
// Want to get VT_CF and VT_BLOB working with a test case first!
case VT_CF: { // special "clipboard format"
// cbSize is the size of the buffer pointed to
// by pClipData, plus sizeof(ulClipFmt)
// XXX - in that case, shouldn't we pass
// pClipData + sizeof(DWORD) to Py_BuildValue??
ULONG cb = CBPCLIPDATA(*pVar->pclipdata);
return Py_BuildValue("is#",
pVar->pclipdata->ulClipFmt,
pVar->pclipdata->pClipData,
(int)cb);
}
*/
default:
PyErr_Format(PyExc_TypeError, "Unsupported property type 0x%x", pVar->vt);
return NULL;
}
}
PyObject *PyMAPIObject_FromSPropValue(SPropValue *pv)
{
PyObject *val;
ULONG i;
switch (PROP_TYPE(pv->ulPropTag)) {
case PT_I2: // case PT_SHORT:
val = PyInt_FromLong(pv->Value.i);
break;
case PT_I4: // case PT_LONG:
val = PyInt_FromLong(pv->Value.l);
break;
case PT_R4: // case PT_FLOAT:
val = PyFloat_FromDouble(pv->Value.flt);
break;
case PT_R8: // case PT_DOUBLE:
val = PyFloat_FromDouble(pv->Value.dbl);
break;
case PT_BOOLEAN:
val = pv->Value.b ? Py_True : Py_False;
Py_INCREF(val);
break;
/*
case PT_CURRENCY:
pv->Value.cur??
break;
*/
case PT_APPTIME :
val = PyWinObject_FromDATE(pv->Value.at);
break;
case PT_SYSTIME:
val = PyWinObject_FromFILETIME(pv->Value.ft);
break;
case PT_STRING8:
val = PyString_FromString(pv->Value.lpszA);
break;
case PT_UNICODE:
val = PyWinObject_FromWCHAR(pv->Value.lpszW);
break;
case PT_BINARY:
val = PyString_FromStringAndSize((char *)pv->Value.bin.lpb, pv->Value.bin.cb);
break;
case PT_CLSID:
val = PyWinObject_FromIID(*pv->Value.lpguid);
break;
case PT_I8:
// case PT_LONGLONG:
val = PyWinObject_FromLARGE_INTEGER(pv->Value.li);
break;
case PT_ERROR:
val = PyInt_FromLong(pv->Value.err);
break;
case PT_NULL:
val = Py_None;
Py_INCREF(Py_None);
break;
case PT_MV_I2:
val = PyTuple_New(pv->Value.MVi.cValues);
if (val) {
for (i=0; i<pv->Value.MVi.cValues; i++)
PyTuple_SET_ITEM(val, i, PyInt_FromLong(pv->Value.MVi.lpi[i]));
}
break;
case PT_MV_LONG:
val = PyTuple_New(pv->Value.MVi.cValues);
if (val) {
for (i=0; i<pv->Value.MVl.cValues; i++)
PyTuple_SET_ITEM(val, i, PyInt_FromLong(pv->Value.MVl.lpl[i]));
}
break;
case PT_MV_R4:
val = PyTuple_New(pv->Value.MVflt.cValues);
if (val) {
for (i=0; i<pv->Value.MVflt.cValues; i++)
PyTuple_SET_ITEM(val, i, PyFloat_FromDouble(pv->Value.MVflt.lpflt[i]));
}
break;
case PT_MV_DOUBLE :
val = PyTuple_New(pv->Value.MVdbl.cValues);
if (val) {
for (i=0; i<pv->Value.MVdbl.cValues; i++)
PyTuple_SET_ITEM(val, i, PyFloat_FromDouble(pv->Value.MVdbl.lpdbl[i]));
}
break;
/*
case PT_MV_CURRENCY:
MVcur
SCurrencyArray
*/
case PT_MV_APPTIME :
val = PyTuple_New(pv->Value.MVat.cValues);
if (val) {
for (i=0; i<pv->Value.MVat.cValues; i++)
PyTuple_SET_ITEM(val, i, PyWinObject_FromDATE(pv->Value.MVat.lpat[i]));
}
break;
case PT_MV_SYSTIME:
val = PyTuple_New(pv->Value.MVft.cValues);
if (val) {
for (i=0; i<pv->Value.MVft.cValues; i++)
PyTuple_SET_ITEM(val, i, PyWinObject_FromFILETIME(pv->Value.MVft.lpft[i]));
}
break;
case PT_MV_BINARY:
val = PyTuple_New(pv->Value.MVbin.cValues);
if (val) {
for (i=0; i<pv->Value.MVbin.cValues; i++)
PyTuple_SET_ITEM(val, i, PyString_FromStringAndSize((char *)pv->Value.MVbin.lpbin[i].lpb, pv->Value.MVbin.lpbin[i].cb));
}
break;
case PT_MV_STRING8:
val = PyTuple_New(pv->Value.MVszA.cValues);
if (val) {
for (i=0; i<pv->Value.MVszA.cValues; i++)
PyTuple_SET_ITEM(val, i, PyString_FromString(pv->Value.MVszA.lppszA[i]));
}
break;
case PT_MV_UNICODE:
val = PyTuple_New(pv->Value.MVszW.cValues);
if (val) {
for (i=0; i<pv->Value.MVszW.cValues; i++)
PyTuple_SET_ITEM(val, i, PyWinObject_FromWCHAR(pv->Value.MVszW.lppszW[i]));
}
break;
/*
case PT_MV_CLSID:
MVguid
SGuidArray
case PT_MV_I8:
MVli
SLargeIntegerArray
*/
case PT_OBJECT:
val = PyInt_FromLong(pv->Value.x);
break;
default:
printf("File %s: Unsupported MAPI property type 0x%X", __FILE__, PROP_TYPE(pv->ulPropTag));
/* Dont set exception, as this prevents otherwise valid props from
being returned
*/
val = Py_None;
Py_INCREF(Py_None);
break;
}
PyObject *rc = PyTuple_New(2);
if (rc==NULL) {
Py_DECREF(val);
PyErr_SetString(PyExc_MemoryError, "Tuple(2) for PROP result");
return NULL;
}
PyTuple_SET_ITEM(rc, 0, PyInt_FromLong(pv->ulPropTag));
PyTuple_SET_ITEM(rc, 1, val);
return rc;
}
