GetHtmlElementAttributeResult GetHtmlElementAttribute(IHTMLElement& htmlElement, const ATL::CComBSTR& attributeName) { GetHtmlElementAttributeResult retValue; ATL::CComVariant vAttr; ATL::CComPtr<IHTMLElement4> htmlElement4; if (FAILED(htmlElement.QueryInterface(&htmlElement4)) || !htmlElement4) { return retValue; } ATL::CComPtr<IHTMLDOMAttribute> attributeNode; if (FAILED(htmlElement4->getAttributeNode(attributeName, &attributeNode)) || !attributeNode) { return retValue; } // we set that attribute found but it's not necessary that we can retrieve its value retValue.isAttributeFound = true; if (FAILED(attributeNode->get_nodeValue(&vAttr))) { return retValue; } if (vAttr.vt == VT_BSTR && vAttr.bstrVal) { retValue.attributeValue = vAttr.bstrVal; } else if (vAttr.vt == VT_I4) { retValue.attributeValue = std::to_wstring(vAttr.iVal); } return retValue; }
// This is the heuristic which detects the requests issued by Flash.ocx. // It turned out that the implementation from ''Flash.ocx'' (tested version is 15.0.0.152) // returns quite minimal configuration in comparison with the implementation from Microsofts' // libraries (see grfBINDF and bindInfo.dwOptions). The impl from MS often includes something // else. bool WBPassthruSink::IsFlashRequest(const wchar_t* const* additionalHeaders) { if (additionalHeaders && *additionalHeaders) { auto flashVersionHeader = ExtractHttpHeader<std::wstring>(*additionalHeaders, L"x-flash-version:", L"\n"); if (!TrimString(flashVersionHeader).empty()) { return true; } } ATL::CComPtr<IBindStatusCallback> bscb; if (SUCCEEDED(QueryServiceFromClient(&bscb)) && !!bscb) { DWORD grfBINDF = 0; BINDINFO bindInfo = {}; bindInfo.cbSize = sizeof(bindInfo); if (SUCCEEDED(bscb->GetBindInfo(&grfBINDF, &bindInfo)) && (BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE| BINDF_PULLDATA) == grfBINDF && (BINDINFO_OPTIONS_ENABLE_UTF8 | BINDINFO_OPTIONS_USE_IE_ENCODING) == bindInfo.dwOptions ) { return true; } } return false; }
HRESULT InjectedType::ReplaceMethodWith(const ModuleID moduleId, const mdToken functionToken, InstructionList &instructions, const mdSignature localVarSigTok, const unsigned minimumStackSize, ExceptionHandlerList &exceptions) const { IMAGE_COR_ILMETHOD* pMethodHeader = nullptr; ULONG iMethodSize = 0; GUARD_FAILURE_HRESULT(m_profilerInfo->GetILFunctionBody(moduleId, functionToken, (LPCBYTE*)&pMethodHeader, &iMethodSize)); Method method(pMethodHeader); method.DeleteAllInstructions(); method.AppendInstructions(instructions); method.SetMinimumStackSize(minimumStackSize); if (exceptions.size() > 0) { method.AddExceptionHandlers(exceptions); } ATL::CComPtr<IMethodMalloc> methodMalloc; GUARD_FAILURE_HRESULT(m_profilerInfo->GetILFunctionBodyAllocator(moduleId, &methodMalloc)); IMAGE_COR_ILMETHOD* pNewMethod = static_cast<IMAGE_COR_ILMETHOD*>(methodMalloc->Alloc(method.GetMethodSize())); method.WriteMethod(pNewMethod); if (localVarSigTok != mdSignatureNil) { pNewMethod->Fat.Flags |= CorILMethod_InitLocals; // always added when local variables present: http://www.liranchen.com/2010/07/behind-locals-init-flag.html pNewMethod->Fat.LocalVarSigTok = localVarSigTok; } GUARD_FAILURE_HRESULT(m_profilerInfo->SetILFunctionBody(moduleId, functionToken, (LPCBYTE)pNewMethod)); return S_OK; }
HRESULT InjectedType::DefineAssemblyMaxVersionRef(const ModuleID moduleId, LPCWSTR assemblyName, mdModuleRef* moduleRef) const { ATL::CComPtr<IMetaDataAssemblyEmit> metaDataAssemblyEmit; GUARD_FAILURE_HRESULT(GetMetaDataAssemblyEmit(moduleId, metaDataAssemblyEmit)); AssemblyReference mscorlibReference; if (!m_assemblyRegistry->FindMaxAssemblyVersion(assemblyName, mscorlibReference)) { return E_FAIL; } ASSEMBLYMETADATA mscorlibMetadata; ZeroMemory(&mscorlibMetadata, sizeof(mscorlibMetadata)); mscorlibMetadata.usMajorVersion = mscorlibReference.version.majorVersion; mscorlibMetadata.usMinorVersion = mscorlibReference.version.minorVersion; mscorlibMetadata.usBuildNumber = mscorlibReference.version.buildNumber; mscorlibMetadata.usRevisionNumber = mscorlibReference.version.revisionNumber; const auto name = mscorlibReference.name.c_str(); return metaDataAssemblyEmit->DefineAssemblyRef(mscorlibReference.publicKeyToken, sizeof(mscorlibReference.publicKeyToken), name, &mscorlibMetadata, nullptr, 0, 0, moduleRef); }
HRESULT CSysProgressDlg::ShowModeless(HWND hWndParent, BOOL immediately) { EnsureValid(); m_hWndProgDlg = NULL; if (!IsValid()) return E_FAIL; m_hWndParent = hWndParent; HRESULT hr = m_pIDlg->StartProgressDialog(hWndParent, NULL, m_dwDlgFlags, NULL); if(FAILED(hr)) return hr; ATL::CComPtr<IOleWindow> pOleWindow; HRESULT hr2 = m_pIDlg.QueryInterface(&pOleWindow); if(SUCCEEDED(hr2)) { hr2 = pOleWindow->GetWindow(&m_hWndProgDlg); if(SUCCEEDED(hr2)) { // see comment in ShowModal() for why we subclass the window if (!m_isVisible) { m_OrigProc = (WNDPROC) SetWindowLongPtr(m_hWndProgDlg, GWLP_WNDPROC, (LONG_PTR) fnSubclass); SetProp(m_hWndProgDlg, L"ParentWindow", m_hWndParent); SetProp(m_hWndProgDlg, L"OrigProc", m_OrigProc); } if (immediately) ShowWindow(m_hWndProgDlg, SW_SHOW); } } m_isVisible = true; return hr; }
HRESULT CSysProgressDlg::ShowModeless(HWND hWndParent, BOOL immediately) { EnsureValid(); m_hWndProgDlg = nullptr; if (!IsValid()) return E_FAIL; m_hWndParent = hWndParent; auto winId = GetWindowThreadProcessId(m_hWndParent, 0); auto threadId = GetCurrentThreadId(); if (winId != threadId) AttachThreadInput(winId, threadId, TRUE); m_hWndFocus = GetFocus(); if (winId != threadId) AttachThreadInput(winId, threadId, FALSE); HRESULT hr = m_pIDlg->StartProgressDialog(hWndParent, nullptr, m_dwDlgFlags, nullptr); if(FAILED(hr)) return hr; ATL::CComPtr<IOleWindow> pOleWindow; HRESULT hr2 = m_pIDlg.QueryInterface(&pOleWindow); if(SUCCEEDED(hr2)) { hr2 = pOleWindow->GetWindow(&m_hWndProgDlg); if(SUCCEEDED(hr2)) { if (immediately) ShowWindow(m_hWndProgDlg, SW_SHOW); } } m_isVisible = true; return hr; }
void DeleteJumpList(LPCTSTR appID) { ATL::CComPtr<ICustomDestinationList> pcdl; HRESULT hr = pcdl.CoCreateInstance(CLSID_DestinationList, nullptr, CLSCTX_INPROC_SERVER); if (SUCCEEDED(hr)) { pcdl->DeleteList(appID); } }
//------------------------------------------------------------------------------------------------- ALVR_RESULT WaitForCompletion(bool bLeft) { ALVR_RESULT res = g_pLvrDevice->SubmitFence(bLeft ? 0 : 1, g_pFenceD3D11); CHECK_ALVR_ERROR_RETURN(res, L"SubmitFence() failed"); res = g_pFenceD3D11->Wait(2000); CHECK_ALVR_ERROR_RETURN(res, L"g_pFenceD3D11->Wait() failed"); return ALVR_OK; }
void ListViewAccServer::ClearProvider( HWND hControl ) { ATL::CComPtr<IAccPropServices> pAccPropSvc; HRESULT hr = pAccPropSvc.CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER); if (hr == S_OK && pAccPropSvc) { MSAAPROPID propid = PROPID_ACC_HELP; pAccPropSvc->ClearHwndProps(hControl, (DWORD)OBJID_CLIENT, CHILDID_SELF, &propid, 1); } }
HRESULT InjectedType::GetRVAFromKnownDefaultCtor(ATL::CComPtr<IMetaDataImport>& metaDataImport, const LPCWSTR knownTypeDefName, mdTypeDef* pKnownTypeDef, mdMethodDef* pKnownTypeDefaultCtorDef, ULONG* pCodeRVA) { GUARD_FAILURE_HRESULT(metaDataImport->FindTypeDefByName(knownTypeDefName, mdTokenNil, pKnownTypeDef)); GUARD_FAILURE_HRESULT(metaDataImport->FindMethod(*pKnownTypeDef, L".ctor", ctorSignature, sizeof(ctorSignature), pKnownTypeDefaultCtorDef)); GUARD_FAILURE_HRESULT(metaDataImport->GetMethodProps(*pKnownTypeDefaultCtorDef, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, pCodeRVA, nullptr)); return S_OK; }
bool CCommonAppUtils::SetAccProperty(HWND hWnd, MSAAPROPID propid, const CString& text) { ATL::CComPtr<IAccPropServices> pAccPropSvc; HRESULT hr = pAccPropSvc.CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER); if (hr == S_OK && pAccPropSvc) { pAccPropSvc->SetHwndPropStr(hWnd, (DWORD)OBJID_CLIENT, CHILDID_SELF, propid, text); return true; } return false; }
bool InjectedType::HasTypeDef(const ModuleID moduleId, const LPCWSTR typeDefName) const { ATL::CComPtr<IMetaDataImport> metaDataImport; auto result = GetMetaDataImport(moduleId, metaDataImport); if (result != S_OK) { return false; } mdTypeDef systemObject = mdTokenNil; result = metaDataImport->FindTypeDefByName(typeDefName, mdTokenNil, &systemObject); return result == S_OK; }
bool CCommonAppUtils::SetAccProperty(HWND hWnd, MSAAPROPID propid, long value) { ATL::CComPtr<IAccPropServices> pAccPropSvc; HRESULT hr = pAccPropSvc.CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER); if (hr == S_OK && pAccPropSvc) { VARIANT var; var.vt = VT_I4; var.intVal = value; pAccPropSvc->SetHwndProp(hWnd, (DWORD)OBJID_CLIENT, CHILDID_SELF, propid, var); return true; } return false; }
HRESULT CSysProgressDlg::ShowModal(HWND hWndParent, BOOL immediately /* = true */) { EnsureValid(); m_hWndProgDlg = NULL; if (!IsValid()) return E_FAIL; m_hWndParent = hWndParent; HRESULT hr = m_pIDlg->StartProgressDialog(hWndParent, NULL, m_dwDlgFlags | PROGDLG_MODAL, NULL); if(FAILED(hr)) return hr; ATL::CComPtr<IOleWindow> pOleWindow; HRESULT hr2 = m_pIDlg.QueryInterface(&pOleWindow); if(SUCCEEDED(hr2)) { hr2 = pOleWindow->GetWindow(&m_hWndProgDlg); if(SUCCEEDED(hr2)) { // StartProgressDialog creates a new thread to host the progress window. // When the window receives WM_DESTROY message StopProgressDialog() wrongly // attempts to re-enable the parent in the calling thread (our thread), // after the progress window is destroyed and the progress thread has died. // When the progress window dies, the system tries to assign a new foreground window. // It cannot assign to hwndParent because StartProgressDialog (w/PROGDLG_MODAL) disabled the parent window. // So the system hands the foreground activation to the next process that wants it in the // system foreground queue. Thus we lose our right to recapture the foreground window. // The way to fix this bug is to insert a call to EnableWindow(hWndParent) in the WM_DESTROY // handler for the progress window in the progress thread. // To do that, we Subclass the progress dialog // Since the window and thread created by the progress dialog object live on a few // milliseconds after calling Stop() and Release(), we must not store anything // in member variables of this class but must only store everything in the window // itself: thus we use SetProp()/GetProp() to store the data. if (!m_isVisible) { m_OrigProc = (WNDPROC) SetWindowLongPtr(m_hWndProgDlg, GWLP_WNDPROC, (LONG_PTR) fnSubclass); SetProp(m_hWndProgDlg, L"ParentWindow", m_hWndParent); SetProp(m_hWndProgDlg, L"OrigProc", m_OrigProc); } if(immediately) ShowWindow(m_hWndProgDlg, SW_SHOW); } } m_isVisible = true; return hr; }
bool IsItemInArray(IShellItem *psi, IObjectArray *poaRemoved) { UINT cItems; if (FAILED(poaRemoved->GetCount(&cItems))) return false; bool fRet = false; for (UINT i = 0; !fRet && i < cItems; i++) { ATL::CComPtr<IShellItem> psiCompare; if (FAILED(poaRemoved->GetAt(i, IID_PPV_ARGS(&psiCompare)))) continue; int iOrder; fRet = SUCCEEDED(psiCompare->Compare(psi, SICHINT_CANONICAL, &iOrder)) && (0 == iOrder); } return fRet; }
HRESULT CreateShellLink(PCWSTR pszArguments, PCWSTR pszTitle, int iconIndex, IShellLink **ppsl) { ATL::CComPtr<IShellLink> psl; HRESULT hr = psl.CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER); if (FAILED(hr)) return hr; WCHAR szAppPath[MAX_PATH]; if (GetModuleFileName(NULL, szAppPath, _countof(szAppPath)) == 0) { hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } hr = psl->SetPath(szAppPath); if (FAILED(hr)) return hr; hr = psl->SetArguments(pszArguments); if (FAILED(hr)) return hr; hr = psl->SetIconLocation(szAppPath, iconIndex); if (FAILED(hr)) return hr; ATL::CComPtr<IPropertyStore> pps; hr = psl.QueryInterface(&pps); if (FAILED(hr)) return hr; PROPVARIANT propvar; hr = InitPropVariantFromString(pszTitle, &propvar); if (SUCCEEDED(hr)) { hr = pps->SetValue(PKEY_Title, propvar); if (SUCCEEDED(hr)) { hr = pps->Commit(); if (SUCCEEDED(hr)) { hr = psl.QueryInterface(ppsl); } } PropVariantClear(&propvar); } return hr; }
// // IClassFactory implementation // HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter, const IID& iid, void** ppv) { if (!ppv) return E_POINTER; // Cannot aggregate. if (pUnknownOuter) return CLASS_E_NOAGGREGATION ; // Create component. ATL::CComPtr<GitWCRev> pA; pA.Attach(new (std::nothrow) GitWCRev()); // refcount set to 1 in constructor if (!pA) return E_OUTOFMEMORY ; return pA->QueryInterface(iid, ppv); }
ProgressTaskBar(__RPC__in HWND hwnd, ULONGLONG Total) : hwnd(hwnd) , Total(Total) { if (FAILED(CoInitialize(nullptr))) ATL::AtlThrowLastWin32(); if (FAILED(TaskbarList.CoCreateInstance(CLSID_TaskbarList))) ATL::AtlThrowLastWin32(); }
//------------------------------------------------------------------------------------------------- ALVR_RESULT D3DHelperLateLatch::CreateConstantBuffer() { ALVR_RESULT res = ALVR_OK; Locker lock(&m_Sect); m_pLateLatchBufferLeft.Release(); m_pLateLatchBufferRight.Release(); res = g_pLvrDevice->CreateLateLatchConstantBufferD3D11(sizeof(ConstantBuffer), 1024, 0, &m_pLateLatchBufferLeft); CHECK_ALVR_ERROR_RETURN(res, L"CreateLateLatchConstantBufferD3D11() failed"); res = g_pLvrDevice->CreateLateLatchConstantBufferD3D11(sizeof(ConstantBuffer), 1024, 0, &m_pLateLatchBufferRight); CHECK_ALVR_ERROR_RETURN(res, L"CreateLateLatchConstantBufferD3D11() failed"); return ALVR_OK; }
ListViewAccServer * ListViewAccServer::CreateProvider(HWND hControl, ListViewAccProvider * provider) { ATL::CComPtr<IAccPropServices> pAccPropSvc; HRESULT hr = pAccPropSvc.CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER); if (hr == S_OK && pAccPropSvc) { ListViewAccServer * pLVServer = new (std::nothrow) ListViewAccServer(pAccPropSvc); if (pLVServer) { pLVServer->m_pAccProvider = provider; MSAAPROPID propid = PROPID_ACC_HELP; pAccPropSvc->SetHwndPropServer(hControl, (DWORD)OBJID_CLIENT, CHILDID_SELF, &propid, 1, pLVServer, ANNO_CONTAINER); pLVServer->Release(); } return pLVServer; } return NULL; }
void remote_host::get_clsid( const CATID& cat_id, LPCOLESTR server_name, CLSID& server_id ) { DWPRINT( L"get_clsid( %s )\n", server_name ); CATID Implist[1] = { cat_id }; ATL::CComPtr<IEnumCLSID> iEnum; HRESULT result = root_->EnumClassesOfCategories( 1, Implist, 0, NULL, &iEnum ); if (FAILED(result)) { throw opc_exception( result, OLESTR("Failed to get enum for categeories") ); } GUID glist; ULONG actual; while((result = iEnum->Next( 1, &glist, &actual )) == S_OK) { cotask_holder<OLECHAR> progID; cotask_holder<OLECHAR> userType; HRESULT res = root_->GetClassDetails( glist, progID.addr(), userType.addr() ); if(FAILED(res)) { throw opc_exception( res, OLESTR("Failed to get ProgId from ClassId") ); } else { DWPRINT( L"progId = %s\n", progID ); if ( lstrcmpW( progID.get(), server_name ) == 0 ) { res = root_->CLSIDFromProgID( progID.get(), &server_id ); if ( FAILED(res) ) { throw opc_exception( res, OLESTR("IOPCServerList::CLSIDFromProgID - Failed to get ClassId from ProgId") ); } return; } } } }
/** * Opens the Door! :) * * Parameters: * >szDoor * Path to lock device for the door. * * Returns: * N/A. */ void perco_exchange::openDoor(_In_ STLADD string_unique_ptr_t&& szDoor) { ATL::CComPtr<PERCo_S20_SDK::IExchangeMain> percoXchg; if (SUCCEEDED(percoXchg.CoCreateInstance(__uuidof(PERCo_S20_SDK::CoExchangeMain)))) { if (SUCCEEDED(percoXchg->SetConnect(PERCO_HOST, PERCO_PORT, PERCO_LOGIN, PERCO_PWD))) { BSTR szDBVersion; BSTR szSDKVersion; if (!percoXchg->CheckVersion(&szDBVersion, &szSDKVersion)) { ATL::CComPtr<IXMLDOMDocument2> request = getSendCommandsRequest(std::move(szDoor)); AtlTrace2(ATL::atlTraceGeneral, 0, "Sending the 'sendcommands' request.\r\n"); if (request && SUCCEEDED(percoXchg->ExecuteCommand(request))) { AtlTrace2(ATL::atlTraceGeneral, 0, "PERCo has responded to the 'sendcommands' request.\r\n"); } } percoXchg->DisConnect(); } } else { AtlTrace2(ATL::atlTraceCOM, 0, "'PERCo_S20_SDK::IExchangeMain' ain't registered.\r\n"); } }
//* void local_host::get_clsid( const CATID& cat_id, LPCOLESTR server_name, CLSID& server_id ) { #if defined _DEBUG && defined _CONSOLE wprintf( L"get_clsid( %s )\n", server_name ); #endif CATID Implist[1] = { cat_id }; ATL::CComPtr<IEnumCLSID> iEnum; HRESULT result = root_->EnumClassesOfCategories(1, Implist,0, NULL, &iEnum); if (FAILED(result)) { throw opc_exception( result, OLESTR("Failed to get enum for categeories") ); } GUID glist; ULONG actual; while((result = iEnum->Next(1, &glist, &actual)) == S_OK) { cotask_holder<OLECHAR> progID; HRESULT res = ProgIDFromCLSID(glist, progID.addr()); if(FAILED(res)) { throw opc_exception( res, OLESTR("Failed to get ProgId from ClassId") ); } else { #if defined _DEBUG && defined _CONSOLE wprintf( L"progId = %s\n", progID ); #endif if ( lstrcmpW( progID.get(), server_name ) == 0 ) { server_id = glist; return; } } } }
void dumpTypeLibrary(IDispatch* dispatchToDump, std::wostream& toOutput) { toOutput << L"Start dumping!" << std::endl; COMUTILS_RETURN_IF_FAILED_START; UINT typeLibCount = 0; COMUTILS_RETURN_IF_FAILED(dispatchToDump->GetTypeInfoCount(&typeLibCount), toOutput, L"Failed to get type count"); toOutput << "Type Library count: " << typeLibCount << std::endl; if (typeLibCount == 0) return; ATL::CComPtr<ITypeInfo> typeInfoOfObj = NULL; COMUTILS_RETURN_IF_FAILED(dispatchToDump->GetTypeInfo(NULL, LOCALE_SYSTEM_DEFAULT, &typeInfoOfObj), toOutput, L"Failed to get type info"); toOutput << L"DEBUG: Got type info!" << std::endl; toOutput << L"DEBUG: Ptr to ITypeLib: " << std::hex << (int)typeInfoOfObj.p << std::dec << std::endl; ATL::CComPtr<ITypeLib> typeLibOfObj = NULL; UINT index = 0; COMUTILS_RETURN_IF_FAILED(typeInfoOfObj->GetContainingTypeLib(&typeLibOfObj, &index), toOutput, L"Failed to get type lib"); toOutput << "DEBUG: Got type lib with index " << index << std::endl; /* TYPEATTR* descriptor = NULL; COMUTILS_RETURN_IF_FAILED(typeInfoOfObj->GetTypeAttr(&descriptor), toOutput, L"Failed to get descriptor!"); toOutput << L"DEBUG: Got descriptor!" << std::endl; toOutput << std::hex << (UINT)descriptor << std::dec << std::endl; dumpTYPEATTR(descriptor, toOutput); typeInfoOfObj->ReleaseTypeAttr(descriptor); toOutput << L"DEBUG: Released descriptor!" << std::endl; */ }
HRESULT CreateSeparatorLink(IShellLink **ppsl) { ATL::CComPtr<IPropertyStore> pps; HRESULT hr = pps.CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER); if (FAILED(hr)) return hr; PROPVARIANT propvar; hr = InitPropVariantFromBoolean(TRUE, &propvar); if (FAILED(hr)) return hr; hr = pps->SetValue(PKEY_AppUserModel_IsDestListSeparator, propvar); if (SUCCEEDED(hr)) { hr = pps->Commit(); if (SUCCEEDED(hr)) { hr = pps.QueryInterface(ppsl); } } PropVariantClear(&propvar); return hr; }
//------------------------------------------------------------------------------------------------- ALVR_RESULT Terminate() { g_MouseInput.Terminate(); g_pFenceD3D11.Release(); g_pLvrDevice.Release(); ::DestroyWindow(g_hWindow); g_D3DHelper.Terminate(); #if defined(AFFINITY_WORK_AROUND) m_pLvrAffinity.Release(); #endif g_pFactory = NULL; ::FreeLibrary(g_hLiquidVRDLL); return ALVR_OK; }
//------------------------------------------------------------------------------------------------- ALVR_RESULT Init() { HRESULT hr = S_OK; //--------------------------------------------------------------------------------------------- // Init ALVR //--------------------------------------------------------------------------------------------- ALVR_RESULT res = ALVR_OK; g_hLiquidVRDLL = LoadLibraryW(ALVR_DLL_NAME); CHECK_RETURN(g_hLiquidVRDLL != NULL, ALVR_FAIL, L"DLL " << ALVR_DLL_NAME << L" is not found"); ALVRInit_Fn pInit = (ALVRInit_Fn)GetProcAddress(g_hLiquidVRDLL, ALVR_INIT_FUNCTION_NAME); res = pInit(ALVR_FULL_VERSION, (void**)&g_pFactory); CHECK_ALVR_ERROR_RETURN(res, ALVR_INIT_FUNCTION_NAME << L"failed"); #if defined(AFFINITY_WORK_AROUND) res = g_pFactory->CreateGpuAffinity(&m_pLvrAffinity); // CHECK_ALVR_ERROR_RETURN(res, L"CreateGpuAffinity() failed"); if(m_pLvrAffinity != NULL) { res = m_pLvrAffinity->EnableGpuAffinity(ALVR_GPU_AFFINITY_FLAGS_NONE); CHECK_ALVR_ERROR_RETURN(res, L"EnableGpuAffinity() failed"); res = m_pLvrAffinity->DisableGpuAffinity(); CHECK_ALVR_ERROR_RETURN(res, L"EnableGpuAffinity() failed"); } #endif //--------------------------------------------------------------------------------------------- // create D3D11 device //--------------------------------------------------------------------------------------------- res = g_D3DHelper.CreateD3D11Device(); CHECK_ALVR_ERROR_RETURN(res, L"CreateD3D11Device() failed"); res = g_pFactory->CreateALVRDeviceExD3D11(g_D3DHelper.m_pd3dDevice, NULL, &g_pLvrDevice); CHECK_ALVR_ERROR_RETURN(res, L"CreateALVRDeviceExD3D11() failed"); res = g_pLvrDevice->CreateFence(&g_pFenceD3D11); CHECK_ALVR_ERROR_RETURN(res, L"CreateFence() failed"); //--------------------------------------------------------------------------------------------- // create window //--------------------------------------------------------------------------------------------- HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL); WNDCLASSEX wcex = {0}; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; wcex.lpfnWndProc = MyDefWindowProcW; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInstance; wcex.hIcon = NULL; wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wcex.lpszClassName = L"SimpleMGPU"; wcex.hIconSm = NULL; RegisterClassEx(&wcex); int posX = 0; int posY = 0; UINT count=0; int adapterIDLocal = 0; DISPLAY_DEVICE displayDevice; displayDevice.cb = sizeof(displayDevice); while(true) { if(EnumDisplayDevices(NULL, count, &displayDevice, 0) == FALSE) { break; } if(displayDevice.StateFlags & DISPLAY_DEVICE_ACTIVE) { if(displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) { break; } adapterIDLocal++; } count++; } EnumDisplayMonitors(NULL, NULL, MyDisplayEnumProc, (LPARAM)displayDevice.DeviceName); // find adapter and provide coordinates unsigned int width = (g_MonitorWorkArea.right - g_MonitorWorkArea.left) * 2 / 3; unsigned int height = (g_MonitorWorkArea.bottom - g_MonitorWorkArea.top) * 2 / 3; posX = (g_MonitorWorkArea.left + g_MonitorWorkArea.right) / 2 - width / 2; posY = (g_MonitorWorkArea.top + g_MonitorWorkArea.bottom) / 2 - height / 2; // GetWindowPosition(posX, posY); g_hWindow = CreateWindow(L"SimpleMGPU", L"SimpleMGPU", WS_POPUP, posX, posY, width, height, NULL, NULL, hInstance, NULL); CHECK_RETURN(g_hWindow != NULL, ALVR_FAIL, L"Window failed to create"); ::ShowWindow(g_hWindow, SW_NORMAL); ::UpdateWindow(g_hWindow); //--------------------------------------------------------------------------------------------- // Create swap chain //--------------------------------------------------------------------------------------------- res = g_D3DHelper.CreateSwapChain(g_hWindow, g_iBackbufferCount); CHECK_ALVR_ERROR_RETURN(res, L"CreateSwapChain() failed"); //--------------------------------------------------------------------------------------------- // prepare 3D scene //--------------------------------------------------------------------------------------------- res = g_D3DHelper.Create3DScene(width, height, true); CHECK_ALVR_ERROR_RETURN(res, L"Create3DScene() failed"); g_MouseInput.Init((HINSTANCE)GetModuleHandle(NULL), g_hWindow, &g_D3DHelper, 200); g_MouseInput.SetEmulation(true); return ALVR_OK; }
void SetProgressValue(ULONGLONG Completed) { TaskbarList->SetProgressValue(hwnd, Completed, Total); }
~ProgressTaskBar() { TaskbarList->SetProgressState(hwnd, TBPF_NOPROGRESS); }
/** * Create XML document to send 'sendcommands' request via the 'PERCo_S20_SDK::IExchangeMain'. * * Parameters: * >szDoor * Path to lock device for the door. * * Returns: * XML document instance. */ ATL::CComPtr<IXMLDOMDocument2> perco_exchange::getSendCommandsRequest(_In_ STLADD string_unique_ptr_t&& szDoor) const { ATL::CComPtr<IXMLDOMDocument2> document; if (SUCCEEDED(document.CoCreateInstance(CLSID_DOMDocument60, nullptr, CLSCTX_INPROC_SERVER))) { ATL::CComPtr<IXMLDOMProcessingInstruction> processingInstruction; if (SUCCEEDED(document->createProcessingInstruction( TEXT("xml"), TEXT("version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\""), &processingInstruction))) { document->appendChild(processingInstruction, nullptr); // Create root <documentrequest> element. ATL::CComPtr<IXMLDOMElement> documentRequest; if (SUCCEEDED(document->createElement(TEXT("documentrequest"), &documentRequest))) { ATL::CComPtr<IXMLDOMAttribute> attribute; if (SUCCEEDED(document->createAttribute(TEXT("type"), &attribute))) { ATL::CComVariant value(TEXT("sendcommands")); if (SUCCEEDED(attribute->put_value(value)) && SUCCEEDED(documentRequest->setAttributeNode(attribute, nullptr)) && SUCCEEDED(document->appendChild(documentRequest, nullptr))) { attribute.Release(); ATL::CComPtr<IXMLDOMElement> login; if (SUCCEEDED(document->createElement(TEXT("login"), &login)) && SUCCEEDED(document->createAttribute(TEXT("loginname"), &attribute))) { value = TEXT("login name"); if (SUCCEEDED(attribute->put_value(value)) && SUCCEEDED(login->setAttributeNode(attribute, nullptr)) && SUCCEEDED(documentRequest->appendChild(login, nullptr))) { ATL::CComPtr<IXMLDOMElement> command; if (SUCCEEDED(document->createElement(TEXT("command"), &command))) { attribute.Release(); if (SUCCEEDED(document->createAttribute(TEXT("commandnumber"), &attribute))) { // cmd #120 is "unlock device reader". value = "120"; if (SUCCEEDED(attribute->put_value(value))) { command->setAttributeNode(attribute, nullptr); } } attribute.Release(); if (SUCCEEDED(document->createAttribute(TEXT("commandname"), &attribute))) { // value = L"Открыть (разблокировать) ИУ"; value = L""; if (SUCCEEDED(attribute->put_value(value))) { command->setAttributeNode(attribute, nullptr); } } attribute.Release(); if (SUCCEEDED(document->createAttribute(TEXT("commandpath"), &attribute))) { value = szDoor->c_str(); if (SUCCEEDED(attribute->put_value(value))) { command->setAttributeNode(attribute, nullptr); } } attribute.Release(); if (SUCCEEDED(document->createAttribute(TEXT("devicename"), &attribute))) { // value = L"Считыватель №2"; value = L""; if (SUCCEEDED(attribute->put_value(value))) { command->setAttributeNode(attribute, nullptr); } } attribute.Release(); if (SUCCEEDED(document->createAttribute(TEXT("typename"), &attribute))) { // value = L"ReaderTI1_"; value = L""; if (SUCCEEDED(attribute->put_value(value))) { command->setAttributeNode(attribute, nullptr); } } if (SUCCEEDED(login->appendChild(command, nullptr))) { ATL::CComPtr<IXMLDOMElement> commandAttributes; if (SUCCEEDED( document->createElement(TEXT("command_attributes"), &commandAttributes)) && SUCCEEDED(command->appendChild(commandAttributes, nullptr))) { ATL::CComPtr<IXMLDOMElement> commandAttribute; if (SUCCEEDED( document->createElement(TEXT("command_attribute"), &commandAttribute))) { attribute.Release(); if (SUCCEEDED( document->createAttribute(TEXT("displayname"), &attribute))) { // value = L"Время разблокировки"; value = L""; if (SUCCEEDED(attribute->put_value(value))) { commandAttribute->setAttributeNode(attribute, nullptr); } } attribute.Release(); if (SUCCEEDED(document->createAttribute(TEXT("value"), &attribute))) { value = L"5"; if (SUCCEEDED(attribute->put_value(value))) { commandAttribute->setAttributeNode(attribute, nullptr); } } attribute.Release(); if (SUCCEEDED( document->createAttribute(TEXT("rangeindex"), &attribute))) { value = L"1"; if (SUCCEEDED(attribute->put_value(value))) { commandAttribute->setAttributeNode(attribute, nullptr); } } if (FAILED(commandAttributes->appendChild(commandAttribute, nullptr))) { document.Release(); } } } } } } } } } } } } szDoor.reset(); return document; }