Przenieś okno do przodu w WPF

Jak mogę przenieść moją aplikację WPF na przód pulpitu? Do tej pory próbowałem:

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);

Żadne z nich nie wykonuje zadania ( Marshal.GetLastWin32Error()mówi, że te operacje zostały zakończone pomyślnie, a atrybuty P / Invoke dla każdej definicji mają SetLastError=true).

Jeśli utworzę nową pustą aplikację WPF i zadzwonię SwitchToThisWindowz zegarem, działa ona dokładnie tak, jak się spodziewano, więc nie jestem pewien, dlaczego nie działa w moim oryginalnym przypadku.

Edycja : Robię to w połączeniu z globalnym skrótem klawiszowym.

myWindow.Activate();

Próbuje przenieść okno na pierwszy plan i aktywuje je.

To powinno wystarczyć, chyba że źle zrozumiałem, a ty chcesz zachowania Always on Top. W takim przypadku chcesz:

myWindow.TopMost = true;

Znalazłem rozwiązanie, które przenosi okno na górę, ale zachowuje się jak normalne okno:

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

Jeśli chcesz, aby okno znajdowało się z przodu przy pierwszym ładowaniu, wykonaj następujące czynności:

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

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

Aby było to szybkie kopiowanie-wklejanie -
użyj tej DoOnProcessmetody „ metody, aby przenieść okno główne procesu” na pierwszy plan (ale nie kradnij fokusu z innych okien)

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

Wiem, że to pytanie jest dość stare, ale właśnie natknąłem się na ten precyzyjny scenariusz i chciałem podzielić się wdrożonym przeze mnie rozwiązaniem.

Jak wspomniano w komentarzach na tej stronie, kilka proponowanych rozwiązań nie działa na XP, które muszę wspierać w moim scenariuszu. Chociaż zgadzam się z opinią @Matthew Xaviera, że ​​ogólnie jest to zła praktyka UX, są chwile, w których jest to całkowicie prawdopodobne UX.

Rozwiązanie przeniesienia okna WPF na samą górę zostało mi zapewnione przez ten sam kod, którego używam do zapewnienia globalnego skrótu. Artykuł na blogu Josepha Cooneya zawiera link do jego próbek kodu, który zawiera oryginalny kod.

Wyczyściłem i zmodyfikowałem trochę kod i zaimplementowałem go jako metodę rozszerzenia do System.Windows.Window. Przetestowałem to na XP 32-bitowym i Win7 64-bitowym, oba działają poprawnie.

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
    }
}

Mam nadzieję, że ten kod pomoże innym, którzy napotkają ten problem.

Jeśli użytkownik wchodzi w interakcję z inną aplikacją, przeniesienie Twojej aplikacji na pierwszy plan może być niemożliwe. Zasadniczo proces może oczekiwać ustawienia okna pierwszego planu, tylko jeśli proces ten jest już procesem pierwszego planu. (Microsoft dokumentuje ograniczenia we wpisie MSDN SetForegroundWindow ()) . Jest tak, ponieważ:

1. Użytkownik „jest właścicielem” pierwszego planu. Na przykład byłoby bardzo irytujące, gdyby inny program ukradł pierwszy plan podczas pisania przez użytkownika, przynajmniej przerywając jej przepływ pracy i prawdopodobnie powodując niezamierzone konsekwencje, ponieważ jej naciśnięcia klawiszy dla jednej aplikacji są źle interpretowane przez sprawcę, dopóki nie zauważy zmiany .
2. Wyobraź sobie, że każdy z dwóch programów sprawdza, czy jego okno jest na pierwszym planie i próbuje ustawić go na pierwszym planie, jeśli tak nie jest. Zaraz po uruchomieniu drugiego programu komputer staje się bezużyteczny, gdy pierwszy plan odbija się między nimi przy każdym przełączeniu zadania.

Wiem, że to późna odpowiedź, być może pomocna dla badaczy

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

Dlaczego niektóre odpowiedzi na tej stronie są błędne!

• Każda zastosowana odpowiedź window.Focus()jest nieprawidłowa.

  • Czemu? Jeśli pojawi się powiadomienie, window.Focus()odciągnie uwagę od tego, co użytkownik wpisuje w danym momencie. Jest to niezwykle frustrujące dla użytkowników końcowych, szczególnie jeśli wyskakujące okienka pojawiają się dość często.

• Każda zastosowana odpowiedź window.Activate()jest nieprawidłowa.

  • Czemu? Sprawi, że wszystkie okna nadrzędne będą widoczne.
• Każda odpowiedź, która window.ShowActivated = falsezostanie pominięta, jest błędna.
  • Czemu? Gdy pojawi się komunikat, przyciągnie uwagę z innego okna, co jest bardzo denerwujące!
• Każda odpowiedź, która nie służy Visibility.Visibledo ukrywania / pokazywania okna, jest niepoprawna.
  • Czemu? Jeśli używamy Citrix, jeśli okno nie zwinie się po zamknięciu, pozostawi dziwny czarny prostokątny uchwyt na ekranie. Dlatego nie możemy używać window.Show()i window.Hide().

Głównie:

• Okno nie powinno przyciągać fokusa od żadnego innego okna, gdy zostanie aktywowane;
• Okno nie powinno aktywować swojego rodzica, gdy jest wyświetlane;
• Okno powinno być kompatybilne z Citrix.

Rozwiązanie MVVM

Ten kod jest w 100% zgodny z Citrix (bez pustych obszarów ekranu). Jest testowany zarówno z normalnym WPF, jak i DevExpress.

Ta odpowiedź jest przeznaczona dla każdego przypadku użycia, w którym chcemy małe okno powiadomienia, które zawsze znajduje się przed innymi oknami (jeśli użytkownik wybierze to w preferencjach).

Jeśli ta odpowiedź wydaje się bardziej złożona niż inne, to dlatego, że jest to solidny kod na poziomie przedsiębiorstwa. Niektóre inne odpowiedzi na tej stronie są proste, ale w rzeczywistości nie działają.

XAML - właściwość dołączona

Dodaj tę dołączoną właściwość do dowolnej UserControlw oknie. Załączona nieruchomość:

• Poczekaj, aż Loadedzdarzenie zostanie uruchomione (w przeciwnym razie nie będzie mógł przeglądać drzewa wizualnego w celu znalezienia okna nadrzędnego).
• Dodaj moduł obsługi zdarzeń, który zapewnia, że ​​okno jest widoczne, czy nie.

W dowolnym momencie możesz ustawić okno tak, aby było na wierzchu lub nie, odwracając wartość dołączonej właściwości.

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

C # - Metoda pomocnicza

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".
        }
    }
}

Stosowanie

Aby tego użyć, musisz utworzyć okno w swoim 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);
    }
}

Dodatkowe linki

Aby dowiedzieć się, jak upewnić się, że okno powiadomień zawsze przesuwa się z powrotem na widoczny ekran, zobacz moją odpowiedź: W WPF, jak przenieść okno na ekran, jeśli jest poza ekranem? .

Miałem podobny problem z aplikacją WPF, która jest wywoływana z aplikacji Access za pośrednictwem obiektu Shell.

Moje rozwiązanie jest poniżej - działa w XP i Win7 x64 z aplikacją skompilowaną do celu x86.

Wolałbym to zrobić niż symulować klawisz Alt.

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();
}

Cóż, ponieważ jest to tak gorący temat ... oto, co działa dla mnie. Wystąpiły błędy, jeśli nie zrobiłem tego w ten sposób, ponieważ Activate () spowoduje błąd, jeśli nie widzisz okna.

Xaml:

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

Codebehind:

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

To był dla mnie jedyny sposób na wyświetlenie okna na górze. Następnie aktywuj go, aby móc pisać w polu bez konieczności ustawiania ostrości za pomocą myszy. control.Focus () nie będzie działać, chyba że okno jest aktywne ();

Cóż, wymyśliłem obejście. Dzwonię z haka na klawiaturę używanego do wprowadzenia skrótu. Wywołanie działa zgodnie z oczekiwaniami, jeśli wstawię go do BackgroundWorker z pauzą. To kludge, ale nie mam pojęcia, dlaczego pierwotnie nie działało.

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();
}

Aby wyświetlić JAKIEKOLWIEK otwarte okno, zaimportuj te biblioteki 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);

oraz w programie Szukamy aplikacji o określonym tytule (wpisz tytuł bez pierwszej litery (indeks> 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);
                }

Problemem może być to, że wątek wywołujący twój kod z haka nie został zainicjowany przez środowisko wykonawcze, więc wywołanie metod środowiska wykonawczego nie działa.

Być może możesz spróbować wykonać Invoke, aby wprowadzić kod do wątku interfejsu użytkownika i wywołać kod, który przenosi okno na pierwszy plan.

Kody te będą działać poprawnie przez cały czas.

Najpierw ustaw aktywowaną procedurę obsługi zdarzeń w XAML:

Activated="Window_Activated"

Dodaj poniższy wiersz do bloku konstruktora okna głównego:

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

A w aktywowanym module obsługi zdarzeń skopiuj następujące kody:

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();
}

Te kroki będą działać dobrze i doprowadzą do przodu wszystkie inne okna w oknie ich rodziców.

Jeśli próbujesz ukryć okno, na przykład minimalizujesz okno, znalazłem to za pomocą

    this.Hide();

ukryje go poprawnie, a następnie po prostu użyje

    this.Show();

pokaże wtedy okno jako najwyżej umieszczony element.

Chciałem tylko dodać inne rozwiązanie do tego pytania. Ta implementacja działa w moim scenariuszu, w którym CaliBurn jest odpowiedzialny za wyświetlanie głównego okna.

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();
    }
}

Pamiętaj, aby nie umieszczać kodu wyświetlającego to okno w module obsługi PreviewMouseDoubleClick, ponieważ aktywne okno powróci do okna, które obsłużyło zdarzenie. Wystarczy umieścić go w module obsługi zdarzeń MouseDoubleClick lub przestać propagować, ustawiając e.Handled na True.

W moim przypadku obsługiwałem PreviewMouseDoubleClick w widoku listy i nie ustawiałem e.Handled = true, a następnie podniosłem zdarzenie MouseDoubleClick, które skupiło się z powrotem do oryginalnego okna.

Zbudowałem metodę rozszerzenia, aby ułatwić ponowne użycie.

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

Wezwij konstruktora formularzy

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