BOOL RegisterLimitEdit() { WNDCLASSEX LimitEditEx; ZeroMemory(&LimitEditEx, sizeof(LimitEditEx)); LimitEditEx.cbSize = sizeof(WNDCLASSEX); GetClassInfoEx(0, TEXT("EDIT"), &LimitEditEx); OldEditWndProc = LimitEditEx.lpfnWndProc; LimitEditEx.lpfnWndProc = LimitEditProc; //PreEditEx.lpszMenuName= LimitEditEx.lpszClassName = TEXT("LimitEdit"); RegisterClassEx(&LimitEditEx); return TRUE; }
BOOL RegisterTimeBoxEdit() { WNDCLASSEX TimeBoxEdit; ZeroMemory(&TimeBoxEdit, sizeof(TimeBoxEdit)); TimeBoxEdit.cbSize = sizeof(WNDCLASSEX); GetClassInfoEx(0, TEXT("EDIT"), &TimeBoxEdit); OldEditWndProc2 = TimeBoxEdit.lpfnWndProc; TimeBoxEdit.lpfnWndProc = TimeBoxProc; //PreEditEx.lpszMenuName= TimeBoxEdit.lpszClassName = TEXT("TimeBoxEdit"); RegisterClassEx(&TimeBoxEdit); return TRUE; }
void InitURLControl() { WNDCLASSEX wce; ZeroMemory(&wce, sizeof(wce)); wce.cbSize = sizeof(WNDCLASSEX); if (GetClassInfoEx(hInst, "Static", &wce)==0) { PrintLastError("GetClassInfoEx()"); return; } wce.hCursor = LoadCursor(NULL, IDC_HAND); wce.hInstance = hInst; wce.lpszClassName = "URLLink"; if (RegisterClassEx(&wce) == 0) { PrintLastError("RegisterClassEx()"); } }
BOOL FadeCtrl_RegisterControl(HMODULE hModule) { WNDCLASSEX wcex; WNDCLASS wc; ZeroMemory(&wc, sizeof(WNDCLASS)); wcex.cbSize = sizeof(WNDCLASSEX); if (GetClassInfoEx(hModule, ABOUT_FADE_CLASS, &wcex) != 0) return (TRUE); wc.style = CS_SAVEBITS | CS_DBLCLKS | CS_BYTEALIGNCLIENT | CS_GLOBALCLASS; wc.lpfnWndProc = (WNDPROC)FadeCtrl_WndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hModule; wc.hIcon = NULL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); wc.lpszMenuName = NULL; wc.lpszClassName = ABOUT_FADE_CLASS; if (!RegisterClass(&wc)) return (FALSE); return (TRUE); }
bool Window::RegClass(LPCTSTR lpszClass, HINSTANCE hInstance) { WNDCLASSEX wcex; if (!GetClassInfoEx(hInstance, lpszClass, &wcex)) { wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = 0; wcex.lpfnWndProc = WindowProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = NULL; wcex.hIcon = NULL; wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wcex.lpszMenuName = NULL; wcex.lpszClassName = NULL; wcex.hIconSm = NULL; FillWndClassEx(wcex); wcex.hInstance = hInstance; wcex.lpszClassName = lpszClass; if (!RegisterClassEx(&wcex)) { return false; } } return true; }
bool CommonWnd::CreateClass() { memset(&_wc, 0, sizeof(WNDCLASSEX)); _hinstance = GetModuleHandle(nullptr); if (GetClassInfoEx(_hinstance, _szClassName.c_str(), &_wc)) { return true; } //Step 1: Registering the Window Class _wc.cbSize = sizeof(WNDCLASSEX); _wc.style = CS_HREDRAW | CS_VREDRAW; _wc.lpfnWndProc = WndProc; _wc.cbClsExtra = 0; _wc.cbWndExtra = 0; _wc.hInstance = _hinstance; _wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION); _wc.hCursor = LoadCursor(nullptr, IDC_ARROW); _wc.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1); _wc.lpszMenuName = nullptr; _wc.lpszClassName = _szClassName.c_str(); _wc.hIconSm = LoadIcon(nullptr, IDI_APPLICATION); if (!RegisterClassEx(&_wc)) { return false; } return true; }
bool basic_window::registerClass(const char *_className) { className = _className; WNDCLASSEX wc; if (!GetClassInfoEx(hInstance, _className, &wc)) { wc.cbSize = sizeof(WNDCLASSEX); wc.style = 0; // Redraw On Size, And Own DC For Window. wc.lpfnWndProc = (WNDPROC) WndProcRouter; 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 = (HBRUSH)(COLOR_WINDOW); wc.lpszMenuName = NULL; // We Don't Want A Menu wc.lpszClassName = className; // Set The Class Name wc.hIconSm = LoadIcon(NULL, IDI_WINLOGO); if (!RegisterClassEx(&wc)) // Attempt To Register The Window Class { char error[50]; sprintf(error, "Failed To Register %s Window Class.", className); MessageBox(NULL, error, "ERROR", MB_OK | MB_ICONEXCLAMATION); return false; } } return true; }
bool mdi_window::registerClass(const char *_className) { className = _className; WNDCLASSEX wc; if (!GetClassInfoEx(hInstance, _className, &wc)) { wc.cbSize = sizeof(WNDCLASSEX); wc.style = 0; wc.lpfnWndProc = (WNDPROC) WndProcRouter; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wc.lpszMenuName = NULL; //no menu for now wc.lpszClassName = className; wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION); if (!RegisterClassEx(&wc)) // Attempt To Register The Window Class { char error[50]; sprintf(error, "Failed To Register %s Window Class.", className); MessageBox(NULL, error, "ERROR", MB_OK | MB_ICONEXCLAMATION); return false; } } return true; }
VOID WepWriteClientData( __in HWND hwnd ) { WCHAR className[256]; LOGICAL isUnicode; memset(&WeServerSharedData->c, 0, sizeof(WeServerSharedData->c)); isUnicode = IsWindowUnicode(hwnd); if (isUnicode) { WeServerSharedData->c.WndProc = GetWindowLongPtrW(hwnd, GWLP_WNDPROC); WeServerSharedData->c.DlgProc = GetWindowLongPtrW(hwnd, DWLP_DLGPROC); } else { WeServerSharedData->c.WndProc = GetWindowLongPtrA(hwnd, GWLP_WNDPROC); WeServerSharedData->c.DlgProc = GetWindowLongPtrA(hwnd, DWLP_DLGPROC); } if (!GetClassName(hwnd, className, sizeof(className) / sizeof(WCHAR))) className[0] = 0; WeServerSharedData->c.ClassInfo.cbSize = sizeof(WNDCLASSEX); GetClassInfoEx(NULL, className, &WeServerSharedData->c.ClassInfo); if (isUnicode) WeServerSharedData->c.ClassInfo.lpfnWndProc = (PVOID)GetClassLongPtrW(hwnd, GCLP_WNDPROC); else WeServerSharedData->c.ClassInfo.lpfnWndProc = (PVOID)GetClassLongPtrA(hwnd, GCLP_WNDPROC); }
//*************************************************************** bool CDummyWindow::init(HINSTANCE hInstance, WNDPROC winProc) { release(); static const char *INVISIBLE_WINDOW_CLASS = "nl_invisible_wnd_class"; WNDCLASSEX wc; wc.cbSize = sizeof(WNDCLASSEX); if (!GetClassInfoEx(hInstance, INVISIBLE_WINDOW_CLASS, &wc)) { wc.cbSize = sizeof(WNDCLASSEX); wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS; wc.lpfnWndProc = nlDefaultWinProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstance; wc.hIcon = 0; wc.hCursor = 0; wc.hbrBackground = 0; wc.lpszMenuName = 0; wc.lpszClassName = INVISIBLE_WINDOW_CLASS; wc.hIconSm = 0; RegisterClassEx(&wc); } _HWnd = CreateWindow(INVISIBLE_WINDOW_CLASS, "", WS_POPUP, CW_USEDEFAULT,CW_USEDEFAULT, CW_USEDEFAULT,CW_USEDEFAULT, NULL, 0, hInstance, 0); if (_HWnd) { if (winProc) SetWindowLongPtr(_HWnd, GWLP_WNDPROC, (LONG_PTR) winProc); return true; } return false; }
int PASCAL ApplyWinMain(HINSTANCE hInstance) { INITCOMMONCONTROLSEX icc; WNDCLASSEX wcx; icc.dwSize = sizeof(icc); icc.dwICC = ICC_WIN95_CLASSES; InitCommonControlsEx(&icc); InitCheckedListBox(hInstance); if(0 == ghInstance) { ghInstance = hInstance; /* Get system dialog information */ wcx.cbSize = sizeof(wcx); if (!GetClassInfoEx(NULL, MAKEINTRESOURCE(32770), &wcx)) return 0; /* Add our own stuff */ wcx.hInstance = hInstance; // wcx.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDR_ICO_MAIN)); wcx.lpszClassName = _T("CheckedCClass"); if (!RegisterClassEx(&wcx)) return 0; } /* The user interface is a modal dialog box */ return DialogBox(hInstance, MAKEINTRESOURCE(IDD_DLGSEGMEN), NULL, (DLGPROC)Main_Apply_DlgProc); }
void Window::enableTooltips(bool enable) { if (hWnd == NULL) return; if (enable && ttData == NULL) { ttData = new TTData; WNDCLASSEX wcx; HINSTANCE hInstance = getInstance(); if (!GetClassInfoEx(hInstance, "DRTooltip", &wcx)) { memset(&wcx, 0, sizeof wcx); wcx.cbSize = sizeof wcx; wcx.lpfnWndProc = TooltipWindowProc; wcx.hInstance = hInstance; wcx.lpszClassName = "DRTooltip"; wcx.hbrBackground = CreateSolidBrush(0xE1FFFF); RegisterClassEx(&wcx); } ttData->hTip = CreateWindowEx(WS_EX_TOPMOST, "DRTooltip", NULL, WS_POPUP, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, hWnd, NULL, getInstance(), NULL); ttData->hitCode = -1; } else if (!enable && ttData != NULL) { DestroyWindow(ttData->hTip); delete ttData; ttData = NULL; } }
/************* * DESCRIPTION: Called before window is created, change window class so * that we have an own DC * INPUT: system * OUTPUT: - *************/ BOOL CCamView::PreCreateWindow(CREATESTRUCT &cs) { cs.style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN; if (CView::PreCreateWindow(cs)) { static BOOL bRegistered = FALSE; // flag for first-time init if (!bRegistered) { // This is the first time a view is being created. // Need to register the view class. // TRACE("CCamView::PreCreateWindow, MFC classname = %s\n", cs.lpszClass); WNDCLASSEX wc; wc.cbSize = sizeof(WNDCLASSEX); // Get class information for MFC default view. // The classname is in cs.lpszClass GetClassInfoEx(AfxGetInstanceHandle(), cs.lpszClass, &wc); // Modify name and style wc.lpszClassName = CAMVIEWCLASSNAME; // Here's the trick, we want to have our own DC ! // We don't want to call GetDC all the time! wc.style |= CS_OWNDC; // Register new class VERIFY(RegisterClassEx(&wc)); } cs.lpszClass = CAMVIEWCLASSNAME; return TRUE; } return FALSE; }
BOOL BaseBar_RegisterControl(HINSTANCE hInstance) { WNDCLASSEX wcex; WNDCLASS wc; ZeroMemory(&wc, sizeof(WNDCLASS)); wcex.cbSize = sizeof(WNDCLASSEX); if (GetClassInfoEx(hInstance, WC_BASEBAR, &wcex) != 0) return (TRUE); wc.style = CS_SAVEBITS; wc.lpfnWndProc = (WNDPROC) BaseBar_WindowProc; wc.hInstance = hInstance; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1); wc.lpszClassName = WC_BASEBAR; if (!RegisterClass(&wc)) return (FALSE); s_hBaseBarAtom = GlobalAddAtom(s_pszBaseBarProp); return (TRUE); }
/* Author : mah Date : 13.06.2002 Description : Constructs window class InputBox */ CInputBox::CInputBox(HWND hWndParent) { HINSTANCE hInst = GetModuleHandle(NULL); WNDCLASSEX wcex; if (!GetClassInfoEx(hInst, _T("InputBox"), &wcex)) { wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = (WNDPROC)WndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInst; wcex.hIcon = NULL;//LoadIcon(hInst, (LPCTSTR)IDI_MYINPUTBOX); wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW); wcex.lpszMenuName = NULL; wcex.lpszClassName = _T("InputBox"); wcex.hIconSm = NULL; if (RegisterClassEx(&wcex) == 0) MessageBox(NULL, _T("Can't create CInputBox!"), _T("Error"), MB_OK); } m_hWndParent = hWndParent; Text = NULL; }
/** * Function: Window::createWindow() * Description: Creates a window with the specified name, starting coordinates, height and width. */ void Window::createWindow() { std::wstring stemp = std::wstring(windowName.begin(), windowName.end()); LPCWSTR windowNaamLPCWSTR = stemp.c_str(); WNDCLASSEX wc = { 0 }; wc.cbSize = sizeof wc; wc.hInstance = GetModuleHandle(NULL); wc.style = CS_CLASSDC; wc.lpfnWndProc = WindowProc; wc.lpszClassName = windowClass; if (!GetClassInfoEx(wc.hInstance, windowClass, &wc)) { if (!RegisterClassEx(&wc)) { loggerW->WriteToFile(Error, "Window Registration Failed!"); } } hwnd = CreateWindowEx(WS_EX_APPWINDOW, windowClass, windowNaamLPCWSTR, WS_OVERLAPPEDWINDOW, startingX, startingY, windowWidth, windowHeight, NULL, NULL, wc.hInstance, this ); SetWindowText(hwnd, windowNaamLPCWSTR); ShowWindow(hwnd, SW_SHOWDEFAULT); Window::updateWindow(); }
BOOL CPanel::PreCreateWindow(CREATESTRUCT& cs) { // TODO: 在此添加专用代码和/或调用基类 HINSTANCE hist = AfxGetInstanceHandle(); WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); if (GetClassInfoEx(hist,cs.lpszClass,&wcex)) { return TRUE; } wcex.cbClsExtra = 0; wcex.cbSize = sizeof(wcex); wcex.cbWndExtra = 0; wcex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); wcex.hCursor = LoadCursor(NULL,IDC_ARROW); wcex.hIcon = LoadIcon(hist,MAKEINTRESOURCE(IDR_MAINFRAME)); wcex.hIconSm = LoadIcon(hist,MAKEINTRESOURCE(IDR_MAINFRAME)); wcex.hInstance = hist; wcex.lpfnWndProc = AfxWndProc; wcex.lpszClassName = cs.lpszClass; wcex.lpszMenuName = NULL; wcex.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS; if (!RegisterClassEx(&wcex)) { return FALSE; } return TRUE; }
BOOL CImageButton::PreCreateWindow(CREATESTRUCT& cs) { // TODO: 在此添加专用代码和/或调用基类 WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); if (GetClassInfoEx(cs.hInstance, cs.lpszClass, &wcex)) // 已经注册 { return TRUE; } // 注册 wcex.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS; wcex.lpfnWndProc = AfxWndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = cs.hInstance; wcex.hIcon = wcex.hIconSm = (HICON)LoadIcon(cs.hInstance, MAKEINTRESOURCE(IDR_MAINFRAME)); wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH); wcex.lpszMenuName = NULL; wcex.lpszClassName = cs.lpszClass; return RegisterClassEx(&wcex); //return CWnd::PreCreateWindow(cs); }
bool Balloon::Initialize() { WNDCLASSEX wincl; if (!GetClassInfoEx(mainInst, balloonName, &wincl)) { ZeroMemory(&wincl, sizeof(WNDCLASSEX)); // Register the window class wincl.hInstance = mainInst; wincl.lpszClassName = balloonName; wincl.lpfnWndProc = BalloonProcedure; wincl.cbSize = sizeof (WNDCLASSEX); wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION); wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION); wincl.hCursor = LoadCursor (NULL, IDC_ARROW); if (!RegisterClassEx (&wincl)) { return false; } } balloonWnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_LAYERED, balloonName, NULL, WS_POPUP, 0, 0, 0, 0, NULL, NULL, mainInst, reinterpret_cast<LPVOID>(this)); if (!balloonWnd) { return false; } return true; }
bool HippoAbstractWindow::registerClass() { WNDCLASSEX wcex; // note that the class may be a predefined Windows control class, // and that RegisterClassEx does NOT fail if the class is already // registered HippoUStr uName(className_); if (GetClassInfoEx(instance_, className_.m_str, &wcex) != 0) { g_debug("Got existing window class %s", uName.c_str()); return true; } else if (GetClassInfoEx(NULL, className_.m_str, &wcex) != 0) { g_debug("Got existing system window class %s", uName.c_str()); return true; } else { ZeroMemory(&wcex, sizeof(WNDCLASSEX)); wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = classStyle_; wcex.lpfnWndProc = windowProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = instance_; wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wcex.lpszMenuName = NULL; wcex.lpszClassName = className_.m_str; if (ui_) { wcex.hIcon = ui_->getBigIcon(); wcex.hIconSm = ui_->getSmallIcon();; } if (RegisterClassEx(&wcex) == 0) { HippoBSTR err; hippoHresultToString(GetLastError(), err); g_warning("Failed to register window class and failed to get existing class %s: %s", uName.c_str(), HippoUStr(err).c_str()); return false; } else { g_debug("Registered new window class %s", uName.c_str()); return true; } } }
static int vboxClipboardCreateWindow(PVBOXCLIPBOARDCONTEXT pCtx) { AssertPtrReturn(pCtx, VERR_INVALID_POINTER); int rc = VINF_SUCCESS; AssertPtr(pCtx->pEnv); HINSTANCE hInstance = pCtx->pEnv->hInstance; Assert(hInstance != 0); /* Register the Window Class. */ WNDCLASSEX wc = { 0 }; wc.cbSize = sizeof(WNDCLASSEX); if (!GetClassInfoEx(hInstance, s_szClipWndClassName, &wc)) { wc.style = CS_NOCLOSE; wc.lpfnWndProc = vboxClipboardWndProc; wc.hInstance = pCtx->pEnv->hInstance; wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1); wc.lpszClassName = s_szClipWndClassName; ATOM wndClass = RegisterClassEx(&wc); if (wndClass == 0) rc = RTErrConvertFromWin32(GetLastError()); } if (RT_SUCCESS(rc)) { const PVBOXCLIPBOARDWINCTX pWinCtx = &pCtx->Win; /* Create the window. */ pWinCtx->hWnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_TOPMOST, s_szClipWndClassName, s_szClipWndClassName, WS_POPUPWINDOW, -200, -200, 100, 100, NULL, NULL, hInstance, NULL); if (pWinCtx->hWnd == NULL) { rc = VERR_NOT_SUPPORTED; } else { SetWindowPos(pWinCtx->hWnd, HWND_TOPMOST, -200, -200, 0, 0, SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE); VBoxClipboardWinAddToCBChain(pWinCtx); if (!VBoxClipboardWinIsNewAPI(&pWinCtx->newAPI)) pWinCtx->oldAPI.timerRefresh = SetTimer(pWinCtx->hWnd, 0, 10 * 1000 /* 10s */, NULL); } } LogFlowFuncLeaveRC(rc); return rc; }
void FadeCtrl_UnregisterControl(HMODULE hModule) { WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); if (GetClassInfoEx(hModule, ABOUT_FADE_CLASS, &wcex) == FALSE) return; UnregisterClass(ABOUT_FADE_CLASS, hModule); }
static void register_subclass(void) { WNDCLASSEX cls; cls.cbSize = sizeof(WNDCLASSEX); GetClassInfoEx(NULL, STATUSCLASSNAME, &cls); g_status_wndproc = cls.lpfnWndProc; cls.lpfnWndProc = create_test_wndproc; cls.lpszClassName = SUBCLASS_NAME; cls.hInstance = NULL; ok(RegisterClassEx(&cls), "RegisterClassEx failed\n"); }
BOOL BaseBar_UnregisterControl(HINSTANCE hInstance) { WNDCLASSEX wcex; if (GetClassInfoEx(hInstance, WC_BASEBAR, &wcex) == 0) return (FALSE); UnregisterClass(WC_BASEBAR, hInstance); GlobalDeleteAtom(s_hBaseBarAtom); return (TRUE); }
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) { WNDCLASSEX wcx; ghInstance = hInstance; wcx.cbSize = sizeof(wcx); if (!GetClassInfoEx(NULL, MAKEINTRESOURCE(32770), &wcx)) return 0; wcx.hInstance = hInstance; wcx.lpszClassName = _T("HLinkClass"); if (!RegisterClassEx(&wcx)) return 0; return DialogBox(hInstance, MAKEINTRESOURCE(DLG_MAIN), NULL, (DLGPROC)MainDlgProc); }
Window::Window(uint width, uint height) { hasInit = false; HINSTANCE hInstance = GetModuleHandle( NULL ); WNDCLASSEX windowClass; ZeroMemory(&windowClass, sizeof(WNDCLASSEX)); if(!GetClassInfoEx(hInstance,WINDOWCLASS,&windowClass)) { windowClass.cbSize = sizeof(WNDCLASSEX); windowClass.style = CS_HREDRAW | CS_VREDRAW; windowClass.lpfnWndProc = (WNDPROC)StaticWindowProc; windowClass.hInstance = hInstance; windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); windowClass.hbrBackground = (HBRUSH)COLOR_WINDOW; windowClass.lpszClassName = WINDOWCLASS; if(!RegisterClassEx(&windowClass)) { return; } } windowHandle = CreateWindowEx(NULL, WINDOWCLASS, // name of the window class "Software Rasteriser!", // title of the window WS_OVERLAPPEDWINDOW|WS_POPUP|WS_VISIBLE|WS_SYSMENU|WS_MAXIMIZEBOX|WS_MINIMIZEBOX, // window style (int)100, // x-position of the window (int)100, // y-position of the window (int)width, // width of the window (int)height, // height of the window NULL, // No parent window! NULL, // No Menus! hInstance, // application handle this); // deviceContext=GetDC(windowHandle); RECT rt; GetClientRect(windowHandle, &rt); screenWidth = rt.right; screenHeight = rt.bottom; BuildBitmap(); Keyboard::Initialise(windowHandle); Mouse::Initialise(windowHandle); hasInit = true; forceQuit = false; }
bool KWindow::RegisterClass(LPCTSTR lpszClass, HINSTANCE hInst) { WNDCLASSEX wc; if (!GetClassInfoEx(hInst, lpszClass, &wc)) { GetWndClassEx(wc); wc.hInstance = hInst; wc.lpszClassName = lpszClass; if (!RegisterClassEx(&wc)) return false; } return true; }
IpcListenerWnd::IpcListenerWnd(const wchar_t* pszClassName, HWND pParent, std::mutex& mutex, IpcMessageHandler& handler) : _mutex( mutex ), _pParentWnd(pParent), _handler( handler ) { // the instance of this module auto hInstance = ::GetModuleHandle( nullptr ); WNDCLASSEX wcx; if (GetClassInfoEx(hInstance, pszClassName, &wcx)) { throw "The server already exists."; } wcx.cbSize = sizeof(wcx); wcx.style = 0; wcx.lpfnWndProc = WindowProc; wcx.cbClsExtra = 0; wcx.cbWndExtra = 0; wcx.hInstance = hInstance; wcx.hIcon = LoadIcon(nullptr, IDI_APPLICATION); wcx.hCursor = LoadCursor(nullptr, IDC_ARROW); wcx.hbrBackground = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)); wcx.lpszMenuName = L"MainMenu"; wcx.lpszClassName = pszClassName; wcx.hIconSm = static_cast<HICON>(LoadImage(hInstance, MAKEINTRESOURCE(5), IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR)); if (!RegisterClassEx(&wcx)) { throw "Can't register IpcListener window class."; } // one way or another the class was created. // so we can create our listener accordingly. if (!this->CWnd::CreateEx(0, pszClassName, nullptr, 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr)) { throw "Can't create IpcListener window."; } this->CWnd::UpdateWindow(); // save this pointer SetWindowLongPtr(GetSafeHwnd(), GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this)); }
int wgWindowRegister(struct wgWindow* object, HINSTANCE hInst, LPCTSTR className) { WNDCLASSEX wc; assert(NULL != object); if (!GetClassInfoEx(hInst, className, &wc)) { object->getWindowClassEx(object, &wc); wc.hInstance = hInst; wc.lpszClassName = className; if (!RegisterClassEx(&wc)) return Result_Failed_RegisterWindowClass; } return Result_Success; }
static void EhTreeInizialize(void) { WNDCLASSEX wc; // Cambio il puntamento standarda della procedura di classe Eh CHAR NewClass[80]; sprintf(NewClass,"%sT",sys.tzWinClassBase); //win_infoarg("%s",NewClass); wc.cbSize=sizeof(wc); if (!GetClassInfoEx(sys.EhWinInstance,sys.tzWinClassBase,&wc)) ehExit("Errore 1"); if (wc.lpfnWndProc!=LIntercept) { EhOriginalProc=wc.lpfnWndProc; wc.lpfnWndProc=LIntercept; wc.lpszClassName=NewClass; if (!RegisterClassEx(&wc)) win_infoarg("error"); strcpy(sys.tzWinClassBase,NewClass); } }