/************************************************************************* * SHPropStgReadMultiple [SHELL32.688] */ HRESULT WINAPI SHPropStgReadMultiple(IPropertyStorage *pps, UINT uCodePage, ULONG cpspec, const PROPSPEC *rgpspec, PROPVARIANT *rgvar) { STATPROPSETSTG stat; HRESULT hres; FIXME("%p %u %u %p %p\n", pps, uCodePage, cpspec, rgpspec, rgvar); memset(rgvar, 0, cpspec*sizeof(PROPVARIANT)); hres = IPropertyStorage_ReadMultiple(pps, cpspec, rgpspec, rgvar); if(FAILED(hres)) return hres; if(!uCodePage) { PROPSPEC prop; PROPVARIANT ret; prop.ulKind = PRSPEC_PROPID; prop.u.propid = PID_CODEPAGE; hres = IPropertyStorage_ReadMultiple(pps, 1, &prop, &ret); if(FAILED(hres) || ret.vt!=VT_I2) return S_OK; uCodePage = ret.u.iVal; } hres = IPropertyStorage_Stat(pps, &stat); if(FAILED(hres)) return S_OK; /* TODO: do something with codepage and stat */ return S_OK; }
/************************************************************************* * SHPropStgCreate [SHELL32.685] */ HRESULT WINAPI SHPropStgCreate(IPropertySetStorage *psstg, REFFMTID fmtid, const CLSID *pclsid, DWORD grfFlags, DWORD grfMode, DWORD dwDisposition, IPropertyStorage **ppstg, UINT *puCodePage) { PROPSPEC prop; PROPVARIANT ret; HRESULT hres; TRACE("%p %s %s %x %x %x %p %p\n", psstg, debugstr_guid(fmtid), debugstr_guid(pclsid), grfFlags, grfMode, dwDisposition, ppstg, puCodePage); hres = IPropertySetStorage_Open(psstg, fmtid, grfMode, ppstg); switch(dwDisposition) { case CREATE_ALWAYS: if(SUCCEEDED(hres)) { IPropertyStorage_Release(*ppstg); hres = IPropertySetStorage_Delete(psstg, fmtid); if(FAILED(hres)) return hres; hres = E_FAIL; } case OPEN_ALWAYS: case CREATE_NEW: if(FAILED(hres)) hres = IPropertySetStorage_Create(psstg, fmtid, pclsid, grfFlags, grfMode, ppstg); case OPEN_EXISTING: if(FAILED(hres)) return hres; if(puCodePage) { prop.ulKind = PRSPEC_PROPID; prop.u.propid = PID_CODEPAGE; hres = IPropertyStorage_ReadMultiple(*ppstg, 1, &prop, &ret); if(FAILED(hres) || ret.vt!=VT_I2) *puCodePage = 0; else *puCodePage = ret.u.iVal; } } return S_OK; }
/************************************************************************* * SHPropStgWriteMultiple [SHELL32.689] */ HRESULT WINAPI SHPropStgWriteMultiple(IPropertyStorage *pps, UINT *uCodePage, ULONG cpspec, const PROPSPEC *rgpspec, PROPVARIANT *rgvar, PROPID propidNameFirst) { STATPROPSETSTG stat; UINT codepage; HRESULT hres; FIXME("%p %p %u %p %p %d\n", pps, uCodePage, cpspec, rgpspec, rgvar, propidNameFirst); hres = IPropertyStorage_Stat(pps, &stat); if(FAILED(hres)) return hres; if(uCodePage && *uCodePage) codepage = *uCodePage; else { PROPSPEC prop; PROPVARIANT ret; prop.ulKind = PRSPEC_PROPID; prop.u.propid = PID_CODEPAGE; hres = IPropertyStorage_ReadMultiple(pps, 1, &prop, &ret); if(FAILED(hres)) return hres; if(ret.vt!=VT_I2 || !ret.u.iVal) return E_FAIL; codepage = ret.u.iVal; if(uCodePage) *uCodePage = codepage; } /* TODO: do something with codepage and stat */ hres = IPropertyStorage_WriteMultiple(pps, cpspec, rgpspec, rgvar, propidNameFirst); return hres; }
/* FIXME: this creates an ANSI storage, try to find conditions under which * Unicode translation fails */ static void testProps(void) { static const WCHAR szDot[] = { '.',0 }; static const WCHAR szPrefix[] = { 's','t','g',0 }; static WCHAR propName[] = { 'p','r','o','p',0 }; static char val[] = "l33t auth0r"; WCHAR filename[MAX_PATH]; HRESULT hr; IStorage *storage = NULL; IPropertySetStorage *propSetStorage = NULL; IPropertyStorage *propertyStorage = NULL; PROPSPEC spec; PROPVARIANT var; CLIPDATA clipdata; unsigned char clipcontent[] = "foobar"; GUID anyOldGuid = { 0x12345678,0xdead,0xbeef, { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 } }; if(!GetTempFileNameW(szDot, szPrefix, 0, filename)) return; DeleteFileW(filename); hr = StgCreateDocfile(filename, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage); ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr); if(!pStgCreatePropSetStg) { IStorage_Release(storage); DeleteFileW(filename); return; } hr = pStgCreatePropSetStg(storage, 0, &propSetStorage); ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr); hr = IPropertySetStorage_Create(propSetStorage, &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &propertyStorage); ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr); hr = IPropertyStorage_WriteMultiple(propertyStorage, 0, NULL, NULL, 0); ok(hr == S_OK, "WriteMultiple with 0 args failed: 0x%08x\n", hr); hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, NULL, NULL, 0); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr); /* test setting one that I can't set */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_DICTIONARY; var.vt = VT_I4; U(var).lVal = 1; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == STG_E_INVALIDPARAMETER, "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr); /* test setting one by name with an invalid propidNameFirst */ spec.ulKind = PRSPEC_LPWSTR; U(spec).lpwstr = propName; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, PID_DICTIONARY); ok(hr == STG_E_INVALIDPARAMETER, "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr); /* test setting behavior (case-sensitive) */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_BEHAVIOR; U(var).lVal = 1; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == STG_E_INVALIDPARAMETER, "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr); /* set one by value.. */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; U(var).lVal = 1; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* set one by name */ spec.ulKind = PRSPEC_LPWSTR; U(spec).lpwstr = propName; U(var).lVal = 2; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, PID_FIRST_USABLE); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* set a string value */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PIDSI_AUTHOR; var.vt = VT_LPSTR; U(var).pszVal = val; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* set a clipboard value */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PIDSI_THUMBNAIL; var.vt = VT_CF; clipdata.cbSize = sizeof clipcontent + sizeof (ULONG); clipdata.ulClipFmt = CF_ENHMETAFILE; clipdata.pClipData = clipcontent; U(var).pclipdata = &clipdata; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* check reading */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 0, NULL, NULL); ok(hr == S_FALSE, "ReadMultiple with 0 args failed: 0x%08x\n", hr); hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, NULL, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr); /* read by propid */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I4 && U(var).lVal == 1, "Didn't get expected type or value for property (got type %d, value %d)\n", var.vt, U(var).lVal); /* read by name */ spec.ulKind = PRSPEC_LPWSTR; U(spec).lpwstr = propName; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I4 && U(var).lVal == 2, "Didn't get expected type or value for property (got type %d, value %d)\n", var.vt, U(var).lVal); /* read string value */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PIDSI_AUTHOR; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val), "Didn't get expected type or value for property (got type %d, value %s)\n", var.vt, U(var).pszVal); PropVariantClear(&var); /* read clipboard format */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PIDSI_THUMBNAIL; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_CF, "variant type wrong\n"); ok(U(var).pclipdata->ulClipFmt == CF_ENHMETAFILE, "clipboard type wrong\n"); ok(U(var).pclipdata->cbSize == sizeof clipcontent + sizeof (ULONG), "clipboard size wrong\n"); ok(!memcmp(U(var).pclipdata->pClipData, clipcontent, sizeof clipcontent), "clipboard contents wrong\n"); ok(S_OK == PropVariantClear(&var), "failed to clear variant\n"); /* check deleting */ hr = IPropertyStorage_DeleteMultiple(propertyStorage, 0, NULL); ok(hr == S_OK, "DeleteMultiple with 0 args failed: 0x%08x\n", hr); hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr); /* contrary to what the docs say, you can't delete the dictionary */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_DICTIONARY; hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec); ok(hr == STG_E_INVALIDPARAMETER, "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr); /* now delete the first value.. */ U(spec).propid = PID_FIRST_USABLE; hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec); ok(hr == S_OK, "DeleteMultiple failed: 0x%08x\n", hr); /* and check that it's no longer readable */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr); hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT); ok(hr == S_OK, "Commit failed: 0x%08x\n", hr); /* check reverting */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); hr = IPropertyStorage_Revert(propertyStorage); ok(hr == S_OK, "Revert failed: 0x%08x\n", hr); /* now check that it's still not there */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr); /* set an integer value again */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; var.vt = VT_I4; U(var).lVal = 1; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* commit it */ hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT); ok(hr == S_OK, "Commit failed: 0x%08x\n", hr); /* set it to a string value */ var.vt = VT_LPSTR; U(var).pszVal = val; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* revert it */ hr = IPropertyStorage_Revert(propertyStorage); ok(hr == S_OK, "Revert failed: 0x%08x\n", hr); /* Oddly enough, there's no guarantee that a successful revert actually * implies the value wasn't saved. Maybe transactional mode needs to be * used for that? */ IPropertyStorage_Release(propertyStorage); propertyStorage = NULL; IPropertySetStorage_Release(propSetStorage); propSetStorage = NULL; IStorage_Release(storage); storage = NULL; /* now open it again */ hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &storage); ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr); hr = pStgCreatePropSetStg(storage, 0, &propSetStorage); ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr); hr = IPropertySetStorage_Open(propSetStorage, &FMTID_SummaryInformation, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage); ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr); /* check properties again */ spec.ulKind = PRSPEC_LPWSTR; U(spec).lpwstr = propName; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I4 && U(var).lVal == 2, "Didn't get expected type or value for property (got type %d, value %d)\n", var.vt, U(var).lVal); spec.ulKind = PRSPEC_PROPID; U(spec).propid = PIDSI_AUTHOR; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val), "Didn't get expected type or value for property (got type %d, value %s)\n", var.vt, U(var).pszVal); PropVariantClear(&var); IPropertyStorage_Release(propertyStorage); IPropertySetStorage_Release(propSetStorage); IStorage_Release(storage); DeleteFileW(filename); /* Test creating a property set storage with a random GUID */ hr = StgCreateDocfile(filename, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage); ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr); if(!pStgCreatePropSetStg) { IStorage_Release(storage); DeleteFileW(filename); return; } hr = pStgCreatePropSetStg(storage, 0, &propSetStorage); ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr); hr = IPropertySetStorage_Create(propSetStorage, &anyOldGuid, NULL, PROPSETFLAG_ANSI, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &propertyStorage); ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr); spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; var.vt = VT_I4; U(var).lVal = 1; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT); ok(hr == S_OK, "Commit failed: 0x%08x\n", hr); IPropertyStorage_Release(propertyStorage); IPropertySetStorage_Release(propSetStorage); IStorage_Release(storage); propertyStorage = NULL; /* now open it again */ hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &storage); ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr); hr = pStgCreatePropSetStg(storage, 0, &propSetStorage); ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr); hr = IPropertySetStorage_Open(propSetStorage, &anyOldGuid, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage); ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr); spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I4 && U(var).lVal == 1, "Didn't get expected type or value for property (got type %d, value %d)\n", var.vt, U(var).lVal); IPropertyStorage_Release(propertyStorage); IPropertySetStorage_Release(propSetStorage); IStorage_Release(storage); DeleteFileW(filename); }
static void testCodepage(void) { static const WCHAR szDot[] = { '.',0 }; static const WCHAR szPrefix[] = { 's','t','g',0 }; static CHAR aval[] = "hi"; static WCHAR wval[] = { 'h','i',0 }; HRESULT hr; IStorage *storage = NULL; IPropertySetStorage *propSetStorage = NULL; IPropertyStorage *propertyStorage = NULL; PROPSPEC spec; PROPVARIANT var; WCHAR fileName[MAX_PATH]; if(!GetTempFileNameW(szDot, szPrefix, 0, fileName)) return; hr = StgCreateDocfile(fileName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage); ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr); if(!pStgCreatePropSetStg) { IStorage_Release(storage); DeleteFileW(fileName); return; } hr = pStgCreatePropSetStg(storage, 0, &propSetStorage); ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr); hr = IPropertySetStorage_Create(propSetStorage, &FMTID_SummaryInformation, NULL, PROPSETFLAG_DEFAULT, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &propertyStorage); ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr); PropVariantInit(&var); spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_CODEPAGE; /* check code page before it's been explicitly set */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I2 && U(var).iVal == 1200, "Didn't get expected type or value for property\n"); /* Set the code page to ascii */ var.vt = VT_I2; U(var).iVal = 1252; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* check code page */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I2 && U(var).iVal == 1252, "Didn't get expected type or value for property\n"); /* Set code page to Unicode */ U(var).iVal = 1200; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* check code page */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I2 && U(var).iVal == 1200, "Didn't get expected type or value for property\n"); /* Set a string value */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; var.vt = VT_LPSTR; U(var).pszVal = aval; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "hi"), "Didn't get expected type or value for property\n"); PropVariantClear(&var); /* This seemingly non-sensical test is to show that the string is indeed * interpreted according to the current system code page, not according to * the property set's code page. (If the latter were true, the whole * string would be maintained. As it is, only the first character is.) */ var.vt = VT_LPSTR; U(var).pszVal = (LPSTR)wval; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "h"), "Didn't get expected type or value for property\n"); PropVariantClear(&var); /* now that a property's been set, you can't change the code page */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_CODEPAGE; var.vt = VT_I2; U(var).iVal = 1200; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == STG_E_INVALIDPARAMETER, "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr); IPropertyStorage_Release(propertyStorage); IPropertySetStorage_Release(propSetStorage); IStorage_Release(storage); DeleteFileW(fileName); /* same tests, but with PROPSETFLAG_ANSI */ hr = StgCreateDocfile(fileName, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage); ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr); hr = pStgCreatePropSetStg(storage, 0, &propSetStorage); ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr); hr = IPropertySetStorage_Create(propSetStorage, &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &propertyStorage); ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr); /* check code page before it's been explicitly set */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I2, "Didn't get expected type for property (%u)\n", var.vt); /* Set code page to Unicode */ U(var).iVal = 1200; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* check code page */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_I2 && U(var).iVal == 1200, "Didn't get expected type or value for property\n"); /* This test is commented out for documentation. It fails under Wine, * and I expect it would under Windows as well, yet it succeeds. There's * obviously something about string conversion I don't understand. */ if(0) { static unsigned char strVal[] = { 0x81, 0xff, 0x04, 0 }; /* Set code page to 950 (Traditional Chinese) */ U(var).iVal = 950; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* Try writing an invalid string: lead byte 0x81 is unused in Traditional * Chinese. */ spec.ulKind = PRSPEC_PROPID; U(spec).propid = PID_FIRST_USABLE; var.vt = VT_LPSTR; U(var).pszVal = (LPSTR)strVal; hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0); ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr); /* Check returned string */ hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var); ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr); ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, (LPCSTR)strVal), "Didn't get expected type or value for property\n"); } IPropertyStorage_Release(propertyStorage); IPropertySetStorage_Release(propSetStorage); IStorage_Release(storage); DeleteFileW(fileName); }
static HRESULT WINAPI PersistFile_Save(IPersistFile *pFile, LPCOLESTR pszFileName, BOOL fRemember) { HRESULT hr = S_OK; INT len; CHAR *url; InternetShortcut *This = impl_from_IPersistFile(pFile); TRACE("(%p, %s, %d)\n", pFile, debugstr_w(pszFileName), fRemember); if (pszFileName != NULL && fRemember) { LPOLESTR oldFile = This->currentFile; This->currentFile = co_strdupW(pszFileName); if (This->currentFile == NULL) { This->currentFile = oldFile; return E_OUTOFMEMORY; } CoTaskMemFree(oldFile); } if (This->url == NULL) return E_FAIL; /* Windows seems to always write: * ASCII "[InternetShortcut]" headers * ASCII names in "name=value" pairs * An ASCII (probably UTF8?) value in "URL=..." */ len = WideCharToMultiByte(CP_UTF8, 0, This->url, -1, NULL, 0, 0, 0); url = heap_alloc(len); if (url != NULL) { HANDLE file; WideCharToMultiByte(CP_UTF8, 0, This->url, -1, url, len, 0, 0); file = CreateFileW(pszFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (file != INVALID_HANDLE_VALUE) { DWORD bytesWritten; char *iconfile; char str_header[] = "[InternetShortcut]"; char str_URL[] = "URL="; char str_ICONFILE[] = "ICONFILE="; char str_eol[] = "\r\n"; IPropertyStorage *pPropStgRead; PROPSPEC ps[2]; PROPVARIANT pvread[2]; ps[0].ulKind = PRSPEC_PROPID; ps[0].u.propid = PID_IS_ICONFILE; ps[1].ulKind = PRSPEC_PROPID; ps[1].u.propid = PID_IS_ICONINDEX; WriteFile(file, str_header, lstrlenA(str_header), &bytesWritten, NULL); WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); WriteFile(file, str_URL, lstrlenA(str_URL), &bytesWritten, NULL); WriteFile(file, url, lstrlenA(url), &bytesWritten, NULL); WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); hr = IPropertySetStorage_Open(This->property_set_storage, &FMTID_Intshcut, STGM_READ|STGM_SHARE_EXCLUSIVE, &pPropStgRead); if (SUCCEEDED(hr)) { hr = IPropertyStorage_ReadMultiple(pPropStgRead, 2, ps, pvread); if (hr == S_FALSE) { /* None of the properties are present, that's ok */ hr = S_OK; IPropertyStorage_Release(pPropStgRead); } else if (SUCCEEDED(hr)) { char indexString[50]; len = WideCharToMultiByte(CP_UTF8, 0, pvread[0].u.pwszVal, -1, NULL, 0, 0, 0); iconfile = heap_alloc(len); if (iconfile != NULL) { WideCharToMultiByte(CP_UTF8, 0, pvread[0].u.pwszVal, -1, iconfile, len, 0, 0); WriteFile(file, str_ICONFILE, lstrlenA(str_ICONFILE), &bytesWritten, NULL); WriteFile(file, iconfile, lstrlenA(iconfile), &bytesWritten, NULL); WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); } sprintf(indexString, "ICONINDEX=%d", pvread[1].u.iVal); WriteFile(file, indexString, lstrlenA(indexString), &bytesWritten, NULL); WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL); IPropertyStorage_Release(pPropStgRead); PropVariantClear(&pvread[0]); PropVariantClear(&pvread[1]); } else { TRACE("Unable to read properties.\n"); } } else { TRACE("Unable to get the IPropertyStorage.\n"); } CloseHandle(file); if (pszFileName == NULL || fRemember) This->isDirty = FALSE; StartLinkProcessor(pszFileName); } else hr = E_FAIL; heap_free(url); } else hr = E_OUTOFMEMORY; return hr; }
static void test_ReadAndWriteProperties(void) { HRESULT hr; IUniformResourceLocatorA *urlA; IUniformResourceLocatorA *urlAFromFile; WCHAR fileNameW[MAX_PATH]; static const WCHAR shortcutW[] = {'t','e','s','t','s','h','o','r','t','c','u','t','.','u','r','l',0}; WCHAR iconPath[] = {'f','i','l','e',':','/','/','/','C',':','/','a','r','b','i','t','r','a','r','y','/','i','c','o','n','/','p','a','t','h',0}; int iconIndex = 7; char testurl[] = "http://some/bogus/url.html"; PROPSPEC ps[2]; ps[0].ulKind = PRSPEC_PROPID; U(ps[0]).propid = PID_IS_ICONFILE; ps[1].ulKind = PRSPEC_PROPID; U(ps[1]).propid = PID_IS_ICONINDEX; /* Make sure we have a valid temporary directory */ GetTempPathW(MAX_PATH, fileNameW); lstrcatW(fileNameW, shortcutW); hr = CoCreateInstance(&CLSID_InternetShortcut, NULL, CLSCTX_ALL, &IID_IUniformResourceLocatorA, (void**)&urlA); if (hr == S_OK) { IPersistFile *pf; IPropertyStorage *pPropStgWrite; IPropertySetStorage *pPropSetStg; PROPVARIANT pv[2]; /* We need to set a URL -- IPersistFile refuses to save without one. */ hr = urlA->lpVtbl->SetURL(urlA, testurl, 0); ok(hr == S_OK, "Failed to set a URL. hr=0x%x\n", hr); /* Write this shortcut out to a file so that we can test reading it in again. */ hr = urlA->lpVtbl->QueryInterface(urlA, &IID_IPersistFile, (void **) &pf); ok(hr == S_OK, "Failed to get the IPersistFile for writing. hr=0x%x\n", hr); hr = IPersistFile_Save(pf, fileNameW, TRUE); ok(hr == S_OK, "Failed to save via IPersistFile. hr=0x%x\n", hr); IPersistFile_Release(pf); pv[0].vt = VT_LPWSTR; U(pv[0]).pwszVal = (void *) iconPath; pv[1].vt = VT_I4; U(pv[1]).iVal = iconIndex; hr = urlA->lpVtbl->QueryInterface(urlA, &IID_IPropertySetStorage, (void **) &pPropSetStg); ok(hr == S_OK, "Unable to get an IPropertySetStorage, hr=0x%x\n", hr); hr = IPropertySetStorage_Open(pPropSetStg, &FMTID_Intshcut, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pPropStgWrite); ok(hr == S_OK, "Unable to get an IPropertyStorage for writing, hr=0x%x\n", hr); hr = IPropertyStorage_WriteMultiple(pPropStgWrite, 2, ps, pv, 0); ok(hr == S_OK, "Unable to set properties, hr=0x%x\n", hr); hr = IPropertyStorage_Commit(pPropStgWrite, STGC_DEFAULT); ok(hr == S_OK, "Failed to commit properties, hr=0x%x\n", hr); pPropStgWrite->lpVtbl->Release(pPropStgWrite); urlA->lpVtbl->Release(urlA); IPropertySetStorage_Release(pPropSetStg); } else skip("could not create a CLSID_InternetShortcut for property tests, hr=0x%x\n", hr); hr = CoCreateInstance(&CLSID_InternetShortcut, NULL, CLSCTX_ALL, &IID_IUniformResourceLocatorA, (void**)&urlAFromFile); if (hr == S_OK) { IPropertySetStorage *pPropSetStg; IPropertyStorage *pPropStgRead; PROPVARIANT pvread[2]; IPersistFile *pf; LPSTR url = NULL; /* Now read that .url file back in. */ hr = urlAFromFile->lpVtbl->QueryInterface(urlAFromFile, &IID_IPersistFile, (void **) &pf); ok(hr == S_OK, "Failed to get the IPersistFile for reading. hr=0x%x\n", hr); hr = IPersistFile_Load(pf, fileNameW, 0); ok(hr == S_OK, "Failed to load via IPersistFile. hr=0x%x\n", hr); IPersistFile_Release(pf); hr = urlAFromFile->lpVtbl->GetURL(urlAFromFile, &url); ok(hr == S_OK, "Unable to get url from file, hr=0x%x\n", hr); ok(lstrcmp(url, testurl) == 0, "Wrong url read from file: %s\n",url); hr = urlAFromFile->lpVtbl->QueryInterface(urlAFromFile, &IID_IPropertySetStorage, (void **) &pPropSetStg); ok(hr == S_OK, "Unable to get an IPropertySetStorage, hr=0x%x\n", hr); hr = IPropertySetStorage_Open(pPropSetStg, &FMTID_Intshcut, STGM_READ | STGM_SHARE_EXCLUSIVE, &pPropStgRead); ok(hr == S_OK, "Unable to get an IPropertyStorage for reading, hr=0x%x\n", hr); hr = IPropertyStorage_ReadMultiple(pPropStgRead, 2, ps, pvread); ok(hr == S_OK, "Unable to read properties, hr=0x%x\n", hr); todo_wine /* Wine doesn't yet support setting properties after save */ { ok(U(pvread[1]).iVal == iconIndex, "Read wrong icon index: %d\n", U(pvread[1]).iVal); ok(lstrcmpW(U(pvread[0]).pwszVal, iconPath) == 0, "Wrong icon path read: %s\n", wine_dbgstr_w(U(pvread[0]).pwszVal)); } PropVariantClear(&pvread[0]); PropVariantClear(&pvread[1]); IPropertyStorage_Release(pPropStgRead); IPropertySetStorage_Release(pPropSetStg); urlAFromFile->lpVtbl->Release(urlAFromFile); DeleteFileW(fileNameW); }