private Image CaptureAppScreen(IntPtr handle)
{
//const int HWND_BOTTOM = 1;
const int HWND_NOTOPMOST = -2;
//const int HWND_TOP = 0;
const int HWND_TOPMOST = -1;
// Put the app window on top of the screen
IntPtr hForeWnd = User32.GetForegroundWindow();
uint dwForeID = User32.GetWindowThreadProcessId(hForeWnd, IntPtr.Zero);
uint dwCurID = User32.GetCurrentThreadId();
User32.AttachThreadInput(dwCurID, dwForeID, true);
User32.ShowWindow(handle, User32.CMDSHOW.Normal);
Thread.Sleep(250);
User32.SetWindowPos(handle, HWND_TOPMOST, 0, 0, 0, 0, User32.UINT.SWP_NOSIZE | User32.UINT.SWP_NOMOVE);
User32.SetWindowPos(handle, HWND_NOTOPMOST, 0, 0, 0, 0, User32.UINT.SWP_NOSIZE | User32.UINT.SWP_NOMOVE);
User32.SetForegroundWindow(handle);
Thread.Sleep(250);
User32.AttachThreadInput(dwCurID, dwForeID, false);
// Create a instance to store img
Rectangle rect = new Rectangle();
User32.GetWindowRect(handle, out rect);
Image img = new Bitmap(rect.Width - rect.X, rect.Height - rect.Y);
Graphics graph = Graphics.FromImage(img);
graph.CopyFromScreen(rect.X, rect.Y, 0, 0, Screen.FromHandle(handle).Bounds.Size);
return(img);
}
public static bool ForceForegroundWindow(int handle)
{
var foregroundWnd = User32.GetForegroundWindow();
if (handle == foregroundWnd)
{
return(true);
}
int ret;
var threadId1 = User32.GetWindowThreadProcessId(foregroundWnd, 0);
var threadId2 = User32.GetWindowThreadProcessId(handle, 0);
if (threadId1 != threadId2)
{
User32.AttachThreadInput(threadId1, threadId2, 1);
ret = User32.SetForegroundWindow(handle);
User32.AttachThreadInput(threadId1, threadId2, 0);
}
else
{
ret = User32.SetForegroundWindow(handle);
}
var showWindowMode = User32.IsIconic(handle) == 0 ? User32.Restore : User32.Show;
User32.ShowWindow(handle, showWindowMode);
User32.SetActiveWindow(handle);
User32.BringWindowToTop(handle);
return(ret != 0);
}
public override void ActivateForm(Window form, Window window, IntPtr hwnd)
{
var fHandle = (PresentationSource.FromVisual(form) as HwndSource).Handle;
var wHandle = (PresentationSource.FromVisual(window) as HwndSource).Handle;
if (window == null || wHandle != fHandle)
{
uint fgProcessId;
uint spProcessId;
User32.GetWindowThreadProcessId(User32.GetForegroundWindow(), out fgProcessId);
User32.GetWindowThreadProcessId(fHandle, out spProcessId);
if (fgProcessId != spProcessId)
{
if (User32.AttachThreadInput(fgProcessId, spProcessId, true))
{
User32.SetForegroundWindow(fHandle);
User32.AttachThreadInput(fgProcessId, spProcessId, false);
}
}
else
{
User32.SetForegroundWindow(fHandle);
}
// stop flashing...happens occassionally when switching quickly when activate manuver is fails
Shell32.FlashWindow(fHandle, 0);
}
}
public static bool DetachThreadInput(uint idAttach, uint idAttachTo)
{
var success = User32.AttachThreadInput(idAttach, idAttachTo, false);
if (!success)
{
var hresult = Marshal.GetHRForLastWin32Error();
Marshal.ThrowExceptionForHR(hresult);
}
return(success);
}
internal static IntPtr GetFocusedWindow()
{
var activeWindowHandle = User32.GetForegroundWindow();
var activeWindowThread = User32.GetWindowThreadProcessId(activeWindowHandle, IntPtr.Zero);
var currentThread = Kernel32.GetCurrentThreadId();
User32.AttachThreadInput(activeWindowThread, currentThread, true);
var focusedControlHandle = User32.GetFocus();
User32.AttachThreadInput(activeWindowThread, currentThread, false);
return(focusedControlHandle);
}
public void Activate(IntPtr hWnd)
{
if (hWnd == User32.GetForegroundWindow())
{
return;
}
//cmd needs to be called synchronous.
if (this.ProcessName.EndsWith("cmd.exe"))
{
if (User32.IsIconic(hWnd))
{
User32.ShowWindow(hWnd, (int)WindowState.SW_RESTORE);
}
User32.SetForegroundWindow(hWnd);
return;
}
var threadId1 = User32.GetWindowThreadProcessId(User32.GetForegroundWindow(), IntPtr.Zero);
var threadId2 = User32.GetWindowThreadProcessId(hWnd, IntPtr.Zero);
if (threadId1 != threadId2)
{
User32.AttachThreadInput(threadId1, threadId2, 1);
User32.SetForegroundWindow(hWnd);
User32.AttachThreadInput(threadId1, threadId2, 0);
}
else
{
User32.SetForegroundWindow(hWnd);
}
if (User32.IsIconic(hWnd))
{
User32.ShowWindowAsync(hWnd, (int)WindowState.SW_RESTORE);
}
else
{
if (User32.IsZoomed(hWnd))
{
User32.ShowWindowAsync(hWnd, (int)WindowState.SW_SHOWMAXIMIZED);
}
else
{
User32.ShowWindowAsync(hWnd, (int)WindowState.SW_SHOWNORMAL);
}
}
}
public static void ForceWindowIntoForeground(IntPtr window)
{
const uint LSFW_LOCK = 1;
const uint LSFW_UNLOCK = 2;
const int ASFW_ANY = -1; // by MSDN
uint currentThread = Native.GetCurrentThreadId();
IntPtr activeWindow = User32.GetForegroundWindow();
//uint activeProcess;
uint activeThread = User32.GetWindowThreadProcessId(activeWindow, IntPtr.Zero);
uint windowProcess;
uint windowThread = User32.GetWindowThreadProcessId(window, IntPtr.Zero);
if (currentThread != activeThread)
{
User32.AttachThreadInput(currentThread, activeThread, true);
}
if (windowThread != currentThread)
{
User32.AttachThreadInput(windowThread, currentThread, true);
}
uint oldTimeout = 0, newTimeout = 0;
User32.SystemParametersInfo(User32.SPI_GETFOREGROUNDLOCKTIMEOUT, 0, ref oldTimeout, 0);
User32.SystemParametersInfo(User32.SPI_SETFOREGROUNDLOCKTIMEOUT, 0, ref newTimeout, 0);
User32.LockSetForegroundWindow(LSFW_UNLOCK);
User32.AllowSetForegroundWindow(ASFW_ANY);
User32.SetForegroundWindow(window);
User32.ShowWindow(window, User32.SW.SW_RESTORE);
User32.SetFocus(window);
User32.SystemParametersInfo(User32.SPI_SETFOREGROUNDLOCKTIMEOUT, 0, ref oldTimeout, 0);
if (currentThread != activeThread)
{
User32.AttachThreadInput(currentThread, activeThread, false);
}
if (windowThread != currentThread)
{
User32.AttachThreadInput(windowThread, currentThread, false);
}
}
public static void RestoreWindow(WindowBase window)
{
try
{
// This is the only reliable method that also doesn't result in issues like this:
// https://www.reddit.com/r/playnite/comments/f6d73l/bug_full_screen_ui_wont_respond_to_left_stick/
// Adapted from https://ask.xiaolee.net/questions/1040342
window.Show();
if (!window.Activate())
{
window.Topmost = true;
window.Topmost = false;
}
if (window.WindowState == WindowState.Minimized)
{
window.WindowState = WindowState.Normal;
}
//Get the process ID for this window's thread
var interopHelper = new WindowInteropHelper(window);
var thisWindowThreadId = User32.GetWindowThreadProcessId(interopHelper.Handle, IntPtr.Zero);
//Get the process ID for the foreground window's thread
var currentForegroundWindow = User32.GetForegroundWindow();
var currentForegroundWindowThreadId = User32.GetWindowThreadProcessId(currentForegroundWindow, IntPtr.Zero);
//Attach this window's thread to the current window's thread
User32.AttachThreadInput(currentForegroundWindowThreadId, thisWindowThreadId, true);
//Set the window position
User32.SetWindowPos(interopHelper.Handle, new IntPtr(0), 0, 0, 0, 0, SWP.NOSIZE | SWP.NOMOVE | SWP.SHOWWINDOW);
//Detach this window's thread from the current window's thread
User32.AttachThreadInput(currentForegroundWindowThreadId, thisWindowThreadId, false);
}
catch (Exception e)
{
logger.Error(e, "Failed to restore window.");
}
}
/// <summary>
/// Forces the window to the foreground by attaching to the foreground window thread
/// </summary>
private void ForceForeground()
{
// This is required as there's a few restrictions on when this can be called
// Per https://msdn.microsoft.com/en-us/library/windows/desktop/ms633539%28v=vs.85%29.aspx
var targetThread = User32.GetWindowThreadProcessId(User32.GetForegroundWindow(), IntPtr.Zero);
var appThread = Kernel32.GetCurrentThreadId();
var attached = false;
try
{
if (targetThread == appThread)
{
// already attached
return;
}
attached = User32.AttachThreadInput(targetThread, appThread, true);
if (!attached)
{
// hmm
Close();
return;
}
var ourHandle = new WindowInteropHelper(this).Handle;
// force us to the forground
User32.BringWindowToTop(ourHandle);
User32.SetFocus(ourHandle);
}
finally
{
if (attached)
{
// unattach
User32.AttachThreadInput(targetThread, appThread, false);
}
}
}
public static void ShowWindow(IntPtr hWnd)
{
if (User32.GetForegroundWindow() != hWnd)
{
IntPtr dwMyThreadID = User32.GetWindowThreadProcessId(User32.GetForegroundWindow(), IntPtr.Zero);
IntPtr dwOtherThreadID = User32.GetWindowThreadProcessId(hWnd, IntPtr.Zero);
if (dwMyThreadID != dwOtherThreadID)
{
User32.AttachThreadInput(dwMyThreadID, dwOtherThreadID, true);
User32.BringWindowToTop(hWnd);
User32.SetForegroundWindow(hWnd);
IntPtr hMain = User32.GetWindow(hWnd, WinBase.GW_ENABLEDPOPUP);
User32.SetFocus(hMain);
User32.AttachThreadInput(dwMyThreadID, dwOtherThreadID, false);
}
else
{
User32.SetForegroundWindow(hWnd);
}
}
}
/// <summary>
/// Sets the focus by using the Win32 SetFocus() method.
/// </summary>
public void FocusNative()
{
if (Properties.NativeWindowHandle.IsSupported)
{
var windowHandle = Properties.NativeWindowHandle.ValueOrDefault;
if (windowHandle != Win32Constants.FALSE)
{
uint windowThreadId = User32.GetWindowThreadProcessId(windowHandle, out _);
uint currentThreadId = Kernel32.GetCurrentThreadId();
// attach window to the calling thread's message queue
User32.AttachThreadInput(currentThreadId, windowThreadId, true);
User32.SetFocus(windowHandle);
// detach the window from the calling thread's message queue
User32.AttachThreadInput(currentThreadId, windowThreadId, false);
Wait.UntilResponsive(this);
return;
}
}
// Fallback to the UIA Version
SetFocus();
}
private static string GetWindowControlText(IntPtr hWnd)
{
string text = null;
try
{
int cid = Kernel32.GetCurrentThreadId();
int tid = User32.GetWindowThreadProcessId(hWnd, IntPtr.Zero);
User32.AttachThreadInput(tid, cid, true);
{
IntPtr hFocus = User32.GetFocus();
if (hFocus != IntPtr.Zero)
{
StringBuilder sb = new StringBuilder(4096);
User32.SendMessage(hFocus, User32.WM_GETTEXT, 4096, sb);
text = sb.ToString();
}
}
User32.AttachThreadInput(tid, cid, false);
}
catch (Exception ex) { TraceLogger.Instance.WriteException(ex); }
return(text);
}
/// <summary>
/// Convert VKCode to Unicode.
/// <remarks>isKeyDown is required for because of keyboard state inconsistencies!</remarks>
/// </summary>
/// <param name="VKCode">VKCode</param>
/// <param name="isKeyDown">Is the key down event?</param>
/// <returns>String representing single unicode character.</returns>
protected string VirtualKey2String(uint VKCode, bool isKeyDown)
{
// ToUnicodeEx needs StringBuilder, it populates that during execution.
var sbString = new StringBuilder(5);
byte[] bKeyState = new byte[255];
bool bKeyStateStatus;
bool isDead = false;
// Gets the current windows window handle, threadID, processID
IntPtr currentHWnd = User32.GetForegroundWindow();
uint currentWindowThreadID = User32.GetWindowThreadProcessId(currentHWnd, out uint currentProcessID);
// This programs Thread ID
uint thisProgramThreadId = Kernel32.GetCurrentThreadId();
// Attach to active thread so we can get that keyboard state
if (User32.AttachThreadInput(thisProgramThreadId, currentWindowThreadID, true))
{
// Current state of the modifiers in keyboard
bKeyStateStatus = User32.GetKeyboardState(bKeyState);
// Detach
User32.AttachThreadInput(thisProgramThreadId, currentWindowThreadID, false);
}
else
{
// Could not attach, perhaps it is this process?
bKeyStateStatus = User32.GetKeyboardState(bKeyState);
}
// On failure we return empty string.
if (!bKeyStateStatus)
{
return("");
}
// Gets the layout of keyboard
IntPtr HKL = User32.GetKeyboardLayout(currentWindowThreadID);
// Maps the virtual keycode
uint lScanCode = User32.MapVirtualKeyEx(VKCode, (uint)MapVirtualKeyMapTypes.VirtualKey2ScanCode, HKL);
// Keyboard state goes inconsistent if this is not in place. In other words, we need to call above commands in UP events also.
if (!isKeyDown)
{
return("");
}
// Converts the VKCode to unicode
int relevantKeyCountInBuffer = User32.ToUnicodeEx(VKCode, lScanCode, bKeyState, sbString, sbString.Capacity, (uint)0, HKL);
var result = "";
switch (relevantKeyCountInBuffer)
{
// Dead keys (^,`...)
case -1:
isDead = true;
// We must clear the buffer because ToUnicodeEx messed it up, see below.
ClearKeyboardBuffer(VKCode, lScanCode, HKL);
break;
case 0:
break;
// Single character in buffer
case 1:
result = sbString[0].ToString();
break;
// Two or more (only two of them is relevant)
case 2:
default:
result = sbString.ToString().Substring(0, 2);
break;
}
// We inject the last dead key back, since ToUnicodeEx removed it.
// More about this peculiar behavior see e.g:
// http://www.experts-exchange.com/Programming/System/Windows__Programming/Q_23453780.html
// http://blogs.msdn.com/michkap/archive/2005/01/19/355870.aspx
// http://blogs.msdn.com/michkap/archive/2007/10/27/5717859.aspx
if (_lastVKCode != 0 && _lastIsDead)
{
var sbTemp = new StringBuilder(5);
User32.ToUnicodeEx(_lastVKCode, _lastScanCode, _lastKeyState, sbTemp, sbTemp.Capacity, 0, HKL);
_lastVKCode = 0;
return(result);
}
// Save these
_lastScanCode = lScanCode;
_lastVKCode = VKCode;
_lastIsDead = isDead;
_lastKeyState = (byte[])bKeyState.Clone();
return(result);
}
public override void ActivateForm(Window form, Window window, IntPtr hwnd)
{
var fHandle = (PresentationSource.FromVisual(form) as HwndSource).Handle;
var wHandle = window == null ? IntPtr.Zero : (PresentationSource.FromVisual(window) as HwndSource).Handle;
if (window == null || wHandle != fHandle)
{
IntPtr Dummy = IntPtr.Zero;
IntPtr hWnd = fHandle;
if (User32.IsIconic(hWnd))
{
User32.ShowWindowAsync(hWnd, SW_RESTORE);
}
else
{
//User32.ShowWindowAsync(hWnd, SW_SHOW);
form.ShowActivated = true;
form.Show();
}
User32.SetForegroundWindow(hWnd);
form.Activate();
form.Topmost = true;
form.Topmost = false;
// Code from Karl E. Peterson, www.mvps.org/vb/sample.htm
// Converted to Delphi by Ray Lischner
// Published in The Delphi Magazine 55, page 16
// Converted to C# by Kevin Gale
IntPtr foregroundWindow = User32.GetForegroundWindow();
if (foregroundWindow != hWnd)
{
uint foregroundThreadId = User32.GetWindowThreadProcessId(foregroundWindow, Dummy);
uint thisThreadId = User32.GetWindowThreadProcessId(hWnd, Dummy);
if (User32.AttachThreadInput(thisThreadId, foregroundThreadId, true))
{
form.Activate();
form.Topmost = true;
form.Topmost = false;
User32.BringWindowToTop(hWnd); // IE 5.5 related hack
User32.SetForegroundWindow(hWnd);
User32.AttachThreadInput(thisThreadId, foregroundThreadId, false);
}
}
if (User32.GetForegroundWindow() != hWnd)
{
// Code by Daniel P. Stasinski
// Converted to C# by Kevin Gale
IntPtr Timeout = IntPtr.Zero;
User32.SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, Timeout, 0);
User32.SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, Dummy, SPIF_SENDCHANGE);
User32.BringWindowToTop(hWnd); // IE 5.5 related hack
User32.SetForegroundWindow(hWnd);
form.Activate();
form.Topmost = true;
form.Topmost = false;
User32.SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, Timeout, SPIF_SENDCHANGE);
}
Shell32.FlashWindow(fHandle, 0);
}
}