Click here to Skip to main content
15,039,714 members
Articles / Desktop Programming / WPF
Posted 23 Apr 2010


23 bookmarked

WPF WindowFinder Tool

Rate me:
Please Sign up or sign in to vote.
4.67/5 (8 votes)
23 Apr 2010CPOL5 min read
A simple tool giving a nice overview about WPF techniques


Window finder is a simple WPF application that shows all the visible top level windows of the current session. It can be very useful to get back access to windows that have gone off screen, e.g. after you have undocked your laptop. While being off screen is not a real problem for top level windows - you can still use the task bar context menu to move them - it can be for popup windows that don't appear in the task bar, especially if the application remembers the position and insists on drawing it outside of the visible area even after a restart. With this little tool, you can just drag any window back to the visible area.

The functionality of this tool is not a big thing, but it nicely shows some WPF techniques in a concise project and how easy it is with WPF to have a simple implementation for simple things, so I decided to publish it here.

What Can I Get from this Article?

The WPF techniques covered here are:

  • MVVM design
  • Using an ItemsControl with a Canvas as the items panel
  • Using a ViewBox to decouple View and ViewModel coordinates
  • Dragging items inside of a ViewBox

Using the Code

Like all my WPF apps, I built this little application using the MVVM design. Even for such simple apps, it pays off using it since it really helps to keep everything simple and clear.

To have all information required to display the items, only two view models are needed: one representing each window and one holding the collection of all windows. The coordinates used in the view models are the native windows coordinates; we don't need any view related translations in the view model.

The WindowItemViewModel represents each window and has just Handle, Text, Process and Rect properties. That's all we need to display a placeholder of a window. It implements INotifyPropertyChanged so the view of the window will follow the real windows position when we change it. You may notice that the properties like Text or Process are not buffered, but will get evaluated every time the property getter is called. This is OK for properties designed to be used in binding, since the binding will anyhow call the getter just once, so buffering would be an unnecessary overhead. And if evaluating the property turns out to be slow, you could just make the binding asynchronous to speed up the display, which would not work if you had evaluated it in the constructor to feed the property with the value.

/// <summary>
/// Item view model for one item in the window list.
/// All coordinates are native window coordinates, it's up to the view 
/// to translate this properly.
/// </summary>
public class WindowItemViewModel : INotifyPropertyChanged
    /// <summary>
    /// Create a new object for the window with the given handle.
    /// </summary>
    /// <param name="handle">The handle of the window.</param>
    public WindowItemViewModel(IntPtr handle)
        this.Handle = handle;
    /// <summary>
    /// The handle of this window.
    /// </summary>
    public IntPtr Handle
        private set;
    /// <summary>
    /// The window text of this window.
    /// </summary>
    public string Text
            StringBuilder stringBuilder = new StringBuilder(256);
            NativeMethods.GetWindowText(Handle, stringBuilder, stringBuilder.Capacity);
            return stringBuilder.ToString();
    /// <summary>
    /// The process image file path.
    /// </summary>
    public string Process 
            IntPtr processIdPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(int)));
            NativeMethods.GetWindowThreadProcessId(Handle, processIdPtr);
            int processId = (int)Marshal.PtrToStructure(processIdPtr, typeof(int));
            IntPtr hProcess = NativeMethods.OpenProcess
		(NativeMethods.PROCESS_ALL_ACCESS, false, processId);
            var stringBuilder = new StringBuilder(256);
		(hProcess, stringBuilder, stringBuilder.Capacity);
            return stringBuilder.ToString();
    /// <summary>
    /// The windows rectangle.
    /// </summary>
    public Rect Rect
            NativeMethods.Rect nativeRect;
            NativeMethods.GetWindowRect(Handle, out nativeRect);
            Rect windowRect = new Rect(nativeRect.TopLeft(), nativeRect.BottomRight());
            return windowRect;
            NativeMethods.SetWindowPos(Handle, IntPtr.Zero,
                0, 0, NativeMethods.SWP_NOACTIVATE | 
		NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOZORDER);
    #region INotifyPropertyChanged Members
    private void ReportPropertyChanged(string propertyName)
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    public event PropertyChangedEventHandler PropertyChanged;

The TopLevelWindowsViewModel provides a list of all windows to show, plus the bounding rectangle of all windows to set up proper scrolling. It derives from DependencyObject so we can just use dependency properties. Looking at the code dependency properties seem to introduce a lot of typing work, but if you use the "propdp" code snippet, it turns out to be easier to handle than a simple property with INotifyPropertyChanged - and much safer! The only "written" code here is the Refresh method, that simply enumerates all windows, creates the list of item view models and calculates the bounds.

/// <summary>
/// View model for the TopLevelWindowsView. 
/// Provide a list of top level windows and some information about the space they occupy.
/// All coordinates are native window coordinates, 
/// it's up to the view to translate this properly.
/// </summary>
public class TopLevelWindowsViewModel : DependencyObject
    /// <summary>
    /// Total width needed to display all windows.
    /// </summary>
    public double TotalWidth
        get { return (double)GetValue(TotalWidthProperty); }
        set { SetValue(TotalWidthProperty, value); }
    public static readonly DependencyProperty TotalWidthProperty =
	("TotalWidth", typeof(double), typeof(TopLevelWindowsViewModel));
    /// <summary>
    /// Total height needed to display all windows.
    /// </summary>
    public double TotalHeight
        get { return (double)GetValue(TotalHeightProperty); }
        set { SetValue(TotalHeightProperty, value); }
    public static readonly DependencyProperty TotalHeightProperty =
	("TotalHeight", typeof(double), typeof(TopLevelWindowsViewModel));
    /// <summary>
    /// Margin needed to ensure all windows are displayed within the scrollable area.
    /// </summary>
    public Thickness TotalMargin
        get { return (Thickness)GetValue(TotalMarginProperty); }
        set { SetValue(TotalMarginProperty, value); }
    public static readonly DependencyProperty TotalMarginProperty =
	("TotalMargin", typeof(Thickness), typeof(TopLevelWindowsViewModel));
    /// <summary>
    /// All top level windows to display.
    /// </summary>
    public IEnumerable<WindowItemViewModel> TopLevelWindows
        get { return (IEnumerable<WindowItemViewModel>)
		GetValue(TopLevelWindowsProperty); }
        set { SetValue(TopLevelWindowsProperty, value); }
    public static readonly DependencyProperty TopLevelWindowsProperty =
	typeof(IEnumerable<WindowItemViewModel>), typeof(TopLevelWindowsViewModel));
    /// <summary>
    /// Refresh all properties.
    /// </summary>
    internal void Refresh()
        List<WindowItemViewModel> topLevelWindows = new List<WindowItemViewModel>();
        NativeMethods.EnumWindows(new NativeMethods.WNDENUMPROC(
            delegate(IntPtr hwnd, IntPtr lParam)
                if (NativeMethods.IsWindowVisible(hwnd))
                    long style = NativeMethods.GetWindowLong
				(hwnd, NativeMethods.GWL_STYLE);
                    if ((style & (NativeMethods.WS_MAXIMIZE | 
				NativeMethods.WS_MINIMIZE)) == 0)
                        topLevelWindows.Add(new WindowItemViewModel(hwnd));
                return 1;
            , IntPtr.Zero);
        // Now calculate total bounds of all windows
        double xMin = topLevelWindows.Select(window => window.Rect.Left).Min();
        double xMax = topLevelWindows.Select(window => window.Rect.Right).Max();
        double yMin = topLevelWindows.Select(window => window.Rect.Top).Min();
        double yMax = topLevelWindows.Select(window => window.Rect.Bottom).Max();
        TotalWidth = xMax - xMin;
        TotalHeight = yMax - yMin;
        TotalMargin = new Thickness(-xMin, -yMin, xMin, yMin);
        TopLevelWindows = topLevelWindows;

Now that the view models are set up, we can start designing the view:

<UserControl x:Class="WindowFinder.TopLevelWindowsView"
    <Grid DockPanel.Dock="Bottom">
      <Slider x:Name="zoom" Margin="15,5" HorizontalAlignment="Right" 
		Width="200" Minimum="0.1" Maximum="2" Value="1"/>
    <ScrollViewer HorizontalScrollBarVisibility="Auto" 
      <Viewbox Width="{Binding TotalWidth}" Height="{Binding TotalHeight}">
          <ScaleTransform ScaleX="{Binding Value, ElementName=zoom}" 
		ScaleY="{Binding Value, ElementName=zoom}"/>
        <ItemsControl ItemsSource="{Binding TopLevelWindows}" 
		Width="{Binding TotalWidth}" Height="{Binding TotalHeight}" 
		Margin="{Binding TotalMargin}">

            <Style TargetType="ContentPresenter">
              <Setter Property="Canvas.Left" Value="{Binding Rect.Left}"/>
              <Setter Property="Canvas.Top" Value="{Binding Rect.Top}"/>

              <Border SnapsToDevicePixels="True" Width="{Binding Rect.Width}" 
			Height="{Binding Rect.Height}" 
                    Background="{x:Null}" BorderThickness="1" BorderBrush="Blue" 
			CornerRadius="2" MinHeight="10" MinWidth="50"
                    ToolTip="{Binding Process}" >
                <TextBlock HorizontalAlignment="Stretch" VerticalAlignment="Top" 
			Background="Blue" Foreground="White"
                         Text="{Binding Text}" FontSize="8" 




Since we use the MVVM pattern, the control's data context is the TopLevelWindowsViewModel. We want to display a list of items, so we use an ItemsControl and bind the ItemsSource property to the TopLevelWindows property of the view model. We want to explicitly position the items, so we use a Canvas as the item control's ItemsPanel. To visualize each window, we simply draw a border and a top aligned text block, so that's how the ItemTemplate is done. The data context of each item will be a WindowItemViewModel, so we can bind to its properties. The borders width and height simply bind to the window rectangle's width and height, but if you look at the XAML you won't find the Canvas.Left and Canvas.Top binding at the borders level. Why this wouldn't work you can see if you look at the visual tree, e.g. using Snoop:


The Border, which is the root element of the item template, is not a direct child of the Canvas. The ItemsControl creates a list of ContentPresenters which then contain the item that we have designed. This seems to be a problem, since the ContentPresenter is not part of our XAML but generated by the ItemsControl when realizing the items, so it's not under our direct control. We could start writing code behind to bubble up the visual tree and find the ContentPresenter or write an ItemsContainerGenerator, but there is a much simpler solution - just using the ItemContainerStyle to access the ContentPresenter's properties as you can see in the XAML above.

Now we can display all our windows in the items presenter, but it would be a one to one mapping of the screen (we used native window coordinates in the view model), which is not the best for getting an overview, so we want to scale down everything. A ViewBox will do exactly what we need. We just have to take care that we don't mess up the scrolling, so we need to keep the aspect ratio of the ViewBox the same as the ItemsControl's. We could use a converter in the binding to scale the values down, but this would make a dynamic scaling hard, if not impossible. The easiest way to solve this in XAML without writing extra code is to simply bind the native width and height to the ViewBox and then just scale the whole view box using a layout transformation.

The final step is to add a simple drag handler to support dragging the lost windows back to the visible area. Just dragging items is a simple task; remember the initial mouse position in the mouse down event and measure the distance in each mouse move event. Since the dragging is applied against the view model and the view model is using native window coordinates, everything turns out to match perfect.

/// <summary>
/// Interaction logic for TopLevelWindowsView.xaml
/// </summary>
public partial class TopLevelWindowsView : UserControl
    public TopLevelWindowsView()
        Application.Current.MainWindow.Activated += MainWindow_Activated;
    /// <summary>
    /// The associated view model.
    /// </summary>
    private TopLevelWindowsViewModel ViewModel
            return DataContext as TopLevelWindowsViewModel;
    private void MainWindow_Activated(object sender, EventArgs e)
        // Refresh the view every time  the main window is activated - 
        // other windows positions might have changed.
    protected override void OnKeyDown(KeyEventArgs e)
        // Provide a keyboard shortcut to manually refresh the view.
        if (e.Key == Key.F5)
    #region Simple drag handler
    private Point dragStartMousePos;
    private Rect dragWindowRect;
    private void caption_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        FrameworkElement caption = (FrameworkElement)sender;
        WindowItemViewModel window = (WindowItemViewModel)caption.DataContext;
        if (window.Handle == this.GetHandle())
            // Moving our own window would cause strange flickering, don't allow this.
        // Capture the mouse and connect to the elements mouse move & button up events.
        caption.MouseLeftButtonUp += caption_MouseLeftButtonUp;
        caption.MouseMove += caption_MouseMove;
        // Remember the current mouse position and window rectangle.
        this.dragStartMousePos = e.GetPosition(caption);
        this.dragWindowRect = window.Rect;
    private void caption_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        FrameworkElement caption = (FrameworkElement)sender;
        // Stop dragging - release capture, disconnect events and refresh the view.
        caption.MouseLeftButtonUp -= caption_MouseLeftButtonUp;
        caption.MouseMove -= caption_MouseMove;
    private void caption_MouseMove(object sender, MouseEventArgs e)
        FrameworkElement caption = (FrameworkElement)sender;
        // Move the dragged window:
        Point mousePos = e.GetPosition(caption);
        Vector delta = mousePos - this.dragStartMousePos;
        // Apply changes to view model.
        WindowItemViewModel window = (WindowItemViewModel)caption.DataContext;
        window.Rect = dragWindowRect;

That's all coding. Just plug the view into the main window and the application is ready - you never need to suffer from lost popup windows again.


  • 2010/04/20 V 1.0


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Software Developer (Senior)
Germany Germany
No Biography provided

Comments and Discussions

GeneralRECT of control, not window Pin
Roman Tarasov7-Jun-11 1:43
MemberRoman Tarasov7-Jun-11 1:43 
GeneralRe: RECT of control, not window Pin
tom-englert11-Jun-11 3:29
Membertom-englert11-Jun-11 3:29 
GeneralThanks! Pin
tundres10-Aug-10 13:14
Membertundres10-Aug-10 13:14 
GeneralRegarding MVVM Pin
Leung Yat Chun (Fainx)23-Apr-10 10:28
professionalLeung Yat Chun (Fainx)23-Apr-10 10:28 
GeneralRe: Regarding MVVM Pin
tom-englert23-Apr-10 10:40
Membertom-englert23-Apr-10 10:40 
GeneralRe: Regarding MVVM Pin
Leung Yat Chun (Fainx)23-Apr-10 11:33
professionalLeung Yat Chun (Fainx)23-Apr-10 11:33 
GeneralRe: Regarding MVVM Pin
tom-englert24-Apr-10 8:06
Membertom-englert24-Apr-10 8:06 

there are several interpretations around, one of them the DataModel-View-ViewModel that additionally introduced a DataModel – but with view layer constraints like that about the threading. I don’t fully agree with this, it somehow mixes up the terms view and data. I prefer this interpretation that aligns the terms with the layers:

The data layer should have no thread affinity; it can be called and may send events in any thread. Data models are objects that represent the data layer. They should expose events to notify about changes, not bind able properties. So in my sample the data model is just the native Windows API since there was no need to wrap or extend it.

A view model, like Dan Crevier correctly states, exposes data to the view in a manner that the view can easily access. So the view model is responsible to provide everything in the UI thread, usually as bind able properties, and, if needed, commands. The key point of a view model is that it’s used as the data context of a view and the view will bind its controls properties to the properties of the view model. So all is true for both TopLevelWindowsViewModel and WindowItemViewModel – they both live in the data context of a framework element and provide properties that the view binds to – why should we call one of them data model even though they represent the same layer?

For the comment about INotifyChanged instead of DependencyObject: Just because an object derives from DependencyObject it does not mean its part of the UI – DependencyObject just provides dependency properties, they merely do the same as INotifyPropertyChanged, but type save and with built in notification – so whenever the object can afford the overhead of the DependencyObject I would recommend using it.

Finally for the caching I explicitly explained in my article why this is not needed, it would just blow up the code, adding the need to update per certain interval as you write – what would this be good for?

GeneralRe: Regarding MVVM [modified] Pin
Leung Yat Chun (Fainx)24-Apr-10 9:45
professionalLeung Yat Chun (Fainx)24-Apr-10 9:45 
GeneralRe: Regarding MVVM Pin
tom-englert25-Apr-10 5:44
Membertom-englert25-Apr-10 5:44 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.