/* 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;
}
