/* Thread safe */ static void gst_gl_window_win32_draw (GstGLWindow * window, guint width, guint height) { GstGLWindowWin32 *window_win32 = GST_GL_WINDOW_WIN32 (window); if (!window_win32->visible) { HWND parent_id = window_win32->parent_win_id; /* if no parent the real size has to be set now because this has not been done * when at window creation */ if (!parent_id) { RECT rect; GetClientRect (window_win32->internal_win_id, &rect); width += 2 * GetSystemMetrics (SM_CXSIZEFRAME); height += 2 * GetSystemMetrics (SM_CYSIZEFRAME) + GetSystemMetrics (SM_CYCAPTION); MoveWindow (window_win32->internal_win_id, rect.left, rect.top, width, height, FALSE); } ShowWindowAsync (window_win32->internal_win_id, SW_SHOW); window_win32->visible = TRUE; } RedrawWindow (window_win32->internal_win_id, NULL, NULL, RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE); }
void CDlgApplication::OnApplicationMax() { // 最大化所选择窗口 HWND hWnd=(HWND)m_wndListApp.GetItemData(m_nCurSelItem); // 在另外线程中最大化所选择窗口 ShowWindowAsync(hWnd,SW_MAXIMIZE); }
void Desktops::SwitchToDesktop(int idx) { if (_current_desktop == idx) return; Desktop& old_desktop = (*this)[_current_desktop]; WindowSet& windows = old_desktop._windows; Desktop& desktop = (*this)[idx]; windows.clear(); // collect window handles of all other desktops WindowSet other_wnds; for(const_iterator it1=begin(); it1!=end(); ++it1) for(WindowSet::const_iterator it2=it1->_windows.begin(); it2!=it1->_windows.end(); ++it2) other_wnds.insert(*it2); // save currently visible application windows EnumWindows(SwitchDesktopEnumFct, (LPARAM)&windows); old_desktop._hwndForeground = (HWND)SendMessage(g_Globals._hwndDesktopBar, PM_GET_LAST_ACTIVE, 0, 0); // hide all windows of the previous desktop for(WindowSet::iterator it=windows.begin(); it!=windows.end(); ++it) ShowWindowAsync(*it, SW_HIDE); // show all windows of the new desktop for(WindowSet::iterator it=desktop._windows.begin(); it!=desktop._windows.end(); ++it) ShowWindowAsync(*it, SW_SHOW); if (desktop._hwndForeground) SetForegroundWindow(desktop._hwndForeground); // remove the window handles of the other desktops from what we found on the previous desktop for(WindowSet::const_iterator it=other_wnds.begin(); it!=other_wnds.end(); ++it) windows.erase(*it); // We don't need to store the window handles of what's now visible the now current desktop. desktop._windows.clear(); _current_desktop = idx; }
void OnScreenDisplayWnd::Create() { RegisterClass(); m_hWnd = CreateWindowEx( WS_EX_TOPMOST | (m_isTransparent ? WS_EX_TRANSPARENT : 0) | WS_EX_TOOLWINDOW, (LPTSTR)MAKEINTRESOURCE(s_classAtom), "OSD", WS_POPUP, m_position.x, m_position.y, 0, 0, NULL, NULL, vdWindow, this); ShowWindowAsync(m_hWnd, SW_HIDE); m_transp = new Transparency(m_hWnd); m_transp->SetTransparencyLevel(m_hasBackground ? m_transpLevel : (unsigned char)255 ); }
/// minimize/restore all windows on the desktop void Desktops::ToggleMinimize() { list<MinimizeStruct>& minimized = (*this)[_current_desktop]._minimized; if (minimized.empty()) { EnumWindows(MinimizeDesktopEnumFct, (LPARAM)&minimized); } else { for(list<MinimizeStruct>::const_iterator it=minimized.begin(); it!=minimized.end(); ++it) ShowWindowAsync(it->first, it->second&WS_MAXIMIZE? SW_MAXIMIZE: SW_RESTORE); minimized.clear(); } }
void MakeWindowActive(HWND hwnd) { WINDOWPLACEMENT wpl; wpl.length = sizeof(WINDOWPLACEMENT); GetWindowPlacement(hwnd, &wpl); TRACE("GetWindowPlacement wpl.showCmd %d\n",wpl.showCmd); if (wpl.showCmd == SW_SHOWMINIMIZED) ShowWindowAsync(hwnd, SW_RESTORE); BringWindowToTop(hwnd); // same as: SetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE); ? SetForegroundWindow(hwnd); }
LRESULT _etk_show_window(EWin32GraphicsEngine *win32Engine, etk_win32_gdi_callback_t *callback) { if(win32Engine == NULL || callback == NULL || callback->command != WM_ETK_MESSAGE_SHOW_WINDOW || callback->win == NULL || callback->win->win32Window == NULL) return FALSE; EAutolock <EWin32GraphicsEngine> autolock(win32Engine); if(autolock.IsLocked() == false || win32Engine->InitCheck() != E_OK) return FALSE; ShowWindowAsync(callback->win->win32Window, callback->win->fActivateWhenShown ? SW_SHOWNORMAL : SW_SHOWNA); callback->win->fActivateWhenShown = false; return TRUE; }
// Show the result of a PDF forward-search synchronization (initiated by a DDE command) void ShowForwardSearchResult(WindowInfo *win, const WCHAR *fileName, UINT line, UINT col, UINT ret, UINT page, Vec<RectI> &rects) { win->fwdSearchMark.rects.Reset(); const PageInfo *pi = win->dm->GetPageInfo(page); if ((ret == PDFSYNCERR_SUCCESS) && (rects.Count() > 0) && (NULL != pi)) { // remember the position of the search result for drawing the rect later on win->fwdSearchMark.rects = rects; win->fwdSearchMark.page = page; win->fwdSearchMark.show = true; win->fwdSearchMark.hideStep = 0; if (!gUserPrefs->forwardSearch.highlightPermanent) SetTimer(win->hwndCanvas, HIDE_FWDSRCHMARK_TIMER_ID, HIDE_FWDSRCHMARK_DELAY_IN_MS, NULL); // Scroll to show the overall highlighted zone int pageNo = page; RectI overallrc = rects.At(0); for (size_t i = 1; i < rects.Count(); i++) overallrc = overallrc.Union(rects.At(i)); TextSel res = { 1, &pageNo, &overallrc }; if (!win->dm->PageVisible(page)) win->dm->GoToPage(page, 0, true); if (!win->dm->ShowResultRectToScreen(&res)) win->RepaintAsync(); if (IsIconic(win->hwndFrame)) ShowWindowAsync(win->hwndFrame, SW_RESTORE); return; } ScopedMem<WCHAR> buf; if (ret == PDFSYNCERR_SYNCFILE_NOTFOUND) ShowNotification(win, _TR("No synchronization file found")); else if (ret == PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED) ShowNotification(win, _TR("Synchronization file cannot be opened")); else if (ret == PDFSYNCERR_INVALID_PAGE_NUMBER) buf.Set(str::Format(_TR("Page number %u inexistant"), page)); else if (ret == PDFSYNCERR_NO_SYNC_AT_LOCATION) ShowNotification(win, _TR("No synchronization info at this position")); else if (ret == PDFSYNCERR_UNKNOWN_SOURCEFILE) buf.Set(str::Format(_TR("Unknown source file (%s)"), fileName)); else if (ret == PDFSYNCERR_NORECORD_IN_SOURCEFILE) buf.Set(str::Format(_TR("Source file %s has no synchronization point"), fileName)); else if (ret == PDFSYNCERR_NORECORD_FOR_THATLINE) buf.Set(str::Format(_TR("No result found around line %u in file %s"), line, fileName)); else if (ret == PDFSYNCERR_NOSYNCPOINT_FOR_LINERECORD) buf.Set(str::Format(_TR("No result found around line %u in file %s"), line, fileName)); if (buf) ShowNotification(win, buf); }
INT CALLBACK WinMain(HINSTANCE h_instance, HINSTANCE h_prev_instance, LPSTR cmd_line, int cmd_show) { LONG current_style = 0; /* Current style of the emacs window. */ LONG style = 0; /* New style of the emacs window. */ LONG style_ex = 0; /* New extended style of the emacs window. */ HWND insert_after = NULL; HWND emacs_window = FindWindowW(EMACS_CLASS_NAME, NULL); BOOL topmost_requested = is_topmost_requested(); if (emacs_window) { /* If window is in full-screen mode, then it will be maximized. Clear WS_MAXIMIZE bit and then compare styles. */ current_style = GetWindowLongPtrW(emacs_window, GWL_STYLE); current_style ^= WS_MAXIMIZE; /* We will toggle between full-screen/windowed modes for Emacs */ if (current_style == EMACS_FULLSCREEN_STYLE) { style = EMACS_WINDOWED_STYLE; style_ex = EMACS_WINDOWED_STYLE_EX; if (topmost_requested) { style_ex |= WS_EX_TOPMOST; insert_after = HWND_NOTOPMOST; } } else { style = EMACS_FULLSCREEN_STYLE; style_ex = EMACS_FULLSCREEN_STYLE_EX; if (topmost_requested) { style_ex |= WS_EX_TOPMOST; insert_after = HWND_TOPMOST; } } SetWindowLongPtrW(emacs_window, GWL_STYLE, style); SetWindowLongPtrW(emacs_window, GWL_EXSTYLE, style_ex); SetWindowPos(emacs_window, insert_after, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE); ShowWindowAsync(emacs_window, SW_MAXIMIZE); } else { MessageBoxW(NULL, L"Can not find emacs window.", L"Error", MB_OK | MB_ICONERROR); } return 0; }
LRESULT _etk_hide_window(EWin32GraphicsEngine *win32Engine, etk_win32_gdi_callback_t *callback) { if(win32Engine == NULL || callback == NULL || callback->command != WM_ETK_MESSAGE_HIDE_WINDOW || callback->win == NULL || callback->win->win32Window == NULL) return FALSE; EAutolock <EWin32GraphicsEngine> autolock(win32Engine); if(autolock.IsLocked() == false || win32Engine->InitCheck() != E_OK) return FALSE; ShowWindowAsync(callback->win->win32Window, SW_HIDE); GUITHREADINFO info; info.cbSize = sizeof(GUITHREADINFO); GetGUIThreadInfo(win32Engine->win32ThreadID, &info); if(info.hwndCapture == callback->win->win32Window) ReleaseCapture(); return TRUE; }
static BOOL CALLBACK MinimizeDesktopEnumFct(HWND hwnd, LPARAM lparam) { list<MinimizeStruct>& minimized = *(list<MinimizeStruct>*)lparam; if (hwnd!=g_Globals._hwndDesktopBar && hwnd!=g_Globals._hwndDesktop) if (IsWindowVisible(hwnd) && !IsIconic(hwnd)) { RECT rect; if (GetWindowRect(hwnd,&rect)) if (rect.right>0 && rect.bottom>0 && rect.right>rect.left && rect.bottom>rect.top) { minimized.push_back(MinimizeStruct(hwnd, GetWindowStyle(hwnd))); ShowWindowAsync(hwnd, SW_MINIMIZE); } } return TRUE; }
void resizeAndMoveWindowTo(HWND win, RECT area) { RECT workarea, rect; HMONITOR current_monitor; MONITORINFO monitor_info; #if (_WIN32_WINNT >= 0x0500 || _WIN32_WINDOWS >= 0x0410) current_monitor = MonitorFromWindow(main_window, MONITOR_DEFAULTTONEAREST); monitor_info.cbSize = sizeof(monitor_info); GetMonitorInfo(current_monitor, &monitor_info); workarea = monitor_info.rcWork; #else SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea, 0); #endif rect.left = workarea.left + (double)(area.left) * (double)(workarea.right - workarea.left) / BUTTON_COLS; rect.right = workarea.left + (double)(1 + area.right) * (double)(workarea.right - workarea.left) / BUTTON_COLS; rect.top = workarea.top + (double)(area.top) * (double)(workarea.bottom - workarea.top) / BUTTON_ROWS; rect.bottom = workarea.top + (double)(1 + area.bottom) * (double)(workarea.bottom - workarea.top) / BUTTON_ROWS; ShowWindowAsync(win, SW_SHOWNORMAL); SetWindowPos(win, 0, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, 0); uncheckAllButtons(); }
BOOL IRA_Dialog::Hide(HWND hwndCtl) noexcept { return ShowWindowAsync(hwndCtl, SW_HIDE); }
// HANDLE_WM_SHOWWINDOW void IRA_Dialog::OnShowWindow(HWND hwnd, BOOL fShow, UINT status) { // Regular show window seems to corrupt the color // Modeless dialogs will call this after Show() ShowWindowAsync(hwnd, static_cast<int>(fShow | status)); }
INT_PTR CALLBACK BlacklistPageDialogProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { if (msg == WM_INITDIALOG) { wchar_t txt[1000]; GetPrivateProfileString(L"Blacklist", L"ProcessBlacklist", L"", txt, ARRAY_SIZE(txt), inipath); SetDlgItemText(hwnd, IDC_PROCESSBLACKLIST, txt); GetPrivateProfileString(L"Blacklist", L"Blacklist", L"", txt, ARRAY_SIZE(txt), inipath); SetDlgItemText(hwnd, IDC_BLACKLIST, txt); GetPrivateProfileString(L"Blacklist", L"Snaplist", L"", txt, ARRAY_SIZE(txt), inipath); SetDlgItemText(hwnd, IDC_SNAPLIST, txt); } else if (msg == WM_COMMAND) { wchar_t txt[1000]; int control = LOWORD(wParam); if (HIWORD(wParam) == EN_KILLFOCUS) { Edit_GetText(GetDlgItem(hwnd,control), txt, ARRAY_SIZE(txt)); if (control == IDC_PROCESSBLACKLIST) { WritePrivateProfileString(L"Blacklist", L"ProcessBlacklist", txt, inipath); } else if (control == IDC_BLACKLIST) { WritePrivateProfileString(L"Blacklist", L"Blacklist", txt, inipath); } else if (control == IDC_SNAPLIST) { WritePrivateProfileString(L"Blacklist", L"Snaplist", txt, inipath); } UpdateSettings(); } else if (HIWORD(wParam) == STN_CLICKED && control == IDC_FINDWINDOW) { // Get size of workspace int left = GetSystemMetrics(SM_XVIRTUALSCREEN); int top = GetSystemMetrics(SM_YVIRTUALSCREEN); int width = GetSystemMetrics(SM_CXVIRTUALSCREEN); int height = GetSystemMetrics(SM_CYVIRTUALSCREEN); // Create window WNDCLASSEX wnd = { sizeof(WNDCLASSEX), 0, CursorProc, 0, 0, g_hinst, NULL, NULL, (HBRUSH)(COLOR_WINDOW+1), NULL, APP_NAME"-find", NULL }; wnd.hCursor = LoadImage(g_hinst, MAKEINTRESOURCE(IDI_FIND), IMAGE_CURSOR, 0, 0, LR_DEFAULTCOLOR); RegisterClassEx(&wnd); HWND findhwnd = CreateWindowEx(WS_EX_TOOLWINDOW|WS_EX_TOPMOST|WS_EX_LAYERED, wnd.lpszClassName, NULL, WS_POPUP, left, top, width, height, NULL, NULL, g_hinst, NULL); SetLayeredWindowAttributes(findhwnd, 0, 1, LWA_ALPHA); // Almost transparent ShowWindowAsync(findhwnd, SW_SHOWNA); // Hide icon ShowWindowAsync(GetDlgItem(hwnd,IDC_FINDWINDOW), SW_HIDE); } } else if (msg == WM_NOTIFY) { LPNMHDR pnmh = (LPNMHDR)lParam; if (pnmh->code == PSN_SETACTIVE) { // Update text SetDlgItemText(hwnd, IDC_BLACKLIST_BOX, l10n->blacklist_box); SetDlgItemText(hwnd, IDC_PROCESSBLACKLIST_HEADER, l10n->blacklist_processblacklist); SetDlgItemText(hwnd, IDC_BLACKLIST_HEADER, l10n->blacklist_blacklist); SetDlgItemText(hwnd, IDC_SNAPLIST_HEADER, l10n->blacklist_snaplist); SetDlgItemText(hwnd, IDC_BLACKLIST_EXPLANATION, l10n->blacklist_explanation); SetDlgItemText(hwnd, IDC_FINDWINDOW_BOX, l10n->blacklist_findwindow_box); SetDlgItemText(hwnd, IDC_FINDWINDOW_EXPLANATION, l10n->blacklist_findwindow_explanation); } } LinkProc(hwnd, msg, wParam, lParam); return FALSE; }
INT_PTR CALLBACK WepWindowsDlgProc( _In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam ) { PWINDOWS_CONTEXT context; if (uMsg == WM_INITDIALOG) { context = (PWINDOWS_CONTEXT)lParam; SetProp(hwndDlg, L"Context", (HANDLE)context); } else { context = (PWINDOWS_CONTEXT)GetProp(hwndDlg, L"Context"); if (uMsg == WM_DESTROY) RemoveProp(hwndDlg, L"Context"); } if (!context) return FALSE; switch (uMsg) { case WM_INITDIALOG: { PPH_STRING windowTitle; PH_RECTANGLE windowRectangle; context->TreeNewHandle = GetDlgItem(hwndDlg, IDC_LIST); WeInitializeWindowTree(hwndDlg, context->TreeNewHandle, &context->TreeContext); PhRegisterDialog(hwndDlg); PhInitializeLayoutManager(&context->LayoutManager, hwndDlg); PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_LIST), NULL, PH_ANCHOR_ALL); if (MinimumSize.left == -1) { RECT rect; rect.left = 0; rect.top = 0; rect.right = 160; rect.bottom = 100; MapDialogRect(hwndDlg, &rect); MinimumSize = rect; MinimumSize.left = 0; } // Set up the window position and size. windowRectangle.Position = PhGetIntegerPairSetting(SETTING_NAME_WINDOWS_WINDOW_POSITION); windowRectangle.Size = PhGetIntegerPairSetting(SETTING_NAME_WINDOWS_WINDOW_SIZE); PhAdjustRectangleToWorkingArea(hwndDlg, &windowRectangle); MoveWindow(hwndDlg, windowRectangle.Left, windowRectangle.Top, windowRectangle.Width, windowRectangle.Height, FALSE); // Implement cascading by saving an offsetted rectangle. windowRectangle.Left += 20; windowRectangle.Top += 20; PhSetIntegerPairSetting(SETTING_NAME_WINDOWS_WINDOW_POSITION, windowRectangle.Position); windowTitle = WepGetWindowTitleForSelector(&context->Selector); SetWindowText(hwndDlg, windowTitle->Buffer); PhDereferenceObject(windowTitle); WepRefreshWindows(context); } break; case WM_DESTROY: { PhSaveWindowPlacementToSetting(SETTING_NAME_WINDOWS_WINDOW_POSITION, SETTING_NAME_WINDOWS_WINDOW_SIZE, hwndDlg); PhDeleteLayoutManager(&context->LayoutManager); PhUnregisterDialog(hwndDlg); WeDeleteWindowTree(&context->TreeContext); WepDeleteWindowSelector(&context->Selector); PhFree(context); } break; case WM_COMMAND: { switch (LOWORD(wParam)) { case IDCANCEL: //case IDOK: DestroyWindow(hwndDlg); break; case IDC_REFRESH: WepRefreshWindows(context); break; case ID_SHOWCONTEXTMENU: { POINT point; PWE_WINDOW_NODE *windows; ULONG numberOfWindows; HMENU menu; HMENU subMenu; point.x = (SHORT)LOWORD(lParam); point.y = (SHORT)HIWORD(lParam); WeGetSelectedWindowNodes( &context->TreeContext, &windows, &numberOfWindows ); if (numberOfWindows != 0) { menu = LoadMenu(PluginInstance->DllBase, MAKEINTRESOURCE(IDR_WINDOW)); subMenu = GetSubMenu(menu, 0); SetMenuDefaultItem(subMenu, ID_WINDOW_PROPERTIES, FALSE); if (numberOfWindows == 1) { WINDOWPLACEMENT placement = { sizeof(placement) }; BYTE alpha; ULONG flags; ULONG i; ULONG id; // State GetWindowPlacement(windows[0]->WindowHandle, &placement); if (placement.showCmd == SW_MINIMIZE) PhEnableMenuItem(subMenu, ID_WINDOW_MINIMIZE, FALSE); else if (placement.showCmd == SW_MAXIMIZE) PhEnableMenuItem(subMenu, ID_WINDOW_MAXIMIZE, FALSE); else if (placement.showCmd == SW_NORMAL) PhEnableMenuItem(subMenu, ID_WINDOW_RESTORE, FALSE); // Visible CheckMenuItem(subMenu, ID_WINDOW_VISIBLE, (GetWindowLong(windows[0]->WindowHandle, GWL_STYLE) & WS_VISIBLE) ? MF_CHECKED : MF_UNCHECKED); // Enabled CheckMenuItem(subMenu, ID_WINDOW_ENABLED, !(GetWindowLong(windows[0]->WindowHandle, GWL_STYLE) & WS_DISABLED) ? MF_CHECKED : MF_UNCHECKED); // Always on Top CheckMenuItem(subMenu, ID_WINDOW_ALWAYSONTOP, (GetWindowLong(windows[0]->WindowHandle, GWL_EXSTYLE) & WS_EX_TOPMOST) ? MF_CHECKED : MF_UNCHECKED); // Opacity if (GetLayeredWindowAttributes(windows[0]->WindowHandle, NULL, &alpha, &flags)) { if (!(flags & LWA_ALPHA)) alpha = 255; } else { alpha = 255; } if (alpha == 255) { id = ID_OPACITY_OPAQUE; } else { id = 0; // Due to integer division, we cannot use simple arithmetic to calculate which menu item to check. for (i = 0; i < 10; i++) { if (alpha == (BYTE)(255 * (i + 1) / 10)) { id = ID_OPACITY_10 + i; break; } } } if (id != 0) { CheckMenuRadioItem(subMenu, ID_OPACITY_10, ID_OPACITY_OPAQUE, id, MF_BYCOMMAND); } } else { PhEnableAllMenuItems(subMenu, FALSE); PhEnableMenuItem(subMenu, ID_WINDOW_COPY, TRUE); } TrackPopupMenu( subMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON, point.x, point.y, 0, hwndDlg, NULL ); DestroyMenu(menu); } } break; case ID_WINDOW_BRINGTOFRONT: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { WINDOWPLACEMENT placement = { sizeof(placement) }; GetWindowPlacement(selectedNode->WindowHandle, &placement); if (placement.showCmd == SW_MINIMIZE) ShowWindowAsync(selectedNode->WindowHandle, SW_RESTORE); else SetForegroundWindow(selectedNode->WindowHandle); } } break; case ID_WINDOW_RESTORE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ShowWindowAsync(selectedNode->WindowHandle, SW_RESTORE); } } break; case ID_WINDOW_MINIMIZE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ShowWindowAsync(selectedNode->WindowHandle, SW_MINIMIZE); } } break; case ID_WINDOW_MAXIMIZE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ShowWindowAsync(selectedNode->WindowHandle, SW_MAXIMIZE); } } break; case ID_WINDOW_CLOSE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { PostMessage(selectedNode->WindowHandle, WM_CLOSE, 0, 0); } } break; case ID_WINDOW_VISIBLE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { if (IsWindowVisible(selectedNode->WindowHandle)) { selectedNode->WindowVisible = FALSE; ShowWindowAsync(selectedNode->WindowHandle, SW_HIDE); } else { selectedNode->WindowVisible = TRUE; ShowWindowAsync(selectedNode->WindowHandle, SW_SHOW); } PhInvalidateTreeNewNode(&selectedNode->Node, TN_CACHE_COLOR); TreeNew_InvalidateNode(context->TreeNewHandle, &selectedNode->Node); } } break; case ID_WINDOW_ENABLED: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { EnableWindow(selectedNode->WindowHandle, !IsWindowEnabled(selectedNode->WindowHandle)); } } break; case ID_WINDOW_ALWAYSONTOP: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { LOGICAL topMost; topMost = GetWindowLong(selectedNode->WindowHandle, GWL_EXSTYLE) & WS_EX_TOPMOST; SetWindowPos(selectedNode->WindowHandle, topMost ? HWND_NOTOPMOST : HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); } } break; case ID_OPACITY_10: case ID_OPACITY_20: case ID_OPACITY_30: case ID_OPACITY_40: case ID_OPACITY_50: case ID_OPACITY_60: case ID_OPACITY_70: case ID_OPACITY_80: case ID_OPACITY_90: case ID_OPACITY_OPAQUE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ULONG opacity; opacity = ((ULONG)LOWORD(wParam) - ID_OPACITY_10) + 1; if (opacity == 10) { // Remove the WS_EX_LAYERED bit since it is not needed. PhSetWindowExStyle(selectedNode->WindowHandle, WS_EX_LAYERED, 0); RedrawWindow(selectedNode->WindowHandle, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN); } else { // Add the WS_EX_LAYERED bit so opacity will work. PhSetWindowExStyle(selectedNode->WindowHandle, WS_EX_LAYERED, WS_EX_LAYERED); SetLayeredWindowAttributes(selectedNode->WindowHandle, 0, (BYTE)(255 * opacity / 10), LWA_ALPHA); } } } break; case ID_WINDOW_HIGHLIGHT: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { if (context->HighlightingWindow) { if (context->HighlightingWindowCount & 1) WeInvertWindowBorder(context->HighlightingWindow); } context->HighlightingWindow = selectedNode->WindowHandle; context->HighlightingWindowCount = 10; SetTimer(hwndDlg, 9, 100, NULL); } } break; case ID_WINDOW_GOTOTHREAD: { PWE_WINDOW_NODE selectedNode; PPH_PROCESS_ITEM processItem; PPH_PROCESS_PROPCONTEXT propContext; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { if (processItem = PhReferenceProcessItem(selectedNode->ClientId.UniqueProcess)) { if (propContext = PhCreateProcessPropContext(WE_PhMainWndHandle, processItem)) { PhSetSelectThreadIdProcessPropContext(propContext, selectedNode->ClientId.UniqueThread); PhShowProcessProperties(propContext); PhDereferenceObject(propContext); } PhDereferenceObject(processItem); } else { PhShowError(hwndDlg, L"The process does not exist."); } } } break; case ID_WINDOW_PROPERTIES: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) WeShowWindowProperties(WE_PhMainWndHandle, selectedNode->WindowHandle); } break; case ID_WINDOW_COPY: { PPH_STRING text; text = PhGetTreeNewText(context->TreeNewHandle, 0); PhSetClipboardStringEx(hwndDlg, text->Buffer, text->Length); PhDereferenceObject(text); } break; } } break; case WM_TIMER: { switch (wParam) { case 9: { WeInvertWindowBorder(context->HighlightingWindow); if (--context->HighlightingWindowCount == 0) KillTimer(hwndDlg, 9); } break; } } break; case WM_SIZE: { PhLayoutManagerLayout(&context->LayoutManager); } break; case WM_SIZING: { PhResizingMinimumSize((PRECT)lParam, wParam, MinimumSize.right, MinimumSize.bottom); } break; case WM_WE_PLUSMINUS: { PWE_WINDOW_NODE node = (PWE_WINDOW_NODE)lParam; if (!node->Opened) { TreeNew_SetRedraw(context->TreeNewHandle, FALSE); WepAddChildWindows(context, node, node->WindowHandle, NULL, NULL); node->Opened = TRUE; TreeNew_SetRedraw(context->TreeNewHandle, TRUE); } } break; } return FALSE; }
LRESULT CALLBACK window_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { GstGLWindowWin32 *window_win32; LRESULT ret = 0; if (uMsg == WM_CREATE) { window_win32 = GST_GL_WINDOW_WIN32 (((LPCREATESTRUCT) lParam)->lpCreateParams); GST_TRACE ("WM_CREATE"); window_win32->device = GetDC (hWnd); /* Do this, otherwise we hang on exit. We can still use it (due to the * CS_OWNDC flag in the WindowClass) after we have Released. */ ReleaseDC (hWnd, window_win32->device); SetProp (hWnd, "gl_window", window_win32); } else if (GetProp (hWnd, "gl_window")) { GstGLWindow *window; GstGLContext *context; GstGLContextClass *context_class; window_win32 = GST_GL_WINDOW_WIN32 (GetProp (hWnd, "gl_window")); window = GST_GL_WINDOW (window_win32); context = gst_gl_window_get_context (window); context_class = GST_GL_CONTEXT_GET_CLASS (context); g_assert (window_win32->internal_win_id == hWnd); switch (uMsg) { case WM_SIZE: { if (window->resize) { window->resize (window->resize_data, LOWORD (lParam), HIWORD (lParam)); } break; } case WM_PAINT: { if (window->draw) { PAINTSTRUCT ps; BeginPaint (hWnd, &ps); window->draw (window->draw_data); context_class->swap_buffers (context); EndPaint (hWnd, &ps); } break; } case WM_CLOSE: { ShowWindowAsync (window_win32->internal_win_id, SW_HIDE); GST_TRACE ("WM_CLOSE"); if (window->close) window->close (window->close_data); break; } case WM_CAPTURECHANGED: { GST_DEBUG ("WM_CAPTURECHANGED"); if (window->draw) window->draw (window->draw_data); break; } case WM_ERASEBKGND: { ret = TRUE; break; } default: { /* transmit messages to the parrent (ex: mouse/keyboard input) */ HWND parent_id = window_win32->parent_win_id; if (parent_id) PostMessage (parent_id, uMsg, wParam, lParam); ret = DefWindowProc (hWnd, uMsg, wParam, lParam); } } gst_object_unref (context); } else { ret = DefWindowProc (hWnd, uMsg, wParam, lParam); } return ret; }
INT_PTR CALLBACK WepWindowsPageProc( _In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam ) { PWINDOWS_CONTEXT context; LPPROPSHEETPAGE propSheetPage; PPH_PROCESS_PROPPAGECONTEXT propPageContext; PPH_PROCESS_ITEM processItem; if (PhPropPageDlgProcHeader(hwndDlg, uMsg, lParam, &propSheetPage, &propPageContext, &processItem)) { context = propPageContext->Context; } else { return FALSE; } switch (uMsg) { case WM_INITDIALOG: { context->TreeNewHandle = GetDlgItem(hwndDlg, IDC_LIST); context->SearchBoxHandle = GetDlgItem(hwndDlg, IDC_SEARCHEDIT); PhCreateSearchControl(hwndDlg, context->SearchBoxHandle, L"Search Windows (Ctrl+K)"); WeInitializeWindowTree(hwndDlg, context->TreeNewHandle, &context->TreeContext); PhRegisterDialog(hwndDlg); PhInitializeLayoutManager(&context->LayoutManager, hwndDlg); PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_SEARCHEDIT), NULL, PH_ANCHOR_TOP | PH_ANCHOR_RIGHT); PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_LIST), NULL, PH_ANCHOR_ALL); WepRefreshWindows(context); } break; case WM_SHOWWINDOW: { if (PhBeginPropPageLayout(hwndDlg, propPageContext)) PhEndPropPageLayout(hwndDlg, propPageContext); } break; case WM_DESTROY: { PhDeleteLayoutManager(&context->LayoutManager); PhUnregisterDialog(hwndDlg); WeDeleteWindowTree(&context->TreeContext); WepDeleteWindowSelector(&context->Selector); PhFree(context); } break; case WM_COMMAND: { switch (GET_WM_COMMAND_CMD(wParam, lParam)) { case EN_CHANGE: { PPH_STRING newSearchboxText; if (GET_WM_COMMAND_HWND(wParam, lParam) != context->SearchBoxHandle) break; newSearchboxText = PH_AUTO(PhGetWindowText(context->SearchBoxHandle)); if (!PhEqualString(context->TreeContext.SearchboxText, newSearchboxText, FALSE)) { PhSwapReference(&context->TreeContext.SearchboxText, newSearchboxText); if (!PhIsNullOrEmptyString(context->TreeContext.SearchboxText)) WeExpandAllWindowNodes(&context->TreeContext, TRUE); PhApplyTreeNewFilters(&context->TreeContext.FilterSupport); TreeNew_NodesStructured(context->TreeNewHandle); // PhInvokeCallback(&SearchChangedEvent, SearchboxText); } } break; } switch (GET_WM_COMMAND_ID(wParam, lParam)) { case IDC_REFRESH: WepRefreshWindows(context); break; case ID_SHOWCONTEXTMENU: { PPH_TREENEW_CONTEXT_MENU contextMenuEvent = (PPH_TREENEW_CONTEXT_MENU)lParam; PWE_WINDOW_NODE *windows; ULONG numberOfWindows; PPH_EMENU menu; PPH_EMENU selectedItem; WeGetSelectedWindowNodes( &context->TreeContext, &windows, &numberOfWindows ); if (numberOfWindows != 0) { menu = PhCreateEMenu(); PhLoadResourceEMenuItem(menu, PluginInstance->DllBase, MAKEINTRESOURCE(IDR_WINDOW), 0); PhInsertCopyCellEMenuItem(menu, ID_WINDOW_COPY, context->TreeNewHandle, contextMenuEvent->Column); PhSetFlagsEMenuItem(menu, ID_WINDOW_PROPERTIES, PH_EMENU_DEFAULT, PH_EMENU_DEFAULT); if (numberOfWindows == 1) { WINDOWPLACEMENT placement = { sizeof(placement) }; BYTE alpha; ULONG flags; ULONG i; ULONG id; // State GetWindowPlacement(windows[0]->WindowHandle, &placement); if (placement.showCmd == SW_MINIMIZE) PhSetFlagsEMenuItem(menu, ID_WINDOW_MINIMIZE, PH_EMENU_DISABLED, PH_EMENU_DISABLED); else if (placement.showCmd == SW_MAXIMIZE) PhSetFlagsEMenuItem(menu, ID_WINDOW_MAXIMIZE, PH_EMENU_DISABLED, PH_EMENU_DISABLED); else if (placement.showCmd == SW_NORMAL) PhSetFlagsEMenuItem(menu, ID_WINDOW_RESTORE, PH_EMENU_DISABLED, PH_EMENU_DISABLED); // Visible PhSetFlagsEMenuItem(menu, ID_WINDOW_VISIBLE, PH_EMENU_CHECKED, (GetWindowLong(windows[0]->WindowHandle, GWL_STYLE) & WS_VISIBLE) ? PH_EMENU_CHECKED : 0); // Enabled PhSetFlagsEMenuItem(menu, ID_WINDOW_ENABLED, PH_EMENU_CHECKED, !(GetWindowLong(windows[0]->WindowHandle, GWL_STYLE) & WS_DISABLED) ? PH_EMENU_CHECKED : 0); // Always on Top PhSetFlagsEMenuItem(menu, ID_WINDOW_ALWAYSONTOP, PH_EMENU_CHECKED, (GetWindowLong(windows[0]->WindowHandle, GWL_EXSTYLE) & WS_EX_TOPMOST) ? PH_EMENU_CHECKED : 0); // Opacity if (GetLayeredWindowAttributes(windows[0]->WindowHandle, NULL, &alpha, &flags)) { if (!(flags & LWA_ALPHA)) alpha = 255; } else { alpha = 255; } if (alpha == 255) { id = ID_OPACITY_OPAQUE; } else { id = 0; // Due to integer division, we cannot use simple arithmetic to calculate which menu item to check. for (i = 0; i < 10; i++) { if (alpha == (BYTE)(255 * (i + 1) / 10)) { id = ID_OPACITY_10 + i; break; } } } if (id != 0) { PhSetFlagsEMenuItem(menu, id, PH_EMENU_CHECKED | PH_EMENU_RADIOCHECK, PH_EMENU_CHECKED | PH_EMENU_RADIOCHECK); } } else { PhSetFlagsAllEMenuItems(menu, PH_EMENU_DISABLED, PH_EMENU_DISABLED); PhSetFlagsEMenuItem(menu, ID_WINDOW_COPY, PH_EMENU_DISABLED, 0); } selectedItem = PhShowEMenu( menu, hwndDlg, PH_EMENU_SHOW_SEND_COMMAND | PH_EMENU_SHOW_LEFTRIGHT, PH_ALIGN_LEFT | PH_ALIGN_TOP, contextMenuEvent->Location.x, contextMenuEvent->Location.y ); if (selectedItem && selectedItem->Id != -1) { BOOLEAN handled = FALSE; handled = PhHandleCopyCellEMenuItem(selectedItem); } PhDestroyEMenu(menu); } } break; case ID_WINDOW_BRINGTOFRONT: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { WINDOWPLACEMENT placement = { sizeof(placement) }; GetWindowPlacement(selectedNode->WindowHandle, &placement); if (placement.showCmd == SW_MINIMIZE) ShowWindowAsync(selectedNode->WindowHandle, SW_RESTORE); else SetForegroundWindow(selectedNode->WindowHandle); } } break; case ID_WINDOW_RESTORE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ShowWindowAsync(selectedNode->WindowHandle, SW_RESTORE); } } break; case ID_WINDOW_MINIMIZE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ShowWindowAsync(selectedNode->WindowHandle, SW_MINIMIZE); } } break; case ID_WINDOW_MAXIMIZE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ShowWindowAsync(selectedNode->WindowHandle, SW_MAXIMIZE); } } break; case ID_WINDOW_CLOSE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { PostMessage(selectedNode->WindowHandle, WM_CLOSE, 0, 0); } } break; case ID_WINDOW_VISIBLE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { if (IsWindowVisible(selectedNode->WindowHandle)) { selectedNode->WindowVisible = FALSE; ShowWindowAsync(selectedNode->WindowHandle, SW_HIDE); } else { selectedNode->WindowVisible = TRUE; ShowWindowAsync(selectedNode->WindowHandle, SW_SHOW); } PhInvalidateTreeNewNode(&selectedNode->Node, TN_CACHE_COLOR); TreeNew_InvalidateNode(context->TreeNewHandle, &selectedNode->Node); } } break; case ID_WINDOW_ENABLED: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { EnableWindow(selectedNode->WindowHandle, !IsWindowEnabled(selectedNode->WindowHandle)); } } break; case ID_WINDOW_ALWAYSONTOP: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { LOGICAL topMost; topMost = GetWindowLong(selectedNode->WindowHandle, GWL_EXSTYLE) & WS_EX_TOPMOST; SetWindowPos(selectedNode->WindowHandle, topMost ? HWND_NOTOPMOST : HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); } } break; case ID_OPACITY_10: case ID_OPACITY_20: case ID_OPACITY_30: case ID_OPACITY_40: case ID_OPACITY_50: case ID_OPACITY_60: case ID_OPACITY_70: case ID_OPACITY_80: case ID_OPACITY_90: case ID_OPACITY_OPAQUE: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { ULONG opacity; opacity = ((ULONG)LOWORD(wParam) - ID_OPACITY_10) + 1; if (opacity == 10) { // Remove the WS_EX_LAYERED bit since it is not needed. PhSetWindowExStyle(selectedNode->WindowHandle, WS_EX_LAYERED, 0); RedrawWindow(selectedNode->WindowHandle, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN); } else { // Add the WS_EX_LAYERED bit so opacity will work. PhSetWindowExStyle(selectedNode->WindowHandle, WS_EX_LAYERED, WS_EX_LAYERED); SetLayeredWindowAttributes(selectedNode->WindowHandle, 0, (BYTE)(255 * opacity / 10), LWA_ALPHA); } } } break; case ID_WINDOW_HIGHLIGHT: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { if (context->HighlightingWindow) { if (context->HighlightingWindowCount & 1) WeInvertWindowBorder(context->HighlightingWindow); } context->HighlightingWindow = selectedNode->WindowHandle; context->HighlightingWindowCount = 10; SetTimer(hwndDlg, 9, 100, NULL); } } break; case ID_WINDOW_GOTOTHREAD: { PWE_WINDOW_NODE selectedNode; PPH_PROCESS_ITEM processItem; PPH_PROCESS_PROPCONTEXT propContext; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) { if (processItem = PhReferenceProcessItem(selectedNode->ClientId.UniqueProcess)) { if (propContext = PhCreateProcessPropContext(WE_PhMainWndHandle, processItem)) { PhSetSelectThreadIdProcessPropContext(propContext, selectedNode->ClientId.UniqueThread); PhShowProcessProperties(propContext); PhDereferenceObject(propContext); } PhDereferenceObject(processItem); } else { PhShowError(hwndDlg, L"The process does not exist."); } } } break; case ID_WINDOW_PROPERTIES: { PWE_WINDOW_NODE selectedNode; if (selectedNode = WeGetSelectedWindowNode(&context->TreeContext)) WeShowWindowProperties(hwndDlg, selectedNode->WindowHandle); } break; case ID_WINDOW_COPY: { PPH_STRING text; text = PhGetTreeNewText(context->TreeNewHandle, 0); PhSetClipboardString(hwndDlg, &text->sr); PhDereferenceObject(text); } break; } } break; case WM_TIMER: { switch (wParam) { case 9: { WeInvertWindowBorder(context->HighlightingWindow); if (--context->HighlightingWindowCount == 0) KillTimer(hwndDlg, 9); } break; } } break; case WM_SIZE: PhLayoutManagerLayout(&context->LayoutManager); break; case WM_NOTIFY: { LPNMHDR header = (LPNMHDR)lParam; switch (header->code) { case PSN_QUERYINITIALFOCUS: SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LPARAM)GetDlgItem(hwndDlg, IDC_REFRESH)); return TRUE; } } break; } return FALSE; }
BOOL CConEmuChild::ShowView(int nShowCmd) { if (!this || !mh_WndDC) return FALSE; BOOL bRc = FALSE; DWORD nTID = 0, nPID = 0; wchar_t sInfo[200]; // Должно быть создано в главной нити! nTID = GetWindowThreadProcessId(mh_WndDC, &nPID); #ifdef _DEBUG DWORD nMainThreadID = GetWindowThreadProcessId(ghWnd, &nPID); _ASSERTE(nTID==nMainThreadID); #endif // Если это "GUI" режим - могут возникать блокировки из-за дочернего окна CVirtualConsole* pVCon = mp_VCon; _ASSERTE(pVCon!=NULL); CVConGuard guard(pVCon); HWND hChildGUI = pVCon->GuiWnd(); BOOL bGuiVisible = (hChildGUI && nShowCmd) ? pVCon->RCon()->isGuiVisible() : FALSE; DWORD nDcShowCmd = nShowCmd; if (gpSetCls->isAdvLogging) { if (hChildGUI != NULL) _wsprintf(sInfo, SKIPLEN(countof(sInfo)) L"ShowView: Back=x%08X, DC=x%08X, ChildGUI=x%08X, ShowCMD=%u, ChildVisible=%u", (DWORD)mh_WndBack, (DWORD)mh_WndDC, (DWORD)hChildGUI, nShowCmd, bGuiVisible); else _wsprintf(sInfo, SKIPLEN(countof(sInfo)) L"ShowView: Back=x%08X, DC=x%08X, ShowCMD=%u", (DWORD)mh_WndBack, (DWORD)mh_WndDC, nShowCmd); gpConEmu->LogString(sInfo); } if (hChildGUI || (GetCurrentThreadId() != nTID)) { // Только Async, иначе можно получить dead-lock bRc = ShowWindowAsync(mh_WndBack, nShowCmd); if (bGuiVisible && !mp_VCon->RCon()->isGuiForceConView()) nDcShowCmd = SW_HIDE; bRc = ShowWindowAsync(mh_WndDC, nDcShowCmd); } else { bRc = ShowWindow(mh_WndBack, nShowCmd); bRc = ShowWindow(mh_WndDC, nShowCmd); if (nShowCmd) { SetWindowPos(mh_WndDC, HWND_TOP, 0, 0, 0,0, SWP_NOSIZE|SWP_NOMOVE); SetWindowPos(mh_WndBack, mh_WndDC, 0, 0, 0,0, SWP_NOSIZE|SWP_NOMOVE); } } if (nShowCmd && bGuiVisible) { // Если активируется таб с ChildGui if (pVCon->isActive(false)) { PostRestoreChildFocus(); } } return bRc; }
static ULONG NTAPI GuiConsoleInputThread(PVOID Param) { NTSTATUS Status; PCSR_THREAD pcsrt = NULL; PGUI_INIT_INFO GuiInitInfo = (PGUI_INIT_INFO)Param; DESKTOP_CONSOLE_THREAD DesktopConsoleThreadInfo; ULONG_PTR InputThreadId = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread); HANDLE hThread = NULL; LONG WindowCount = 0; MSG msg; /* * This thread dispatches all the console notifications to the * notification window. It is common for all the console windows * in a given desktop in a window station. */ /* Assign this console input thread to this desktop */ DesktopConsoleThreadInfo.DesktopHandle = GuiInitInfo->Desktop; // Duplicated desktop handle DesktopConsoleThreadInfo.ThreadId = InputThreadId; Status = NtUserConsoleControl(ConsoleCtrlDesktopConsoleThread, &DesktopConsoleThreadInfo, sizeof(DesktopConsoleThreadInfo)); if (!NT_SUCCESS(Status)) goto Quit; /* Connect this CSR thread to the USER subsystem */ pcsrt = CsrConnectToUser(); if (pcsrt == NULL) goto Quit; hThread = pcsrt->ThreadHandle; /* Assign the desktop to this thread */ if (!SetThreadDesktop(DesktopConsoleThreadInfo.DesktopHandle)) goto Quit; /* The thread has been initialized, set the event */ NtSetEvent(GuiInitInfo->GuiThreadStartupEvent, NULL); Status = STATUS_SUCCESS; while (GetMessageW(&msg, NULL, 0, 0)) { switch (msg.message) { case PM_CREATE_CONSOLE: { PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam; PCONSRV_CONSOLE Console = GuiData->Console; HWND NewWindow; RECT rcWnd; DPRINT("PM_CREATE_CONSOLE -- creating window\n"); NewWindow = CreateWindowExW(WS_EX_CLIENTEDGE, GUI_CONWND_CLASS, Console->Title.Buffer, WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, GuiData->IsWindowVisible ? HWND_DESKTOP : HWND_MESSAGE, NULL, ConSrvDllInstance, (PVOID)GuiData); if (NewWindow == NULL) { DPRINT1("Failed to create a new console window\n"); continue; } ASSERT(NewWindow == GuiData->hWindow); InterlockedIncrement(&WindowCount); // // FIXME: TODO: Move everything there into conwnd.c!OnNcCreate() // /* Retrieve our real position */ // See conwnd.c!OnMove() GetWindowRect(GuiData->hWindow, &rcWnd); GuiData->GuiInfo.WindowOrigin.x = rcWnd.left; GuiData->GuiInfo.WindowOrigin.y = rcWnd.top; if (GuiData->IsWindowVisible) { /* Move and resize the window to the user's values */ /* CAN WE DEADLOCK ?? */ GuiConsoleMoveWindow(GuiData); // FIXME: This MUST be done via the CreateWindowExW call. SendMessageW(GuiData->hWindow, PM_RESIZE_TERMINAL, 0, 0); } // FIXME: HACK: Potential HACK for CORE-8129; see revision 63595. CreateSysMenu(GuiData->hWindow); if (GuiData->IsWindowVisible) { /* Switch to full-screen mode if necessary */ // FIXME: Move elsewhere, it cause misdrawings of the window. if (GuiData->GuiInfo.FullScreen) SwitchFullScreen(GuiData, TRUE); DPRINT("PM_CREATE_CONSOLE -- showing window\n"); // ShowWindow(NewWindow, (int)GuiData->GuiInfo.ShowWindow); ShowWindowAsync(NewWindow, (int)GuiData->GuiInfo.ShowWindow); DPRINT("Window showed\n"); } else { DPRINT("PM_CREATE_CONSOLE -- hidden window\n"); ShowWindowAsync(NewWindow, SW_HIDE); } continue; } case PM_DESTROY_CONSOLE: { PGUI_CONSOLE_DATA GuiData = (PGUI_CONSOLE_DATA)msg.lParam; MSG TempMsg; /* Exit the full screen mode if it was already set */ // LeaveFullScreen(GuiData); /* * Window creation is done using a PostMessage(), so it's possible * that the window that we want to destroy doesn't exist yet. * So first empty the message queue. */ /* while (PeekMessageW(&TempMsg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&TempMsg); DispatchMessageW(&TempMsg); }*/ while (PeekMessageW(&TempMsg, NULL, 0, 0, PM_REMOVE)) ; if (GuiData->hWindow == NULL) continue; DestroyWindow(GuiData->hWindow); NtSetEvent(GuiData->hGuiTermEvent, NULL); if (InterlockedDecrement(&WindowCount) == 0) { DPRINT("CONSRV: Going to quit the Input Thread 0x%p\n", InputThreadId); goto Quit; } continue; } } TranslateMessage(&msg); DispatchMessageW(&msg); } Quit: DPRINT("CONSRV: Quit the Input Thread 0x%p, Status = 0x%08lx\n", InputThreadId, Status); /* Remove this console input thread from this desktop */ // DesktopConsoleThreadInfo.DesktopHandle; DesktopConsoleThreadInfo.ThreadId = 0; NtUserConsoleControl(ConsoleCtrlDesktopConsoleThread, &DesktopConsoleThreadInfo, sizeof(DesktopConsoleThreadInfo)); /* Close the duplicated desktop handle */ CloseDesktop(DesktopConsoleThreadInfo.DesktopHandle); // NtUserCloseDesktop /* Cleanup CSR thread */ if (pcsrt) { if (hThread != pcsrt->ThreadHandle) DPRINT1("WARNING!! hThread (0x%p) != pcsrt->ThreadHandle (0x%p), you may expect crashes soon!!\n", hThread, pcsrt->ThreadHandle); CsrDereferenceThread(pcsrt); } /* Exit the thread */ RtlExitUserThread(Status); return 0; }
BOOL IRA_Dialog::Show(HWND hwndCtl) noexcept { return ShowWindowAsync(hwndCtl, SW_SHOWNORMAL); }
LRESULT CALLBACK window_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { GstGLWindowWin32 *window_win32; if (uMsg == WM_CREATE) { window_win32 = GST_GL_WINDOW_WIN32 (((LPCREATESTRUCT) lParam)->lpCreateParams); GST_TRACE ("WM_CREATE"); window_win32->device = GetDC (hWnd); /* Do this, otherwise we hang on exit. We can still use it (due to the * CS_OWNDC flag in the WindowClass) after we have Released. */ ReleaseDC (hWnd, window_win32->device); SetProp (hWnd, "gl_window", window_win32); return 0; } else if (GetProp (hWnd, "gl_window")) { GstGLWindow *window; GstGLContext *context; GstGLContextClass *context_class; window_win32 = GST_GL_WINDOW_WIN32 (GetProp (hWnd, "gl_window")); window = GST_GL_WINDOW (window_win32); context = gst_gl_window_get_context (window); context_class = GST_GL_CONTEXT_GET_CLASS (context); g_assert (window_win32->internal_win_id == hWnd); switch (uMsg) { case WM_SIZE: { if (window->resize) { window->resize (window->resize_data, LOWORD (lParam), HIWORD (lParam)); } break; } case WM_PAINT: { if (window->draw) { PAINTSTRUCT ps; BeginPaint (hWnd, &ps); window->draw (window->draw_data); context_class->swap_buffers (context); EndPaint (hWnd, &ps); } break; } case WM_CLOSE: { ShowWindowAsync (window_win32->internal_win_id, SW_HIDE); GST_TRACE ("WM_CLOSE"); if (window->close) window->close (window->close_data); break; } case WM_GST_GL_WINDOW_QUIT: { HWND parent_id = 0; GST_TRACE ("WM_GST_GL_WINDOW_QUIT"); parent_id = window_win32->parent_win_id; if (parent_id) { WNDPROC parent_proc = GetProp (parent_id, "gl_window_parent_proc"); g_assert (parent_proc); SetWindowLongPtr (parent_id, GWLP_WNDPROC, (LONG_PTR) parent_proc); SetParent (hWnd, NULL); RemoveProp (parent_id, "gl_window_parent_proc"); } window_win32->is_closed = TRUE; RemoveProp (hWnd, "gl_window"); if (window_win32->internal_win_id) { if (!DestroyWindow (window_win32->internal_win_id)) GST_WARNING ("failed to destroy window %" G_GUINTPTR_FORMAT ", 0x%x", (guintptr) hWnd, (unsigned int) GetLastError ()); } PostQuitMessage (0); break; } case WM_CAPTURECHANGED: { GST_DEBUG ("WM_CAPTURECHANGED"); if (window->draw) window->draw (window->draw_data); break; } case WM_GST_GL_WINDOW_CUSTOM: { if (!window_win32->is_closed) { GstGLMessage *message = (GstGLMessage *) wParam; _run_message (message); } break; } case WM_ERASEBKGND: return TRUE; default: { /* transmit messages to the parrent (ex: mouse/keyboard input) */ HWND parent_id = window_win32->parent_win_id; if (parent_id) PostMessage (parent_id, uMsg, wParam, lParam); return DefWindowProc (hWnd, uMsg, wParam, lParam); } } gst_object_unref (context); return 0; } else { return DefWindowProc (hWnd, uMsg, wParam, lParam); } }
void ShowProcessList() { static bool Active = false; if (Active) return; Active = true; VMenu2 ProcList(MSG(MProcessListTitle),nullptr,0,ScrY-4); ProcList.SetFlags(VMENU_WRAPMODE); ProcList.SetPosition(-1,-1,0,0); static bool bShowImage = false; struct ProcInfo pi={&ProcList,bShowImage}; if (EnumWindows(EnumWindowsProc,(LPARAM)&pi)) { ProcList.AssignHighlights(FALSE); ProcList.SetBottomTitle(MSG(MProcessListBottom)); ProcList.SortItems(TaskSort); ProcList.Run([&](int Key)->int { int KeyProcessed = 1; switch (Key) { case KEY_F1: { Help Hlp(L"TaskList"); break; } case KEY_NUMDEL: case KEY_DEL: { HWND ProcWnd=*static_cast<HWND*>(ProcList.GetUserData(nullptr,0)); if (ProcWnd) { wchar_t_ptr Title; int LenTitle=GetWindowTextLength(ProcWnd); if (LenTitle) { Title.reset(LenTitle + 1); if (Title && (LenTitle=GetWindowText(ProcWnd, Title.get(), LenTitle+1))) Title[LenTitle]=0; } DWORD ProcID; GetWindowThreadProcessId(ProcWnd,&ProcID); if (!Message(MSG_WARNING,2,MSG(MKillProcessTitle),MSG(MAskKillProcess), NullToEmpty(Title.get()),MSG(MKillProcessWarning),MSG(MKillProcessKill),MSG(MCancel))) { if (KillProcess(ProcID)) Sleep(500); else { Global->CatchError(); Message(MSG_WARNING|MSG_ERRORTYPE,1,MSG(MKillProcessTitle),MSG(MCannotKillProcess),MSG(MOk)); } } } } case KEY_CTRLR: case KEY_RCTRLR: { ProcList.DeleteItems(); if (!EnumWindows(EnumWindowsProc,(LPARAM)&pi)) ProcList.Close(-1); else ProcList.SortItems(TaskSort); break; } case KEY_F2: { pi.bShowImage=(bShowImage=!bShowImage); int SelectPos=ProcList.GetSelectPos(); ProcList.DeleteItems(); if (!EnumWindows(EnumWindowsProc,(LPARAM)&pi)) ProcList.Close(-1); else { ProcList.SortItems(TaskSort); ProcList.SetSelectPos(SelectPos); } break; } default: KeyProcessed = 0; } return KeyProcessed; }); if (ProcList.GetExitCode()>=0) { HWND ProcWnd=*static_cast<HWND*>(ProcList.GetUserData(nullptr,0)); if (ProcWnd) { //SetForegroundWindow(ProcWnd); // Allow SetForegroundWindow on Win98+. DWORD dwMs; // Remember the current value. BOOL bSPI = SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, &dwMs, 0); if (bSPI) // Reset foreground lock timeout bSPI = SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, 0, 0); SetForegroundWindow(ProcWnd); if (bSPI) // Restore old value SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, ToPtr(dwMs), 0); WINDOWPLACEMENT wp; wp.length=sizeof(wp); if (!GetWindowPlacement(ProcWnd,&wp) || wp.showCmd!=SW_SHOWMAXIMIZED) ShowWindowAsync(ProcWnd,SW_RESTORE); } } } Active = false; }