BOOL InitApp (LPSTR pszCmdLineA) { BOOL fShow = FALSE; BOOL fQuiet = FALSE; BOOL fExit = FALSE; BOOL fInstall = FALSE; BOOL fUninstall = FALSE; BOOL fAutoInit = FALSE; BOOL fNetDetect = FALSE; BOOL fRenewMaps = FALSE; // Initialize our global variables and window classes // memset (&g, 0x00, sizeof(g)); g.fStartup = TRUE; // Parse the command-line // while (pszCmdLineA && *pszCmdLineA) { if ((*pszCmdLineA != '-') && (*pszCmdLineA != '/')) break; switch (*(++pszCmdLineA)) { case 'a': case 'A': fAutoInit = TRUE; break; case 'm': case 'M': fRenewMaps = TRUE; break; case 'n': case 'N': fNetDetect = TRUE; break; case 's': case 'S': fShow = TRUE; break; case 'q': case 'Q': fQuiet = TRUE; break; case 'e': case 'E': fExit = TRUE; break; case 'i': case 'I': fInstall = TRUE; break; case 'u': case 'U': fUninstall = TRUE; break; case ':': CopyAnsiToString(g.SmbName,pszCmdLineA); MapShareName(pszCmdLineA); break; case 'z': case 'Z': DoUnMapShare(TRUE); return(0); case 'x': case 'X': TestAndDoMapShare(SERVICE_START_PENDING); TestAndDoMapShare(SERVICE_RUNNING); return 0; } while (*pszCmdLineA && (*pszCmdLineA != ' ')) ++pszCmdLineA; if (*pszCmdLineA==' ') ++pszCmdLineA; } if (fInstall) Shortcut_FixStartup (cszSHORTCUT_NAME, g.fStartup = TRUE); else if (fUninstall) Shortcut_FixStartup (cszSHORTCUT_NAME, g.fStartup = FALSE); if (fInstall || fUninstall) { HKEY hk; if (RegCreateKeyEx (HKEY_CURRENT_USER, AFSREG_USER_OPENAFS_SUBKEY, 0, NULL, 0, (IsWow64()?KEY_WOW64_64KEY:0)|KEY_WRITE, NULL, &hk, NULL) == 0) { DWORD dwSize = sizeof(g.fStartup); DWORD dwType = REG_DWORD; RegSetValueEx (hk, TEXT("ShowTrayIcon"), NULL, dwType, (PBYTE)&g.fStartup, dwSize); RegCloseKey (hk); } } // Only show up if there's not another version of this app around already. // for (HWND hSearch = GetWindow (GetDesktopWindow(), GW_CHILD); hSearch && IsWindow(hSearch); hSearch = GetWindow (hSearch, GW_HWNDNEXT)) { TCHAR szClassName[ cchRESOURCE ]; if (GetClassName (hSearch, szClassName, cchRESOURCE)) { if (!lstrcmpi (szClassName, cszCLASSNAME)) { if (fShow) PostMessage (hSearch, WM_COMMAND, M_ACTIVATE, 0); else if (fExit) PostMessage (hSearch, WM_COMMAND, M_TERMINATE_NOW, 0); else if (fUninstall) PostMessage (hSearch, WM_COMMAND, M_TERMINATE_NOW, 0); return FALSE; } } } if (fExit || fUninstall || fInstall) return FALSE; HKEY hk; if (RegOpenKeyEx (HKEY_CURRENT_USER, AFSREG_USER_OPENAFS_SUBKEY, 0, (IsWow64()?KEY_WOW64_64KEY:0)|KEY_QUERY_VALUE, &hk) == 0) { DWORD dwSize = sizeof(g.fStartup); DWORD dwType = REG_DWORD; RegQueryValueEx (hk, TEXT("ShowTrayIcon"), NULL, &dwType, (PBYTE)&g.fStartup, &dwSize); RegCloseKey (hk); } else if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, AFSREG_CLT_OPENAFS_SUBKEY, 0, (IsWow64()?KEY_WOW64_64KEY:0)|KEY_QUERY_VALUE, &hk) == 0) { DWORD dwSize = sizeof(g.fStartup); DWORD dwType = REG_DWORD; RegQueryValueEx (hk, TEXT("ShowTrayIcon"), NULL, &dwType, (PBYTE)&g.fStartup, &dwSize); RegCloseKey (hk); } Shortcut_FixStartup (cszSHORTCUT_NAME, g.fStartup); // Is this Windows NT? // OSVERSIONINFO Version; memset (&Version, 0x00, sizeof(Version)); Version.dwOSVersionInfoSize = sizeof(Version); if (GetVersionEx (&Version)) g.fIsWinNT = (Version.dwPlatformId == VER_PLATFORM_WIN32_NT) ? TRUE : FALSE; if (!g.fIsWinNT) lstrcpy (g.szHelpFile, TEXT("afs-light.hlp")); else lstrcpy (g.szHelpFile, TEXT("afs-nt.hlp")); // Initialize winsock etc // WSADATA Data; WSAStartup (0x0101, &Data); InitCommonControls(); RegisterCheckListClass(); osi_Init(); lock_InitializeMutex(&g.expirationCheckLock, "expiration check lock", 0); lock_InitializeMutex(&g.credsLock, "global creds lock", 0); KFW_AFS_wait_for_service_start(); if ( IsDebuggerPresent() ) { if ( !g.fIsWinNT ) OutputDebugString("No Service Present on non-NT systems\n"); else { if ( IsServiceRunning() ) OutputDebugString("AFSD Service started\n"); else { OutputDebugString("AFSD Service stopped\n"); if ( !IsServiceConfigured() ) OutputDebugString("AFSD Service not configured\n"); else if ( fAutoInit ) OutputDebugString("AFSD Service will be started\n"); } } } // If the service isn't started yet, and autoInit start the service if ( g.fIsWinNT && !IsServiceRunning() && IsServiceConfigured() && fAutoInit ) { SC_HANDLE hManager; if ((hManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS)) != NULL ) { SC_HANDLE hService; if ((hService = OpenService( hManager, TEXT("TransarcAFSDaemon"), SERVICE_QUERY_STATUS | SERVICE_START) ) != NULL) { if (StartService(hService, 0, 0)) { if ( IsDebuggerPresent() ) OutputDebugString("AFSD Service start successful\n"); fRenewMaps = TRUE; } else if ( IsDebuggerPresent() ) OutputDebugString("AFSD Service start failed\n"); CloseServiceHandle (hService); } CloseServiceHandle (hManager); } KFW_AFS_wait_for_service_start(); } KFW_initialize(); // Create a main window. All further initialization will be done during // processing of WM_INITDIALOG. // WNDCLASS wc; if (!GetClassInfo (NULL, WC_DIALOG, &wc)) // Get dialog class info return FALSE; wc.hInstance = THIS_HINST; wc.hIcon = TaLocale_LoadIcon (IDI_MAIN); wc.lpszClassName = cszCLASSNAME; wc.style |= CS_GLOBALCLASS; RegisterClass(&wc); g.hMain = ModelessDialog (IDD_MAIN, NULL, (DLGPROC)Main_DlgProc); if (g.hMain == NULL) return FALSE; // If the service isn't started yet, show our startup wizard. // if (!IsServiceRunning() && !fQuiet) { if (!g.fIsWinNT) Message (MB_ICONHAND, IDS_UNCONFIG_TITLE_95, IDS_UNCONFIG_DESC_95); else if (IsServiceConfigured()) ShowStartupWizard(); else if (!IsServerInstalled()) Message (MB_ICONHAND, IDS_UNCONFIG_TITLE, IDS_UNCONFIG_DESC); } if (IsServiceRunning()) { if ( fRenewMaps ) { if ( IsDebuggerPresent() ) OutputDebugString("Renewing Drive Maps\n"); DoMapShareChange(FALSE); } if (fShow) { if ( IsDebuggerPresent() ) OutputDebugString("Displaying Main window\n"); Main_Show (TRUE); } // If the root cell is reachable and we have no tokens // display the Obtain Tokens dialog to the user if ( fAutoInit ) { if ( IsDebuggerPresent() ) OutputDebugString("Obtaining Tokens (if needed)\n"); ObtainTokensFromUserIfNeeded(g.hMain); } } else if ( IsDebuggerPresent() ) OutputDebugString("AFSD Service Stopped\n"); if ( fNetDetect ) { // Start IP Address Change Monitor if ( IsDebuggerPresent() ) OutputDebugString("Activating Network Change Monitor\n"); IpAddrChangeMonitorInit(g.hMain); } Main_EnableRemindTimer(TRUE); return TRUE; }
CBrowserWnd::CBrowserWnd(HINSTANCE hInst) { m_hInst = hInst; m_hWnd = NULL; m_view = new CHTMLViewWnd(hInst, &m_browser_context, this); #ifndef NO_TOOLBAR m_toolbar = new CToolbarWnd(hInst, this); #endif WNDCLASS wc; if(!GetClassInfo(m_hInst, BROWSERWND_CLASS, &wc)) { ZeroMemory(&wc, sizeof(wc)); wc.style = CS_DBLCLKS /*| CS_HREDRAW | CS_VREDRAW*/; wc.lpfnWndProc = (WNDPROC)CBrowserWnd::WndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = m_hInst; wc.hIcon = NULL; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1); wc.lpszMenuName = NULL; wc.lpszClassName = BROWSERWND_CLASS; RegisterClass(&wc); } #ifndef LITEHTML_UTF8 LPWSTR css = NULL; HRSRC hResource = ::FindResource(m_hInst, L"master.css", L"CSS"); if(hResource) { DWORD imageSize = ::SizeofResource(m_hInst, hResource); if(imageSize) { LPCSTR pResourceData = (LPCSTR) ::LockResource(::LoadResource(m_hInst, hResource)); if(pResourceData) { css = new WCHAR[imageSize * 3]; int ret = MultiByteToWideChar(CP_UTF8, 0, pResourceData, imageSize, css, imageSize * 3); css[ret] = 0; } } } #else LPSTR css = NULL; HRSRC hResource = ::FindResource(m_hInst, L"master.css", L"CSS"); if(hResource) { DWORD imageSize = ::SizeofResource(m_hInst, hResource); if(imageSize) { LPCSTR pResourceData = (LPCSTR) ::LockResource(::LoadResource(m_hInst, hResource)); if(pResourceData) { css = new CHAR[imageSize + 1]; lstrcpynA(css, pResourceData, imageSize); css[imageSize] = 0; } } } #endif if(css) { m_browser_context.load_master_stylesheet(css); delete css; } }
QString QWindowsContext::registerWindowClass(QString cname, WNDPROC proc, unsigned style, HBRUSH brush, bool icon) { // since multiple Qt versions can be used in one process // each one has to have window class names with a unique name // The first instance gets the unmodified name; if the class // has already been registered by another instance of Qt then // add an instance-specific ID, the address of the window proc. static int classExists = -1; const HINSTANCE appInstance = (HINSTANCE)GetModuleHandle(0); if (classExists == -1) { WNDCLASS wcinfo; classExists = GetClassInfo(appInstance, (wchar_t*)cname.utf16(), &wcinfo); classExists = classExists && wcinfo.lpfnWndProc != proc; } if (classExists) cname += QString::number((quintptr)proc); if (d->m_registeredWindowClassNames.contains(cname)) // already registered in our list return cname; #ifndef Q_OS_WINCE WNDCLASSEX wc; wc.cbSize = sizeof(WNDCLASSEX); #else WNDCLASS wc; #endif wc.style = style; wc.lpfnWndProc = proc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = appInstance; wc.hCursor = 0; #ifndef Q_OS_WINCE wc.hbrBackground = brush; if (icon) { wc.hIcon = (HICON)LoadImage(appInstance, L"IDI_ICON1", IMAGE_ICON, 0, 0, LR_DEFAULTSIZE); if (wc.hIcon) { int sw = GetSystemMetrics(SM_CXSMICON); int sh = GetSystemMetrics(SM_CYSMICON); wc.hIconSm = (HICON)LoadImage(appInstance, L"IDI_ICON1", IMAGE_ICON, sw, sh, 0); } else { wc.hIcon = (HICON)LoadImage(0, IDI_APPLICATION, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_SHARED); wc.hIconSm = 0; } } else { wc.hIcon = 0; wc.hIconSm = 0; } #else if (icon) { wc.hIcon = (HICON)LoadImage(appInstance, L"IDI_ICON1", IMAGE_ICON, 0, 0, LR_DEFAULTSIZE); } else { wc.hIcon = 0; } #endif wc.lpszMenuName = 0; wc.lpszClassName = (wchar_t*)cname.utf16(); #ifndef Q_OS_WINCE ATOM atom = RegisterClassEx(&wc); #else ATOM atom = RegisterClass(&wc); #endif if (!atom) qErrnoWarning("QApplication::regClass: Registering window class '%s' failed.", qPrintable(cname)); d->m_registeredWindowClassNames.insert(cname); qCDebug(lcQpaWindows).nospace() << __FUNCTION__ << ' ' << cname << " style=0x" << hex << style << dec << " brush=" << brush << " icon=" << icon << " atom=" << atom; return cname; }
//Create a Direct3D Window //まだFullscreenに対応してない bool CWindowDG::CCreateWindow(LONG x, LONG y, LONG width, LONG height, const TCHAR* szTitle, BOOL isWindow) { WNDCLASS wc; HWND hWnd; DWORD dwExStyle; DWORD dwStyle; RECT WindowRect; WindowRect.left = 0; WindowRect.right = width; WindowRect.top = 0; WindowRect.bottom= height; m_isFullscreen=!isWindow; //すでに登録されていなければ、登録する if(!GetClassInfo(GetModuleHandle(NULL), _T("CWindowDG"), &wc)) { wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = (WNDPROC) CWindowBase::BaseWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandle(NULL); wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wc.lpszMenuName = NULL; wc.lpszClassName = _T("CWindowDG"); if(!RegisterClass(&wc)) { MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION); ExitProcess(0); return FALSE; } } if(m_isFullscreen) { } if(m_isFullscreen) { dwExStyle=WS_EX_APPWINDOW; dwStyle=WS_POPUP; } else { dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; dwStyle=WS_OVERLAPPEDWINDOW; } AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); if(!(hWnd=CreateWindowEx( dwExStyle, _T("CWindowDG"), szTitle, dwStyle, x, y, !m_isFullscreen ? WindowRect.right-WindowRect.left : 0, !m_isFullscreen ? WindowRect.bottom-WindowRect.top : 0, NULL, NULL, GetModuleHandle(NULL), (void*)this))) { MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION); ExitProcess(0); return FALSE; } m_hWnd = hWnd; if(!InitD3D(m_hWnd, width, height, isWindow)) { MessageBox(NULL,"Direct3D Initialize Error.","ERROR",MB_OK|MB_ICONEXCLAMATION); ExitProcess(0); return FALSE; } ShowWindow(hWnd,SW_SHOW); SetForegroundWindow(hWnd); SetFocus(hWnd); return TRUE; }
FORCE_INLINE int NSISCALL ui_doinstall(void) { header *header = g_header; static WNDCLASS wc; // richedit subclassing and bgbg creation // detect default language // more information at: // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/intl/nls_0xrn.asp LANGID (WINAPI *GUDUIL)(); static const char guduil[] = "GetUserDefaultUILanguage"; GUDUIL = myGetProcAddress("KERNEL32.dll", (char *) guduil); if (GUDUIL) { // Windows ME/2000+ myitoa(state_language, GUDUIL()); } else { *(WORD*)state_language = CHAR2_TO_WORD('0', 'x'); { // Windows 9x static const char reg_9x_locale[] = "Control Panel\\Desktop\\ResourceLocale"; myRegGetStr(HKEY_CURRENT_USER, reg_9x_locale, NULL, state_language + 2); } if (!state_language[2]) { // Windows NT // This key exists on 9x as well, so it's only read if ResourceLocale wasn't found static const char reg_nt_locale_key[] = ".DEFAULT\\Control Panel\\International"; static const char reg_nt_locale_val[] = "Locale"; myRegGetStr(HKEY_USERS, reg_nt_locale_key, reg_nt_locale_val, state_language + 2); } } // set default language set_language(); // initialize auto close flag g_exec_flags.autoclose=g_flags&CH_FLAGS_AUTO_CLOSE; // read install directory from registry if (!is_valid_instpath(state_install_directory)) { if (header->install_reg_key_ptr) { myRegGetStr( (HKEY)header->install_reg_rootkey, GetNSISStringNP(header->install_reg_key_ptr), GetNSISStringNP(header->install_reg_value_ptr), ps_tmpbuf ); if (ps_tmpbuf[0]) { char *p=ps_tmpbuf; char *e; if (p[0]=='\"') { char *p2; p++; p2 = findchar(p, '"'); *p2 = 0; } // p is the path now, check for .exe extension e=p+mystrlen(p)-4; if (e > p) { // if filename ends in .exe, and is not a directory, remove the filename if (!lstrcmpi(e, ".exe")) // check extension { DWORD d; d=GetFileAttributes(p); if (d == INVALID_FILE_ATTRIBUTES || !(d&FILE_ATTRIBUTE_DIRECTORY)) { // if there is no back-slash, the string will become empty, but that's ok because // it would make an invalid instdir anyway trimslashtoend(p); } } } mystrcpy(state_install_directory,addtrailingslash(p)); } } } if (!is_valid_instpath(state_install_directory)) { GetNSISString(state_install_directory,header->install_directory_ptr); } #ifdef NSIS_CONFIG_LOG if (g_flags & CH_FLAGS_SILENT_LOG && !g_is_uninstaller) { #ifndef NSIS_CONFIG_LOG_ODS build_g_logfile(); #endif log_dolog=1; } #endif #ifdef NSIS_CONFIG_VISIBLE_SUPPORT g_hIcon=LoadImage(g_hInstance,MAKEINTRESOURCE(IDI_ICON2),IMAGE_ICON,0,0,LR_DEFAULTSIZE|LR_SHARED); #ifdef NSIS_SUPPORT_BGBG if (header->bg_color1 != -1) { DWORD cn = CHAR4_TO_DWORD('_', 'N', 'b', 0); RECT vp; extern LRESULT CALLBACK BG_WndProc(HWND, UINT, WPARAM, LPARAM); wc.lpfnWndProc = BG_WndProc; wc.hInstance = g_hInstance; wc.hIcon = g_hIcon; //wc.hCursor = LoadCursor(NULL,IDC_ARROW); wc.lpszClassName = (LPCSTR)&cn; if (!RegisterClass(&wc)) return 0; SystemParametersInfo(SPI_GETWORKAREA, 0, &vp, 0); m_bgwnd = CreateWindowEx(WS_EX_TOOLWINDOW,(LPCSTR)&cn,0,WS_POPUP, vp.left,vp.top,vp.right-vp.left,vp.bottom-vp.top,0,NULL,g_hInstance,NULL); } #endif//NSIS_SUPPORT_BGBG #endif//NSIS_CONFIG_VISIBLE_SUPPORT #ifdef NSIS_SUPPORT_CODECALLBACKS // Select language if (ExecuteCallbackFunction(CB_ONINIT)) return 2; set_language(); #endif #ifdef NSIS_CONFIG_VISIBLE_SUPPORT #ifdef NSIS_CONFIG_SILENT_SUPPORT if (!g_exec_flags.silent) #endif//NSIS_CONFIG_SILENT_SUPPORT { #ifdef NSIS_SUPPORT_BGBG ShowWindow(m_bgwnd, SW_SHOW); #endif//NSIS_SUPPORT_BGBG #ifdef NSIS_CONFIG_LICENSEPAGE { // load richedit DLL static char str1[]="RichEd20.dll"; static char str2[]="RichEdit20A"; if (!LoadLibrary(str1)) { *(WORD*)(str1+6) = CHAR2_TO_WORD('3','2'); LoadLibrary(str1); } // make richedit20a point to RICHEDIT if (!GetClassInfo(NULL,str2,&wc)) { str2[8]=0; GetClassInfo(NULL,str2,&wc); wc.lpszClassName = str2; str2[8]='2'; RegisterClass(&wc); } } #endif { int ret=DialogBox(g_hInstance,MAKEINTRESOURCE(IDD_INST+dlg_offset),0,DialogProc); #if defined(NSIS_SUPPORT_CODECALLBACKS) && defined(NSIS_CONFIG_ENHANCEDUI_SUPPORT) ExecuteCallbackFunction(CB_ONGUIEND); #endif return ret; } } #endif//NSIS_CONFIG_VISIBLE_SUPPORT #ifdef NSIS_CONFIG_SILENT_SUPPORT #ifdef NSIS_CONFIG_VISIBLE_SUPPORT else #endif//NSIS_CONFIG_VISIBLE_SUPPORT { if (install_thread(NULL)) { #ifdef NSIS_SUPPORT_CODECALLBACKS if (!g_quit_flag) ExecuteCallbackFunction(CB_ONINSTFAILED); #endif//NSIS_SUPPORT_CODECALLBACKS return 2; } #ifdef NSIS_SUPPORT_CODECALLBACKS ExecuteCallbackFunction(CB_ONINSTSUCCESS); #endif//NSIS_SUPPORT_CODECALLBACKS return 0; } #endif//NSIS_CONFIG_SILENT_SUPPORT }
int GLUTAPIENTRY glutEnterGameMode(void) { GLUTwindow *window; int width, height; Window win; /* Initialize GLUT since glutInit may not have been called. */ #if defined(_WIN32) WNDCLASS wc; if (!GetClassInfo(GetModuleHandle(NULL), "GLUT", &wc)) { __glutOpenWin32Connection(NULL); } #else if (!__glutDisplay) { __glutOpenXConnection(NULL); } #endif if (__glutMappedMenu) { __glutFatalUsage("entering game mode not allowed while menus in use"); } if (__glutGameModeWindow) { /* Already in game mode, so blow away game mode window so apps can change resolutions. */ window = __glutGameModeWindow; /* Setting the game mode window to NULL tricks the window destroy code into not undoing the screen display change since we plan on immediately doing another mode change. */ __glutGameModeWindow = NULL; __glutDestroyWindow(window, window); } /* Assume default screen size until we find out if we can actually change the display settings. */ width = __glutScreenWidth; height = __glutScreenHeight; if (currentDm) { #ifdef _WIN32 LONG status; static int registered = 0; /* The Cygnus B20.1 tools do not have this defined. */ #ifndef CDS_FULLSCREEN #define CDS_FULLSCREEN 0x00000004 #endif status = ChangeDisplaySettings(¤tDm->devmode, CDS_FULLSCREEN); if (status == DISP_CHANGE_SUCCESSFUL) { __glutDisplaySettingsChanged = 1; width = currentDm->cap[DM_WIDTH]; height = currentDm->cap[DM_HEIGHT]; if (!registered) { atexit(__glutCloseDownGameMode); registered = 1; } } else { /* Switch back to default resolution. */ ChangeDisplaySettings(NULL, 0); } #endif } window = __glutCreateWindow(NULL, 0, 0, width, height, /* game mode */ 1); win = window->win; #if !defined(_WIN32) __glutMakeFullScreenAtoms(); /* Game mode window is a toplevel window. */ XSetWMProtocols(__glutDisplay, win, &__glutWMDeleteWindow, 1); #endif /* Schedule the fullscreen property to be added and to make sure the window is configured right. Win32 doesn't need this. */ window->desiredX = 0; window->desiredY = 0; window->desiredWidth = width; window->desiredHeight = height; window->desiredConfMask |= CWX | CWY | CWWidth | CWHeight; #ifdef _WIN32 /* Win32 does not want to use GLUT_FULL_SCREEN_WORK for game mode because we need to be maximizing the window in game mode, not just sizing it to take up the full screen. The Win32-ness of game mode happens when you pass 1 in the gameMode parameter to __glutCreateWindow above. A gameMode of creates a WS_POPUP window, not a standard WS_OVERLAPPEDWINDOW window. WS_POPUP ensures the taskbar is hidden. */ __glutPutOnWorkList(window, GLUT_CONFIGURE_WORK); #else __glutPutOnWorkList(window, GLUT_CONFIGURE_WORK | GLUT_FULL_SCREEN_WORK); #endif __glutGameModeWindow = window; return window->num + 1; }
void kgmUnregisterWindowClass(){ WNDCLASS wcl; if(GetClassInfo(0, cWndClass, &wcl)) UnregisterClass(cWndClass, 0); }
// COpenHoldemApp initialization BOOL COpenHoldemApp::InitInstance() { Scintilla_RegisterClasses(AfxGetInstanceHandle()); // Initialize richedit2 library AfxInitRichEdit2(); // Change class name of Dialog WNDCLASS wc; GetClassInfo(AfxGetInstanceHandle(), "#32770", &wc); wc.lpszClassName = "OpenHoldemFormula"; wc.hIcon = AfxGetApp()->LoadIcon(IDI_ICON1); RegisterClass(&wc); // InitCommonControlsEx() is required on Windows XP if an application // manifest specifies use of ComCtl32.dll version 6 or later to enable // visual styles. Otherwise, any window creation will fail. INITCOMMONCONTROLSEX InitCtrls; InitCtrls.dwSize = sizeof(InitCtrls); // Set this to include all the common control classes you want to use // in your application. InitCtrls.dwICC = ICC_WIN95_CLASSES; InitCommonControlsEx(&InitCtrls); CWinApp::InitInstance(); // Since OH 4.0.0 we always use an ini-file, // the one and only in our OH-directory, // no matter how it is named. // For the technical details please see: // http://msdn.microsoft.com/de-de/library/xykfyy20(v=vs.80).aspx InstantiateSomeSingletonsForVeryEarlyUseInInitInstance(); free((void*)m_pszProfileName); m_pszProfileName = _strdup(p_filenames->IniFilePath().GetString()); prefs.LoadPreferences(); // Classes if (!p_sessioncounter) p_sessioncounter = new CSessionCounter; // Start logging immediatelly after the loading the preferences // and initializing the sessioncounter. start_log(); InstantiateAllSingletons(); // mouse.dll - failure in load is fatal _mouse_dll = LoadLibrary("mouse.dll"); if (_mouse_dll==NULL) { CString t = ""; t.Format("Unable to load mouse.dll, error: %d\n\nExiting.", GetLastError()); OH_MessageBox_Error_Warning(t, "OpenHoldem mouse.dll ERROR"); return false; } else { _dll_mouse_process_message = (mouse_process_message_t) GetProcAddress(_mouse_dll, "ProcessMessage"); _dll_mouse_click = (mouse_click_t) GetProcAddress(_mouse_dll, "MouseClick"); _dll_mouse_click_drag = (mouse_clickdrag_t) GetProcAddress(_mouse_dll, "MouseClickDrag"); if (_dll_mouse_process_message==NULL || _dll_mouse_click==NULL || _dll_mouse_click_drag==NULL) { CString t = ""; t.Format("Unable to find all symbols in mouse.dll"); OH_MessageBox_Error_Warning(t, "OpenHoldem mouse.dll ERROR"); FreeLibrary(_mouse_dll); _mouse_dll = NULL; return false; } } // keyboard.dll - failure in load is fatal _keyboard_dll = LoadLibrary("keyboard.dll"); if (_keyboard_dll==NULL) { CString t = ""; t.Format("Unable to load keyboard.dll, error: %d\n\nExiting.", GetLastError()); OH_MessageBox_Error_Warning(t, "OpenHoldem keyboard.dll ERROR"); return false; } else { _dll_keyboard_process_message = (keyboard_process_message_t) GetProcAddress(_keyboard_dll, "ProcessMessage"); _dll_keyboard_sendstring = (keyboard_sendstring_t) GetProcAddress(_keyboard_dll, "SendString"); _dll_keyboard_sendkey = (keyboard_sendkey_t) GetProcAddress(_keyboard_dll, "SendKey"); if (_dll_keyboard_process_message==NULL || _dll_keyboard_sendstring==NULL || _dll_keyboard_sendkey==NULL) { CString t = ""; t.Format("Unable to find all symbols in keyboard.dll"); OH_MessageBox_Error_Warning(t, "OpenHoldem keyboard.dll ERROR"); FreeLibrary(_keyboard_dll); _keyboard_dll = NULL; return false; } } MyLoadStdProfileSettings(k_number_of_last_recently_used_files_in_file_menu); // Register the application's document templates. Document templates // serve as the connection between documents, frame windows and views CSingleDocTemplate* pDocTemplate; pDocTemplate = new CSingleDocTemplate( IDR_MAINFRAME, RUNTIME_CLASS(COpenHoldemDoc), RUNTIME_CLASS(CMainFrame), // main SDI frame window RUNTIME_CLASS(COpenHoldemView)); if (!pDocTemplate) return FALSE; AddDocTemplate(pDocTemplate); EnableShellOpen(); RegisterShellFileTypes(false); // Parse command line for standard shell commands, DDE, file open CCommandLineInfo cmdInfo; ParseCommandLine(cmdInfo); // Open the most recently saved file. (First on the MRU list.) Get the last // file from the registry. We need not account for cmdInfo.m_bRunAutomated and // cmdInfo.m_bRunEmbedded as they are processed before we get here. if (cmdInfo.m_nShellCommand == CCommandLineInfo::FileNew) { CString sLastPath(GetProfileString(_afxFileSection, "File1")); if (! sLastPath.IsEmpty()) { CFile f; // If file is there, set to open! if (f.Open(sLastPath, CFile::modeRead | CFile::shareDenyWrite)) { cmdInfo.m_nShellCommand = CCommandLineInfo::FileOpen; cmdInfo.m_strFileName = sLastPath; f.Close(); } } } // Dispatch commands specified on the command line. Will return FALSE if // app was launched with /RegServer, /Register, /Unregserver or /Unregister. if (!ProcessShellCommand(cmdInfo)) return FALSE; if (prefs.simple_window_title()) m_pMainWnd->PostMessage(WMA_SETWINDOWTEXT, 0, (LPARAM)NULL); // The one and only window has been initialized, so show and update it if (prefs.gui_start_minimized()) { m_pMainWnd->ShowWindow(SW_MINIMIZE); } else { m_pMainWnd->ShowWindow(SW_SHOW); } m_pMainWnd->UpdateWindow(); // call DragAcceptFiles only if there's a suffix // In an SDI app, this should occur after ProcessShellCommand // Enable drag/drop open m_pMainWnd->DragAcceptFiles(); // Bring main window to front m_pMainWnd->SetWindowPos(&CWnd::wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); m_pMainWnd->SetActiveWindow(); m_pMainWnd->SetFocus(); m_pMainWnd->SetForegroundWindow(); // autoconnect on start, if preferred if (prefs.autoconnector_when_to_connect() == k_AutoConnector_Connect_Once) { p_autoconnector->Connect(NULL); } // Start thread anyway; permanent connection might be enabled later via preferences. p_autoconnectorthread->StartThread(); return TRUE; }
BOOL InitApplication (HINSTANCE hInst, LPTSTR pszCmdLine, int nCmdShow) { TaLocale_LoadCorrespondingModule (hInst); memset (&g, 0x00, sizeof(g)); g.hInst = hInst; g.hAccel = TaLocale_LoadAccelerators (ACCEL_MAIN); HWND hPrevious; TCHAR szTitle[ cchRESOURCE ]; GetString (szTitle, IDS_APP_TITLE); if ((hPrevious = FindWindow (TEXT("AFSManagerClass"), szTitle)) != NULL) { SetFocus (hPrevious); SendMessage (hPrevious, WM_SHOW_YOURSELF, 0, 0); return FALSE; } AfsAppLib_SetAppName(szTitle); AfsAppLib_SetPumpRoutine(PumpMessage); TASKQUEUE_PARAMS tqp; memset (&tqp, 0x00, sizeof(tqp)); tqp.nThreadsMax = 10; tqp.fnCreateTaskPacket = CreateTaskPacket; tqp.fnPerformTask = PerformTask; tqp.fnFreeTaskPacket = FreeTaskPacket; AfsAppLib_InitTaskQueue (&tqp); Main_ConfigureHelp(); // Determine how the app is supposed to look--that is, remember what it // looked like last time, and if there was no "last time", pick some // decent defaults. // if (!RestoreSettings (REGSTR_SETTINGS_BASE, REGSTR_SETTINGS_PATH, REGVAL_SETTINGS, &gr, sizeof(gr), wVerGLOBALS_RESTORED)) { memset (&gr, 0x00, sizeof(gr)); SetRectEmpty (&gr.rMain); SetRectEmpty (&gr.rMainPreview); SetRectEmpty (&gr.rServerLast); SetRectEmpty (&gr.rViewLog); SetRectEmpty (&gr.rActions); gr.fPreview = TRUE; gr.fVert = TRUE; gr.fActions = FALSE; gr.tabLast = tabFILESETS; Server_SetDefaultView_Horz (&gr.diHorz.viewSvr); Server_SetDefaultView_Vert (&gr.diVert.viewSvr); Services_SetDefaultView (&gr.viewSvc); Aggregates_SetDefaultView (&gr.viewAgg); Filesets_SetDefaultView (&gr.viewSet); Replicas_SetDefaultView (&gr.viewRep); Action_SetDefaultView (&gr.viewAct); Server_Key_SetDefaultView (&gr.viewKey); gr.diHorz.cSplitter = -100; gr.diVert.cSplitter = -89; gr.cbQuotaUnits = cb1KB; gr.fOpenMonitors = TRUE; gr.fCloseUnmonitors = TRUE; gr.fServerLongNames = FALSE; gr.fDoubleClickOpens = 2; gr.fWarnBadCreds = TRUE; gr.ivSvr = ivSTATUS; gr.ivAgg = ivSTATUS; gr.ivSet = ivSTATUS; gr.ivSvc = ivSTATUS; } ULONG status; if (!AfsClass_Initialize (&status)) { if (status == ADMCLIENTCANTINITAFSLOCATION) ImmediateErrorDialog (status, IDS_ERROR_CANT_INIT_AFSCLASS_INSTALL); else ImmediateErrorDialog (status, IDS_ERROR_CANT_INIT_AFSCLASS_UNKNOWN); return FALSE; } AfsClass_RequestLongServerNames (gr.fServerLongNames); AfsClass_SpecifyRefreshDomain (AFSCLASS_WANT_VOLUMES); // Create a notification object for the AFSClass library, so that it can // let us know when anything changes. The notification handler we'll // install will take requests from the rest of the SVRMGR package and // forward notifications around to whichever windows are actually // interested. // CreateNotificationDispatch(); // Create a few variations on WC_DIALOG, so we get appropriate icons on // our windows. // WNDCLASS wc; GetClassInfo (THIS_HINST, MAKEINTRESOURCE( WC_DIALOG ), &wc); wc.hInstance = THIS_HINST; wc.hIcon = TaLocale_LoadIcon (IDI_MAIN); wc.lpszClassName = TEXT("AFSManagerClass"); wc.style |= CS_GLOBALCLASS; RegisterClass (&wc); GetClassInfo (THIS_HINST, MAKEINTRESOURCE( WC_DIALOG ), &wc); wc.hInstance = THIS_HINST; wc.hIcon = TaLocale_LoadIcon (IDI_SERVER); wc.lpszClassName = TEXT("ServerWindowClass"); wc.style |= CS_GLOBALCLASS; RegisterClass (&wc); // Okay, the big step: create the main window (ie, the servers list). // Note that it doesn't get shown yet! // CMDLINEOP op = ParseCommandLine (pszCmdLine); if (op == opCLOSEAPP) return FALSE; if (op == opLOOKUPERRORCODE) { Help_FindError(); return FALSE; } g.hMain = ModelessDialog (IDD_MAIN, NULL, (DLGPROC)Main_DialogProc); if (g.hMain == NULL) return FALSE; if (op != opNOCELLDIALOG) { if (OpenCellDialog() != IDOK) return FALSE; } return TRUE; }
bool BasicWindow::InitWindowsApp(HINSTANCE appHandle, int showStyle) { int classStyle, bgColor, wndStyle, width, height, x, y; char caption[255]; // Read integers from ini file: class style, bgcolor, window style, width, height and starting x and y. classStyle = GetPrivateProfileInt("Window", "class_style", 0, "./D3D11.ini"); bgColor = GetPrivateProfileInt("Window", "bgcolor", 0, "./D3D11.ini"); wndStyle = GetPrivateProfileInt("Window", "window_style", 0, "./D3D11.ini"); width = GetPrivateProfileInt("Window", "width", 0, "./D3D11.ini"); height = GetPrivateProfileInt("Window", "height", 0, "./D3D11.ini"); x = GetPrivateProfileInt("Window", "x", 0, "./D3D11.ini"); y = GetPrivateProfileInt("Window", "y", 0, "./D3D11.ini"); // Make sure the width, height and starting x, y are valid numbers. width = width <=0 ? CW_USEDEFAULT : width; height = height <=0 ? CW_USEDEFAULT : height; x = x <=0 ? CW_USEDEFAULT : x; y = y <=0 ? CW_USEDEFAULT : y; // Read the window caption from file and store. GetPrivateProfileString("Window", "caption", "Ny Window", caption, 255, "./D3D11.ini"); mCaption = caption; WNDCLASS wc; // If the window class is not already registered, register it. if(!GetClassInfo(appHandle, "BasicWindowClass", &wc)) { wc.style = classStyle; // Window class style: Redraw when movement or size changes. wc.lpfnWndProc = WindowProc; // Pointer to the window procedure. wc.cbClsExtra = 0; // No extra bytes allocated following the class structure. wc.cbWndExtra = 0; // No extra bytes allocated followint the window instance. wc.hInstance = appHandle; // Handle to the instance where the window procedure is contained. wc.hIcon = LoadIcon(0, IDI_APPLICATION); // Handle to the class icon. wc.hCursor = LoadCursor(0, IDC_ARROW); // Handle to the class cursor. wc.hbrBackground = (HBRUSH)bgColor; // Handle to the class background brush. wc.lpszMenuName = 0; // Resource name of the class menu. wc.lpszClassName = "BasicWindowClass"; // Name of the class for use when the window is created. // If the class registration failed, show a message and return failure. if(!RegisterClass(&wc)) { std::stringstream ss; ss << "RegisterClass failed, error code: "; ss << GetLastError(); ShowMessage(ss.str()); return false; } } // Create the window and save a handle to it. mHandle = CreateWindow("BasicWindowClass", // Name of the registered window class to use at creation. mCaption.c_str(), // The caption of the window. wndStyle, // Window style. x, // Initial x-position. y, // Initial y-position. width, // Width of the window in device units. height, // Height of the window in device units. 0, // Handle to parent (there is no parent). 0, // Handle to a menu (there is no menu). appHandle, // Application instance handle. this); // The value passed to the window through CREATESTRUCT's // lpCreateParams member (used in WindowProc). // If the window creation failed, show a message and return failure. if(mHandle == 0) { std::stringstream ss; ss << "CreateWindow failed, error code: "; ss << GetLastError(); ShowMessage(ss.str()); return false; } // Show and update the window and return success. ShowWindow(mHandle, showStyle); UpdateWindow(mHandle); return true; }
/* * Initialise the GUI. Create all the windows, set up all the call-backs * etc. */ int gui_mch_init(void) { const char szVimWndClass[] = VIM_CLASS; const char szTextAreaClass[] = "VimTextArea"; WNDCLASS wndclass; #ifdef WIN16_3DLOOK Ctl3dRegister(s_hinst); Ctl3dAutoSubclass(s_hinst); #endif /* Display any pending error messages */ display_errors(); gui.scrollbar_width = GetSystemMetrics(SM_CXVSCROLL); gui.scrollbar_height = GetSystemMetrics(SM_CYHSCROLL); #ifdef FEAT_MENU gui.menu_height = 0; /* Windows takes care of this */ #endif gui.border_width = 0; gui.currBgColor = INVALCOLOR; s_brush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE)); if (GetClassInfo(s_hinst, szVimWndClass, &wndclass) == 0) { wndclass.style = 0; wndclass.lpfnWndProc = _WndProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 0; wndclass.hInstance = s_hinst; wndclass.hIcon = LoadIcon(wndclass.hInstance, MAKEINTRESOURCE(IDR_VIM)); wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); wndclass.hbrBackground = s_brush; wndclass.lpszMenuName = NULL; wndclass.lpszClassName = szVimWndClass; if (( #ifdef GLOBAL_IME atom = #endif RegisterClass(&wndclass)) == 0) return FAIL; } s_hwnd = CreateWindow( szVimWndClass, "Vim MSWindows GUI", WS_OVERLAPPEDWINDOW, gui_win_x == -1 ? CW_USEDEFAULT : gui_win_x, gui_win_y == -1 ? CW_USEDEFAULT : gui_win_y, 100, /* Any value will do */ 100, /* Any value will do */ NULL, NULL, s_hinst, NULL); if (s_hwnd == NULL) return FAIL; #ifdef GLOBAL_IME global_ime_init(atom, s_hwnd); #endif /* Create the text area window */ if (GetClassInfo(s_hinst, szTextAreaClass, &wndclass) == 0) { wndclass.style = CS_OWNDC; wndclass.lpfnWndProc = _TextAreaWndProc; wndclass.cbClsExtra = 0; wndclass.cbWndExtra = 0; wndclass.hInstance = s_hinst; wndclass.hIcon = NULL; wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); wndclass.hbrBackground = NULL; wndclass.lpszMenuName = NULL; wndclass.lpszClassName = szTextAreaClass; if (RegisterClass(&wndclass) == 0) return FAIL; } s_textArea = CreateWindow( szTextAreaClass, "Vim text area", WS_CHILD | WS_VISIBLE, 0, 0, 100, /* Any value will do for now */ 100, /* Any value will do for now */ s_hwnd, NULL, s_hinst, NULL); if (s_textArea == NULL) return FAIL; #ifdef FEAT_MENU s_menuBar = CreateMenu(); #endif s_hdc = GetDC(s_textArea); #ifdef MSWIN16_FASTTEXT SetBkMode(s_hdc, OPAQUE); #endif DragAcceptFiles(s_hwnd, TRUE); /* Do we need to bother with this? */ /* m_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT); */ /* Get background/foreground colors from the system */ gui_mch_def_colors(); /* Get the colors from the "Normal" group (set in syntax.c or in a vimrc * file) */ set_normal_colors(); /* * Check that none of the colors are the same as the background color. * Then store the current values as the defaults. */ gui_check_colors(); gui.def_norm_pixel = gui.norm_pixel; gui.def_back_pixel = gui.back_pixel; /* Get the colors for the highlight groups (gui_check_colors() might have * changed them) */ highlight_gui_started(); /* * Start out by adding the configured border width into the border offset */ gui.border_offset = gui.border_width; /* * compute a couple of metrics used for the dialogs */ get_dialog_font_metrics(); #ifdef FEAT_TOOLBAR /* * Create the toolbar */ initialise_toolbar(); #endif #ifdef MSWIN_FIND_REPLACE /* * Initialise the dialog box stuff */ s_findrep_msg = RegisterWindowMessage(FINDMSGSTRING); /* Initialise the struct */ s_findrep_struct.lStructSize = sizeof(s_findrep_struct); s_findrep_struct.lpstrFindWhat = alloc(MSWIN_FR_BUFSIZE); s_findrep_struct.lpstrFindWhat[0] = NUL; s_findrep_struct.lpstrReplaceWith = alloc(MSWIN_FR_BUFSIZE); s_findrep_struct.lpstrReplaceWith[0] = NUL; s_findrep_struct.wFindWhatLen = MSWIN_FR_BUFSIZE; s_findrep_struct.wReplaceWithLen = MSWIN_FR_BUFSIZE; #endif return OK; }
Bool GWinControl::ClassExists() { WNDCLASS wc; return GetClassInfo( GApp::g_HInstance, ClassName(), &wc ); }
bool CoreWindow_wgl::createWindow(int x, int y, int width, int height, const TCHAR* title) { WNDCLASS wc; HWND hWnd; DWORD dwExStyle; DWORD dwStyle; RECT WindowRect; WindowRect.left = 0; WindowRect.right = width; WindowRect.top = 0; WindowRect.bottom = height; dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; AdjustWindowRect(&WindowRect, dwStyle, FALSE); if (!GetClassInfo(GetModuleHandle(NULL), _TX("CoreWindow_wgl"), &wc)) { // memset(&wcx, 0, sizeof(WNDCLASSEX)); // wcx.cbSize = sizeof(WNDCLASSEX); wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; wc.lpfnWndProc = (WNDPROC) CoreWindow_wgl::BaseWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = GetModuleHandle(NULL); wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wc.lpszMenuName = 0; wc.lpszClassName = _TX("CoreWindow_wgl"); if (!RegisterClass(&wc)) { MessageBox(NULL,_TX("Failed To Register The Window Class."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION); ExitProcess(0); return FALSE; } } hWnd = CreateWindowEx(dwExStyle, _TX("CoreWindow_wgl"), title, dwStyle, x, y, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top, NULL, NULL, GetModuleHandle(NULL), (void*)this);//BaseWndProcにthisを渡してやる if (!hWnd) { KillGLWindow(); MessageBox(NULL,_TX("Window Creation Error."),_TX("ERROR"),MB_OK|MB_ICONEXCLAMATION); ExitProcess(0); return FALSE; } // ウィンドウハンドルとCWindowBaseオブジェクトを結びつける SetProp(hWnd, _TX("CoreWindow_wgl"), (HANDLE)this); m_hWnd = hWnd; if (!g_mainWin) g_mainWin = this; return TRUE; }
LRESULT CALLBACK Listview_WindowProc( HWND hwnd, // handle of window UINT uMsg, // message identifier WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ) { LPLISTVIEW_PARAM lv = LPLISTVIEW_PARAM(GetWindowLong(hwnd, 16)); WNDPROC pwndProc = (WNDPROC) GetWindowLong(hwnd, 12); switch(uMsg) { case WM_NCCREATE: { lv = InitializeListViewInstance(hwnd); TCHAR pszClassName[MAX_PATH] = { 0 }; GetClassName(hwnd, pszClassName, MAX_PATH); if ( lstrcmpi(pszClassName, TEXT("DBFListView32")) ) { int preflen = sizeof(DBF_CONTROL) / sizeof(TCHAR) - 1, chr = 0; while(chr <= preflen && pszClassName[chr] == DBF_CONTROL[chr] ) chr++; if ( chr == preflen ) { WNDCLASS wc = { 0 }; if ( GetClassInfo( (HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE), &pszClassName[chr], &wc ) ) { SetWindowLong(hwnd, 12, (LONG) wc.lpfnWndProc); lv->pfnWndProc = wc.lpfnWndProc; lv->fIsListView = FALSE; pwndProc = wc.lpfnWndProc; } else return FALSE; } else return FALSE; } SetRect(&lv->rc, LPCREATESTRUCT(lParam)->x, LPCREATESTRUCT(lParam)->y, LPCREATESTRUCT(lParam)->cx, LPCREATESTRUCT(lParam)->cy ); lv->hHeader = NULL; break; } case WM_ERASEBKGND: { if ( lv->fIsListView ) { if ( !lv->hHeader ) lv->hHeader = (HWND) lv->pfnWndProc(hwnd, LVM_GETHEADER, 0, 0); GetClientRect(lv->hHeader, &lv->header_rc); return CallWindowProc(lv->pfnWndProc, hwnd, uMsg, WPARAM(lv->hDC), lParam); } else return pwndProc(hwnd, uMsg, WPARAM(lv->hDC), lParam); break; } case WM_SIZING: case WM_SIZE: { GetClientRect(hwnd, &lv->rc); if ( lv->fIsListView ) { if ( !lv->hHeader ) lv->hHeader = (HWND) lv->pfnWndProc(hwnd, LVM_GETHEADER, 0, 0); GetClientRect(lv->hHeader, &lv->header_rc); } break; } case WM_PRINT: { WNDPROC pwnd = ( lv->fIsListView ? lv->pfnWndProc : pwndProc ); // pwnd(hwnd, WM_ERASEBKGND, (WPARAM) lv->hDC, 0); // pwnd(hwnd, WM_PAINT, (WPARAM) lv->hDC, 0); pwnd(hwnd, WM_PRINT, (WPARAM) lv->hDC, lParam); if ( !PBYTE(lv->pvBits)[0] ) FillRect((HDC) wParam, &lv->rc, GetSysColorBrush(COLOR_WINDOW)); else BitBlt((HDC) wParam, 0, 0, lv->rc.right, lv->rc.bottom, lv->hDC, 0, 0, SRCCOPY); return 0; } case WM_PAINT: { PAINTSTRUCT ps = { 0 }; HDC hdc = BeginPaint(hwnd, &ps); if ( lv->fIsListView ) CallWindowProc(lv->pfnWndProc, hwnd, uMsg, WPARAM(lv->hDC), lParam); else pwndProc(hwnd, uMsg, WPARAM(lv->hDC), lParam); if ( lv->fIsListView ) BitBlt(hdc, 0, lv->header_rc.bottom, lv->rc.right, lv->rc.bottom - lv->header_rc.bottom, lv->hDC, 0, lv->header_rc.bottom, SRCCOPY); else BitBlt(hdc, 0, 0, lv->rc.right, lv->rc.bottom, lv->hDC, 0, 0, SRCCOPY); EndPaint(hwnd, &ps); return 0; } case WM_NCDESTROY: { LRESULT ret = ( lv->fIsListView ? lv->pfnWndProc(hwnd, uMsg, wParam, lParam) : pwndProc(hwnd, uMsg, wParam, lParam) ); UninitializeListViewInstance(hwnd); return ret; } } if ( lv->fIsListView && lv->pfnWndProc ) return lv->pfnWndProc(hwnd, uMsg, wParam, lParam); else if ( !lv->fIsListView && pwndProc ) return pwndProc(hwnd, uMsg, wParam, lParam); return DefWindowProc(hwnd, uMsg, wParam, lParam); }
/* * Opens a window. Requires a SFG_Window object created and attached * to the freeglut structure. OpenGL context is created here. */ void fgPlatformOpenWindow( SFG_Window* window, const char* title, GLboolean positionUse, int x, int y, GLboolean sizeUse, int w, int h, GLboolean gameMode, GLboolean isSubWindow ) { WNDCLASS wc; DWORD flags = 0; DWORD exFlags = 0; ATOM atom; /* Grab the window class we have registered on glutInit(): */ atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc ); FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found", "fgOpenWindow" ); /* Determine window style flags*/ if( gameMode ) { FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL, "Game mode being invoked on a subwindow", "fgOpenWindow" ); /* * Set the window creation flags appropriately to make the window * entirely visible: */ flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; } else { flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN; /* * There's a small difference between creating the top, child and * menu windows */ if ( window->IsMenu ) { flags |= WS_POPUP; exFlags |= WS_EX_TOOLWINDOW; } #if defined(_WIN32_WCE) /* no decorations for windows CE */ #else /* if this is not a subwindow (child), set its style based on the requested display mode */ else if( window->Parent == NULL ) if ( fgState.DisplayMode & GLUT_BORDERLESS ) { /* no window decorations needed */ } else if ( fgState.DisplayMode & GLUT_CAPTIONLESS ) /* only window decoration is a border, no title bar or buttons */ flags |= WS_DLGFRAME; else /* window decoration are a border, title bar and buttons. * NB: we later query whether the window has a title bar or * not by testing for the maximize button, as the test for * WS_CAPTION can be true without the window having a title * bar. This style WS_OVERLAPPEDWINDOW gives you a maximize * button. */ flags |= WS_OVERLAPPEDWINDOW; #endif else /* subwindows always have no decoration, but are marked as a child window to the OS */ flags |= WS_CHILD; } /* determine window size and position */ if( gameMode ) { /* if in gamemode, query the origin of specified by the -display * command line parameter (if any) and offset the upper-left corner * of the window so we create the window on that screen. * The -display argument doesn't do anything if not trying to enter * gamemode. */ int xoff=0, yoff=0; get_display_origin(&xoff,&yoff); x += xoff; y += yoff; } if( !positionUse ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; } if( !sizeUse ) { if( ! window->IsMenu ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; } else /* fail safe - Windows can make a window of size (0, 0) */ w = h = 300; /* default window size */ } /* store requested client area width and height */ window->State.Width = w; window->State.Height = h; #if !defined(_WIN32_WCE) /* no decorations for windows CE */ if( sizeUse ) { RECT windowRect; /* * Update the window dimensions, taking the window decorations * into account. FreeGLUT is to create the window with the * topleft outside corner at (x,y) and with client area * dimensions (w,h). * note: don't need to do this when w=h=CW_USEDEFAULT, so in the * if( sizeUse ) here is convenient. */ windowRect.left = x; windowRect.top = y; windowRect.right = x+w; windowRect.bottom = y+h; fghComputeWindowRectFromClientArea_UseStyle(flags,&windowRect,TRUE); w = windowRect.right - windowRect.left; h = windowRect.bottom- windowRect.top; } #endif /* !defined(_WIN32_WCE) */ #if defined(_WIN32_WCE) { wchar_t* wstr = fghWstrFromStr(title); window->Window.Handle = CreateWindow( _T("FREEGLUT"), wstr, WS_VISIBLE | WS_POPUP, 0,0, 240,320, NULL, NULL, fgDisplay.pDisplay.Instance, (LPVOID) window ); free(wstr); SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON); SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON); SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR); MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE); ShowWindow(window->Window.Handle, SW_SHOW); UpdateWindow(window->Window.Handle); } #else window->Window.Handle = CreateWindowEx( exFlags, _T("FREEGLUT"), title, flags, x, y, w, h, (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, (HMENU) NULL, fgDisplay.pDisplay.Instance, (LPVOID) window ); #endif /* defined(_WIN32_WCE) */ if( !( window->Window.Handle ) ) fgError( "Failed to create a window (%s)!", title ); #if !defined(_WIN32_WCE) /* Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders */ SetWindowLong(window->Window.Handle, GWL_STYLE, flags); SetWindowPos(window->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); #endif /* defined(_WIN32_WCE) */ /* Make a menu window always on top - fix Feature Request 947118 */ if( window->IsMenu || gameMode ) SetWindowPos( window->Window.Handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE ); /* Enable multitouch: additional flag TWF_FINETOUCH, TWF_WANTPALM */ #ifdef WM_TOUCH if (fghRegisterTouchWindow == (pRegisterTouchWindow)0xDEADBEEF) fghRegisterTouchWindow = (pRegisterTouchWindow)GetProcAddress(GetModuleHandle("user32"),"RegisterTouchWindow"); if (fghRegisterTouchWindow) fghRegisterTouchWindow( window->Window.Handle, TWF_FINETOUCH | TWF_WANTPALM ); #endif #if defined(_WIN32_WCE) ShowWindow( window->Window.Handle, SW_SHOW ); #else ShowWindow( window->Window.Handle, fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); #endif /* defined(_WIN32_WCE) */ UpdateWindow( window->Window.Handle ); ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */ }
CPUTResult CPUTWindowWin::Create(CPUT* cput, const cString WindowTitle, CPUTWindowCreationParams windowParams) { // If were here, we are sure that window is not created. // Take into notice this whole framework is not Thread-Safe. ASSERT( (windowParams.windowPositionX < GetSystemMetrics(SM_CXFULLSCREEN) && (windowParams.windowPositionX>=-1)), _L("You are attempting to create a window outside the desktop coordinates. Check your CPUTWindowCreationParams")); ASSERT( (windowParams.windowPositionY < GetSystemMetrics(SM_CYFULLSCREEN) && (windowParams.windowPositionY>=-1)), _L("You are attempting to create a window outside the desktop coordinates. Check your CPUTWindowCreationParams")); // Get the hInstance of this executable mhInst = GetModuleHandle(NULL); if( !mhInst ) { return CPUT_ERROR_CANNOT_GET_WINDOW_INSTANCE; } // Clear message queue MSG msg = { 0 }; while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); } WNDCLASS Window; // Window class DEVMODE DispDevice; // Display Device settings DWORD Style; // Window style DWORD ExStyle; // Window extended style RECT WindowRect; // Window rectangle // Load icon HANDLE hIcon = LoadImage(mhInst, L"CPUT.ico", IMAGE_ICON, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE ); // set up app title (if not specified) mAppTitle = WindowTitle; if(0==mAppTitle.compare(_L(""))) { mAppTitle = _L("CPUT Sample"); } // Register the Win32 class for this app WNDCLASS wc; if(TRUE == GetClassInfo(mhInst, mAppTitle.c_str(), &wc)) { // point to the existing one mhInst = wc.hInstance; } else { // register a new windows class ATOM classID; classID = MyRegisterClass(mhInst); if(0==classID) { HandleWin32Error(); return CPUT_ERROR_WINDOW_CANNOT_REGISTER_APP; } } // Perform Win32 instance initialization const int nCmdShow = SW_SHOWNORMAL; if (false == InitInstance(nCmdShow, windowParams.windowWidth, windowParams.windowHeight, windowParams.windowPositionX, windowParams.windowPositionY)) { return CPUT_ERROR_CANNOT_GET_WINDOW_INSTANCE; } // store the CPUT pointer mCPUT = (CPUT*) cput; return CPUT_SUCCESS; }
/* * A call to this function should initialize all the display stuff... */ static void fghInitialize( const char* displayName ) { #if TARGET_HOST_POSIX_X11 fgDisplay.Display = XOpenDisplay( displayName ); if( fgDisplay.Display == NULL ) fgError( "failed to open display '%s'", XDisplayName( displayName ) ); if( !glXQueryExtension( fgDisplay.Display, NULL, NULL ) ) fgError( "OpenGL GLX extension not supported by display '%s'", XDisplayName( displayName ) ); fgDisplay.Screen = DefaultScreen( fgDisplay.Display ); fgDisplay.RootWindow = RootWindow( fgDisplay.Display, fgDisplay.Screen ); fgDisplay.ScreenWidth = DisplayWidth( fgDisplay.Display, fgDisplay.Screen ); fgDisplay.ScreenHeight = DisplayHeight( fgDisplay.Display, fgDisplay.Screen ); fgDisplay.ScreenWidthMM = DisplayWidthMM( fgDisplay.Display, fgDisplay.Screen ); fgDisplay.ScreenHeightMM = DisplayHeightMM( fgDisplay.Display, fgDisplay.Screen ); fgDisplay.Connection = ConnectionNumber( fgDisplay.Display ); /* Create the window deletion atom */ fgDisplay.DeleteWindow = fghGetAtom("WM_DELETE_WINDOW"); /* Create the state and full screen atoms */ fgDisplay.State = None; fgDisplay.StateFullScreen = None; if (fghNetWMSupported()) { const Atom supported = fghGetAtom("_NET_SUPPORTED"); const Atom state = fghGetAtom("_NET_WM_STATE"); /* Check if the state hint is supported. */ if (fgHintPresent(fgDisplay.RootWindow, supported, state)) { const Atom full_screen = fghGetAtom("_NET_WM_STATE_FULLSCREEN"); fgDisplay.State = state; /* Check if the window manager supports full screen. */ /** Check "_NET_WM_ALLOWED_ACTIONS" on our window instead? **/ if (fgHintPresent(fgDisplay.RootWindow, supported, full_screen)) { fgDisplay.StateFullScreen = full_screen; } } } #elif TARGET_HOST_MS_WINDOWS WNDCLASS wc; ATOM atom; /* What we need to do is to initialize the fgDisplay global structure here. */ fgDisplay.Instance = GetModuleHandle( NULL ); fgDisplay.DisplayName= displayName ? strdup(displayName) : 0 ; atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); if( atom == 0 ) { ZeroMemory( &wc, sizeof(WNDCLASS) ); /* * Each of the windows should have its own device context, and we * want redraw events during Vertical and Horizontal Resizes by * the user. * * XXX Old code had "| CS_DBCLCKS" commented out. Plans for the * XXX future? Dead-end idea? */ wc.lpfnWndProc = fgWindowProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = fgDisplay.Instance; wc.hIcon = LoadIcon( fgDisplay.Instance, _T("GLUT_ICON") ); #if defined(_WIN32_WCE) wc.style = CS_HREDRAW | CS_VREDRAW; #else wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; if (!wc.hIcon) wc.hIcon = LoadIcon( NULL, IDI_WINLOGO ); #endif wc.hCursor = LoadCursor( NULL, IDC_ARROW ); wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = _T("FREEGLUT"); /* Register the window class */ atom = RegisterClass( &wc ); FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Not Registered", "fghInitialize" ); } /* The screen dimensions can be obtained via GetSystemMetrics() calls */ fgDisplay.ScreenWidth = GetSystemMetrics( SM_CXSCREEN ); fgDisplay.ScreenHeight = GetSystemMetrics( SM_CYSCREEN ); { HWND desktop = GetDesktopWindow( ); HDC context = GetDC( desktop ); fgDisplay.ScreenWidthMM = GetDeviceCaps( context, HORZSIZE ); fgDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE ); ReleaseDC( desktop, context ); } /* If we have a DisplayName try to use it for metrics */ if( fgDisplay.DisplayName ) { HDC context = CreateDC(fgDisplay.DisplayName,0,0,0); if( context ) { fgDisplay.ScreenWidth = GetDeviceCaps( context, HORZRES ); fgDisplay.ScreenHeight = GetDeviceCaps( context, VERTRES ); fgDisplay.ScreenWidthMM = GetDeviceCaps( context, HORZSIZE ); fgDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE ); DeleteDC(context); } else fgWarning("fghInitialize: " "CreateDC failed, Screen size info may be incorrect\n" "This is quite likely caused by a bad '-display' parameter"); } /* Set the timer granularity to 1 ms */ timeBeginPeriod ( 1 ); #endif fgState.Initialised = GL_TRUE; /* Avoid registering atexit callback on Win32 as it results in an access * violation due to calling into a module which has been unloaded. */ #if ( TARGET_HOST_MS_WINDOWS == 0 ) atexit(fgDeinitialize); #endif /* InputDevice uses GlutTimerFunc(), so fgState.Initialised must be TRUE */ fgInitialiseInputDevices(); }
LRESULT PASCAL HotKeyWndProc(HWND hWnd, register UINT uMsg, register WPARAM wParam, register LPARAM lParam) { CM_HOTKEY *pHotKey = ( CM_HOTKEY * ) GetProp( hWnd, _T("HOTKEY") ); switch ( uMsg ) { case WM_CREATE: { CM_HOTKEY *pHotKey = new CM_HOTKEY; ZeroMemory( pHotKey, sizeof( CM_HOTKEY ) ); SetProp( hWnd, _T("HOTKEY"), pHotKey ); SetWindowLong( hWnd, GWL_EXSTYLE, GetWindowLong( hWnd, GWL_EXSTYLE ) | WS_EX_CLIENTEDGE ); SetWindowPos( hWnd, NULL, -1, -1, -1, -1, SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE | SWP_DRAWFRAME ); SendMessage( hWnd, UM_UPDATEHOTKEYTEXT, 0, 0 ); g_bEatCommand = FALSE; break; } case WM_DESTROY: { RemoveProp( hWnd, _T("HOTKEY") ); delete pHotKey; break; } case UM_TAKEBACKFOCUS: { if ( GetFocus() != hWnd ) { SetFocus( hWnd ); } g_bEatCommand = FALSE; return 0; } case HOTM_QUERYEATCOMMAND: { return g_bEatCommand; } case UM_UPDATEHOTKEYTEXT: { TCHAR szHotKey[ 100 ]; *szHotKey = '\0'; GetHotKeyString( *pHotKey, szHotKey ); g_bCanUpdateText = TRUE; SetWindowText( hWnd, szHotKey ); g_bCanUpdateText = FALSE; SendMessage( hWnd, EM_SETSEL, 1000, 1000 ); return 0; } case UM_INTERNALSETHOTKEY: { UINT nVirtKey = wParam; switch ( nVirtKey ) { case VK_CONTROL: case VK_SHIFT: case VK_MENU: { nVirtKey = 0; } } if ( nVirtKey ) { CM_HOTKEY cmHotKey = *pHotKey; BYTE byModifiers = 0; byModifiers |= ( ( GetKeyState( VK_CONTROL ) < 0 ) ? HOTKEYF_CONTROL : 0 ); byModifiers |= ( ( GetKeyState( VK_SHIFT ) < 0 ) ? HOTKEYF_SHIFT : 0 ); byModifiers |= ( ( GetKeyState( VK_MENU ) < 0 ) ? HOTKEYF_ALT : 0 ); if ( cmHotKey.byModifiers1 || cmHotKey.nVirtKey1 ) { if ( !cmHotKey.byModifiers2 && !cmHotKey.nVirtKey2 ) { cmHotKey.byModifiers2 = byModifiers; cmHotKey.nVirtKey2 = nVirtKey; } else { cmHotKey.byModifiers2 = 0; cmHotKey.nVirtKey2 = 0; goto set_loword; } } else { set_loword: ASSERT( !cmHotKey.byModifiers2 && !cmHotKey.nVirtKey2 ); cmHotKey.byModifiers1 = byModifiers; cmHotKey.nVirtKey1 = nVirtKey; } SendMessage( hWnd, HOTM_SETHOTKEY, 0, ( LPARAM ) &cmHotKey ); } return 0; } case HOTM_SETHOTKEY: { if ( lParam ) { *pHotKey = *( CM_HOTKEY * ) lParam; } else { CM_HOTKEY cmHotKey = { 0, 0, 0, 0 }; *pHotKey = cmHotKey; } SendMessage( hWnd, UM_UPDATEHOTKEYTEXT, 0, 0 ); return 0; } case HOTM_GETHOTKEY: { *( ( CM_HOTKEY * ) lParam ) = *pHotKey; break; } case WM_KEYDOWN: case WM_SYSKEYDOWN: { g_bEatCommand = TRUE; SendMessage( hWnd, UM_INTERNALSETHOTKEY, wParam, lParam ); PostMessage( hWnd, UM_TAKEBACKFOCUS, 0, 0 ); return DefWindowProc( hWnd, uMsg, wParam, lParam ); } case WM_KEYUP: case WM_SYSKEYUP: { return DefWindowProc( hWnd, uMsg, wParam, lParam ); } case WM_CHAR: case WM_SYSCHAR: { return DefWindowProc( hWnd, uMsg, wParam, lParam ); } case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_LBUTTONDBLCLK: case WM_RBUTTONDOWN: case WM_RBUTTONUP: case WM_RBUTTONDBLCLK: case WM_MBUTTONDOWN: case WM_MBUTTONUP: case WM_MBUTTONDBLCLK: case WM_CONTEXTMENU: { SetFocus( hWnd ); return 0; } case WM_SYSCOMMAND: { return 0; } case WM_SETTEXT: { if ( g_bCanUpdateText ) { break; } else { return 0; } } case WM_GETDLGCODE: { DWORD dwDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS | DLGC_WANTTAB; if ( HAS_FLAG( GetWindowLong( hWnd, GWL_STYLE ), ES_WANTRETURN ) ) { dwDlgCode |= DLGC_WANTALLKEYS; } return dwDlgCode; } } // Other than the above messages, the hotkey control behaves identical to an edit control WNDCLASS wcEdit; VERIFY( GetClassInfo( ( HINSTANCE ) GetWindowLong( hWnd, GWL_HINSTANCE ), _T("EDIT"), &wcEdit ) ); #ifdef _ACTIVEX return CallWindowProc( wcEdit.lpfnWndProc, hWnd, uMsg, wParam, lParam ); #else #if _MSC_VER > 1100 return CallWindowProc( ( WNDPROC ) wcEdit.lpfnWndProc, hWnd, uMsg, wParam, lParam ); #else return CallWindowProc( ( FARPROC ) wcEdit.lpfnWndProc, hWnd, uMsg, wParam, lParam ); #endif #endif }
BOOL InitApplication (HINSTANCE hInst, LPTSTR pszCmdLine, int nCmdShow) { TaLocale_LoadCorrespondingModule (hInst); memset (&g, 0x00, sizeof(g)); g.hInst = hInst; g.hAccel = TaLocale_LoadAccelerators (ACCEL_MAIN); HWND hPrevious; TCHAR szTitle[ cchRESOURCE ]; GetString (szTitle, IDS_APP_TITLE); if ((hPrevious = FindWindow (TEXT("AFSAccountManagerClass"), szTitle)) != NULL) { SetFocus (hPrevious); SendMessage (hPrevious, WM_SHOW_YOURSELF, 0, 0); return FALSE; } AfsAppLib_SetAppName(szTitle); AfsAppLib_SetPumpRoutine(PumpMessage); TASKQUEUE_PARAMS tqp; memset (&tqp, 0x00, sizeof(tqp)); tqp.nThreadsMax = 10; tqp.fnCreateTaskPacket = CreateTaskPacket; tqp.fnPerformTask = PerformTask; tqp.fnFreeTaskPacket = FreeTaskPacket; AfsAppLib_InitTaskQueue (&tqp); Main_ConfigureHelp(); // Determine how the app is supposed to look--that is, remember what it // looked like last time, and if there was no "last time", pick some // decent defaults. // if (!RestoreSettings (REGSTR_SETTINGS_BASE, REGSTR_SETTINGS_PATH, REGVAL_SETTINGS, &gr, sizeof(gr), wVerGLOBALS_RESTORED)) { memset (&gr, 0x00, sizeof(gr)); SetRectEmpty (&gr.rMain); gr.cminRefreshRate = 60; // 1 hour default refresh rate User_SetDefaultCreateParams (&gr.CreateUser); Group_SetDefaultCreateParams (&gr.CreateGroup); Machine_SetDefaultCreateParams (&gr.CreateMachine); Actions_SetDefaultView (&gr.viewAct); User_SetDefaultView (&gr.viewUsr, &gr.ivUsr); Group_SetDefaultView (&gr.viewGrp, &gr.ivGrp); Machine_SetDefaultView (&gr.viewMch, &gr.ivMch); Users_SetDefaultSearchParams (&gr.SearchUsers); } // Create a variation on WC_DIALOG, so we get appropriate icons on // our windows. // WNDCLASS wc; GetClassInfo (THIS_HINST, MAKEINTRESOURCE( WC_DIALOG ), &wc); wc.hInstance = THIS_HINST; wc.hIcon = TaLocale_LoadIcon (IDI_MAIN); wc.lpszClassName = TEXT("AFSAccountManagerClass"); wc.style |= CS_GLOBALCLASS; RegisterClass (&wc); // Okay, the big step: create the main window. Note that it doesn't // get shown yet! // CMDLINEOP op = ParseCommandLine (pszCmdLine); if (op == opCLOSEAPP) return FALSE; // Okay, the big step: create the main window. // Note that it doesn't get shown yet! // g.hMain = ModelessDialog (IDD_MAIN, NULL, (DLGPROC)Main_DialogProc); if (g.hMain == NULL) return FALSE; if (op != opNOCELLDIALOG) { if (OpenCellDialog() != IDOK) return FALSE; } return TRUE; }
/* * Opens a window. Requires a SFG_Window object created and attached * to the freeglut structure. OpenGL context is created here. */ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, int h, GLboolean gameMode, GLboolean isSubWindow ) { #if TARGET_HOST_UNIX_X11 XSetWindowAttributes winAttr; XTextProperty textProperty; XSizeHints sizeHints; XWMHints wmHints; unsigned long mask; freeglut_assert_ready; /* * XXX fgChooseVisual() is a common part of all three. * XXX With a little thought, we should be able to greatly * XXX simplify this. */ if( !window->IsMenu ) window->Window.VisualInfo = fgChooseVisual( ); else if( fgStructure.MenuContext ) window->Window.VisualInfo = fgChooseVisual( ); else { /* XXX Why are menus double- and depth-buffered? */ unsigned int current_DisplayMode = fgState.DisplayMode ; fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ; window->Window.VisualInfo = fgChooseVisual( ); fgState.DisplayMode = current_DisplayMode ; } if( ! window->Window.VisualInfo ) { /* * The "fgChooseVisual" returned a null meaning that the visual * context is not available. * Try a couple of variations to see if they will work. */ if( !( fgState.DisplayMode & GLUT_DOUBLE ) ) { fgState.DisplayMode |= GLUT_DOUBLE ; window->Window.VisualInfo = fgChooseVisual( ); fgState.DisplayMode &= ~GLUT_DOUBLE; } /* * GLUT also checks for multi-sampling, but I don't see that * anywhere else in FREEGLUT so I won't bother with it for the moment. */ } /* * XXX This seems to be abusing an assert() for error-checking. * XXX It is possible that the visual simply can't be found, * XXX in which case we should print an error and return a 0 * XXX for the window id, I think. */ assert( window->Window.VisualInfo != NULL ); /* * XXX HINT: the masks should be updated when adding/removing callbacks. * XXX This might speed up message processing. Is that true? * XXX * XXX A: Not appreciably, but it WILL make it easier to debug. * XXX Try tracing old GLUT and try tracing freeglut. Old GLUT * XXX turns off events that it doesn't need and is a whole lot * XXX more pleasant to trace. (Think mouse-motion! Tons of * XXX ``bonus'' GUI events stream in.) */ winAttr.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyRelease | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask; winAttr.background_pixmap = None; winAttr.background_pixel = 0; winAttr.border_pixel = 0; winAttr.colormap = XCreateColormap( fgDisplay.Display, fgDisplay.RootWindow, window->Window.VisualInfo->visual, AllocNone ); mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; if( window->IsMenu ) { winAttr.override_redirect = True; mask |= CWOverrideRedirect; } window->Window.Handle = XCreateWindow( fgDisplay.Display, window->Parent == NULL ? fgDisplay.RootWindow : window->Parent->Window.Handle, x, y, w, h, 0, window->Window.VisualInfo->depth, InputOutput, window->Window.VisualInfo->visual, mask, &winAttr ); /* * The GLX context creation, possibly trying the direct context rendering * or else use the current context if the user has so specified */ if( window->IsMenu ) { /* * If there isn't already an OpenGL rendering context for menu * windows, make one */ if( !fgStructure.MenuContext ) { fgStructure.MenuContext = (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) ); fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo; fgStructure.MenuContext->Context = glXCreateContext( fgDisplay.Display, fgStructure.MenuContext->VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } /* window->Window.Context = fgStructure.MenuContext->Context; */ window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } else if( fgState.UseCurrentContext ) { window->Window.Context = glXGetCurrentContext( ); if( ! window->Window.Context ) window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } else window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); if( !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) { if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT ) fgError( "Unable to force direct context rendering for window '%s'", title ); else if( fgState.DirectContext == GLUT_TRY_DIRECT_CONTEXT ) fgWarning( "Unable to create direct context rendering for window '%s'\nThis may hurt performance.", title ); } glXMakeCurrent( fgDisplay.Display, window->Window.Handle, window->Window.Context ); /* * XXX Assume the new window is visible by default * XXX Is this a safe assumption? */ window->State.Visible = GL_TRUE; sizeHints.flags = 0; if ( fgState.Position.Use ) sizeHints.flags |= USPosition; if ( fgState.Size.Use ) sizeHints.flags |= USSize; /* * Fill in the size hints values now (the x, y, width and height * settings are obsolote, are there any more WMs that support them?) * Unless the X servers actually stop supporting these, we should * continue to fill them in. It is *not* our place to tell the user * that they should replace a window manager that they like, and which * works, just because *we* think that it's not "modern" enough. */ #if TARGET_HOST_WINCE sizeHints.x = 0; sizeHints.y = 0; sizeHints.width = 320; sizeHints.height = 240; #else sizeHints.x = x; sizeHints.y = y; sizeHints.width = w; sizeHints.height = h; #endif /* TARGET_HOST_WINCE */ wmHints.flags = StateHint; wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState; /* * Prepare the window and iconified window names... */ XStringListToTextProperty( (char **) &title, 1, &textProperty ); XSetWMProperties( fgDisplay.Display, window->Window.Handle, &textProperty, &textProperty, 0, 0, &sizeHints, &wmHints, NULL ); XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 ); XMapWindow( fgDisplay.Display, window->Window.Handle ); #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE WNDCLASS wc; DWORD flags; DWORD exFlags = 0; ATOM atom; freeglut_assert_ready; /* * Grab the window class we have registered on glutInit(): */ atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); assert( atom != 0 ); if( gameMode ) { assert( window->Parent == NULL ); /* * Set the window creation flags appropriately to make the window * entirely visible: */ flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; } else { #if !TARGET_HOST_WINCE if ( ( ! isSubWindow ) && ( ! window->IsMenu ) ) { /* * Update the window dimensions, taking account of window * decorations. "freeglut" is to create the window with the * outside of its border at (x,y) and with dimensions (w,h). */ w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2; h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + GetSystemMetrics( SM_CYCAPTION ); } #endif /* TARGET_HOST_WINCE */ if( ! fgState.Position.Use ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; } if( ! fgState.Size.Use ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; } /* * There's a small difference between creating the top, child and * game mode windows */ flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; if ( window->IsMenu ) { flags |= WS_POPUP; exFlags |= WS_EX_TOOLWINDOW; } #if !TARGET_HOST_WINCE else if( window->Parent == NULL ) flags |= WS_OVERLAPPEDWINDOW; #endif else flags |= WS_CHILD; } #if TARGET_HOST_WINCE { wchar_t* wstr = wstr_from_str(title); window->Window.Handle = CreateWindow( _T("FREEGLUT"), wstr, WS_VISIBLE | WS_POPUP, 0,0, 240,320, NULL, NULL, fgDisplay.Instance, (LPVOID) window ); free(wstr); SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON); SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON); SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR); MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE); ShowWindow(window->Window.Handle, SW_SHOW); UpdateWindow(window->Window.Handle); } #else window->Window.Handle = CreateWindowEx( exFlags, "FREEGLUT", title, flags, x, y, w, h, (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, (HMENU) NULL, fgDisplay.Instance, (LPVOID) window ); #endif /* TARGET_HOST_WINCE */ if( !( window->Window.Handle ) ) fgError( "Failed to create a window (%s)!", title ); #if TARGET_HOST_WINCE ShowWindow( window->Window.Handle, SW_SHOW ); #else ShowWindow( window->Window.Handle, fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); #endif /* TARGET_HOST_WINCE */ UpdateWindow( window->Window.Handle ); ShowCursor( TRUE ); /* XXX Old comments say "hide cusror"! */ #endif fgSetWindow( window ); window->Window.DoubleBuffered = ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0; if ( ! window->Window.DoubleBuffered ) { glDrawBuffer ( GL_FRONT ); glReadBuffer ( GL_FRONT ); } }
kgmWindow::kgmWindow(kgmWindow* wp, kgmString wname, int x, int y, int w, int h, int bpp, bool fs) { m_parent = wp; m_msAbs = true; m_msf = false; m_fs = false; kgmLog::log("Init screen"); #ifdef WIN32 WNDCLASS wcl; if(!GetClassInfo(0, cWndClass, &wcl)) kgmRegisterWindowClass(); m_wnd = CreateWindow(cWndClass, wname, (fs)?(WS_POPUP|WS_VISIBLE):(WS_OVERLAPPEDWINDOW|WS_VISIBLE), x, y, w, h, (wp)?(wp->m_wnd):(0), 0, 0, 0); SetWindowLong(m_wnd, GWL_USERDATA, (LONG)this); ShowWindow(m_wnd, SW_SHOW); UpdateWindow(m_wnd); #elif defined(ANDROID) kgm_log() << "Init window rect: " << w << " " << h << "."; m_wRect[0] = x; m_wRect[1] = y; m_wRect[2] = w; m_wRect[3] = h; #else XSetWindowAttributes swa; int cmask = CWColormap | CWBorderPixel | CWEventMask | CWOverrideRedirect; m_dpy = (wp) ? (wp->m_dpy) : XOpenDisplay(NULL); m_screen = (wp) ? (wp->m_screen) : DefaultScreen(m_dpy); m_wnd = XCreateSimpleWindow(m_dpy, (wp)?(wp->m_wnd):RootWindow(m_dpy, 0), x, y, w, h, 0, BlackPixel(m_dpy, 0), BlackPixel(m_dpy, 0)); //m_wnd = XCreateWindow(m_dpy, DefaultRootWindow(m_dpy), x, y, w, h, 0, // DefaultDepth(m_dpy, 0), InputOutput, DefaultVisual(m_dpy, 0), // cmask, &swa); //m_wnd = XCreateWindow(m_dpy, RootWindow(m_dpy, 0), x, y, w, h, 0, // DefaultDepth(m_dpy, 0), InputOutput, DefaultVisual(m_dpy, 0), // cmask, &swa); Atom delWindow = XInternAtom( m_dpy, "WM_DELETE_WINDOW", 0 ); XSetWMProtocols(m_dpy, m_wnd, &delWindow, 1); XSelectInput(m_dpy, m_wnd, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask | ButtonMotionMask); XMapWindow(m_dpy, m_wnd); XStoreName(m_dpy, m_wnd, wname); XFlush(m_dpy); Bool b_ret; XkbSetDetectableAutoRepeat(m_dpy, True, &b_ret); #endif }
GLboolean renderspu_SystemVBoxCreateWindow( VisualInfo *visual, GLboolean showIt, WindowInfo *window ) { #if 0 HDESK desktop; #endif HINSTANCE hinstance; WNDCLASS wc; DWORD window_style; int window_plus_caption_width; int window_plus_caption_height; window->visual = visual; window->nativeWindow = 0; if ( render_spu.use_L2 ) { crWarning( "Going fullscreen because we think we're using Lightning-2." ); render_spu.fullscreen = 1; } /* * Begin Windows / WGL code */ hinstance = GetModuleHandle( NULL ); if (!hinstance) { crError( "Render SPU: Couldn't get a handle to my module." ); return GL_FALSE; } crDebug( "Render SPU: Got the module handle: 0x%x", hinstance ); #if 0 /* If we were launched from a service, telnet, or rsh, we need to * get the input desktop. */ desktop = OpenInputDesktop( 0, FALSE, DESKTOP_CREATEMENU | DESKTOP_CREATEWINDOW | DESKTOP_ENUMERATE | DESKTOP_HOOKCONTROL | DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS | DESKTOP_SWITCHDESKTOP | GENERIC_WRITE ); if ( !desktop ) { crError( "Render SPU: Couldn't acquire input desktop" ); return GL_FALSE; } crDebug( "Render SPU: Got the desktop: 0x%x", desktop ); if ( !SetThreadDesktop( desktop ) ) { /* If this function fails, it's probably because * it's already been called (i.e., the render SPU * is bolted to an application?) */ /*crError( "Couldn't set thread to input desktop" ); */ } crDebug( "Render SPU: Set the thread desktop -- this might have failed." ); #endif if ( !GetClassInfo(hinstance, WINDOW_NAME, &wc) ) { wc.style = CS_OWNDC; // | CS_PARENTDC; wc.lpfnWndProc = (WNDPROC) MainWndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hinstance; wc.hIcon = NULL; //LoadIcon( NULL, IDI_APPLICATION ); wc.hCursor = NULL; //LoadCursor( NULL, IDC_ARROW ); wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = WINDOW_NAME; if ( !RegisterClass( &wc ) ) { crError( "Render SPU: Couldn't register window class -- you're not trying " "to do multi-pipe stuff on windows, are you?\n\nNote --" "This error message is from 1997 and probably doesn't make" "any sense any more, but it's nostalgic for Humper." ); return GL_FALSE; } crDebug( "Render SPU: Registered the class" ); } crDebug( "Render SPU: Got the class information" ); /* Full screen window should be a popup (undecorated) window */ #if 1 window_style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED; if (render_spu_parent_window_id) { window_style |= WS_CHILD; } #else window_style = ( WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN ); window_style |= WS_SYSMENU; #endif crDebug( "Render SPU: Fullscreen: %s", render_spu.fullscreen ? "yes" : "no"); if ( render_spu.fullscreen ) { #if 0 int smCxFixedFrame = GetSystemMetrics( SM_CXFIXEDFRAME ); int smCyFixedFrame = GetSystemMetrics( SM_CXFIXEDFRAME ) + 1; int smCyCaption = GetSystemMetrics( SM_CYCAPTION ); window->width = GetSystemMetrics( SM_CXSCREEN ) ; window->height = GetSystemMetrics( SM_CYSCREEN ) ; crDebug( "Render SPU: Window Dims: %d, %d", window->width, window->height ); window->x = render_spu->defaultX - smCxFixedFrame - 1; window->y = render_spu->defaultY - smCyFixedFrame - smCyCaption; window_plus_caption_width = window->width + 2 * smCxFixedFrame; window_plus_caption_height = window->height + 2 * smCyFixedFrame + smCyCaption; #else /* Since it's undecorated, we don't have to do anything fancy * with these parameters. */ window->width = GetSystemMetrics( SM_CXSCREEN ) ; window->height = GetSystemMetrics( SM_CYSCREEN ) ; window->x = 0; window->y = 0; window_plus_caption_width = window->width; window_plus_caption_height = window->height; #endif } else { /* CreateWindow takes the size of the entire window, so we add * in the size necessary for the frame and the caption. */ int smCxFixedFrame, smCyFixedFrame, smCyCaption; smCxFixedFrame = GetSystemMetrics( SM_CXFIXEDFRAME ); crDebug( "Render SPU: Got the X fixed frame" ); smCyFixedFrame = GetSystemMetrics( SM_CYFIXEDFRAME ); crDebug( "Render SPU: Got the Y fixed frame" ); smCyCaption = GetSystemMetrics( SM_CYCAPTION ); crDebug( "Render SPU: Got the Caption " ); window_plus_caption_width = window->width + 2 * smCxFixedFrame; window_plus_caption_height = window->height + 2 * smCyFixedFrame + smCyCaption; window->x = render_spu.defaultX; window->y = render_spu.defaultY; } crDebug( "Render SPU: Creating the window: (%d,%d), (%d,%d)", render_spu.defaultX, render_spu.defaultY, window_plus_caption_width, window_plus_caption_height ); /*window->hWnd = CreateWindowEx( WS_EX_NOACTIVATE | WS_EX_NOPARENTNOTIFY, WINDOW_NAME, WINDOW_NAME, window_style, window->x, window->y, window->width, window->height, (void*) render_spu_parent_window_id, NULL, hinstance, &render_spu );*/ { CREATESTRUCT cs; cs.lpCreateParams = &window->hWnd; cs.dwExStyle = WS_EX_NOACTIVATE | WS_EX_NOPARENTNOTIFY; cs.lpszName = WINDOW_NAME; cs.lpszClass = WINDOW_NAME; cs.style = window_style; cs.x = window->x; cs.y = window->y; cs.cx = window->width; cs.cy = window->height; cs.hwndParent = (void*) render_spu_parent_window_id; cs.hMenu = NULL; cs.hInstance = hinstance; if (render_spu.dwWinThreadId) { DWORD res; int cnt=0; if (!PostThreadMessage(render_spu.dwWinThreadId, WM_VBOX_RENDERSPU_CREATE_WINDOW, 0, (LPARAM) &cs)) { crError("Render SPU: PostThreadMessage failed with %i", GetLastError()); return GL_FALSE; } do { res = WaitForSingleObject(render_spu.hWinThreadReadyEvent, 1000); cnt++; } while ((res!=WAIT_OBJECT_0) && (cnt<10)); crDebug("Render SPU: window thread waited %i secs", cnt); if (res!=WAIT_OBJECT_0) { crError("Render SPU: window thread not responded after %i tries", cnt); return GL_FALSE; } } else { crError("Render SPU: window thread is not running"); return GL_FALSE; } } if ( !window->hWnd ) { crError( "Render SPU: Create Window failed! That's almost certainly terrible." ); return GL_FALSE; } if (showIt) { /* NO ERROR CODE FOR SHOWWINDOW */ crDebug( "Render SPU: Showing the window" ); crDebug("renderspu_SystemVBoxCreateWindow: showwindow: %x", window->hWnd); ShowWindow( window->hWnd, SW_SHOWNORMAL ); } //SetForegroundWindow( visual->hWnd ); SetWindowPos( window->hWnd, HWND_TOP, window->x, window->y, window->width, window->height, ( render_spu.fullscreen ? (SWP_SHOWWINDOW | SWP_NOSENDCHANGING | SWP_NOREDRAW | SWP_NOACTIVATE ) : SWP_NOACTIVATE ) ); crDebug("Render SPU: SetWindowPos (%x, %d, %d, %d, %d)", window->hWnd, window->x, window->y, window->width, window->height); if ( render_spu.fullscreen ) ShowCursor( FALSE ); window->device_context = GetDC( window->hWnd ); crDebug( "Render SPU: Got the DC: 0x%x", window->device_context ); if ( !bSetupPixelFormat( window->device_context, visual->visAttribs ) ) { crError( "Render SPU: Couldn't set up the device context! Yikes!" ); return GL_FALSE; } return GL_TRUE; }
bool CheckCanCreateWindow(LPCSTR lpClassNameA, LPCWSTR lpClassNameW, DWORD& dwStyle, DWORD& dwExStyle, HWND& hWndParent, BOOL& bAttachGui, BOOL& bStyleHidden) { bAttachGui = FALSE; #ifdef _DEBUG // "!dwStyle" добавил для shell32.dll!CExecuteApplication::_CreateHiddenDDEWindow() _ASSERTE(hWndParent==NULL || ghConEmuWnd == NULL || hWndParent!=ghConEmuWnd || !dwStyle); STARTUPINFO si = {sizeof(si)}; GetStartupInfo(&si); bool lbAfxFrameOrView90 = false; if (lpClassNameA && (((DWORD_PTR)lpClassNameA) & ~0xFFFF)) { lbAfxFrameOrView90 = lstrcmpA(lpClassNameA, "AfxFrameOrView90") == 0 || lstrcmpiA(lpClassNameA, "Xshell4:MainWnd") == 0; } else if (lpClassNameW && (((DWORD_PTR)lpClassNameW) & ~0xFFFF)) { lbAfxFrameOrView90 = lstrcmpW(lpClassNameW, L"AfxFrameOrView90") == 0 || lstrcmpiW(lpClassNameW, L"Xshell4:MainWnd") == 0; } if (lbAfxFrameOrView90) { lbAfxFrameOrView90 = true; } #endif if (gbAttachGuiClient && ghConEmuWndBack) { #ifdef _DEBUG WNDCLASS wc = {}; BOOL lbClass = FALSE; if ((lpClassNameW && ((DWORD_PTR)lpClassNameW) <= 0xFFFF)) { lbClass = GetClassInfo((HINSTANCE)GetModuleHandle(NULL), lpClassNameW, &wc); } #endif DWORD nTID = GetCurrentThreadId(); if ((nTID != gnHookMainThreadId) && (gnAttachGuiClientThreadId && nTID != gnAttachGuiClientThreadId)) { _ASSERTEX(nTID==gnHookMainThreadId || !gnAttachGuiClientThreadId || (ghAttachGuiClient && IsWindow(ghAttachGuiClient))); } else { const DWORD dwNormalSized = (WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX); // Some applications can 'disable' Maximize button but they are still 'resizeable' const DWORD dwDlgSized = (WS_POPUP|WS_THICKFRAME); const DWORD dwSizedMask = (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_POPUP|DS_MODALFRAME|WS_CHILDWINDOW); const DWORD dwNoCaptionSized = (WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX); // Lets check bool lbCanAttach = // Обычное окно с заголовком (0x00CF0000 or 0x00CE0000) ((dwStyle & dwNormalSized) == dwNormalSized) // Диалог с ресайзом рамки (0x80040000) || ((dwStyle & dwDlgSized) == dwDlgSized) // Обычное окно без заголовка (0xC0070080 : 0x00070000) || ((dwStyle & dwSizedMask) == dwNoCaptionSized) ; if (dwStyle & (DS_MODALFRAME|WS_CHILDWINDOW)) lbCanAttach = false; else if ((dwStyle & WS_POPUP) && !(dwStyle & WS_THICKFRAME)) lbCanAttach = false; else if (dwExStyle & (WS_EX_TOOLWINDOW|WS_EX_TOPMOST|WS_EX_DLGMODALFRAME|WS_EX_MDICHILD)) lbCanAttach = false; // Disable attach of some window classes if (lbCanAttach && lpClassNameW && (((DWORD_PTR)lpClassNameW) & ~0xFFFF)) { if (lstrcmpW(lpClassNameW, L"MozillaTempWindowClass") == 0) lbCanAttach = false; } if (lbCanAttach) { // Родительское окно - ConEmu DC // -- hWndParent = ghConEmuWndBack; // Надо ли его ставить сразу, если не включаем WS_CHILD? // WS_CHILDWINDOW перед созданием выставлять нельзя, т.к. например у WordPad.exe сносит крышу: // все его окна создаются нормально, но он показывает ошибку "Не удалось создать новый документ" //// Уберем рамку, меню и заголовок - оставим //dwStyle = (dwStyle | WS_CHILDWINDOW|WS_TABSTOP) & ~(WS_THICKFRAME/*|WS_CAPTION|WS_MINIMIZEBOX|WS_MAXIMIZEBOX*/); bStyleHidden = (dwStyle & WS_VISIBLE) == WS_VISIBLE; dwStyle &= ~WS_VISIBLE; // А вот видимость - точно сбросим ////dwExStyle = dwExStyle & ~WS_EX_WINDOWEDGE; bAttachGui = TRUE; //gbAttachGuiClient = FALSE; // Только одно окно приложения -- сбросим после реального создания окна gbGuiClientAttached = TRUE; // Сразу взведем флажок режима #ifdef _DEBUG if (!ghGuiClientRetHook) ghGuiClientRetHook = SetWindowsHookExW(WH_CALLWNDPROCRET, GuiClientRetHook, NULL, GetCurrentThreadId()); //if (!ghGuiClientCallHook) // ghGuiClientCallHook = SetWindowsHookExW(WH_CALLWNDPROC, GuiClientCallHook, NULL, GetCurrentThreadId()); //if (!ghGuiClientMsgHook) // ghGuiClientMsgHook = SetWindowsHookExW(WH_GETMESSAGE, GuiClientMsgHook, NULL, GetCurrentThreadId()); #endif //gnAttachGuiClientThreadId = nTID; -- перенес к "ghAttachGuiClient = hWindow;" RECT rcGui = AttachGuiClientPos(dwStyle, dwExStyle); if (hWndParent != ghConEmuWndBack) { MapWindowPoints(ghConEmuWndBack, hWndParent, (LPPOINT)&rcGui, 2); } grcConEmuClient = rcGui; } return true; } } if (gbGuiClientAttached /*ghAttachGuiClient*/) { return true; // В GUI приложениях - разрешено все } #ifndef _DEBUG return true; #else if (gnHookMainThreadId && gnHookMainThreadId != GetCurrentThreadId()) return true; // Разрешено, отдается на откуп консольной программе/плагинам if ((dwStyle & (WS_POPUP|DS_MODALFRAME)) == (WS_POPUP|DS_MODALFRAME)) { // Это скорее всего обычный диалог, разрешим, но пока для отладчика - assert _ASSERTE((dwStyle & WS_POPUP) == 0); return true; } if ((lpClassNameA && ((DWORD_PTR)lpClassNameA) <= 0xFFFF) || (lpClassNameW && ((DWORD_PTR)lpClassNameW) <= 0xFFFF)) { // Что-то системное return true; } // Окно на любой чих создается. dwStyle == 0x88000000. if ((lpClassNameW && lstrcmpW(lpClassNameW, L"CicMarshalWndClass") == 0) || (lpClassNameA && lstrcmpA(lpClassNameA, "CicMarshalWndClass") == 0) ) { return true; } // WiX if ((lpClassNameW && lstrcmpW(lpClassNameW, L"MsiHiddenWindow") == 0) ) { return true; } #ifdef _DEBUG // В консоли нет обработчика сообщений, поэтому создание окон в главной // нити приводит к "зависанию" приложения - например, любые программы, // использующие DDE могут виснуть. wchar_t szModule[MAX_PATH] = {}; GetModuleFileName(ghOurModule, szModule, countof(szModule)); //const wchar_t* pszSlash = PointToName(szModule); //if (lstrcmpi(pszSlash, L"far.exe")==0 || lstrcmpi(szModule, L"far64.exe")==0) if (IsFarExe(szModule)) { _ASSERTE(dwStyle == 0 && FALSE); } //SetLastError(ERROR_THREAD_MODE_NOT_BACKGROUND); //return false; #endif // Разрешить? По настройке? return true; #endif }
virtual bool OnInit() { wxStrcat(g_strLoadOrder, GetClassInfo()->GetClassName()); return true; }
/* * A call to this function should initialize all the display stuff... */ static void ogInitializeDisplay( const char *displayName ) { #if TARGET_HOST_UNIX_X11 ogDisplay.Display = XOpenDisplay( displayName ); if( ogDisplay.Display == NULL ) ogError( "Failed to open display '%s'.", XDisplayName( displayName ) ); if( !glXQueryExtension( ogDisplay.Display, NULL, NULL ) ) ogError( "OpenGL GLX extension not supported by display '%s'.", XDisplayName( displayName ) ); ogDisplay.Screen = DefaultScreen( ogDisplay.Display ); ogDisplay.RootWindow = RootWindow( ogDisplay.Display, ogDisplay.Screen ); ogDisplay.ScreenWidth = DisplayWidth( ogDisplay.Display, ogDisplay.Screen ); ogDisplay.ScreenHeight = DisplayHeight( ogDisplay.Display, ogDisplay.Screen ); ogDisplay.ScreenWidthMM = DisplayWidthMM( ogDisplay.Display, ogDisplay.Screen ); ogDisplay.ScreenHeightMM = DisplayHeightMM( ogDisplay.Display, ogDisplay.Screen ); ogDisplay.Connection = ConnectionNumber( ogDisplay.Display ); /* Create the window deletion atom */ ogDisplay.DeleteWindow = XInternAtom( ogDisplay.Display, "WM_DELETE_WINDOW", FALSE ); #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE WNDCLASS wc; ATOM atom; /* We need to initialize the ogDisplay global structure here. */ ogDisplay.Instance = GetModuleHandle( NULL ); atom = GetClassInfo( ogDisplay.Instance, _T( OPENGLUT_STRING ), &wc ); if( !atom ) { ZeroMemory( &wc, sizeof(WNDCLASS) ); /* * Each of the windows should have its own device context, and we * want redraw events during Vertical and Horizontal Resizes by * the user. * * XXX Old code had "| CS_DBCLCKS" commented out. Plans for the * XXX future? Dead-end idea? */ #if TARGET_HOST_WIN32 wc.style = CS_OWNDC; #endif wc.style |= CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = ogWindowProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = ogDisplay.Instance; wc.hIcon = LoadIcon( ogDisplay.Instance, _T( "GLUT_ICON" ) ); if( !wc.hIcon ) wc.hIcon = LoadIcon( NULL, IDI_WINLOGO ); wc.hCursor = LoadCursor( NULL, IDC_ARROW ); wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = _T( OPENGLUT_STRING ); /* Register the window class */ atom = RegisterClass( &wc ); assert( atom ); } /* The screen dimensions can be obtained via GetSystemMetrics() calls */ ogDisplay.ScreenWidth = GetSystemMetrics( SM_CXSCREEN ); ogDisplay.ScreenHeight = GetSystemMetrics( SM_CYSCREEN ); { HWND desktop = GetDesktopWindow( ); HDC context = GetDC( desktop ); ogDisplay.ScreenWidthMM = GetDeviceCaps( context, HORZSIZE ); ogDisplay.ScreenHeightMM = GetDeviceCaps( context, VERTSIZE ); ReleaseDC( desktop, context ); } #endif ogState.Initialised = GL_TRUE; }
static void _create_glwindow( const char* title, int cw, int ch ) { WNDCLASS wndclass = {0}; DWORD wndstyle = 0; RECT rect = {0}; HWND hwnd = 0; HDC hdc = 0; HGLRC hglrc = 0; if ( !GetClassInfo( GetModuleHandle( 0 ), APP_WINDOW_CLASSNAME, &wndclass ) ) { wndclass.style = CS_OWNDC | CS_DBLCLKS; wndclass.lpfnWndProc = _window_proc; wndclass.hInstance = GetModuleHandle( 0 ); wndclass.hIcon = LoadIcon( 0, IDI_APPLICATION ); wndclass.hbrBackground = (HBRUSH)NULL; wndclass.lpszClassName = APP_WINDOW_CLASSNAME; if ( !RegisterClass( &wndclass ) ) { assert(!"RegisterClass() failed"); } } SetRect( &rect, 0, 0, cw, ch ); AdjustWindowRect( &rect, WS_OVERLAPPEDWINDOW, 0 ); if ( !( hwnd = CreateWindow( APP_WINDOW_CLASSNAME, title, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, 0, 0, wndclass.hInstance, 0 ) ) ) { assert( !"CreateWindow() failed" ); } if ( !( hdc = GetDC( hwnd ) ) ) { assert( !"GetDC() failed" ); } window.hwnd = hwnd; window.hdc = hdc; window.fullscreen = 0; window.x = rect.left; window.y = rect.top; window.w = cw; window.h = ch; window.hcursor = LoadCursor( 0, IDC_ARROW ); //app_window_setcursor( window, APP_MOUSECURSOR_ARROW ); { int pixelformat = 0; PIXELFORMATDESCRIPTOR pfd = {0}; pfd.nSize = sizeof( PIXELFORMATDESCRIPTOR ); pfd.nVersion = 1; pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cRedBits = 8; pfd.cGreenBits = 8; pfd.cBlueBits = 8; pfd.cAlphaBits = 8; pfd.cDepthBits = 0; pfd.iLayerType = PFD_MAIN_PLANE; if ( !( pixelformat = ChoosePixelFormat( window.hdc, &pfd ) ) ) { assert( !"ChoosePixelFormat() failed" ); } if ( !SetPixelFormat( window.hdc, pixelformat, &pfd ) ) { assert( !"SetPixelFormat() failed" ); } } if ( !( hglrc = wglCreateContext( window.hdc ) ) ) { assert( !"wglCreateContext() failed" ); } wglMakeCurrent(window.hdc, hglrc ); window.hglrc = hglrc; EGL_loadextensions(); ShowWindow( window.hwnd, SW_RESTORE ); SendMessage( window.hwnd, APP_WINDOW_CREATE, 0, 0 ); }
void WiEngineApp::createWindow() { WNDCLASS wc; DWORD flags = 0; DWORD exFlags = 0; ATOM atom; // Grab the window class we have registered on constructor atom = GetClassInfo(m_module, _T("WiEngine"), &wc); if(!atom) { LOGW("WiEngineApp::createWindow: No window class info found, register window class failed?"); return; } // basic flags flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // if has menu if(m_hasMenu) { flags |= WS_POPUP; exFlags |= WS_EX_TOOLWINDOW; } // check border if(!m_borderless) { flags |= WS_OVERLAPPEDWINDOW; } // check resizable if(m_resizable) { flags |= WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX; } else { flags ^= WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX; } // windows rect wyScreenConfig& sc = wyDirector::getScreenConfig(); wyRect winRect = wyr((m_desktopWidth - sc.winWidth) / 2, (m_desktopHeight - sc.winHeight) / 2, sc.winWidth, sc.winHeight); computeWindowRectFromClientArea(flags, &winRect); // create window m_hWnd = CreateWindowEx( exFlags, _T("WiEngine"), m_title, flags, winRect.x, winRect.y, winRect.width, winRect.height, NULL, NULL, m_module, NULL); if(!m_hWnd) { LOGE("WiEngineApp::createWindow: failed to create window"); return; } // Need to set requested style again, apparently Windows doesn't listen when requesting windows without title bar or borders SetWindowLong(m_hWnd, GWL_STYLE, flags); SetWindowPos(m_hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); // Make a menu window always on top if(m_hasMenu) { SetWindowPos(m_hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); } }
// Is this object a kind of (a subclass of) 'info'? // E.g. is wxWindow a kind of wxObject? // Go from this class to superclass, taking into account // two possible base classes. bool wxObject::IsKindOf(const wxClassInfo *info) const { const wxClassInfo *thisInfo = GetClassInfo(); return (thisInfo) ? thisInfo->IsKindOf(info) : false ; }
bool Win32Factory::init() { const char* vlc_name = "VLC Media Player"; const char* vlc_icon = "VLC_ICON"; const char* vlc_class = "SkinWindowClass"; // Get instance handle m_hInst = GetModuleHandle( NULL ); if( m_hInst == NULL ) { msg_Err( getIntf(), "Cannot get module handle" ); } // Create window class WNDCLASS skinWindowClass; skinWindowClass.style = CS_DBLCLKS; skinWindowClass.lpfnWndProc = (WNDPROC)Win32Factory::Win32Proc; skinWindowClass.lpszClassName = _T(vlc_class); skinWindowClass.lpszMenuName = NULL; skinWindowClass.cbClsExtra = 0; skinWindowClass.cbWndExtra = 0; skinWindowClass.hbrBackground = NULL; skinWindowClass.hCursor = LoadCursor( NULL, IDC_ARROW ); skinWindowClass.hIcon = LoadIcon( m_hInst, _T(vlc_icon) ); skinWindowClass.hInstance = m_hInst; // Register class and check it if( !RegisterClass( &skinWindowClass ) ) { WNDCLASS wndclass; // Check why it failed. If it's because the class already exists // then fine, otherwise return with an error. if( !GetClassInfo( m_hInst, _T(vlc_class), &wndclass ) ) { msg_Err( getIntf(), "cannot register window class" ); return false; } } // Create Window m_hParentWindow = CreateWindowEx( WS_EX_TOOLWINDOW, _T(vlc_class), _T(vlc_name), WS_POPUP | WS_SYSMENU | WS_MINIMIZEBOX, -200, -200, 0, 0, 0, 0, m_hInst, 0 ); if( m_hParentWindow == NULL ) { msg_Err( getIntf(), "cannot create parent window" ); return false; } // Store with it a pointer to the interface thread SetWindowLongPtr( m_hParentWindow, GWLP_USERDATA, (LONG_PTR)getIntf() ); // We do it this way otherwise CreateWindowEx will fail // if WS_EX_LAYERED is not supported SetWindowLongPtr( m_hParentWindow, GWL_EXSTYLE, GetWindowLongPtr( m_hParentWindow, GWL_EXSTYLE ) | WS_EX_LAYERED ); ShowWindow( m_hParentWindow, SW_SHOW ); // Initialize the systray icon m_trayIcon.cbSize = sizeof( NOTIFYICONDATA ); m_trayIcon.hWnd = m_hParentWindow; m_trayIcon.uID = 42; m_trayIcon.uFlags = NIF_ICON|NIF_TIP|NIF_MESSAGE; m_trayIcon.uCallbackMessage = MY_WM_TRAYACTION; m_trayIcon.hIcon = LoadIcon( m_hInst, _T(vlc_icon) ); strcpy( m_trayIcon.szTip, vlc_name ); // Show the systray icon if needed if( var_InheritBool( getIntf(), "skins2-systray" ) ) { addInTray(); } // Show the task in the task bar if needed if( var_InheritBool( getIntf(), "skins2-taskbar" ) ) { addInTaskBar(); } // Initialize the OLE library (for drag & drop) OleInitialize( NULL ); // Initialize the resource path char *datadir = config_GetUserDir( VLC_DATA_DIR ); m_resourcePath.push_back( (string)datadir + "\\skins" ); free( datadir ); datadir = config_GetDataDir( getIntf() ); m_resourcePath.push_back( (string)datadir + "\\skins" ); m_resourcePath.push_back( (string)datadir + "\\skins2" ); m_resourcePath.push_back( (string)datadir + "\\share\\skins" ); m_resourcePath.push_back( (string)datadir + "\\share\\skins2" ); free( datadir ); // All went well return true; }
// COpenHoldemApp initialization BOOL COpenHoldemApp::InitInstance() { Scintilla_RegisterClasses(AfxGetInstanceHandle()); // Initialize richedit2 library AfxInitRichEdit2(); // Change class name of Dialog WNDCLASS wc; GetClassInfo(AfxGetInstanceHandle(), "#32770", &wc); wc.lpszClassName = "OpenHoldemFormula"; wc.hIcon = AfxGetApp()->LoadIcon(IDI_ICON1); RegisterClass(&wc); // InitCommonControlsEx() is required on Windows XP if an application // manifest specifies use of ComCtl32.dll version 6 or later to enable // visual styles. Otherwise, any window creation will fail. INITCOMMONCONTROLSEX InitCtrls; InitCtrls.dwSize = sizeof(InitCtrls); // Set this to include all the common control classes you want to use // in your application. InitCtrls.dwICC = ICC_WIN95_CLASSES; InitCommonControlsEx(&InitCtrls); CWinApp::InitInstance(); // Standard initialization // If you are not using these features and wish to reduce the size // of your final executable, you should remove from the following // the specific initialization routines you do not need // Change the registry key under which our settings are stored bool load_from_registry = true; for (int i = 1; i < __argc; i++) { LPCTSTR pszParam = __targv[i]; if (_tcsncmp(pszParam, "/ini:", 5) == 0) { CString path(pszParam+5); path.Replace("~", _startup_path); free((void*)m_pszProfileName); m_pszProfileName = _strdup(path); load_from_registry = false; } if (_tcscmp(pszParam, "/ini") == 0) { CString path; path.Format("%s\\openholdem.ini", _startup_path); free((void*)m_pszProfileName); m_pszProfileName = _strdup(path); load_from_registry = false; } } if (load_from_registry) SetRegistryKey(_T("OpenHoldem")); prefs.LoadPreferences(load_from_registry); // Classes if (!p_sessioncounter) p_sessioncounter = new CSessionCounter; // Start logging immediatelly after the loading the preferences // and initializing the sessioncounter. start_log(); InstanciateAllSingletonsExceptSessionCounter(); // mouse.dll - failure in load is fatal _mouse_dll = LoadLibrary("mouse.dll"); if (_mouse_dll==NULL) { CString t = ""; t.Format("Unable to load mouse.dll, error: %d\n\nExiting.", GetLastError()); OH_MessageBox(t, "OpenHoldem mouse.dll ERROR", MB_OK | MB_TOPMOST); return false; } else { _dll_mouse_process_message = (mouse_process_message_t) GetProcAddress(_mouse_dll, "ProcessMessage"); _dll_mouse_click = (mouse_click_t) GetProcAddress(_mouse_dll, "MouseClick"); _dll_mouse_click_drag = (mouse_clickdrag_t) GetProcAddress(_mouse_dll, "MouseClickDrag"); if (_dll_mouse_process_message==NULL || _dll_mouse_click==NULL || _dll_mouse_click_drag==NULL) { CString t = ""; t.Format("Unable to find all symbols in mouse.dll"); OH_MessageBox(t, "OpenHoldem mouse.dll ERROR", MB_OK | MB_TOPMOST); FreeLibrary(_mouse_dll); _mouse_dll = NULL; return false; } } // keyboard.dll - failure in load is fatal _keyboard_dll = LoadLibrary("keyboard.dll"); if (_keyboard_dll==NULL) { CString t = ""; t.Format("Unable to load keyboard.dll, error: %d\n\nExiting.", GetLastError()); OH_MessageBox(t, "OpenHoldem keyboard.dll ERROR", MB_OK | MB_TOPMOST); return false; } else { _dll_keyboard_process_message = (keyboard_process_message_t) GetProcAddress(_keyboard_dll, "ProcessMessage"); _dll_keyboard_sendstring = (keyboard_sendstring_t) GetProcAddress(_keyboard_dll, "SendString"); _dll_keyboard_sendkey = (keyboard_sendkey_t) GetProcAddress(_keyboard_dll, "SendKey"); if (_dll_keyboard_process_message==NULL || _dll_keyboard_sendstring==NULL || _dll_keyboard_sendkey==NULL) { CString t = ""; t.Format("Unable to find all symbols in keyboard.dll"); OH_MessageBox(t, "OpenHoldem keyboard.dll ERROR", MB_OK | MB_TOPMOST); FreeLibrary(_keyboard_dll); _keyboard_dll = NULL; return false; } } MyLoadStdProfileSettings(4); // Load standard INI file options (including MRU) if (m_pRecentFileList == NULL) AfxMessageBox("Still NULL"); // Register the application's document templates. Document templates // serve as the connection between documents, frame windows and views CSingleDocTemplate* pDocTemplate; pDocTemplate = new CSingleDocTemplate( IDR_MAINFRAME, RUNTIME_CLASS(COpenHoldemDoc), RUNTIME_CLASS(CMainFrame), // main SDI frame window RUNTIME_CLASS(COpenHoldemView)); if (!pDocTemplate) return FALSE; AddDocTemplate(pDocTemplate); // Enable DDE Execute open if (load_from_registry) { EnableShellOpen(); RegisterShellFileTypes(false); } // Parse command line for standard shell commands, DDE, file open CCommandLineInfo cmdInfo; ParseCommandLine(cmdInfo); // Open the most recently saved file. (First on the MRU list.) Get the last // file from the registry. We need not account for cmdInfo.m_bRunAutomated and // cmdInfo.m_bRunEmbedded as they are processed before we get here. if (cmdInfo.m_nShellCommand == CCommandLineInfo::FileNew) { CString sLastPath(GetProfileString(_afxFileSection, "File1")); if (! sLastPath.IsEmpty()) { CFile f; // If file is there, set to open! if (f.Open(sLastPath, CFile::modeRead | CFile::shareDenyWrite)) { cmdInfo.m_nShellCommand = CCommandLineInfo::FileOpen; cmdInfo.m_strFileName = sLastPath; f.Close(); } } } // Dispatch commands specified on the command line. Will return FALSE if // app was launched with /RegServer, /Register, /Unregserver or /Unregister. if (!ProcessShellCommand(cmdInfo)) return FALSE; if (prefs.simple_window_title()) m_pMainWnd->PostMessage(WMA_SETWINDOWTEXT, 0, (LPARAM)NULL); // The one and only window has been initialized, so show and update it if (prefs.gui_start_minimized()) { m_pMainWnd->ShowWindow(SW_MINIMIZE); } else { m_pMainWnd->ShowWindow(SW_SHOW); } m_pMainWnd->UpdateWindow(); // call DragAcceptFiles only if there's a suffix // In an SDI app, this should occur after ProcessShellCommand // Enable drag/drop open m_pMainWnd->DragAcceptFiles(); // Bring main window to front m_pMainWnd->SetWindowPos(&CWnd::wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); m_pMainWnd->SetActiveWindow(); m_pMainWnd->SetFocus(); m_pMainWnd->SetForegroundWindow(); // autoconnect on start, if preferred if (prefs.autoconnector_when_to_connect() == k_AutoConnector_Connect_Once) { p_autoconnector->Connect(NULL); } // Start thread anyway; permanent connection might be enabled later via preferences. p_autoconnectorthread->StartThread(); return TRUE; }