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;
}
HRESULT Window::StaticInitialize()
{
g_plistIdle = new TList<Window*>;
WNDCLASSA wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)Win32WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 4;
wc.hInstance = GetModuleHandleA(NULL);
wc.hIcon = LoadIcon(NULL, ID_APP_ICON);
wc.hCursor = NULL;
#ifdef DEBUG
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); //imago test 7/7/09 (NYI final multimon issue, see enginewindow.cpp(386))
#else
wc.hbrBackground = NULL; //imago test
#endif
wc.lpszMenuName = NULL;
wc.lpszClassName = GetTopLevelWindowClassname();
RegisterClassA(&wc);
//
// See if TrackMouseEvent exists
//
s_pfnTrackMouseEvent =
(PFNTrackMouseEvent)GetProcAddress(
GetModuleHandleA("user32"),
"TrackMouseEvent"
);
return S_OK;
}
bool Win32Window::registerWindowClass() {
m_WindowClassRegistered++;
if(m_WindowClassRegistered != 1) {
return true;
}
memset(&m_WindowClass, 0, sizeof(m_WindowClass));
// Fill all the info for our window class.
m_WindowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
m_WindowClass.lpfnWndProc = Win32Window::windowProc;
m_WindowClass.hInstance = (HINSTANCE)GetModuleHandle(NULL);
m_WindowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
m_WindowClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
m_WindowClass.lpszMenuName = MAKEINTRESOURCE(NULL);
m_WindowClass.lpszClassName = ARX_WINDOW_CLASS;
m_WindowClass.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_MAIN));
// Register our window class.
bool ret = RegisterClassA(&m_WindowClass) != 0;
return ret;
}
MessageWindow::MessageWindow( const RString &sClassName )
{
AppInstance inst;
WNDCLASS WindowClass =
{
CS_OWNDC | CS_BYTEALIGNCLIENT,
WndProc,
0, /* cbClsExtra */
0, /* cbWndExtra */
inst, /* hInstance */
NULL, /* set icon later */
LoadCursor( NULL, IDC_ARROW ), /* default cursor */
NULL, /* hbrBackground */
NULL, /* lpszMenuName */
sClassName /* lpszClassName */
};
if( !RegisterClassA(&WindowClass) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS )
RageException::Throw( "%s", werr_ssprintf( GetLastError(), "RegisterClass" ).c_str() );
// XXX: on 2k/XP, use HWND_MESSAGE as parent
m_hWnd = CreateWindow( sClassName, sClassName, WS_DISABLED, 0, 0, 0, 0, NULL, NULL, inst, NULL );
ASSERT( m_hWnd != NULL );
SetProp( m_hWnd, "MessageWindow", this );
}
HWND
CreateTestWindow()
{
HINSTANCE hinst = GetModuleHandle(NULL);
WNDCLASSA wc;
wc.style = 0;
wc.lpfnWndProc = DefWindowProcA;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hinst;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = "testclass";
RegisterClassA(&wc);
return CreateWindowA("testclass",
"testwnd",
WS_VISIBLE,
0,
0,
50,
30,
NULL,
NULL,
hinst,
0);
}
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmdline, int show) {
WNDCLASSA cls;
HWND hWnd;
MSG msg;
init_server_name();
memset(&cls, 0, sizeof(cls));
cls.lpfnWndProc = (WNDPROC) WindowProc;
cls.hIcon = LoadIcon(NULL, IDI_APPLICATION);
cls.lpszClassName = server_name;
RegisterClassA(&cls);
hWnd = CreateWindowA(cls.lpszClassName, server_name, WS_OVERLAPPEDWINDOW,
0, 0, 0, 0, NULL, NULL, NULL, NULL);
ShowWindow(hWnd, SW_HIDE);
TrayIcon.cbSize = sizeof(TrayIcon);
TrayIcon.uID = ID_TRAYICON;
TrayIcon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
TrayIcon.hIcon = LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON),
IMAGE_ICON, 16, 16, 0);
TrayIcon.hWnd = hWnd;
snprintf(TrayIcon.szTip, sizeof(TrayIcon.szTip), "%s", server_name);
TrayIcon.uCallbackMessage = WM_USER;
Shell_NotifyIconA(NIM_ADD, &TrayIcon);
while (GetMessage(&msg, hWnd, 0, 0) > 0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// Return the WM_QUIT value.
return msg.wParam;
}
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 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 test_messages(void)
{
WNDCLASSA cls;
HWND win;
MSG msg;
HANDLE thread;
DWORD tid;
InitializeCriticalSection(&clipboard_cs);
memset(&cls, 0, sizeof(cls));
cls.lpfnWndProc = clipboard_wnd_proc;
cls.hInstance = GetModuleHandleA(NULL);
cls.lpszClassName = "clipboard_test";
RegisterClassA(&cls);
win = CreateWindowA("clipboard_test", NULL, 0, 0, 0, 0, 0, NULL, 0, NULL, 0);
ok(win != NULL, "CreateWindow failed: %d\n", GetLastError());
thread = CreateThread(NULL, 0, clipboard_thread, (void*)win, 0, &tid);
ok(thread != NULL, "CreateThread failed: %d\n", GetLastError());
while(GetMessageA(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessageA(&msg);
}
ok(WaitForSingleObject(thread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
CloseHandle(thread);
UnregisterClassA("clipboard_test", GetModuleHandleA(NULL));
DeleteCriticalSection(&clipboard_cs);
}
////////////////////////////////////////////////////////////
/// Register the window class
////////////////////////////////////////////////////////////
void WindowImplWin32::RegisterWindowClass()
{
if (HasUnicodeSupport())
{
WNDCLASSW WindowClass;
WindowClass.style = 0;
WindowClass.lpfnWndProc = &WindowImplWin32::GlobalOnEvent;
WindowClass.cbClsExtra = 0;
WindowClass.cbWndExtra = 0;
WindowClass.hInstance = GetModuleHandle(NULL);
WindowClass.hIcon = NULL;
WindowClass.hCursor = 0;
WindowClass.hbrBackground = 0;
WindowClass.lpszMenuName = NULL;
WindowClass.lpszClassName = ourClassNameW;
RegisterClassW(&WindowClass);
}
else
{
WNDCLASSA WindowClass;
WindowClass.style = 0;
WindowClass.lpfnWndProc = &WindowImplWin32::GlobalOnEvent;
WindowClass.cbClsExtra = 0;
WindowClass.cbWndExtra = 0;
WindowClass.hInstance = GetModuleHandle(NULL);
WindowClass.hIcon = NULL;
WindowClass.hCursor = 0;
WindowClass.hbrBackground = 0;
WindowClass.lpszMenuName = NULL;
WindowClass.lpszClassName = ourClassNameA;
RegisterClassA(&WindowClass);
}
}
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass)
{
if (g_IsNT)
return RegisterClassW(wndClass);
WNDCLASSA wndClassA;
wndClassA.style = wndClass->style;
wndClassA.lpfnWndProc = wndClass->lpfnWndProc;
wndClassA.cbClsExtra = wndClass->cbClsExtra;
wndClassA.cbWndExtra = wndClass->cbWndExtra;
wndClassA.hInstance = wndClass->hInstance;
wndClassA.hIcon = wndClass->hIcon;
wndClassA.hCursor = wndClass->hCursor;
wndClassA.hbrBackground = wndClass->hbrBackground;
AString menuName;
AString className;
if (IS_INTRESOURCE(wndClass->lpszMenuName))
wndClassA.lpszMenuName = (LPCSTR)wndClass->lpszMenuName;
else
{
menuName = GetSystemString(wndClass->lpszMenuName);
wndClassA.lpszMenuName = menuName;
}
if (IS_INTRESOURCE(wndClass->lpszClassName))
wndClassA.lpszClassName = (LPCSTR)wndClass->lpszClassName;
else
{
className = GetSystemString(wndClass->lpszClassName);
wndClassA.lpszClassName = className;
}
return RegisterClassA(&wndClassA);
}
static HWND winraw_create_window(WNDPROC wnd_proc)
{
HWND wnd;
WNDCLASSA wc = {0};
wc.hInstance = GetModuleHandleA(NULL);
if (!wc.hInstance)
{
RARCH_ERR("[WINRAW]: GetModuleHandleA failed with error %lu.\n", GetLastError());
return NULL;
}
wc.lpfnWndProc = wnd_proc;
wc.lpszClassName = "winraw-input";
if (!RegisterClassA(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
{
RARCH_ERR("[WINRAW]: RegisterClassA failed with error %lu.\n", GetLastError());
return NULL;
}
wnd = CreateWindowExA(0, wc.lpszClassName, NULL, 0, 0, 0, 0, 0,
HWND_MESSAGE, NULL, NULL, NULL);
if (!wnd)
{
RARCH_ERR("[WINRAW]: CreateWindowExA failed with error %lu.\n", GetLastError());
goto error;
}
return wnd;
error:
UnregisterClassA(wc.lpszClassName, NULL);
return NULL;
}
int main(int argc, char **argv)
{
WNDCLASSA Class = {0};
CREATESTRUCTA Cs = {0};
FARPROC MenuWindowProcA;
HMODULE hModule;
HWND hWindow;
Class.lpfnWndProc = DefWindowProc;
Class.lpszClassName = "Class";
Class.cbWndExtra = sizeof(PVOID);
RegisterClassA(&Class);
hModule = LoadLibraryA("USER32.DLL");
MenuWindowProcA = GetProcAddress(hModule,"MenuWindowProcA");
hWindow = CreateWindowA("Class","Window",0,0,0,32,32,NULL,NULL,NULL,NULL);
// set the pointer value of the (soon to be) popup menu structure
SetWindowLongPtr(hWindow,0,(LONG_PTR)0x80808080);
// set WND->fnid = FNID_MENU
MenuWindowProcA(hWindow,0,WM_NCCREATE,(WPARAM)0,(LPARAM)&Cs);
// trigger -> ExPoolFree(0x80808080)
DestroyWindow(hWindow);
return 0;
}
HWND
CreateTestWindow()
{
WNDCLASSA wc;
wc.style = 0;
wc.lpfnWndProc = DefWindowProcA;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_hInstance;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = "testclass";
RegisterClassA(&wc);
return CreateWindowA("testclass",
"testwnd",
WS_VISIBLE,
0,
0,
50,
30,
NULL,
NULL,
g_hInstance,
0);
}
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);
}
ATOM WINAPI HookRegisterClassA(
WNDCLASSA *lpWndClass // address of structure with class data
)
{
OldWndProc = lpWndClass->lpfnWndProc;
lpWndClass->lpfnWndProc = HookWndProc;
return RegisterClassA(lpWndClass);
}
void CButtonBar::Create(HWND hParent, const RECT &rect)
{
WNDCLASSA wndclass;
if (FALSE == GetClassInfoA(genDll.m_hInstance, CLASSNAME, &wndclass))
{
memset(&wndclass, 0, sizeof(wndclass));
wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndclass.hInstance = genDll.m_hInstance;
wndclass.lpfnWndProc = WindowProc;
wndclass.lpszClassName = CLASSNAME;
wndclass.lpszMenuName = 0;
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
if (false == RegisterClassA(&wndclass))
{
DWORD dwError = GetLastError();
char str[30];
sprintf_s(str, 30, "Error 0x%x", dwError);
MessageBoxA(hParent, str, "Fatal Error!", MB_ICONERROR);
#ifdef _DEBUG
DebugBreak();
#endif
PostQuitMessage(-1);
}
}
m_hWnd = CreateWindowA(CLASSNAME, "", WS_CHILD | WS_VISIBLE, rect.left, rect.top,
rect.right - rect.left + 1, rect.bottom - rect.top + 1, hParent, 0, genDll.m_hInstance, 0);
if (m_hWnd == 0)
{
DWORD dwError = GetLastError();
char str[30];
sprintf_s(str, 30, "Error 0x%x", dwError);
MessageBoxA(hParent, str, "Fatal Error!", MB_ICONERROR);
#ifdef _DEBUG
DebugBreak();
#endif
PostQuitMessage(-1);
}
GetClientRect(m_hWnd, &m_rClient);
m_hbFBack = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_FBACK));
m_hbFFar = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_FFAR));
m_hbPlay = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_PLAY));
m_hbPause = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_PAUSE));
m_hbStop = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_STOP));
m_hbFBack2 = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_FBACK2));
m_hbFFar2 = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_FFAR2));
m_hbPlay2 = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_PLAY2));
m_hbPause2 = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_PAUSE2));
m_hbStop2 = LoadBitmap(genDll.m_hInstance, MAKEINTRESOURCE(IDB_STOP2));
SetWindowLongPtrA(m_hWnd, GWL_USERDATA, (LONG_PTR)this);
}
void CListSide::Create(HWND hParent, RECT rect, HFONT hFont, int nVBarPos, int nLineHeight, bool bEnableLineSel, bool bIsLyrics)
{
m_bIsLyrics = bIsLyrics;
m_bEnableLineSel = bEnableLineSel;
rect.bottom--;
rect.right--;
WNDCLASSA wndclass;
if (FALSE == GetClassInfoA(genDll.m_hInstance, TABLECLASS, &wndclass))
{
ZeroMemory(&wndclass, sizeof(WNDCLASS));
wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hInstance = genDll.m_hInstance;
wndclass.lpfnWndProc = WindowProc;
wndclass.lpszClassName = TABLECLASS;
wndclass.style = CS_VREDRAW | CS_HREDRAW | CS_CLASSDC;
if (FALSE == RegisterClassA(&wndclass))
{
DWORD dwError = GetLastError();
char str[20];
sprintf(str, "Error 0x%x", dwError);
MessageBoxA(genDll.m_hWinamp, str, "Fatal Error!", MB_ICONERROR);
#ifdef _DEBUG
DebugBreak();
#endif
PostQuitMessage(-1);
}
}
m_hWnd = CreateWindowA(TABLECLASS, 0, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_VSCROLL, rect.left, rect.top,
rect.right - rect.left + 1, rect.bottom - rect.top + 1, hParent, NULL, genDll.m_hInstance, NULL);
if (m_hWnd == 0)
{
DWORD dwError = GetLastError();
char str[20];
sprintf(str, "Error 0x%x", dwError);
MessageBoxA(genDll.m_hWinamp, str, "Fatal Error!", MB_ICONERROR);
#ifdef _DEBUG
DebugBreak();
#endif
PostQuitMessage(-1);
}
GetClientRect(m_hWnd, &m_rClient);
m_nVBarPos = nVBarPos;
SetWindowLongPtrW(m_hWnd, GWL_USERDATA, (LONG_PTR)this);
EnableScrollBar(m_hWnd, SB_VERT, ESB_DISABLE_BOTH);
m_hFont = hFont;
m_nLineHeight = nLineHeight;
AddLine();
}
boolean Window::init( int width, int height, const char* title, boolean fullscreen )
{
HINSTANCE instance = GetModuleHandle( 0 );
WNDCLASSA wc;
wc.style = 0;
wc.lpfnWndProc = (WNDPROC)wndproc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = instance;
wc.hIcon = LoadIcon( 0, IDI_APPLICATION );
wc.hCursor = LoadCursor( 0, IDC_ARROW );
wc.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
wc.lpszMenuName = 0;
wc.lpszClassName = title;
RegisterClassA( &wc );
DWORD style = fullscreen ? WS_POPUP : WS_OVERLAPPEDWINDOW;
//style &= WS_MAXIMIZEBOX;
RECT rct;
rct.left = 0;
rct.right = width;
rct.top = 0;
rct.bottom = height;
AdjustWindowRect( &rct, style, FALSE );
HWND hwnd = CreateWindowA( title, title, style, 0, 0, rct.right - rct.left, rct.bottom - rct.top, 0, 0, instance, 0 );
if( hwnd )
{
this->hInstance = instance;
this->hWnd = hwnd;
this->title = title;
GetClientRect( hwnd, &rct );
this->width = rct.right - rct.left;
this->height = rct.bottom - rct.top;
this->hInstance = instance;
this->fullscreen = fullscreen;
this->done = false;
this->updateFlag = true;
SetWindowLongPtrA( hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>( this ) );
UpdateWindow( hwnd );
ShowWindow( hwnd, SW_SHOW );
return true;
}
UnregisterClassA( title, instance );
return false;
}
static BOOL register_window_class(void)
{
WNDCLASSA cls;
memset(&cls, 0, sizeof(cls));
cls.lpfnWndProc = test_window_proc;
cls.lpszClassName = "oleacc_test";
cls.hInstance = GetModuleHandleA(NULL);
return RegisterClassA(&cls);
}
s32 CALLBACK
WinMain(HINSTANCE instance,
HINSTANCE, LPSTR, s32)
{
WNDCLASS WindowClass = {};
WindowClass.style = CS_HREDRAW|CS_VREDRAW;
WindowClass.lpfnWndProc = MainWindowCallback;
WindowClass.hInstance = instance;
WindowClass.lpszClassName = "Win32WindowClass";
WindowClass.hCursor = LoadCursor(0, IDC_ARROW);
WindowClass.hIcon = LoadIcon(0, IDI_APPLICATION);
if(RegisterClassA(&WindowClass))
{
HWND Window =
CreateWindowExA(
0,
WindowClass.lpszClassName,
"Steven's Awesome App",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
0,0,instance,0);
if(Window)
{
HDC DeviceContext = GetDC(Window);
HGLRC GLRenderContext = InitializeOpenGL(Window, DeviceContext);
GlobalRunning = true;
LoadGLFunctions();
SetupTriangle();
glClearColor(0.0f,1.0f,0.0f,1.0f);
while(GlobalRunning)
{
ProcessPendingMessages();
Render(GLRenderContext);
SwapBuffers(DeviceContext);
}
wglMakeCurrent(DeviceContext, 0);
wglDeleteContext(GLRenderContext);
ReleaseDC(Window, DeviceContext);
}
}
return 0;
}
// 初始化窗口并设置标题
int screen_init(int w, int h, const char *title) {
WNDCLASSA wc = { CS_BYTEALIGNCLIENT, (WNDPROC)screen_events, 0, 0, 0,
NULL, NULL, NULL, NULL, "SCREEN3.1415926" };
BITMAPINFO bi = { { sizeof(BITMAPINFOHEADER), w, -h, 1, 32, BI_RGB,
w * h * 4, 0, 0, 0, 0 } };
RECT rect = { 0, 0, w, h };
int wx, wy, sx, sy;
LPVOID ptr;
HDC hDC;
screen_close();
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.hInstance = GetModuleHandle(NULL);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
if (!RegisterClassA(&wc)) return -1;
screen_handle = CreateWindowA("SCREEN3.1415926", title,
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
0, 0, 0, 0, NULL, NULL, wc.hInstance, NULL);
if (screen_handle == NULL) return -2;
screen_exit = 0;
hDC = GetDC(screen_handle);
screen_dc = CreateCompatibleDC(hDC);
ReleaseDC(screen_handle, hDC);
screen_hb = CreateDIBSection(screen_dc, &bi, DIB_RGB_COLORS, &ptr, 0, 0);
if (screen_hb == NULL) return -3;
screen_ob = (HBITMAP)SelectObject(screen_dc, screen_hb);
screen_fb = (unsigned char*)ptr;
screen_w = w;
screen_h = h;
screen_pitch = w * 4;
AdjustWindowRect(&rect, GetWindowLong(screen_handle, GWL_STYLE), 0);
wx = rect.right - rect.left;
wy = rect.bottom - rect.top;
sx = (GetSystemMetrics(SM_CXSCREEN) - wx) / 2;
sy = (GetSystemMetrics(SM_CYSCREEN) - wy) / 2;
if (sy < 0) sy = 0;
SetWindowPos(screen_handle, NULL, sx, sy, wx, wy, (SWP_NOCOPYBITS | SWP_NOZORDER | SWP_SHOWWINDOW));
SetForegroundWindow(screen_handle);
ShowWindow(screen_handle, SW_NORMAL);
screen_dispatch();
memset(screen_keys, 0, sizeof(int) * 512);
memset(screen_fb, 0, w * h * 4);
return 0;
}
void socketmanager::InitMultiIOHandler() {
if (MultiIOHandlerInited) return;
InitMultiIOHandlerCommon();
WNDCLASSA wc = {
0, &wndproc, 0, 0,
(HINSTANCE) GetModuleHandle(0),
0, 0, 0, 0,
tclassname
};
RegisterClassA(&wc);
wind = CreateWindowA(tclassname, tclassname, 0, 0, 0, 0, 0, 0, 0, (HINSTANCE) GetModuleHandle(0), 0);
MultiIOHandlerInited = true;
}
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);
}
void GraphicsWindow::Initialize( bool bD3D )
{
// A few things need to be handled differently for D3D.
g_bD3D = bD3D;
AppInstance inst;
do
{
const wstring wsClassName = RStringToWstring( g_sClassName );
WNDCLASSW WindowClassW =
{
CS_OWNDC | CS_BYTEALIGNCLIENT,
GraphicsWindow_WndProc,
0, /* cbClsExtra */
0, /* cbWndExtra */
inst, /* hInstance */
NULL, /* set icon later */
LoadCursor( NULL, IDC_ARROW ), /* default cursor */
NULL, /* hbrBackground */
NULL, /* lpszMenuName */
wsClassName.c_str() /* lpszClassName */
};
m_bWideWindowClass = true;
if( RegisterClassW( &WindowClassW ) )
break;
WNDCLASS WindowClassA =
{
CS_OWNDC | CS_BYTEALIGNCLIENT,
GraphicsWindow_WndProc,
0, /* cbClsExtra */
0, /* cbWndExtra */
inst, /* hInstance */
NULL, /* set icon later */
LoadCursor( NULL, IDC_ARROW ), /* default cursor */
NULL, /* hbrBackground */
NULL, /* lpszMenuName */
g_sClassName /* lpszClassName */
};
m_bWideWindowClass = false;
if( !RegisterClassA( &WindowClassA ) )
RageException::Throw( "%s", werr_ssprintf( GetLastError(), "RegisterClass" ).c_str() );
} while(0);
g_iQueryCancelAutoPlayMessage = RegisterWindowMessage( "QueryCancelAutoPlay" );
}
void WIN32Window::internalCreateWindow()
{
m_defaultCursor = LoadCursor(NULL, IDC_ARROW);
WNDCLASSA wc;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)WindowProcProxy::call;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_instance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = m_defaultCursor;
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = g_app.getCompactName().c_str();
if(!RegisterClassA(&wc))
g_logger.fatal("Failed to register the window class.");
DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
DWORD dwStyle = WS_OVERLAPPEDWINDOW;
// initialize in the center of the screen
m_position = ((getDisplaySize() - m_size) / 2).toPoint();
Rect screenRect = adjustWindowRect(Rect(m_position, m_size));
updateUnmaximizedCoords();
m_window = CreateWindowExA(dwExStyle,
g_app.getCompactName().c_str(),
NULL,
dwStyle,
screenRect.left(),
screenRect.top(),
screenRect.width(),
screenRect.height(),
NULL,
NULL,
m_instance,
NULL);
if(!m_window)
g_logger.fatal("Unable to create window");
ShowWindow(m_window, SW_HIDE);
m_deviceContext = GetDC(m_window);
if(!m_deviceContext)
g_logger.fatal("GetDC failed");
}
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);
}
// для GCC - другая
int main()
#endif
{
MSG msg;
WNDCLASSA wcl;
// 0. Регистрируем оконный класс
wcl.hInstance = NULL;
wcl.lpszClassName = szWinName;
wcl.lpfnWndProc = MyFunc;
wcl.style = 0;
wcl.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcl.hCursor = LoadCursor(NULL, IDC_ARROW);
wcl.lpszMenuName = NULL;
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
wcl.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
if(!RegisterClassA(&wcl)) return 0;
// 1. Создаём окно
hWnd = CreateWindowA(szWinName, "Video",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 1024, 700, HWND_DESKTOP, NULL,
NULL, NULL);
// 2. Отображаем окно на экран
ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);
// 3. Запускаем таймер (20 мсек, 50 кадров в секунду)
SetTimer(hWnd, 1, 20, NULL);
// 4. стартуем получение кадров с камеры
InitVideo();
// 5. Стандартный цикл обработки событий
while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
static DWORD WINAPI drop_window_therad(void *arg)
{
struct DragParam *param = arg;
WNDCLASSA cls;
WINDOWINFO info;
BOOL r;
MSG msg;
memset(&cls, 0, sizeof(cls));
cls.lpfnWndProc = drop_window_proc;
cls.hInstance = GetModuleHandleA(NULL);
cls.lpszClassName = "drop test";
RegisterClassA(&cls);
param->hwnd = CreateWindowA("drop test", NULL, 0, 0, 0, 0, 0,
NULL, 0, NULL, 0);
ok(param->hwnd != NULL, "CreateWindow failed: %d\n", GetLastError());
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
r = GetWindowInfo(param->hwnd, &info);
ok(r, "got %d\n", r);
ok(!(info.dwExStyle & WS_EX_ACCEPTFILES), "got %08x\n", info.dwExStyle);
DragAcceptFiles(param->hwnd, TRUE);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
r = GetWindowInfo(param->hwnd, &info);
ok(r, "got %d\n", r);
ok((info.dwExStyle & WS_EX_ACCEPTFILES), "got %08x\n", info.dwExStyle);
SetEvent(param->ready);
while ((r = GetMessageA(&msg, NULL, 0, 0)) != 0) {
if (r == (BOOL)-1) {
ok(0, "unexpected return value, got %d\n", r);
break;
}
DispatchMessageA(&msg);
}
DestroyWindow(param->hwnd);
UnregisterClassA("drop test", GetModuleHandleA(NULL));
return 0;
}
