// @pymethod |PyIExtractIcon|Extract|Description of Extract. PyObject *PyIExtractIcon::Extract(PyObject *self, PyObject *args) { IExtractIconA *pIEI = GetI(self); if ( pIEI == NULL ) return NULL; // @pyparm <o unicode>|pszFile||Description for pszFile // @pyparm int|nIconIndex||Description for nIconIndex // @pyparm int|nIconSize||Description for nIconIndex HICON hiconLarge; HICON hiconSmall; PyObject *obpszFile; char *pszFile; UINT nIconIndex; UINT nIconSize; if ( !PyArg_ParseTuple(args, "Oii:Extract", &obpszFile, &nIconIndex, &nIconSize) ) return NULL; BOOL bPythonIsHappy = TRUE; if (!PyWinObject_AsString(obpszFile, &pszFile)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIEI->Extract( pszFile, nIconIndex, &hiconLarge, &hiconSmall, nIconSize ); PyWinObject_FreeString(pszFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIEI, IID_IExtractIcon ); if (hr==S_FALSE) return Py_BuildValue("OO", Py_None, Py_None); return Py_BuildValue("NN", PyWinLong_FromHANDLE(hiconLarge), PyWinLong_FromHANDLE(hiconSmall)); // @rdesc The result is (hicon_large, hicon_small), or // (None,None) if the underlying function returns S_FALSE, indicating // the calling application should extract it. }
STDMETHODIMP PyGExtractIcon::GetIconLocation( /* [unique][in] */ UINT uFlags, /* [unique][out] */ LPSTR szIconFile, /* [unique][in] */ UINT cchMax, /* [unique][out] */ LPINT piIndex, /* [unique][out] */ UINT *pflags) { PY_GATEWAY_METHOD; if (cchMax && szIconFile) szIconFile[0] = 0; *piIndex = 0; *pflags = 0; PyObject *result; HRESULT hr=InvokeViaPolicy("GetIconLocation", &result, "i", uFlags); if (FAILED(hr)) return hr; PyObject *obFileName; // Process the Python results, and convert back to the real params if (PyInt_Check(result) || PyLong_Check(result)) hr = PyInt_AsLong(result); else { if (PyArg_ParseTuple(result, "Oii", &obFileName, piIndex, pflags)) { char *filename; if (PyWinObject_AsString(obFileName, &filename)) { strncpy(szIconFile, filename, cchMax); PyWinObject_FreeString(filename); } } hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetIconLocation"); } Py_DECREF(result); return hr; }
// Converts a aequence of string or unicode objects into an array of char pointers void PyWinObject_FreeCharArray(char **pchars, DWORD str_cnt) { if (pchars!=NULL){ for (DWORD pchar_index=0; pchar_index<str_cnt; pchar_index++) PyWinObject_FreeString(pchars[pchar_index]); free(pchars); } }
// @pymethod |PyICopyHookA|CopyCallback|Description of CopyCallback. PyObject *PyICopyHookA::CopyCallback(PyObject *self, PyObject *args) { ICopyHookA *pICH = GetI(self); if ( pICH == NULL ) return NULL; // @pyparm HWND|hwnd||Description for hwnd // @pyparm int|wFunc||Description for wFunc // @pyparm int|wFlags||Description for wFlags // @pyparm string/<o unicode>|srcFile||Description for srcFile // @pyparm int|srcAttribs||Description for srcAttribs // @pyparm string/<o unicode>|destFile||Description for destFile // @pyparm int|destAttribs||Description for destAttribs PyObject *obsrcFile; PyObject *obdestFile; HWND hwnd; PyObject *obhwnd; UINT wFunc; UINT wFlags; LPSTR srcFile; DWORD srcAttribs; LPSTR destFile; DWORD destAttribs; if ( !PyArg_ParseTuple(args, "OiiOlOl:CopyCallback", &obhwnd, &wFunc, &wFlags, &obsrcFile, &srcAttribs, &obdestFile, &destAttribs) ) return NULL; if (!PyWinObject_AsHANDLE(obhwnd, (HANDLE *)&hwnd)) return NULL; BOOL bPythonIsHappy = TRUE; if (bPythonIsHappy && !PyWinObject_AsString(obsrcFile, &srcFile)) bPythonIsHappy = FALSE; if (bPythonIsHappy && !PyWinObject_AsString(obdestFile, &destFile)) bPythonIsHappy = FALSE; if (!bPythonIsHappy) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pICH->CopyCallback( hwnd, wFunc, wFlags, srcFile, srcAttribs, destFile, destAttribs ); PyWinObject_FreeString(srcFile); PyWinObject_FreeString(destFile); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pICH, IID_IShellCopyHook ); Py_INCREF(Py_None); return Py_None; }
void PyWinObject_FreeResourceId(WCHAR *resource_id) { if ((resource_id!=NULL) && !IS_INTRESOURCE(resource_id)) PyWinObject_FreeString(resource_id); }
// @object PySPropValue|A MAPI property value. Property values can either be passed from // python into MAPI functions, or returned from MAPI functions to Python. BOOL PyMAPIObject_AsSPropValue(PyObject *Valob, SPropValue *pv, void *pAllocMoreLinkBlock) { PyObject *ob; // @pyparm int|propType||The type of the MAPI property // @pyparm object|value||The property value if (!PyArg_ParseTuple(Valob, "lO:SPropValue item", &pv->ulPropTag, &ob )) { PyErr_Clear(); PyErr_SetString(PyExc_TypeError, "An SPropValue item must be a tuple of (integer, object)"); return NULL; } BOOL ok = TRUE; unsigned int i; PyErr_Clear(); // @comm The parameters can be one of the following pairs of values. // @flagh propType|value switch (PROP_TYPE(pv->ulPropTag)) { // @flag PT_I2|An integer case PT_I2: // case PT_SHORT: pv->Value.i = (int)PyInt_AsLong(ob); break; // @flag PT_MV_I2|A sequence of integers case PT_MV_I2: MAKE_MV(short int, pAllocMoreLinkBlock, pv->Value.MVi.lpi, pv->Value.MVi.cValues, PyInt_AsLong) // @flag PT_I4|An integer case PT_I4: // case PT_LONG: pv->Value.l = PyInt_AsLong(ob); break; // @flag PT_MV_I4|A sequence of integers case PT_MV_I4: MAKE_MV(long, pAllocMoreLinkBlock, pv->Value.MVl.lpl, pv->Value.MVl.cValues, PyInt_AsLong) // @flag PT_R4|A float case PT_R4: // case PT_FLOAT: pv->Value.flt = (float)PyFloat_AsDouble(ob); break; // @flag PT_MV_R4|A sequence of floats case PT_MV_R4: MAKE_MV(float, pAllocMoreLinkBlock, pv->Value.MVflt.lpflt, pv->Value.MVflt.cValues, PyFloat_AsDouble) // @flag PT_R8|A float case PT_R8: // case PT_DOUBLE: pv->Value.dbl = PyFloat_AsDouble(ob); break; // @flag PT_MV_R8|A sequence of floats case PT_MV_R8: MAKE_MV(double, pAllocMoreLinkBlock, pv->Value.MVdbl.lpdbl, pv->Value.MVdbl.cValues, PyFloat_AsDouble) // @flag PT_BOOLEAN|A boolean value (or an int) case PT_BOOLEAN: pv->Value.b = PyInt_AsLong(ob) ? VARIANT_TRUE : VARIANT_FALSE; break; /* case PT_CURRENCY: p->Value.cur ?? break; */ // @flag PT_APPTIME|A <o PyTime> object case PT_APPTIME : ok = PyWinObject_AsDATE(ob, &pv->Value.at); break; // @flag PT_MV_APPTIME|An sequence of <o PyTime> object case PT_MV_APPTIME: MAKEB_MV(double, pAllocMoreLinkBlock, pv->Value.MVat.lpat, pv->Value.MVat.cValues, PyWinObject_AsDATE) // @flag PT_SYSTIME|A <o PyTime> object case PT_SYSTIME: ok = PyWinObject_AsFILETIME(ob, &pv->Value.ft); break; // @flag PT_MV_APPTIME|An sequence of <o PyTime> object case PT_MV_SYSTIME: MAKEB_MV(FILETIME, pAllocMoreLinkBlock, pv->Value.MVft.lpft, pv->Value.MVft.cValues, PyWinObject_AsFILETIME) // @flag PT_STRING8|A string or <o PyUnicode> case PT_STRING8: { // Copy into new MAPI memory block DWORD bufLen; char *str; ok = PyWinObject_AsString(ob, &str, FALSE, &bufLen); if (ok) { bufLen++; HRESULT hr = MAPIAllocateMore(bufLen, pAllocMoreLinkBlock, (void **)&pv->Value.lpszA); if (S_OK!=hr) { OleSetOleError(hr); ok = FALSE; } else { memcpy(pv->Value.lpszA, str, bufLen-sizeof(char)); // Null terminate memcpy(((char *)pv->Value.lpszA)+(bufLen-sizeof(char)),"\0", sizeof(char)); } } PyWinObject_FreeString(str); break; } // @flag PT_STRING8|A sequence of string or <o PyUnicode> objects. case PT_MV_STRING8: ok = AllocMVBuffer( ob, sizeof(char *), pAllocMoreLinkBlock, (void **)&pv->Value.MVszA.lppszA, &pv->Value.MVszA.cValues); if (!ok) break; for (i=0; ok && !PyErr_Occurred() && i<pv->Value.MVszA.cValues; i++) { PyObject *obmv=PySequence_GetItem(ob,i); if (obmv==NULL) break; DWORD bufLen; char *str; ok = PyWinObject_AsString(obmv, &str, FALSE, &bufLen); if (ok) { bufLen++; HRESULT hr = MAPIAllocateMore(bufLen, pAllocMoreLinkBlock, (void **)&pv->Value.MVszA.lppszA[i]); if (S_OK!=hr) { OleSetOleError(hr); ok = FALSE; } else { memcpy(pv->Value.MVszA.lppszA[i], str, bufLen-sizeof(char)); // Null terminate memcpy(((char *)pv->Value.MVszA.lppszA[i])+(bufLen-sizeof(char)),"\0", sizeof(char)); } } PyWinObject_FreeString(str); Py_DECREF(obmv); } break; // @flag PT_UNICODE|A string or <o PyUnicode> case PT_UNICODE: { // Bit of a hack - need to copy into MAPI block. BSTR wstr = NULL; ok = PyWinObject_AsBstr(ob, &wstr, FALSE); if (ok) { DWORD bufSize = sizeof(WCHAR) * (SysStringLen(wstr)+1); HRESULT hr = MAPIAllocateMore(bufSize, pAllocMoreLinkBlock, (void **)&pv->Value.lpszW); if (S_OK!=hr) { OleSetOleError(hr); ok = FALSE; } else { memcpy(pv->Value.lpszW, wstr, bufSize-2); // Null terminate memcpy(((char *)pv->Value.lpszW)+(bufSize-2),"\0\0", 2); } } SysFreeString(wstr); break; } // @flag PT_MV_UNICODE|A sequence of string or <o PyUnicode> case PT_MV_UNICODE: ok = AllocMVBuffer( ob, sizeof(char *), pAllocMoreLinkBlock, (void **)&pv->Value.MVszW.lppszW, &pv->Value.MVszW.cValues); if (!ok) break; for (i=0; ok && !PyErr_Occurred() && i<pv->Value.MVszW.cValues; i++) { PyObject *obmv=PySequence_GetItem(ob,i); if (obmv==NULL) break; BSTR wstr = NULL; ok = PyWinObject_AsBstr(obmv, &wstr, FALSE); if (ok) { DWORD bufSize = sizeof(WCHAR) * (SysStringLen(wstr)+1); HRESULT hr = MAPIAllocateMore(bufSize, pAllocMoreLinkBlock, (void **)&pv->Value.MVszW.lppszW[i]); if (S_OK!=hr) { OleSetOleError(hr); ok = FALSE; } else { memcpy(pv->Value.MVszW.lppszW[i], wstr, bufSize-2); // Null terminate memcpy(((char *)pv->Value.MVszW.lppszW[i])+(bufSize-2),"\0\0", 2); } } SysFreeString(wstr); Py_DECREF(obmv); } break; // @flag PT_BINARY|A string containing binary data case PT_BINARY: pv->Value.bin.lpb = (unsigned char *)PyString_AsString(ob); pv->Value.bin.cb = PyString_Size(ob); break; // @flag PT_MV_BINARY|A sequence of strings containing binary data case PT_MV_BINARY: ok = AllocMVBuffer( ob, sizeof(SBinary), pAllocMoreLinkBlock, (void **)&pv->Value.MVbin.lpbin, &pv->Value.MVbin.cValues); for (i=0; !PyErr_Occurred() && i<pv->Value.MVbin.cValues; i++) { PyObject *obmv=PySequence_GetItem(ob,i); if (obmv==NULL) break; pv->Value.MVbin.lpbin[i].lpb = (unsigned char *)PyString_AsString(ob); pv->Value.MVbin.lpbin[i].cb = PyString_Size(ob); Py_DECREF(obmv); } break; // @flag PT_CLSID|A <o PyIID> case PT_CLSID: { HRESULT hr = MAPIAllocateMore(sizeof(CLSID), pAllocMoreLinkBlock, (void **)&pv->Value.lpguid); if (S_OK != hr) { OleSetOleError(hr); ok = FALSE; } else ok = PyWinObject_AsIID(ob, pv->Value.lpguid); break; } // @flag PT_MV_CLSID|A sequence of <o PyIID> objects case PT_MV_CLSID: MAKEB_MV(CLSID, pAllocMoreLinkBlock, pv->Value.MVguid.lpguid, pv->Value.MVguid.cValues, PyWinObject_AsIID) // @flag PT_I8|A <o PyLARGE_INTEGER> case PT_I8: // case PT_LONGLONG: ok = PyWinObject_AsLARGE_INTEGER(ob, &pv->Value.li); break; // @flag PT_MV_I8|A sequence of <o PyLARGE_INTEGER> case PT_MV_I8: MAKEB_MV(LARGE_INTEGER, pAllocMoreLinkBlock, pv->Value.MVli.lpli, pv->Value.MVli.cValues, PyWinObject_AsLARGE_INTEGER) // @flag PT_ERROR|An integer error code. case PT_ERROR: pv->Value.err = (SCODE)PyInt_AsLong(ob); break; // @flag PT_NULL|Anything! case PT_NULL: pv->Value.x = 0; break; default: { char buf[128]; sprintf(buf, "Unsupported MAPI property type 0x%X", PROP_TYPE(pv->ulPropTag)); PyErr_SetString(PyExc_TypeError, buf); ok = FALSE; } } ok = (ok && !PyErr_Occurred()); return ok; }
//***************************************************************************** // // @pymethod int|win32clipboard|SetClipboardText|Convienience function to // call SetClipboardData with text. // @comm You may pass a Unicode or string/bytes object to this function, // but depending on the value of the 'format' param, it may be converted // to the appropriate type for that param. // @comm Many applications will want to call this function twice, with the // same string specified but CF_UNICODETEXT specified the second. static PyObject * py_set_clipboard_text(PyObject* self, PyObject* args) { int format = CF_TEXT; PyObject *obtext, *ret=NULL; if (!PyArg_ParseTuple(args, "O|i:SetClipboardText", &obtext, // @pyparm str/unicode|text||The text to place on the clipboard. &format)) // @pyparm int|format|CF_TEXT|The clipboard format to use - must be CF_TEXT or CF_UNICODETEXT return NULL; const void *src = 0; DWORD cb = 0; // number of bytes *excluding* NULL size_t size_null = 0; if (format == CF_TEXT) { if (!PyWinObject_AsString(obtext, (char **)&src, FALSE, &cb)) return NULL; size_null = sizeof(char); } else if (format == CF_UNICODETEXT) { DWORD cchars; if (!PyWinObject_AsWCHAR(obtext, (WCHAR **)&src, FALSE, &cchars)) return NULL; cb = cchars * sizeof(WCHAR); size_null = sizeof(WCHAR); } else { return PyErr_Format(PyExc_ValueError, "Format arg must be one of CF_TEXT (%d) or CF_UNICODETEXT (%d) - got %d", CF_TEXT, CF_UNICODETEXT, format); } HGLOBAL hMem; BYTE *dest=NULL; hMem = GlobalAlloc(GHND, cb + size_null); if (hMem == NULL) PyWin_SetAPIError("GlobalAlloc"); else{ dest = (BYTE *)GlobalLock(hMem); memcpy(dest, src, cb); // whack the terminator on. memset(dest+cb, 0, size_null); GlobalUnlock(hMem); HANDLE data; Py_BEGIN_ALLOW_THREADS; data = SetClipboardData((UINT)format, hMem); Py_END_ALLOW_THREADS; if (!data) PyWin_SetAPIError("SetClipboardText"); else ret = PyWinLong_FromHANDLE(data); } if (format == CF_TEXT) PyWinObject_FreeString((char *)src); else PyWinObject_FreeWCHAR((WCHAR *)src); return ret; // @pyseeapi SetClipboardData // @rdesc If the function succeeds, the return value is integer handle // of the data.<nl> // If the function fails, win32api.error is raised with the GetLastError // info. }