Вынести окно на передний план в WPF

Хорошо, я понял, как обойтись. Я звоню с клавиатуры, которая используется для горячей клавиши. Вызов работает должным образом, если я помещаю его в BackgroundWorker с паузой. Это кладж, но я понятия не имею, почему он изначально не работал.

void hotkey_execute()
{
    IntPtr handle = new WindowInteropHelper(Application.Current.MainWindow).Handle;
    BackgroundWorker bg = new BackgroundWorker();
    bg.DoWork += new DoWorkEventHandler(delegate
        {
            Thread.Sleep(10);
            SwitchToThisWindow(handle, true);
        });
    bg.RunWorkerAsync();
}

myWindow.Activate();

Пытается вывести окно на передний план и активирует его.

Это должно помочь, если я неправильно понял, и вы не хотите, чтобы поведение всегда было на вершине. В таком случае вам нужно:

myWindow.TopMost = true;

Если пользователь взаимодействует с другим приложением, возможно, не удастся вывести ваше на передний план. Как правило, процесс может ожидать установки окна переднего плана только в том случае, если этот процесс уже является процессом переднего плана. (Microsoft документирует ограничения в записи MSDN SetForegroundWindow ().) Это потому, что:

1. Пользователь «владеет» передним планом. Например, было бы очень неприятно, если бы другая программа украла передний план, пока пользователь печатает, по крайней мере, прерывая его рабочий процесс и, возможно, вызывая непредвиденные последствия, поскольку ее нажатия клавиш, предназначенные для одного приложения, неправильно интерпретируются злоумышленником, пока он не заметит изменение. .
2. Представьте, что каждая из двух программ проверяет, является ли ее окно передним планом, и пытается установить его на передний план, если это не так. Как только вторая программа запускается, компьютер становится бесполезным, поскольку передний план перескакивает между ними при каждом переключении задач.

Проблема может заключаться в том, что поток, вызывающий ваш код из ловушки, не был инициализирован средой выполнения, поэтому вызов методов среды выполнения не работает.

Возможно, вы могли бы попробовать выполнить Invoke для маршалинга вашего кода в поток пользовательского интерфейса, чтобы вызвать ваш код, который выводит окно на передний план.

Если вам нужно, чтобы окно было впереди при первой загрузке, вы должны использовать следующее:

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

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

У меня была аналогичная проблема с приложением WPF, которое вызывается из приложения Access через объект Shell.

Мое решение ниже - работает в XP и Win7 x64 с приложением, скомпилированным для цели x86.

Я бы лучше сделал это, чем имитировал бы alt-tab.

void Window_Loaded(object sender, RoutedEventArgs e)
{
    // make sure the window is normal or maximised
    // this was the core of the problem for me;
    // even though the default was "Normal", starting it via shell minimised it
    this.WindowState = WindowState.Normal;

    // only required for some scenarios
    this.Activate();
}

Чтобы показать ЛЮБОЕ открытое в данный момент окно, импортируйте эту DLL:

public partial class Form1 : Form
{
    [DllImportAttribute("User32.dll")]
    private static extern int FindWindow(String ClassName, String WindowName);
    [DllImportAttribute("User32.dll")]
    private static extern int SetForegroundWindow(int hWnd);

и в программе ищем приложение с указанным заголовком (пишем заголовок без первой буквы (индекс> 0))

  foreach (Process proc in Process.GetProcesses())
                {
                    tx = proc.MainWindowTitle.ToString();
                    if (tx.IndexOf("Title of Your app WITHOUT FIRST LETTER") > 0)
                    {
                        tx = proc.MainWindowTitle;
                        hWnd = proc.Handle.ToInt32(); break;
                    }
                }
                hWnd = FindWindow(null, tx);
                if (hWnd > 0)
                {
                    SetForegroundWindow(hWnd);
                }

Я нашел решение, которое выводит окно наверх, но ведет себя как обычное окно:

if (!Window.IsVisible)
{
    Window.Show();
}

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

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

Чтобы сделать это быстро скопируйте и вставьте один -
Используйте метод DoOnProcess этого класса, чтобы переместить главное окно процесса на передний план (но не для кражи фокуса из других окон)

public class MoveToForeground
{
    [DllImportAttribute("User32.dll")]
    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 http://msdn.microsoft.com/en-us/library/ms633545(VS.85).aspx
            SetWindowPos(new IntPtr(hWnd), 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE);
        }
    }
}

HTH

Я знаю, что этот вопрос довольно старый, но я только что наткнулся на этот точный сценарий и хотел поделиться решением, которое я реализовал.

Как упоминалось в комментариях на этой странице, некоторые из предложенных решений не работают в XP, что мне нужно поддерживать в моем сценарии. Хотя я согласен с мнением @Matthew Xavier, что в целом это плохая практика UX, бывают случаи, когда это вполне правдоподобный UX.

Решение для вывода окна WPF наверх было фактически предоставлено мне тем же кодом, который я использую для предоставления глобальной горячей клавиши. Статья в блоге Джозефа Куни содержит ссылка на его образцы кода, который содержит исходный код.

Я немного очистил и изменил код и реализовал его как метод расширения для System.Windows.Window. Я тестировал это на 32-разрядной версии XP и 64-разрядной версии Win7, оба из которых работают правильно.

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;

        #endregion

        /// <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;
            w.Show();
            w.Activate();
        }

        #region Imports

        [DllImport("user32.dll")]
        private static extern IntPtr GetForegroundWindow();

        [DllImport("user32.dll")]
        private static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr ProcessId);

        [DllImport("user32.dll")]
        private static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

        [DllImport("user32.dll")]
        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

        #endregion
    }
}

Надеюсь, этот код поможет другим, столкнувшимся с этой проблемой.

Что ж, раз это такая горячая тема ... вот что мне подходит. У меня были ошибки, если я этого не сделал, потому что Activate () выдаст ошибку, если вы не видите окно.

Xaml:

<Window .... 
        Topmost = "True" 
        .... 
        ContentRendered = "mainWindow_ContentRendered"> .... </Window>

Код позади:

private void mainWindow_ContentRendered(object sender, EventArgs e)
{
    this.Topmost = false;
    this.Activate();
    _UsernameTextBox.Focus();
}

Для меня это был единственный способ показать окно сверху. Затем активируйте его, чтобы вы могли вводить текст в поле, не устанавливая фокус с помощью мыши. control.Focus () не будет работать, если окно не активировано ();

Если вы пытаетесь скрыть окно, например, сворачиваете окно, я обнаружил, что с помощью

    this.Hide();

скроет его правильно, тогда просто используя

    this.Show();

затем снова отобразит окно как самый верхний элемент.

Я знаю, что это запоздалый ответ, может быть, полезно для исследователей

 if (!WindowName.IsVisible)
 {
     WindowName.Show();
     WindowName.Activate();
 }

Почему некоторые ответы на этой странице неверны!

• Любой ответ, в котором используется window.Focus(), неверен.

  • Почему? Если появится сообщение с уведомлением, window.Focus() отвлечет внимание от всего, что пользователь набирает в данный момент. Это безумно расстраивает конечных пользователей, особенно если всплывающие окна появляются довольно часто.

• Любой ответ, в котором используется window.Activate(), неверен.

  • Почему? Он также сделает видимыми все родительские окна.
• Любой ответ, в котором отсутствует window.ShowActivated = false, неверен.
  • Почему? Когда всплывает сообщение, он отвлекает внимание от другого окна, что очень раздражает!
• Любой ответ, в котором не используется Visibility.Visible для скрытия / отображения окна, неверен.
  • Почему? Если мы используем Citrix, если окно не сворачивается при закрытии, на экране остается странный черный прямоугольник. Таким образом, мы не можем использовать window.Show() и window.Hide().

По сути:

• Окно не должно отвлекать внимание от любого другого окна при его активации;
• Окно не должно активировать своего родителя, когда оно отображается;
• Окно должно быть совместимо с Citrix.

Решение MVVM

Этот код на 100% совместим с Citrix (на экране отсутствуют пустые области). Он протестирован как с обычным WPF, так и с DevExpress.

Этот ответ предназначен для любого варианта использования, когда нам нужно небольшое окно уведомления, которое всегда находится перед другими окнами (если пользователь выбирает это в настройках).

Если этот ответ кажется более сложным, чем другие, то это потому, что это надежный код корпоративного уровня. Некоторые другие ответы на этой странице просты, но на самом деле не работают.

XAML - прикрепленное свойство

Добавьте это присоединенное свойство к любому UserControl в окне. Прилагаемое свойство будет:

• Подождите, пока не сработает событие Loaded (иначе он не сможет найти в визуальном дереве родительское окно).
• Добавьте обработчик событий, который проверяет, будет ли окно видимым или нет.

В любой момент вы можете установить окно спереди или нет, перевернув значение присоединенного свойства.

<UserControl x:Class = "..."
         ...
         attachedProperties:EnsureWindowInForeground.EnsureWindowInForeground=
             "{Binding EnsureWindowInForeground, Mode=OneWay}">

C# - вспомогательный метод

public static class HideAndShowWindowHelper
{
    /// <summary>
    ///     Intent: Ensure that small notification window is on top of other windows.
    /// </summary>
    /// <param name = "window"></param>
    public static void ShiftWindowIntoForeground(Window window)
    {
        try
        {
            // Prevent the window from grabbing focus away from other windows the first time is created.
            window.ShowActivated = false;

            // Do not use .Show() and .Hide() - not compatible with Citrix!
            if (window.Visibility != Visibility.Visible)
            {
                window.Visibility = Visibility.Visible;
            }

            // We can't allow the window to be maximized, as there is no de-maximize button!
            if (window.WindowState == WindowState.Maximized)
            {
                window.WindowState = WindowState.Normal;
            }

            window.Topmost = true;
        }
        catch (Exception)
        {
            // Gulp. Avoids "Cannot set visibility while window is closing".
        }
    }

    /// <summary>
    ///     Intent: Ensure that small notification window can be hidden by other windows.
    /// </summary>
    /// <param name = "window"></param>
    public static void ShiftWindowIntoBackground(Window window)
    {
        try
        {
            // Prevent the window from grabbing focus away from other windows the first time is created.
            window.ShowActivated = false;

            // Do not use .Show() and .Hide() - not compatible with Citrix!
            if (window.Visibility != Visibility.Collapsed)
            {
                window.Visibility = Visibility.Collapsed;
            }

            // We can't allow the window to be maximized, as there is no de-maximize button!
            if (window.WindowState == WindowState.Maximized)
            {
                window.WindowState = WindowState.Normal;
            }

            window.Topmost = false;
        }
        catch (Exception)
        {
            // Gulp. Avoids "Cannot set visibility while window is closing".
        }
    }
}

использование

Чтобы использовать это, вам нужно создать окно в вашей ViewModel:

private ToastView _toastViewWindow;
private void ShowWindow()
{
    if (_toastViewWindow == null)
    {
        _toastViewWindow = new ToastView();
        _dialogService.Show<ToastView>(this, this, _toastViewWindow, true);
    }
    ShiftWindowOntoScreenHelper.ShiftWindowOntoScreen(_toastViewWindow);
    HideAndShowWindowHelper.ShiftWindowIntoForeground(_toastViewWindow);
}

private void HideWindow()
{
    if (_toastViewWindow != null)
    {
        HideAndShowWindowHelper.ShiftWindowIntoBackground(_toastViewWindow);
    }
}

Дополнительные ссылки

Советы о том, как сделать так, чтобы окно уведомлений всегда возвращалось на видимый экран, см. В моем ответе: Как в WPF переместить окно на экран, если оно находится вне экрана?.

Эти коды будут работать нормально всегда.

Сначала установите активированный обработчик событий в XAML:

Activated = "Window_Activated"

Добавьте строку ниже в блок конструктора главного окна:

public MainWindow()
{
    InitializeComponent();
    this.LocationChanged += (sender, e) => this.Window_Activated(sender, e);
}

А внутри активированного обработчика событий скопируйте эти коды:

private void Window_Activated(object sender, EventArgs e)
{
    if (Application.Current.Windows.Count > 1)
    {
        foreach (Window win in Application.Current.Windows)
            try
            {
                if (!win.Equals(this))
                {
                    if (!win.IsVisible)
                    {
                        win.ShowDialog();
                    }

                    if (win.WindowState == WindowState.Minimized)
                    {
                        win.WindowState = WindowState.Normal;
                    }

                    win.Activate();
                    win.Topmost = true;
                    win.Topmost = false;
                    win.Focus();
                }
            }
            catch { }
    }
    else
        this.Focus();
}

Эти шаги будут работать нормально и выведут на передний план все остальные окна в окно своих родителей.

Просто хотел добавить еще одно решение этого вопроса. Эта реализация работает для моего сценария, где CaliBurn отвечает за отображение основного окна.

protected override void OnStartup(object sender, StartupEventArgs e)
{
    DisplayRootViewFor<IMainWindowViewModel>();

    Application.MainWindow.Topmost = true;
    Application.MainWindow.Activate();
    Application.MainWindow.Activated += OnMainWindowActivated;
}

private static void OnMainWindowActivated(object sender, EventArgs e)
{
    var window = sender as Window;
    if (window != null)
    {
        window.Activated -= OnMainWindowActivated;
        window.Topmost = false;
        window.Focus();
    }
}

Не забудьте не помещать код, который показывает это окно, в обработчик PreviewMouseDoubleClick, поскольку активное окно переключится обратно на окно, которое обработало событие. Просто поместите его в обработчик событий MouseDoubleClick или остановите всплытие, установив для e.Handled значение True.

В моем случае я обрабатывал PreviewMouseDoubleClick в Listview и не устанавливал e.Handled = true, тогда он поднял событие MouseDoubleClick, которое вернуло фокус обратно в исходное окно.

Я создал метод расширения, чтобы упростить его повторное использование.

using System.Windows.Forms;
    namespace YourNamespace{
        public static class WindowsFormExtensions {
            public static void PutOnTop(this Form form) {
                form.Show();
                form.Activate();
            }// END PutOnTop()       
        }// END class
    }// END namespace

Вызов конструктора форм

namespace YourNamespace{
       public partial class FormName : Form {
       public FormName(){
            this.PutOnTop();
            InitalizeComponents();
        }// END Constructor
    } // END Form            
}// END namespace