static BOOL init(void) { HMODULE hComctl32; BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*); WNDCLASSA wc; INITCOMMONCONTROLSEX iccex; hComctl32 = GetModuleHandleA("comctl32.dll"); pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx"); if (!pInitCommonControlsEx) { win_skip("InitCommonControlsEx() is missing. Skipping the tests\n"); return FALSE; } iccex.dwSize = sizeof(iccex); iccex.dwICC = ICC_USEREX_CLASSES; pInitCommonControlsEx(&iccex); pSetWindowSubclass = (void*)GetProcAddress(hComctl32, (LPSTR)410); wc.style = CS_HREDRAW | CS_VREDRAW; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandleA(NULL); wc.hIcon = NULL; wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW); wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW); wc.lpszMenuName = NULL; wc.lpszClassName = ComboExTestClass; wc.lpfnWndProc = ComboExTestWndProc; RegisterClassA(&wc); hComboExParentWnd = CreateWindowExA(0, ComboExTestClass, "ComboEx test", WS_OVERLAPPEDWINDOW|WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, GetModuleHandleA(NULL), 0); ok(hComboExParentWnd != NULL, "failed to create parent window\n"); hMainHinst = GetModuleHandleA(NULL); return hComboExParentWnd != NULL; }
BOOL InitInstance(HANDLE hInstance) { WNDCLASSEX wcex; RECT rect; int height, width; memset(&wcex, 0x00, sizeof(wcex)); wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = WndProc; wcex.hInstance = hInstance; wcex.lpszClassName = ClassName; RegisterClassExA(&wcex); //calculate required window width and height, taking in account the required client area and borders height = BoardHeight*BlockSize; width = BoardWidth*BlockSize; rect.left = 0; rect.top = 0; rect.bottom = height; rect.right = width; AdjustWindowRectEx(&rect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_TOPMOST); height += ((rect.bottom - rect.top) - height); width += ((rect.right - rect.left) - width); ///////////////////////////////////////////////// if ((hWndMain = CreateWindowExA(WS_EX_TOPMOST, ClassName, MainTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, width, height, NULL, NULL, hInstance, NULL)) == NULL) { return FALSE; } ShowWindow(hWndMain, SW_SHOW); UpdateWindow(hWndMain); return TRUE; }
static DWORD CALLBACK thread( LPVOID arg ) { HDESK d1, d2; HWND hwnd = CreateWindowExA(0,"WinStationClass","test",WS_POPUP,0,0,100,100,GetDesktopWindow(),0,0,0); ok( hwnd != 0, "CreateWindow failed\n" ); d1 = GetThreadDesktop(GetCurrentThreadId()); trace( "thread %p desktop: %p\n", arg, d1 ); ok( d1 == initial_desktop, "thread %p doesn't use initial desktop\n", arg ); SetLastError( 0xdeadbeef ); ok( !CloseHandle( d1 ), "CloseHandle succeeded\n" ); ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() ); SetLastError( 0xdeadbeef ); ok( !CloseDesktop( d1 ), "CloseDesktop succeeded\n" ); ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */ "bad last error %d\n", GetLastError() ); print_object( d1 ); d2 = CreateDesktopA( "foobar2", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL ); trace( "created desktop %p\n", d2 ); ok( d2 != 0, "CreateDesktop failed\n" ); SetLastError( 0xdeadbeef ); ok( !SetThreadDesktop( d2 ), "set thread desktop succeeded with existing window\n" ); ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */ "bad last error %d\n", GetLastError() ); DestroyWindow( hwnd ); ok( SetThreadDesktop( d2 ), "set thread desktop failed\n" ); d1 = GetThreadDesktop(GetCurrentThreadId()); ok( d1 == d2, "GetThreadDesktop did not return set desktop %p/%p\n", d1, d2 ); print_object( d2 ); if (arg < (LPVOID)5) { HANDLE hthread = CreateThread( NULL, 0, thread, (char *)arg + 1, 0, NULL ); Sleep(1000); WaitForSingleObject( hthread, INFINITE ); CloseHandle( hthread ); } return 0; }
static HWND create_updown_control(DWORD style, HWND buddy) { WNDPROC oldproc; HWND updown; RECT rect; GetClientRect(parent_wnd, &rect); updown = CreateWindowExA(0, UPDOWN_CLASSA, NULL, WS_CHILD | WS_BORDER | WS_VISIBLE | style, 0, 0, rect.right, rect.bottom, parent_wnd, (HMENU)1, GetModuleHandleA(NULL), NULL); ok(updown != NULL, "Failed to create UpDown control.\n"); if (!updown) return NULL; SendMessageA(updown, UDM_SETBUDDY, (WPARAM)buddy, 0); SendMessageA(updown, UDM_SETRANGE, 0, MAKELONG(100, 0)); SendMessageA(updown, UDM_SETPOS, 0, MAKELONG(50, 0)); oldproc = (WNDPROC)SetWindowLongPtrA(updown, GWLP_WNDPROC, (LONG_PTR)updown_subclass_proc); SetWindowLongPtrA(updown, GWLP_USERDATA, (LONG_PTR)oldproc); return updown; }
bool pinDialogPriv::doNonmodalNotifyDlg(bool messageLoop) { MSG msg ; HWND hwnd = GetForegroundWindow(); WNDCLASSEXA wc = {0}; wc.cbSize = sizeof(WNDCLASSEX); wc.lpfnWndProc = (WNDPROC) nonmodalDialogProc; wc.hInstance = params.m_hInst; wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE); wc.lpszClassName = "DialogClass"; RegisterClassExA(&wc); m_hwnd = CreateWindowExA(WS_EX_DLGMODALFRAME | WS_EX_TOPMOST, "DialogClass", "PIN message", WS_VISIBLE | WS_SYSMENU | WS_CAPTION , 100, 100, 380, 80, NULL, NULL, params.m_hInst, this); int counter = 20; //always pump some messages, like dialog init while( GetMessage(&msg, NULL, 0, 0) && counter--) { DispatchMessage(&msg); if (messageLoop) counter = 20; } return true; }
/** * * rct2: 0x00407E6E */ int osinterface_progressbar_create(char* title, int a2) { DWORD style = WS_VISIBLE | WS_BORDER | WS_DLGFRAME; if (a2) { style = WS_VISIBLE | WS_BORDER | WS_DLGFRAME | PBS_SMOOTH; } int width = 340; int height = GetSystemMetrics(SM_CYCAPTION) + 24; HWND hwnd = CreateWindowExA(WS_EX_TOPMOST | WS_EX_DLGMODALFRAME, "msctls_progress32", title, style, (RCT2_GLOBAL(0x01423C08, sint32) - width) / 2, (RCT2_GLOBAL(0x01423C0C, sint32) - height) / 2, width, height, 0, 0, RCT2_GLOBAL(RCT2_ADDRESS_HINSTANCE, HINSTANCE), 0); RCT2_GLOBAL(RCT2_ADDRESS_PROGRESSBAR_HWND, HWND) = hwnd; if (hwnd) { RCT2_GLOBAL(0x009E2DFC, uint32) = 1; if (RCT2_GLOBAL(RCT2_ADDRESS_HFONT, HFONT)) { SendMessageA(hwnd, WM_SETFONT, (WPARAM)RCT2_GLOBAL(RCT2_ADDRESS_HFONT, HFONT), 1); } SetWindowTextA(hwnd, title); osinterface_progressbar_setmax(0xFF); osinterface_progressbar_setpos(0); return 1; } else { return 0; } }
static HWND create_datetime_control(DWORD style) { WNDPROC oldproc; HWND hWndDateTime = NULL; hWndDateTime = CreateWindowExA(0, DATETIMEPICK_CLASSA, NULL, style, 0,50,300,120, NULL, NULL, NULL, NULL); if (!hWndDateTime) return NULL; oldproc = (WNDPROC)SetWindowLongPtrA(hWndDateTime, GWLP_WNDPROC, (LONG_PTR)datetime_subclass_proc); SetWindowLongPtrA(hWndDateTime, GWLP_USERDATA, (LONG_PTR)oldproc); return hWndDateTime; }
static void test_margin(void) { RECT r, r1; HWND hwnd; DWORD ret; hwnd = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0, 10, 10, 300, 100, NULL, NULL, NULL, 0); ok(hwnd != NULL, "failed to create tooltip wnd\n"); ret = SendMessageA(hwnd, TTM_SETMARGIN, 0, 0); ok(!ret, "got %d\n", ret); SetRect(&r, -1, -1, 1, 1); ret = SendMessageA(hwnd, TTM_SETMARGIN, 0, (LPARAM)&r); ok(!ret, "got %d\n", ret); SetRect(&r1, 0, 0, 0, 0); ret = SendMessageA(hwnd, TTM_GETMARGIN, 0, (LPARAM)&r1); ok(!ret, "got %d\n", ret); ok(EqualRect(&r, &r1), "got %s, was %s\n", wine_dbgstr_rect(&r1), wine_dbgstr_rect(&r)); ret = SendMessageA(hwnd, TTM_SETMARGIN, 0, 0); ok(!ret, "got %d\n", ret); SetRect(&r1, 0, 0, 0, 0); ret = SendMessageA(hwnd, TTM_GETMARGIN, 0, (LPARAM)&r1); ok(!ret, "got %d\n", ret); ok(EqualRect(&r, &r1), "got %s, was %s\n", wine_dbgstr_rect(&r1), wine_dbgstr_rect(&r)); ret = SendMessageA(hwnd, TTM_GETMARGIN, 0, 0); ok(!ret, "got %d\n", ret); DestroyWindow(hwnd); }
static unsigned __stdcall windowThreadFunction( LPVOID _lpParam ) { WindowThreadParam *lpParam = (WindowThreadParam *)_lpParam; // Actually create the window lpParam->hWnd = CreateWindowExA(dwExStyle, g_lpszClassName, lpParam->lpszWindowName, dwStyle, 0, // x 0, // y lpParam->nWidth, lpParam->nHeight, NULL, // hWndParent NULL, // hMenu NULL, // hInstance NULL); // lpParam // Notify parent thread that window has been created SetEvent(lpParam->hEvent); BOOL bRet; MSG msg; while ((bRet = GetMessage(&msg, NULL, 0, 0 )) != FALSE) { if (bRet == -1) { // handle the error and possibly exit } else { TranslateMessage(&msg); DispatchMessage(&msg); } } // Return the exit code return msg.wParam; }
static void test_customdraw(void) { static struct { LRESULT FirstReturnValue; int ExpectedCalls; } expectedResults[] = { /* Valid notification responses */ {CDRF_DODEFAULT, TEST_CDDS_PREPAINT}, {CDRF_SKIPDEFAULT, TEST_CDDS_PREPAINT}, {CDRF_NOTIFYPOSTPAINT, TEST_CDDS_PREPAINT | TEST_CDDS_POSTPAINT}, /* Invalid notification responses */ {CDRF_NOTIFYITEMDRAW, TEST_CDDS_PREPAINT}, {CDRF_NOTIFYPOSTERASE, TEST_CDDS_PREPAINT}, {CDRF_NEWFONT, TEST_CDDS_PREPAINT} }; DWORD iterationNumber; WNDCLASSA wc; LRESULT lResult; /* Create a class to use the custom draw wndproc */ wc.style = CS_HREDRAW | CS_VREDRAW; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandleA(NULL); wc.hIcon = NULL; wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW); wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW); wc.lpszMenuName = NULL; wc.lpszClassName = "CustomDrawClass"; wc.lpfnWndProc = custom_draw_wnd_proc; RegisterClassA(&wc); for (iterationNumber = 0; iterationNumber < sizeof(expectedResults)/sizeof(expectedResults[0]); iterationNumber++) { HWND parent, hwndTip; RECT rect; TTTOOLINFOA toolInfo = { 0 }; /* Create a main window */ parent = CreateWindowExA(0, "CustomDrawClass", NULL, WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE, 50, 50, 300, 300, NULL, NULL, NULL, 0); ok(parent != NULL, "Creation of main window failed\n"); /* Make it show */ ShowWindow(parent, SW_SHOWNORMAL); flush_events(100); /* Create Tooltip */ hwndTip = CreateWindowExA(WS_EX_TOPMOST, TOOLTIPS_CLASSA, NULL, TTS_NOPREFIX | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, parent, NULL, GetModuleHandleA(NULL), 0); ok(hwndTip != NULL, "Creation of tooltip window failed\n"); /* Set up parms for the wndproc to handle */ CD_Stages = 0; CD_Result = expectedResults[iterationNumber].FirstReturnValue; g_hwnd = hwndTip; /* Make it topmost, as per the MSDN */ SetWindowPos(hwndTip, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); /* Create a tool */ toolInfo.cbSize = TTTOOLINFOA_V1_SIZE; toolInfo.hwnd = parent; toolInfo.hinst = GetModuleHandleA(NULL); toolInfo.uFlags = TTF_SUBCLASS; toolInfo.uId = 0x1234ABCD; toolInfo.lpszText = (LPSTR)"This is a test tooltip"; toolInfo.lParam = 0xdeadbeef; GetClientRect (parent, &toolInfo.rect); lResult = SendMessageA(hwndTip, TTM_ADDTOOLA, 0, (LPARAM)&toolInfo); ok(lResult, "Adding the tool to the tooltip failed\n"); /* Make tooltip appear quickly */ SendMessageA(hwndTip, TTM_SETDELAYTIME, TTDT_INITIAL, MAKELPARAM(1,0)); /* Put cursor inside window, tooltip will appear immediately */ GetWindowRect( parent, &rect ); SetCursorPos( (rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2 ); flush_events(200); if (CD_Stages) { /* Check CustomDraw results */ ok(CD_Stages == expectedResults[iterationNumber].ExpectedCalls || broken(CD_Stages == (expectedResults[iterationNumber].ExpectedCalls & ~TEST_CDDS_POSTPAINT)), /* nt4 */ "CustomDraw run %d stages %x, expected %x\n", iterationNumber, CD_Stages, expectedResults[iterationNumber].ExpectedCalls); } /* Clean up */ DestroyWindow(hwndTip); DestroyWindow(parent); } }
INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE ignoreMe0, LPSTR ignoreMe1, INT ignoreMe2) { LPCSTR szName = "Pez App"; WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(0), 0, 0, 0, 0, szName, 0 }; DWORD dwStyle = WS_SYSMENU | WS_VISIBLE | WS_POPUP; DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; RECT rect; int windowWidth, windowHeight, windowLeft, windowTop; HWND hWnd; PIXELFORMATDESCRIPTOR pfd; HDC hDC; HGLRC hRC; int pixelFormat; GLenum err; DWORD previousTime = GetTickCount(); MSG msg = {0}; wc.hCursor = LoadCursor(0, IDC_ARROW); RegisterClassEx(&wc); SetRect(&rect, 0, 0, PEZ_VIEWPORT_WIDTH, PEZ_VIEWPORT_HEIGHT); AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle); windowWidth = rect.right - rect.left; windowHeight = rect.bottom - rect.top; windowLeft = GetSystemMetrics(SM_CXSCREEN) / 2 - windowWidth / 2; windowTop = GetSystemMetrics(SM_CYSCREEN) / 2 - windowHeight / 2; hWnd = CreateWindowExA(0, szName, szName, dwStyle, windowLeft, windowTop, windowWidth, windowHeight, 0, 0, 0, 0); // Create the GL context. ZeroMemory(&pfd, sizeof(pfd)); pfd.nSize = sizeof(pfd); pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 24; pfd.cDepthBits = 24; pfd.cStencilBits = 8; pfd.iLayerType = PFD_MAIN_PLANE; hDC = GetDC(hWnd); pixelFormat = ChoosePixelFormat(hDC, &pfd); SetPixelFormat(hDC, pixelFormat, &pfd); hRC = wglCreateContext(hDC); wglMakeCurrent(hDC, hRC); if (PEZ_ENABLE_MULTISAMPLING) { int pixelAttribs[] = { WGL_SAMPLES_ARB, 16, WGL_SAMPLE_BUFFERS_ARB, GL_TRUE, WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_RED_BITS_ARB, 8, WGL_GREEN_BITS_ARB, 8, WGL_BLUE_BITS_ARB, 8, WGL_ALPHA_BITS_ARB, 8, WGL_DEPTH_BITS_ARB, 24, WGL_STENCIL_BITS_ARB, 8, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, 0 }; int* sampleCount = pixelAttribs + 1; int* useSampleBuffer = pixelAttribs + 3; int pixelFormat = -1; PROC proc = wglGetProcAddress("wglChoosePixelFormatARB"); unsigned int numFormats; PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) proc; if (!wglChoosePixelFormatARB) { PezFatalError("Could not load function pointer for 'wglChoosePixelFormatARB'. Is your driver properly installed?"); } // Try fewer and fewer samples per pixel till we find one that is supported: while (pixelFormat <= 0 && *sampleCount >= 0) { wglChoosePixelFormatARB(hDC, pixelAttribs, 0, 1, &pixelFormat, &numFormats); (*sampleCount)--; if (*sampleCount <= 1) { *useSampleBuffer = GL_FALSE; } } // Win32 allows the pixel format to be set only once per app, so destroy and re-create the app: DestroyWindow(hWnd); hWnd = CreateWindowExA(0, szName, szName, dwStyle, windowLeft, windowTop, windowWidth, windowHeight, 0, 0, 0, 0); SetWindowPos(hWnd, HWND_TOP, windowLeft, windowTop, windowWidth, windowHeight, 0); hDC = GetDC(hWnd); SetPixelFormat(hDC, pixelFormat, &pfd); hRC = wglCreateContext(hDC); wglMakeCurrent(hDC, hRC); } #define PEZ_TRANSPARENT_WINDOW 0 // For transparency, this doesn't seem to work. I think I'd need to read back from an OpenGL FBO and blit it with GDI. if (PEZ_TRANSPARENT_WINDOW) { long flag = GetWindowLong(hWnd, GWL_EXSTYLE); int opacity = 128; flag |= WS_EX_LAYERED; SetWindowLong(hWnd, GWL_EXSTYLE, flag); SetLayeredWindowAttributes(hWnd, 0, opacity, LWA_ALPHA); } err = glewInit(); if (GLEW_OK != err) { PezFatalError("GLEW Error: %s\n", glewGetErrorString(err)); } PezDebugString("OpenGL Version: %s\n", glGetString(GL_VERSION)); if (!PEZ_VERTICAL_SYNC) { wglSwapIntervalEXT(0); } if (PEZ_FORWARD_COMPATIBLE_GL && glewIsSupported("GL_VERSION_3_0")) { const int contextAttribs[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 0 }; HGLRC newRC = wglCreateContextAttribsARB(hDC, 0, contextAttribs); wglMakeCurrent(0, 0); wglDeleteContext(hRC); hRC = newRC; wglMakeCurrent(hDC, hRC); } { const char* szWindowTitle = PezInitialize(PEZ_VIEWPORT_WIDTH, PEZ_VIEWPORT_HEIGHT); SetWindowTextA(hWnd, szWindowTitle); } // ------------------- // Start the Game Loop // ------------------- while (msg.message != WM_QUIT) { if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } else { DWORD currentTime = GetTickCount(); DWORD deltaTime = currentTime - previousTime; previousTime = currentTime; PezUpdate(deltaTime); PezRender(); SwapBuffers(hDC); if (glGetError() != GL_NO_ERROR) { PezFatalError("OpenGL error.\n"); } } } UnregisterClass(szName, wc.hInstance); return 0; }
static void test_invalid_init(void) { HRESULT hr; IAutoComplete *ac; IUnknown *acSource; HWND edit_control; /* AutoComplete instance */ hr = CoCreateInstance(&CLSID_AutoComplete, NULL, CLSCTX_INPROC_SERVER, &IID_IAutoComplete, (void **)&ac); if (hr == REGDB_E_CLASSNOTREG) { win_skip("CLSID_AutoComplete is not registered\n"); return; } ok(hr == S_OK, "no IID_IAutoComplete (0x%08x)\n", hr); /* AutoComplete source */ hr = CoCreateInstance(&CLSID_ACLMulti, NULL, CLSCTX_INPROC_SERVER, &IID_IACList, (void **)&acSource); if (hr == REGDB_E_CLASSNOTREG) { win_skip("CLSID_ACLMulti is not registered\n"); IAutoComplete_Release(ac); return; } ok(hr == S_OK, "no IID_IACList (0x%08x)\n", hr); edit_control = CreateWindowExA(0, "EDIT", "Some text", 0, 10, 10, 300, 300, hMainWnd, NULL, hinst, NULL); ok(edit_control != NULL, "Can't create edit control\n"); /* The refcount of acSource would be incremented on older Windows. */ hr = IAutoComplete_Init(ac, NULL, acSource, NULL, NULL); ok(hr == E_INVALIDARG || broken(hr == S_OK), /* Win2k/XP/Win2k3 */ "Init returned 0x%08x\n", hr); if (hr == E_INVALIDARG) { LONG ref; IUnknown_AddRef(acSource); ref = IUnknown_Release(acSource); ok(ref == 1, "Expected AutoComplete source refcount to be 1, got %d\n", ref); } if (0) { /* Older Windows versions never check the window handle, while newer * versions only check for NULL. Subsequent attempts to initialize the * object after this call succeeds would fail, because initialization * state is determined by whether a non-NULL window handle is stored. */ hr = IAutoComplete_Init(ac, (HWND)0xdeadbeef, acSource, NULL, NULL); ok(hr == S_OK, "Init returned 0x%08x\n", hr); /* Tests crash on older Windows. */ hr = IAutoComplete_Init(ac, NULL, NULL, NULL, NULL); ok(hr == E_INVALIDARG, "Init returned 0x%08x\n", hr); hr = IAutoComplete_Init(ac, edit_control, NULL, NULL, NULL); ok(hr == E_INVALIDARG, "Init returned 0x%08x\n", hr); } /* bind to edit control */ hr = IAutoComplete_Init(ac, edit_control, acSource, NULL, NULL); ok(hr == S_OK, "Init returned 0x%08x\n", hr); /* try invalid parameters after successful initialization .*/ hr = IAutoComplete_Init(ac, NULL, NULL, NULL, NULL); ok(hr == E_INVALIDARG || hr == E_FAIL, /* Win2k/XP/Win2k3 */ "Init returned 0x%08x\n", hr); hr = IAutoComplete_Init(ac, NULL, acSource, NULL, NULL); ok(hr == E_INVALIDARG || hr == E_FAIL, /* Win2k/XP/Win2k3 */ "Init returned 0x%08x\n", hr); hr = IAutoComplete_Init(ac, edit_control, NULL, NULL, NULL); ok(hr == E_INVALIDARG || hr == E_FAIL, /* Win2k/XP/Win2k3 */ "Init returned 0x%08x\n", hr); /* try initializing twice on the same control */ hr = IAutoComplete_Init(ac, edit_control, acSource, NULL, NULL); ok(hr == E_FAIL, "Init returned 0x%08x\n", hr); /* try initializing with a different control */ hr = IAutoComplete_Init(ac, hEdit, acSource, NULL, NULL); ok(hr == E_FAIL, "Init returned 0x%08x\n", hr); DestroyWindow(edit_control); /* try initializing with a different control after * destroying the original initialization control */ hr = IAutoComplete_Init(ac, hEdit, acSource, NULL, NULL); ok(hr == E_UNEXPECTED || hr == E_FAIL, /* Win2k/XP/Win2k3 */ "Init returned 0x%08x\n", hr); IUnknown_Release(acSource); IAutoComplete_Release(ac); }
void figures::rectangle::openWindowSet3D(){ HWND hwnd; HWND h_text_a; HINSTANCE hInstance = GetModuleHandle(0); hwnd = CreateWindowExA(WS_EX_CLIENTEDGE, "rectangle", "", (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX), CW_USEDEFAULT, CW_USEDEFAULT, 500, 350, NULL, NULL, hInstance, NULL); //EDIT int xE = 120; //x pos int bE = 50; //Breite //STATIC int xS = 20; //x pos int bS = 90; //Breite //Höhe int hEaS = 25; //y position of boxes int top = 10; int deltaY = 30; //current Values int xSC = 180; //x pos int bSC = 100; //Breite double rotAngleXInDeg = (rotAngleX / (2 * pi))*(360); double rotAngleZInDeg = (rotAngleZ / (2 * pi))*(360); double phi0InDeg = (phi0 / (2 * pi))*(360); const string sA = use.numberToString(a); const string sB = use.numberToString(b); const string sPhi0 = use.numberToString(phi0InDeg); const string sRotAngleX = use.numberToString(rotAngleXInDeg); const string sRotAngleZ = use.numberToString(rotAngleZInDeg); const string sVelocity = use.numberToString(velocity); //Headline CreateWindow("STATIC", "Rectangle 3D ", WS_VISIBLE | WS_CHILD | SS_CENTER, xS, top, 290, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; CreateWindow("STATIC", "currently", WS_VISIBLE | WS_CHILD | SS_CENTER, xSC, top, bSC, hEaS, hwnd, NULL, hInstance, NULL); CreateWindow("STATIC", "For cutting in the x-y plane\nleave xRotAngle and zRotAngle = 0\n\nFor cutting perpendicular to the x - y plane\nleave phi0 = 0, \nand chose xRotAngle = 90" , WS_VISIBLE | WS_CHILD | SS_LEFT, xSC + bSC + 10, top, 180, 205, hwnd, NULL, hInstance, NULL); top += deltaY; //a CreateWindow("STATIC", "a = ", WS_VISIBLE | WS_CHILD | SS_RIGHT, xS, top, bS, hEaS, hwnd, NULL, hInstance, NULL); h_text_a = CreateWindow("EDIT", sA.c_str(), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, xE, top, bE, hEaS, hwnd, (HMENU)ID_TEXT_REC_a, hInstance, NULL); CreateWindow("STATIC", sA.c_str(), WS_VISIBLE | WS_CHILD | SS_RIGHT, xSC, top, bS, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; //b CreateWindow("STATIC", "b = ", WS_VISIBLE | WS_CHILD | SS_RIGHT, xS, top, bS, hEaS, hwnd, NULL, hInstance, NULL); CreateWindow("EDIT", sB.c_str(), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, xE, top, bE, hEaS, hwnd, (HMENU)ID_TEXT_REC_b, hInstance, NULL); CreateWindow("STATIC", sB.c_str(), WS_VISIBLE | WS_CHILD | SS_RIGHT, xSC, top, bS, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; //phi0 CreateWindow("STATIC", "phi0 = ", WS_VISIBLE | WS_CHILD | SS_RIGHT, xS, top, bS, hEaS, hwnd, NULL, hInstance, NULL); CreateWindow("EDIT", sPhi0.c_str(), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, xE, top, bE, hEaS, hwnd, (HMENU)ID_TEXT_REC_phi0, hInstance, NULL); CreateWindow("STATIC", sPhi0.c_str(), WS_VISIBLE | WS_CHILD | SS_RIGHT, xSC, top, bS, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; //xRotAngle CreateWindow("STATIC", "xRotAngle = ", WS_VISIBLE | WS_CHILD | SS_RIGHT, xS, top, bS, hEaS, hwnd, NULL, hInstance, NULL); CreateWindow("EDIT", sRotAngleX.c_str(), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, xE, top, bE, hEaS, hwnd, (HMENU)ID_TEXT_REC_xRotWinkel, hInstance, NULL); CreateWindow("STATIC", sRotAngleX.c_str(), WS_VISIBLE | WS_CHILD | SS_RIGHT, xSC, top, bS, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; //zRotAngle CreateWindow("STATIC", "zRotAngle = ", WS_VISIBLE | WS_CHILD | SS_RIGHT, xS, top, bS, hEaS, hwnd, NULL, hInstance, NULL); CreateWindow("EDIT", sRotAngleZ.c_str(), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, xE, top, bE, hEaS, hwnd, (HMENU)ID_TEXT_REC_zRotWinkel, hInstance, NULL); CreateWindow("STATIC", sRotAngleZ.c_str(), WS_VISIBLE | WS_CHILD | SS_RIGHT, xSC, top, bS, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; //velocity CreateWindow("STATIC", "velocity = ", WS_VISIBLE | WS_CHILD | SS_RIGHT, xS, top, bS, hEaS, hwnd, NULL, hInstance, NULL); CreateWindow("EDIT", sVelocity.c_str(), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, xE, top, bE, hEaS, hwnd, (HMENU)ID_TEXT_REC_velocity, hInstance, NULL); CreateWindow("STATIC", sVelocity.c_str(), WS_VISIBLE | WS_CHILD | SS_RIGHT, xSC, top, bS, hEaS, hwnd, NULL, hInstance, NULL); top += deltaY; //BUTTON CreateWindowEx(0, /* more or ''extended'' styles */ TEXT("BUTTON"), /* GUI ''class'' to create */ TEXT("OK"), /* GUI caption */ WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON | WS_TABSTOP, /* control styles separated by | */ 10, /* LEFT POSITION (Position from left) */ top, /* TOP POSITION (Position from Top) */ 290, /* WIDTH OF CONTROL */ 50, /* HEIGHT OF CONTROL */ hwnd, /* Parent window handle */ (HMENU)ID_OK_KNOPF_REC, /* control''s ID for WM_COMMAND */ hInstance, /* application instance */ NULL); //Show the window including all controls. ShowWindow(hwnd, 5); UpdateWindow(hwnd); SetForegroundWindow(hwnd); //set h_text_R on focus and mark text, such that user can start typing new values immidiately SetFocus(h_text_a); SendDlgItemMessage(hwnd, ID_TEXT_REC_a, EM_SETSEL, 0, -1); MSG Msg; while (GetMessage(&Msg, NULL, 0, 0) > 0) { if (IsDialogMessage(hwnd, &Msg)) { /* Already handled by dialog manager */ } else { TranslateMessage(&Msg); DispatchMessage(&Msg); } if (rec_BOOL) { //a //////////////////////////////////////////////////// use.assignValueToMember(G_Text_Rec_a, a, "a"); //b //////////////////////////////////////////////////// use.assignValueToMember(G_Text_Rec_b, b, "b"); //rotangleX //////////////////////////////////////////////////// use.assignValueToMember(G_Text_Rec_xRotWinkel, rotAngleX, "rotanglex"); rotAngleX = (rotAngleX / 360)*(2 * pi); //rotangleZ //////////////////////////////////////////////////// use.assignValueToMember(G_Text_Rec_zRotWinkel, rotAngleZ, "rotAngleZ"); rotAngleZ = (rotAngleZ / 360)*(2 * pi); //veclotiy //////////////////////////////////////////////////// use.assignValueToMember(G_Text_Rec_velocity, velocity, "velocity"); //phi0 //////////////////////////////////////////////////// use.assignValueToMember(G_Text_Rec_phi0, phi0, "phi0"); phi0 = (phi0 / 360)*(2 * pi); //Export Values s.t. they can be loaded the next time the program starts string name = "recLastValues.txt"; fstream f; f << fixed; f << setprecision(3); f.open(name, fstream::out | fstream::trunc); f.close(); f.open(name, fstream::out | fstream::app); f << a << endl; f << b << endl; f << phi0 << endl; f << rotAngleX << endl; f << rotAngleZ << endl; f << velocity << endl; f.close(); rec_BOOL = 0; } }//while }
int CALLBACK WinMain(_In_ HINSTANCE _HInstance, _In_ HINSTANCE _HPrevInstance, _In_ LPSTR _LpCmdLine, _In_ int _NCmdShow) { LARGE_INTEGER perfCountFrequencyResult; QueryPerformanceFrequency(&perfCountFrequencyResult); int64 perfCountFrequency = perfCountFrequencyResult.QuadPart; Win32LoadXInput(); WNDCLASS windowClass = {}; Win32ResizeDIBSection(&GlobalBackbuffer, 1280, 720); windowClass.style = CS_OWNDC|CS_HREDRAW|CS_VREDRAW; windowClass.lpfnWndProc = MainWindowCallback; windowClass.hInstance = _HInstance; //WindowClass.hIcon; //WindowClass.lpszMenuName; windowClass.lpszClassName = "HandmadeHeroWindowClass"; if (!RegisterClass(&windowClass)) { // TODO(jungyoun.la): Logging return 0; } HWND windowHandle = CreateWindowExA( 0, windowClass.lpszClassName, "Handmade Hero", WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, _HInstance, 0); if (!windowHandle) { // TODO(jungyoun.la): Logging return 0; } HDC deviceContext = GetDC(windowHandle); int32 blueOffset = 0; int32 greenOffset = 0; win32_sound_output soundOutput = {}; soundOutput.SamplesPerSecond = 48000; soundOutput.ToneHz = 256; soundOutput.ToneVolume = 3000; soundOutput.WavePeriod = soundOutput.SamplesPerSecond / soundOutput.ToneHz; soundOutput.BytesPerSample = sizeof(int16) * 2; soundOutput.SecondaryBufferSize = soundOutput.SamplesPerSecond * soundOutput.BytesPerSample; soundOutput.LatencySampleCount = soundOutput.SamplesPerSecond / 15; Win32InitDSound(windowHandle, soundOutput.SamplesPerSecond, soundOutput.SecondaryBufferSize); Win32FillSoundBuffer(&soundOutput, 0, soundOutput.LatencySampleCount * soundOutput.BytesPerSample); GlobalSecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING); GlobalRunning = true; // @See(jungyoun.la): https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx LARGE_INTEGER lastCounter; QueryPerformanceCounter(&lastCounter); uint64 lastCycleCount = __rdtsc(); while (GlobalRunning) { MSG message; while (PeekMessage(&message, 0, 0, 0, PM_REMOVE)) { if (message.message == WM_QUIT) { GlobalRunning = false; } TranslateMessage(&message); DispatchMessageA(&message); } // TODO(jungyoun.la): Should we poll this more frequently. for (DWORD controllerIndex = 0; controllerIndex < XUSER_MAX_COUNT; controllerIndex++) { XINPUT_STATE controllerState; ZeroMemory(&controllerState, sizeof(XINPUT_STATE)); if (XInputGetState(controllerIndex, &controllerState) == ERROR_SUCCESS) { // Controller is connected XINPUT_GAMEPAD* pad = &controllerState.Gamepad; bool up = (pad->wButtons & XINPUT_GAMEPAD_DPAD_UP); bool down = (pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN); bool left = (pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT); bool right = (pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT); bool start = (pad->wButtons & XINPUT_GAMEPAD_START); bool back = (pad->wButtons & XINPUT_GAMEPAD_BACK); bool leftShoulder = (pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER); bool rightShoulder = (pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER); bool aButton = (pad->wButtons & XINPUT_GAMEPAD_A); bool bButton = (pad->wButtons & XINPUT_GAMEPAD_B); bool xButton = (pad->wButtons & XINPUT_GAMEPAD_X); bool yButton = (pad->wButtons & XINPUT_GAMEPAD_Y); int16 stickX = pad->sThumbLX; int16 stickY = pad->sThumbLY; blueOffset += stickX >> 12; greenOffset -= stickY >> 12; } else { // Controller is not connected } }
static void test_setinfo(void) { WNDCLASSA wc; LRESULT lResult; HWND parent, parent2, hwndTip, hwndTip2; TTTOOLINFOA toolInfo = { 0 }; TTTOOLINFOA toolInfo2 = { 0 }; WNDPROC wndProc; /* Create a class to use the custom draw wndproc */ wc.style = CS_HREDRAW | CS_VREDRAW; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandleA(NULL); wc.hIcon = NULL; wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW); wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW); wc.lpszMenuName = NULL; wc.lpszClassName = "SetInfoClass"; wc.lpfnWndProc = info_wnd_proc; RegisterClassA(&wc); /* Create a main window */ parent = CreateWindowExA(0, "SetInfoClass", NULL, WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE, 50, 50, 300, 300, NULL, NULL, NULL, 0); ok(parent != NULL, "Creation of main window failed\n"); parent2 = CreateWindowExA(0, "SetInfoClass", NULL, WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE, 50, 50, 300, 300, NULL, NULL, NULL, 0); ok(parent2 != NULL, "Creation of main window failed\n"); /* Make it show */ ShowWindow(parent2, SW_SHOWNORMAL); flush_events(100); /* Create Tooltip */ hwndTip = CreateWindowExA(WS_EX_TOPMOST, TOOLTIPS_CLASSA, NULL, TTS_NOPREFIX | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, parent, NULL, GetModuleHandleA(NULL), 0); ok(hwndTip != NULL, "Creation of tooltip window failed\n"); hwndTip2 = CreateWindowExA(WS_EX_TOPMOST, TOOLTIPS_CLASSA, NULL, TTS_NOPREFIX | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, parent, NULL, GetModuleHandleA(NULL), 0); ok(hwndTip2 != NULL, "Creation of tooltip window failed\n"); /* Make it topmost, as per the MSDN */ SetWindowPos(hwndTip, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); /* Create a tool */ toolInfo.cbSize = TTTOOLINFOA_V1_SIZE; toolInfo.hwnd = parent; toolInfo.hinst = GetModuleHandleA(NULL); toolInfo.uFlags = TTF_SUBCLASS; toolInfo.uId = 0x1234ABCD; toolInfo.lpszText = (LPSTR)"This is a test tooltip"; toolInfo.lParam = 0xdeadbeef; GetClientRect (parent, &toolInfo.rect); lResult = SendMessageA(hwndTip, TTM_ADDTOOLA, 0, (LPARAM)&toolInfo); ok(lResult, "Adding the tool to the tooltip failed\n"); toolInfo.cbSize = TTTOOLINFOA_V1_SIZE; toolInfo.hwnd = parent2; toolInfo.hinst = GetModuleHandleA(NULL); toolInfo.uFlags = 0; toolInfo.uId = 0x1234ABCE; toolInfo.lpszText = (LPSTR)"This is a test tooltip"; toolInfo.lParam = 0xdeadbeef; GetClientRect (parent, &toolInfo.rect); lResult = SendMessageA(hwndTip, TTM_ADDTOOLA, 0, (LPARAM)&toolInfo); ok(lResult, "Adding the tool to the tooltip failed\n"); /* Try to Remove Subclass */ toolInfo2.cbSize = TTTOOLINFOA_V1_SIZE; toolInfo2.hwnd = parent; toolInfo2.uId = 0x1234ABCD; lResult = SendMessageA(hwndTip, TTM_GETTOOLINFOA, 0, (LPARAM)&toolInfo2); ok(lResult, "GetToolInfo failed\n"); ok(toolInfo2.uFlags & TTF_SUBCLASS, "uFlags does not have subclass\n"); wndProc = (WNDPROC)GetWindowLongPtrA(parent, GWLP_WNDPROC); ok (wndProc != info_wnd_proc, "Window Proc is wrong\n"); toolInfo2.uFlags &= ~TTF_SUBCLASS; SendMessageA(hwndTip, TTM_SETTOOLINFOA, 0, (LPARAM)&toolInfo2); lResult = SendMessageA(hwndTip, TTM_GETTOOLINFOA, 0, (LPARAM)&toolInfo2); ok(lResult, "GetToolInfo failed\n"); ok(!(toolInfo2.uFlags & TTF_SUBCLASS), "uFlags has subclass\n"); wndProc = (WNDPROC)GetWindowLongPtrA(parent, GWLP_WNDPROC); ok (wndProc != info_wnd_proc, "Window Proc is wrong\n"); /* Try to Add Subclass */ /* Make it topmost, as per the MSDN */ SetWindowPos(hwndTip2, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); toolInfo2.cbSize = TTTOOLINFOA_V1_SIZE; toolInfo2.hwnd = parent2; toolInfo2.uId = 0x1234ABCE; lResult = SendMessageA(hwndTip, TTM_GETTOOLINFOA, 0, (LPARAM)&toolInfo2); ok(lResult, "GetToolInfo failed\n"); ok(!(toolInfo2.uFlags & TTF_SUBCLASS), "uFlags has subclass\n"); wndProc = (WNDPROC)GetWindowLongPtrA(parent2, GWLP_WNDPROC); ok (wndProc == info_wnd_proc, "Window Proc is wrong\n"); toolInfo2.uFlags |= TTF_SUBCLASS; SendMessageA(hwndTip, TTM_SETTOOLINFOA, 0, (LPARAM)&toolInfo2); lResult = SendMessageA(hwndTip, TTM_GETTOOLINFOA, 0, (LPARAM)&toolInfo2); ok(lResult, "GetToolInfo failed\n"); ok(toolInfo2.uFlags & TTF_SUBCLASS, "uFlags does not have subclass\n"); wndProc = (WNDPROC)GetWindowLongPtrA(parent2, GWLP_WNDPROC); ok (wndProc == info_wnd_proc, "Window Proc is wrong\n"); /* Clean up */ DestroyWindow(hwndTip); DestroyWindow(hwndTip2); DestroyWindow(parent); DestroyWindow(parent2); }
static void test_WM_LBUTTONDOWN(void) { HWND hComboEx, hCombo, hEdit, hList; COMBOBOXINFO cbInfo; UINT x, y, item_height; LRESULT result; UINT i; int idx; RECT rect; WCHAR buffer[3]; static const UINT choices[] = {8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72}; static const WCHAR stringFormat[] = {'%','2','d','\0'}; BOOL (WINAPI *pGetComboBoxInfo)(HWND, PCOMBOBOXINFO); pGetComboBoxInfo = (void*)GetProcAddress(GetModuleHandleA("user32.dll"), "GetComboBoxInfo"); if (!pGetComboBoxInfo){ win_skip("GetComboBoxInfo is not available\n"); return; } hComboEx = CreateWindowExA(0, WC_COMBOBOXEXA, NULL, WS_VISIBLE|WS_CHILD|CBS_DROPDOWN, 0, 0, 200, 150, hComboExParentWnd, NULL, hMainHinst, NULL); for (i = 0; i < sizeof(choices)/sizeof(UINT); i++){ COMBOBOXEXITEMW cbexItem; wsprintfW(buffer, stringFormat, choices[i]); memset(&cbexItem, 0x00, sizeof(cbexItem)); cbexItem.mask = CBEIF_TEXT; cbexItem.iItem = i; cbexItem.pszText = buffer; cbexItem.cchTextMax = 0; ok(SendMessageW(hComboEx, CBEM_INSERTITEMW, 0, (LPARAM)&cbexItem) >= 0, "Failed to add item %d\n", i); } hCombo = (HWND)SendMessageA(hComboEx, CBEM_GETCOMBOCONTROL, 0, 0); hEdit = (HWND)SendMessageA(hComboEx, CBEM_GETEDITCONTROL, 0, 0); cbInfo.cbSize = sizeof(COMBOBOXINFO); result = pGetComboBoxInfo(hCombo, &cbInfo); ok(result, "Failed to get combobox info structure. LastError=%d\n", GetLastError()); hList = cbInfo.hwndList; ok(GetFocus() == hComboExParentWnd, "Focus not on Main Window, instead on %p\n", GetFocus()); /* Click on the button to drop down the list */ x = cbInfo.rcButton.left + (cbInfo.rcButton.right-cbInfo.rcButton.left)/2; y = cbInfo.rcButton.top + (cbInfo.rcButton.bottom-cbInfo.rcButton.top)/2; result = SendMessageA(hCombo, WM_LBUTTONDOWN, 0, MAKELPARAM(x, y)); ok(result, "WM_LBUTTONDOWN was not processed. LastError=%d\n", GetLastError()); ok(GetFocus() == hCombo || broken(GetFocus() != hCombo), /* win98 */ "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n", GetFocus()); ok(SendMessageA(hComboEx, CB_GETDROPPEDSTATE, 0, 0), "The dropdown list should have appeared after clicking the button.\n"); idx = SendMessageA(hCombo, CB_GETTOPINDEX, 0, 0); ok(idx == 0, "For TopIndex expected %d, got %d\n", 0, idx); result = SendMessageA(hCombo, WM_LBUTTONUP, 0, MAKELPARAM(x, y)); ok(result, "WM_LBUTTONUP was not processed. LastError=%d\n", GetLastError()); ok(GetFocus() == hCombo || broken(GetFocus() != hCombo), /* win98 */ "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n", GetFocus()); /* Click on the 5th item in the list */ item_height = SendMessageA(hCombo, CB_GETITEMHEIGHT, 0, 0); ok(GetClientRect(hList, &rect), "Failed to get list's client rect.\n"); x = rect.left + (rect.right-rect.left)/2; y = item_height/2 + item_height*4; result = SendMessageA(hList, WM_MOUSEMOVE, 0, MAKELPARAM(x, y)); ok(!result, "WM_MOUSEMOVE was not processed. LastError=%d\n", GetLastError()); ok(GetFocus() == hCombo || broken(GetFocus() != hCombo), /* win98 */ "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n", GetFocus()); result = SendMessageA(hList, WM_LBUTTONDOWN, 0, MAKELPARAM(x, y)); ok(!result, "WM_LBUTTONDOWN was not processed. LastError=%d\n", GetLastError()); ok(GetFocus() == hCombo || broken(GetFocus() != hCombo), /* win98 */ "Focus not on ComboBoxEx's ComboBox Control, instead on %p\n", GetFocus()); ok(SendMessageA(hComboEx, CB_GETDROPPEDSTATE, 0, 0), "The dropdown list should still be visible.\n"); result = SendMessageA(hList, WM_LBUTTONUP, 0, MAKELPARAM(x, y)); ok(!result, "WM_LBUTTONUP was not processed. LastError=%d\n", GetLastError()); todo_wine ok(GetFocus() == hEdit || broken(GetFocus() == hCombo), /* win98 */ "Focus not on ComboBoxEx's Edit Control, instead on %p\n", GetFocus()); result = SendMessageA(hCombo, CB_GETDROPPEDSTATE, 0, 0); ok(!result || broken(result != 0), /* win98 */ "The dropdown list should have been rolled up.\n"); idx = SendMessageA(hComboEx, CB_GETCURSEL, 0, 0); ok(idx == 4 || broken(idx == -1), /* win98 */ "Current Selection: expected %d, got %d\n", 4, idx); ok(received_end_edit, "Expected to receive a CBEN_ENDEDIT message\n"); SetFocus( hComboExParentWnd ); ok( GetFocus() == hComboExParentWnd, "got %p\n", GetFocus() ); SetFocus( hComboEx ); ok( GetFocus() == hEdit, "got %p\n", GetFocus() ); DestroyWindow(hComboEx); }
static void test_GetRandomRgn(void) { HWND hwnd = CreateWindowExA(0,"BUTTON","test",WS_VISIBLE|WS_POPUP,0,0,100,100,GetDesktopWindow(),0,0,0); HDC hdc; HRGN hrgn = CreateRectRgn(0, 0, 0, 0); int ret; RECT rc, rc2; RECT ret_rc, window_rc; ok( hwnd != 0, "CreateWindow failed\n" ); SetRect(&window_rc, 400, 300, 500, 400); SetWindowPos(hwnd, HWND_TOPMOST, window_rc.left, window_rc.top, window_rc.right - window_rc.left, window_rc.bottom - window_rc.top, 0 ); hdc = GetDC(hwnd); ret = GetRandomRgn(hdc, hrgn, 1); ok(ret == 0, "GetRandomRgn rets %d\n", ret); ret = GetRandomRgn(hdc, hrgn, 2); ok(ret == 0, "GetRandomRgn rets %d\n", ret); ret = GetRandomRgn(hdc, hrgn, 3); ok(ret == 0, "GetRandomRgn rets %d\n", ret); /* Set a clip region */ SetRect(&rc, 20, 20, 80, 80); IntersectClipRect(hdc, rc.left, rc.top, rc.right, rc.bottom); ret = GetRandomRgn(hdc, hrgn, 1); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); ret = GetRandomRgn(hdc, hrgn, 2); ok(ret == 0, "GetRandomRgn rets %d\n", ret); ret = GetRandomRgn(hdc, hrgn, 3); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); /* Move the clip to the meta and clear the clip */ SetMetaRgn(hdc); ret = GetRandomRgn(hdc, hrgn, 1); ok(ret == 0, "GetRandomRgn rets %d\n", ret); ret = GetRandomRgn(hdc, hrgn, 2); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); ret = GetRandomRgn(hdc, hrgn, 3); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); /* Set a new clip (still got the meta) */ SetRect(&rc2, 10, 30, 70, 90); IntersectClipRect(hdc, rc2.left, rc2.top, rc2.right, rc2.bottom); ret = GetRandomRgn(hdc, hrgn, 1); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc2, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); ret = GetRandomRgn(hdc, hrgn, 2); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); IntersectRect(&rc2, &rc, &rc2); ret = GetRandomRgn(hdc, hrgn, 3); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); ok(EqualRect(&rc2, &ret_rc), "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); ret = GetRandomRgn(hdc, hrgn, SYSRGN); ok(ret != 0, "GetRandomRgn rets %d\n", ret); GetRgnBox(hrgn, &ret_rc); if(GetVersion() & 0x80000000) OffsetRect(&window_rc, -window_rc.left, -window_rc.top); /* the window may be partially obscured so the region may be smaller */ IntersectRect( &window_rc, &ret_rc, &ret_rc ); ok(EqualRect(&window_rc, &ret_rc) || broken(IsRectEmpty(&ret_rc)), /* win95 */ "GetRandomRgn %d,%d - %d,%d\n", ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom); DeleteObject(hrgn); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); }
bool Win32Window::Initialize(const char* name, size_t width, size_t height) { Destroy(); IsMouseInWindow(false); parentClassName = name; childClassName = parentClassName + "_Child"; // Work around compile error from not defining "UNICODE" while Chromium does const LPSTR idcArrow = MAKEINTRESOURCEA(32512); WNDCLASSEXA parentWindowClass = { 0 }; parentWindowClass.cbSize = sizeof(WNDCLASSEXA); parentWindowClass.style = 0; parentWindowClass.lpfnWndProc = WndProc; parentWindowClass.cbClsExtra = 0; parentWindowClass.cbWndExtra = 0; parentWindowClass.hInstance = GetModuleHandle(NULL); parentWindowClass.hIcon = NULL; parentWindowClass.hCursor = LoadCursorA(NULL, idcArrow); parentWindowClass.hbrBackground = 0; parentWindowClass.lpszMenuName = NULL; parentWindowClass.lpszClassName = parentClassName.c_str(); if (!RegisterClassExA(&parentWindowClass)) { return false; } WNDCLASSEXA childWindowClass = { 0 }; childWindowClass.cbSize = sizeof(WNDCLASSEXA); childWindowClass.style = CS_OWNDC; childWindowClass.lpfnWndProc = WndProc; childWindowClass.cbClsExtra = 0; childWindowClass.cbWndExtra = 0; childWindowClass.hInstance = GetModuleHandle(NULL); childWindowClass.hIcon = NULL; childWindowClass.hCursor = LoadCursorA(NULL, idcArrow); childWindowClass.hbrBackground = 0; childWindowClass.lpszMenuName = NULL; childWindowClass.lpszClassName = childClassName.c_str(); if (!RegisterClassExA(&childWindowClass)) { return false; } DWORD parentStyle = WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SYSMENU; DWORD parentExtendedStyle = WS_EX_APPWINDOW; RECT sizeRect = { 0, 0, static_cast<LONG>(width), static_cast<LONG>(height) }; AdjustWindowRectEx(&sizeRect, parentStyle, FALSE, parentExtendedStyle); parentWindow = CreateWindowExA( parentExtendedStyle, parentClassName.c_str(), name, parentStyle, CW_USEDEFAULT, CW_USEDEFAULT, sizeRect.right - sizeRect.left, sizeRect.bottom - sizeRect.top, NULL, NULL, GetModuleHandle(NULL), this ); nativeWindow = CreateWindowExA( 0, childClassName.c_str(), name, WS_CHILD, 0, 0, static_cast<int>(width), static_cast<int>(height), parentWindow, NULL, GetModuleHandle(NULL), this ); nativeDisplay = GetDC(nativeWindow); if (!nativeDisplay) { Destroy(); return false; } { Event event; event.Type = Event::EVENT_INIT_WINDOW; event.Time = GetTickCount64(); PushEvent(event); } return true; }
/* * Opens a window. Requires a SFG_Window object created and attached * to the freeglut structure. OpenGL context is created here. */ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, int h, GLboolean gameMode, GLboolean isSubWindow ) { #if TARGET_HOST_UNIX_X11 XSetWindowAttributes winAttr; XTextProperty textProperty; XSizeHints sizeHints; XWMHints wmHints; unsigned long mask; unsigned int current_DisplayMode = fgState.DisplayMode ; /* Save the display mode if we are creating a menu window */ if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ; window->Window.VisualInfo = fgChooseVisual( ); if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = current_DisplayMode ; if( ! window->Window.VisualInfo ) { /* * The "fgChooseVisual" returned a null meaning that the visual * context is not available. * Try a couple of variations to see if they will work. */ if( !( fgState.DisplayMode & GLUT_DOUBLE ) ) { fgState.DisplayMode |= GLUT_DOUBLE ; window->Window.VisualInfo = fgChooseVisual( ); fgState.DisplayMode &= ~GLUT_DOUBLE; } /* * GLUT also checks for multi-sampling, but I don't see that * anywhere else in FREEGLUT so I won't bother with it for the moment. */ } FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.VisualInfo != NULL, "Visual with necessary capabilities not found", "fgOpenWindow" ); /* * XXX HINT: the masks should be updated when adding/removing callbacks. * XXX This might speed up message processing. Is that true? * XXX * XXX A: Not appreciably, but it WILL make it easier to debug. * XXX Try tracing old GLUT and try tracing freeglut. Old GLUT * XXX turns off events that it doesn't need and is a whole lot * XXX more pleasant to trace. (Think mouse-motion! Tons of * XXX ``bonus'' GUI events stream in.) */ winAttr.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask; winAttr.background_pixmap = None; winAttr.background_pixel = 0; winAttr.border_pixel = 0; winAttr.colormap = XCreateColormap( fgDisplay.Display, fgDisplay.RootWindow, window->Window.VisualInfo->visual, AllocNone ); mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; if( window->IsMenu || ( gameMode == GL_TRUE ) ) { winAttr.override_redirect = True; mask |= CWOverrideRedirect; } window->Window.Handle = XCreateWindow( fgDisplay.Display, window->Parent == NULL ? fgDisplay.RootWindow : window->Parent->Window.Handle, x, y, w, h, 0, window->Window.VisualInfo->depth, InputOutput, window->Window.VisualInfo->visual, mask, &winAttr ); /* * The GLX context creation, possibly trying the direct context rendering * or else use the current context if the user has so specified */ if( window->IsMenu ) { /* * If there isn't already an OpenGL rendering context for menu * windows, make one */ if( !fgStructure.MenuContext ) { fgStructure.MenuContext = (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) ); fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo; fgStructure.MenuContext->Context = glXCreateContext( fgDisplay.Display, fgStructure.MenuContext->VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } /* window->Window.Context = fgStructure.MenuContext->Context; */ window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } else if( fgState.UseCurrentContext ) { window->Window.Context = glXGetCurrentContext( ); if( ! window->Window.Context ) window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } else window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); #if !defined( __FreeBSD__ ) && !defined( __NetBSD__ ) if( !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) { if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT ) fgError( "Unable to force direct context rendering for window '%s'", title ); else if( fgState.DirectContext == GLUT_TRY_DIRECT_CONTEXT ) fgWarning( "Unable to create direct context rendering for window '%s'\nThis may hurt performance.", title ); } #endif /* * XXX Assume the new window is visible by default * XXX Is this a safe assumption? */ window->State.Visible = GL_TRUE; sizeHints.flags = 0; if ( fgState.Position.Use ) sizeHints.flags |= USPosition; if ( fgState.Size.Use ) sizeHints.flags |= USSize; /* * Fill in the size hints values now (the x, y, width and height * settings are obsolete, are there any more WMs that support them?) * Unless the X servers actually stop supporting these, we should * continue to fill them in. It is *not* our place to tell the user * that they should replace a window manager that they like, and which * works, just because *we* think that it's not "modern" enough. */ sizeHints.x = x; sizeHints.y = y; sizeHints.width = w; sizeHints.height = h; wmHints.flags = StateHint; wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState; /* Prepare the window and iconified window names... */ XStringListToTextProperty( (char **) &title, 1, &textProperty ); XSetWMProperties( fgDisplay.Display, window->Window.Handle, &textProperty, &textProperty, 0, 0, &sizeHints, &wmHints, NULL ); XFree( textProperty.value ); XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 ); glXMakeCurrent( fgDisplay.Display, window->Window.Handle, window->Window.Context ); XMapWindow( fgDisplay.Display, window->Window.Handle ); #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE WNDCLASS wc; DWORD flags; DWORD exFlags = 0; ATOM atom; /* Grab the window class we have registered on glutInit(): */ atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found", "fgOpenWindow" ); if( gameMode ) { FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL, "Game mode being invoked on a subwindow", "fgOpenWindow" ); /* * Set the window creation flags appropriately to make the window * entirely visible: */ flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; } else { #if !TARGET_HOST_WINCE if ( ( ! isSubWindow ) && ( ! window->IsMenu ) ) { /* * Update the window dimensions, taking account of window * decorations. "freeglut" is to create the window with the * outside of its border at (x,y) and with dimensions (w,h). */ w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2; h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + GetSystemMetrics( SM_CYCAPTION ); } #endif /* TARGET_HOST_WINCE */ if( ! fgState.Position.Use ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; } if( ! fgState.Size.Use ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; } /* * There's a small difference between creating the top, child and * game mode windows */ flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; if ( window->IsMenu ) { flags |= WS_POPUP; exFlags |= WS_EX_TOOLWINDOW; } #if !TARGET_HOST_WINCE else if( window->Parent == NULL ) flags |= WS_OVERLAPPEDWINDOW; #endif else flags |= WS_CHILD; } #if TARGET_HOST_WINCE { wchar_t* wstr = fghWstrFromStr(title); window->Window.Handle = CreateWindow( _T("FREEGLUT"), wstr, WS_VISIBLE | WS_POPUP, 0,0, 240,320, NULL, NULL, fgDisplay.Instance, (LPVOID) window ); free(wstr); SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON); SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON); SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR); MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE); ShowWindow(window->Window.Handle, SW_SHOW); UpdateWindow(window->Window.Handle); } #else window->Window.Handle = CreateWindowExA( exFlags, "FREEGLUT", title, flags, x, y, w, h, (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, (HMENU) NULL, fgDisplay.Instance, (LPVOID) window ); #endif /* TARGET_HOST_WINCE */ if( !( window->Window.Handle ) ) fgError( "Failed to create a window (%s)!", title ); #if TARGET_HOST_WINCE ShowWindow( window->Window.Handle, SW_SHOW ); #else ShowWindow( window->Window.Handle, fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); #endif /* TARGET_HOST_WINCE */ UpdateWindow( window->Window.Handle ); ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */ #endif fgSetWindow( window ); window->Window.DoubleBuffered = ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0; if ( ! window->Window.DoubleBuffered ) { glDrawBuffer ( GL_FRONT ); glReadBuffer ( GL_FRONT ); } }
static HWND create_progress(DWORD style) { return CreateWindowExA(0, PROGRESS_CLASSA, "", WS_VISIBLE | style, 0, 0, 100, 20, NULL, NULL, GetModuleHandleA(NULL), 0); }
static DWORD WINAPI detectCDThread(LPVOID lpParameter) { const char *classname = "PhysicsFSDetectCDCatcher"; const char *winname = "PhysicsFSDetectCDMsgWindow"; HINSTANCE hInstance = GetModuleHandleW(NULL); ATOM class_atom = 0; WNDCLASSEXA wce; MSG msg; memset(&wce, '\0', sizeof (wce)); wce.cbSize = sizeof (wce); wce.lpfnWndProc = detectCDWndProc; wce.lpszClassName = classname; wce.hInstance = hInstance; class_atom = RegisterClassExA(&wce); if (class_atom == 0) { initialDiscDetectionComplete = 1; /* let main thread go on. */ return 0; } /* if */ detectCDHwnd = CreateWindowExA(0, classname, winname, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, HWND_DESKTOP, NULL, hInstance, NULL); if (detectCDHwnd == NULL) { initialDiscDetectionComplete = 1; /* let main thread go on. */ UnregisterClassA(classname, hInstance); return 0; } /* if */ /* We'll get events when discs come and go from now on. */ /* Do initial detection, possibly blocking awhile... */ drivesWithMediaBitmap = pollDiscDrives(); initialDiscDetectionComplete = 1; /* let main thread go on. */ do { const BOOL rc = GetMessageW(&msg, detectCDHwnd, 0, 0); if ((rc == 0) || (rc == -1)) break; /* don't care if WM_QUIT or error break this loop. */ TranslateMessage(&msg); DispatchMessageW(&msg); } while (1); /* we've been asked to quit. */ DestroyWindow(detectCDHwnd); do { const BOOL rc = GetMessage(&msg, detectCDHwnd, 0, 0); if ((rc == 0) || (rc == -1)) break; TranslateMessage(&msg); DispatchMessageW(&msg); } while (1); UnregisterClassA(classname, hInstance); return 0; } /* detectCDThread */
static void test_gettext(void) { static const CHAR testtip2A[] = "testtip\ttest2"; static const CHAR testtipA[] = "testtip"; HWND hwnd, notify; TTTOOLINFOA toolinfoA; TTTOOLINFOW toolinfoW; LRESULT r; CHAR bufA[10] = ""; WCHAR bufW[10] = { 0 }; DWORD length, style; notify = create_parent_window(); ok(notify != NULL, "Expected notification window to be created\n"); /* For bug 14790 - lpszText is NULL */ hwnd = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0, 10, 10, 300, 100, NULL, NULL, NULL, 0); ok(hwnd != NULL, "failed to create tooltip wnd\n"); /* use sizeof(TTTOOLINFOA) instead of TTTOOLINFOA_V1_SIZE so that adding it fails on Win9x */ /* otherwise it crashes on the NULL lpszText */ toolinfoA.cbSize = sizeof(TTTOOLINFOA); toolinfoA.hwnd = NULL; toolinfoA.hinst = GetModuleHandleA(NULL); toolinfoA.uFlags = 0; toolinfoA.uId = 0x1234ABCD; toolinfoA.lpszText = NULL; toolinfoA.lParam = 0xdeadbeef; GetClientRect(hwnd, &toolinfoA.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&toolinfoA); ok(r, "got %ld\n", r); toolinfoA.hwnd = NULL; toolinfoA.uId = 0x1234abcd; toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTEXTA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); ok(!*toolinfoA.lpszText, "lpszText should be empty, got %s\n", toolinfoA.lpszText); toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTOOLINFOA, 0, (LPARAM)&toolinfoA); todo_wine ok(!r, "got %ld\n", r); ok(toolinfoA.lpszText == NULL, "expected NULL, got %p\n", toolinfoA.lpszText); /* NULL hinst, valid resource id for text */ toolinfoA.cbSize = sizeof(TTTOOLINFOA); toolinfoA.hwnd = NULL; toolinfoA.hinst = NULL; toolinfoA.uFlags = 0; toolinfoA.uId = 0x1233abcd; toolinfoA.lpszText = MAKEINTRESOURCEA(IDS_TBADD1); toolinfoA.lParam = 0xdeadbeef; GetClientRect(hwnd, &toolinfoA.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&toolinfoA); ok(r, "failed to add a tool\n"); toolinfoA.hwnd = NULL; toolinfoA.uId = 0x1233abcd; toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTEXTA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); ok(!strcmp(toolinfoA.lpszText, "abc"), "got wrong text, %s\n", toolinfoA.lpszText); toolinfoA.hinst = (HINSTANCE)0xdeadbee; r = SendMessageA(hwnd, TTM_GETTOOLINFOA, 0, (LPARAM)&toolinfoA); todo_wine ok(!r, "got %ld\n", r); ok(toolinfoA.hinst == NULL, "expected NULL, got %p\n", toolinfoA.hinst); r = SendMessageA(hwnd, TTM_DELTOOLA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); /* add another tool with text */ toolinfoA.cbSize = sizeof(TTTOOLINFOA); toolinfoA.hwnd = NULL; toolinfoA.hinst = GetModuleHandleA(NULL); toolinfoA.uFlags = 0; toolinfoA.uId = 0x1235ABCD; strcpy(bufA, testtipA); toolinfoA.lpszText = bufA; toolinfoA.lParam = 0xdeadbeef; GetClientRect(hwnd, &toolinfoA.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&toolinfoA); ok(r, "Adding the tool to the tooltip failed\n"); length = SendMessageA(hwnd, WM_GETTEXTLENGTH, 0, 0); ok(length == 0, "Expected 0, got %d\n", length); toolinfoA.hwnd = NULL; toolinfoA.uId = 0x1235abcd; toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTEXTA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); ok(!strcmp(toolinfoA.lpszText, testtipA), "expected %s, got %p\n", testtipA, toolinfoA.lpszText); memset(bufA, 0x1f, sizeof(bufA)); toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTOOLINFOA, 0, (LPARAM)&toolinfoA); todo_wine ok(!r, "got %ld\n", r); ok(!strcmp(toolinfoA.lpszText, testtipA), "expected %s, got %p\n", testtipA, toolinfoA.lpszText); length = SendMessageA(hwnd, WM_GETTEXTLENGTH, 0, 0); ok(length == 0, "Expected 0, got %d\n", length); /* add another with callback text */ toolinfoA.cbSize = sizeof(TTTOOLINFOA); toolinfoA.hwnd = notify; toolinfoA.hinst = GetModuleHandleA(NULL); toolinfoA.uFlags = 0; toolinfoA.uId = 0x1236ABCD; toolinfoA.lpszText = LPSTR_TEXTCALLBACKA; toolinfoA.lParam = 0xdeadbeef; GetClientRect(hwnd, &toolinfoA.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&toolinfoA); ok(r, "Adding the tool to the tooltip failed\n"); toolinfoA.hwnd = notify; toolinfoA.uId = 0x1236abcd; toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTEXTA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); ok(!strcmp(toolinfoA.lpszText, testcallbackA), "lpszText should be an (%s) string\n", testcallbackA); toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTOOLINFOA, 0, (LPARAM)&toolinfoA); todo_wine ok(!r, "got %ld\n", r); ok(toolinfoA.lpszText == LPSTR_TEXTCALLBACKA, "expected LPSTR_TEXTCALLBACKA, got %p\n", toolinfoA.lpszText); DestroyWindow(hwnd); DestroyWindow(notify); hwnd = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL, 0, 10, 10, 300, 100, NULL, NULL, NULL, 0); ok(hwnd != NULL, "failed to create tooltip wnd\n"); toolinfoW.cbSize = sizeof(TTTOOLINFOW); toolinfoW.hwnd = NULL; toolinfoW.hinst = GetModuleHandleA(NULL); toolinfoW.uFlags = 0; toolinfoW.uId = 0x1234ABCD; toolinfoW.lpszText = NULL; toolinfoW.lParam = 0xdeadbeef; GetClientRect(hwnd, &toolinfoW.rect); r = SendMessageW(hwnd, TTM_ADDTOOLW, 0, (LPARAM)&toolinfoW); ok(!r, "Adding the tool to the tooltip succeeded!\n"); if (0) /* crashes on NT4 */ { toolinfoW.hwnd = NULL; toolinfoW.uId = 0x1234ABCD; toolinfoW.lpszText = bufW; SendMessageW(hwnd, TTM_GETTEXTW, 0, (LPARAM)&toolinfoW); ok(toolinfoW.lpszText[0] == 0, "lpszText should be an empty string\n"); } /* text with embedded tabs */ toolinfoA.cbSize = sizeof(TTTOOLINFOA); toolinfoA.hwnd = NULL; toolinfoA.hinst = GetModuleHandleA(NULL); toolinfoA.uFlags = 0; toolinfoA.uId = 0x1235abce; strcpy(bufA, testtip2A); toolinfoA.lpszText = bufA; toolinfoA.lParam = 0xdeadbeef; GetClientRect(hwnd, &toolinfoA.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&toolinfoA); ok(r, "got %ld\n", r); toolinfoA.hwnd = NULL; toolinfoA.uId = 0x1235abce; toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTEXTA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); ok(!strcmp(toolinfoA.lpszText, testtipA), "expected %s, got %s\n", testtipA, toolinfoA.lpszText); /* enable TTS_NOPREFIX, original text is retained */ style = GetWindowLongA(hwnd, GWL_STYLE); SetWindowLongA(hwnd, GWL_STYLE, style | TTS_NOPREFIX); toolinfoA.hwnd = NULL; toolinfoA.uId = 0x1235abce; toolinfoA.lpszText = bufA; r = SendMessageA(hwnd, TTM_GETTEXTA, 0, (LPARAM)&toolinfoA); ok(!r, "got %ld\n", r); ok(!strcmp(toolinfoA.lpszText, testtip2A), "expected %s, got %s\n", testtip2A, toolinfoA.lpszText); DestroyWindow(hwnd); }
static void test_ttm_gettoolinfo(void) { TTTOOLINFOA ti; TTTOOLINFOW tiW; HWND hwnd; DWORD r; hwnd = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0, 10, 10, 300, 100, NULL, NULL, NULL, 0); ti.cbSize = TTTOOLINFOA_V2_SIZE; ti.hwnd = NULL; ti.hinst = GetModuleHandleA(NULL); ti.uFlags = 0; ti.uId = 0x1234ABCD; ti.lpszText = NULL; ti.lParam = 0x1abe11ed; GetClientRect(hwnd, &ti.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti); ok(r, "Adding the tool to the tooltip failed\n"); ti.cbSize = TTTOOLINFOA_V2_SIZE; ti.lParam = 0xaaaaaaaa; r = SendMessageA(hwnd, TTM_GETTOOLINFOA, 0, (LPARAM)&ti); ok(r, "Getting tooltip info failed\n"); ok(0x1abe11ed == ti.lParam || broken(0x1abe11ed != ti.lParam), /* comctl32 < 5.81 */ "Expected 0x1abe11ed, got %lx\n", ti.lParam); tiW.cbSize = TTTOOLINFOW_V2_SIZE; tiW.hwnd = NULL; tiW.uId = 0x1234ABCD; tiW.lParam = 0xaaaaaaaa; tiW.lpszText = NULL; r = SendMessageA(hwnd, TTM_GETTOOLINFOW, 0, (LPARAM)&tiW); ok(r, "Getting tooltip info failed\n"); ok(0x1abe11ed == tiW.lParam || broken(0x1abe11ed != tiW.lParam), /* comctl32 < 5.81 */ "Expected 0x1abe11ed, got %lx\n", tiW.lParam); ti.cbSize = TTTOOLINFOA_V2_SIZE; ti.uId = 0x1234ABCD; ti.lParam = 0x55555555; SendMessageA(hwnd, TTM_SETTOOLINFOA, 0, (LPARAM)&ti); ti.cbSize = TTTOOLINFOA_V2_SIZE; ti.lParam = 0xdeadbeef; r = SendMessageA(hwnd, TTM_GETTOOLINFOA, 0, (LPARAM)&ti); ok(r, "Getting tooltip info failed\n"); ok(0x55555555 == ti.lParam || broken(0x55555555 != ti.lParam), /* comctl32 < 5.81 */ "Expected 0x55555555, got %lx\n", ti.lParam); DestroyWindow(hwnd); /* 1. test size parameter validation rules (ansi messages) */ hwnd = CreateWindowExA(0, TOOLTIPS_CLASSA, NULL, 0, 10, 10, 300, 100, NULL, NULL, NULL, 0); ti.cbSize = TTTOOLINFOA_V1_SIZE - 1; ti.hwnd = NULL; ti.hinst = GetModuleHandleA(NULL); ti.uFlags = 0; ti.uId = 0x1234ABCD; ti.lpszText = NULL; ti.lParam = 0xdeadbeef; GetClientRect(hwnd, &ti.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti); ok(r, "Adding the tool to the tooltip failed\n"); r = SendMessageA(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); ti.cbSize = TTTOOLINFOA_V1_SIZE - 1; ti.hwnd = NULL; ti.uId = 0x1234ABCD; SendMessageA(hwnd, TTM_DELTOOLA, 0, (LPARAM)&ti); r = SendMessageA(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(0, r); ti.cbSize = TTTOOLINFOA_V2_SIZE - 1; ti.hwnd = NULL; ti.hinst = GetModuleHandleA(NULL); ti.uFlags = 0; ti.uId = 0x1234ABCD; ti.lpszText = NULL; ti.lParam = 0xdeadbeef; GetClientRect(hwnd, &ti.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti); ok(r, "Adding the tool to the tooltip failed\n"); r = SendMessageA(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); ti.cbSize = TTTOOLINFOA_V2_SIZE - 1; ti.hwnd = NULL; ti.uId = 0x1234ABCD; SendMessageA(hwnd, TTM_DELTOOLA, 0, (LPARAM)&ti); r = SendMessageA(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(0, r); ti.cbSize = TTTOOLINFOA_V2_SIZE + 1; ti.hwnd = NULL; ti.hinst = GetModuleHandleA(NULL); ti.uFlags = 0; ti.uId = 0x1234ABCD; ti.lpszText = NULL; ti.lParam = 0xdeadbeef; GetClientRect(hwnd, &ti.rect); r = SendMessageA(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti); ok(r, "Adding the tool to the tooltip failed\n"); r = SendMessageA(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); ti.cbSize = TTTOOLINFOA_V2_SIZE + 1; ti.hwnd = NULL; ti.uId = 0x1234ABCD; SendMessageA(hwnd, TTM_DELTOOLA, 0, (LPARAM)&ti); r = SendMessageA(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(0, r); DestroyWindow(hwnd); /* 2. test size parameter validation rules (w-messages) */ hwnd = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL, 0, 10, 10, 300, 100, NULL, NULL, NULL, 0); if(!hwnd) { win_skip("CreateWindowExW() not supported. Skipping.\n"); return; } tiW.cbSize = TTTOOLINFOW_V1_SIZE - 1; tiW.hwnd = NULL; tiW.hinst = GetModuleHandleA(NULL); tiW.uFlags = 0; tiW.uId = 0x1234ABCD; tiW.lpszText = NULL; tiW.lParam = 0xdeadbeef; GetClientRect(hwnd, &tiW.rect); r = SendMessageW(hwnd, TTM_ADDTOOLW, 0, (LPARAM)&tiW); ok(r, "Adding the tool to the tooltip failed\n"); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); tiW.cbSize = TTTOOLINFOW_V1_SIZE - 1; tiW.hwnd = NULL; tiW.uId = 0x1234ABCD; SendMessageW(hwnd, TTM_DELTOOLW, 0, (LPARAM)&tiW); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(0, r); tiW.cbSize = TTTOOLINFOW_V2_SIZE - 1; tiW.hwnd = NULL; tiW.hinst = GetModuleHandleA(NULL); tiW.uFlags = 0; tiW.uId = 0x1234ABCD; tiW.lpszText = NULL; tiW.lParam = 0xdeadbeef; GetClientRect(hwnd, &tiW.rect); r = SendMessageW(hwnd, TTM_ADDTOOLW, 0, (LPARAM)&tiW); ok(r, "Adding the tool to the tooltip failed\n"); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); tiW.cbSize = TTTOOLINFOW_V2_SIZE - 1; tiW.hwnd = NULL; tiW.uId = 0x1234ABCD; SendMessageW(hwnd, TTM_DELTOOLW, 0, (LPARAM)&tiW); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(0, r); tiW.cbSize = TTTOOLINFOW_V2_SIZE + 1; tiW.hwnd = NULL; tiW.hinst = GetModuleHandleA(NULL); tiW.uFlags = 0; tiW.uId = 0x1234ABCD; tiW.lpszText = NULL; tiW.lParam = 0xdeadbeef; GetClientRect(hwnd, &tiW.rect); r = SendMessageW(hwnd, TTM_ADDTOOLA, 0, (LPARAM)&tiW); ok(r, "Adding the tool to the tooltip failed\n"); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); /* looks like TTM_DELTOOLW doesn't work with invalid size */ tiW.cbSize = TTTOOLINFOW_V2_SIZE + 1; tiW.hwnd = NULL; tiW.uId = 0x1234ABCD; SendMessageW(hwnd, TTM_DELTOOLW, 0, (LPARAM)&tiW); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(1, r); tiW.cbSize = TTTOOLINFOW_V2_SIZE; tiW.hwnd = NULL; tiW.uId = 0x1234ABCD; SendMessageW(hwnd, TTM_DELTOOLW, 0, (LPARAM)&tiW); r = SendMessageW(hwnd, TTM_GETTOOLCOUNT, 0, 0); expect(0, r); DestroyWindow(hwnd); }
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) { GLuint PixelFormat; // Holds The Results After Searching For A Match WNDCLASSA wc; // Windows Class Structure DWORD dwExStyle; // Window Extended Style DWORD dwStyle; // Window Style RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values WindowRect.left=(long)0; // Set Left Value To 0 WindowRect.right=(long)width; // Set Right Value To Requested Width WindowRect.top=(long)0; // Set Top Value To 0 WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window. wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages wc.cbClsExtra = 0; // No Extra Window Data wc.cbWndExtra = 0; // No Extra Window Data wc.hInstance = hInstance; // Set The Instance wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer wc.hbrBackground = NULL; // No Background Required For GL wc.lpszMenuName = NULL; // We Don't Want A Menu wc.lpszClassName = "OpenGL"; // Set The Class Name if (!RegisterClassA(&wc)) // Attempt To Register The Window Class { MessageBoxA(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } if (fullscreen) // Attempt Fullscreen Mode? { DEVMODE dmScreenSettings; // Device Mode memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure dmScreenSettings.dmPelsWidth = width; // Selected Screen Width dmScreenSettings.dmPelsHeight = height; // Selected Screen Height dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) { if (MessageBoxA(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) { fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE } else { MessageBoxA(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP); return FALSE; // Return FALSE } } } if (fullscreen) // Are We Still In Fullscreen Mode? { dwExStyle=WS_EX_APPWINDOW; // Window Extended Style dwStyle=WS_POPUP; // Windows Style ShowCursor(FALSE); // Hide Mouse Pointer } else { dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style } AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size if (!(hWnd=CreateWindowExA( dwExStyle, // Extended Style For The Window "OpenGL", // Class Name title, // Window Title dwStyle | // Defined Window Style WS_CLIPSIBLINGS | // Required Window Style WS_CLIPCHILDREN, // Required Window Style 0, 0, // Window Position WindowRect.right-WindowRect.left, // Calculate Window Width WindowRect.bottom-WindowRect.top, // Calculate Window Height NULL, // No Parent Window NULL, // No Menu hInstance, // Instance NULL))) // Dont Pass Anything To WM_CREATE { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be { sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor 1, // Version Number PFD_DRAW_TO_WINDOW | // Format Must Support Window PFD_SUPPORT_OPENGL | // Format Must Support OpenGL PFD_DOUBLEBUFFER, // Must Support Double Buffering PFD_TYPE_RGBA, // Request An RGBA Format bits, // Select Our Color Depth 0, 0, 0, 0, 0, 0, // Color Bits Ignored 0, // No Alpha Buffer 0, // Shift Bit Ignored 0, // No Accumulation Buffer 0, 0, 0, 0, // Accumulation Bits Ignored 16, // 16Bit Z-Buffer (Depth Buffer) 0, // No Stencil Buffer 0, // No Auxiliary Buffer PFD_MAIN_PLANE, // Main Drawing Layer 0, // Reserved 0, 0, 0 // Layer Masks Ignored }; if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context? { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format? { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format? { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context? { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } ShowWindow(hWnd,SW_SHOW); // Show The Window SetForegroundWindow(hWnd); // Slightly Higher Priority SetFocus(hWnd); // Sets Keyboard Focus To The Window ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen if (!InitGL()) // Initialize Our Newly Created GL Window { KillGLWindow(); // Reset The Display MessageBoxA(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION); return FALSE; // Return FALSE } return TRUE; // Success }
static void test_button_messages(void) { static const struct { DWORD style; DWORD dlg_code; const struct message *setfocus; const struct message *killfocus; const struct message *setstyle; const struct message *setstate; const struct message *clearstate; const struct message *setcheck; } button[] = { { BS_PUSHBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON, setfocus_seq, killfocus_seq, setstyle_seq, setstate_seq, setstate_seq, setcheck_ignored_seq }, { BS_DEFPUSHBUTTON, DLGC_BUTTON | DLGC_DEFPUSHBUTTON, setfocus_seq, killfocus_seq, setstyle_seq, setstate_seq, setstate_seq, setcheck_ignored_seq }, { BS_CHECKBOX, DLGC_BUTTON, setfocus_static_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_static_seq }, { BS_AUTOCHECKBOX, DLGC_BUTTON, setfocus_static_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_static_seq }, { BS_RADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON, setfocus_static_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_radio_redraw_seq }, { BS_3STATE, DLGC_BUTTON, setfocus_static_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_static_seq }, { BS_AUTO3STATE, DLGC_BUTTON, setfocus_static_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_static_seq }, { BS_GROUPBOX, DLGC_STATIC, setfocus_groupbox_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_ignored_seq }, { BS_USERBUTTON, DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON, setfocus_seq, killfocus_seq, setstyle_user_seq, setstate_user_seq, clearstate_seq, setcheck_ignored_seq }, { BS_AUTORADIOBUTTON, DLGC_BUTTON | DLGC_RADIOBUTTON, setfocus_static_seq, killfocus_static_seq, setstyle_static_seq, setstate_static_seq, setstate_static_seq, setcheck_radio_redraw_seq }, { BS_OWNERDRAW, DLGC_BUTTON, setfocus_ownerdraw_seq, killfocus_ownerdraw_seq, setstyle_ownerdraw_seq, setstate_ownerdraw_seq, clearstate_ownerdraw_seq, setcheck_ignored_seq }, }; const struct message *seq; unsigned int i; HWND hwnd, parent; DWORD dlg_code; HFONT zfont; BOOL todo; /* selection with VK_SPACE should capture button window */ hwnd = create_button(BS_CHECKBOX | WS_VISIBLE | WS_POPUP, NULL); ok(hwnd != 0, "Failed to create button window\n"); ReleaseCapture(); SetFocus(hwnd); SendMessageA(hwnd, WM_KEYDOWN, VK_SPACE, 0); ok(GetCapture() == hwnd, "Should be captured on VK_SPACE WM_KEYDOWN\n"); SendMessageA(hwnd, WM_KEYUP, VK_SPACE, 0); DestroyWindow(hwnd); parent = CreateWindowExA(0, "TestParentClass", "Test parent", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100, 100, 200, 200, 0, 0, 0, NULL); ok(parent != 0, "Failed to create parent window\n"); for (i = 0; i < sizeof(button)/sizeof(button[0]); i++) { MSG msg; DWORD style, state; trace("%d: button test sequence\n", i); hwnd = create_button(button[i].style, parent); style = GetWindowLongA(hwnd, GWL_STYLE); style &= ~(WS_CHILD | BS_NOTIFY); /* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */ if (button[i].style == BS_USERBUTTON) ok(style == BS_PUSHBUTTON, "expected style BS_PUSHBUTTON got %x\n", style); else ok(style == button[i].style, "expected style %x got %x\n", button[i].style, style); dlg_code = SendMessageA(hwnd, WM_GETDLGCODE, 0, 0); ok(dlg_code == button[i].dlg_code, "%u: wrong dlg_code %08x\n", i, dlg_code); ShowWindow(hwnd, SW_SHOW); UpdateWindow(hwnd); SetFocus(0); flush_events(); SetFocus(0); flush_sequences(sequences, NUM_MSG_SEQUENCES); todo = button[i].style != BS_OWNERDRAW; ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus()); SetFocus(hwnd); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setfocus, "SetFocus(hwnd) on a button", todo); todo = button[i].style == BS_OWNERDRAW; SetFocus(0); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].killfocus, "SetFocus(0) on a button", todo); ok(GetFocus() == 0, "expected focus 0, got %p\n", GetFocus()); SendMessageA(hwnd, BM_SETSTYLE, button[i].style | BS_BOTTOM, TRUE); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setstyle, "BM_SETSTYLE on a button", TRUE); style = GetWindowLongA(hwnd, GWL_STYLE); style &= ~(WS_VISIBLE | WS_CHILD | BS_NOTIFY); /* XP doesn't turn a BS_USERBUTTON into BS_PUSHBUTTON here! */ ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style); state = SendMessageA(hwnd, BM_GETSTATE, 0, 0); ok(state == 0, "expected state 0, got %04x\n", state); flush_sequences(sequences, NUM_MSG_SEQUENCES); SendMessageA(hwnd, BM_SETSTATE, TRUE, 0); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setstate, "BM_SETSTATE/TRUE on a button", TRUE); state = SendMessageA(hwnd, BM_GETSTATE, 0, 0); ok(state == BST_PUSHED, "expected state 0x0004, got %04x\n", state); style = GetWindowLongA(hwnd, GWL_STYLE); style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE); ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style); flush_sequences(sequences, NUM_MSG_SEQUENCES); SendMessageA(hwnd, BM_SETSTATE, FALSE, 0); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].clearstate, "BM_SETSTATE/FALSE on a button", TRUE); state = SendMessageA(hwnd, BM_GETSTATE, 0, 0); ok(state == 0, "expected state 0, got %04x\n", state); style = GetWindowLongA(hwnd, GWL_STYLE); style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE); ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style); state = SendMessageA(hwnd, BM_GETCHECK, 0, 0); ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state); flush_sequences(sequences, NUM_MSG_SEQUENCES); if (button[i].style == BS_RADIOBUTTON || button[i].style == BS_AUTORADIOBUTTON) { seq = setcheck_radio_seq; todo = TRUE; } else { seq = setcheck_ignored_seq; todo = FALSE; } SendMessageA(hwnd, BM_SETCHECK, BST_UNCHECKED, 0); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); ok_sequence(sequences, COMBINED_SEQ_INDEX, seq, "BM_SETCHECK on a button", todo); state = SendMessageA(hwnd, BM_GETCHECK, 0, 0); ok(state == BST_UNCHECKED, "expected BST_UNCHECKED, got %04x\n", state); style = GetWindowLongA(hwnd, GWL_STYLE); style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE); ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style); flush_sequences(sequences, NUM_MSG_SEQUENCES); SendMessageA(hwnd, BM_SETCHECK, BST_CHECKED, 0); SendMessageA(hwnd, WM_APP, 0, 0); /* place a separator mark here */ while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg); if (button[i].style == BS_PUSHBUTTON || button[i].style == BS_DEFPUSHBUTTON || button[i].style == BS_GROUPBOX || button[i].style == BS_USERBUTTON || button[i].style == BS_OWNERDRAW) { ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setcheck, "BM_SETCHECK on a button", FALSE); state = SendMessageA(hwnd, BM_GETCHECK, 0, 0); ok(state == BST_UNCHECKED, "expected check BST_UNCHECKED, got %04x\n", state); } else { ok_sequence(sequences, COMBINED_SEQ_INDEX, button[i].setcheck, "BM_SETCHECK on a button", TRUE); state = SendMessageA(hwnd, BM_GETCHECK, 0, 0); ok(state == BST_CHECKED, "expected check BST_CHECKED, got %04x\n", state); } style = GetWindowLongA(hwnd, GWL_STYLE); style &= ~(WS_CHILD | BS_NOTIFY | WS_VISIBLE); if (button[i].style == BS_RADIOBUTTON || button[i].style == BS_AUTORADIOBUTTON) ok(style == (button[i].style | WS_TABSTOP), "expected style %04x | WS_TABSTOP got %04x\n", button[i].style, style); else ok(style == button[i].style, "expected style %04x got %04x\n", button[i].style, style); DestroyWindow(hwnd); } DestroyWindow(parent); hwnd = create_button(BS_PUSHBUTTON, NULL); SetForegroundWindow(hwnd); flush_events(); SetActiveWindow(hwnd); SetFocus(0); flush_sequences(sequences, NUM_MSG_SEQUENCES); SendMessageA(hwnd, WM_LBUTTONDOWN, 0, 0); ok_sequence(sequences, COMBINED_SEQ_INDEX, lbuttondown_seq, "WM_LBUTTONDOWN on a button", FALSE); SendMessageA(hwnd, WM_LBUTTONUP, 0, 0); ok_sequence(sequences, COMBINED_SEQ_INDEX, lbuttonup_seq, "WM_LBUTTONUP on a button", TRUE); flush_sequences(sequences, NUM_MSG_SEQUENCES); zfont = GetStockObject(SYSTEM_FONT); SendMessageA(hwnd, WM_SETFONT, (WPARAM)zfont, TRUE); UpdateWindow(hwnd); ok_sequence(sequences, COMBINED_SEQ_INDEX, setfont_seq, "WM_SETFONT on a button", FALSE); DestroyWindow(hwnd); }
static void test_savedc_2(void) { HWND hwnd; HDC hdc; HRGN hrgn; RECT rc, rc_clip; int ret; hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100, 0, 0, 0, NULL); assert(hwnd != 0); ShowWindow(hwnd, SW_SHOW); UpdateWindow(hwnd); hrgn = CreateRectRgn(0, 0, 0, 0); assert(hrgn != 0); hdc = GetDC(hwnd); ok(hdc != NULL, "GetDC failed\n"); ret = GetClipBox(hdc, &rc_clip); ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret); ret = GetClipRgn(hdc, hrgn); ok(ret == 0, "GetClipRgn returned %d instead of 0\n", ret); ret = GetRgnBox(hrgn, &rc); ok(ret == NULLREGION, "GetRgnBox returned %d (%d,%d-%d,%d) instead of NULLREGION\n", ret, rc.left, rc.top, rc.right, rc.bottom); /*dump_region(hrgn);*/ SetRect(&rc, 0, 0, 100, 100); ok(EqualRect(&rc, &rc_clip), "rects are not equal: (%d,%d-%d,%d) - (%d,%d-%d,%d)\n", rc.left, rc.top, rc.right, rc.bottom, rc_clip.left, rc_clip.top, rc_clip.right, rc_clip.bottom); ret = SaveDC(hdc); todo_wine { ok(ret == 1, "ret = %d\n", ret); } ret = IntersectClipRect(hdc, 0, 0, 50, 50); if (ret == COMPLEXREGION) { /* XP returns COMPLEXREGION although dump_region reports only 1 rect */ trace("Windows BUG: IntersectClipRect returned %d instead of SIMPLEREGION\n", ret); /* let's make sure that it's a simple region */ ret = GetClipRgn(hdc, hrgn); ok(ret == 1, "GetClipRgn returned %d instead of 1\n", ret); dump_region(hrgn); } else ok(ret == SIMPLEREGION, "IntersectClipRect returned %d instead of SIMPLEREGION\n", ret); ret = GetClipBox(hdc, &rc_clip); ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret); SetRect(&rc, 0, 0, 50, 50); ok(EqualRect(&rc, &rc_clip), "rects are not equal\n"); ret = RestoreDC(hdc, 1); ok(ret, "ret = %d\n", ret); ret = GetClipBox(hdc, &rc_clip); ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret); SetRect(&rc, 0, 0, 100, 100); ok(EqualRect(&rc, &rc_clip), "rects are not equal\n"); DeleteObject(hrgn); ReleaseDC(hwnd, hdc); DestroyWindow(hwnd); }
static BOOL CALLBACK EnumJoysticks(const DIDEVICEINSTANCEA *lpddi, void *pvRef) { HRESULT hr; UserData * data = pvRef; IDirectInputDeviceA *pJoystick; DIDATAFORMAT format; DIDEVCAPS caps; DIJOYSTATE2 js; JoystickInfo info; int i, count; ULONG ref; DIDEVICEINSTANCEA inst; DIDEVICEINSTANCE_DX3A inst3; DIPROPDWORD dipw; DIPROPSTRING dps; DIPROPGUIDANDPATH dpg; WCHAR nameBuffer[MAX_PATH]; HWND hWnd = get_hwnd(); char oldstate[248], curstate[248]; ok(data->version > 0x0300, "Joysticks not supported in version 0x%04x\n", data->version); hr = IDirectInput_CreateDevice(data->pDI, &lpddi->guidInstance, NULL, NULL); ok(hr==E_POINTER,"IDirectInput_CreateDevice() should have returned " "E_POINTER, returned: %08x\n", hr); hr = IDirectInput_CreateDevice(data->pDI, NULL, &pJoystick, NULL); ok(hr==E_POINTER,"IDirectInput_CreateDevice() should have returned " "E_POINTER, returned: %08x\n", hr); hr = IDirectInput_CreateDevice(data->pDI, NULL, NULL, NULL); ok(hr==E_POINTER,"IDirectInput_CreateDevice() should have returned " "E_POINTER, returned: %08x\n", hr); hr = IDirectInput_CreateDevice(data->pDI, &lpddi->guidInstance, &pJoystick, NULL); ok(hr==DI_OK,"IDirectInput_CreateDevice() failed: %08x\n", hr); if (hr!=DI_OK) goto DONE; trace("---- %s ----\n", lpddi->tszProductName); /* Test for joystick ID property */ ZeroMemory(&dipw, sizeof(dipw)); dipw.diph.dwSize = sizeof(DIPROPDWORD); dipw.diph.dwHeaderSize = sizeof(DIPROPHEADER); dipw.diph.dwObj = 0; dipw.diph.dwHow = DIPH_DEVICE; hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_JOYSTICKID, &dipw.diph); ok(SUCCEEDED(hr), "IDirectInputDevice_GetProperty() for DIPROP_JOYSTICKID failed\n"); /* Test for INSTANCENAME property */ memset(&dps, 0, sizeof(dps)); dps.diph.dwSize = sizeof(DIPROPSTRING); dps.diph.dwHeaderSize = sizeof(DIPROPHEADER); dps.diph.dwHow = DIPH_DEVICE; hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_INSTANCENAME, &dps.diph); ok(SUCCEEDED(hr), "IDirectInput_GetProperty() for DIPROP_INSTANCENAME failed: %08x\n", hr); /* Test if instance name is the same as present in DIDEVICEINSTANCE */ MultiByteToWideChar(CP_ACP, 0, lpddi->tszInstanceName, -1, nameBuffer, MAX_PATH); ok(!lstrcmpW(nameBuffer, dps.wsz), "DIPROP_INSTANCENAME returned is wrong. Expected: %s Got: %s\n", wine_dbgstr_w(nameBuffer), wine_dbgstr_w(dps.wsz)); /* Test for GUIDPATH properties */ memset(&dpg, 0, sizeof(dpg)); dpg.diph.dwSize = sizeof(DIPROPGUIDANDPATH); dpg.diph.dwHeaderSize = sizeof(DIPROPHEADER); dpg.diph.dwHow = DIPH_DEVICE; hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_GUIDANDPATH, &dpg.diph); todo_wine ok(SUCCEEDED(hr), "IDirectInput_GetProperty() for DIPROP_GUIDANDPATH failed: %08x\n", hr); hr = IDirectInputDevice_SetDataFormat(pJoystick, NULL); ok(hr==E_POINTER,"IDirectInputDevice_SetDataFormat() should have returned " "E_POINTER, returned: %08x\n", hr); ZeroMemory(&format, sizeof(format)); hr = IDirectInputDevice_SetDataFormat(pJoystick, &format); ok(hr==DIERR_INVALIDPARAM,"IDirectInputDevice_SetDataFormat() should have " "returned DIERR_INVALIDPARAM, returned: %08x\n", hr); /* try the default formats */ hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick); ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr); hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick2); ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr); /* try an alternate format */ hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystickTest); ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr); hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick2); ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr); if (hr != DI_OK) goto RELEASE; for (i=0; i<16; i++) { hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, NULL, i); ok(hr == SetCoop_null_window[i], "SetCooperativeLevel(NULL, %d): %08x\n", i, hr); } for (i=0; i<16; i++) { hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, hWnd, i); ok(hr == SetCoop_real_window[i], "SetCooperativeLevel(hwnd, %d): %08x\n", i, hr); } hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, hWnd, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND); ok(hr==DI_OK,"IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr); /* get capabilities */ hr = IDirectInputDevice_GetCapabilities(pJoystick, NULL); ok(hr==E_POINTER,"IDirectInputDevice_GetCapabilities() " "should have returned E_POINTER, returned: %08x\n", hr); ZeroMemory(&caps, sizeof(caps)); hr = IDirectInputDevice_GetCapabilities(pJoystick, &caps); ok(hr==DIERR_INVALIDPARAM,"IDirectInputDevice_GetCapabilities() " "should have returned DIERR_INVALIDPARAM, returned: %08x\n", hr); caps.dwSize = sizeof(caps); hr = IDirectInputDevice_GetCapabilities(pJoystick, &caps); ok(hr==DI_OK,"IDirectInputDevice_GetCapabilities() failed: %08x\n", hr); ZeroMemory(&info, sizeof(info)); info.pJoystick = pJoystick; /* default min/max limits */ info.lMin = 0; info.lMax = 0xffff; /* enumerate objects */ hr = IDirectInputDevice_EnumObjects(pJoystick, EnumAxes, &info, DIDFT_ALL); ok(hr==DI_OK,"IDirectInputDevice_EnumObjects() failed: %08x\n", hr); ok(caps.dwAxes == info.axis, "Number of enumerated axes (%d) doesn't match capabilities (%d)\n", info.axis, caps.dwAxes); ok(caps.dwButtons == info.button, "Number of enumerated buttons (%d) doesn't match capabilities (%d)\n", info.button, caps.dwButtons); ok(caps.dwPOVs == info.pov, "Number of enumerated POVs (%d) doesn't match capabilities (%d)\n", info.pov, caps.dwPOVs); /* Set format and check limits again */ hr = IDirectInputDevice_SetDataFormat(pJoystick, &c_dfDIJoystick2); ok(hr==DI_OK,"IDirectInputDevice_SetDataFormat() failed: %08x\n", hr); info.lMin = -2000; info.lMax = +2000; info.dZone= 123; hr = IDirectInputDevice_EnumObjects(pJoystick, EnumAxes, &info, DIDFT_ALL); ok(hr==DI_OK,"IDirectInputDevice_EnumObjects() failed: %08x\n", hr); hr = IDirectInputDevice_GetDeviceInfo(pJoystick, 0); ok(hr==E_POINTER, "IDirectInputDevice_GetDeviceInfo() " "should have returned E_POINTER, returned: %08x\n", hr); ZeroMemory(&inst, sizeof(inst)); ZeroMemory(&inst3, sizeof(inst3)); hr = IDirectInputDevice_GetDeviceInfo(pJoystick, &inst); ok(hr==DIERR_INVALIDPARAM, "IDirectInputDevice_GetDeviceInfo() " "should have returned DIERR_INVALIDPARAM, returned: %08x\n", hr); inst.dwSize = sizeof(inst); hr = IDirectInputDevice_GetDeviceInfo(pJoystick, &inst); ok(hr==DI_OK,"IDirectInputDevice_GetDeviceInfo() failed: %08x\n", hr); inst3.dwSize = sizeof(inst3); hr = IDirectInputDevice_GetDeviceInfo(pJoystick, (DIDEVICEINSTANCEA*)&inst3); ok(hr==DI_OK,"IDirectInputDevice_GetDeviceInfo() failed: %08x\n", hr); hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr == S_FALSE, "IDirectInputDevice_Unacquire() should have returned S_FALSE, got: %08x\n", hr); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); if (hr != DI_OK) goto RELEASE; hr = IDirectInputDevice_Acquire(pJoystick); ok(hr == S_FALSE, "IDirectInputDevice_Acquire() should have returned S_FALSE, got: %08x\n", hr); if (info.pov < 4) { hr = IDirectInputDevice_GetDeviceState(pJoystick, sizeof(DIJOYSTATE2), &js); ok(hr == DI_OK, "IDirectInputDevice_GetDeviceState() failed: %08x\n", hr); ok(js.rgdwPOV[3] == -1, "Default for unassigned POV should be -1 not: %d\n", js.rgdwPOV[3]); } if (caps.dwFlags & DIDC_FORCEFEEDBACK) { DWORD axes[2] = {DIJOFS_X, DIJOFS_Y}; LONG direction[2] = {0, 0}; DICONSTANTFORCE force = {0}; DIEFFECT eff; LPDIRECTINPUTEFFECT effect = NULL; LONG cnt1, cnt2; HWND real_hWnd; HINSTANCE hInstance = GetModuleHandleW(NULL); DIPROPDWORD dip_gain_set, dip_gain_get; trace("Testing force-feedback\n"); memset(&eff, 0, sizeof(eff)); eff.dwSize = sizeof(eff); eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS; eff.dwDuration = INFINITE; eff.dwGain = DI_FFNOMINALMAX; eff.dwTriggerButton = DIEB_NOTRIGGER; eff.cAxes = sizeof(axes) / sizeof(axes[0]); eff.rgdwAxes = axes; eff.rglDirection = direction; eff.cbTypeSpecificParams = sizeof(force); eff.lpvTypeSpecificParams = &force; /* Sending effects to joystick requires * calling IDirectInputEffect_Initialize, which requires * having exclusive access to the device, which requires * - not having acquired the joystick when calling * IDirectInputDevice_SetCooperativeLevel * - a visible window */ real_hWnd = CreateWindowExA(0, "EDIT", "Test text", 0, 10, 10, 300, 300, NULL, NULL, hInstance, NULL); ok(real_hWnd!=0,"CreateWindowExA failed: %p\n", real_hWnd); ShowWindow(real_hWnd, SW_SHOW); hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, real_hWnd, DISCL_EXCLUSIVE | DISCL_FOREGROUND); ok(hr==DI_OK,"IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); cnt1 = get_refcount((IUnknown*)pJoystick); hr = IDirectInputDevice2_CreateEffect((IDirectInputDevice2A*)pJoystick, &GUID_ConstantForce, &eff, &effect, NULL); ok(hr == DI_OK, "IDirectInputDevice_CreateEffect() failed: %08x\n", hr); cnt2 = get_refcount((IUnknown*)pJoystick); ok(cnt1 == cnt2, "Ref count is wrong %d != %d\n", cnt1, cnt2); if (effect) { DWORD effect_status; struct DIPROPDWORD diprop_word; GUID guid = {0}; hr = IDirectInputEffect_Initialize(effect, hInstance, data->version, &GUID_ConstantForce); ok(hr==DI_OK,"IDirectInputEffect_Initialize failed: %08x\n", hr); hr = IDirectInputEffect_SetParameters(effect, &eff, DIEP_AXES | DIEP_DIRECTION | DIEP_TYPESPECIFICPARAMS); ok(hr==DI_OK,"IDirectInputEffect_SetParameters failed: %08x\n", hr); if (hr==DI_OK) { /* Test that upload, unacquire, acquire still permits updating * uploaded effect. */ hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); hr = IDirectInputEffect_SetParameters(effect, &eff, DIEP_GAIN); ok(hr==DI_OK,"IDirectInputEffect_SetParameters failed: %08x\n", hr); } /* Check effect status. * State: initially stopped * start * State: started * unacquire, acquire, download * State: stopped * start * State: started * * Shows that: * - effects are stopped after Unacquire + Acquire * - effects are preserved (Download + Start doesn't complain * about incomplete effect) */ hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status); ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr); ok(effect_status==0,"IDirectInputEffect_GetEffectStatus() reported effect as started\n"); hr = IDirectInputEffect_SetParameters(effect, &eff, DIEP_START); ok(hr==DI_OK,"IDirectInputEffect_SetParameters failed: %08x\n", hr); hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status); ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr); todo_wine ok(effect_status!=0,"IDirectInputEffect_GetEffectStatus() reported effect as stopped\n"); hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); hr = IDirectInputEffect_Download(effect); ok(hr==DI_OK,"IDirectInputEffect_Download() failed: %08x\n", hr); hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status); ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr); ok(effect_status==0,"IDirectInputEffect_GetEffectStatus() reported effect as started\n"); hr = IDirectInputEffect_Start(effect, 1, 0); ok(hr==DI_OK,"IDirectInputEffect_Start() failed: %08x\n", hr); hr = IDirectInputEffect_GetEffectStatus(effect, &effect_status); ok(hr==DI_OK,"IDirectInputEffect_GetEffectStatus() failed: %08x\n", hr); todo_wine ok(effect_status!=0,"IDirectInputEffect_GetEffectStatus() reported effect as stopped\n"); hr = IDirectInputEffect_GetEffectGuid(effect, &guid); ok(hr==DI_OK,"IDirectInputEffect_GetEffectGuid() failed: %08x\n", hr); ok(IsEqualGUID(&GUID_ConstantForce, &guid), "Wrong guid returned\n"); /* Check autocenter status * State: initially stopped * enable * State: enabled * acquire * State: enabled * unacquire * State: enabled * * IDirectInputDevice2_SetProperty(DIPROP_AUTOCENTER) can only be * executed when the device is released. * * If Executed interactively, user can feel that autocenter is * only disabled when the joystick is acquired. */ diprop_word.diph.dwSize = sizeof(diprop_word); diprop_word.diph.dwHeaderSize = sizeof(diprop_word.diph); diprop_word.diph.dwObj = 0; diprop_word.diph.dwHow = DIPH_DEVICE; hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph); ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr); ok(diprop_word.dwData==DIPROPAUTOCENTER_ON,"IDirectInputDevice2_GetProperty() reported autocenter as disabled\n"); diprop_word.dwData = DIPROPAUTOCENTER_OFF; hr = IDirectInputDevice2_SetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph); ok(hr==DI_OK,"IDirectInputDevice2_SetProperty() failed: %08x\n", hr); hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph); ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr); ok(diprop_word.dwData==DIPROPAUTOCENTER_OFF,"IDirectInputDevice2_GetProperty() reported autocenter as enabled\n"); if (winetest_interactive) { trace("Acquiring in 2s, autocenter will be disabled.\n"); Sleep(2000); } hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); if (winetest_interactive) trace("Acquired.\n"); hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph); ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr); ok(diprop_word.dwData==DIPROPAUTOCENTER_OFF,"IDirectInputDevice2_GetProperty() reported autocenter as enabled\n"); if (winetest_interactive) { trace("Releasing in 2s, autocenter will be re-enabled.\n"); Sleep(2000); } hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); if (winetest_interactive) trace("Released\n"); hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph); ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr); ok(diprop_word.dwData==DIPROPAUTOCENTER_OFF,"IDirectInputDevice2_GetProperty() reported autocenter as enabled\n"); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); hr = IDirectInputDevice2_GetProperty(pJoystick, DIPROP_AUTOCENTER, &diprop_word.diph); ok(hr==DI_OK,"IDirectInputDevice2_GetProperty() failed: %08x\n", hr); /* Device gain (DIPROP_FFGAIN). * From MSDN: * 0..10000 range, otherwise DIERR_INVALIDPARAM. * Can be changed even if device is acquired. * Difference found by tests: * <0 is refused, >10000 is accepted */ dip_gain_set.diph.dwSize = sizeof(DIPROPDWORD); dip_gain_set.diph.dwHeaderSize = sizeof(DIPROPHEADER); dip_gain_set.diph.dwObj = 0; dip_gain_set.diph.dwHow = DIPH_DEVICE; dip_gain_set.dwData = 10000; dip_gain_get.diph.dwSize = sizeof(DIPROPDWORD); dip_gain_get.diph.dwHeaderSize = sizeof(DIPROPHEADER); dip_gain_get.diph.dwObj = 0; dip_gain_get.diph.dwHow = DIPH_DEVICE; dip_gain_get.dwData = 0; /* Test device is acquisition (non)impact. */ hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr == DI_OK, "IDirectInputDevice_Unacquire() should have returned S_FALSE, got: %08x\n", hr); dip_gain_set.dwData = 1; hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph); ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr); hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph); ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr); ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); dip_gain_set.dwData = 2; hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph); ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr); hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph); ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr); ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData); /* Test range and internal clamping. */ dip_gain_set.dwData = -1; hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph); todo_wine ok(hr==DIERR_INVALIDPARAM, "IDirectInputDevice_SetProperty() should have returned %08x: %08x\n", DIERR_INVALIDPARAM, hr); dip_gain_set.dwData = 0; hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph); ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr); hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph); ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr); ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData); dip_gain_set.dwData = 10000; hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph); ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr); hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph); ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr); ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData); /* WARNING: This call succeeds, on the contrary of what is stated on MSDN. */ dip_gain_set.dwData = 10001; hr = IDirectInputDevice_SetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_set.diph); ok(hr==DI_OK, "IDirectInputDevice_SetProperty() failed: %08x\n", hr); hr = IDirectInputDevice_GetProperty(pJoystick, DIPROP_FFGAIN, &dip_gain_get.diph); ok(hr==DI_OK, "IDirectInputDevice_GetProperty() failed: %08x\n", hr); ok(dip_gain_get.dwData==dip_gain_set.dwData, "Gain not updated: %i\n", dip_gain_get.dwData); ref = IUnknown_Release(effect); ok(ref == 0, "IDirectInputDevice_Release() reference count = %d\n", ref); } cnt1 = get_refcount((IUnknown*)pJoystick); ok(cnt1 == cnt2, "Ref count is wrong %d != %d\n", cnt1, cnt2); /* Before destroying the window, release joystick to revert to * non-exclusive, background cooperative level. */ hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); hr = IDirectInputDevice_SetCooperativeLevel(pJoystick, hWnd, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND); ok(hr==DI_OK,"IDirectInputDevice_SetCooperativeLevel() failed: %08x\n", hr); DestroyWindow (real_hWnd); hr = IDirectInputDevice_Acquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Acquire() failed: %08x\n", hr); } if (winetest_interactive) { trace("You have 30 seconds to test all axes, sliders, POVs and buttons\n"); count = 300; } else count = 1; trace("\n"); oldstate[0]='\0'; for (i = 0; i < count; i++) { hr = IDirectInputDevice_GetDeviceState(pJoystick, sizeof(DIJOYSTATE2), &js); ok(hr==DI_OK,"IDirectInputDevice_GetDeviceState() failed: %08x\n", hr); if (hr != DI_OK) break; sprintf(curstate, "X%5d Y%5d Z%5d Rx%5d Ry%5d Rz%5d " "S0%5d S1%5d POV0%5d POV1%5d POV2%5d POV3%5d " "B %d %d %d %d %d %d %d %d %d %d %d %d\n", js.lX, js.lY, js.lZ, js.lRx, js.lRy, js.lRz, js.rglSlider[0], js.rglSlider[1], js.rgdwPOV[0], js.rgdwPOV[1], js.rgdwPOV[2], js.rgdwPOV[3], js.rgbButtons[0]>>7, js.rgbButtons[1]>>7, js.rgbButtons[2]>>7, js.rgbButtons[3]>>7, js.rgbButtons[4]>>7, js.rgbButtons[5]>>7, js.rgbButtons[6]>>7, js.rgbButtons[7]>>7, js.rgbButtons[8]>>7, js.rgbButtons[9]>>7, js.rgbButtons[10]>>7, js.rgbButtons[11]>>7); if (strcmp(oldstate, curstate) != 0) { trace("%s\n", curstate); strcpy(oldstate, curstate); } Sleep(100); } trace("\n"); hr = IDirectInputDevice_Unacquire(pJoystick); ok(hr==DI_OK,"IDirectInputDevice_Unacquire() failed: %08x\n", hr); RELEASE: ref = IDirectInputDevice_Release(pJoystick); ok(ref==0,"IDirectInputDevice_Release() reference count = %d\n", ref); DONE: return DIENUM_CONTINUE; }
int CALLBACK WinMain(HINSTANCE Instance, HINSTANCE PrevInstance, LPSTR CommandLine, int ShowFlags) { DWORD error; UINT DesiredSchedulerMS = 1; float MSPerFrame = 0; float TargetSecondsPerFrame; int width; int height; HWND Window; RECT ClientRect; HGLRC RC; GLenum err = 0; GameState state = {0}; WNDCLASSEX WindowClass; WindowClass.cbSize = sizeof(WindowClass); WindowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; WindowClass.lpfnWndProc = MyWindowProc; WindowClass.cbClsExtra = 0; WindowClass.cbWndExtra = 0; WindowClass.hInstance = Instance; WindowClass.hIcon = 0; WindowClass.hCursor = 0; WindowClass.hbrBackground = 0; WindowClass.lpszMenuName = NULL; WindowClass.lpszClassName = "WindowClass"; WindowClass.hIconSm = 0; if( RegisterClassEx(&WindowClass) ) { width = GetSystemMetrics(SM_CXMAXIMIZED); height = GetSystemMetrics(SM_CYMAXIMIZED); Window = CreateWindowExA(0, WindowClass.lpszClassName, "My Test Window", WS_OVERLAPPEDWINDOW|WS_VISIBLE|WS_MAXIMIZE, 0, 0, width, height, 0, 0, Instance, 0); TargetSecondsPerFrame = 1.0f / 60.0f; if(Window) { HDC DC = GetDC(Window); SetupPixelFormat(DC); RC = wglCreateContext(DC); wglMakeCurrent(DC, RC); err = glewInit(); if (GLEW_OK != err) fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); GetClientRect(Window, &ClientRect); width = ClientRect.right - ClientRect.left; height = ClientRect.bottom - ClientRect.top; state.width = (float)width; state.height = (float)height; glViewport(0,0, width, height); glEnable(GL_DEPTH_TEST); //V3 p1 = { -8.0f, 6.0f, 4.3f }; V3 p1 = { 0.0f, 6.0f, 4.0f }; InitCamera(&state.main, p1); state.deltaT = TargetSecondsPerFrame; InitGame(&state); Running = 1; LARGE_INTEGER start, end; float timeElasped; DWORD sleepMS; while(Running) { start = Win32GetTime(); ProcessMessages(&state); if(state.keys & Z_KEY){ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); }else { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); } UpdateAndRender(&state); end = Win32GetTime(); timeElasped = Win32GetSecondsElapsed(start, end); if(timeElasped < TargetSecondsPerFrame){ sleepMS = (DWORD)((TargetSecondsPerFrame*1000) - (timeElasped*1000)); Sleep(sleepMS); }else{ OutputDebugString("Missed Frame"); } SwapBuffers(DC); } } else { error = GetLastError(); } } else { error = GetLastError(); } return 0; }
int CALLBACK WinMain(HINSTANCE Instance, HINSTANCE PrevInstance, LPSTR CommandLine, int ShowCode) { Win32LoadXInput(); WNDCLASSA WindowClass = {}; Win32ResizeDIBSection(&GlobalBackbuffer, 1280, 720); WindowClass.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC; WindowClass.lpfnWndProc = Win32MainWindowCallback; WindowClass.hInstance = Instance; // WindowClass.hIcon = ; WindowClass.lpszClassName = "HandmadeHeroWindowClass"; if (RegisterClassA(&WindowClass)) { HWND Window = CreateWindowExA(0, WindowClass.lpszClassName, "Handmade Hero", WS_OVERLAPPEDWINDOW|WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, Instance, 0); if (Window) { // NOTE: Since we specified CS_OWNDC, we can just // get one device context and use it forever because we // are not sharing it with anyone. HDC DeviceContext = GetDC(Window); // NOTE: Graphics test int XOffset = 0; int YOffset = 0; win32_sound_output SoundOutput = {}; // TODO: Make this like sixty seconds? SoundOutput.SamplesPerSecond = 48000; SoundOutput.ToneHz = 256; SoundOutput.ToneVolume = 3000; SoundOutput.WavePeriod = SoundOutput.SamplesPerSecond / SoundOutput.ToneHz; SoundOutput.BytesPerSample = sizeof(int16) * 2; SoundOutput.SecondaryBufferSize = SoundOutput.SamplesPerSecond * SoundOutput.BytesPerSample; SoundOutput.LatencySampleCount = SoundOutput.SamplesPerSecond / 15; Win32InitDSound(Window, SoundOutput.SamplesPerSecond, SoundOutput.SecondaryBufferSize); Win32FillSoundBuffer(&SoundOutput, 0, SoundOutput.LatencySampleCount * SoundOutput.BytesPerSample); GlobalSecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING); GlobalRunning = true; while(GlobalRunning) { MSG Message; while(PeekMessage(&Message, 0, 0, 0, PM_REMOVE)) { if (Message.message == WM_QUIT) { GlobalRunning = false; } TranslateMessage(&Message); DispatchMessageA(&Message); } // TODO: Should we poll this more frequently for (DWORD ControllerIndex = 0; ControllerIndex < XUSER_MAX_COUNT; ++ControllerIndex) { XINPUT_STATE ControllerState; if (XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS) { // NOTE: This controller is plugged in // TODO: See if ControllerState.dwPacketNumber increments too rapidly XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad; bool32 Up = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP); bool32 Down = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN); bool32 Left = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT); bool32 Right = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT); bool32 Start = (Pad->wButtons & XINPUT_GAMEPAD_START); bool32 Back = (Pad->wButtons & XINPUT_GAMEPAD_BACK); bool32 LeftShoulder = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER); bool32 RightShoulder = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER); bool32 AButton = (Pad->wButtons & XINPUT_GAMEPAD_A); bool32 BButton = (Pad->wButtons & XINPUT_GAMEPAD_B); bool32 XButton = (Pad->wButtons & XINPUT_GAMEPAD_X); bool32 YButton = (Pad->wButtons & XINPUT_GAMEPAD_Y); int16 StickX = Pad->sThumbLX; int16 StickY = Pad->sThumbLY; // TODO: We will do deadzone handling later using // XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE // XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE XOffset += StickX / 4096; YOffset += StickY / 4096; SoundOutput.ToneHz = 512 + (int)(256.0f * ((real32)StickY / 30000.0f)); SoundOutput.WavePeriod = SoundOutput.SamplesPerSecond / SoundOutput.ToneHz; } else { // NOTE: The controller is not available } } RenderWeirdGradient(&GlobalBackbuffer, XOffset, YOffset); // NOTE: DirectSound output test DWORD PlayCursor; DWORD WriteCursor; if (SUCCEEDED(GlobalSecondaryBuffer->GetCurrentPosition(&PlayCursor, &WriteCursor))) { DWORD ByteToLock = (SoundOutput.RunningSampleIndex * SoundOutput.BytesPerSample) % SoundOutput.SecondaryBufferSize; DWORD TargetCursor = (PlayCursor + (SoundOutput.LatencySampleCount * SoundOutput.BytesPerSample)) % SoundOutput.SecondaryBufferSize; DWORD BytesToWrite; // TODO: Change this to using a lower latency offset from the playcursor // when we actually start having sound effects. if (ByteToLock > TargetCursor) { BytesToWrite = SoundOutput.SecondaryBufferSize - ByteToLock; BytesToWrite += TargetCursor; } else { BytesToWrite = TargetCursor - ByteToLock; } Win32FillSoundBuffer(&SoundOutput, ByteToLock, BytesToWrite); } win32_window_dimension Dimension = Win32GetWindowDimension(Window); Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext, Dimension.Width, Dimension.Height); } } else { // TODO: Logging } } else { // TODO: Logging } return 0; }
static HWND createComboEx(DWORD style) { return CreateWindowExA(0, WC_COMBOBOXEXA, NULL, style, 0, 0, 300, 300, hComboExParentWnd, NULL, hMainHinst, NULL); }