HRESULT BaseApp::createDeviceResources(HWND hWnd) { HRESULT hr = S_OK; RECT rc; GetClientRect(hWnd, &rc); D2D1_SIZE_U size = D2D1::SizeU( rc.right - rc.left, rc.bottom - rc.top ); hr = d2dFactory->CreateHwndRenderTarget( D2D1::RenderTargetProperties(), D2D1::HwndRenderTargetProperties(hWnd, size), &renderingTarget ); size_t index{ 0 }; // Brushes for (auto color : brushColor) { solidBrushes.push_back(NULL); hr = renderingTarget->CreateSolidColorBrush( color, &solidBrushes.at(index)); ++index; } // Text formats // Pasing in Font, font-size index = 0; for (auto font : fonts) { for (auto fontSize : fontSizes) { textFormats.push_back(NULL); hr = d2dDWriteFactory->CreateTextFormat( TUtils::toWSString(font).c_str(), NULL, DWRITE_FONT_WEIGHT_REGULAR, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, fontSize, L"en-us", &textFormats.at(index) ); // Center align (horizontally) the text. if (SUCCEEDED(hr)) { hr = textFormats.at(index)->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING); hr = textFormats.at(index)->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR); } ++index; } } //// Bitmaps IWICBitmapDecoder* wicBitmapDecoder = NULL; IWICFormatConverter* wicFormatConverter = NULL; IWICBitmapFrameDecode* wicBitmapFrameDecode = NULL; index = 0; for (auto spriteSheetFile : spriteSheetFiles) { hr = wicImaingFactory->CreateDecoderFromFilename( TUtils::toWSString(spriteSheetFile).c_str(), NULL, GENERIC_READ, WICDecodeMetadataCacheOnLoad, &wicBitmapDecoder); hr = wicImaingFactory->CreateFormatConverter(&wicFormatConverter); hr = wicBitmapDecoder->GetFrame(0, &wicBitmapFrameDecode); hr = wicFormatConverter->Initialize( wicBitmapFrameDecode, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, NULL, 0.f, WICBitmapPaletteTypeMedianCut ); spriteSheets.push_back(NULL); hr = renderingTarget->CreateBitmapFromWicBitmap( wicFormatConverter, NULL, &spriteSheets.at(index) ); ++index; } return hr; }
/* static */ wxString wxStandardPaths::DoGetDirectory(int csidl) { if ( !gs_shellFuncs.initialized ) ResolveShellFunctions(); wxString dir; HRESULT hr = E_FAIL; // test whether the function is available during compile-time (it must be // defined as either "SHGetFolderPathA" or "SHGetFolderPathW") #ifdef SHGetFolderPath // and now test whether we have it during run-time if ( gs_shellFuncs.pSHGetFolderPath ) { hr = gs_shellFuncs.pSHGetFolderPath ( NULL, // parent window, not used csidl, NULL, // access token (current user) SHGFP_TYPE_CURRENT, // current path, not just default value wxStringBuffer(dir, MAX_PATH) ); // somewhat incredibly, the error code in the Unicode version is // different from the one in ASCII version for this function #if wxUSE_UNICODE if ( hr == E_FAIL ) #else if ( hr == S_FALSE ) #endif { // directory doesn't exist, maybe we can get its default value? hr = gs_shellFuncs.pSHGetFolderPath ( NULL, csidl, NULL, SHGFP_TYPE_DEFAULT, wxStringBuffer(dir, MAX_PATH) ); } } #endif // SHGetFolderPath #ifdef SHGetSpecialFolderPath if ( FAILED(hr) && gs_shellFuncs.pSHGetSpecialFolderPath ) { hr = gs_shellFuncs.pSHGetSpecialFolderPath ( NULL, // parent window wxStringBuffer(dir, MAX_PATH), csidl, FALSE // don't create if doesn't exist ); } #endif // SHGetSpecialFolderPath // SHGetSpecialFolderLocation should be available with all compilers and // under all Win32 systems, so don't test for it (and as it doesn't exist // in "A" and "W" versions anyhow, testing would be more involved, too) if ( FAILED(hr) ) { LPITEMIDLIST pidl; hr = SHGetSpecialFolderLocation(NULL, csidl, &pidl); if ( SUCCEEDED(hr) ) { // creating this temp object has (nice) side effect of freeing pidl dir = wxItemIdList(pidl).GetPath(); } } return dir; }
/**----------------------------------------------------------------------------- * 프로그램 시작점 *------------------------------------------------------------------------------ */ INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT ) { /// 윈도우 클래스 등록 WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, "BasicFrame", NULL }; RegisterClassEx( &wc ); /// 윈도우 생성 HWND hWnd = CreateWindow( "BasicFrame", WINDOW_TITLE, WS_OVERLAPPEDWINDOW, 100, 100, WINDOW_W, WINDOW_H, GetDesktopWindow(), NULL, wc.hInstance, NULL ); g_hwnd = hWnd; g_pLog = new ZFLog( ZF_LOG_TARGET_CONSOLE | ZF_LOG_TARGET_WINDOW ); // g_pCamera = new ZCamera; g_pCamera = (ZCamera*)_aligned_malloc( sizeof( ZCamera ), 16 ); /// Direct3D 초기화 if( SUCCEEDED( InitD3D( hWnd ) ) ) { if( SUCCEEDED( InitGeometry() ) ) { /// 윈도우 출력 ShowWindow( hWnd, SW_SHOWDEFAULT ); UpdateWindow( hWnd ); /// 메시지 루프 MSG msg; ZeroMemory( &msg, sizeof(msg) ); while( msg.message!=WM_QUIT ) { /// 메시지큐에 메시지가 있으면 메시지 처리 if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); } else { /// 처리할 메시지가 없으면 Render()함수 호출 Render(); } } } } delete g_pLog; // delete g_pCamera; if ( g_pCamera ) { g_pCamera->~ZCamera(); _aligned_free( g_pCamera ); } /// 등록된 클래스 소거 UnregisterClass( "D3D Tutorial", wc.hInstance ); return 0; }
static void create_system_ports_list(IDirectMusic8Impl* object) { port_info * port; const WCHAR emulated[] = {' ','[','E','m','u','l','a','t','e','d',']',0}; ULONG nb_ports; ULONG nb_midi_out; ULONG nb_midi_in; MIDIOUTCAPSW caps_out; MIDIINCAPSW caps_in; IDirectMusicSynth8* synth; HRESULT hr; ULONG i; TRACE("(%p)\n", object); /* NOTE: - it seems some native versions get the rest of devices through dmusic32.EnumLegacyDevices...*sigh*...which is undocumented - should we enum wave devices ? Native does not seem to */ nb_midi_out = midiOutGetNumDevs(); nb_midi_in = midiInGetNumDevs(); nb_ports = 1 /* midi mapper */ + nb_midi_out + nb_midi_in + 1 /* synth port */; port = object->system_ports = HeapAlloc(GetProcessHeap(), 0, nb_ports * sizeof(port_info)); if (!object->system_ports) return; /* Fill common port caps for all winmm ports */ for (i = 0; i < (nb_ports - 1 /* synth port*/); i++) { object->system_ports[i].caps.dwSize = sizeof(DMUS_PORTCAPS); object->system_ports[i].caps.dwType = DMUS_PORT_WINMM_DRIVER; object->system_ports[i].caps.dwMemorySize = 0; object->system_ports[i].caps.dwMaxChannelGroups = 1; object->system_ports[i].caps.dwMaxVoices = 0; object->system_ports[i].caps.dwMaxAudioChannels = 0; object->system_ports[i].caps.dwEffectFlags = DMUS_EFFECT_NONE; /* Fake port GUID */ object->system_ports[i].caps.guidPort = IID_IUnknown; object->system_ports[i].caps.guidPort.Data1 = i + 1; } /* Fill midi mapper port info */ port->device = MIDI_MAPPER; port->create = DMUSIC_CreateMidiOutPortImpl; midiOutGetDevCapsW(MIDI_MAPPER, &caps_out, sizeof(caps_out)); strcpyW(port->caps.wszDescription, caps_out.szPname); strcatW(port->caps.wszDescription, emulated); port->caps.dwFlags = DMUS_PC_SHAREABLE; port->caps.dwClass = DMUS_PC_OUTPUTCLASS; port++; /* Fill midi out port info */ for (i = 0; i < nb_midi_out; i++) { port->device = i; port->create = DMUSIC_CreateMidiOutPortImpl; midiOutGetDevCapsW(i, &caps_out, sizeof(caps_out)); strcpyW(port->caps.wszDescription, caps_out.szPname); strcatW(port->caps.wszDescription, emulated); port->caps.dwFlags = DMUS_PC_SHAREABLE | DMUS_PC_EXTERNAL; port->caps.dwClass = DMUS_PC_OUTPUTCLASS; port++; } /* Fill midi in port info */ for (i = 0; i < nb_midi_in; i++) { port->device = i; port->create = DMUSIC_CreateMidiInPortImpl; midiInGetDevCapsW(i, &caps_in, sizeof(caps_in)); strcpyW(port->caps.wszDescription, caps_in.szPname); strcatW(port->caps.wszDescription, emulated); port->caps.dwFlags = DMUS_PC_EXTERNAL; port->caps.dwClass = DMUS_PC_INPUTCLASS; port++; } /* Fill synth port info */ port->create = DMUSIC_CreateSynthPortImpl; hr = CoCreateInstance(&CLSID_DirectMusicSynth, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicSynth8, (void**)&synth); if (SUCCEEDED(hr)) { port->caps.dwSize = sizeof(port->caps); hr = IDirectMusicSynth8_GetPortCaps(synth, &port->caps); IDirectMusicSynth8_Release(synth); } if (FAILED(hr)) nb_ports--; object->nb_system_ports = nb_ports; }
// Load the rendering pipeline dependencies. void D3D12HelloTriangle::LoadPipeline() { #ifdef _DEBUG // Enable the D3D12 debug layer. { ComPtr<ID3D12Debug> debugController; if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)))) { debugController->EnableDebugLayer(); } } #endif ComPtr<IDXGIFactory4> factory; ThrowIfFailed(CreateDXGIFactory1(IID_PPV_ARGS(&factory))); if (m_useWarpDevice) { ComPtr<IDXGIAdapter> warpAdapter; ThrowIfFailed(factory->EnumWarpAdapter(IID_PPV_ARGS(&warpAdapter))); ThrowIfFailed(D3D12CreateDevice( warpAdapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device) )); } else { ThrowIfFailed(D3D12CreateDevice( nullptr, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device) )); } // Describe and create the command queue. D3D12_COMMAND_QUEUE_DESC queueDesc = {}; queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE; queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT; ThrowIfFailed(m_device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&m_commandQueue))); // Describe and create the swap chain. DXGI_SWAP_CHAIN_DESC swapChainDesc = {}; swapChainDesc.BufferCount = FrameCount; swapChainDesc.BufferDesc.Width = m_width; swapChainDesc.BufferDesc.Height = m_height; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD; swapChainDesc.OutputWindow = m_hwnd; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.Windowed = TRUE; ComPtr<IDXGISwapChain> swapChain; ThrowIfFailed(factory->CreateSwapChain( m_commandQueue.Get(), // Swap chain needs the queue so that it can force a flush on it. &swapChainDesc, &swapChain )); ThrowIfFailed(swapChain.As(&m_swapChain)); m_frameIndex = m_swapChain->GetCurrentBackBufferIndex(); // Create descriptor heaps. { // Describe and create a render target view (RTV) descriptor heap. D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {}; rtvHeapDesc.NumDescriptors = FrameCount; rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV; rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; ThrowIfFailed(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&m_rtvHeap))); m_rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV); } // Create frame resources. { CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart()); // Create a RTV for each frame. for (UINT n = 0; n < FrameCount; n++) { ThrowIfFailed(m_swapChain->GetBuffer(n, IID_PPV_ARGS(&m_renderTargets[n]))); m_device->CreateRenderTargetView(m_renderTargets[n].Get(), nullptr, rtvHandle); rtvHandle.Offset(1, m_rtvDescriptorSize); } } ThrowIfFailed(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocator))); }
static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { if (argumentCount < 1) return JSValueMakeUndefined(context); static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length"); COMPtr<IWebFramePrivate> framePrivate; if (SUCCEEDED(frame->QueryInterface(&framePrivate))) framePrivate->layout(); JSStringRef character = JSValueToStringCopy(context, arguments[0], exception); ASSERT(!*exception); int virtualKeyCode; int charCode = 0; int keyData = 1; bool needsShiftKeyModifier = false; if (JSStringIsEqualToUTF8CString(character, "leftArrow")) { virtualKeyCode = VK_LEFT; keyData += KF_EXTENDED << 16; // In this case, extended means "not keypad". } else if (JSStringIsEqualToUTF8CString(character, "rightArrow")) { virtualKeyCode = VK_RIGHT; keyData += KF_EXTENDED << 16; } else if (JSStringIsEqualToUTF8CString(character, "upArrow")) { virtualKeyCode = VK_UP; keyData += KF_EXTENDED << 16; } else if (JSStringIsEqualToUTF8CString(character, "downArrow")) { virtualKeyCode = VK_DOWN; keyData += KF_EXTENDED << 16; } else if (JSStringIsEqualToUTF8CString(character, "pageUp")) virtualKeyCode = VK_PRIOR; else if (JSStringIsEqualToUTF8CString(character, "pageDown")) virtualKeyCode = VK_NEXT; else if (JSStringIsEqualToUTF8CString(character, "home")) virtualKeyCode = VK_HOME; else if (JSStringIsEqualToUTF8CString(character, "end")) virtualKeyCode = VK_END; else if (JSStringIsEqualToUTF8CString(character, "insert")) virtualKeyCode = VK_INSERT; else if (JSStringIsEqualToUTF8CString(character, "delete")) virtualKeyCode = VK_DELETE; else if (JSStringIsEqualToUTF8CString(character, "printScreen")) virtualKeyCode = VK_SNAPSHOT; else if (JSStringIsEqualToUTF8CString(character, "menu")) virtualKeyCode = VK_APPS; else if (JSStringIsEqualToUTF8CString(character, "leftControl")) { virtualKeyCode = VK_CONTROL; keyData += makeKeyDataForScanCode(VK_LCONTROL); } else if (JSStringIsEqualToUTF8CString(character, "leftShift")) { virtualKeyCode = VK_SHIFT; keyData += makeKeyDataForScanCode(VK_LSHIFT); } else if (JSStringIsEqualToUTF8CString(character, "leftAlt")) { virtualKeyCode = VK_MENU; keyData += makeKeyDataForScanCode(VK_LMENU); } else if (JSStringIsEqualToUTF8CString(character, "rightControl")) { virtualKeyCode = VK_CONTROL; keyData += makeKeyDataForScanCode(VK_RCONTROL); } else if (JSStringIsEqualToUTF8CString(character, "rightShift")) { virtualKeyCode = VK_SHIFT; keyData += makeKeyDataForScanCode(VK_RSHIFT); } else if (JSStringIsEqualToUTF8CString(character, "rightAlt")) { virtualKeyCode = VK_MENU; keyData += makeKeyDataForScanCode(VK_RMENU); } else { static const char shiftedUSCharacters[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ~!@#$%^&*()_+{}|:\"<>?"; charCode = JSStringGetCharactersPtr(character)[0]; virtualKeyCode = LOBYTE(VkKeyScan(charCode)); if (strchr(shiftedUSCharacters, charCode)) needsShiftKeyModifier = true; } JSStringRelease(character); BYTE keyState[256]; if (argumentCount > 1 || needsShiftKeyModifier) { ::GetKeyboardState(keyState); BYTE newKeyState[256]; memcpy(newKeyState, keyState, sizeof(keyState)); if (needsShiftKeyModifier) newKeyState[VK_SHIFT] = 0x80; if (argumentCount > 1) { JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], 0); if (modifiersArray) { int modifiersCount = JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0); for (int i = 0; i < modifiersCount; ++i) { JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0); JSStringRef string = JSValueToStringCopy(context, value, 0); if (JSStringIsEqualToUTF8CString(string, "ctrlKey") || JSStringIsEqualToUTF8CString(string, "addSelectionKey")) newKeyState[VK_CONTROL] = 0x80; else if (JSStringIsEqualToUTF8CString(string, "shiftKey") || JSStringIsEqualToUTF8CString(string, "rangeSelectionKey")) newKeyState[VK_SHIFT] = 0x80; else if (JSStringIsEqualToUTF8CString(string, "altKey")) newKeyState[VK_MENU] = 0x80; JSStringRelease(string); } } } ::SetKeyboardState(newKeyState); } MSG msg = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYDOWN : WM_KEYDOWN, virtualKeyCode, keyData); if (virtualKeyCode != 255) dispatchMessage(&msg); else { // For characters that do not exist in the active keyboard layout, // ::Translate will not work, so we post an WM_CHAR event ourselves. ::PostMessage(webViewWindow, WM_CHAR, charCode, 0); } // Tests expect that all messages are processed by the time keyDown() returns. if (::PeekMessage(&msg, webViewWindow, WM_CHAR, WM_CHAR, PM_REMOVE) || ::PeekMessage(&msg, webViewWindow, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE)) ::DispatchMessage(&msg); MSG msgUp = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYUP : WM_KEYUP, virtualKeyCode, keyData); ::DispatchMessage(&msgUp); if (argumentCount > 1 || needsShiftKeyModifier) ::SetKeyboardState(keyState); return JSValueMakeUndefined(context); }
bool checkDShowAvailability() { ComSmartPtr <IGraphBuilder> graph; return SUCCEEDED (graph.CoCreateInstance (CLSID_FilterGraph)); }
static HRESULT WINAPI SynthPortImpl_IDirectMusicPort_DownloadInstrument(LPDIRECTMUSICPORT iface, IDirectMusicInstrument* instrument, IDirectMusicDownloadedInstrument** downloaded_instrument, DMUS_NOTERANGE* note_ranges, DWORD num_note_ranges) { SynthPortImpl *This = impl_from_SynthPortImpl_IDirectMusicPort(iface); IDirectMusicInstrumentImpl *instrument_object; HRESULT ret; BOOL free; HANDLE download; DMUS_DOWNLOADINFO *info; DMUS_OFFSETTABLE *offset_table; DMUS_INSTRUMENT *instrument_info; BYTE *data; ULONG offset; ULONG nb_regions; ULONG size; ULONG i; TRACE("(%p/%p)->(%p, %p, %p, %d)\n", iface, This, instrument, downloaded_instrument, note_ranges, num_note_ranges); if (!instrument || !downloaded_instrument || (num_note_ranges && !note_ranges)) return E_POINTER; instrument_object = impl_from_IDirectMusicInstrument(instrument); nb_regions = instrument_object->header.cRegions; size = sizeof(DMUS_DOWNLOADINFO) + sizeof(ULONG) * (1 + nb_regions) + sizeof(DMUS_INSTRUMENT) + sizeof(DMUS_REGION) * nb_regions; data = HeapAlloc(GetProcessHeap(), 0, size); if (!data) return E_OUTOFMEMORY; info = (DMUS_DOWNLOADINFO*)data; offset_table = (DMUS_OFFSETTABLE*)(data + sizeof(DMUS_DOWNLOADINFO)); offset = sizeof(DMUS_DOWNLOADINFO) + sizeof(ULONG) * (1 + nb_regions); info->dwDLType = DMUS_DOWNLOADINFO_INSTRUMENT2; info->dwDLId = 0; info->dwNumOffsetTableEntries = 1 + instrument_object->header.cRegions; info->cbSize = size; offset_table->ulOffsetTable[0] = offset; instrument_info = (DMUS_INSTRUMENT*)(data + offset); offset += sizeof(DMUS_INSTRUMENT); instrument_info->ulPatch = MIDILOCALE2Patch(&instrument_object->header.Locale); instrument_info->ulFirstRegionIdx = 1; instrument_info->ulGlobalArtIdx = 0; /* FIXME */ instrument_info->ulFirstExtCkIdx = 0; /* FIXME */ instrument_info->ulCopyrightIdx = 0; /* FIXME */ instrument_info->ulFlags = 0; /* FIXME */ for (i = 0; i < nb_regions; i++) { DMUS_REGION *region = (DMUS_REGION*)(data + offset); offset_table->ulOffsetTable[1 + i] = offset; offset += sizeof(DMUS_REGION); region->RangeKey = instrument_object->regions[i].header.RangeKey; region->RangeVelocity = instrument_object->regions[i].header.RangeVelocity; region->fusOptions = instrument_object->regions[i].header.fusOptions; region->usKeyGroup = instrument_object->regions[i].header.usKeyGroup; region->ulRegionArtIdx = 0; /* FIXME */ region->ulNextRegionIdx = i != (nb_regions - 1) ? (i + 2) : 0; region->ulFirstExtCkIdx = 0; /* FIXME */ region->WaveLink = instrument_object->regions[i].wave_link; region->WSMP = instrument_object->regions[i].wave_sample; region->WLOOP[0] = instrument_object->regions[i].wave_loop; } ret = IDirectMusicSynth8_Download(This->synth, &download, (VOID*)data, &free); if (SUCCEEDED(ret)) ret = DMUSIC_CreateDirectMusicDownloadedInstrumentImpl(downloaded_instrument); if (SUCCEEDED(ret)) { IDirectMusicDownloadedInstrumentImpl *downloaded_object = impl_from_IDirectMusicDownloadedInstrument(*downloaded_instrument); downloaded_object->data = data; downloaded_object->downloaded = TRUE; } *downloaded_instrument = NULL; HeapFree(GetProcessHeap(), 0, data); return E_FAIL; }
HRESULT DMUSIC_CreateSynthPortImpl(LPCGUID guid, LPVOID *object, LPUNKNOWN unkouter, LPDMUS_PORTPARAMS port_params, LPDMUS_PORTCAPS port_caps, DWORD device) { SynthPortImpl *obj; HRESULT hr = E_FAIL; int i; TRACE("(%s, %p, %p, %p, %p, %d)\n", debugstr_guid(guid), object, unkouter, port_params, port_caps, device); *object = NULL; obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SynthPortImpl)); if (!obj) return E_OUTOFMEMORY; obj->IDirectMusicPort_iface.lpVtbl = &SynthPortImpl_DirectMusicPort_Vtbl; obj->IDirectMusicPortDownload_iface.lpVtbl = &SynthPortImpl_DirectMusicPortDownload_Vtbl; obj->IDirectMusicThru_iface.lpVtbl = &SynthPortImpl_DirectMusicThru_Vtbl; obj->IKsControl_iface.lpVtbl = &SynthPortImpl_IKsControl_Vtbl; obj->ref = 0; /* Will be inited by QueryInterface */ obj->fActive = FALSE; obj->params = *port_params; obj->caps = *port_caps; hr = DMUSIC_CreateReferenceClockImpl(&IID_IReferenceClock, (LPVOID*)&obj->pLatencyClock, NULL); if (hr != S_OK) { HeapFree(GetProcessHeap(), 0, obj); return hr; } if (SUCCEEDED(hr)) hr = CoCreateInstance(&CLSID_DirectMusicSynth, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicSynth, (void**)&obj->synth); if (SUCCEEDED(hr)) hr = CoCreateInstance(&CLSID_DirectMusicSynthSink, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicSynthSink, (void**)&obj->synth_sink); if (SUCCEEDED(hr)) hr = IDirectMusicSynth_SetMasterClock(obj->synth, obj->pLatencyClock); if (SUCCEEDED(hr)) hr = IDirectMusicSynthSink_SetMasterClock(obj->synth_sink, obj->pLatencyClock); if (SUCCEEDED(hr)) hr = IDirectMusicSynth_SetSynthSink(obj->synth, obj->synth_sink); if (SUCCEEDED(hr)) hr = IDirectMusicSynth_Open(obj->synth, port_params); if (0) { if (port_params->dwValidParams & DMUS_PORTPARAMS_CHANNELGROUPS) { obj->nrofgroups = port_params->dwChannelGroups; /* Setting default priorities */ for (i = 0; i < obj->nrofgroups; i++) { TRACE ("Setting default channel priorities on channel group %i\n", i + 1); obj->group[i].channel[0].priority = DAUD_CHAN1_DEF_VOICE_PRIORITY; obj->group[i].channel[1].priority = DAUD_CHAN2_DEF_VOICE_PRIORITY; obj->group[i].channel[2].priority = DAUD_CHAN3_DEF_VOICE_PRIORITY; obj->group[i].channel[3].priority = DAUD_CHAN4_DEF_VOICE_PRIORITY; obj->group[i].channel[4].priority = DAUD_CHAN5_DEF_VOICE_PRIORITY; obj->group[i].channel[5].priority = DAUD_CHAN6_DEF_VOICE_PRIORITY; obj->group[i].channel[6].priority = DAUD_CHAN7_DEF_VOICE_PRIORITY; obj->group[i].channel[7].priority = DAUD_CHAN8_DEF_VOICE_PRIORITY; obj->group[i].channel[8].priority = DAUD_CHAN9_DEF_VOICE_PRIORITY; obj->group[i].channel[9].priority = DAUD_CHAN10_DEF_VOICE_PRIORITY; obj->group[i].channel[10].priority = DAUD_CHAN11_DEF_VOICE_PRIORITY; obj->group[i].channel[11].priority = DAUD_CHAN12_DEF_VOICE_PRIORITY; obj->group[i].channel[12].priority = DAUD_CHAN13_DEF_VOICE_PRIORITY; obj->group[i].channel[13].priority = DAUD_CHAN14_DEF_VOICE_PRIORITY; obj->group[i].channel[14].priority = DAUD_CHAN15_DEF_VOICE_PRIORITY; obj->group[i].channel[15].priority = DAUD_CHAN16_DEF_VOICE_PRIORITY; } } } if (SUCCEEDED(hr)) return IDirectMusicPort_QueryInterface((LPDIRECTMUSICPORT)obj, guid, object); if (obj->synth) IDirectMusicSynth_Release(obj->synth); if (obj->synth_sink) IDirectMusicSynthSink_Release(obj->synth_sink); if (obj->pLatencyClock) IReferenceClock_Release(obj->pLatencyClock); HeapFree(GetProcessHeap(), 0, obj); return hr; }
IXMLDOMDocument* SettingsXML::CreateDomDocument(wchar_t* pszErr /*= NULL*/, size_t cchErrMax /*= 0*/) { HRESULT hr; IXMLDOMDocument* pFile = NULL; static HMODULE hMsXml3 = NULL; typedef HRESULT (__stdcall* DllGetClassObject_t)(REFCLSID rclsid, REFIID riid, LPVOID *ppv); static DllGetClassObject_t lpfnGetClassObject = NULL; wchar_t szDllErr[128] = {}; hr = CoInitialize(NULL); // Если в прошлый раз обломались, и загрузили "msxml3.dll" - то и не дергаться if (hMsXml3 && (hMsXml3 != (HMODULE)INVALID_HANDLE_VALUE)) hr = REGDB_E_CLASSNOTREG; else hr = CoCreateInstance(CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER, //-V519 IID_IXMLDOMDocument, (void**)&pFile); // Если msxml3.dll (Msxml2.DOMDocument.3.0) не зарегистрирована - будет такая ошибка if (FAILED(hr)) // (hr == REGDB_E_CLASSNOTREG) { HRESULT hFact; // Попробовать грузануть ее ручками if (!hMsXml3) { wchar_t szDll[MAX_PATH+16]; struct FindPlaces { LPCWSTR sDir, sSlash; } findPlaces[] = { {gpConEmu->ms_ConEmuExeDir, L"\\"}, {gpConEmu->ms_ConEmuBaseDir, L"\\"}, {L"", L""}, {NULL}}; for (FindPlaces* fp = findPlaces; fp->sDir; fp++) { _wsprintf(szDll, SKIPLEN(countof(szDll)) L"%s%smsxml3.dll", fp->sDir, fp->sSlash); hMsXml3 = LoadLibrary(szDll); hFact = hMsXml3 ? 0 : (HRESULT)GetLastError(); if (hMsXml3) break; //if (!hMsXml3 // && (((DWORD)hFact) == ERROR_MOD_NOT_FOUND // || ((DWORD)hFact) == ERROR_BAD_EXE_FORMAT // || ((DWORD)hFact) == ERROR_FILE_NOT_FOUND)) } //_wsprintf(szDll, SKIPLEN(countof(szDll)) L"%s\\msxml3.dll", gpConEmu->ms_ConEmuExeDir); //hMsXml3 = LoadLibrary(szDll); //hFact = hMsXml3 ? 0 : (HRESULT)GetLastError(); //if (!hMsXml3 // && (((DWORD)hFact) == ERROR_MOD_NOT_FOUND // || ((DWORD)hFact) == ERROR_BAD_EXE_FORMAT // || ((DWORD)hFact) == ERROR_FILE_NOT_FOUND)) //{ // _wsprintf(szDll, SKIPLEN(countof(szDll)) L"%s\\msxml3.dll", gpConEmu->ms_ConEmuBaseDir); // hMsXml3 = LoadLibrary(szDll); // hFact = hMsXml3 ? 0 : (HRESULT)GetLastError(); //} if (!hMsXml3) { hMsXml3 = (HMODULE)INVALID_HANDLE_VALUE; _wsprintf(szDllErr, SKIPLEN(countof(szDllErr)) L"\nLoadLibrary(\"msxml3.dll\") failed\nErrCode=0x%08X", (DWORD)hFact); } } if (hMsXml3 && (hMsXml3 != (HMODULE)INVALID_HANDLE_VALUE)) { if (!lpfnGetClassObject) lpfnGetClassObject = (DllGetClassObject_t)GetProcAddress(hMsXml3, "DllGetClassObject"); if (!lpfnGetClassObject) { hFact = (HRESULT)GetLastError(); _wsprintf(szDllErr, SKIPLEN(countof(szDllErr)) L"\nGetProcAddress(\"DllGetClassObject\") failed\nErrCode=0x%08X", (DWORD)hFact); } else { IClassFactory* pFact = NULL; hFact = lpfnGetClassObject(CLSID_DOMDocument30, IID_IClassFactory, (void**)&pFact); if (SUCCEEDED(hFact) && pFact) { hFact = pFact->CreateInstance(NULL, IID_IXMLDOMDocument, (void**)&pFile); if (SUCCEEDED(hFact)) hr = hFact; else _wsprintf(szDllErr, SKIPLEN(countof(szDllErr)) L"\nCreateInstance(IID_IXMLDOMDocument) failed\nErrCode=0x%08X", (DWORD)hFact); pFact->Release(); } else { _wsprintf(szDllErr, SKIPLEN(countof(szDllErr)) L"\nGetClassObject(CLSID_DOMDocument30) failed\nErrCode=0x%08X", (DWORD)hFact); } } } } if (FAILED(hr) || !pFile) { wchar_t szErr[512]; bool bShowError = (pszErr == NULL); if (pszErr == NULL) { pszErr = szErr; cchErrMax = countof(szErr); } _wsprintf(pszErr, SKIPLEN(cchErrMax) L"XML setting file can not be used!\n" L"Dynamic libraries 'msxml3.dll'/'msxml3r.dll' was not found!\n\n" L"Can't create IID_IXMLDOMDocument!\n" L"ErrCode=0x%08X %s", (DWORD)hr, szDllErr); if (bShowError) { static bool bWarned = false; if (!bWarned) { // Не задалбывать пользователя ошибками. Один раз - и хватит bWarned = true; MBoxError(szErr); } } return NULL; } return pFile; }
IXMLDOMNode* SettingsXML::FindItem(IXMLDOMNode* apFrom, const wchar_t* asType, const wchar_t* asName, bool abAllowCreate) { HRESULT hr = S_OK; IXMLDOMNodeList* pList = NULL; IXMLDOMNode* pChild = NULL; IXMLDOMNamedNodeMap* pAttrs = NULL; IXMLDOMAttribute *pIXMLDOMAttribute = NULL; IXMLDOMNode *pIXMLDOMNode = NULL; IXMLDOMNode *pName = NULL; BSTR bsText = NULL; BOOL lbEmpty = TRUE; // Получить все дочерние элементы нужного типа if (apFrom == NULL) { hr = S_FALSE; } else { bsText = ::SysAllocString(asType); hr = apFrom->selectNodes(bsText, &pList); ::SysFreeString(bsText); bsText = NULL; } if (SUCCEEDED(hr) && pList) { hr = pList->reset(); while((hr = pList->nextNode(&pIXMLDOMNode)) == S_OK && pIXMLDOMNode) { lbEmpty = FALSE; hr = pIXMLDOMNode->get_attributes(&pAttrs); if (SUCCEEDED(hr) && pAttrs) { bsText = GetAttr(pIXMLDOMNode, pAttrs, L"name"); if (bsText) { if (lstrcmpi(bsText, asName) == 0) { ::SysFreeString(bsText); bsText = NULL; pChild = pIXMLDOMNode; pIXMLDOMNode = NULL; break; } ::SysFreeString(bsText); bsText = NULL; } } pIXMLDOMNode->Release(); pIXMLDOMNode = NULL; } pList->Release(); //pList = NULL; -- для отладки } if (lbEmpty && abAllowCreate && (asType[0] == L'k')) { bsText = ::SysAllocString(L"value"); hr = apFrom->selectNodes(bsText, &pList); ::SysFreeString(bsText); bsText = NULL; if (SUCCEEDED(hr) && pList) { hr = pList->reset(); if ((hr = pList->nextNode(&pIXMLDOMNode)) == S_OK && pIXMLDOMNode) { lbEmpty = FALSE; pIXMLDOMNode->Release(); pIXMLDOMNode = NULL; } pList->Release(); //pList = NULL; -- для отладки } } if (!pChild && abAllowCreate) { VARIANT vtType; vtType.vt = VT_I4; vtType.lVal = NODE_ELEMENT; bsText = ::SysAllocString(asType); hr = mp_File->createNode(vtType, bsText, L"", &pChild); ::SysFreeString(bsText); bsText = NULL; if (SUCCEEDED(hr) && pChild) { if (SetAttr(pChild, L"name", asName)) { if (asType[0] == L'k') { AppendNewLine(pChild); mb_KeyEmpty = true; } if (asType[0] == L'k') { //if (mb_KeyEmpty) //AppendIndent(apFrom, lbEmpty ? (mi_Level-1) : mi_Level); AppendIndent(apFrom, (mi_Level-1)); } else if (mb_KeyEmpty) { AppendIndent(apFrom, !lbEmpty ? (mi_Level-1) : mi_Level); } else { AppendIndent(apFrom, 1); } hr = apFrom->appendChild(pChild, &pIXMLDOMNode); pChild->Release(); pChild = NULL; if (FAILED(hr)) { pAttrs->Release(); pAttrs = NULL; } else { pChild = pIXMLDOMNode; pIXMLDOMNode = NULL; } AppendNewLine(apFrom); AppendIndent(apFrom, mi_Level-1); if ((asType[0] != L'k') && mb_KeyEmpty) mb_KeyEmpty = false; } else { pChild->Release(); pChild = NULL; } } } return pChild; }
//void SettingsXML::Save(const wchar_t *regName, const wchar_t *value) //{ // if (!value) value = L""; // сюда мог придти и NULL // // Save(regName, (LPCBYTE)value, REG_SZ, (_tcslen(value)+1)*sizeof(wchar_t)); //} void SettingsXML::Save(const wchar_t *regName, LPCBYTE value, DWORD nType, DWORD nSize) { HRESULT hr = S_OK; IXMLDOMNamedNodeMap* pAttrs = NULL; IXMLDOMNodeList* pList = NULL; IXMLDOMAttribute *pIXMLDOMAttribute = NULL; IXMLDOMNode *pNode = NULL; IXMLDOMNode* pChild = NULL; IXMLDOMNode *pNodeRmv = NULL; BSTR bsValue = NULL; BSTR bsType = NULL; bool bNeedSetType = false; // nType: // REG_DWORD: сохранение числа в 16-ричном или 10-чном формате, в зависимости от того, что сейчас указано в xml ("dword"/"ulong"/"long") // REG_BINARY: строго в hex (FF,FF,...) // REG_SZ: ASCIIZ строка, можно проконтролировать, чтобы nSize/2 не был меньше длины строки // REG_MULTI_SZ: ASCIIZZ. При формировании <list...> нужно убедиться, что мы не вылезли за пределы nSize pChild = FindItem(mp_Key, L"value", regName, true); // создать, если его еще нету if (!pChild) goto wrap; hr = pChild->get_attributes(&pAttrs); if (FAILED(hr) || !pAttrs) goto wrap; bsType = GetAttr(pChild, pAttrs, L"type"); switch(nType) { case REG_DWORD: { wchar_t szValue[32]; if (bsType && (bsType[0] == L'u' || bsType[0] == L'U')) { _wsprintf(szValue, SKIPLEN(countof(szValue)) L"%u", *(LPDWORD)value); } else if (bsType && (bsType[0] == L'l' || bsType[0] == L'L')) { _wsprintf(szValue, SKIPLEN(countof(szValue)) L"%i", *(int*)value); } else { _wsprintf(szValue, SKIPLEN(countof(szValue)) L"%08x", *(LPDWORD)value); if (bsType) ::SysFreeString(bsType); // нужно добавить/установить тип bsType = ::SysAllocString(L"dword"); bNeedSetType = true; } bsValue = ::SysAllocString(szValue); } break; case REG_BINARY: { if (nSize == 1 && bsType && (bsType[0] == L'u' || bsType[0] == L'U')) { wchar_t szValue[4]; BYTE bt = *value; _wsprintf(szValue, SKIPLEN(countof(szValue)) L"%u", (DWORD)bt); bsValue = ::SysAllocString(szValue); } else if (nSize == 1 && bsType && (bsType[0] == L'l' || bsType[0] == L'L')) { wchar_t szValue[4]; char bt = *value; _wsprintf(szValue, SKIPLEN(countof(szValue)) L"%i", (int)bt); bsValue = ::SysAllocString(szValue); } else { DWORD nLen = nSize*2 + (nSize-1); // по 2 символа на байт + ',' между ними bsValue = ::SysAllocStringLen(NULL, nLen); nLen ++; // Чтобы далее не добавлять WCHAR на '\0' wchar_t* psz = (wchar_t*)bsValue; LPCBYTE ptr = value; while(nSize) { _wsprintf(psz, SKIPLEN(nLen-(psz-bsValue)) L"%02x", (DWORD)*ptr); ptr++; nSize--; psz+=2; if (nSize) *(psz++) = L','; } if (bsType && lstrcmp(bsType, L"hex")) { // Допустим только "hex" ::SysFreeString(bsType); bsType = NULL; } if (!bsType) { // нужно добавить/установить тип bsType = ::SysAllocString(L"hex"); bNeedSetType = true; } } } break; case REG_SZ: { wchar_t* psz = (wchar_t*)value; bsValue = ::SysAllocString(psz); if (bsType && lstrcmp(bsType, L"string")) { // Допустим только "string" ::SysFreeString(bsType); bsType = NULL; } if (!bsType) { // нужно добавить/установить тип bsType = ::SysAllocString(L"string"); bNeedSetType = true; } } break; case REG_MULTI_SZ: { if (bsType && lstrcmp(bsType, L"multi")) { // Допустим только "multi" ::SysFreeString(bsType); bsType = NULL; } if (!bsType) { // нужно добавить/установить тип bsType = ::SysAllocString(L"multi"); bNeedSetType = true; } } break; default: goto wrap; // не поддерживается } if (bNeedSetType) { _ASSERTE(bsType!=NULL); SetAttr(pChild, pAttrs, L"type", bsType); ::SysFreeString(bsType); bsType = NULL; } // Теперь собственно значение if (nType != REG_MULTI_SZ) { _ASSERTE(bsValue != NULL); SetAttr(pChild, pAttrs, L"data", bsValue); ::SysFreeString(bsValue); bsValue = NULL; } else // Тут нужно формировать список элементов <list> { VARIANT_BOOL bHasChild = VARIANT_FALSE; DOMNodeType nodeType = NODE_INVALID; // Если ранее был параметр "data" - удалить его из списка атрибутов hr = pAttrs->getNamedItem(L"data", &pNode); if (SUCCEEDED(hr) && pNode) { hr = pChild->removeChild(pNode, &pNodeRmv); pNode->Release(); pNode = NULL; if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; } } //TODO: может оставить перевод строки? // Сначала почистим #ifdef _DEBUG hr = pChild->get_nodeType(&nodeType); #endif hr = pChild->hasChildNodes(&bHasChild); if (bHasChild) { while((hr = pChild->get_firstChild(&pNode)) == S_OK && pNode) { hr = pNode->get_nodeType(&nodeType); #ifdef _DEBUG BSTR bsDebug = NULL; pNode->get_text(&bsDebug); if (bsDebug) ::SysFreeString(bsDebug); bsDebug = NULL; #endif hr = pChild->removeChild(pNode, &pNodeRmv); if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; } pNode->Release(); pNode = NULL; } } // Теперь - добавляем список wchar_t* psz = (wchar_t*)value; BSTR bsNodeType = ::SysAllocString(L"line"); VARIANT vtType; vtType.vt = VT_I4; vtType.lVal = NODE_ELEMENT; long nAllLen = nSize/2; // длина в wchar_t long nLen = 0; while(psz && *psz && nAllLen > 0) { hr = mp_File->createNode(vtType, bsNodeType, L"", &pNode); if (FAILED(hr) || !pNode) break; if (!SetAttr(pNode, L"data", psz)) break; hr = pChild->appendChild(pNode, &pNodeRmv); pNode->Release(); pNode = NULL; if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; } if (FAILED(hr)) break; nLen = _tcslen(psz)+1; psz += nLen; nAllLen -= nLen; } _ASSERTE(nAllLen <= 1); } mb_Modified = true; wrap: if (pIXMLDOMAttribute) { pIXMLDOMAttribute->Release(); pIXMLDOMAttribute = NULL; } if (pNode) { pNode->Release(); pNode = NULL; } if (pNodeRmv) { pNodeRmv->Release(); pNodeRmv = NULL; } if (pChild) { pChild->Release(); pChild = NULL; } if (pAttrs) { pAttrs->Release(); pAttrs = NULL; } if (bsValue) { ::SysFreeString(bsValue); bsValue = NULL; } if (bsType) { ::SysFreeString(bsType); bsType = NULL; } }
bool SettingsXML::Load(const wchar_t *regName, LPBYTE value, DWORD nSize) { bool lbRc = false; HRESULT hr = S_OK; IXMLDOMNode* pChild = NULL; IXMLDOMNamedNodeMap* pAttrs = NULL; IXMLDOMAttribute *pIXMLDOMAttribute = NULL; IXMLDOMNode *pNode = NULL; BSTR bsType = NULL; BSTR bsData = NULL; if (!value || !nSize) return false; if (mp_Key) pChild = FindItem(mp_Key, L"value", regName, false); if (!pChild) return false; hr = pChild->get_attributes(&pAttrs); if (SUCCEEDED(hr) && pAttrs) { bsType = GetAttr(pChild, pAttrs, L"type"); } if (SUCCEEDED(hr) && bsType) { bsData = GetAttr(pChild, pAttrs, L"data"); } if (SUCCEEDED(hr) && bsData) { if (!lstrcmpi(bsType, L"string")) { #ifdef _DEBUG DWORD nLen = _tcslen(bsData) + 1; #endif DWORD nMaxLen = nSize / 2; lstrcpyn((wchar_t*)value, bsData, nMaxLen); lbRc = true; } else if (!lstrcmpi(bsType, L"ulong")) { wchar_t* pszEnd = NULL; DWORD lVal = wcstoul(bsData, &pszEnd, 10); if (nSize > 4) nSize = 4; if (pszEnd && pszEnd != bsData) { memmove(value, &lVal, nSize); lbRc = true; } } else if (!lstrcmpi(bsType, L"long")) { wchar_t* pszEnd = NULL; int lVal = wcstol(bsData, &pszEnd, 10); if (nSize > 4) nSize = 4; if (pszEnd && pszEnd != bsData) { memmove(value, &lVal, nSize); lbRc = true; } } else if (!lstrcmpi(bsType, L"dword")) { wchar_t* pszEnd = NULL; DWORD lVal = wcstoul(bsData, &pszEnd, 16); if (nSize > 4) nSize = 4; if (pszEnd && pszEnd != bsData) { memmove(value, &lVal, nSize); lbRc = true; } } else if (!lstrcmpi(bsType, L"hex")) { wchar_t* pszCur = bsData; wchar_t* pszEnd = NULL; LPBYTE pCur = value; wchar_t cHex; DWORD lVal = 0; lbRc = true; while (*pszCur && nSize) { lVal = 0; cHex = *(pszCur++); if (cHex >= L'0' && cHex <= L'9') { lVal = cHex - L'0'; } else if (cHex >= L'a' && cHex <= L'f') { lVal = cHex - L'a' + 10; } else if (cHex >= L'A' && cHex <= L'F') { lVal = cHex - L'A' + 10; } else { lbRc = false; break; } cHex = *(pszCur++); if (cHex && cHex != L',') { lVal = lVal << 4; if (cHex >= L'0' && cHex <= L'9') { lVal |= cHex - L'0'; } else if (cHex >= L'a' && cHex <= L'f') { lVal |= cHex - L'a' + 10; } else if (cHex >= L'A' && cHex <= L'F') { lVal |= cHex - L'A' + 10; } else { lbRc = false; break; } cHex = *(pszCur++); } *pCur = (BYTE)lVal; pCur++; nSize--; if (cHex != L',') { break; } } while(nSize--) // очистить хвост *(pCur++) = 0; } } // Остальные типы (строки) - не интересуют if (bsType) { ::SysFreeString(bsType); bsType = NULL; } if (bsData) { ::SysFreeString(bsData); bsData = NULL; } if (pChild) { pChild->Release(); pChild = NULL; } if (pAttrs) { pAttrs->Release(); pAttrs = NULL; } return lbRc; }
// эта функция, если значения нет (или тип некорректный) *value НЕ трогает bool SettingsXML::Load(const wchar_t *regName, wchar_t **value) { bool lbRc = false; HRESULT hr = S_OK; IXMLDOMNode* pChild = NULL; IXMLDOMNamedNodeMap* pAttrs = NULL; IXMLDOMAttribute *pIXMLDOMAttribute = NULL; IXMLDOMNode *pNode = NULL; IXMLDOMNodeList* pList = NULL; BSTR bsType = NULL; BSTR bsData = NULL; size_t nLen = 0; //if (*value) {free(*value); *value = NULL;} if (mp_Key) pChild = FindItem(mp_Key, L"value", regName, false); if (!pChild) return false; hr = pChild->get_attributes(&pAttrs); if (SUCCEEDED(hr) && pAttrs) { bsType = GetAttr(pChild, pAttrs, L"type"); } if (SUCCEEDED(hr) && bsType) { if (!lstrcmpi(bsType, L"multi")) { // Тут значения хранятся так: //<value name="CmdLineHistory" type="multi"> // <line data="C:\Far\Far.exe"/> // <line data="cmd"/> //</value> wchar_t *pszData = NULL, *pszCur = NULL; size_t nMaxLen = 0, nCurLen = 0; long nCount = 0; if (pAttrs) { pAttrs->Release(); pAttrs = NULL; } // Получить все дочерние элементы нужного типа bsData = ::SysAllocString(L"line"); hr = pChild->selectNodes(bsData, &pList); ::SysFreeString(bsData); bsData = NULL; if (SUCCEEDED(hr) && pList) { hr = pList->get_length(&nCount); if (SUCCEEDED(hr) && nCount > 0) { HEAPVAL; nMaxLen = ((MAX_PATH+1) * nCount) + 1; pszData = (wchar_t*)malloc(nMaxLen * sizeof(wchar_t)); pszCur = pszData; pszCur[0] = 0; pszCur[1] = 0; nCurLen = 2; // сразу посчитать DoubleZero HEAPVAL; } } if (SUCCEEDED(hr) && pList) { hr = pList->reset(); while((hr = pList->nextNode(&pNode)) == S_OK && pNode) { bsData = GetAttr(pNode, L"data"); pNode->Release(); pNode = NULL; if (SUCCEEDED(hr) && bsData) { nLen = _tcslen(bsData) + 1; if ((nCurLen + nLen) > nMaxLen) { // Нужно пересоздать! nMaxLen = nCurLen + nLen + MAX_PATH + 1; wchar_t *psz = (wchar_t*)malloc(nMaxLen * sizeof(wchar_t)); _ASSERTE(psz); if (!psz) break; // Не удалось выделить память! wmemmove(psz, pszData, nCurLen); pszCur = psz + (pszCur - pszData); HEAPVAL; free(pszData); pszData = psz; HEAPVAL; } lstrcpy(pszCur, bsData); pszCur += nLen; // указатель - на место для следующей строки nCurLen += nLen; *pszCur = 0; // ASCIIZZ HEAPVAL; ::SysFreeString(bsData); bsData = NULL; } } pList->Release(); pList = NULL; } // значит что-то прочитать удалось if (pszData) { if (*value) {free(*value); *value = NULL;} *value = pszData; lbRc = true; } } else if (!lstrcmpi(bsType, L"string")) { bsData = GetAttr(pChild, pAttrs, L"data"); if (SUCCEEDED(hr) && bsData) { nLen = _tcslen(bsData); if (*value) {free(*value); *value = NULL;} *value = (wchar_t*)malloc((nLen+2)*sizeof(wchar_t)); lstrcpy(*value, bsData); (*value)[nLen] = 0; // уже должен быть после lstrcpy (*value)[nLen+1] = 0; // ASCIIZZ lbRc = true; } } // Все остальные типы - не интересуют. Нам нужны только строки } if (bsType) { ::SysFreeString(bsType); bsType = NULL; } if (bsData) { ::SysFreeString(bsData); bsData = NULL; } if (pChild) { pChild->Release(); pChild = NULL; } if (pAttrs) { pAttrs->Release(); pAttrs = NULL; } //if (!lbRc) //{ // _ASSERTE(*value == NULL); // *value = (wchar_t*)malloc(sizeof(wchar_t)*2); // (*value)[0] = 0; (*value)[1] = 0; // На случай REG_MULTI_SZ //} return lbRc; }
HRESULT LoopbackCapture( IMMDevice *pMMDevice, bool bInt16, HANDLE hStartedEvent, HANDLE hStopEvent, PUINT32 pnFrames, bool bMono, INT32 iSampleRateDivisor ) { HRESULT hr; SimpleTcpServer server; // Wait for client connection before attempting any audio capture server.setup(); server.waitForClient(); // activate an IAudioClient IAudioClient *pAudioClient; hr = pMMDevice->Activate( __uuidof(IAudioClient), CLSCTX_ALL, NULL, (void**)&pAudioClient ); if (FAILED(hr)) { printf("IMMDevice::Activate(IAudioClient) failed: hr = 0x%08x", hr); return hr; } // get the default device periodicity REFERENCE_TIME hnsDefaultDevicePeriod; hr = pAudioClient->GetDevicePeriod(&hnsDefaultDevicePeriod, NULL); if (FAILED(hr)) { printf("IAudioClient::GetDevicePeriod failed: hr = 0x%08x\n", hr); pAudioClient->Release(); return hr; } // get the default device format WAVEFORMATEX *pwfx; hr = pAudioClient->GetMixFormat(&pwfx); if (FAILED(hr)) { printf("IAudioClient::GetMixFormat failed: hr = 0x%08x\n", hr); CoTaskMemFree(pwfx); pAudioClient->Release(); return hr; } if (bInt16) { // coerce int-16 wave format // can do this in-place since we're not changing the size of the format // also, the engine will auto-convert from float to int for us switch (pwfx->wFormatTag) { case WAVE_FORMAT_IEEE_FLOAT: pwfx->wFormatTag = WAVE_FORMAT_PCM; pwfx->wBitsPerSample = 16; pwfx->nBlockAlign = pwfx->nChannels * pwfx->wBitsPerSample / 8; pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec; break; case WAVE_FORMAT_EXTENSIBLE: { // naked scope for case-local variable PWAVEFORMATEXTENSIBLE pEx = reinterpret_cast<PWAVEFORMATEXTENSIBLE>(pwfx); if (IsEqualGUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, pEx->SubFormat)) { pEx->SubFormat = KSDATAFORMAT_SUBTYPE_PCM; pEx->Samples.wValidBitsPerSample = 16; pwfx->wBitsPerSample = 16; pwfx->nBlockAlign = pwfx->nChannels * pwfx->wBitsPerSample / 8; pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec; } else { printf("Don't know how to coerce mix format to int-16\n"); CoTaskMemFree(pwfx); pAudioClient->Release(); return E_UNEXPECTED; } } break; default: printf("Don't know how to coerce WAVEFORMATEX with wFormatTag = 0x%08x to int-16\n", pwfx->wFormatTag); CoTaskMemFree(pwfx); pAudioClient->Release(); return E_UNEXPECTED; } } // create a periodic waitable timer HANDLE hWakeUp = CreateWaitableTimer(NULL, FALSE, NULL); if (NULL == hWakeUp) { DWORD dwErr = GetLastError(); printf("CreateWaitableTimer failed: last error = %u\n", dwErr); CoTaskMemFree(pwfx); pAudioClient->Release(); return HRESULT_FROM_WIN32(dwErr); } UINT32 nBlockAlign = pwfx->nBlockAlign; UINT32 nBufferSize; *pnFrames = 0; // call IAudioClient::Initialize // note that AUDCLNT_STREAMFLAGS_LOOPBACK and AUDCLNT_STREAMFLAGS_EVENTCALLBACK // do not work together... // the "data ready" event never gets set // so we're going to do a timer-driven loop hr = pAudioClient->Initialize( AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_LOOPBACK, 0, 0, pwfx, 0 ); if (FAILED(hr)) { printf("IAudioClient::Initialize failed: hr = 0x%08x\n", hr); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } CoTaskMemFree(pwfx); // Get the buffer size hr = pAudioClient->GetBufferSize(&nBufferSize); if (FAILED(hr)) { printf("IAudioClient::GetBufferSize failed: hr = 0x%08x\n", hr); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } // Configure the server. The buffer size returned is in frames // so assume stereo, 16 bits per sample to convert from frames to bytes server.configure( bMono, iSampleRateDivisor, nBufferSize * 2 * 2); // activate an IAudioCaptureClient IAudioCaptureClient *pAudioCaptureClient; hr = pAudioClient->GetService( __uuidof(IAudioCaptureClient), (void**)&pAudioCaptureClient ); if (FAILED(hr)) { printf("IAudioClient::GetService(IAudioCaptureClient) failed: hr 0x%08x\n", hr); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } // register with MMCSS DWORD nTaskIndex = 0; HANDLE hTask = AvSetMmThreadCharacteristics(L"Capture", &nTaskIndex); if (NULL == hTask) { DWORD dwErr = GetLastError(); printf("AvSetMmThreadCharacteristics failed: last error = %u\n", dwErr); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return HRESULT_FROM_WIN32(dwErr); } // set the waitable timer LARGE_INTEGER liFirstFire; liFirstFire.QuadPart = -hnsDefaultDevicePeriod / 2; // negative means relative time LONG lTimeBetweenFires = (LONG)hnsDefaultDevicePeriod / 2 / (10 * 1000); // convert to milliseconds BOOL bOK = SetWaitableTimer( hWakeUp, &liFirstFire, lTimeBetweenFires, NULL, NULL, FALSE ); if (!bOK) { DWORD dwErr = GetLastError(); printf("SetWaitableTimer failed: last error = %u\n", dwErr); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return HRESULT_FROM_WIN32(dwErr); } // call IAudioClient::Start hr = pAudioClient->Start(); if (FAILED(hr)) { printf("IAudioClient::Start failed: hr = 0x%08x\n", hr); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } SetEvent(hStartedEvent); // loopback capture loop HANDLE waitArray[2] = { hStopEvent, hWakeUp }; DWORD dwWaitResult; bool bDone = false; for (UINT32 nPasses = 0; !bDone; nPasses++) { // drain data while it is available UINT32 nNextPacketSize; for ( hr = pAudioCaptureClient->GetNextPacketSize(&nNextPacketSize); SUCCEEDED(hr) && nNextPacketSize > 0; hr = pAudioCaptureClient->GetNextPacketSize(&nNextPacketSize) ) { // get the captured data BYTE *pData; UINT32 nNumFramesToRead; DWORD dwFlags; hr = pAudioCaptureClient->GetBuffer( &pData, &nNumFramesToRead, &dwFlags, NULL, NULL ); if (FAILED(hr)) { printf("IAudioCaptureClient::GetBuffer failed on pass %u after %u frames: hr = 0x%08x\n", nPasses, *pnFrames, hr); pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } #ifdef _DEBUG if (0 != dwFlags) { printf("[ignoring] IAudioCaptureClient::GetBuffer set flags to 0x%08x on pass %u after %u frames\n", dwFlags, nPasses, *pnFrames); } #endif if (0 == nNumFramesToRead) { printf("IAudioCaptureClient::GetBuffer said to read 0 frames on pass %u after %u frames\n", nPasses, *pnFrames); pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return E_UNEXPECTED; } LONG lBytesToWrite = nNumFramesToRead * nBlockAlign; if (server.sendData(reinterpret_cast<const char*>(pData), lBytesToWrite) != 0) { printf("Error sending data to peer\n"); pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return E_UNEXPECTED; } *pnFrames += nNumFramesToRead; hr = pAudioCaptureClient->ReleaseBuffer(nNumFramesToRead); if (FAILED(hr)) { printf("IAudioCaptureClient::ReleaseBuffer failed on pass %u after %u frames: hr = 0x%08x\n", nPasses, *pnFrames, hr); pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } } if (FAILED(hr)) { printf("IAudioCaptureClient::GetNextPacketSize failed on pass %u after %u frames: hr = 0x%08x\n", nPasses, *pnFrames, hr); pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return hr; } dwWaitResult = WaitForMultipleObjects( ARRAYSIZE(waitArray), waitArray, FALSE, INFINITE ); if (WAIT_OBJECT_0 == dwWaitResult) { printf("Received stop event after %u passes and %u frames\n", nPasses, *pnFrames); bDone = true; continue; // exits loop } if (WAIT_OBJECT_0 + 1 != dwWaitResult) { printf("Unexpected WaitForMultipleObjects return value %u on pass %u after %u frames\n", dwWaitResult, nPasses, *pnFrames); pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); return E_UNEXPECTED; } } // capture loop pAudioClient->Stop(); CancelWaitableTimer(hWakeUp); AvRevertMmThreadCharacteristics(hTask); pAudioCaptureClient->Release(); CloseHandle(hWakeUp); pAudioClient->Release(); server.shutdown(); return hr; }
BOOL CDxtexDoc::OnNewDocument() { HRESULT hr; LPDIRECT3DDEVICE9 pd3ddev = PDxtexApp()->Pd3ddev(); if (!CDocument::OnNewDocument()) return FALSE; CNewTextureDlg dlg; // Obtain maximum texture dimension D3DCAPS9 d3dcaps; if ( SUCCEEDED( pd3ddev->GetDeviceCaps( &d3dcaps ) ) ) { dlg.SetMaxTextureSize( d3dcaps.MaxTextureWidth, d3dcaps.MaxTextureHeight ); } if (IDCANCEL == dlg.DoModal()) return FALSE; m_dwWidth = dlg.m_dwWidth; m_dwHeight = dlg.m_dwHeight; m_numMips = dlg.m_numMips; if (dlg.m_iTexType == 0) { LPDIRECT3DTEXTURE9 pmiptex; hr = pd3ddev->CreateTexture(m_dwWidth, m_dwHeight, m_numMips, 0, dlg.m_fmt, D3DPOOL_MANAGED, &pmiptex, NULL); if (FAILED(hr)) { AfxMessageBox(ID_ERROR_CANTCREATETEXTURE); return FALSE; } m_ptexOrig = pmiptex; } else if (dlg.m_iTexType == 1) { // Cube Map LPDIRECT3DCUBETEXTURE9 pcubetex; m_dwCubeMapFlags = DDS_CUBEMAP_ALLFACES; hr = pd3ddev->CreateCubeTexture(m_dwWidth, m_numMips, 0, dlg.m_fmt, D3DPOOL_MANAGED, &pcubetex, NULL); if (FAILED(hr)) { AfxMessageBox(ID_ERROR_CANTCREATETEXTURE); return FALSE; } m_ptexOrig = pcubetex; } else { LPDIRECT3DVOLUMETEXTURE9 pvoltex; m_dwDepth = dlg.m_dwDepth; hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, m_dwDepth, m_numMips, 0, dlg.m_fmt, D3DPOOL_SYSTEMMEM, &pvoltex, NULL); if (FAILED(hr)) { AfxMessageBox(ID_ERROR_CANTCREATETEXTURE); return FALSE; } m_ptexOrig = pvoltex; } return TRUE; }
// // Name: // CTestSuiteItemCollection::LoadFromRegistry // // Description: // Loads the category information from the registry. Used to initialize // the list of categories. // // Results: // // S_OK - All is well // REGDB_E_KEYMISSING - Could not open the registry key. // E_UNEXPECTED - An unknown exception has been caught. // STDMETHODIMP CTestSuiteItemCollection::LoadFromRegistry() { HRESULT hr = S_OK; try { CComPtr<ICatInformation> pCatInfo; hr = pCatInfo.CoCreateInstance(CLSID_StdComponentCategoriesMgr); CHECK_HR(hr); CComPtr<IEnumCLSID> pEnumClsId; CATID rgcid[1]; rgcid[0] = CATID_Test; // Find all the clsids for the CATID_Test category hr = pCatInfo->EnumClassesOfCategories(1, rgcid, -1, 0, &pEnumClsId); CHECK_HR(hr); enum{MAX_CNT = 64}; CLSID rgClsId[MAX_CNT]; do { // For each item in the collection create a ITestSuiteItem and place it into // the collection ULONG cActual = 0L; hr = pEnumClsId->Next(MAX_CNT, rgClsId, &cActual); if(SUCCEEDED(hr)) { for(ULONG l = 0; l < cActual; l++) { CComPtr<ICustomTestSuiteItem> pCustomItem; hr = pCustomItem.CoCreateInstance(__uuidof(CTestSuiteItem)); CHECK_HR(hr); // Get the clsid pCustomItem->put_Clsid(rgClsId[l]); CComPtr<ITestSuiteItem> pItem; pCustomItem.QueryInterface(&pItem); // Get the description CComBSTR bstrName; CComBSTR bstrDescription; getTestInformation(rgClsId[l], bstrName, bstrDescription); LPOLESTR szProgId; ::ProgIDFromCLSID(rgClsId[l], &szProgId); pItem->put_ProgId(szProgId); ::CoTaskMemFree(szProgId); pItem->put_TestName(bstrName); pItem->put_Description(bstrDescription); // add it to the collection Add(pItem); } } }while(hr == S_OK); } catch(HRESULT hr) { // // Fix Me! // Make this a more meningful message // // Jerry Edens, 10/22/99 1:52:59 PM // ATLTRACE("Error 0x%8x\n", hr); } catch(_com_error& rerr) { ATLTRACE("Error 0x%8x\n", rerr.Error()); } catch(...) { hr = E_UNEXPECTED; } return hr; }
STDAPI AMovieSetupRegisterServer( CLSID clsServer , LPCWSTR szDescription , LPCWSTR szFileName , LPCWSTR szThreadingModel = L"Both" , LPCWSTR szServerType = L"InprocServer32" ) { // temp buffer // TCHAR achTemp[MAX_PATH]; // convert CLSID uuid to string and write // out subkey as string - CLSID\{} // OLECHAR szCLSID[CHARS_IN_GUID]; HRESULT hr = StringFromGUID2( clsServer , szCLSID , CHARS_IN_GUID ); ASSERT( SUCCEEDED(hr) ); // create key // HKEY hkey; wsprintf( achTemp, TEXT("CLSID\\%ls"), szCLSID ); LONG lreturn = RegCreateKey( HKEY_CLASSES_ROOT , (LPCTSTR)achTemp , &hkey ); if( ERROR_SUCCESS != lreturn ) { return AmHresultFromWin32(lreturn); } // set description string // wsprintf( achTemp, TEXT("%ls"), szDescription ); lreturn = RegSetValue( hkey , (LPCTSTR)NULL , REG_SZ , achTemp , sizeof(achTemp) ); if( ERROR_SUCCESS != lreturn ) { RegCloseKey( hkey ); return AmHresultFromWin32(lreturn); } // create CLSID\\{"CLSID"}\\"ServerType" key, // using key to CLSID\\{"CLSID"} passed back by // last call to RegCreateKey(). // HKEY hsubkey; wsprintf( achTemp, TEXT("%ls"), szServerType ); lreturn = RegCreateKey( hkey , achTemp , &hsubkey ); if( ERROR_SUCCESS != lreturn ) { RegCloseKey( hkey ); return AmHresultFromWin32(lreturn); } // set Server string // wsprintf( achTemp, TEXT("%ls"), szFileName ); lreturn = RegSetValue( hsubkey , (LPCTSTR)NULL , REG_SZ , (LPCTSTR)achTemp , sizeof(TCHAR) * (lstrlen(achTemp)+1) ); if( ERROR_SUCCESS != lreturn ) { RegCloseKey( hkey ); RegCloseKey( hsubkey ); return AmHresultFromWin32(lreturn); } wsprintf( achTemp, TEXT("%ls"), szThreadingModel ); lreturn = RegSetValueEx( hsubkey , TEXT("ThreadingModel") , 0L , REG_SZ , (CONST BYTE *)achTemp , sizeof(TCHAR) * (lstrlen(achTemp)+1) ); // close hkeys // RegCloseKey( hkey ); RegCloseKey( hsubkey ); // and return // return HRESULT_FROM_WIN32(lreturn); }
//====================================================================== bool loadFile (const String& fileOrURLPath) { jassert (state == uninitializedState); if (! createNativeWindow()) return false; HRESULT hr = graphBuilder.CoCreateInstance (CLSID_FilterGraph); // basic playback interfaces if (SUCCEEDED (hr)) hr = graphBuilder.QueryInterface (mediaControl); if (SUCCEEDED (hr)) hr = graphBuilder.QueryInterface (mediaPosition); if (SUCCEEDED (hr)) hr = graphBuilder.QueryInterface (mediaEvent); if (SUCCEEDED (hr)) hr = graphBuilder.QueryInterface (basicAudio); // video renderer interface if (SUCCEEDED (hr)) { #if JUCE_MEDIAFOUNDATION if (type == dshowEVR) videoRenderer = new DirectShowHelpers::EVR(); else #endif videoRenderer = new DirectShowHelpers::VMR7(); hr = videoRenderer->create (graphBuilder, baseFilter, hwnd); } // build filter graph if (SUCCEEDED (hr)) hr = graphBuilder->RenderFile (fileOrURLPath.toWideCharPointer(), nullptr); // remove video renderer if not connected (no video) if (SUCCEEDED (hr)) { if (isRendererConnected()) { hasVideo = true; hr = videoRenderer->getVideoSize (videoWidth, videoHeight); } else { hasVideo = false; graphBuilder->RemoveFilter (baseFilter); videoRenderer = nullptr; baseFilter = nullptr; } } // set window to receive events if (SUCCEEDED (hr)) hr = mediaEvent->SetNotifyWindow ((OAHWND) hwnd, graphEventID, 0); if (SUCCEEDED (hr)) { state = stoppedState; return true; } release(); return false; }
STDAPI AMovieDllRegisterServer2( BOOL bRegister ) { HRESULT hr = NOERROR; DbgLog((LOG_TRACE, 2, TEXT("AMovieDllRegisterServer2()"))); // get file name (where g_hInst is the // instance handle of the filter dll) // WCHAR achFileName[MAX_PATH]; // WIN95 doesn't support GetModuleFileNameW // { char achTemp[MAX_PATH]; DbgLog((LOG_TRACE, 2, TEXT("- get module file name"))); // g_hInst handle is set in our dll entry point. Make sure // DllEntryPoint in dllentry.cpp is called ASSERT(g_hInst != 0); if( 0 == GetModuleFileNameA( g_hInst , achTemp , sizeof(achTemp) ) ) { // we've failed! DWORD dwerr = GetLastError(); return AmHresultFromWin32(dwerr); } MultiByteToWideChar( CP_ACP , 0L , achTemp , lstrlenA(achTemp) + 1 , achFileName , NUMELMS(achFileName) ); } // // first registering, register all OLE servers // if( bRegister ) { DbgLog((LOG_TRACE, 2, TEXT("- register OLE Servers"))); hr = RegisterAllServers( achFileName, TRUE ); } // // next, register/unregister all filters // if( SUCCEEDED(hr) ) { // init is ref counted so call just in case // we're being called cold. // DbgLog((LOG_TRACE, 2, TEXT("- CoInitialize"))); hr = CoInitialize( (LPVOID)NULL ); ASSERT( SUCCEEDED(hr) ); // get hold of IFilterMapper2 // DbgLog((LOG_TRACE, 2, TEXT("- obtain IFilterMapper2"))); IFilterMapper2 *pIFM2 = 0; IFilterMapper *pIFM = 0; hr = CoCreateInstance( CLSID_FilterMapper2 , NULL , CLSCTX_INPROC_SERVER , IID_IFilterMapper2 , (void **)&pIFM2 ); if(FAILED(hr)) { DbgLog((LOG_TRACE, 2, TEXT("- trying IFilterMapper instead"))); hr = CoCreateInstance( CLSID_FilterMapper, NULL, CLSCTX_INPROC_SERVER, IID_IFilterMapper, (void **)&pIFM); } if( SUCCEEDED(hr) ) { // scan through array of CFactoryTemplates // registering servers and filters. // DbgLog((LOG_TRACE, 2, TEXT("- register Filters"))); for( int i = 0; i < g_cTemplates; i++ ) { // get i'th template // const CFactoryTemplate *pT = &g_Templates[i]; if( NULL != pT->m_pAMovieSetup_Filter ) { DbgLog((LOG_TRACE, 2, TEXT("- - register %ls"), (LPCWSTR)pT->m_Name )); if(pIFM2) { hr = AMovieSetupRegisterFilter2( pT->m_pAMovieSetup_Filter, pIFM2, bRegister ); } else { hr = AMovieSetupRegisterFilter( pT->m_pAMovieSetup_Filter, pIFM, bRegister ); } } // check final error for this pass // and break loop if we failed // if( FAILED(hr) ) break; } // release interface // if(pIFM2) pIFM2->Release(); else pIFM->Release(); } // and clear up // CoFreeUnusedLibraries(); CoUninitialize(); } // // if unregistering, unregister all OLE servers // if( SUCCEEDED(hr) && !bRegister ) { DbgLog((LOG_TRACE, 2, TEXT("- register OLE Servers"))); hr = RegisterAllServers( achFileName, FALSE ); } DbgLog((LOG_TRACE, 2, TEXT("- return %0x"), hr)); return hr; }
HRESULT CMyDevice::Initialize( _In_ IWDFDriver * FxDriver, _In_ IWDFDeviceInitialize * FxDeviceInit ) /*++ Routine Description: This method initializes the device callback object and creates the partner device object. The method should perform any device-specific configuration that: * could fail (these can't be done in the constructor) * must be done before the partner object is created -or- * can be done after the partner object is created and which aren't influenced by any device-level parameters the parent (the driver in this case) might set. Arguments: FxDeviceInit - the settings for this device. Return Value: status. --*/ { IWDFDevice *fxDevice; HRESULT hr; // // Configure things like the locking model before we go to create our // partner device. // // // Set no locking unless you need an automatic callbacks synchronization // FxDeviceInit->SetLockingConstraint(None); // // TODO: If you're writing a filter driver then indicate that here. // // FxDeviceInit->SetFilter(); // // // TODO: Any per-device initialization which must be done before // creating the partner object. // // // Create a new FX device object and assign the new callback object to // handle any device level events that occur. // // // QueryIUnknown references the IUnknown interface that it returns // (which is the same as referencing the device). We pass that to // CreateDevice, which takes its own reference if everything works. // { IUnknown *unknown = this->QueryIUnknown(); hr = FxDriver->CreateDevice(FxDeviceInit, unknown, &fxDevice); unknown->Release(); } // // If that succeeded then set our FxDevice member variable. // if (SUCCEEDED(hr)) { m_FxDevice = fxDevice; // // Drop the reference we got from CreateDevice. Since this object // is partnered with the framework object they have the same // lifespan - there is no need for an additional reference. // fxDevice->Release(); } return hr; }
STDAPI AMovieDllRegisterServer( void ) { HRESULT hr = NOERROR; // get file name (where g_hInst is the // instance handle of the filter dll) // WCHAR achFileName[MAX_PATH]; { // WIN95 doesn't support GetModuleFileNameW // char achTemp[MAX_PATH]; if( 0 == GetModuleFileNameA( g_hInst , achTemp , sizeof(achTemp) ) ) { // we've failed! DWORD dwerr = GetLastError(); return AmHresultFromWin32(dwerr); } MultiByteToWideChar( CP_ACP , 0L , achTemp , lstrlenA(achTemp) + 1 , achFileName , NUMELMS(achFileName) ); } // scan through array of CFactoryTemplates // registering servers and filters. // for( int i = 0; i < g_cTemplates; i++ ) { // get i'th template // const CFactoryTemplate *pT = &g_Templates[i]; // register CLSID and InprocServer32 // hr = AMovieSetupRegisterServer( *(pT->m_ClsID) , (LPCWSTR)pT->m_Name , achFileName ); // instantiate all servers and get hold of // IAMovieSetup, if implemented, and call // IAMovieSetup.Register() method // if( SUCCEEDED(hr) && (NULL != pT->m_lpfnNew) ) { // instantiate object // PAMOVIESETUP psetup; hr = CoCreateInstance( *(pT->m_ClsID) , 0 , CLSCTX_INPROC_SERVER , IID_IAMovieSetup , reinterpret_cast<void**>(&psetup) ); if( SUCCEEDED(hr) ) { hr = psetup->Unregister(); if( SUCCEEDED(hr) ) hr = psetup->Register(); psetup->Release(); } else { if( (E_NOINTERFACE == hr ) || (VFW_E_NEED_OWNER == hr ) ) hr = NOERROR; } } // check final error for this pass // and break loop if we failed // if( FAILED(hr) ) break; } // end-for return hr; }
JNIEXPORT jstring JNICALL Java_jmtp_PortableDeviceContentImplWin32_createObjectWithPropertiesAndData (JNIEnv* env, jobject obj, jobject jobjValues, jobject jobjFile) { //variabelen HRESULT hr; IPortableDeviceContent* pDeviceContent; IPortableDeviceValues* pDeviceObjectValues; jobject jobjValuesReference; jstring jsFileLocation; LPWSTR wszFileLocation; DWORD dwBufferSize; CComPtr<IStream> pFileStream; CComPtr<IStream> pDeviceStream; CComPtr<IPortableDeviceDataStream> pDeviceDataStream; STATSTG fileStats; BYTE* pBuffer; DWORD dwReadFromStream; LPWSTR wszObjectID; jstring jsObjectID; jmethodID mid; //Methode implementatie pDeviceContent = GetPortableDeviceContent(env, obj); jobjValuesReference = RetrieveCOMReferenceFromCOMReferenceable(env, jobjValues); pDeviceObjectValues = (IPortableDeviceValues*)ConvertComReferenceToPointer(env, jobjValuesReference); //COM stream object aanmaken mid = env->GetMethodID(env->FindClass("java/io/File"), "getAbsolutePath", "()Ljava/lang/String;"); jsFileLocation = (jstring)env->CallObjectMethod(jobjFile, mid); wszFileLocation = (WCHAR*)env->GetStringChars(jsFileLocation, NULL); hr = SHCreateStreamOnFileW(wszFileLocation, STGM_READ, &pFileStream); env->ReleaseStringChars(jsFileLocation, (jchar*)wszFileLocation); //string resources terug vrijgeven if(SUCCEEDED(hr)) { //groote van het bestand bepalen //(door een beperking in java op het gebied van unsigned integers, moeten we het wel in c++ doen) pFileStream->Stat(&fileStats, STATFLAG_NONAME); pDeviceObjectValues->SetUnsignedLargeIntegerValue(WPD_OBJECT_SIZE, fileStats.cbSize.QuadPart); hr = pDeviceContent->CreateObjectWithPropertiesAndData(pDeviceObjectValues, &pDeviceStream, &dwBufferSize, NULL); if(SUCCEEDED(hr)) { pDeviceStream->QueryInterface(IID_IPortableDeviceDataStream, (void**)&pDeviceDataStream); //data kopieren pBuffer = new BYTE[dwBufferSize]; dwReadFromStream = 0; do { pFileStream->Read(pBuffer, dwBufferSize, &dwReadFromStream); pDeviceDataStream->Write(pBuffer, dwReadFromStream, NULL); } while(dwReadFromStream > 0); delete[] pBuffer; hr = pDeviceDataStream->Commit(STGC_DEFAULT); if(SUCCEEDED(hr)) { pDeviceDataStream->GetObjectID(&wszObjectID); jsObjectID = (jstring)env->NewString((jchar*)wszObjectID, wcslen(wszObjectID)); CoTaskMemFree(wszObjectID); return jsObjectID; } else { ThrowCOMException(env, L"Couldn't commit the data to the portable device", hr); } } else { ThrowCOMException(env, L"Couldn't create a COM stream object to the portable device", hr); } } else { ThrowCOMException(env, L"Couldn't create a COM stream object to the file", hr); } return NULL; }
static int MCA_do_file_dialog(MCExecPoint& ep, const char *p_title, const char *p_prompt, const char *p_filter, const char *p_initial, unsigned int p_options) { int t_result = 0; char *t_initial_file; t_initial_file = NULL; char *t_initial_folder; t_initial_folder = NULL; ep . clear(); if (*p_initial != '\0') { char *t_initial_clone; t_initial_clone = strdup(p_initial); MCU_w32path2std(t_initial_clone); MCU_fix_path(t_initial_clone); if (MCS_exists(t_initial_clone, False)) t_initial_folder = t_initial_clone; else if ((p_options & MCA_OPTION_SAVE_DIALOG) != 0) { t_initial_file = strrchr(t_initial_clone, '/'); if (t_initial_file == NULL) { if (strlen(t_initial_clone) != 0) t_initial_file = t_initial_clone; } else { *t_initial_file = '\0'; t_initial_file++; if (t_initial_file[0] == '\0') t_initial_file = NULL; if (MCS_exists(t_initial_clone, False)) t_initial_folder = t_initial_clone; } } else { char *t_leaf; t_leaf = strrchr(t_initial_clone, '/'); if (t_leaf != NULL) { *t_leaf = '\0'; if (MCS_exists(t_initial_clone, False)) t_initial_folder = t_initial_clone; } } t_initial_file = strdup(t_initial_file); t_initial_folder = MCS_resolvepath(t_initial_folder); delete t_initial_clone; } if (!MCModeMakeLocalWindows()) { char ** t_filters = NULL; uint32_t t_filter_count = 0; if (p_filter != NULL) { const char *t_strptr = p_filter; while (t_strptr[0] != '\0') { t_filter_count++; t_filters = (char**)realloc(t_filters, t_filter_count * sizeof(char*)); t_filters[t_filter_count - 1] = (char *)t_strptr; t_strptr += strlen(t_strptr) + 1; } } MCRemoteFileDialog(ep, p_title, p_prompt, t_filters, t_filter_count, t_initial_folder, t_initial_file, (p_options & MCA_OPTION_SAVE_DIALOG) != 0, (p_options & MCA_OPTION_PLURAL) != 0); free(t_filters); return 0; } Window t_window; t_window = MCModeGetParentWindow(); bool t_succeeded; int t_filter_index; if (MCmajorosversion >= 0x0600) { static SHCreateItemFromParsingNamePtr s_shcreateitemfromparsingname = NULL; if (s_shcreateitemfromparsingname == NULL) { static HMODULE s_shell32_module = NULL; s_shell32_module = LoadLibraryA("shell32.dll"); s_shcreateitemfromparsingname = (SHCreateItemFromParsingNamePtr)GetProcAddress(s_shell32_module, "SHCreateItemFromParsingName"); } IFileSaveDialog *t_file_save_dialog; IFileOpenDialog *t_file_open_dialog; IFileDialog *t_file_dialog; t_file_dialog = NULL; HRESULT t_hresult; if ((p_options & MCA_OPTION_SAVE_DIALOG) == 0) { t_hresult = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, __uuidof(IFileOpenDialog), (LPVOID *)&t_file_open_dialog); t_succeeded = SUCCEEDED(t_hresult); t_file_dialog = t_file_open_dialog; } else { t_hresult = CoCreateInstance(CLSID_FileSaveDialog, NULL, CLSCTX_INPROC_SERVER, __uuidof(IFileSaveDialog), (LPVOID *)&t_file_save_dialog); t_succeeded = SUCCEEDED(t_hresult); t_file_dialog = t_file_save_dialog; } if (t_succeeded) { DWORD t_options; t_options = FOS_FORCEFILESYSTEM | FOS_NOCHANGEDIR | FOS_PATHMUSTEXIST; if (p_options & MCA_OPTION_PLURAL) t_options |= FOS_ALLOWMULTISELECT; if (p_options & MCA_OPTION_SAVE_DIALOG) t_options |= FOS_OVERWRITEPROMPT; if (p_options & MCA_OPTION_FOLDER_DIALOG) t_options |= FOS_PICKFOLDERS; else t_options |= FOS_FILEMUSTEXIST; t_hresult = t_file_dialog -> SetOptions(t_options); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded && t_initial_folder != NULL) { IShellItem *t_initial_folder_shellitem; t_initial_folder_shellitem = NULL; t_hresult = s_shcreateitemfromparsingname(WideCString(t_initial_folder), NULL, __uuidof(IShellItem), (LPVOID *)&t_initial_folder_shellitem); if (SUCCEEDED(t_hresult)) t_file_dialog -> SetFolder(t_initial_folder_shellitem); if (t_initial_folder_shellitem != NULL) t_initial_folder_shellitem -> Release(); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded && t_initial_file != NULL) { t_hresult = t_file_dialog -> SetFileName(WideCString(t_initial_file)); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded && p_filter != NULL && (p_options & MCA_OPTION_FOLDER_DIALOG) == 0) { uint4 t_filter_length, t_filter_count; measure_filter(p_filter, t_filter_length, t_filter_count); WideCString t_filters(p_filter, t_filter_length); COMDLG_FILTERSPEC *t_filter_spec; filter_to_spec(t_filters, t_filter_count, t_filter_spec); t_hresult = t_file_dialog -> SetFileTypes(t_filter_count, t_filter_spec); t_succeeded = SUCCEEDED(t_hresult); delete t_filter_spec; } if (t_succeeded && p_filter != NULL && (p_options & MCA_OPTION_FOLDER_DIALOG) == 0) { t_hresult = t_file_dialog -> SetFileTypeIndex(1); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded) t_hresult = t_file_dialog -> SetTitle(WideCString(p_prompt)); if (t_succeeded) { t_hresult = t_file_dialog -> Show(t_window != NULL ? (HWND)t_window -> handle . window : NULL); t_succeeded = SUCCEEDED(t_hresult); } if ((p_options & MCA_OPTION_SAVE_DIALOG) == 0) { IShellItemArray *t_file_items; t_file_items = NULL; if (t_succeeded) { t_hresult = t_file_open_dialog -> GetResults(&t_file_items); t_succeeded = SUCCEEDED(t_hresult); } DWORD t_file_item_count; if (t_succeeded) { t_hresult = t_file_items -> GetCount(&t_file_item_count); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded) { ep . clear(); for(uint4 t_index = 0; t_index < t_file_item_count && t_succeeded; ++t_index) { IShellItem *t_file_item; t_file_item = NULL; if (t_succeeded) { t_hresult = t_file_items -> GetItemAt(t_index, &t_file_item); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded) { t_hresult = append_shellitem_path_and_release(ep, t_file_item, t_index == 0); t_succeeded = SUCCEEDED(t_hresult); } } } if (t_file_items != NULL) t_file_items -> Release(); } else { IShellItem *t_file_item; t_file_item = NULL; if (t_succeeded) { t_hresult = t_file_dialog -> GetResult(&t_file_item); t_succeeded = SUCCEEDED(t_hresult); } if (t_succeeded) { ep . clear(); t_hresult = append_shellitem_path_and_release(ep, t_file_item, true); t_succeeded = SUCCEEDED(t_hresult); } } t_filter_index = 0; if (t_succeeded && (p_options & MCA_OPTION_FOLDER_DIALOG) == 0) { UINT t_index; t_hresult = t_file_dialog -> GetFileTypeIndex(&t_index); t_succeeded = SUCCEEDED(t_hresult); if (t_succeeded) t_filter_index = (int)t_index; } if (t_file_dialog != NULL) t_file_dialog -> Release(); if (!t_succeeded) t_result = t_hresult; else t_result = 0; } else { OPENFILENAMEA t_open_dialog; memset(&t_open_dialog, 0, sizeof(OPENFILENAMEA)); t_open_dialog . lStructSize = sizeof(OPENFILENAMEA); char *t_initial_file_buffer = new char[MAX_PATH]; if (t_initial_file != NULL) strcpy(t_initial_file_buffer, t_initial_file); else *t_initial_file_buffer = '\0'; t_open_dialog . lpstrFilter = p_filter; t_open_dialog . nFilterIndex = 1; t_open_dialog . lpstrFile = t_initial_file_buffer; t_open_dialog . nMaxFile = MAX_PATH; t_open_dialog . lpstrInitialDir = t_initial_folder; t_open_dialog . lpstrTitle = p_prompt; t_open_dialog . Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_NOCHANGEDIR | OFN_LONGNAMES | OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_ENABLESIZING; if (p_options & MCA_OPTION_PLURAL) t_open_dialog . Flags |= OFN_ALLOWMULTISELECT; if (p_options & MCA_OPTION_SAVE_DIALOG) t_open_dialog . Flags |= OFN_OVERWRITEPROMPT; t_open_dialog . lpstrFilter = p_filter; t_open_dialog . lpfnHook = open_dialog_hook; t_open_dialog . hwndOwner = t_window != NULL ? (HWND)t_window -> handle . window : NULL; if (p_options & MCA_OPTION_SAVE_DIALOG) t_succeeded = GetSaveFileNameA((LPOPENFILENAMEA)&t_open_dialog) == TRUE; else { *t_open_dialog . lpstrFile = '\0'; t_succeeded = GetOpenFileNameA((LPOPENFILENAMEA)&t_open_dialog) == TRUE; } if (!t_succeeded) t_result = CommDlgExtendedError(); // MW-2005-07-26: Try again without the specified filename if it was invalid if (t_result == FNERR_INVALIDFILENAME) { *t_open_dialog . lpstrFile = '\0'; if (p_options & MCA_OPTION_SAVE_DIALOG) t_succeeded = GetSaveFileNameA((LPOPENFILENAMEA)&t_open_dialog) == TRUE; else t_succeeded = GetOpenFileNameA((LPOPENFILENAMEA)&t_open_dialog) == TRUE; if (!t_succeeded) t_result = CommDlgExtendedError(); } if (t_result == FNERR_BUFFERTOOSMALL) t_succeeded = true; if (t_succeeded) { build_paths(ep); t_filter_index = t_open_dialog . nFilterIndex; } delete t_initial_file_buffer; } if (t_succeeded) { if (p_options & MCA_OPTION_RETURN_FILTER) { const char *t_type = p_filter; const char *t_types = p_filter; for(int t_index = t_filter_index * 2 - 1; t_index > 1; t_types += 1) if (*t_types == '\0') t_type = t_types + 1, t_index -= 1; MCresult -> copysvalue(t_type); } t_result = 0; } waitonbutton(); if (t_initial_folder != NULL) delete t_initial_folder; if (t_initial_file != NULL) delete t_initial_file; return t_result; }
bool ENABLE_FIREWALL() { BOOL couldEnable = false; HRESULT hr = S_OK; HRESULT comInit = E_FAIL; INetFwProfile* fwProfile = NULL; // Initialize COM. #if 1 comInit = CoInitialize( 0 ); #else comInit = CoInitializeEx( 0, COINIT_APARTMENTTHREADED /*| COINIT_DISABLE_OLE1DDE */ ); #endif // Ignore RPC_E_CHANGED_MODE; this just means that COM has already been // initialized with a different mode. Since we don't care what the mode is, // we'll just use the existing mode. if (comInit != RPC_E_CHANGED_MODE) { hr = comInit; if (FAILED(hr)) { fprintf( stderr, "CoInitializeEx failed: 0x%08lx\n", hr ); goto error; } } // Retrieve the firewall profile currently in effect. hr = WindowsFirewallInitialize(&fwProfile); if (FAILED(hr)) { fprintf( stderr, "WindowsFirewallInitialize failed: 0x%08lx\n", hr ); goto error; } HMODULE hm = GetModuleHandle( 0 ); wchar_t path[512]; if( !GetModuleFileNameW( hm, path, sizeof(path)/sizeof(wchar_t) ) ) { fprintf( stderr, "GetModuleFileName() failed: 0x%lx\n", GetLastError() ); goto error; } // Add the application to the authorized application collection. hr = WindowsFirewallAddApp( fwProfile, path, L"Introduction Library User" ); if (FAILED(hr)) { fprintf( stderr, "WindowsFirewallAddApp failed: 0x%08lx\n", hr ); goto error; } error: WindowsFirewallCleanup(fwProfile); if (SUCCEEDED(comInit)) { CoUninitialize(); } return couldEnable != FALSE; }
bool VistaDirectXGamepad::InitDirectXInput() { // get window handle from touch sequence GamepadAttach *pAttach = dynamic_cast<GamepadAttach*>(m_pWindowAspect->GetTouchSequence()); if(pAttach && pAttach->m_nHwnd == 0L) return false; DIJOYCONFIG PreferredJoyCfg = {0}; DI_ENUM_CONTEXT enumContext; memset(&enumContext, 0, sizeof(DI_ENUM_CONTEXT)); enumContext.pPreferredJoyCfg = &PreferredJoyCfg; enumContext.bPreferredJoyCfgValid = false; enumContext.m_pDI = m_pDI; enumContext.m_pJoystick = m_pJoystick; IDirectInputJoyConfig8* pJoyConfig = NULL; HRESULT hr; // claim a joystick config structure hr = m_pDI->QueryInterface( IID_IDirectInputJoyConfig8, (void **) &pJoyConfig ); // fill the config structure with information from the // windows system database PreferredJoyCfg.dwSize = sizeof(PreferredJoyCfg); // simply try to claim config for joystick 0 // This function is expected to fail if no joystick is attached // as index 0 is not present if( SUCCEEDED( pJoyConfig->GetConfig(0, &PreferredJoyCfg, DIJC_GUIDINSTANCE ) ) ) enumContext.bPreferredJoyCfgValid = true; // give away this structure if(pJoyConfig) pJoyConfig->Release(); // Look for a joystick if(m_strJoyName.empty()) { hr = m_pDI->EnumDevices( DI8DEVCLASS_GAMECTRL, EnumJoysticksCallback, &enumContext, DIEDFL_ATTACHEDONLY ); } else { enumContext.m_strJoyName = m_strJoyName; enumContext.bPreferredJoyCfgValid = false; hr = m_pDI->EnumDevices( DI8DEVCLASS_GAMECTRL, FindJoysticksCallback, &enumContext, DIEDFL_ATTACHEDONLY ); } if( hr == S_OK && enumContext.m_pJoystick ) { // copy the joystick allocation routine to // our member pointer m_pJoystick = enumContext.m_pJoystick; DIDEVICEINSTANCE DeviceInfo; DeviceInfo.dwSize=sizeof(DIDEVICEINSTANCE); if( FAILED( hr = m_pJoystick->GetDeviceInfo(&DeviceInfo))){ std::cerr<<"GetDeviceInfo failed!\n"; return false; } std::cout << "VistaDirectXGamepad::InitDirextX() -- found [" << DeviceInfo.tszInstanceName << "] controller\n"; // set the desired data-format // c_dfDIJoystick2 is a global enum from directX hr = m_pJoystick->SetDataFormat( &c_dfDIJoystick2 ); if(hr != S_OK ) { std::cerr << "Could not set DataFormat for Joystick.\n"; } // Set the cooperative level to let DInput know how this device should // interact with the system and with other DInput applications. hr = m_pJoystick->SetCooperativeLevel( pAttach->m_nHwnd, DISCL_EXCLUSIVE | DISCL_BACKGROUND ); if( hr != S_OK ) { std::cerr << "Could not set cooperative level\n"; return false; } // normalize axes and determine number of buttons _sEnumJoystickContext s(m_pJoystick); hr = m_pJoystick->EnumObjects( EnumObjectsCallback, (VOID*)&s , DIDFT_AXIS | DIDFT_BUTTON ); if( hr != S_OK ) std::cout<<"\nEnumObjects failed (no axis or buttons?)!"; m_nNumberOfButtons = s.m_nBtNum; std::cout << "This controller has [" << s.m_nBtNum << "] buttons.\n"; DIPROPDWORD dipdw; dipdw.diph.dwSize = sizeof(DIPROPDWORD); dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER); dipdw.diph.dwObj = 0; dipdw.diph.dwHow = DIPH_DEVICE; dipdw.dwData = DIPROPAXISMODE_ABS; //DIPROPAXISMODE_ABS or DIPROPAXISMODE_REL hr = m_pJoystick->SetProperty(DIPROP_AXISMODE , &dipdw.diph); if(hr != S_OK) std::cerr << "Could not set axis mode\n"; dipdw.dwData = 100; // = 1% hr = m_pJoystick->SetProperty(DIPROP_DEADZONE , &dipdw.diph); if(hr != S_OK) std::cerr << "Could not set DEADZONE\n"; dipdw.dwData = 10000; // = 100% hr = m_pJoystick->SetProperty(DIPROP_SATURATION , &dipdw.diph); if(hr != S_OK) std::cerr << "Could not set SATURATION\n"; hr = m_pJoystick->Acquire(); if( hr != S_OK ) std::cerr << "Could not acquire initially!\n"; m_eDriver = TP_DIRECTX; // try to figure out whether this driver has a force feedback support or not if(s.m_nForceFeedbackAxes != 0) { // yes! VistaDirectXForceFeedbackAspect *pForce = new VistaDirectXForceFeedbackAspect(this); // configure force aspect // assign and register as aspect m_pForceAspect = pForce; RegisterAspect( m_pForceAspect ); } return true; } else { std::cerr << "VistaDirectXGamepad::InitDirectXInput() " << "-- FAILED to enumerate a joystick" << std::endl; if(enumContext.m_nCount == 0) std::cerr << "VistaDirectXGamepad::InitDirectXInput() -- " << "Maybe no joystick attached?\n"; } return false; }
/** * name: PaintThemeButton * desc: Draws the themed button * param: ctl - BTNCTRL structure for the button * hdcMem - device context to draw to * rcClient - rectangle of the whole button * return: nothing **/ static void __fastcall PaintThemeButton(BTNCTRL *ctl, HDC hdcMem, LPRECT rcClient) { RECT rcText = { 0, 0, 0, 0 }; WCHAR wszText[MAX_PATH] = { 0 }; WORD ccText; // Draw the flat button if ((ctl->dwStyle & MBS_FLAT) && ctl->hThemeToolbar) { int state = IsWindowEnabled(ctl->hwnd) ? (ctl->stateId == PBS_NORMAL && ctl->defbutton ? PBS_DEFAULTED : ctl->stateId) : PBS_DISABLED; if (IsThemeBackgroundPartiallyTransparent(ctl->hThemeToolbar, TP_BUTTON, TBStateConvert2Flat(state))) { if (SUCCEEDED(DrawThemeParentBackground(ctl->hwnd, hdcMem, rcClient))) DrawThemeParentBackground(GetParent(ctl->hwnd), hdcMem, rcClient); } DrawThemeBackground(ctl->hThemeToolbar, hdcMem, TP_BUTTON, TBStateConvert2Flat(state), rcClient, rcClient); } else { // draw themed button background if (ctl->hThemeButton) { int state = IsWindowEnabled(ctl->hwnd) ? (ctl->stateId == PBS_NORMAL && ctl->defbutton ? PBS_DEFAULTED : ctl->stateId) : PBS_DISABLED; if (IsThemeBackgroundPartiallyTransparent(ctl->hThemeButton, BP_PUSHBUTTON, state)) { if (SUCCEEDED(DrawThemeParentBackground(ctl->hwnd, hdcMem, rcClient))) DrawThemeParentBackground(GetParent(ctl->hwnd), hdcMem, rcClient); } DrawThemeBackground(ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, state, rcClient, rcClient); } } // calculate text rect { RECT sizeText; HFONT hOldFont; ccText = GetWindowTextW(ctl->hwnd, wszText, sizeof(wszText) / sizeof(WCHAR)); if (ccText > 0) { hOldFont = (HFONT)SelectObject(hdcMem, ctl->hFont); GetThemeTextExtent( ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, IsWindowEnabled(ctl->hwnd) ? ctl->stateId : PBS_DISABLED, wszText, ccText, DST_PREFIXTEXT, NULL, &sizeText); if (ctl->cHot) { RECT rcHot; GetThemeTextExtent(ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, IsWindowEnabled(ctl->hwnd) ? ctl->stateId : PBS_DISABLED, L"&", 1, DST_PREFIXTEXT, NULL, &rcHot); sizeText.right -= (rcHot.right - rcHot.left); } SelectObject(hdcMem, hOldFont); rcText.left = (ctl->hIcon) ? 0 : (rcClient->right - rcClient->left - (sizeText.right - sizeText.left)) / 2; rcText.top = (rcClient->bottom - rcClient->top - (sizeText.bottom - sizeText.top)) / 2; rcText.right = rcText.left + (sizeText.right - sizeText.left); rcText.bottom = rcText.top + (sizeText.bottom - sizeText.top); if (ctl->stateId == PBS_PRESSED) { OffsetRect(&rcText, 1, 1); } } } PaintIcon(ctl, hdcMem, &ccText, rcClient, &rcText); // draw text if (ccText > 0 && ctl->hThemeButton) { HFONT hOldFont = (HFONT)SelectObject(hdcMem, ctl->hFont); DrawThemeText(ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, IsWindowEnabled(ctl->hwnd) ? ctl->stateId : PBS_DISABLED, wszText, ccText, DST_PREFIXTEXT, 0, &rcText); SelectObject(hdcMem, hOldFont); } }
void LSAPIInit::setLitestepVars() { wchar_t wzTemp[MAX_PATH]; DWORD dwLength = MAX_PATH; // just using a shorter name, no real reason to re-assign. SettingsManager *pSM = m_smSettingsManager; // Set the variable "litestepdir" since it was never set if (SUCCEEDED(StringCchCopyW(wzTemp, MAX_PATH, m_wzLitestepPath))) { PathAddBackslashEx(wzTemp, MAX_PATH); PathQuoteSpacesW(wzTemp); pSM->SetVariable(L"litestepdir", wzTemp); } if (GetWindowsDirectoryW(wzTemp, MAX_PATH)) { PathAddBackslashEx(wzTemp, MAX_PATH); pSM->SetVariable(L"windir", wzTemp); } if (GetUserNameW(wzTemp, &dwLength)) { PathQuoteSpacesW(wzTemp); pSM->SetVariable(L"username", wzTemp); } pSM->SetVariable(L"nl", L"\n", true); pSM->SetVariable(L"cr", L"\r", true); pSM->SetVariable(L"dollar", L"$", true); pSM->SetVariable(L"at", L"@", true); pSM->SetVariable(L"bitbucket", L"::{645FF040-5081-101B-9F08-00AA002F954E}"); pSM->SetVariable(L"documents", L"::{450D8FBA-AD25-11D0-98A8-0800361B1103}"); pSM->SetVariable(L"drives", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}"); pSM->SetVariable(L"network", L"::{208D2C60-3AEA-1069-A2D7-08002B30309D}"); pSM->SetVariable(L"controls", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}"); pSM->SetVariable(L"dialup", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{992CFFA0-F557-101A-88EC-00DD010CCC48}"); pSM->SetVariable(L"networkanddialup", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{7007ACC7-3202-11D1-AAD2-00805FC1270E}"); pSM->SetVariable(L"printers", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{2227A280-3AEA-1069-A2DE-08002B30309D}"); pSM->SetVariable(L"scheduled", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{D6277990-4C6A-11CF-8D87-00AA0060F5BF}"); pSM->SetVariable(L"admintools", L"::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{D20EA4E1-3957-11d2-A40B-0C5020524153}"); setShellFolderVariable(L"quicklaunch", LS_CSIDL_QUICKLAUNCH); setShellFolderVariable(L"commondesktopdir", CSIDL_COMMON_DESKTOPDIRECTORY); setShellFolderVariable(L"commonfavorites", CSIDL_COMMON_FAVORITES); setShellFolderVariable(L"commonprograms", CSIDL_COMMON_PROGRAMS); setShellFolderVariable(L"commonstartmenu", CSIDL_COMMON_STARTMENU); setShellFolderVariable(L"commonstartup", CSIDL_COMMON_STARTUP); setShellFolderVariable(L"cookies", CSIDL_COOKIES); setShellFolderVariable(L"desktop", CSIDL_DESKTOP); setShellFolderVariable(L"desktopdir", CSIDL_DESKTOPDIRECTORY); setShellFolderVariable(L"favorites", CSIDL_FAVORITES); setShellFolderVariable(L"fonts", CSIDL_FONTS); setShellFolderVariable(L"history", CSIDL_HISTORY); setShellFolderVariable(L"internet", CSIDL_INTERNET); setShellFolderVariable(L"internetcache", CSIDL_INTERNET_CACHE); setShellFolderVariable(L"nethood", CSIDL_NETHOOD); setShellFolderVariable(L"documentsdir", CSIDL_PERSONAL); setShellFolderVariable(L"printhood", CSIDL_PRINTHOOD); setShellFolderVariable(L"programs", CSIDL_PROGRAMS); setShellFolderVariable(L"recent", CSIDL_RECENT); setShellFolderVariable(L"sendto", CSIDL_SENDTO); setShellFolderVariable(L"startmenu", CSIDL_STARTMENU); setShellFolderVariable(L"startup", CSIDL_STARTUP); setShellFolderVariable(L"templates", CSIDL_TEMPLATES); setShellFolderVariable(L"commonadmintoolsdir", CSIDL_COMMON_ADMINTOOLS); setShellFolderVariable(L"admintoolsdir", CSIDL_ADMINTOOLS); // // Set version identification variables // struct VersionToVariable { UINT uVersion; LPCWSTR pszVariable; } versions[] = \ { { WINVER_WIN95, L"Win95" }, { WINVER_WIN98, L"Win98" }, { WINVER_WINME, L"WinME" }, { WINVER_WINNT4, L"WinNT4" }, { WINVER_WIN2000, L"Win2000" }, { WINVER_WINXP, L"WinXP" }, { WINVER_VISTA, L"WinVista" }, { WINVER_WIN7, L"Win7" }, { WINVER_WIN8, L"Win8" }, { WINVER_WIN81, L"Win81" }, { WINVER_WIN2003, L"Win2003" }, { WINVER_WHS, L"Win2003" }, // WHS is Win2003 in disguise { WINVER_WIN2008, L"Win2008" }, { WINVER_WIN2008R2, L"Win2008R2" }, { WINVER_WIN2012, L"Win2012" }, { WINVER_WIN2012R2, L"Win2012R2" } }; UINT uVersion = GetWindowsVersion(); for (size_t idx = 0; idx < COUNTOF(versions); ++idx) { if (versions[idx].uVersion == uVersion) { pSM->SetVariable(versions[idx].pszVariable, L"true"); } else { pSM->SetVariable(versions[idx].pszVariable, L"false"); } } if (IsOS(OS_NT)) { pSM->SetVariable(L"Win9x", L"false"); pSM->SetVariable(L"WinNT", L"true"); } else { pSM->SetVariable(L"Win9x", L"true"); pSM->SetVariable(L"WinNT", L"false"); } #if defined(_WIN64) pSM->SetVariable(L"Win64", L"true"); #else if (IsOS(OS_WOW6432)) { pSM->SetVariable(L"Win64", L"true"); } else { pSM->SetVariable(L"Win64", L"false"); } #endif // screen resolution StringCchPrintfW(wzTemp, MAX_PATH, L"%d", GetSystemMetrics(SM_CXSCREEN)); pSM->SetVariable(L"ResolutionX", wzTemp); StringCchPrintfW(wzTemp, MAX_PATH, L"%d", GetSystemMetrics(SM_CYSCREEN)); pSM->SetVariable(L"ResolutionY", wzTemp); // build date/time from PE headers getCompileTime(wzTemp, MAX_PATH); pSM->SetVariable(L"CompileDate", wzTemp); #if defined(LS_CUSTOM_INCLUDEFOLDER) pSM->SetVariable(L"IncludeFolder", L"1"); #endif // LS_CUSTOM_INCLUDEFOLDER }
HRESULT CTextureHolder::CopyBitmapToSurface(){ // Get a DDraw object to create a temporary surface LPDIRECTDRAW7 pDD; m_pddsSurface->GetDDInterface( (VOID**)&pDD ); // Get the bitmap structure (to extract width, height, and bpp) BITMAP bm; GetObject( m_hbmBitmap, sizeof(BITMAP), &bm ); // Setup the new surface desc DDSURFACEDESC2 ddsd; ddsd.dwSize = sizeof(ddsd); m_pddsSurface->GetSurfaceDesc( &ddsd ); ddsd.dwFlags = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT| DDSD_TEXTURESTAGE; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY; ddsd.ddsCaps.dwCaps2 = 0L; ddsd.dwWidth = bm.bmWidth; ddsd.dwHeight = bm.bmHeight; // Create a new surface for the texture LPDIRECTDRAWSURFACE7 pddsTempSurface; HRESULT hr; if( FAILED( hr = pDD->CreateSurface( &ddsd, &pddsTempSurface, NULL ) ) ) { pDD->Release(); return hr; } // Get a DC for the bitmap HDC hdcBitmap = CreateCompatibleDC( NULL ); if( NULL == hdcBitmap ) { pddsTempSurface->Release(); pDD->Release(); return hr; // bug? return E_FAIL? } SelectObject( hdcBitmap, m_hbmBitmap ); // Handle palettized textures. Need to attach a palette if( ddsd.ddpfPixelFormat.dwRGBBitCount == 8 ) { LPDIRECTDRAWPALETTE pPalette; DWORD dwPaletteFlags = DDPCAPS_8BIT|DDPCAPS_ALLOW256; DWORD pe[256]; WORD wNumColors = GetDIBColorTable( hdcBitmap, 0, 256, (RGBQUAD*)pe ); // Create the color table for( WORD i=0; i<wNumColors; i++ ) { pe[i] = RGB( GetBValue(pe[i]), GetGValue(pe[i]), GetRValue(pe[i]) ); // Handle textures with transparent pixels if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) ) { // Set alpha for opaque pixels if( m_dwFlags & D3DTEXTR_TRANSPARENTBLACK ) { if( pe[i] != 0x00000000 ) pe[i] |= 0xff000000; } else if( m_dwFlags & D3DTEXTR_TRANSPARENTWHITE ) { if( pe[i] != 0x00ffffff ) pe[i] |= 0xff000000; } } } // Add DDPCAPS_ALPHA flag for textures with transparent pixels if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) ) dwPaletteFlags |= DDPCAPS_ALPHA; // Create & attach a palette pDD->CreatePalette( dwPaletteFlags, (PALETTEENTRY*)pe, &pPalette, NULL ); pddsTempSurface->SetPalette( pPalette ); m_pddsSurface->SetPalette( pPalette ); SAFE_RELEASE( pPalette ); } // Copy the bitmap image to the surface. HDC hdcSurface; if( SUCCEEDED( pddsTempSurface->GetDC( &hdcSurface ) ) ) { BitBlt( hdcSurface, 0, 0, bm.bmWidth, bm.bmHeight, hdcBitmap, 0, 0, SRCCOPY ); pddsTempSurface->ReleaseDC( hdcSurface ); } DeleteDC( hdcBitmap ); // Copy the temp surface to the real texture surface m_pddsSurface->Blt( NULL, pddsTempSurface, NULL, DDBLT_WAIT, NULL ); // Done with the temp surface pddsTempSurface->Release(); // For textures with real alpha (not palettized), set transparent bits if( ddsd.ddpfPixelFormat.dwRGBAlphaBitMask ) { if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) ) { // Lock the texture surface DDSURFACEDESC2 ddsd; ddsd.dwSize = sizeof(ddsd); while( m_pddsSurface->Lock( NULL, &ddsd, 0, NULL ) == DDERR_WASSTILLDRAWING ); DWORD dwAlphaMask = ddsd.ddpfPixelFormat.dwRGBAlphaBitMask; DWORD dwRGBMask = ( ddsd.ddpfPixelFormat.dwRBitMask | ddsd.ddpfPixelFormat.dwGBitMask | ddsd.ddpfPixelFormat.dwBBitMask ); DWORD dwColorkey = 0x00000000; // Colorkey on black if( m_dwFlags & D3DTEXTR_TRANSPARENTWHITE ) dwColorkey = dwRGBMask; // Colorkey on white // Add an opaque alpha value to each non-colorkeyed pixel for( DWORD y=0; y<ddsd.dwHeight; y++ ) { WORD* p16 = (WORD*)((BYTE*)ddsd.lpSurface + y*ddsd.lPitch); DWORD* p32 = (DWORD*)((BYTE*)ddsd.lpSurface + y*ddsd.lPitch); for( DWORD x=0; x<ddsd.dwWidth; x++ ) { if( ddsd.ddpfPixelFormat.dwRGBBitCount == 16 ) { if( ( *p16 &= dwRGBMask ) != dwColorkey ) *p16 |= dwAlphaMask; p16++; } if( ddsd.ddpfPixelFormat.dwRGBBitCount == 32 ) { if( ( *p32 &= dwRGBMask ) != dwColorkey ) *p32 |= dwAlphaMask; p32++; } } } m_pddsSurface->Unlock( NULL ); } else if( m_bHasMyAlpha ){ DDSURFACEDESC2 ddsd; ddsd.dwSize = sizeof(ddsd); while( m_pddsSurface->Lock( NULL, &ddsd, 0, NULL ) == DDERR_WASSTILLDRAWING ); DWORD dwRGBMask = ( ddsd.ddpfPixelFormat.dwRBitMask | ddsd.ddpfPixelFormat.dwGBitMask | ddsd.ddpfPixelFormat.dwBBitMask ); DWORD rMask = ddsd.ddpfPixelFormat.dwRBitMask; DWORD gMask = ddsd.ddpfPixelFormat.dwGBitMask; DWORD bMask = ddsd.ddpfPixelFormat.dwBBitMask; DWORD aMask = ddsd.ddpfPixelFormat.dwRGBAlphaBitMask; DWORD rShift = GetShift( rMask ); DWORD gShift = GetShift( gMask ); DWORD bShift = GetShift( bMask ); DWORD aShift = GetShift( aMask ); DWORD maxRVal = rMask >> rShift; DWORD maxGVal = gMask >> gShift; DWORD maxBVal = bMask >> bShift; DWORD maxAVal = aMask >> aShift; DWORD rVal, gVal, bVal, aVal; FLOAT min, max; // Add an opaque alpha value to each non-colorkeyed pixel for( DWORD y=0; y<ddsd.dwHeight; y++ ){ WORD* p16 = (WORD*)((BYTE*)ddsd.lpSurface + y*ddsd.lPitch); DWORD* p32 = (DWORD*)((BYTE*)ddsd.lpSurface + y*ddsd.lPitch); for( DWORD x=0; x<ddsd.dwWidth; x++ ){ if( ddsd.ddpfPixelFormat.dwRGBBitCount == 32 ){ *p32 &= dwRGBMask; // set alpha to zero if( *p32 == 0 ){} // black is 100% transparent, so leave alpha at 0% else if( *p32 == dwRGBMask ){ // white is opaque, so set alpha to 100% *p32 |= aMask; } else{ // set alpha to equal intensity of brightest hue rVal = ( *p32 & rMask ) >> rShift; gVal = ( *p32 & gMask ) >> gShift; bVal = ( *p32 & bMask ) >> bShift; max = max( (FLOAT)rVal / maxRVal, max( (FLOAT)gVal / maxGVal, (FLOAT)bVal / maxBVal ) ); // min = min( (FLOAT)rVal / maxRVal, min( (FLOAT)gVal / maxGVal, (FLOAT)bVal / maxBVal ) ); aVal = max * 255; //if( rVal == gVal && gVal == bVal ){ // white fading to black // *p32 = dwRGBMask; // set color to white //} // maximize luminosity and saturation rVal /= max; gVal /= max; bVal /= max; *p32 = ( aVal << aShift ) | ( rVal << rShift ) | ( gVal << gShift ) | ( bVal << bShift ); } p32++; } else if( ddsd.ddpfPixelFormat.dwRGBBitCount == 16 ){ *p16 &= dwRGBMask; // set alpha to zero if( *p16 == 0 ){} // black is 100% transparent, so leave alpha at 0% else if( *p16 == dwRGBMask ){ // white is opaque, so set alpha to 100% *p16 |= aMask; } else{ // set alpha to equal intensity of brightest hue rVal = ( *p16 & rMask ) >> rShift; gVal = ( *p16 & gMask ) >> gShift; bVal = ( *p16 & bMask ) >> bShift; aVal = STATSTEXTURE_ALPHA * max( (FLOAT)rVal / maxRVal, max( (FLOAT)gVal / maxGVal, (FLOAT)bVal / maxBVal ) ); if( aVal < STATSTEXTURE_ALPHA ){ // semi-tranparent white *p16 = dwRGBMask; } *p16 |= aVal << aShift; } p16++; } } }
HRESULT BaseApp::initialize() { HRESULT hr; //get the dpi information HDC screen = GetDC(0); int dpiX = GetDeviceCaps(screen, LOGPIXELSX); int dpiY = GetDeviceCaps(screen, LOGPIXELSY); ReleaseDC(0, screen); // Initialize device-indpendent resources, such // as the Direct2D factory. hr = createDeviceIndependentResources(); DPIScale::Initialize(d2dFactory); if (SUCCEEDED(hr)) { // Register the window class. WNDCLASSEX wcex = { sizeof(WNDCLASSEX) }; wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = BaseApp::wndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = sizeof(LONG_PTR); wcex.hInstance = HINST_THISCOMPONENT; wcex.hbrBackground = NULL; wcex.lpszMenuName = NULL; wcex.hCursor = LoadCursor(NULL, IDI_APPLICATION); wcex.lpszClassName = "Base App Window Class"; RegisterClassEx(&wcex); // Create the window. mainWindowHandle = CreateWindow( "Base App Window Class", APP_WINDOW_CAPTION, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, static_cast<INT>(APP_WINDOW_WIDTH * DPIScale::getScaleX()), // For modern screen static_cast<INT>(APP_WINDOW_HEIGHT * DPIScale::getScaleY()), // For modern screen NULL, NULL, HINST_THISCOMPONENT, this ); hr = mainWindowHandle ? S_OK : E_FAIL; if (SUCCEEDED(hr)) { loadConfig(); hr = createDeviceResources(mainWindowHandle); initializeGameAssets(); ShowWindow(mainWindowHandle, SW_SHOWNORMAL); UpdateWindow(mainWindowHandle); } } return hr; }