BSTR SysAllocString() {
if(m_length > 0)
return SysAllocStringLen(m_buffer,m_length);
return 0;
}
static HRESULT WINAPI HTMLLocation_get_href(IHTMLLocation *iface, BSTR *p)
{
HTMLLocation *This = impl_from_IHTMLLocation(iface);
URL_COMPONENTSW url = {sizeof(URL_COMPONENTSW)};
WCHAR *buf = NULL, *url_path = NULL;
HRESULT hres, ret;
DWORD len = 0;
int i;
TRACE("(%p)->(%p)\n", This, p);
if(!p)
return E_POINTER;
url.dwSchemeLength = 1;
url.dwHostNameLength = 1;
url.dwUrlPathLength = 1;
url.dwExtraInfoLength = 1;
hres = get_url_components(This, &url);
if(FAILED(hres))
return hres;
switch(url.nScheme) {
case INTERNET_SCHEME_FILE:
{
/* prepend a slash */
url_path = HeapAlloc(GetProcessHeap(), 0, (url.dwUrlPathLength + 1) * sizeof(WCHAR));
if(!url_path)
return E_OUTOFMEMORY;
url_path[0] = '/';
memcpy(url_path + 1, url.lpszUrlPath, url.dwUrlPathLength * sizeof(WCHAR));
url.lpszUrlPath = url_path;
url.dwUrlPathLength = url.dwUrlPathLength + 1;
}
break;
case INTERNET_SCHEME_HTTP:
case INTERNET_SCHEME_HTTPS:
case INTERNET_SCHEME_FTP:
if(!url.dwUrlPathLength) {
/* add a slash if it's blank */
url_path = url.lpszUrlPath = HeapAlloc(GetProcessHeap(), 0, 1 * sizeof(WCHAR));
if(!url.lpszUrlPath)
return E_OUTOFMEMORY;
url.lpszUrlPath[0] = '/';
url.dwUrlPathLength = 1;
}
break;
default:
break;
}
/* replace \ with / */
for(i = 0; i < url.dwUrlPathLength; ++i)
if(url.lpszUrlPath[i] == '\\')
url.lpszUrlPath[i] = '/';
if(InternetCreateUrlW(&url, ICU_ESCAPE, NULL, &len)) {
FIXME("InternetCreateUrl succeeded with NULL buffer?\n");
ret = E_FAIL;
goto cleanup;
}
if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
FIXME("InternetCreateUrl failed with error: %08x\n", GetLastError());
SetLastError(0);
ret = E_FAIL;
goto cleanup;
}
SetLastError(0);
buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
if(!buf) {
ret = E_OUTOFMEMORY;
goto cleanup;
}
if(!InternetCreateUrlW(&url, ICU_ESCAPE, buf, &len)) {
FIXME("InternetCreateUrl failed with error: %08x\n", GetLastError());
SetLastError(0);
ret = E_FAIL;
goto cleanup;
}
*p = SysAllocStringLen(buf, len);
if(!*p) {
ret = E_OUTOFMEMORY;
goto cleanup;
}
ret = S_OK;
cleanup:
HeapFree(GetProcessHeap(), 0, buf);
HeapFree(GetProcessHeap(), 0, url_path);
return ret;
}
// And another one to get the default for WSID.
static BSTR get_hostname() {
BSTR hostname = SysAllocStringLen(NULL, 31);
memset(hostname, 0, 60);
GetEnvironmentVariable(L"COMPUTERNAME", hostname, 30);
return hostname;
}
void GetInterfaceNameByIID(const GUID &aIID, BSTR *aName)
{
Assert(aName);
if (!aName)
return;
*aName = NULL;
#if !defined(VBOX_WITH_XPCOM)
LONG rc;
LPOLESTR iidStr = NULL;
if (StringFromIID(aIID, &iidStr) == S_OK)
{
HKEY ifaceKey;
rc = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Interface",
0, KEY_QUERY_VALUE, &ifaceKey);
if (rc == ERROR_SUCCESS)
{
HKEY iidKey;
rc = RegOpenKeyExW(ifaceKey, iidStr, 0, KEY_QUERY_VALUE, &iidKey);
if (rc == ERROR_SUCCESS)
{
/* determine the size and type */
DWORD sz, type;
rc = RegQueryValueExW(iidKey, NULL, NULL, &type, NULL, &sz);
if (rc == ERROR_SUCCESS && type == REG_SZ)
{
/* query the value to BSTR */
*aName = SysAllocStringLen(NULL, (sz + 1) / sizeof(TCHAR) + 1);
rc = RegQueryValueExW(iidKey, NULL, NULL, NULL, (LPBYTE) *aName, &sz);
if (rc != ERROR_SUCCESS)
{
SysFreeString(*aName);
aName = NULL;
}
}
RegCloseKey(iidKey);
}
RegCloseKey(ifaceKey);
}
CoTaskMemFree(iidStr);
}
#else /* !defined (VBOX_WITH_XPCOM) */
nsresult rv;
nsCOMPtr<nsIInterfaceInfoManager> iim =
do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv))
{
nsCOMPtr<nsIInterfaceInfo> iinfo;
rv = iim->GetInfoForIID(&aIID, getter_AddRefs(iinfo));
if (NS_SUCCEEDED(rv))
{
const char *iname = NULL;
iinfo->GetNameShared(&iname);
char *utf8IName = NULL;
if (RT_SUCCESS(RTStrCurrentCPToUtf8(&utf8IName, iname)))
{
PRTUTF16 utf16IName = NULL;
if (RT_SUCCESS(RTStrToUtf16(utf8IName, &utf16IName)))
{
*aName = SysAllocString((OLECHAR *) utf16IName);
RTUtf16Free(utf16IName);
}
RTStrFree(utf8IName);
}
}
}
#endif /* !defined (VBOX_WITH_XPCOM) */
}
static BSTR
CopyBSTR(BSTR aSrc)
{
return SysAllocStringLen(aSrc, SysStringLen(aSrc));
}
static HRESULT get_dbpropset_from_proplist(struct dbprops *props, DBPROPSET **propset)
{
struct dbprop_pair *pair;
int i = 0;
HRESULT hr;
*propset = CoTaskMemAlloc(sizeof(DBPROPSET));
if (!*propset)
return E_OUTOFMEMORY;
(*propset)->rgProperties = CoTaskMemAlloc(props->count*sizeof(DBPROP));
if (!(*propset)->rgProperties)
{
CoTaskMemFree(*propset);
*propset = NULL;
return E_OUTOFMEMORY;
}
(*propset)->cProperties = 0;
LIST_FOR_EACH_ENTRY(pair, &props->props, struct dbprop_pair, entry)
{
const struct dbproperty *descr = get_known_dprop_descr(pair->name);
VARIANT dest, src;
if (!descr)
{
static const WCHAR eqW[] = {'=',0};
BSTR str;
int len;
/* provider specific property is always VT_BSTR */
len = SysStringLen(pair->name) + SysStringLen(pair->value) + 1 /* for '=' */;
str = SysAllocStringLen(NULL, len);
strcpyW(str, pair->name);
strcatW(str, eqW);
strcatW(str, pair->value);
(*propset)->cProperties++;
(*propset)->guidPropertySet = DBPROPSET_DBINIT;
(*propset)->rgProperties[i].dwPropertyID = DBPROP_INIT_PROVIDERSTRING;
(*propset)->rgProperties[i].dwOptions = DBPROPOPTIONS_REQUIRED;
(*propset)->rgProperties[i].dwStatus = 0;
memset(&(*propset)->rgProperties[i].colid, 0, sizeof(DBID));
V_VT(&(*propset)->rgProperties[i].vValue) = VT_BSTR;
V_BSTR(&(*propset)->rgProperties[i].vValue) = str;
i++;
continue;
}
V_VT(&src) = VT_BSTR;
V_BSTR(&src) = pair->value;
VariantInit(&dest);
hr = VariantChangeType(&dest, &src, 0, descr->type);
if (FAILED(hr))
{
ERR("failed to init property %s value as type %d\n", debugstr_w(pair->name), descr->type);
free_dbpropset(1, *propset);
*propset = NULL;
return hr;
}
(*propset)->cProperties++;
(*propset)->guidPropertySet = DBPROPSET_DBINIT;
(*propset)->rgProperties[i].dwPropertyID = descr->id;
(*propset)->rgProperties[i].dwOptions = descr->options;
(*propset)->rgProperties[i].dwStatus = 0;
memset(&(*propset)->rgProperties[i].colid, 0, sizeof(DBID));
(*propset)->rgProperties[i].vValue = dest;
i++;
}
return S_OK;
}
HRESULT CFormattedTextDraw::get_RTFText(BSTR *pVal)
{
*pVal = SysAllocStringLen(m_RTFText, SysStringLen(m_RTFText));
return S_OK;
}
/*** IDataInitialize methods ***/
static HRESULT WINAPI datainit_GetDataSource(IDataInitialize *iface, IUnknown *outer, DWORD clsctx,
LPWSTR initstring, REFIID riid, IUnknown **datasource)
{
static const WCHAR providerW[] = {'P','r','o','v','i','d','e','r','=',0};
static const WCHAR msdasqlW[] = {'M','S','D','A','S','Q','L',0};
datainit *This = impl_from_IDataInitialize(iface);
IDBProperties *dbprops;
DBPROPSET *propset;
WCHAR *prov = NULL;
CLSID provclsid;
HRESULT hr;
TRACE("(%p)->(%p 0x%x %s %s %p)\n", This, outer, clsctx, debugstr_w(initstring), debugstr_guid(riid), datasource);
/* first get provider name */
provclsid = IID_NULL;
if (initstring && (prov = strstrW(initstring, providerW)))
{
WCHAR *start, *progid;
int len;
prov += sizeof(providerW)/sizeof(WCHAR)-1;
start = prov;
while (*prov && *prov != ';')
++prov;
TRACE("got provider %s\n", debugstr_wn(start, prov-start));
len = prov - start;
progid = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
if (!progid) return E_OUTOFMEMORY;
memcpy(progid, start, len*sizeof(WCHAR));
progid[len] = 0;
hr = CLSIDFromProgID(progid, &provclsid);
CoTaskMemFree(progid);
if (FAILED(hr))
{
ERR("provider %s not registered\n", debugstr_wn(start, prov-start));
return hr;
}
}
else
{
hr = CLSIDFromProgID(msdasqlW, &provclsid);
if (FAILED(hr))
ERR("ODBC provider for OLE DB not registered\n");
}
/* check for provider mismatch if it was specified in init string */
if (*datasource && prov)
{
DBPROPIDSET propidset;
enum DBPROPENUM prop;
CLSID initprov;
ULONG count;
hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
if (FAILED(hr))
{
WARN("provider doesn't support IDBProperties\n");
return hr;
}
prop = DBPROP_INIT_DATASOURCE;
propidset.rgPropertyIDs = ∝
propidset.cPropertyIDs = 1;
propidset.guidPropertySet = DBPROPSET_DBINIT;
count = 0;
propset = NULL;
hr = IDBProperties_GetProperties(dbprops, 1, &propidset, &count, &propset);
IDBProperties_Release(dbprops);
if (FAILED(hr))
{
WARN("GetProperties failed for datasource, 0x%08x\n", hr);
return hr;
}
TRACE("initial data source provider %s\n", debugstr_w(V_BSTR(&propset->rgProperties[0].vValue)));
initprov = IID_NULL;
CLSIDFromProgID(V_BSTR(&propset->rgProperties[0].vValue), &initprov);
free_dbpropset(count, propset);
if (!IsEqualIID(&provclsid, &initprov)) return DB_E_MISMATCHEDPROVIDER;
}
if (!*datasource)
{
if (!IsEqualIID(&provclsid, &IID_NULL))
hr = CoCreateInstance(&provclsid, outer, clsctx, riid, (void**)datasource);
if (FAILED(hr) && IsEqualIID(riid, &IID_IDBInitialize))
hr = create_db_init(datasource);
}
/* now set properties */
if (initstring)
{
WCHAR *eq, *start;
hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
if (FAILED(hr))
{
WARN("provider doesn't support IDBProperties\n");
return hr;
}
start = initstring;
while (start && (eq = strchrW(start, '=')))
{
static const WCHAR providerW[] = {'P','r','o','v','i','d','e','r',0};
WCHAR *scol = strchrW(eq+1, ';');
BSTR value, name;
name = SysAllocStringLen(start, eq - start);
/* skip equal sign to get value */
eq++;
value = SysAllocStringLen(eq, scol ? scol - eq : -1);
/* skip semicolon if present */
if (scol) scol++;
start = scol;
if (!strcmpW(name, providerW))
{
SysFreeString(name);
SysFreeString(value);
continue;
}
TRACE("property (name=%s, value=%s)\n", debugstr_w(name), debugstr_w(value));
hr = set_dbpropset(name, value, &propset);
SysFreeString(name);
SysFreeString(value);
if (FAILED(hr)) break;
hr = IDBProperties_SetProperties(dbprops, 1, propset);
free_dbpropset(1, propset);
TRACE("provider ret 0x%08x\n", hr);
}
IDBProperties_Release(dbprops);
}
return hr;
}
HRESULT variant_change_type(script_ctx_t *ctx, VARIANT *dst, VARIANT *src, VARTYPE vt)
{
jsval_t val;
HRESULT hres;
clear_ei(ctx);
hres = variant_to_jsval(src, &val);
if(FAILED(hres))
return hres;
switch(vt) {
case VT_I2:
case VT_I4: {
INT i;
hres = to_int32(ctx, val, &i);
if(SUCCEEDED(hres)) {
if(vt == VT_I4)
V_I4(dst) = i;
else
V_I2(dst) = i;
}
break;
}
case VT_R8: {
double n;
hres = to_number(ctx, val, &n);
if(SUCCEEDED(hres))
V_R8(dst) = n;
break;
}
case VT_R4: {
double n;
hres = to_number(ctx, val, &n);
if(SUCCEEDED(hres))
V_R4(dst) = n;
break;
}
case VT_BOOL: {
BOOL b;
hres = to_boolean(val, &b);
if(SUCCEEDED(hres))
V_BOOL(dst) = b ? VARIANT_TRUE : VARIANT_FALSE;
break;
}
case VT_BSTR: {
jsstr_t *str;
hres = to_string(ctx, val, &str);
if(FAILED(hres))
break;
if(str->length_flags & JSSTR_FLAG_NULLBSTR) {
V_BSTR(dst) = NULL;
break;
}
V_BSTR(dst) = SysAllocStringLen(str->str, jsstr_length(str));
if(!V_BSTR(dst))
hres = E_OUTOFMEMORY;
break;
}
case VT_EMPTY:
hres = V_VT(src) == VT_EMPTY ? S_OK : E_NOTIMPL;
break;
case VT_NULL:
hres = V_VT(src) == VT_NULL ? S_OK : E_NOTIMPL;
break;
default:
FIXME("vt %d not implemented\n", vt);
hres = E_NOTIMPL;
}
jsval_release(val);
if(FAILED(hres))
return hres;
V_VT(dst) = vt;
return S_OK;
}
static HRESULT WINAPI DEVENUM_IPropertyBag_Read(
LPPROPERTYBAG iface,
LPCOLESTR pszPropName,
VARIANT* pVar,
IErrorLog* pErrorLog)
{
LPVOID pData = NULL;
DWORD received;
DWORD type = 0;
RegPropBagImpl *This = impl_from_IPropertyBag(iface);
HRESULT res = S_OK;
LONG reswin32;
TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
if (!pszPropName || !pVar)
return E_POINTER;
reswin32 = RegQueryValueExW(This->hkey, pszPropName, NULL, NULL, NULL, &received);
res = HRESULT_FROM_WIN32(reswin32);
if (SUCCEEDED(res))
{
pData = HeapAlloc(GetProcessHeap(), 0, received);
/* work around a GCC bug that occurs here unless we use the reswin32 variable as well */
reswin32 = RegQueryValueExW(This->hkey, pszPropName, NULL, &type, pData, &received);
res = HRESULT_FROM_WIN32(reswin32);
}
if (SUCCEEDED(res))
{
res = E_INVALIDARG; /* assume we cannot coerce into right type */
TRACE("Read %d bytes (%s)\n", received, type == REG_SZ ? debugstr_w(pData) : "binary data");
switch (type)
{
case REG_SZ:
switch (V_VT(pVar))
{
case VT_LPWSTR:
V_UNION(pVar, bstrVal) = CoTaskMemAlloc(received);
memcpy(V_UNION(pVar, bstrVal), pData, received);
res = S_OK;
break;
case VT_EMPTY:
V_VT(pVar) = VT_BSTR;
/* fall through */
case VT_BSTR:
V_UNION(pVar, bstrVal) = SysAllocStringLen(pData, received/sizeof(WCHAR) - 1);
res = S_OK;
break;
}
break;
case REG_DWORD:
TRACE("REG_DWORD: %x\n", *(DWORD *)pData);
switch (V_VT(pVar))
{
case VT_EMPTY:
V_VT(pVar) = VT_I4;
/* fall through */
case VT_I4:
case VT_UI4:
V_UNION(pVar, ulVal) = *(DWORD *)pData;
res = S_OK;
break;
}
break;
case REG_BINARY:
{
SAFEARRAYBOUND bound;
void * pArrayElements;
bound.lLbound = 0;
bound.cElements = received;
TRACE("REG_BINARY: len = %d\n", received);
switch (V_VT(pVar))
{
case VT_EMPTY:
V_VT(pVar) = VT_ARRAY | VT_UI1;
/* fall through */
case VT_ARRAY | VT_UI1:
if (!(V_UNION(pVar, parray) = SafeArrayCreate(VT_UI1, 1, &bound)))
res = E_OUTOFMEMORY;
else
res = S_OK;
break;
}
if (res == E_INVALIDARG)
break;
res = SafeArrayAccessData(V_UNION(pVar, parray), &pArrayElements);
if (FAILED(res))
break;
CopyMemory(pArrayElements, pData, received);
res = SafeArrayUnaccessData(V_UNION(pVar, parray));
break;
}
}
if (res == E_INVALIDARG)
FIXME("Variant type %x not supported for regtype %x\n", V_VT(pVar), type);
}
HeapFree(GetProcessHeap(), 0, pData);
TRACE("<- %x\n", res);
return res;
}
static void test_VarWeekdayName(void)
{
char buff[256];
BSTR out = NULL;
HRESULT hres;
int iWeekday, fAbbrev, iFirstDay;
BSTR dayNames[7][2]; /* Monday-Sunday, full/abbr */
DWORD defaultFirstDay;
int firstDay;
int day;
int size;
DWORD localeValue;
CHECKPTR(VarWeekdayName);
SetLastError(0xdeadbeef);
GetLocaleInfoW(LOCALE_USER_DEFAULT, 0, NULL, 0);
if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
win_skip("GetLocaleInfoW is not implemented\n");
return;
}
/* Initialize days' names */
for (day = 0; day <= 6; ++day)
{
for (fAbbrev = 0; fAbbrev <= 1; ++fAbbrev)
{
localeValue = fAbbrev ? LOCALE_SABBREVDAYNAME1 : LOCALE_SDAYNAME1;
localeValue += day;
size = GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue, NULL, 0);
dayNames[day][fAbbrev] = SysAllocStringLen(NULL, size - 1);
GetLocaleInfoW(LOCALE_USER_DEFAULT, localeValue,
dayNames[day][fAbbrev], size);
}
}
/* Get the user's first day of week. 0=Monday, .. */
GetLocaleInfoW(
LOCALE_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK | LOCALE_RETURN_NUMBER,
(LPWSTR)&defaultFirstDay, sizeof(defaultFirstDay) / sizeof(WCHAR));
/* Check invalid arguments */
VARWDN_F(0, 0, 4, 0, E_INVALIDARG);
VARWDN_F(8, 0, 4, 0, E_INVALIDARG);
VARWDN_F(4, 0, -1, 0, E_INVALIDARG);
VARWDN_F(4, 0, 8, 0, E_INVALIDARG);
hres = pVarWeekdayName(1, 0, 0, 0, NULL);
ok(E_INVALIDARG == hres,
"Null pointer: expected E_INVALIDARG, got 0x%08x\n", hres);
/* Check all combinations */
for (iWeekday = 1; iWeekday <= 7; ++iWeekday)
{
for (fAbbrev = 0; fAbbrev <= 1; ++fAbbrev)
{
/* 0 = Default, 1 = Sunday, 2 = Monday, .. */
for (iFirstDay = 0; iFirstDay <= 7; ++iFirstDay)
{
VARWDN_O(iWeekday, fAbbrev, iFirstDay, 0);
if (iFirstDay == 0)
firstDay = defaultFirstDay;
else
/* Translate from 0=Sunday to 0=Monday in the modulo 7 space */
firstDay = iFirstDay - 2;
day = (7 + iWeekday - 1 + firstDay) % 7;
ok(VARCMP_EQ == VarBstrCmp(out, dayNames[day][fAbbrev],
LOCALE_USER_DEFAULT, 0),
"VarWeekdayName(%d,%d,%d): got wrong dayname: '%s'\n",
iWeekday, fAbbrev, iFirstDay, buff);
SysFreeString(out);
}
}
}
/* Cleanup */
for (day = 0; day <= 6; ++day)
{
for (fAbbrev = 0; fAbbrev <= 1; ++fAbbrev)
{
SysFreeString(dayNames[day][fAbbrev]);
}
}
}
void loadInitScript(){
TCHAR scriptfile[MAX_PATH];
GetModuleFileName(Statics::instance().hInstance, scriptfile, MAX_PATH);
BOOL res = PathRemoveFileSpec((LPWSTR)scriptfile);
PathAppend((LPWSTR)scriptfile, START_SCRIPT_FILE_NAME);
if (PathFileExists(scriptfile)== TRUE){
HANDLE hFile = CreateFile(
scriptfile, // name of the write
GENERIC_READ, // open for writing
0, // do not share
NULL, // default security
OPEN_ALWAYS, // overwrite existing
FILE_ATTRIBUTE_NORMAL, // normal file
NULL
); // no attr. template
if (hFile == INVALID_HANDLE_VALUE)
{
::MessageBox(0,TEXT("Could not open file (error %d)\n"),TEXT("Error"), MB_OK);
return;
}
char* buf = NULL;
DWORD fSize, fRead;
fSize = GetFileSize(hFile, NULL);
if (fSize == INVALID_FILE_SIZE){
::MessageBox(0,TEXT("Could not open file (error %d)\n"),TEXT("Error"), MB_OK);
CloseHandle(hFile);
return;
}
buf = new char[fSize+1];
buf[fSize] = 0;
ReadFile(hFile, buf, fSize,& fRead, NULL);
CloseHandle(hFile);
// assume file is UTF8 encoded
int newlen = MultiByteToWideChar(CP_UTF8, 0, buf, fSize, NULL,0);
BSTR wbuf = SysAllocStringLen(NULL, newlen);
int res = MultiByteToWideChar(CP_UTF8, 0, buf, fSize, wbuf, newlen);
if (buf!=NULL)
delete[] buf;
g_editor = new CEditor(nppData._nppHandle);
LocRef<System> system = new System(scriptfile, *MyActiveSite::getInstance());
MyActiveSite::getInstance()->addNamedItem(TEXT("Editor"), static_cast<IUnknown*>(g_editor));
MyActiveSite::getInstance()->addNamedItem(TEXT("System"), static_cast<IUnknown*>(system));
MyActiveSite::getInstance()->Connect();
MyActiveSite::getInstance()->runScript(wbuf, scriptfile);
SysFreeString(wbuf);
}
}
//---------------------------------------------------------------------------
HRESULT GetRegistryKeyValue(
HKEY RootKey,
const wchar_t * KeyName,
const wchar_t * Name,
VARIANT * Result)
{
HRESULT hr = E_FAIL;
HKEY hkey;
DWORD err;
err = RegOpenKeyExW(RootKey,KeyName,0,KEY_READ,&hkey);
if( err == ERROR_SUCCESS ){
DWORD ValueType, ValueSize, sLen;
err = RegQueryValueExW(hkey,Name,NULL,&ValueType,NULL,&ValueSize);
if( err == ERROR_SUCCESS ){
PBYTE pValueData = (PBYTE) malloc(ValueSize);
if( pValueData == NULL ){
err = ERROR_NOT_ENOUGH_MEMORY;
}
else {
err = RegQueryValueExW(hkey,Name,NULL,&ValueType,pValueData,&ValueSize);
if( err == ERROR_SUCCESS ){
BSTR sValue = NULL;
switch( ValueType ){
case REG_BINARY :
break;
case REG_DWORD :
if( SUCCEEDED(VariantChangeTypeEx(Result,Result,0,0,VT_I4)) ){
V_I4(Result) = *(DWORD *) pValueData;
hr = S_OK;
}
break;
case REG_EXPAND_SZ :
sLen = ExpandEnvironmentStringsW((LPCWSTR) pValueData,sValue,0);
if( sLen == 0 ){
err = GetLastError();
}
else {
sValue = SysAllocStringLen(NULL,sLen - 1);
if( sValue == NULL ){
err = ERROR_NOT_ENOUGH_MEMORY;
}
else {
ExpandEnvironmentStringsW((LPCWSTR) pValueData,sValue,sLen);
if( SUCCEEDED(VariantChangeTypeEx(Result,Result,0,0,VT_EMPTY)) ){
V_BSTR(Result) = sValue;
V_VT(Result) = VT_BSTR;
hr = S_OK;
sValue = NULL;
}
SysFreeString(sValue);
}
}
/*Val.resize(ExpandEnvironmentStringsW((LPCWSTR) pValueData,Val.c_str(),0) + 1);
ExpandEnvironmentStringsW((LPCWSTR) pValueData,Val.c_str(),Val.strlen());
Val.resize(wcslen(Val.c_str()));*/
break;
case REG_LINK :
case REG_MULTI_SZ :
case REG_NONE :
case REG_RESOURCE_LIST :
hr = E_FAIL;
break;
case REG_SZ :
sLen = (DWORD) wcslen((LPCWSTR) pValueData);
sValue = SysAllocStringLen(NULL,sLen);
if( sValue == NULL ){
err = ERROR_NOT_ENOUGH_MEMORY;
}
else {
if( SUCCEEDED(VariantChangeTypeEx(Result,Result,0,0,VT_EMPTY)) ){
V_BSTR(Result) = sValue;
V_VT(Result) = VT_BSTR;
hr = S_OK;
sValue = NULL;
}
SysFreeString(sValue);
}
/*Val = (wchar_t *) pValueData;*/
break;
}
}
free(pValueData);
}
}
RegCloseKey(hkey);
}
SetLastError(err);
return hr;
}
HRESULT dhFormatExceptionW(PDH_EXCEPTION pException, LPWSTR szBuffer, UINT cchBufferSize, BOOL bFixedFont)
{
HRESULT hr;
UINT cch = 0;
# define DESCRIPTION_LENGTH 255
if (!szBuffer && cchBufferSize) return E_INVALIDARG;
if (!pException)
{
dhGetLastException(&pException);
if (!pException)
{
if (cchBufferSize != 0)
{
_snwprintf(szBuffer, cchBufferSize, L"No error information available.");
szBuffer[cchBufferSize - 1] = L'\0';
}
return NOERROR;
}
}
hr = (pException->hr == DISP_E_EXCEPTION && pException->swCode ?
pException->swCode : pException->hr);
if (!pException->szSource)
{
if (pException->bDispatchError)
pException->szSource = SysAllocString(L"IDispatch Interface");
else
pException->szSource = SysAllocString(L"Application");
}
if (!pException->szDescription)
{
pException->szDescription = SysAllocStringLen(NULL, DESCRIPTION_LENGTH);
if (pException->szDescription)
{
switch (hr)
{
case E_NOINTERFACE:
_snwprintf(pException->szDescription, DESCRIPTION_LENGTH, L"Object required");
break;
case DISP_E_UNKNOWNNAME:
case DISP_E_MEMBERNOTFOUND:
_snwprintf(pException->szDescription, DESCRIPTION_LENGTH, L"Object doesn't support this property or method: '%s'", pException->szMember);
break;
case DISP_E_TYPEMISMATCH:
if (pException->szMember[0])
{
_snwprintf(pException->szDescription, DESCRIPTION_LENGTH, L"Type mismatch: '%s'. Argument Index: %d", pException->szMember, pException->iArgError);
break;
}
default:
{
#ifndef UNICODE
CHAR szDescription[DESCRIPTION_LENGTH];
#else
LPWSTR szDescription = pException->szDescription;
#endif
cch = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
szDescription, DESCRIPTION_LENGTH, NULL);
if (!cch) wcscpy(pException->szDescription, L"Unknown runtime error");
#ifndef UNICODE
else MultiByteToWideChar(CP_ACP, 0, szDescription, -1, pException->szDescription, DESCRIPTION_LENGTH);
#endif
}
}
}
}
if (pException->szDescription)
{
if (!cch) cch = wcslen(pException->szDescription);
if (cch >= 2 && pException->szDescription[cch - 2] == L'\r')
pException->szDescription[cch - 2] = L'\0';
else if (cch >= 1 && pException->szDescription[cch - 1] == L'\n')
pException->szDescription[cch - 1] = L'\0';
}
if (cchBufferSize)
{
if (!bFixedFont)
{
_snwprintf(szBuffer, cchBufferSize, L"Member:\t %s\r\nFunction:\t %s\t\t\r\nError In:\t %s\r\nError:\t %s\r\nCode:\t %x\r\nSource:\t %s",
pException->szCompleteMember,
pException->szInitialFunction, pException->szErrorFunction,
pException->szDescription, hr,
pException->szSource);
}
else
{
_snwprintf(szBuffer, cchBufferSize, L"Member: %s\r\nFunction: %s\r\nError In: %s\r\nError: %s\r\nCode: %x\r\nSource: %s",
pException->szCompleteMember,
pException->szInitialFunction, pException->szErrorFunction,
pException->szDescription, hr,
pException->szSource);
}
szBuffer[cchBufferSize - 1] = L'\0';
}
return NOERROR;
}
static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
{
VARIANT args[8];
unsigned argn, i;
switch(flags) {
case DISPATCH_PROPERTYGET:
if(!(prop->flags & (BP_GET|BP_GETPUT))) {
FIXME("property does not support DISPATCH_PROPERTYGET\n");
return E_FAIL;
}
break;
case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
if(!prop->proc && prop->flags == BP_GET) {
const int vt = prop->min_args, val = prop->max_args;
switch(vt) {
case VT_I2:
V_VT(res) = VT_I2;
V_I2(res) = val;
break;
case VT_I4:
V_VT(res) = VT_I4;
V_I4(res) = val;
break;
case VT_BSTR: {
const string_constant_t *str = (const string_constant_t*)prop->max_args;
BSTR ret;
ret = SysAllocStringLen(str->buf, str->len);
if(!ret)
return E_OUTOFMEMORY;
V_VT(res) = VT_BSTR;
V_BSTR(res) = ret;
break;
}
DEFAULT_UNREACHABLE;
}
return S_OK;
}
break;
case DISPATCH_METHOD:
if(prop->flags & (BP_GET|BP_GETPUT)) {
FIXME("Call on property\n");
return E_FAIL;
}
break;
case DISPATCH_PROPERTYPUT:
if(!(prop->flags & BP_GETPUT)) {
FIXME("property does not support DISPATCH_PROPERTYPUT\n");
return E_FAIL;
}
FIXME("call put\n");
return E_NOTIMPL;
default:
FIXME("unsupported flags %x\n", flags);
return E_NOTIMPL;
}
argn = arg_cnt(dp);
if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) {
FIXME("invalid number of arguments\n");
return E_FAIL;
}
assert(argn < sizeof(args)/sizeof(*args));
for(i=0; i < argn; i++) {
if(V_VT(dp->rgvarg+dp->cArgs-i-1) == (VT_BYREF|VT_VARIANT))
args[i] = *V_VARIANTREF(dp->rgvarg+dp->cArgs-i-1);
else
args[i] = dp->rgvarg[dp->cArgs-i-1];
}
return prop->proc(This, args, dp->cArgs, res);
}
BSTR JSStringCopyBSTR(const JSStringRef string)
{
return SysAllocStringLen(JSStringGetCharactersPtr(string), JSStringGetLength(string));
}
static void test_ParseName(void)
{
static const WCHAR cadabraW[] = {'c','a','d','a','b','r','a',0};
WCHAR pathW[MAX_PATH];
IShellDispatch *sd;
FolderItem *item;
Folder *folder;
HRESULT hr;
VARIANT v;
BSTR str;
hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellDispatch, (void**)&sd);
ok(hr == S_OK, "got 0x%08x\n", hr);
GetTempPathW(sizeof(pathW)/sizeof(pathW[0]), pathW);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = SysAllocString(pathW);
hr = IShellDispatch_NameSpace(sd, v, &folder);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&v);
item = (void*)0xdeadbeef;
hr = Folder_ParseName(folder, NULL, &item);
ok(hr == S_FALSE, "got 0x%08x\n", hr);
ok(item == NULL, "got %p\n", item);
/* empty name */
str = SysAllocStringLen(NULL, 0);
item = (void*)0xdeadbeef;
hr = Folder_ParseName(folder, str, &item);
ok(hr == S_FALSE, "got 0x%08x\n", hr);
ok(item == NULL, "got %p\n", item);
SysFreeString(str);
/* path doesn't exist */
str = SysAllocString(cadabraW);
item = (void*)0xdeadbeef;
hr = Folder_ParseName(folder, str, &item);
ok(hr == S_FALSE, "got 0x%08x\n", hr);
ok(item == NULL, "got %p\n", item);
SysFreeString(str);
lstrcatW(pathW, cadabraW);
CreateDirectoryW(pathW, NULL);
str = SysAllocString(cadabraW);
item = NULL;
hr = Folder_ParseName(folder, str, &item);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(item != NULL, "got %p\n", item);
SysFreeString(str);
hr = FolderItem_get_Path(item, &str);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(str[0] != 0, "path %s\n", wine_dbgstr_w(str));
SysFreeString(str);
RemoveDirectoryW(pathW);
FolderItem_Release(item);
Folder_Release(folder);
IShellDispatch_Release(sd);
}
static HRESULT WINAPI domcomment_insertData(
IXMLDOMComment *iface,
long offset, BSTR p)
{
domcomment *This = impl_from_IXMLDOMComment( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( This->node );
xmlChar *pXmlContent;
BSTR sNewString;
HRESULT hr = S_FALSE;
long nLength = 0, nLengthP = 0;
xmlChar *str = NULL;
TRACE("%p\n", This);
/* If have a NULL or empty string, don't do anything. */
if(SysStringLen(p) == 0)
return S_OK;
if(offset < 0)
{
return E_INVALIDARG;
}
pXmlContent = xmlNodeGetContent(pDOMNode->node);
if(pXmlContent)
{
BSTR sContent = bstr_from_xmlChar( pXmlContent );
nLength = SysStringLen(sContent);
nLengthP = SysStringLen(p);
if(nLength < offset)
{
SysFreeString(sContent);
xmlFree(pXmlContent);
return E_INVALIDARG;
}
sNewString = SysAllocStringLen(NULL, nLength + nLengthP + 1);
if(sNewString)
{
if(offset > 0)
memcpy(sNewString, sContent, offset * sizeof(WCHAR));
memcpy(&sNewString[offset], p, nLengthP * sizeof(WCHAR));
if(offset+nLengthP < nLength)
memcpy(&sNewString[offset+nLengthP], &sContent[offset], (nLength-offset) * sizeof(WCHAR));
sNewString[nLengthP + nLength] = 0;
str = xmlChar_from_wchar((WCHAR*)sNewString);
if(str)
{
xmlNodeSetContent(pDOMNode->node, str);
hr = S_OK;
}
HeapFree( GetProcessHeap(), 0, str );
SysFreeString(sNewString);
}
SysFreeString(sContent);
xmlFree(pXmlContent);
}
return hr;
}
HRESULT node_transform_node(const xmlnode *This, IXMLDOMNode *stylesheet, BSTR *p)
{
#ifdef SONAME_LIBXSLT
xsltStylesheetPtr xsltSS;
xmlnode *sheet;
if (!libxslt_handle) return E_NOTIMPL;
if (!stylesheet || !p) return E_INVALIDARG;
*p = NULL;
sheet = get_node_obj(stylesheet);
if(!sheet) return E_FAIL;
xsltSS = pxsltParseStylesheetDoc(sheet->node->doc);
if(xsltSS)
{
xmlDocPtr result = pxsltApplyStylesheet(xsltSS, This->node->doc, NULL);
if(result)
{
const xmlChar *content;
if(result->type == XML_HTML_DOCUMENT_NODE)
{
xmlOutputBufferPtr output = xmlAllocOutputBuffer(NULL);
if (output)
{
htmldoc_dumpcontent(output, result->doc);
content = xmlBufferContent(output->buffer);
*p = bstr_from_xmlChar(content);
xmlOutputBufferClose(output);
}
}
else
{
xmlBufferPtr buf = xmlBufferCreate();
if (buf)
{
int size = xmlNodeDump(buf, NULL, (xmlNodePtr)result, 0, 0);
if(size > 0)
{
content = xmlBufferContent(buf);
*p = bstr_from_xmlChar(content);
}
xmlBufferFree(buf);
}
}
xmlFreeDoc(result);
}
/* libxslt "helpfully" frees the XML document the stylesheet was
generated from, too */
xsltSS->doc = NULL;
pxsltFreeStylesheet(xsltSS);
}
if(!*p) *p = SysAllocStringLen(NULL, 0);
return S_OK;
#else
FIXME("libxslt headers were not found at compile time\n");
return E_NOTIMPL;
#endif
}
HWND COccManager::CreateDlgControl(CWnd* pWndParent, HWND hwAfter,
BOOL bDialogEx, LPDLGITEMTEMPLATE pItem, WORD nMsg, BYTE* lpData, DWORD cb)
{
LPWSTR pszClass = (LPWSTR)(pItem + 1);
DLGITEMTEMPLATE dlgItemTmp;
if (bDialogEx)
{
// We have an extended dialog template: copy relevant parts into an
// ordinary dialog template, because their layouts are different
DLGITEMTEMPLATEEX* pItemEx = (DLGITEMTEMPLATEEX*)pItem;
dlgItemTmp.style = pItemEx->style;
dlgItemTmp.dwExtendedStyle = pItemEx->exStyle;
dlgItemTmp.x = pItemEx->x;
dlgItemTmp.y = pItemEx->y;
dlgItemTmp.cx = pItemEx->cx;
dlgItemTmp.cy = pItemEx->cy;
dlgItemTmp.id = (WORD)pItemEx->id;
pItem = &dlgItemTmp;
pszClass = (LPWSTR)(pItemEx + 1);
}
CRect rect(pItem->x, pItem->y, pItem->x + pItem->cx, pItem->y + pItem->cy);
::MapDialogRect(pWndParent->m_hWnd, &rect);
BSTR bstrLicKey = NULL;
// extract license key data, if any
if (cb >= sizeof(ULONG))
{
ULONG cchLicKey = *(UNALIGNED ULONG*)lpData;
lpData += sizeof(ULONG);
cb -= sizeof(ULONG);
if (cchLicKey > 0)
{
bstrLicKey = SysAllocStringLen((LPCOLESTR)lpData, cchLicKey);
lpData += cchLicKey * sizeof(WCHAR);
cb -= cchLicKey * sizeof(WCHAR);
}
}
// If WM_OCC_INITNEW, we should have exhausted all of the data by now.
ASSERT((nMsg != WM_OCC_INITNEW) || (cb == 0));
CDataBoundProperty* pBindings = NULL;
CString strDataField;
WORD ctlidRowSource = 0;
DISPID defdispid = 0;
UINT dwType = 0;
if (nMsg == WM_OCC_LOADFROMSTREAM_EX ||
nMsg == WM_OCC_LOADFROMSTORAGE_EX)
{
// Read the size of the section
ULONG cbOffset = *(UNALIGNED ULONG*)lpData;
ULONG cbBindInfo = cbOffset - sizeof(DWORD);
lpData += sizeof(DWORD);
ULONG dwFlags = *(UNALIGNED ULONG*)lpData;
cbBindInfo -= sizeof(DWORD);
lpData += sizeof(DWORD);
ASSERT(dwFlags == 1);
ULONG cbBinding = *(UNALIGNED ULONG*)lpData;
cbBindInfo -= sizeof(DWORD);
lpData += sizeof(DWORD);
while(cbBindInfo > 0)
{
DISPID dispid;
UWORD ctlid;
dispid = *(UNALIGNED DISPID *)lpData;
lpData += sizeof(DISPID);
cbBindInfo -= sizeof(DISPID);
ctlid = *(UNALIGNED WORD *)lpData;
lpData += sizeof(WORD);
cbBindInfo -= sizeof(WORD);
if(dispid == DISPID_DATASOURCE)
{
defdispid = *(UNALIGNED ULONG*)lpData;
cbBindInfo -= sizeof(DISPID);
lpData += sizeof(DISPID);
dwType = *(UNALIGNED ULONG*)lpData;
cbBindInfo -= sizeof(DWORD);
lpData += sizeof(DWORD);
ASSERT(*(UNALIGNED DISPID *)lpData == DISPID_DATAFIELD);
lpData += sizeof(DISPID);
cbBindInfo -= sizeof(DISPID);
// Skip the string length
lpData += sizeof(DWORD);
cbBindInfo -= sizeof(DWORD);
strDataField = (char *)lpData;
lpData += strDataField.GetLength()+1;
cbBindInfo -= strDataField.GetLength()+1;
ctlidRowSource = ctlid;
} else
pBindings = new CDataBoundProperty(pBindings, dispid, ctlid);
}
cb -= cbOffset;
}
// From now on act as a regular type
nMsg -= (WM_OCC_LOADFROMSTREAM_EX - WM_OCC_LOADFROMSTREAM);
GUID clsid;
HRESULT hr;
if (pszClass[0] == L'{')
hr = CLSIDFromString(pszClass, &clsid);
else
hr = CLSIDFromProgID(pszClass, &clsid);
#ifdef _DEBUG
if (FAILED(hr))
{
TRACE1("Unable to convert \"%ls\" to a class ID.\n", pszClass);
TRACE1(">>> Result code: 0x%08lx\n", hr);
if (pszClass[0] != L'{')
TRACE0(">>> Is the control properly registered?\n");
}
#endif
CMemFile memFile(lpData, cb);
CMemFile* pMemFile = (nMsg == WM_OCC_INITNEW) ? NULL : &memFile;
CWnd* pWndNew = NULL;
COleControlSite* pSite = NULL;
if (SUCCEEDED(hr) &&
pWndParent->InitControlContainer() &&
pWndParent->m_pCtrlCont->CreateControl(NULL, clsid, NULL, pItem->style,
rect, pItem->id, pMemFile, (nMsg == WM_OCC_LOADFROMSTORAGE),
bstrLicKey, &pSite))
{
ASSERT(pSite != NULL);
// set ZOrder only!
SetWindowPos(pSite->m_hWnd, hwAfter, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
pSite->m_pBindings = pBindings;
pSite->m_strDataField = strDataField;
pSite->m_ctlidRowSource = ctlidRowSource;
pSite->m_defdispid = defdispid;
pSite->m_dwType = dwType;
// Determine if this is a DataSource by QI for ICursor
ICursor* pCursor;
if (SUCCEEDED(pSite->m_pObject->QueryInterface(IID_ICursor,
(LPVOID *)&pCursor)))
{
pCursor->Release();
pSite->m_pDataSourceControl = new CDataSourceControl(pSite);
}
}
if (bstrLicKey != NULL)
SysFreeString(bstrLicKey);
return (pSite != NULL) ? pSite->m_hWnd : NULL;
}
