Coder Perfect

In WPF, add a front-facing window.


What is the best way to get my WPF application to the front of the screen? So far, I’ve attempted:

SwitchToThisWindow(new WindowInteropHelper(Application.Current.MainWindow).Handle, true);

SetWindowPos(new WindowInteropHelper(Application.Current.MainWindow).Handle, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

SetForegroundWindow(new WindowInteropHelper(Application.Current.MainWindow).Handle);

None of them are up to the task (Marshal. These activities were completed successfully, according to GetLastWin32Error(), and the P/Invoke attributes for each definition do have SetLastError=true).

I’m not sure why it’s not working in my original case. If I build a fresh blank WPF program and call SwitchToThisWindow with a timer, it works perfectly.

Edit: I’m using a global hotkey to accomplish this.

Asked by Factor Mystic

Solution #1


Activates the window by attempting to bring it to the foreground.

Unless I misunderstood and you desire Always on Top behavior, that should suffice. In that situation, you’ll need:

myWindow.TopMost = true;

Answered by Morten Christiansen

Solution #2

I found a way that raises the window to the top while still allowing it to function normally:

if (!Window.IsVisible)

if (Window.WindowState == WindowState.Minimized)
    Window.WindowState = WindowState.Normal;

Window.Topmost = true;  // important
Window.Topmost = false; // important
Window.Focus();         // important

Answered by Jader Dias

Solution #3

If you want the window to be in front the first time it loads, use the following code:

private void Window_ContentRendered(object sender, EventArgs e)
    this.Topmost = false;

private void Window_Initialized(object sender, EventArgs e)
    this.Topmost = true;

Alternatively, you can override the methods:

protected override void OnContentRendered(EventArgs e)
    Topmost = false;

protected override void OnInitialized(EventArgs e)
    Topmost = true;

Answered by Amir

Solution #4

I realize this is an old issue, but I recently came across this exact scenario and wanted to share the solution I came up with.

Several of the options suggested do not work on XP, which I need to support in my case, as indicated in comments on this page. While I agree with @Matthew Xavier that this is a horrible UX strategy in general, there are situations when it is completely plausible.

The same code I’m using to offer the global hotkey supplied me with the solution for bringing a WPF window to the top. Joseph Cooney’s blog post includes a link to his code samples, which includes the original code.

I cleaned up and tweaked the code before implementing it as a System extension method. Windows. Window. I’ve tested it on both XP 32 bit and Win7 64 bit, and it works fine on both.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Interop;
using System.Runtime.InteropServices;

namespace System.Windows
    public static class SystemWindows
        #region Constants

        const UInt32 SWP_NOSIZE = 0x0001;
        const UInt32 SWP_NOMOVE = 0x0002;
        const UInt32 SWP_SHOWWINDOW = 0x0040;


        /// <summary>
        /// Activate a window from anywhere by attaching to the foreground window
        /// </summary>
        public static void GlobalActivate(this Window w)
            //Get the process ID for this window's thread
            var interopHelper = new WindowInteropHelper(w);
            var thisWindowThreadId = GetWindowThreadProcessId(interopHelper.Handle, IntPtr.Zero);

            //Get the process ID for the foreground window's thread
            var currentForegroundWindow = GetForegroundWindow();
            var currentForegroundWindowThreadId = GetWindowThreadProcessId(currentForegroundWindow, IntPtr.Zero);

            //Attach this window's thread to the current window's thread
            AttachThreadInput(currentForegroundWindowThreadId, thisWindowThreadId, true);

            //Set the window position
            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
            AttachThreadInput(currentForegroundWindowThreadId, thisWindowThreadId, false);

            //Show and activate the window
            if (w.WindowState == WindowState.Minimized) w.WindowState = WindowState.Normal;

        #region Imports

        private static extern IntPtr GetForegroundWindow();

        private static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr ProcessId);

        private static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);


I hope that this code will be useful to anyone who are having similar issues.

Answered by Zodman

Solution #5

To make this a rapid copy-paste job, use the DoOnProcess function of this class to bring the process’ primary window to the foreground (but not to steal focus from other windows)

public class MoveToForeground
    private static extern int FindWindow(String ClassName, String WindowName);

    const int SWP_NOMOVE        = 0x0002;
    const int SWP_NOSIZE        = 0x0001;            
    const int SWP_SHOWWINDOW    = 0x0040;
    const int SWP_NOACTIVATE    = 0x0010;
    [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
    public static extern IntPtr SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int x, int Y, int cx, int cy, int wFlags);

    public static void DoOnProcess(string processName)
        var allProcs = Process.GetProcessesByName(processName);
        if (allProcs.Length > 0)
            Process proc = allProcs[0];
            int hWnd = FindWindow(null, proc.MainWindowTitle.ToString());
            // Change behavior by settings the wFlags params. See
            SetWindowPos(new IntPtr(hWnd), 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE);


Answered by Hertzel Guinness

Post is based on