/* MAKE_EXPORT LoadCursorW_new=LoadCursorW */ HCURSOR WINAPI LoadCursorW_new(HINSTANCE hInstance, LPCWSTR lpCursorNameW) { if(IS_INTRESOURCE(lpCursorNameW)) return LoadCursorA(hInstance, (LPCSTR)lpCursorNameW); ALLOC_WtoA(lpCursorName); return LoadCursorA(hInstance, lpCursorNameA); }
static void scrollbar_test_init(void) { WNDCLASSEXA wc; CHAR cls_name[] = "scroll_test_class"; LONG style[] = {WS_VSCROLL, WS_HSCROLL, WS_VSCROLL | WS_HSCROLL, 0}; int i; memset( &wc, 0, sizeof wc ); wc.cbSize = sizeof wc; wc.style = CS_VREDRAW | CS_HREDRAW; wc.hInstance = GetModuleHandleA(0); wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW); wc.hbrBackground = GetStockObject(WHITE_BRUSH); wc.lpszClassName = cls_name; wc.lpfnWndProc = scroll_init_proc; RegisterClassExA(&wc); for(i = 0; i < sizeof style / sizeof style[0]; i++) { /* need not to destroy these windows due creation abort */ CreateWindowExA(0, cls_name, NULL, style[i], 100, 100, 100, 100, NULL, NULL, wc.hInstance, (LPVOID)TRUE); CreateWindowExA(0, cls_name, NULL, style[i], 100, 100, 100, 100, NULL, NULL, wc.hInstance, (LPVOID)FALSE); } UnregisterClassA(cls_name, wc.hInstance); }
static HWND CreateTestWindow() { MSG msg; WNDCLASSA wclass; HANDLE hInstance = GetModuleHandleA( NULL ); HWND hWndTest; wclass.lpszClassName = "MouseInputTestClass"; wclass.style = CS_HREDRAW | CS_VREDRAW; wclass.lpfnWndProc = WndProc; wclass.hInstance = hInstance; wclass.hIcon = LoadIconA( 0, IDI_APPLICATION ); wclass.hCursor = LoadCursorA( NULL, IDC_ARROW ); wclass.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 ); wclass.lpszMenuName = 0; wclass.cbClsExtra = 0; wclass.cbWndExtra = 0; RegisterClassA( &wclass ); /* create the test window that will receive the keystrokes */ hWndTest = CreateWindowA( wclass.lpszClassName, "MouseInputTestTest", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 100, 100, NULL, NULL, hInstance, NULL); assert( hWndTest ); ShowWindow( hWndTest, SW_SHOWMAXIMIZED); SetWindowPos( hWndTest, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE ); SetForegroundWindow( hWndTest ); UpdateWindow( hWndTest); SetFocus(hWndTest); /* flush pending messages */ while (PeekMessage( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg ); return hWndTest; }
static BOOL RegisterWindowClasses (void) { WNDCLASSA cls; cls.style = 0; cls.lpfnWndProc = DefWindowProcA; cls.cbClsExtra = 0; cls.cbWndExtra = 0; cls.hInstance = g_hinst; cls.hIcon = NULL; cls.hCursor = LoadCursorA (NULL, IDC_ARROW); cls.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); cls.lpszMenuName = NULL; cls.lpszClassName = "GetNextDlgItemWindowClass"; if (!RegisterClassA (&cls)) return FALSE; cls.lpfnWndProc = main_window_procA; cls.lpszClassName = "IsDialogMessageWindowClass"; if (!RegisterClassA (&cls)) return FALSE; GetClassInfoA(0, "#32770", &cls); cls.lpfnWndProc = testDlgWinProc; cls.lpszClassName = "WM_NEXTDLGCTLWndClass"; if (!RegisterClassA (&cls)) return FALSE; return TRUE; }
static void init(void) { WNDCLASSA wc; RECT rect; BOOL ret; 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 = progressTestClass; wc.lpfnWndProc = progress_test_wnd_proc; RegisterClassA(&wc); SetRect(&rect, 0, 0, 400, 20); ret = AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE); ok(ret, "got %d\n", ret); hProgressParentWnd = CreateWindowExA(0, progressTestClass, "Progress Bar Test", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, GetModuleHandleA(NULL), 0); ok(hProgressParentWnd != NULL, "failed to create parent wnd\n"); }
static void createwindow(void) { wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = DefWindowProcA; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandleA(0); wc.hIcon = LoadIconA(wc.hInstance, IDI_APPLICATION); wc.hCursor = LoadCursorA(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH); wc.lpszMenuName = NULL; wc.lpszClassName = "TestWindowClass"; if(!RegisterClassA(&wc)) assert(0); hwnd = CreateWindowExA(0, "TestWindowClass", "TestWindowClass", WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), NULL, NULL, GetModuleHandleA(0), NULL); assert(hwnd != NULL); ShowWindow(hwnd, SW_HIDE); UpdateWindow(hwnd); SetFocus(hwnd); }
bool RenderWindow::Init(void *pData) { bool bRet=false; WNDCLASSEXA wndclass; wndclass.cbWndExtra=0; wndclass.cbClsExtra=0; wndclass.cbSize=sizeof(WNDCLASSEXA); wndclass.hbrBackground=NULL; wndclass.hCursor=LoadCursorA(NULL,MAKEINTRESOURCEA(IDC_ARROW)); wndclass.hInstance=*(HINSTANCE*)pData; wndclass.style=CS_VREDRAW|CS_HREDRAW; wndclass.lpszMenuName=NULL; wndclass.lpszClassName="vCoreMainWindow"; if (NULL==wndclass.hInstance) { Van::Log::ErrLog.Print("hinstance is null"); } wndclass.hIcon=(HICON)LoadImageA(wndclass.hInstance,"../Logo.ico",IMAGE_ICON,0,0,LR_LOADFROMFILE); wndclass.hIconSm=(HICON)LoadImageA(wndclass.hInstance,"../Logo.ico",IMAGE_ICON,0,0,LR_LOADFROMFILE); wndclass.lpfnWndProc=SystemEventManager::SystemEventProcesser; if (!RegisterClassExA(&wndclass)) { Van::Log::ErrLog.Print("RegisterClassExA fail!"); return false; } Van::Log::DebugLog.Print("Register Render Window Sucess!"); m_hWnd=CreateWindowExA((DWORD)NULL, "vCoreMainWindow", "Van Core Render Window", WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|!WS_MAXIMIZEBOX, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, *(HINSTANCE*)pData, NULL); if(NULL==m_hWnd) { Log::ErrLog.Print("create Window fail!"); return false; } m_hDC=GetDC(m_hWnd); DWORD dwCurrentStyle = GetWindowLongA(m_hWnd, GWL_STYLE); SetWindowLong(m_hWnd, GWL_STYLE, dwCurrentStyle &~WS_SYSMENU); m_pRenderWindow=new GLRenderWindow(); RECT rect; GetWindowRect(m_hWnd,&rect); m_uiWidth=rect.right-rect.left; m_uiHeight=rect.bottom-rect.top; if(m_pRenderWindow->CreateRendererViaDevice(m_hWnd,m_hDC,m_uiWidth,m_uiHeight)) { bRet=true; CreateScene(); } return bRet; }
/** * sgens_window_show(): Show the VDP Layer Options window. * @param parent Parent window. */ void MDP_FNCALL sgens_window_show(void *parent) { if (sgens_window) { // Sonic Gens window is already visible. Set focus. // TODO: Figure out how to do this. ShowWindow(sgens_window, SW_SHOW); return; } // Initialize the Win32 Unicode Translation Layer. w32u_init(); sgens_window_child_windows_created = FALSE; // If no HINSTANCE was specified, use the main executable's HINSTANCE. if (!sgens_hInstance) sgens_hInstance = GetModuleHandle(NULL); if (sgens_wndclass.lpfnWndProc != sgens_window_wndproc) { // Create the window class. sgens_wndclass.style = 0; sgens_wndclass.lpfnWndProc = sgens_window_wndproc; sgens_wndclass.cbClsExtra = 0; sgens_wndclass.cbWndExtra = 0; sgens_wndclass.hInstance = sgens_hInstance; sgens_wndclass.hIcon = LoadIconA(sgens_hInstance, MAKEINTRESOURCE(IDI_SGENS)); sgens_wndclass.hCursor = LoadCursorA(NULL, IDC_ARROW); sgens_wndclass.hbrBackground = GetSysColorBrush(COLOR_3DFACE); sgens_wndclass.lpszMenuName = NULL; sgens_wndclass.lpszClassName = "mdp_misc_sgens_window"; pRegisterClassU(&sgens_wndclass); } // Create the window. sgens_window = pCreateWindowU("mdp_misc_sgens_window", "Sonic Gens", WS_DLGFRAME | WS_POPUP | WS_SYSMENU | WS_CAPTION, CW_USEDEFAULT, CW_USEDEFAULT, SGENS_WINDOW_WIDTH, SGENS_WINDOW_HEIGHT, (HWND)parent, NULL, sgens_hInstance, NULL); // Window adjustment. gsft_win32_set_actual_window_size(sgens_window, SGENS_WINDOW_WIDTH, SGENS_WINDOW_HEIGHT); gsft_win32_center_on_window(sgens_window, (HWND)parent); // Update the current ROM type and information display. sgens_window_update_rom_type(); sgens_window_update(); UpdateWindow(sgens_window); ShowWindow(sgens_window, TRUE); // Register the window with MDP Host Services. sgens_host_srv->window_register(&mdp, sgens_window); }
void MCScreenDC::setcursor(Window p_window, MCCursorRef p_cursor) { if (p_cursor == nil || p_cursor -> kind == kMCCursorNone) SetCursor(NULL); else if (p_cursor -> kind == kMCCursorStandard) SetCursor(LoadCursorA(nil, p_cursor -> standard)); else SetCursor(p_cursor -> custom); }
int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { HINSTANCE Module = hInstance; WNDCLASSEX WindowClass = {}; WindowClass.cbSize = sizeof(WindowClass); WindowClass.style = CS_HREDRAW | CS_VREDRAW; WindowClass.lpfnWndProc = MainWindowProc; WindowClass.hInstance = Module; WindowClass.hIcon = LoadIcon(0, IDI_APPLICATION); WindowClass.hCursor = LoadCursorA(0, IDC_ARROW); WindowClass.lpszClassName = WINDOW_CLASS_NAME; RegisterClassExA(&WindowClass); DWORD WindowExStyle = WS_EX_APPWINDOW; DWORD WindowStyle = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW & ~(WS_THICKFRAME | WS_MAXIMIZEBOX); HWND MainWindow = CreateWindowEx( WindowExStyle, WINDOW_CLASS_NAME, "FSWindow", WindowStyle, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, Module, 0); RECT AdjustRect = {}; AdjustRect.right = MAIN_WINDOW_WIDTH; AdjustRect.bottom = MAIN_WINDOW_HEIGHT; AdjustWindowRectEx(&AdjustRect, WindowStyle, FALSE, WindowExStyle); SetWindowPos(MainWindow, 0, 0, 0, AdjustRect.right - AdjustRect.left, AdjustRect.bottom - AdjustRect.top, SWP_NOMOVE | SWP_NOCOPYBITS | SWP_SHOWWINDOW); BOOL Running = TRUE; while(Running) { MSG Message; while(PeekMessageA(&Message, 0, 0, 0, PM_REMOVE)) { if(Message.message == WM_QUIT) { Running = FALSE; break; } else { TranslateMessage(&Message); DispatchMessageA(&Message); } } Sleep(10); } return 0; }
/****************************************************************************** * FillTreeView [Internal] * * For each child (given by lpe) of the parent shell folder, which is given by * lpsf and whose PIDL is pidl, insert a treeview-item right under hParent * * PARAMS * info [I] data for the dialog * lpsf [I] IShellFolder interface of the parent shell folder * pidl [I] ITEMIDLIST of the parent shell folder * hParent [I] The treeview item that represents the parent shell folder * lpe [I] An iterator for the children of the parent shell folder */ static void FillTreeView( browse_info *info, IShellFolder * lpsf, LPITEMIDLIST pidl, HTREEITEM hParent, IEnumIDList* lpe) { HTREEITEM hPrev = 0; LPITEMIDLIST pidlTemp = 0; ULONG ulFetched; HRESULT hr; HWND hwnd = GetParent( info->hwndTreeView ); TRACE("%p %p %p %p\n",lpsf, pidl, hParent, lpe); /* No IEnumIDList -> No children */ if (!lpe) return; SetCapture( hwnd ); SetCursor( LoadCursorA( 0, (LPSTR)IDC_WAIT ) ); while (NOERROR == IEnumIDList_Next(lpe,1,&pidlTemp,&ulFetched)) { ULONG ulAttrs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER; IEnumIDList* pEnumIL = NULL; IShellFolder* pSFChild = NULL; IShellFolder_GetAttributesOf(lpsf, 1, (LPCITEMIDLIST*)&pidlTemp, &ulAttrs); if (ulAttrs & SFGAO_FOLDER) { hr = IShellFolder_BindToObject(lpsf,pidlTemp,NULL,&IID_IShellFolder,(LPVOID*)&pSFChild); if (SUCCEEDED(hr)) { DWORD flags = BrowseFlagsToSHCONTF(info->lpBrowseInfo->ulFlags); hr = IShellFolder_EnumObjects(pSFChild, hwnd, flags, &pEnumIL); if (hr == S_OK) { if ((IEnumIDList_Skip(pEnumIL, 1) != S_OK) || FAILED(IEnumIDList_Reset(pEnumIL))) { IEnumIDList_Release(pEnumIL); pEnumIL = NULL; } } IShellFolder_Release(pSFChild); } } if (!(hPrev = InsertTreeViewItem(info, lpsf, pidlTemp, pidl, pEnumIL, hParent))) goto done; SHFree(pidlTemp); /* Finally, free the pidl that the shell gave us... */ pidlTemp=NULL; } done: ReleaseCapture(); SetCursor(LoadCursorW(0, (LPWSTR)IDC_ARROW)); SHFree(pidlTemp); }
/** * vlopt_window_show(): Show the VDP Layer Options window. * @param parent Parent window. */ void vlopt_window_show(void *parent) { if (vlopt_window) { // VDP Layer Options window is already visible. // Set focus. // TODO return; } // Initialize the Win32 Unicode Translation Layer. w32u_init(); vlopt_window_child_windows_created = FALSE; // If no HINSTANCE was specified, use the main executable's HINSTANCE. if (!vlopt_hInstance) vlopt_hInstance = pGetModuleHandleU(NULL); // Create the window class. if (vlopt_window_wndclass.lpfnWndProc != vlopt_window_wndproc) { vlopt_window_wndclass.style = 0; vlopt_window_wndclass.lpfnWndProc = vlopt_window_wndproc; vlopt_window_wndclass.cbClsExtra = 0; vlopt_window_wndclass.cbWndExtra = 0; vlopt_window_wndclass.hInstance = vlopt_hInstance; vlopt_window_wndclass.hIcon = LoadIconA(vlopt_hInstance, MAKEINTRESOURCE(IDI_VLOPT)); vlopt_window_wndclass.hCursor = LoadCursorA(NULL, IDC_ARROW); vlopt_window_wndclass.hbrBackground = GetSysColorBrush(COLOR_3DFACE); vlopt_window_wndclass.lpszMenuName = NULL; vlopt_window_wndclass.lpszClassName = "vlopt_window_wndclass"; pRegisterClassU(&vlopt_window_wndclass); } // Create the window. vlopt_window = pCreateWindowU("vlopt_window_wndclass", "VDP Layer Options", WS_DLGFRAME | WS_POPUP | WS_SYSMENU | WS_CAPTION, CW_USEDEFAULT, CW_USEDEFAULT, DLU_X(VLOPT_WINDOW_WIDTH), DLU_Y(VLOPT_WINDOW_HEIGHT), (HWND)parent, NULL, vlopt_hInstance, NULL); // Window adjustment. gsft_win32_set_actual_window_size(vlopt_window, DLU_X(VLOPT_WINDOW_WIDTH), DLU_Y(VLOPT_WINDOW_HEIGHT)); gsft_win32_center_on_window(vlopt_window, (HWND)parent); UpdateWindow(vlopt_window); ShowWindow(vlopt_window, TRUE); // Register the window with MDP Host Services. vlopt_host_srv->window_register(&mdp, vlopt_window); }
static void init(void) { HMODULE hComctl32; BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*); WNDCLASSA wc; RECT rect; BOOL ret; hComctl32 = GetModuleHandleA("comctl32.dll"); pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx"); if (pInitCommonControlsEx) { INITCOMMONCONTROLSEX iccex; iccex.dwSize = sizeof(iccex); iccex.dwICC = ICC_PROGRESS_CLASS; pInitCommonControlsEx(&iccex); } else InitCommonControls(); 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 = progressTestClass; wc.lpfnWndProc = progress_test_wnd_proc; RegisterClassA(&wc); SetRect(&rect, 0, 0, 400, 20); ret = AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE); ok(ret, "got %d\n", ret); hProgressParentWnd = CreateWindowExA(0, progressTestClass, "Progress Bar Test", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, GetModuleHandleA(NULL), 0); ok(hProgressParentWnd != NULL, "failed to create parent wnd\n"); GetClientRect(hProgressParentWnd, &rect); hProgressWnd = CreateWindowExA(0, PROGRESS_CLASSA, "", WS_CHILD | WS_VISIBLE, 0, 0, rect.right, rect.bottom, hProgressParentWnd, NULL, GetModuleHandleA(NULL), 0); ok(hProgressWnd != NULL, "failed to create parent wnd\n"); progress_wndproc = (WNDPROC)SetWindowLongPtrA(hProgressWnd, GWLP_WNDPROC, (LPARAM)progress_subclass_proc); ShowWindow(hProgressParentWnd, SW_SHOWNORMAL); ok(GetUpdateRect(hProgressParentWnd, NULL, FALSE), "GetUpdateRect: There should be a region that needs to be updated\n"); flush_events(); update_window(hProgressParentWnd); }
static BOOL register_parent_wnd_class(void){ WNDCLASSA cls; cls.style = 0; cls.lpfnWndProc = parent_wnd_proc; cls.cbClsExtra = 0; cls.cbWndExtra = 0; cls.hInstance = GetModuleHandleA(NULL); cls.hIcon = 0; cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW); cls.hbrBackground = GetStockObject(WHITE_BRUSH); cls.lpszMenuName = NULL; cls.lpszClassName = "Trackbar test parent class"; return RegisterClassA(&cls); }
static void register_testwindow_class(void) { WNDCLASSEXA cls; ZeroMemory(&cls, sizeof(cls)); cls.cbSize = sizeof(cls); cls.style = 0; cls.lpfnWndProc = testwindow_wndproc; cls.hInstance = NULL; cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW); cls.hbrBackground = (HBRUSH) COLOR_WINDOW; cls.lpszClassName = testwindow_class; RegisterClassExA(&cls); }
static void register_class(void) { WNDCLASSA cls; cls.style = CS_DBLCLKS; cls.lpfnWndProc = DefWindowProcA; cls.cbClsExtra = 0; cls.cbWndExtra = 0; cls.hInstance = GetModuleHandleA(0); cls.hIcon = 0; cls.hCursor = LoadCursorA(0, IDC_ARROW); cls.hbrBackground = GetStockObject(WHITE_BRUSH); cls.lpszMenuName = NULL; cls.lpszClassName = "WinStationClass"; RegisterClassA(&cls); }
static ATOM register_class(void) { WNDCLASSA wndclassA; wndclassA.style = 0; wndclassA.lpfnWndProc = DefWindowProc; wndclassA.cbClsExtra = 0; wndclassA.cbWndExtra = 0; wndclassA.hInstance = GetModuleHandleA(NULL); wndclassA.hIcon = NULL; wndclassA.hCursor = LoadCursorA(NULL, IDC_ARROW); wndclassA.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1); wndclassA.lpszMenuName = NULL; wndclassA.lpszClassName = "WineAtlTestClass"; return RegisterClassA(&wndclassA); }
static void createMainWnd(void) { WNDCLASSA wc; wc.style = CS_HREDRAW | CS_VREDRAW; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandleA(NULL); wc.hIcon = NULL; wc.hCursor = LoadCursorA(NULL, IDC_IBEAM); wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW); wc.lpszMenuName = NULL; wc.lpszClassName = "MyTestWnd"; wc.lpfnWndProc = MyWndProc; RegisterClassA(&wc); hMainWnd = CreateWindowExA(0, "MyTestWnd", "Blah", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 130, 105, NULL, NULL, GetModuleHandleA(NULL), 0); }
/* Registers the window class. */ static BOOL RICHED32_Register(void) { WNDCLASSA wndClass; ZeroMemory(&wndClass, sizeof(WNDCLASSA)); wndClass.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS; wndClass.lpfnWndProc = RichEdit10ANSIWndProc; wndClass.cbClsExtra = 0; wndClass.cbWndExtra = sizeof(void *); wndClass.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW); wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); wndClass.lpszClassName = RICHEDIT_CLASS10A; /* WC_RICHED32A; */ RegisterClassA(&wndClass); return TRUE; }
static BOOL register_parent_wnd_class(void) { WNDCLASSA wc; 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_IBEAM); wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW); wc.lpszMenuName = NULL; wc.lpszClassName = "MyTestWnd"; wc.lpfnWndProc = parent_wndproc; return RegisterClassA(&wc); }
/*********************************************************************** * FD31_ScanDir [internal] */ static BOOL FD31_ScanDir(HWND hWnd, LPWSTR newPath) { WCHAR buffer[BUFFILE]; HWND hdlg, hdlgDir; LRESULT lRet = TRUE; HCURSOR hCursorWait, oldCursor; TRACE("Trying to change to %s\n", debugstr_w(newPath)); if ( newPath[0] && !SetCurrentDirectoryW( newPath )) return FALSE; lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR)); /* get the list of spec files */ GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR)); hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT); oldCursor = SetCursor(hCursorWait); /* list of files */ if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) { WCHAR* scptr; /* ptr on semi-colon */ WCHAR* filter = buffer; TRACE("Using filter %s\n", debugstr_w(filter)); SendMessageW(hdlg, LB_RESETCONTENT, 0, 0); while (filter) { scptr = strchrW(filter, ';'); if (scptr) *scptr = 0; while (*filter == ' ') filter++; TRACE("Using file spec %s\n", debugstr_w(filter)); if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR) return FALSE; if (scptr) *scptr = ';'; filter = (scptr) ? (scptr + 1) : 0; } } /* list of directories */ strcpyW(buffer, FILE_star); if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) { lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY); } SetCursor(oldCursor); return lRet; }
/*********************************************************************** * FD31_ScanDir [internal] */ static BOOL FD31_ScanDir(const OPENFILENAMEW *ofn, HWND hWnd, LPCWSTR newPath) { WCHAR buffer[BUFFILE]; HWND hdlg; LRESULT lRet = TRUE; HCURSOR hCursorWait, oldCursor; TRACE("Trying to change to %s\n", debugstr_w(newPath)); if ( newPath[0] && !SetCurrentDirectoryW( newPath )) return FALSE; /* get the list of spec files */ lstrcpynW(buffer, FD31_GetFileType(ofn->lpstrCustomFilter, ofn->lpstrFilter, ofn->nFilterIndex - 1), BUFFILE); hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT); oldCursor = SetCursor(hCursorWait); /* list of files */ if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) { WCHAR* scptr; /* ptr on semi-colon */ WCHAR* filter = buffer; TRACE("Using filter %s\n", debugstr_w(filter)); SendMessageW(hdlg, LB_RESETCONTENT, 0, 0); while (filter) { scptr = strchrW(filter, ';'); if (scptr) *scptr = 0; while (*filter == ' ') filter++; TRACE("Using file spec %s\n", debugstr_w(filter)); SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter); if (scptr) *scptr = ';'; filter = (scptr) ? (scptr + 1) : 0; } } /* list of directories */ strcpyW(buffer, FILE_star); if (GetDlgItem(hWnd, lst2) != 0) { lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY); } SetCursor(oldCursor); return lRet; }
Wasabi::Wasabi() { engineParams = { { "appName", (void*)"Wasabi" }, // LPCSTR { "classStyle", (void*)(CS_HREDRAW | CS_VREDRAW) }, // DWORD { "classIcon", (void*)(NULL) }, // HICON { "classCursor", (void*)(LoadCursorA(NULL, MAKEINTRESOURCEA(32512))) }, // HCURSOR { "menuName", (void*)(NULL) }, // LPCSTR { "menuProc", (void*)(NULL) }, // void (*) (HMENU, UINT) { "classIcon_sm", (void*)(NULL) }, // HICON { "windowMenu", (void*)(NULL) }, // HMENU { "windowParent", (void*)(NULL) }, // HWND { "windowStyle", (void*)(WS_CAPTION | WS_OVERLAPPEDWINDOW | WS_VISIBLE) }, // DWORD { "windowStyleEx", (void*)(WS_EX_OVERLAPPEDWINDOW) }, // DWORD { "defAdapter", (void*)(0) }, // int { "defWndX", (void*)(-1) }, // int { "defWndY", (void*)(-1) }, //int }; }
static ATOM register_dummy_class(void) { WNDCLASSA wc = { 0, DefWindowProcA, 0, 0, GetModuleHandleA(NULL), NULL, LoadCursorA(NULL, (LPSTR)IDC_ARROW), (HBRUSH)(COLOR_BTNFACE+1), NULL, "WineOleTestClass", }; return RegisterClassA(&wc); }
/* window procedure for the desktop window */ static LRESULT WINAPI desktop_wnd_proc( HWND hwnd, UINT message, WPARAM wp, LPARAM lp ) { WINE_TRACE( "got msg %04x wp %lx lp %lx\n", message, wp, lp ); switch(message) { case WM_SYSCOMMAND: switch(wp & 0xfff0) { case SC_CLOSE: ExitWindows( 0, 0 ); break; case SC_SCREENSAVE: return start_screensaver(); } return 0; case WM_CLOSE: PostQuitMessage(0); return 0; case WM_SETCURSOR: return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_ARROW ) ); case WM_NCHITTEST: return HTCLIENT; case WM_ERASEBKGND: if (!using_root) PaintDesktop( (HDC)wp ); return TRUE; case WM_PAINT: { PAINTSTRUCT ps; BeginPaint( hwnd, &ps ); if (!using_root && ps.fErase) PaintDesktop( ps.hdc ); EndPaint( hwnd, &ps ); } return 0; default: return DefWindowProcW( hwnd, message, wp, lp ); } }
static BOOL dsm_RegisterWindowClasses(void) { WNDCLASSA cls; BOOL rc; cls.style = 0; cls.lpfnWndProc = DefWindowProcA; cls.cbClsExtra = 0; cls.cbWndExtra = 0; cls.hInstance = GetModuleHandleA(0); cls.hIcon = 0; cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW); cls.hbrBackground = GetStockObject(WHITE_BRUSH); cls.lpszMenuName = NULL; cls.lpszClassName = "TWAIN_dsm_class"; rc = RegisterClassA(&cls); ok(rc, "RegisterClassA failed: le=%u\n", GetLastError()); return rc; }
static inline VOID RegisterDialogClass(LPCSTR name, WNDPROC callback, HINSTANCE hInst) { WNDCLASSA wnd; wnd.style = CS_HREDRAW | CS_VREDRAW; wnd.cbWndExtra = DLGWINDOWEXTRA; wnd.cbClsExtra = 0; wnd.hCursor = LoadCursorA(NULL,(LPCSTR)MAKEINTRESOURCE(IDC_ARROW)); wnd.hIcon = LoadIcon(NULL,MAKEINTRESOURCE(IDI_ICON1)); wnd.hInstance = hInst; wnd.lpfnWndProc = callback; wnd.lpszClassName = name; wnd.lpszMenuName = NULL; wnd.hbrBackground = (HBRUSH)(COLOR_WINDOW); if (!RegisterClassA(&wnd)) { return; } }
egl::Error DisplayD3D::initialize(egl::Display *display) { ASSERT(mRenderer == nullptr && display != nullptr); mDisplay = display; egl::Error error = CreateRendererD3D(display, &mRenderer); if (error.isError()) { return error; } ASSERT(mDevice == nullptr); mDevice = new DeviceD3D(mRenderer); #if !defined(ANGLE_ENABLE_WINDOWS_STORE) // Work around compile error from not defining "UNICODE" while Chromium does const LPSTR idcArrow = MAKEINTRESOURCEA(32512); std::string className = FormatString("ANGLE DisplayD3D 0x%0.8p Child Window Class", mDisplay); WNDCLASSA childWindowClassDesc = { 0 }; childWindowClassDesc.style = CS_OWNDC; childWindowClassDesc.lpfnWndProc = IntermediateWindowProc; childWindowClassDesc.cbClsExtra = 0; childWindowClassDesc.cbWndExtra = 0; childWindowClassDesc.hInstance = GetModuleHandle(nullptr); childWindowClassDesc.hIcon = nullptr; childWindowClassDesc.hCursor = LoadCursorA(nullptr, idcArrow); childWindowClassDesc.hbrBackground = 0; childWindowClassDesc.lpszMenuName = nullptr; childWindowClassDesc.lpszClassName = className.c_str(); mChildWindowClass = RegisterClassA(&childWindowClassDesc); if (!mChildWindowClass) { return egl::Error(EGL_NOT_INITIALIZED, "Failed to register child window class."); } #endif return egl::Error(EGL_SUCCESS); }
static BOOL init_procs(void) { WNDCLASSA cls; HANDLE user32 = GetModuleHandleA("user32.dll"); pBroadcastA = (PBROADCAST)GetProcAddress(user32, "BroadcastSystemMessageA"); if (!pBroadcastA) pBroadcastA = (PBROADCAST)GetProcAddress(user32, "BroadcastSystemMessage"); ok(pBroadcastA != NULL, "No BroadcastSystemMessage found\n"); if (!pBroadcastA) { win_skip("BroadcastA is not available\n"); return FALSE; } pBroadcastW = (PBROADCAST)GetProcAddress(user32, "BroadcastSystemMessageW"); pBroadcastExA = (PBROADCASTEX)GetProcAddress(user32, "BroadcastSystemMessageExA"); pBroadcastExW = (PBROADCASTEX)GetProcAddress(user32, "BroadcastSystemMessageExW"); hevent = CreateEventA(NULL, TRUE, FALSE, "Asynchronous checking event"); cls.style = CS_DBLCLKS; cls.lpfnWndProc = main_window_procA; cls.cbClsExtra = 0; cls.cbWndExtra = 0; cls.hInstance = GetModuleHandleA(0); cls.hIcon = 0; cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW); cls.hbrBackground = GetStockObject(WHITE_BRUSH); cls.lpszMenuName = NULL; cls.lpszClassName = "MainWindowClass"; if (!RegisterClassA(&cls)) return FALSE; if (!CreateWindowExA(0, "MainWindowClass", "Main window", WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP, 100, 100, 200, 200, 0, 0, GetModuleHandleA(NULL), NULL)) return FALSE; return TRUE; }
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; }