QString qAxInit()
{
static QString libFile;
if (initCount++)
return libFile;
InitializeCriticalSection(&qAxModuleSection);
libFile = QString::fromWCharArray(qAxModuleFilename);
libFile = libFile.toLower();
if (LoadTypeLibEx(reinterpret_cast<const wchar_t *>(libFile.utf16()),
REGKIND_NONE, &qAxTypeLibrary) == S_OK)
return libFile;
const int lastDot = libFile.lastIndexOf(QLatin1Char('.'));
libFile.truncate(lastDot);
libFile += QLatin1String(".tlb");
if (LoadTypeLibEx(reinterpret_cast<const wchar_t *>(libFile.utf16()),
REGKIND_NONE, &qAxTypeLibrary) == S_OK)
return libFile;
libFile.truncate(lastDot);
libFile += QLatin1String(".olb");
if (LoadTypeLibEx(reinterpret_cast<const wchar_t *>(libFile.utf16()),
REGKIND_NONE, &qAxTypeLibrary) == S_OK)
return libFile;
return QString();
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow) {
CoInitialize(NULL);
#if 0
// register the type lib
ITypeLib* pTLib = NULL;
LoadTypeLibEx(L"AnyEXETypeInfo.tlb", REGKIND_REGISTER, &pTLib);
pTLib->Release();
#endif
if(strstr(lpCmdLine, "/Embedding") || strstr(lpCmdLine, "-Embedding")) {
ComponentClassFactory cf;
DWORD regID = 0;
CoRegisterClassObject(CLSID_Component, (IClassFactory*)&cf, CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, ®ID);
MSG ms;
while(GetMessage(&ms, 0, 0, 0)) {
TranslateMessage(&ms);
DispatchMessage(&ms);
}
CoRevokeClassObject(regID);
}
CoUninitialize();
return 0;
}
int main(int argc, char* argv[])
{
// ATL helper macro to convert between ANSI and Unicode strings.
USES_CONVERSION;
char oneMoreTime; // ('n' or 'y')
char pathToComServer[100] = {0};
do
{
// Get path to COM server.
cout << "Please enter path to COM server (or *tlb file)";
ITypeLib* pTypeLib = NULL;
cin.ignore(0, '\n');
cin.get(pathToComServer, 100);
// Load type information for a COM server.
if(SUCCEEDED(LoadTypeLibEx(A2W(pathToComServer), REGKIND_DEFAULT, &pTypeLib)))
{
// Read info about the type lib.
DumpLibraryStats(pTypeLib);
// Read info about COM types.
DumpComTypes(pTypeLib);
// COM clean up.
pTypeLib->Release();
}
// Want another?
cout << "Do you want to enter another? (y or n)";
cin >> oneMoreTime;
}while (oneMoreTime != 'n');
return 0;
}
/*
* call-seq:
* WIN32OLE_TYPE.new(typelib, ole_class) -> WIN32OLE_TYPE object
*
* Returns a new WIN32OLE_TYPE object.
* The first argument <i>typelib</i> specifies OLE type library name.
* The second argument specifies OLE class name.
*
* WIN32OLE_TYPE.new('Microsoft Excel 9.0 Object Library', 'Application')
* # => WIN32OLE_TYPE object of Application class of Excel.
*/
static VALUE
foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass)
{
VALUE file;
OLECHAR * pbuf;
ITypeLib *pTypeLib;
HRESULT hr;
SafeStringValue(oleclass);
SafeStringValue(typelib);
file = typelib_file(typelib);
if (file == Qnil) {
file = typelib;
}
pbuf = ole_vstr2wc(file);
hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
if (FAILED(hr))
ole_raise(hr, eWIN32OLERuntimeError, "failed to LoadTypeLibEx");
SysFreeString(pbuf);
if (oleclass_from_typelib(self, pTypeLib, oleclass) == Qfalse) {
OLE_RELEASE(pTypeLib);
rb_raise(eWIN32OLERuntimeError, "not found `%s` in `%s`",
StringValuePtr(oleclass), StringValuePtr(typelib));
}
OLE_RELEASE(pTypeLib);
return self;
}
static HRESULT
oletypelib_from_guid(VALUE guid, VALUE version, ITypeLib **ppTypeLib)
{
VALUE path;
OLECHAR *pBuf;
HRESULT hr;
path = oletypelib_path(guid, version);
if (path == Qnil) {
return E_UNEXPECTED;
}
pBuf = ole_vstr2wc(path);
hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
SysFreeString(pBuf);
return hr;
}
ITypeLib *tCOMUtil::LoadTypeLibByName(const char *pcFilename)
{
HRESULT hr;
ITypeLib *ptlib = NULL;
wchar_t *wcFilename = new wchar_t[strlen(pcFilename)+1];
mbstowcs(wcFilename, pcFilename, strlen(pcFilename)+1);
hr = LoadTypeLibEx(wcFilename, REGKIND_NONE, &ptlib);
delete wcFilename;
wcFilename = NULL;
if(FAILED(hr))
return NULL;
return ptlib;
}
static void
CheckTlbPath(JSONWriter& aJson, const nsAString& aTypelibPath)
{
const nsString& flatPath = PromiseFlatString(aTypelibPath);
DWORD bufCharLen = ExpandEnvironmentStrings(flatPath.get(), nullptr, 0);
auto buf = MakeUnique<WCHAR[]>(bufCharLen);
if (!ExpandEnvironmentStrings(flatPath.get(), buf.get(), bufCharLen)) {
return;
}
// See whether this tlb can actually be loaded
RefPtr<ITypeLib> typeLib;
HRESULT hr = LoadTypeLibEx(buf.get(), REGKIND_NONE, getter_AddRefs(typeLib));
nsPrintfCString loadResult("0x%08X", hr);
aJson.StringProperty("LoadResult", loadResult.get());
}
/***********************************************************************
* DllRegisterServer (shdocvw.@)
*/
HRESULT WINAPI DllRegisterServer(void)
{
ITypeLib *typelib;
HRESULT hres;
static const WCHAR shdocvwW[] = {'s','h','d','o','c','v','w','.','d','l','l',0};
hres = register_server(TRUE);
if(FAILED(hres))
return hres;
hres = LoadTypeLibEx(shdocvwW, REGKIND_REGISTER, &typelib);
if(FAILED(hres)) {
ERR("Could not load typelib: %08x\n", hres);
return hres;
}
ITypeLib_Release(typelib);
return hres;
}
//==============================================
int g_RegisterCOM() {
HRESULT hr;
ITypeLib* pTypeLib;
// Register typelib
hr = LoadTypeLibEx(L"CP_TimeSync.exe", REGKIND_REGISTER, &pTypeLib);
if( hr != S_OK) {
return 1;
}
pTypeLib->Release();
// Register server
hr = g_RegisterServer( "CP_TimeSync.exe", // application filename, full path is not needed
CLSID_CP_TimeSyncClass, // ClassID GUID
"CP_TimeSync", // Friendly name - shows up in dcomcnfg
"CP_TimeSync.Application", // Version-independent ProgID used in late - binding
"CP_TimeSync.Application.1", // ProgID with version
NULL); // Threading model
if( hr != S_OK) return 2;
return 0;
}
/*
* call-seq:
* WIN32OLE_TYPELIB.new(typelib [, version1, version2]) -> WIN32OLE_TYPELIB object
*
* Returns a new WIN32OLE_TYPELIB object.
*
* The first argument <i>typelib</i> specifies OLE type library name or GUID or
* OLE library file.
* The second argument is major version or version of the type library.
* The third argument is minor version.
* The second argument and third argument are optional.
* If the first argument is type library name, then the second and third argument
* are ignored.
*
* tlib1 = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
* tlib2 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}')
* tlib3 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}', 1.3)
* tlib4 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}', 1, 3)
* tlib5 = WIN32OLE_TYPELIB.new("C:\\WINNT\\SYSTEM32\\SHELL32.DLL")
* puts tlib1.name # -> 'Microsoft Excel 9.0 Object Library'
* puts tlib2.name # -> 'Microsoft Excel 9.0 Object Library'
* puts tlib3.name # -> 'Microsoft Excel 9.0 Object Library'
* puts tlib4.name # -> 'Microsoft Excel 9.0 Object Library'
* puts tlib5.name # -> 'Microsoft Shell Controls And Automation'
*
*/
static VALUE
foletypelib_initialize(VALUE self, VALUE args)
{
VALUE found = Qfalse;
VALUE typelib = Qnil;
int len = 0;
OLECHAR * pbuf;
ITypeLib *pTypeLib;
HRESULT hr = S_OK;
len = RARRAY_LEN(args);
rb_check_arity(len, 1, 3);
typelib = rb_ary_entry(args, 0);
SafeStringValue(typelib);
found = oletypelib_search_registry(self, typelib);
if (found == Qfalse) {
found = oletypelib_search_registry2(self, args);
}
if (found == Qfalse) {
pbuf = ole_vstr2wc(typelib);
hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
SysFreeString(pbuf);
if (SUCCEEDED(hr)) {
found = Qtrue;
oletypelib_set_member(self, pTypeLib);
}
}
if (found == Qfalse) {
rb_raise(eWIN32OLERuntimeError, "not found type library `%s`",
StringValuePtr(typelib));
}
return self;
}
static void test_dump_typelib(const char *name)
{
WCHAR wszName[MAX_PATH];
ITypeLib *typelib;
int ifcount = sizeof(info)/sizeof(info[0]);
int iface, func;
MultiByteToWideChar(CP_UTF8, 0, name, -1, wszName, MAX_PATH);
ole_check(LoadTypeLibEx(wszName, REGKIND_NONE, &typelib));
expect_eq(ITypeLib_GetTypeInfoCount(typelib), ifcount, UINT, "%d");
for (iface = 0; iface < ifcount; iface++)
{
const interface_info *if_info = &info[iface];
ITypeInfo *typeinfo;
TYPEATTR *typeattr;
BSTR bstrIfName;
trace("Interface %s\n", if_info->name);
ole_check(ITypeLib_GetTypeInfo(typelib, iface, &typeinfo));
ole_check(ITypeLib_GetDocumentation(typelib, iface, &bstrIfName, NULL, NULL, NULL));
expect_wstr_utf8val(bstrIfName, if_info->name);
SysFreeString(bstrIfName);
ole_check(ITypeInfo_GetTypeAttr(typeinfo, &typeattr));
expect_int(typeattr->typekind, if_info->type);
expect_hex(typeattr->wTypeFlags, if_info->wTypeFlags);
expect_int(typeattr->cbAlignment, if_info->cbAlignment);
expect_int(typeattr->cbSizeInstance, if_info->cbSizeInstance);
expect_int(typeattr->cbSizeVft, if_info->cbSizeVft);
expect_int(typeattr->cFuncs, if_info->cFuncs);
for (func = 0; func < typeattr->cFuncs; func++)
{
function_info *fn_info = (function_info *)&if_info->funcs[func];
FUNCDESC *desc;
BSTR namesTab[256];
UINT cNames;
int i;
trace("Function %s\n", fn_info->names[0]);
ole_check(ITypeInfo_GetFuncDesc(typeinfo, func, &desc));
expect_int(desc->memid, fn_info->memid);
expect_int(desc->funckind, fn_info->funckind);
expect_int(desc->invkind, fn_info->invkind);
expect_int(desc->callconv, fn_info->callconv);
expect_int(desc->cParams, fn_info->cParams);
expect_int(desc->cParamsOpt, fn_info->cParamsOpt);
expect_int(desc->oVft, fn_info->oVft);
expect_int(desc->cScodes, fn_info->cScodes);
expect_int(desc->wFuncFlags, fn_info->wFuncFlags);
ole_check(ITypeInfo_GetNames(typeinfo, desc->memid, namesTab, 256, &cNames));
for (i = 0; i < cNames; i++)
{
expect_wstr_utf8val(namesTab[i], fn_info->names[i]);
SysFreeString(namesTab[i]);
}
expect_null(fn_info->names[cNames]);
check_type(&desc->elemdescFunc, &fn_info->ret_type);
for (i = 0 ; i < desc->cParams; i++)
{
check_type(&desc->lprgelemdescParam[i], &fn_info->params[i]);
}
expect_int(fn_info->params[desc->cParams].vt, (VARTYPE)-1);
ITypeInfo_ReleaseFuncDesc(typeinfo, desc);
}
ITypeInfo_ReleaseTypeAttr(typeinfo, typeattr);
ITypeInfo_Release(typeinfo);
}
ITypeLib_Release(typelib);
}
static HRESULT register_server(BOOL do_register)
{
HRESULT hres;
HMODULE hAdvpack;
HRESULT (WINAPI *pRegInstall)(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
STRTABLEA strtable;
STRENTRYA pse[35];
static CLSID const *clsids[35];
unsigned int i = 0;
static const WCHAR wszAdvpack[] = {'a','d','v','p','a','c','k','.','d','l','l',0};
TRACE("(%x)\n", do_register);
INF_SET_CLSID(AboutProtocol);
INF_SET_CLSID(CAnchorBrowsePropertyPage);
INF_SET_CLSID(CBackgroundPropertyPage);
INF_SET_CLSID(CCDAnchorPropertyPage);
INF_SET_CLSID(CCDGenericPropertyPage);
INF_SET_CLSID(CDocBrowsePropertyPage);
INF_SET_CLSID(CDwnBindInfo);
INF_SET_CLSID(CHiFiUses);
INF_SET_CLSID(CHtmlComponentConstructor);
INF_SET_CLSID(CImageBrowsePropertyPage);
INF_SET_CLSID(CInlineStylePropertyPage);
INF_SET_CLSID(CPeerHandler);
INF_SET_CLSID(CRecalcEngine);
INF_SET_CLSID(CSvrOMUses);
INF_SET_CLSID(CrSource);
INF_SET_CLSID(ExternalFrameworkSite);
INF_SET_CLSID(HTADocument);
INF_SET_CLSID(HTMLDocument);
INF_SET_CLSID(HTMLLoadOptions);
INF_SET_CLSID(HTMLPluginDocument);
INF_SET_CLSID(HTMLPopup);
INF_SET_CLSID(HTMLPopupDoc);
INF_SET_CLSID(HTMLServerDoc);
INF_SET_CLSID(HTMLWindowProxy);
INF_SET_CLSID(IImageDecodeFilter);
INF_SET_CLSID(IImgCtx);
INF_SET_CLSID(IntDitherer);
INF_SET_CLSID(JSProtocol);
INF_SET_CLSID(MHTMLDocument);
INF_SET_CLSID(MailtoProtocol);
INF_SET_CLSID(ResProtocol);
INF_SET_CLSID(Scriptlet);
INF_SET_CLSID(SysimageProtocol);
INF_SET_CLSID(TridentAPI);
INF_SET_ID(LIBID_MSHTML);
for(i=0; i < sizeof(pse)/sizeof(pse[0]); i++) {
pse[i].pszValue = heap_alloc(39);
sprintf(pse[i].pszValue, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
clsids[i]->Data1, clsids[i]->Data2, clsids[i]->Data3, clsids[i]->Data4[0],
clsids[i]->Data4[1], clsids[i]->Data4[2], clsids[i]->Data4[3], clsids[i]->Data4[4],
clsids[i]->Data4[5], clsids[i]->Data4[6], clsids[i]->Data4[7]);
}
strtable.cEntries = sizeof(pse)/sizeof(pse[0]);
strtable.pse = pse;
hAdvpack = LoadLibraryW(wszAdvpack);
pRegInstall = (void *)GetProcAddress(hAdvpack, "RegInstall");
hres = pRegInstall(hInst, do_register ? "RegisterDll" : "UnregisterDll", &strtable);
for(i=0; i < sizeof(pse)/sizeof(pse[0]); i++)
heap_free(pse[i].pszValue);
if(FAILED(hres)) {
ERR("RegInstall failed: %08x\n", hres);
return hres;
}
if(do_register) {
ITypeLib *typelib;
static const WCHAR wszMSHTML[] = {'m','s','h','t','m','l','.','t','l','b',0};
hres = LoadTypeLibEx(wszMSHTML, REGKIND_REGISTER, &typelib);
if(SUCCEEDED(hres))
ITypeLib_Release(typelib);
}else {
hres = UnRegisterTypeLib(&LIBID_MSHTML, 4, 0, LOCALE_SYSTEM_DEFAULT, SYS_WIN32);
}
if(FAILED(hres))
ERR("typelib registration failed: %08x\n", hres);
return hres;
}
HRESULT CoCOMServer::LoadTypeInfo(ITypeInfo ** pptinfo, const CLSID &libid, const CLSID &iid, LCID lcid)
{
HRESULT hr;
LPTYPELIB ptlib = NULL;
LPTYPEINFO ptinfo = NULL;
*pptinfo = NULL;
// Load type library.
hr = LoadRegTypeLib(libid, 1, 0, lcid, &ptlib);
if (FAILED(hr))
{ // search for TypeLib in current dll
WCHAR buf[MAX_PATH * sizeof(WCHAR)]; // LoadTypeLibEx needs Unicode string
if (GetModuleFileNameW(g_hInstance, buf, _countof(buf)))
hr = LoadTypeLibEx(buf,REGKIND_NONE,&ptlib);
else // MemoryModule, search troug g_ListOfMemoryModules and use temp file to extract and load TypeLib file
{
HMEMORYMODULE hmodule = (HMEMORYMODULE)(g_hMemoryModule);
HMEMORYRSRC res = MemoryFindResource(hmodule,_T("TYPELIB"),MAKEINTRESOURCE(1));
if (!res)
return TYPE_E_INVALIDSTATE;
DWORD resSize = MemorySizeOfResource(hmodule,res);
// Path to temp directory + our temporary file name
DWORD tempPathLength = GetTempPathW(MAX_PATH, buf);
wcscpy(buf + tempPathLength,L"AutoHotkey.MemoryModule.temp.tlb");
// Write manifest to temportary file
// Using FILE_ATTRIBUTE_TEMPORARY will avoid writing it to disk
// It will be deleted after LoadTypeLib has been called.
HANDLE hFile = CreateFileW(buf,GENERIC_WRITE,NULL,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_TEMPORARY,NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
#if DEBUG_OUTPUT
OutputDebugStringA("CreateFile failed.\n");
#endif
return TYPE_E_CANTLOADLIBRARY; //failed to create file, continue and try loading without CreateActCtx
}
DWORD byteswritten = 0;
WriteFile(hFile,MemoryLoadResource(hmodule,res),resSize,&byteswritten,NULL);
CloseHandle(hFile);
if (byteswritten == 0)
{
#if DEBUG_OUTPUT
OutputDebugStringA("WriteFile failed.\n");
#endif
return TYPE_E_CANTLOADLIBRARY; //failed to write data, continue and try loading
}
hr = LoadTypeLibEx(buf,REGKIND_NONE,&ptlib);
// Open file and automatically delete on CloseHandle (FILE_FLAG_DELETE_ON_CLOSE)
hFile = CreateFileW(buf,GENERIC_WRITE,FILE_SHARE_DELETE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_TEMPORARY|FILE_FLAG_DELETE_ON_CLOSE,NULL);
CloseHandle(hFile);
}
if (FAILED(hr))
return hr;
}
// Get type information for interface of the object.
hr = ptlib->GetTypeInfoOfGuid(iid, &ptinfo);
if (FAILED(hr))
{
ptlib->Release();
return hr;
}
ptlib->Release();
*pptinfo = ptinfo;
return NOERROR;
}
// deprecated - remove once a registry-free version of Safari has shipped (first major version after 3.1.1)
static void registerWebKitNightly()
{
// look up server's file name
TCHAR szFileName[MAX_PATH];
GetModuleFileName(gInstance, szFileName, MAX_PATH);
typedef HRESULT (WINAPI *RegisterTypeLibForUserPtr)(ITypeLib*, OLECHAR*, OLECHAR*);
COMPtr<ITypeLib> typeLib;
LoadTypeLibEx(szFileName, REGKIND_NONE, &typeLib);
if (RegisterTypeLibForUserPtr registerTypeLibForUser = reinterpret_cast<RegisterTypeLibForUserPtr>(GetProcAddress(GetModuleHandle(TEXT("oleaut32.dll")), "RegisterTypeLibForUser")))
registerTypeLibForUser(typeLib.get(), szFileName, 0);
else
RegisterTypeLib(typeLib.get(), szFileName, 0);
HKEY userClasses;
if (RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("SOFTWARE\\CLASSES"), 0, KEY_WRITE, &userClasses) != ERROR_SUCCESS)
userClasses = 0;
// register entries from table
int nEntries = ARRAYSIZE(gRegTable);
HRESULT hr = S_OK;
for (int i = 0; SUCCEEDED(hr) && i < nEntries; i++) {
LPTSTR pszKeyName = _tcsdup(gRegTable[i][0]);
LPTSTR pszValueName = gRegTable[i][1] ? _tcsdup(gRegTable[i][1]) : 0;
LPTSTR allocatedValue = (gRegTable[i][2] != (LPTSTR)-1) ? _tcsdup(gRegTable[i][2]) : (LPTSTR)-1;
LPTSTR pszValue = allocatedValue;
if (pszKeyName && pszValue) {
int clsidIndex = i/gSlotsPerEntry;
substituteGUID(pszKeyName, &gRegCLSIDs[clsidIndex]);
substituteGUID(pszValueName, &gRegCLSIDs[clsidIndex]);
// map rogue value to module file name
if (pszValue == (LPTSTR)-1)
pszValue = szFileName;
else
substituteGUID(pszValue, &gRegCLSIDs[clsidIndex]);
// create the key
HKEY hkey;
LONG err = RegCreateKey(HKEY_CLASSES_ROOT, pszKeyName, &hkey);
if (err != ERROR_SUCCESS && userClasses)
err = RegCreateKey(userClasses, pszKeyName, &hkey);
if (err == ERROR_SUCCESS) {
// set the value
err = RegSetValueEx(hkey, pszValueName, 0, REG_SZ, (const BYTE*)pszValue, (DWORD) sizeof(pszValue[0])*(_tcslen(pszValue) + 1));
RegCloseKey(hkey);
}
}
if (pszKeyName)
free(pszKeyName);
if (pszValueName)
free(pszValueName);
if (allocatedValue && allocatedValue != (LPTSTR)-1)
free(allocatedValue);
}
if (userClasses)
RegCloseKey(userClasses);
}
