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