IDebugApplication *get_debug_application()
{
HRESULT hr = S_OK;
IClassFactory *classFactory = nullptr;
IProcessDebugManager *pdm = nullptr;
IDebugApplication *debugApplication = nullptr;
IfComFailError(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED));
IfComFailError(CoGetClassObject(__uuidof(ProcessDebugManager), CLSCTX_INPROC_SERVER, NULL, __uuidof(IClassFactory), (LPVOID *) &classFactory));
IfComFailError(classFactory->CreateInstance(0, _uuidof(IProcessDebugManager), (LPVOID *) &pdm));
Assert::IsTrue(SUCCEEDED(pdm->GetDefaultApplication(&debugApplication)));
error:
if (pdm)
{
pdm->Release();
}
if (classFactory)
{
classFactory->Release();
}
return debugApplication;
}
HRESULT MyCoCreateInstance(LPCTSTR lpDll, const CLSID& rclsid, const IID& riid, void** ppv)
{
HRESULT hr = E_FAIL;
HMODULE hDll = LoadLibrary(lpDll);
if ( hDll != NULL )
{
HRESULT (WINAPI *pfnDllGetClassObject)(const CLSID& rclsid, const IID& riid, void** ppv);
(FARPROC&)pfnDllGetClassObject = GetProcAddress(hDll, "DllGetClassObject");
if ( pfnDllGetClassObject != NULL )
{
IClassFactory* lpClassFactory = NULL;
hr = pfnDllGetClassObject(rclsid, IID_IClassFactory, (PVOID*)&lpClassFactory);
if ( SUCCEEDED(hr) && lpClassFactory != NULL )
{
hr = lpClassFactory->CreateInstance(NULL, riid, ppv);
lpClassFactory->Release();
lpClassFactory = NULL;
}
}
}
return hr;
}
bool initialize()
{
DllGetClassObjectFunc pfnDllGetClassObject = nullptr;
IClassFactory *pClassFactory = nullptr;
m_hLibMLang = LoadLibrary(_T("mlang.dll"));
if (m_hLibMLang != nullptr)
{
pfnDllGetClassObject = (DllGetClassObjectFunc)GetProcAddress(m_hLibMLang, "DllGetClassObject");
if (pfnDllGetClassObject != nullptr)
{
HRESULT hr = pfnDllGetClassObject(CLSID_CMultiLanguage, IID_IClassFactory, (void**)&pClassFactory);
if (pClassFactory != nullptr)
{
hr = pClassFactory->CreateInstance(nullptr, IID_IMultiLanguage2, (void**)&m_pmlang);
if (SUCCEEDED(hr))
{
pClassFactory->Release();
return true;
}
}
}
}
if (pClassFactory != nullptr)
pClassFactory->Release();
if (m_hLibMLang != nullptr)
{
FreeLibrary(m_hLibMLang);
m_hLibMLang = nullptr;
}
return false;
}
int main()
{
TRACE("Starting COM-Client-Application\n");
IUnknown* pUnk;
IMotion* pMot;
IVisual* pVis;
IClassFactory* pClf;
GetClassObject(CLSID_CSpaceship, IID_IClassFactory, (void**) &pClf);
pClf->CreateInstance(IID_IUnknown, (void**) &pUnk);
pUnk->QueryInterface(IID_IMotion, (void**) &pMot);
pMot->QueryInterface(IID_IVisual, (void**) &pVis);
TRACE("pUnk: %p, pMot: %p, pVis: %p\n", pUnk, pMot, pVis);
pMot->Fly();
int nPos = pMot->GetPosition();
TRACE("nPos: %d\n", nPos);
pVis->Display();
pClf->Release();
pUnk->Release();
pMot->Release();
pVis->Release();
return 0;
}
HRESULT PALAPI PAL_CoCreateInstance(REFCLSID rclsid,
REFIID riid,
void **ppv)
{
for (size_t i = 0; i < sizeof(g_CoClasses) / sizeof(g_CoClasses[0]); i++)
{
const CoClass *pCoClass = &g_CoClasses[i];
if (*pCoClass->pClsid == rclsid)
{
HRESULT hr;
HINSTANCE dll;
DLLGETCLASSOBJECT *dllGetClassObject;
IClassFactory *classFactory;
WCHAR FullPath[_MAX_PATH];
if (!PAL_GetPALDirectoryW(FullPath, _MAX_PATH)) {
goto Win32Error;
}
if (wcslen(FullPath) + wcslen(pCoClass->dllName) >= _MAX_PATH) {
SetLastError(ERROR_FILENAME_EXCED_RANGE);
goto Win32Error;
}
wcsncat(FullPath, pCoClass->dllName, _MAX_PATH);
dll = LoadLibraryW(FullPath);
if (dll == NULL)
goto Win32Error;
dllGetClassObject = (DLLGETCLASSOBJECT*)GetProcAddress(dll, "DllGetClassObject");
if (dllGetClassObject == NULL) {
// The CLR shim exports a DllGetClassObject which in turn decides which DLL to load and
// call DllGetClassObjectInternal on. Without the shim, the PALRT must do the same
// here.
dllGetClassObject = (DLLGETCLASSOBJECT*)GetProcAddress(dll, "DllGetClassObjectInternal");
if (dllGetClassObject == NULL) {
goto Win32Error;
}
}
hr = (*dllGetClassObject)(rclsid, IID_IClassFactory, (void**)&classFactory);
if (FAILED(hr))
return hr;
hr = classFactory->CreateInstance(NULL, riid, ppv);
classFactory->Release();
return hr;
}
}
_ASSERTE(!"Unknown CLSID in PAL_CoCreateInstance");
return CLASS_E_CLASSNOTAVAILABLE;
Win32Error:
DWORD dwError = GetLastError();
return HRESULT_FROM_WIN32(dwError);
}
nekoFlashInstance::nekoFlashInstance(nekoIBlock *block)
: nekoIBlockInstance(block)
, mFlashType(FLASH_MOVIE)
, mCurView(NULL)
, mSkipAbleTime(0)
, mOleObject(0)
, mFlashSite(0)
, flashInterface(0)
{
HMODULE flashLib = GetNekoNovel()->GetFlashLib();
mFlashSite = nekoNew nekoFlashSite;
mFlashSite->Init(this);
if(flashLib)
{
IClassFactory* factory = 0;
GetClassObject getClassFunc = (GetClassObject)GetProcAddress(flashLib, "DllGetClassObject");
HRESULT result = getClassFunc(ShockwaveFlashObjects::CLSID_ShockwaveFlash, IID_IClassFactory, (void**)&factory);
if(SUCCEEDED(result))
{
factory->CreateInstance(NULL, IID_IOleObject, (void**)&mOleObject);
factory->Release();
}
}
// If we still don't have the object, try loading from registry
if(!mOleObject)
{
HRESULT result = CoCreateInstance(ShockwaveFlashObjects::CLSID_ShockwaveFlash, 0, CLSCTX_INPROC_SERVER, IID_IOleObject, (void**)&mOleObject);
if(FAILED(result))
{
LogPrint(LOG_LEVEL_WARN, "플래시 컨트롤을 불러올 수 없습니다.\nFlash.ocx가 설치되어 있지 않을 수 있습니다.");
return;
}
}
IOleClientSite* clientSite = 0;
mFlashSite->QueryInterface(__uuidof(IOleClientSite), (void**)&clientSite);
mOleObject->SetClientSite(clientSite);
clientSite->Release();
mOleObject->QueryInterface(__uuidof(ShockwaveFlashObjects::IShockwaveFlash), (LPVOID*)&flashInterface);
flashInterface->PutWMode("opaque");
mOleObject->DoVerb(OLEIVERB_SHOW, 0, clientSite, 0, 0, 0);
clientSite->Release();
//mOleObject->QueryInterface(__uuidof(IOleInPlaceObjectWindowless), (LPVOID*)windowlessObject.Pptr());
flashInterface->QueryInterface(IID_IViewObject, (void**)&mCurView);
mBufferUsingCount++;
}
STDAPI DllGetClassObject( REFCLSID clsid, REFIID riid, void** ppv )
{
IClassFactory* pFactory = NULL;
if (CLSID_MackieControlXT == clsid)
{
// TRACE("DllGetClassObject: CMackieControlXTFactory\n");
pFactory = new CMackieControlXTFactory; // No AddRef in constructor
}
else if (CLSID_MackieControlXTPropPage == clsid)
{
// TRACE("DllGetClassObject: CMackieControlXTPropPageFactory\n");
pFactory = new CMackieControlXTPropPageFactory; // No AddRef in constructor
}
else if (CLSID_MackieControlMaster == clsid)
{
// TRACE("DllGetClassObject: CMackieControlMasterFactory\n");
pFactory = new CMackieControlMasterFactory; // No AddRef in constructor
}
else if (CLSID_MackieControlMasterPropPage == clsid)
{
// TRACE("DllGetClassObject: CMackieControlMasterPropPageFactory\n");
pFactory = new CMackieControlMasterPropPageFactory; // No AddRef in constructor
}
else if (CLSID_MackieControlC4 == clsid)
{
// TRACE("DllGetClassObject: CMackieControlC4Factory\n");
pFactory = new CMackieControlC4Factory; // No AddRef in constructor
}
else if (CLSID_MackieControlC4PropPage == clsid)
{
// TRACE("DllGetClassObject: CMackieControlC4PropPageFactory\n");
pFactory = new CMackieControlC4PropPageFactory; // No AddRef in constructor
}
else
{
// TRACE("DllGetClassObject: CLASS_E_CLASSNOTAVAILABLE\n");
return CLASS_E_CLASSNOTAVAILABLE;
}
if (!pFactory)
{
// TRACE("DllGetClassObject: E_OUTOFMEMORY");
return E_OUTOFMEMORY;
}
// Get requested interface.
HRESULT const hr = pFactory->QueryInterface( riid, ppv );
pFactory->Release();
return hr;
}
/**
* @brief Get a class factory able to create objects of class ID requestedClassID.
*
* NOTE: This function does NOT do what the MSDN spec actually says it does. Fix this is if that's important.
* Note: The caller is responsible for releasing the class factory.
* Note: This implementation is intended for use for inprocess COM only.
* http://msdn2.microsoft.com/en-us/library/ms684007.aspx
* @param requestedClassID class ID for which you want a class factory
* @param dwClsContext should be CLSCTX_INPROC
* @param factoryInterface receives the desired class factory, of type IClassFactory
* @return S_OK upon success, CO_E_NOT_SUPPORTED upon being given an unsupported context, or REGDB_E_CLASSNOTREG upon a bunch of means of failure
* @return E_OUTOFMEMORY upon running out of memory while creating the class factory
* @return E_NOINTERFACE if the class does not support the requested interface
* @return CLASS_E_CLASSNOTAVAILABLE if the DLL does not support the requested class id, though the dll map file claimed it did
* @return REGDB_E_CLASSNOTREG if there was an error calling DllGetClassObject and we never registered the factory
*/
DLLEXPORT
HRESULT CoGetClassObject(REFCLSID requestedClassID, DWORD dwClsContext, LPVOID,
REFIID /*requestedInterfaceID*/, LPVOID* factoryInterface)
{
if (dwClsContext != CLSCTX_INPROC) {
return CO_E_NOT_SUPPORTED;
}
IClassFactory* factory = NULL;
HRESULT hr = ComRegistry::getInstance()->getFactoryPointer(requestedClassID, &factory);
if (SUCCEEDED(hr))
factory->AddRef();
*factoryInterface = factory;
return hr;
}
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
{
HRESULT result = E_INVALIDARG;
if (NULL != ppv)
{
IClassFactory *classFactory = NULL;
if (CLSID_YCbCrPixelFormatConverter == rclsid)
{
result = S_OK;
classFactory = new TestClassFactory<YCbCrPixelFormatConverter>();
}
else if (CLSID_CmykPixelFormatConverter == rclsid)
{
result = S_OK;
classFactory = new TestClassFactory<CmykPixelFormatConverter>();
}
else if (CLSID_AitDecoder == rclsid)
{
result = S_OK;
classFactory = new TestClassFactory<AitDecoder>();
}
else if (CLSID_AitEncoder == rclsid)
{
result = S_OK;
classFactory = new TestClassFactory<AitEncoder>();
}
else
{
result = E_NOINTERFACE;
}
if (SUCCEEDED(result))
{
if (NULL != classFactory)
{
result = classFactory->QueryInterface(riid, ppv);
}
else
{
result = E_OUTOFMEMORY;
}
}
}
return result;
}
extern "C" HRESULT CoCreateInstance(REFCLSID requestedClassID,
LPUNKNOWN outerAggregateIUnknown, DWORD /*dwClsContext*/,
REFIID objectInterfaceID, LPVOID* objectInterface)
{
*objectInterface = NULL;
IClassFactory* pIFactory = NULL;
HRESULT hr = CoGetClassObject(requestedClassID, static_cast<unsigned long>(CLSCTX_INPROC),
(void *)0, IID_IClassFactory, (void **)&pIFactory);
if (SUCCEEDED(hr))
{
// Create the component
hr = pIFactory->CreateInstance(outerAggregateIUnknown, objectInterfaceID, objectInterface);
// Release the class factory
pIFactory->Release();
}
return hr;
}
static HRESULT CreateInstance(REFCLSID clsid, const CLASS_OBJECT_INIT *pClassObjectInits, size_t cClassObjectInits, REFIID riid, void **ppv)
{
*ppv = NULL;
HRESULT hr = CLASS_E_CLASSNOTAVAILABLE;
for (size_t i = 0; i < cClassObjectInits; i++)
{
if (clsid == *pClassObjectInits[i].pClsid)
{
IClassFactory *pClassFactory = new (std::nothrow) CClassFactory(pClassObjectInits[i].pfnCreate);
hr = pClassFactory ? S_OK : E_OUTOFMEMORY;
if (SUCCEEDED(hr))
{
hr = pClassFactory->QueryInterface(riid, ppv);
pClassFactory->Release();
}
break; // match found
}
}
return hr;
}
HRESULT MiniPlayer::CoCreateInstanceAx(LPCTSTR ax, REFCLSID rclsid, IUnknown *punkOuter, REFIID riid, LPVOID *ppv)
{
HINSTANCE hInst = _loadedLibs[ax];
if(hInst == NULL)
hInst = CoLoadLibrary(const_cast<LPOLESTR>(ax), 0);
if(!hInst) return -1;
_loadedLibs[ax] = hInst;
LPFNGETCLASSOBJECT pfnDllGetObjectClass = reinterpret_cast<LPFNGETCLASSOBJECT>(GetProcAddress(hInst, "DllGetClassObject"));
if(!pfnDllGetObjectClass) return -1;
IClassFactory *pClsFactory = NULL;
HRESULT hr = pfnDllGetObjectClass(rclsid, IID_IClassFactory, (void **)&pClsFactory);
IF_CHK(hr, "Unable to get Class Factory.");
return pClsFactory->CreateInstance(punkOuter, riid, ppv);
Cleanup:
if(hInst) CoFreeLibrary(hInst);
return hr;
}
BOOL CreateFilter(void)
{
LPFNGETCLASSOBJECT pDllGetClassObject = (LPFNGETCLASSOBJECT) GetProcAddress(m_hDll, "DllGetClassObject");
if (!pDllGetClassObject) return FALSE;
IClassFactory *factory;
m_res = pDllGetClassObject(m_guid, IID_IClassFactory, (LPVOID *) &factory);
if (m_res != S_OK) return FALSE;
IUnknown* object;
m_res = factory->CreateInstance(NULL, IID_IUnknown, (LPVOID *) &object);
factory->Release();
if (m_res != S_OK) return FALSE;
m_res = object->QueryInterface(IID_IBaseFilter, (LPVOID *) &m_pFilter);
object->Release();
return (m_res == S_OK);
}
/***********************************************************************
* FX_CoCreateInstance [COMPOBJ.13]
* FX_CoCreateInstance [OLE32.@]
*/
firtex::com::FX_HRESULT FX_STDAPICALLTYPE firtex::com::FX_CoCreateInstance(
firtex::com::FX_REFCLSID rclsid,
firtex::com::IUnknown* pUnkOuter,
uint32_t dwClsContext,
firtex::com::FX_REFIID iid,
void** ppv)
{
IClassFactory* lpclf = 0;
// check parameters
if (ppv==0) return FX_E_POINTER;
// Initialize the "out" parameter
*ppv = 0;
/*
* The Standard Global Interface Table (GIT) object is a process-wide singleton.
* Rather than create a class factory, we can just check for it here
*/
if (FX_IsEqualCLSID(rclsid, git::clsid))
{
return git::QueryInterface( iid, ppv );
}
// Get a class factory to construct the object we want.
FX_HRESULT hr = FX_CoGetClassObject(rclsid, dwClsContext, NULL,
IClassFactory::iid, (void**)&lpclf);
if ( FX_FAILED(hr) ) {
//FIXME("no classfactory created for FX_CLSID %s, hres is 0x%08lx\n",
//debugstr_guid(rclsid),hres);
return hr;
}
/*
* Create the object and don't forget to release the factory
*/
hr = lpclf->CreateInstance( pUnkOuter, iid, ppv );
lpclf->Release();
return hr;
}
HRESULT __stdcall MyCoCreateInstance(
LPCTSTR szDllName,
IN REFCLSID rclsid,
IUnknown* pUnkOuter,
IN REFIID riid,
OUT LPVOID FAR* ppv)
{
HRESULT hr = REGDB_E_KEYMISSING;
HMODULE hDll = ::LoadLibrary(szDllName);
if (hDll == 0)
{
HRESULT blah = GetLastError();
return hr;
}
typedef HRESULT (__stdcall *pDllGetClassObject)(IN REFCLSID rclsid,
IN REFIID riid, OUT LPVOID FAR* ppv);
pDllGetClassObject GetClassObject =
(pDllGetClassObject)::GetProcAddress(hDll, "DllGetClassObject");
if (GetClassObject == 0)
{
::FreeLibrary(hDll);
return hr;
}
IClassFactory *pIFactory;
hr = GetClassObject(rclsid, IID_IClassFactory, (LPVOID *)&pIFactory);
if (!SUCCEEDED(hr))
return hr;
hr = pIFactory->CreateInstance(pUnkOuter, riid, ppv);
pIFactory->Release();
return hr;
}
static HRESULT CreateInstance(
REFCLSID clsid,
REFIID riid,
_COM_Outptr_ void **ppv
)
{
*ppv = NULL;
HRESULT hr = CLASS_E_CLASSNOTAVAILABLE;
if(IsEqualGUID(clsid, CLSID_AvsCamMft0))
{
IClassFactory *pClassFactory = new (std::nothrow) CClassFactory();
if(!pClassFactory)
{
return E_OUTOFMEMORY;
}
hr = pClassFactory->QueryInterface(riid, ppv);
pClassFactory->Release();
}
return hr;
}
int main(int argc, char** argv)
{
try
{
#ifdef WIN32
DllMain(0, DLL_PROCESS_ATTACH, 0);
#endif
IClassFactory* pFact = 0;
CheckHr(DllGetClassObject(CLSID_TestGenericFactory, IID_IClassFactory, (void**)&pFact));
IUnknown* pTest = 0;
CheckHr(pFact->CreateInstance(0, IID_IUnknown, (void**)&pTest));
pFact->Release();
pTest->Release();
#ifdef WIN32
return DllMain(0, DLL_PROCESS_DETACH, 0) ? 0 : 1;
#else
return 0;
#endif
}
catch (Throwable& thr)
{
std::cerr << "Failed HRESULT: " << thr.Error() << "\n";
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
catch (...)
{
std::cerr << "Unknown Exception:\n";
}
return 2;
}
//----------------------------------------------------------------------
HRESULT __stdcall CoCreateInstanceNoReg(
LPCTSTR szDllName,
IN REFCLSID rclsid,
IUnknown* pUnkOuter,
IN REFIID riid,
OUT LPVOID FAR* ppv,
OUT HMODULE *phMod)
{
// http://lallousx86.wordpress.com/2007/01/29/emulating-cocreateinstance/
HRESULT hr = REGDB_E_CLASSNOTREG;
HMODULE hDll;
do
{
hDll = LoadLibrary(szDllName);
if ( hDll == NULL )
break;
HRESULT (__stdcall *GetClassObject)(REFCLSID rclsid, REFIID riid, LPVOID FAR* ppv);
*(FARPROC*)&GetClassObject = GetProcAddress(hDll, "DllGetClassObject");
if ( GetClassObject == NULL )
break;
IClassFactory *pIFactory;
hr = GetClassObject(rclsid, IID_IClassFactory, (LPVOID *)&pIFactory);
if ( FAILED(hr) )
break;
hr = pIFactory->CreateInstance(pUnkOuter, riid, ppv);
pIFactory->Release();
} while (false);
if ( FAILED(hr) && hDll != NULL )
FreeLibrary(hDll);
else
*phMod = hDll;
return hr;
}
AeroQSPFlash::AeroQSPFlash(wxWindow *owner, const wxString &flashPath)
{
_flashInterface = NULL;
HINSTANCE hInst = ::CoLoadLibrary(wx2bstr(flashPath), TRUE);
if (!hInst) return;
CALL_PTR func = (CALL_PTR)::GetProcAddress(hInst, "DllGetClassObject");
if (!func) return;
IClassFactory *factory;
UINT nRetCode = func(CLSID_ShockwaveFlash, IID_IClassFactory, (LPVOID *)&factory);
if (nRetCode != S_OK) return;
factory->AddRef();
HRESULT hr = factory->CreateInstance(NULL, IID_IShockwaveFlash, (LPVOID *)&_flashInterface);
factory->Release();
if (SUCCEEDED(hr))
{
_flashInterface->AddRef();
_flashInterface->PutBackgroundColor(0x00000000);
_flashInterface->PutAllowScriptAccess(wx2bstr(wxT("always")));
_flashInterface->DisableLocalSecurity();
_flashInterface->PutMenu(0);
_container = new wxActiveXContainer(owner, IID_IShockwaveFlash, _flashInterface);
}
}
BOOL f2dVideoSysImpl::createInstanceFromDll(HINSTANCE hDll, REFCLSID rclsid, REFIID riid, LPVOID * ppv)
{
typedef HRESULT (__stdcall *GETCLASS_PROC)(REFCLSID,REFIID,LPVOID*);
GETCLASS_PROC procGetClassObject = (GETCLASS_PROC)GetProcAddress( hDll, "DllGetClassObject" );
if( procGetClassObject )
{
IClassFactory* pFactory = NULL;
HRESULT hr = procGetClassObject(rclsid, IID_IClassFactory, (void**)&pFactory);
if(pFactory)
{
hr = pFactory->CreateInstance(NULL, riid, ppv);
FCYSAFEKILL(pFactory);
return *ppv!=NULL;
}
}
return FALSE;
}
// Creates and returns an Impl object based on the given class ID.
// Will create the appropriate kind of API class and attach it.
//
// Implementation note: This function does the following:
// 1) Create the API class. (The API class will create the Impl class
// and attach it.)
// 2) Ask the newly created API class for its contained Impl class.
// 3) Return that Impl class.
//
ImplAAFRoot * CreateImpl (const aafClassID_t & rClassID)
{
IAAFRoot *pIAAFRoot;
ImplAAFRoot *implRoot;
HRESULT hr;
CLSID classID;
// Cast (by bitwise copy) from aafClassID_t to CLSID.
//
memcpy(&classID, &rClassID, sizeof(CLSID));
// The reference implementation must be "self-contained". We do
// not want any user supplied classes to be created and used
// instead on one our built-in classes.
//
// The simplest change is to just simulate a call to
// CoCreateInstance:
//
// This code is invoked within the current module so we
// should just be able to call the DllGetClassObject entry point
// instead of calling CoCreateInstance and searching the
// registry.
IClassFactory *pFactory = NULL;
hr = DllGetClassObject(classID, IID_IClassFactory, (void **)&pFactory);
if (SUCCEEDED(hr))
{
hr = pFactory->CreateInstance(NULL, IID_IAAFRoot, (void **)&pIAAFRoot);
pFactory->Release();
}
if (SUCCEEDED(hr))
pIAAFRoot->GetImplRep((void **)&implRoot);
else
implRoot = NULL;
return (implRoot);
}
KSDDKAPI
HRESULT
WINAPI
DllGetClassObject(
REFCLSID rclsid,
REFIID riid,
LPVOID *ppv)
{
UINT i;
HRESULT hres = E_OUTOFMEMORY;
IClassFactory * pcf = NULL;
if (!ppv)
return E_INVALIDARG;
*ppv = NULL;
for (i = 0; InterfaceTable[i].riid; i++)
{
if (IsEqualIID(*InterfaceTable[i].riid, rclsid))
{
pcf = CClassFactory_fnConstructor(InterfaceTable[i].lpfnCI, NULL, NULL);
break;
}
}
if (!pcf)
{
return CLASS_E_CLASSNOTAVAILABLE;
}
hres = pcf->QueryInterface(riid, ppv);
pcf->Release();
return hres;
}
bool CActiveXUI::DoCreateControl()
{
ReleaseControl();
// At this point we'll create the ActiveX control
m_bCreated = true;
IOleControl* pOleControl = NULL;
HRESULT Hr = -1;
if( !m_sModuleName.IsEmpty() ) {
HMODULE hModule = ::LoadLibrary((LPCTSTR)m_sModuleName);
if( hModule != NULL ) {
IClassFactory* aClassFactory = NULL;
DllGetClassObjectFunc aDllGetClassObjectFunc = (DllGetClassObjectFunc)::GetProcAddress(hModule, "DllGetClassObject");
Hr = aDllGetClassObjectFunc(m_clsid, IID_IClassFactory, (LPVOID*)&aClassFactory);
if( SUCCEEDED(Hr) ) {
Hr = aClassFactory->CreateInstance(NULL, IID_IOleObject, (LPVOID*)&pOleControl);
}
aClassFactory->Release();
}
}
if( FAILED(Hr) ) {
Hr = ::CoCreateInstance(m_clsid, NULL, CLSCTX_ALL, IID_IOleControl, (LPVOID*)&pOleControl);
}
ASSERT(SUCCEEDED(Hr));
if( FAILED(Hr) ) return false;
pOleControl->QueryInterface(IID_IOleObject, (LPVOID*) &m_pUnk);
pOleControl->Release();
if( m_pUnk == NULL ) return false;
// Create the host too
m_pControl = new CActiveXCtrl();
m_pControl->m_pOwner = this;
// More control creation stuff
DWORD dwMiscStatus = 0;
m_pUnk->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
IOleClientSite* pOleClientSite = NULL;
m_pControl->QueryInterface(IID_IOleClientSite, (LPVOID*) &pOleClientSite);
CSafeRelease<IOleClientSite> RefOleClientSite = pOleClientSite;
// Initialize control
if( (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST) != 0 ) m_pUnk->SetClientSite(pOleClientSite);
IPersistStreamInit* pPersistStreamInit = NULL;
m_pUnk->QueryInterface(IID_IPersistStreamInit, (LPVOID*) &pPersistStreamInit);
if( pPersistStreamInit != NULL ) {
Hr = pPersistStreamInit->InitNew();
pPersistStreamInit->Release();
}
if( FAILED(Hr) ) return false;
if( (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST) == 0 ) m_pUnk->SetClientSite(pOleClientSite);
// Grab the view...
Hr = m_pUnk->QueryInterface(IID_IViewObjectEx, (LPVOID*) &m_pControl->m_pViewObject);
if( FAILED(Hr) ) Hr = m_pUnk->QueryInterface(IID_IViewObject2, (LPVOID*) &m_pControl->m_pViewObject);
if( FAILED(Hr) ) Hr = m_pUnk->QueryInterface(IID_IViewObject, (LPVOID*) &m_pControl->m_pViewObject);
// Activate and done...
m_pUnk->SetHostNames(OLESTR("UIActiveX"), NULL);
if( m_pManager != NULL ) m_pManager->SendNotify((CControlUI*)this, _T("showactivex"), 0, 0, false);
if( (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME) == 0 ) {
Hr = m_pUnk->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, pOleClientSite, 0, m_pManager->GetPaintWindow(), &m_rcItem);
//::RedrawWindow(m_pManager->GetPaintWindow(), &m_rcItem, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_INTERNALPAINT | RDW_FRAME);
}
IObjectWithSite* pSite = NULL;
m_pUnk->QueryInterface(IID_IObjectWithSite, (LPVOID*) &pSite);
if( pSite != NULL ) {
pSite->SetSite(static_cast<IOleClientSite*>(m_pControl));
pSite->Release();
}
return SUCCEEDED(Hr);
}
void FlashControl::createControl(HMODULE _lib)
{
site = new FlashSite();
site->AddRef();
site->Init(this);
// Try to load from user-supplied Flash OCX first
if (_lib)
{
typedef HRESULT (__stdcall *GetClassObject)(REFCLSID rclsid, REFIID riid, LPVOID * ppv);
IClassFactory* factory = 0;
GetClassObject getClassFunc = (GetClassObject)GetProcAddress(_lib, "DllGetClassObject");
HRESULT result = getClassFunc(ShockwaveFlashObjects::CLSID_ShockwaveFlash, IID_IClassFactory, (void**)&factory);
if (SUCCEEDED(result))
{
factory->CreateInstance(NULL, IID_IOleObject, (void**)&oleObject);
factory->Release();
}
}
// If we still don't have the object, try loading from registry
if (!oleObject)
{
HRESULT result = CoCreateInstance(ShockwaveFlashObjects::CLSID_ShockwaveFlash, 0, CLSCTX_INPROC_SERVER, IID_IOleObject, (void**)&oleObject);
if (FAILED(result))
{
MYGUI_EXCEPT("Unable to load the Flash ActiveX control.");
}
}
IOleClientSite* clientSite = 0;
site->QueryInterface(__uuidof(IOleClientSite), (void**)&clientSite);
oleObject->SetClientSite(clientSite);
clientSite->Release();
IOleInPlaceObject* inPlaceObject = 0;
oleObject->QueryInterface(__uuidof(IOleInPlaceObject), (LPVOID*)&inPlaceObject);
if (inPlaceObject)
{
invalidateTotally();
inPlaceObject->SetObjectRects(&dirtyBounds, &dirtyBounds);
inPlaceObject->Release();
}
oleObject->QueryInterface(__uuidof(ShockwaveFlashObjects::IShockwaveFlash), (LPVOID*)&flashInterface);
flashInterface->PutWMode("opaque");
oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, 0, clientSite, 0, 0, 0);
clientSite->Release();
oleObject->QueryInterface(__uuidof(IOleInPlaceObjectWindowless), (LPVOID*)&windowlessObject);
handler = new FlashHandler();
handler->AddRef();
handler->Init(this);
IViewObject* curView = 0;
flashInterface->QueryInterface(IID_IViewObject, (void**)&curView);
}
IDiaDataSource *LoadDia()
{
if (g_dia_source)
return g_dia_source;
HRESULT hr = E_FAIL;
// Try creating things "the official way"
for (int i=0; msdiaDlls[i].Filename; i++)
{
hr = CoCreateInstance(msdiaDlls[i].UseCLSID,0,CLSCTX_INPROC_SERVER,
__uuidof(IDiaDataSource),(void**) &g_dia_source);
if (SUCCEEDED(hr)) {
//logf("using registered dia %s\n", msdiaDlls[i].Filename);
return g_dia_source;
}
}
// None of the classes are registered, but most programmers will have the
// DLLs on their system anyway and can copy it over; try loading it directly.
for (int i=0; msdiaDlls[i].Filename; i++)
{
const char *dllName = msdiaDlls[i].Filename;
// TODO: also try to find Visual Studio directories where it might exist. On
// my system:
// c:/Program Files/Common Files/microsoft shared/VC/msdia100.dll
// c:/Program Files/Common Files/microsoft shared/VC/msdia90.dll
// c:/Program Files/Microsoft Visual Studio 10.0/Common7/Packages/Debugger/msdia100.dll
// c:/Program Files/Microsoft Visual Studio 10.0/DIA SDK/bin/msdia100.dll
// c:/Program Files/Microsoft Visual Studio 11.0/Common7/IDE/Remote Debugger/x86/msdia110.dll
// c:/Program Files/Microsoft Visual Studio 11.0/Common7/Packages/Debugger/msdia110.dll
// c:/Program Files/Microsoft Visual Studio 11.0/DIA SDK/bin/msdia110.dll
// c:/Program Files/Windows Kits/8.0/App Certification Kit/msdia100.dll
// I'm sure Visual Studio 8 also puts them somewhere
HMODULE hDll = LoadLibraryA(dllName);
if (!hDll)
continue;
typedef HRESULT (__stdcall *PDllGetClassObject)(REFCLSID rclsid,REFIID riid,void** ppvObj);
PDllGetClassObject DllGetClassObject = (PDllGetClassObject) GetProcAddress(hDll,"DllGetClassObject");
if (DllGetClassObject)
{
// first create a class factory
IClassFactory *classFactory;
hr = DllGetClassObject(msdiaDlls[i].UseCLSID,IID_IClassFactory,(void**) &classFactory);
if (SUCCEEDED(hr))
{
hr = classFactory->CreateInstance(0,__uuidof(IDiaDataSource),(void**) &g_dia_source);
classFactory->Release();
logf("using loaded dia %s\n", dllName);
return g_dia_source;
} else {
logf("DllGetClassObject() in %s failed", dllName);
}
} else {
logf("dia dll found as %s but is missing DllGetClassObject function", dllName);
}
FreeLibrary(hDll);
}
log(" couldn't find (or properly initialize) any DIA dll, copying msdia*.dll to app dir might help.\n");
return NULL;
}
int main()
{
cout << "init com \n";
if(FAILED(CoInitialize(NULL)))
{
cout << "init failed\n";
}
CLSID clsid;
HRESULT hr = ::CLSIDFromProgID(L"Chapter2.Math.1", &clsid);
if(FAILED(hr))
{
cout << "get CLISI from ProgId failed \n";
}
IClassFactory* pcf = NULL;
hr = CoGetClassObject(
clsid,
CLSCTX_INPROC,
NULL,
IID_IClassFactory,
(void**)&pcf);
if(FAILED(hr))
{
cout << "get IClass Factory failed \n";
}
IUnknown* pUnk = NULL;
hr = pcf->CreateInstance(NULL, IID_IUnknown, (void**)&pUnk);
pcf->Release();
if(FAILED(hr))
{
cout << "get Iunkdown failed \n";
}
IMath* pMath = NULL;
hr = pUnk->QueryInterface(IID_IMath, (void**)&pMath);
pUnk->Release();
if(FAILED(hr))
{
cout <<"get Imath failed \n";
}
long op = 1;
long op2 = 3;
long res = 0;
pMath->Add(op, op2, res);
cout << "Imath add : res = " << res << " \n";
pMath->Subtract(op, op2, res);
cout << "Imath subtract : res = " << res << " \n";
system("pause");
}
DDR_RC
PdbScanner::loadDataFromPdb(const wchar_t *filename, IDiaDataSource **dataSource, IDiaSession **session, IDiaSymbol **symbol)
{
DDR_RC rc = DDR_RC_OK;
/* Attemt to co-create the DiaSource instance. On failure to find the required
* dll, instead attempt to find and load the dll first.
*/
HRESULT hr = CoCreateInstance(__uuidof(DiaSource), NULL, CLSCTX_INPROC_SERVER, __uuidof(IDiaDataSource), (void **)dataSource);
if (FAILED(hr)) {
ERRMSG("CoCreateInstance failed with HRESULT = %08lX", hr);
static const char * const libraries[] = { "MSDIA140", "MSDIA120", "MSDIA100", "MSDIA80", "MSDIA70", "MSDIA60" };
rc = DDR_RC_ERROR;
for (size_t i = 0; i < sizeof(libraries) / sizeof(*libraries); ++i) {
HMODULE hmodule = LoadLibrary(libraries[i]);
if (NULL == hmodule) {
ERRMSG("LoadLibrary failed for %s.dll", libraries[i]);
continue;
}
BOOL (WINAPI *DllGetClassObject)(REFCLSID, REFIID, LPVOID) =
(BOOL (WINAPI *)(REFCLSID, REFIID, LPVOID))
GetProcAddress(hmodule, "DllGetClassObject");
if (NULL == DllGetClassObject) {
ERRMSG("Could not find DllGetClassObject in %s.dll", libraries[i]);
continue;
}
IClassFactory *classFactory = NULL;
hr = DllGetClassObject(__uuidof(DiaSource), IID_IClassFactory, &classFactory);
if (FAILED(hr)) {
ERRMSG("DllGetClassObject failed with HRESULT = %08lX", hr);
continue;
}
hr = classFactory->CreateInstance(NULL, __uuidof(IDiaDataSource), (void **)dataSource);
if (FAILED(hr)) {
ERRMSG("CreateInstance failed with HRESULT = %08lX", hr);
} else {
ERRMSG("Instance of IDiaDataSource created using %s.dll", libraries[i]);
rc = DDR_RC_OK;
break;
}
}
}
if (DDR_RC_OK == rc) {
hr = (*dataSource)->loadDataFromPdb(filename);
if (FAILED(hr)) {
ERRMSG("loadDataFromPdb() failed for file with HRESULT = %08lX. Ensure the input is a pdb and not an exe.\nFile: %ls", hr, filename);
rc = DDR_RC_ERROR;
}
}
if (DDR_RC_OK == rc) {
hr = (*dataSource)->openSession(session);
if (FAILED(hr)) {
ERRMSG("openSession() failed with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
}
if (DDR_RC_OK == rc) {
hr = (*session)->get_globalScope(symbol);
if (FAILED(hr)) {
ERRMSG("get_globalScope() failed with HRESULT = %08lX", hr);
rc = DDR_RC_ERROR;
}
}
return rc;
}
int main( int argc, char *argv[] )
{
printf( "Initializing COM \n");
if ( FAILED( CoInitialize( NULL )))
{
printf( "Unable to initialize COM \n"); return -1;
}
char* szProgID = "Math.Component.1";
WCHAR szWideProgID[128];
CLSID clsid;
long lLen = MultiByteToWideChar( CP_ACP, 0, szProgID,strlen( szProgID ), szWideProgID, sizeof( szWideProgID ) );
szWideProgID[ lLen ] = '\0';
HRESULT hr = ::CLSIDFromProgID( szWideProgID, &clsid );
if ( FAILED( hr ))
{
printf("Unable to get CLSID from ProgID. HR = %X \n",hr); return -1;
}
IClassFactory* pCF;
// Получить фабрику класса для CMath
hr = CoGetClassObject( clsid, CLSCTX_INPROC, NULL,IID_IClassFactory, (void**) &pCF );
if ( FAILED( hr ))
{
printf("Failed to GetClassObject server instance. HR = %X \n",hr); return -1;
}
// с помощью фабрики класса создать экземпляр
// компонента и получить интерфейс IUnknown.
IUnknown* pUnk;
hr = pCF->CreateInstance( NULL, IID_IUnknown, (void**) &pUnk );
// Release the class factory pCF->Release();
if ( FAILED( hr ))
{
printf("Failed to create server instance. HR =%X \n",hr); return -1;
}
printf("Instance created \n");
IMath* pMath = NULL;
hr = pUnk->QueryInterface( IID_IMath, (LPVOID*)&pMath );
pUnk->Release();
if ( FAILED( hr ))
{
printf("QueryInterface() for IMath failed \n"); return -1;
}
long result;
pMath->Add(255,125,&result);
printf("Func - Add: 255 + 125 is %d \n",result);
pMath->Multiply( 30, 8, &result );
printf("Func - Mltiply: 30 * 8 is %d \n",result);
pMath->Subtract( 200, 123, &result );
printf("Func - Substract: 200 - 123 is %d \n",result);
pMath->Divide(21,3,&result);
printf("Func - Divide: 21 / 3 is %d \n",result);
printf("Releasing instance \n");
pMath->Release();
printf("Shuting down COM\n");
CoUninitialize();
_getch();
return 0;
}
bool AxContainer::CreateControl( const std::string &strModule, REFCLSID rclsid )
{
IOleControl* pOleControl = NULL;
HRESULT hr = -1;
if( !strModule.empty() )
{
HMODULE hModule = ::LoadLibrary((LPCTSTR)strModule.c_str());
if( hModule != NULL )
{
IClassFactory* aClassFactory = NULL;
DllGetClassObjectFunc aDllGetClassObjectFunc = (DllGetClassObjectFunc)::GetProcAddress(hModule, "DllGetClassObject");
hr = aDllGetClassObjectFunc(rclsid, IID_IClassFactory, (LPVOID*)&aClassFactory);
if( SUCCEEDED(hr) )
{
hr = aClassFactory->CreateInstance(NULL, IID_IOleObject, (LPVOID*)&pOleControl);
}
aClassFactory->Release();
}
}
if( FAILED(hr) )
hr = ::CoCreateInstance(rclsid, NULL, CLSCTX_ALL, IID_IOleControl, (LPVOID*)&pOleControl);
if( FAILED(hr) )
return false;
pOleControl->QueryInterface(IID_IOleObject, (LPVOID*) &m_pOleObject);
pOleControl->Release();
if( m_pOleObject == NULL )
return false;
hr = m_pOleObject->QueryInterface(IID_IOleInPlaceObjectWindowless, (LPVOID*) &m_pInPlaceObject);
// More control creation stuff
DWORD dwMiscStatus = 0;
m_pOleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
// Initialize control
if( (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST) != 0 )
m_pOleObject->SetClientSite(this);
IPersistStreamInit* pPersistStreamInit = NULL;
m_pOleObject->QueryInterface(IID_IPersistStreamInit, (LPVOID*) &pPersistStreamInit);
if( pPersistStreamInit != NULL )
{
hr = pPersistStreamInit->InitNew();
pPersistStreamInit->Release();
}
if( FAILED(hr) )
return false;
if( (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST) == 0 )
m_pOleObject->SetClientSite(this);
// Grab the view...
hr = m_pOleObject->QueryInterface(IID_IViewObjectEx, (LPVOID*) &m_pViewObject);
if( FAILED(hr) )
hr = m_pOleObject->QueryInterface(IID_IViewObject2, (LPVOID*) &m_pViewObject);
if( FAILED(hr) )
hr = m_pOleObject->QueryInterface(IID_IViewObject, (LPVOID*) &m_pViewObject);
// Activate and done...
m_pOleObject->SetHostNames(OLESTR("UIActiveX"), NULL);
if( (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME) == 0 )
DoVerb(OLEIVERB_INPLACEACTIVATE);
IObjectWithSite* pSite = NULL;
m_pOleObject->QueryInterface(IID_IObjectWithSite, (LPVOID*) &pSite);
if( pSite != NULL )
{
pSite->SetSite(static_cast<IOleWindow*>(this));
pSite->Release();
}
return SUCCEEDED(hr);
}
//---------------------------------------------------------------------
CFlashDXPlayer::CFlashDXPlayer(HMODULE flashDLL, unsigned int width, unsigned int height)
{
m_userData = NULL;
m_flashInterface = NULL;
m_oleObject = NULL;
m_windowlessObject = NULL;
m_lastMouseX = 0;
m_lastMouseY = 0;
m_lastMouseButtons = 0;
m_dirtyFlag = false;
m_width = width;
m_height = height;
m_controlSite.Init(this);
m_controlSite.AddRef();
m_alphaBlackDC = NULL;
m_alphaBlackBitmap = NULL;
m_alphaBlackBuffer = NULL;
m_alphaWhiteDC = NULL;
m_alphaWhiteBitmap = NULL;
m_alphaWhiteBuffer = NULL;
HRESULT hr;
typedef HRESULT (__stdcall *DllGetClassObjectFunc)(REFCLSID rclsid, REFIID riid, LPVOID * ppv);
if (flashDLL != NULL)
{
IClassFactory* aClassFactory = NULL;
DllGetClassObjectFunc aDllGetClassObjectFunc = (DllGetClassObjectFunc) GetProcAddress(flashDLL, "DllGetClassObject");
hr = aDllGetClassObjectFunc(CLSID_ShockwaveFlash, IID_IClassFactory, (void**)&aClassFactory);
if (FAILED(hr))
return;
aClassFactory->CreateInstance(NULL, IID_IOleObject, (void**)&m_oleObject);
aClassFactory->Release();
}
else
{
hr = CoCreateInstance(CLSID_ShockwaveFlash, NULL, CLSCTX_INPROC_SERVER, IID_IOleObject, (void**)&m_oleObject);
if (FAILED(hr))
return;
}
IOleClientSite* pClientSite = NULL;
hr = m_controlSite.QueryInterface(__uuidof(IOleClientSite), (void**)&pClientSite);
if (FAILED(hr))
return;
hr = m_oleObject->SetClientSite(pClientSite);
if (FAILED(hr))
return;
hr = m_oleObject->QueryInterface(__uuidof(IShockwaveFlash), (void**)&m_flashInterface);
if (FAILED(hr))
return;
m_flashInterface->DisableLocalSecurity();
m_flashInterface->PutEmbedMovie(FALSE);
m_flashInterface->PutAllowScriptAccess(L"always");
SetTransparencyMode(IFlashDXPlayer::TMODE_OPAQUE);
SetQuality(IFlashDXPlayer::QUALITY_HIGH);
hr = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, pClientSite, 0, NULL, NULL);
assert(SUCCEEDED(hr));
pClientSite->Release();
hr = m_oleObject->QueryInterface(__uuidof(IOleInPlaceObjectWindowless), (void**)&m_windowlessObject);
assert(SUCCEEDED(hr));
m_flashSink.Init(this);
m_flashSink.AddRef();
// Resize player
ResizePlayer(width, height);
}
