Check if something is overlapping my window? - wpf

Question

How do I check if something is overlapping my Window?
I found this WinForms code which should do the trick:
public static bool IsOverlapped(IWin32Window window)
{
if (window == null)
throw new ArgumentNullException("window");
if (window.Handle == IntPtr.Zero)
throw new InvalidOperationException("Window does not yet exist");
if (!IsWindowVisible(window.Handle))
return false;
IntPtr hWnd = window.Handle;
HashSet<IntPtr> visited = new HashSet<IntPtr> { hWnd };
// The set is used to make calling GetWindow in a loop stable by checking if we have already
// visited the window returned by GetWindow. This avoids the possibility of an infinate loop.
RECT thisRect;
GetWindowRect(hWnd, out thisRect);
while ((hWnd = GetWindow(hWnd, GW_HWNDPREV)) != IntPtr.Zero && !visited.Contains(hWnd))
{
visited.Add(hWnd);
RECT testRect, intersection;
if (IsWindowVisible(hWnd) && GetWindowRect(hWnd, out testRect) && IntersectRect(out intersection, ref thisRect, ref testRect))
return true;
}
return false;
}
[DllImport("user32.dll")]
private static extern IntPtr GetWindow(IntPtr hWnd, int uCmd);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool GetWindowRect(IntPtr hWnd, [Out] out RECT lpRect);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IntersectRect([Out] out RECT lprcDst, [In] ref RECT lprcSrc1, [In] ref RECT lprcSrc2);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool IsWindowVisible(IntPtr hWnd);
private const int GW_HWNDPREV = 3;
[StructLayout(LayoutKind.Sequential)]
private struct RECT
{
public int left;
public int top;
public int right;
public int bottom;
}
But I am not sure how to make it work on WPF, can someone help me out?
I tried a lot of things already..

Answer 1

If you want to get the handle for a given WPF window you can use the System.Windows.Interop.WindowInteropHelper class. An update to the IsOverlapped would allow you to interact with the WinForms code:
public static bool IsOverlapped(Window window)
{
if (window == null)
throw new ArgumentNullException("window");
var hWnd = new WindowInteropHelper(window).Handle;
if (hWnd == IntPtr.Zero)
throw new InvalidOperationException("Window does not yet exist");
if (!IsWindowVisible(hWnd))
return false;
HashSet<IntPtr> visited = new HashSet<IntPtr> { hWnd };
// The set is used to make calling GetWindow in a loop stable by checking if we have already
// visited the window returned by GetWindow. This avoids the possibility of an infinate loop.
RECT thisRect;
GetWindowRect(hWnd, out thisRect);
while ((hWnd = GetWindow(hWnd, GW_HWNDPREV)) != IntPtr.Zero && !visited.Contains(hWnd))
{
visited.Add(hWnd);
RECT testRect, intersection;
if (IsWindowVisible(hWnd) && GetWindowRect(hWnd, out testRect) && IntersectRect(out intersection, ref thisRect, ref testRect))
return true;
}
return false;
}

Answer 2

I solved it this way:
[System.Runtime.InteropServices.DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();
private void TmrCheckTopmost_Tick(object sender, EventArgs e)
{
if (!GetForegroundWindow().Equals(new WindowInteropHelper(this).Handle))
{
Topmost = false;
Topmost = true;
Focus();
}
}

Answer 3

public static bool IsOverlappedElement(FrameworkElement element)
{
var hwndYourWindow = ((HwndSource)PresentationSource.FromVisual(Window.GetWindow(element))).Handle;
var controlRect = GetAbsolutePlacement(element);
var overlappingWindows = GetOverlappingWindowsRectangle(WindowsListFactory.Load(), hwndYourWindow, controlRect).ToList();
return overlappingWindows.Any();
}
GetOverlappingWindowsRectangle methods inputs:
WindowsListFactory.Load() returns with all relevant active windows data
(the following github repository contains this function... click here.)
hwndYourWindow is your window which contains your UI element.
controlRect is your element path (to detect overlapping).
The following function will return with (real) windows which is overlapped your visual element (or window).
private IEnumerable<WindowEntry> GetOverlappingWindowsRectangle(IEnumerable<WindowEntry> filteredWindows, IntPtr interrupterHwnd, Rect displayedControl)
{
const uint GW_HWNDNEXT = 2;
var byHandle = filteredWindows.ToDictionary(win => win.HWnd);
for (IntPtr hWnd = GetTopWindow(IntPtr.Zero); hWnd != IntPtr.Zero; hWnd = GetWindow(hWnd, GW_HWNDNEXT))
{
if (interrupterHwnd == hWnd) break;
if (byHandle.ContainsKey(hWnd) == false) continue;
var result = GetWindowRect(new HandleRef(this, hWnd), out RECT rect);
if (result == false) continue;
byHandle[hWnd].Frame = CreateRectangle(rect);
if (displayedControl.IntersectsWith(byHandle[hWnd].Frame) == false) continue;
yield return byHandle[hWnd];
}
}
//Helper methods:
private Rect CreateRectangle(RECT rect)
{
var rectangle = new Rect();
rectangle.X = rect.Left;
rectangle.Y = rect.Top;
rectangle.Width = rect.Right - rect.Left + 1;
rectangle.Height = rect.Bottom - rect.Top + 1;
return rectangle;
}
private Rect GetAbsolutePlacement(FrameworkElement element, bool relativeToScreen = false)
{
var absolutePos = element.PointToScreen(new System.Windows.Point(0, 0));
if (relativeToScreen)
{
return new Rect(absolutePos.X, absolutePos.Y, element.ActualWidth, element.ActualHeight);
}
var posMW = Application.Current.MainWindow.PointToScreen(new System.Windows.Point(0, 0));
absolutePos = new System.Windows.Point(absolutePos.X - posMW.X, absolutePos.Y - posMW.Y);
return new Rect(absolutePos.X, absolutePos.Y, element.ActualWidth, element.ActualHeight);
}
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool GetWindowRect(HandleRef hWnd, out RECT lpRect);
[DllImport("user32.dll")]
private static extern IntPtr GetTopWindow(IntPtr hWnd);
[DllImport("User32")]
private static extern IntPtr GetWindow(IntPtr hWnd, uint wCmd);