Porta una finestra in primo piano in WPF

Come posso portare la mia applicazione WPF in primo piano sul desktop? Finora ho provato:

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

Nessuno dei quali sta facendo il lavoro ( Marshal.GetLastWin32Error()sta dicendo che queste operazioni sono state completate con successo e gli attributi P / Invoke per ogni definizione lo hanno SetLastError=true).

Se creo una nuova applicazione WPF vuota e chiamo SwitchToThisWindowcon un timer, funziona esattamente come previsto, quindi non sono sicuro del motivo per cui non funziona nel mio caso originale.

Modifica : lo sto facendo in combinazione con un tasto di scelta rapida globale.

myWindow.Activate();

Tenta di portare la finestra in primo piano e di attivarla.

Questo dovrebbe funzionare, a meno che io non abbia capito male e tu desideri un comportamento Sempre in primo piano. In tal caso vuoi:

myWindow.TopMost = true;

Ho trovato una soluzione che porta la finestra in alto, ma si comporta come una normale finestra:

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

Nel caso in cui sia necessario che la finestra sia in primo piano la prima volta che viene caricata, è necessario utilizzare quanto segue:

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

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

So che questa domanda è piuttosto vecchia, ma mi sono appena imbattuto in questo preciso scenario e volevo condividere la soluzione che ho implementato.

Come accennato nei commenti in questa pagina, molte delle soluzioni proposte non funzionano su XP, che devo supportare nel mio scenario. Anche se sono d'accordo con l'opinione di @Matthew Xavier che generalmente questa è una cattiva pratica di UX, ci sono momenti in cui è del tutto plausibile.

La soluzione per portare una finestra WPF in alto mi è stata effettivamente fornita dallo stesso codice che sto usando per fornire il tasto di scelta rapida globale. Un articolo del blog di Joseph Cooney contiene un collegamento ai suoi esempi di codice che contiene il codice originale.

Ho ripulito e modificato un po 'il codice e l'ho implementato come metodo di estensione per System.Windows.Window. L'ho testato su XP 32 bit e Win7 64 bit, entrambi funzionano correttamente.

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

Spero che questo codice aiuti gli altri che riscontrano questo problema.

Per renderlo un rapido copia-incolla -
Usa questo DoOnProcessmetodo di classe per spostare la finestra principale del processo in primo piano (ma non per rubare lo stato attivo da altre finestre)

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

Se l'utente sta interagendo con un'altra applicazione, potrebbe non essere possibile portare la tua in primo piano. Come regola generale, un processo può aspettarsi di impostare la finestra in primo piano solo se quel processo è già il processo in primo piano. (Microsoft documenta le limitazioni nella voce SetForegroundWindow () MSDN.) Ciò è dovuto al fatto che:

1. L'utente "possiede" il primo piano. Ad esempio, sarebbe estremamente fastidioso se un altro programma rubasse il primo piano mentre l'utente sta digitando, interrompendo per lo meno il suo flusso di lavoro e possibilmente causando conseguenze non intenzionali poiché le sue battiture destinate a un'applicazione vengono interpretate erroneamente dall'autore del reato fino a quando non si accorge del cambiamento .
2. Immagina che ciascuno dei due programmi controlli per vedere se la sua finestra è in primo piano e tenta di impostarla in primo piano se non lo è. Non appena il secondo programma è in esecuzione, il computer diventa inutilizzabile poiché il primo piano rimbalza tra i due ad ogni cambio di attività.

Perché alcune delle risposte in questa pagina sono sbagliate!

• Qualsiasi risposta che usi window.Focus()è sbagliata.

  • Perché? Se viene visualizzato un messaggio di notifica, window.Focus()attirerà l'attenzione lontano da ciò che l'utente sta digitando in quel momento. Questo è incredibilmente frustrante per gli utenti finali, soprattutto se i popup si verificano abbastanza frequentemente.

• Qualsiasi risposta che usi window.Activate()è sbagliata.

  • Perché? Renderà visibili anche tutte le finestre genitore.
• Qualsiasi risposta omessa window.ShowActivated = falseè sbagliata.
  • Perché? Allontanerà il focus da un'altra finestra quando il messaggio si apre, il che è molto fastidioso!
• Qualsiasi risposta che non usi Visibility.Visibleper nascondere / mostrare la finestra è sbagliata.
  • Perché? Se stiamo usando Citrix, se la finestra non è compressa quando è chiusa, lascerà uno strano blocco rettangolare nero sullo schermo. Quindi, non possiamo usare window.Show()e window.Hide().

Essenzialmente:

• La finestra non dovrebbe allontanare il focus da altre finestre quando si attiva;
• La finestra non dovrebbe attivare il suo genitore quando viene mostrata;
• La finestra dovrebbe essere compatibile con Citrix.

Soluzione MVVM

Questo codice è compatibile al 100% con Citrix (nessuna area vuota dello schermo). È testato sia con WPF normale che con DevExpress.

Questa risposta è intesa per qualsiasi caso d'uso in cui vogliamo una piccola finestra di notifica che sia sempre davanti alle altre finestre (se l'utente seleziona questa nelle preferenze).

Se questa risposta sembra più complessa delle altre, è perché è un codice robusto a livello aziendale. Alcune delle altre risposte in questa pagina sono semplici, ma in realtà non funzionano.

XAML: proprietà collegata

Aggiungi questa proprietà allegata a qualsiasi UserControlall'interno della finestra. La proprietà annessa:

• Attendi che l' Loadedevento venga generato (altrimenti non può cercare l'albero visivo per trovare la finestra padre).
• Aggiungi un gestore di eventi che assicuri che la finestra sia visibile o meno.

In qualsiasi momento, puoi impostare la finestra in modo che sia in primo piano o meno, capovolgendo il valore della proprietà allegata.

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

C # - Metodo di supporto

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

Utilizzo

Per usarlo, devi creare la finestra nel tuo 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);
    }
}

Link aggiuntivi

Per suggerimenti su come garantire che una finestra di notifica torni sempre sullo schermo visibile, vedere la mia risposta: In WPF, come spostare una finestra sullo schermo se è fuori dallo schermo? .

So che questa è una risposta tardiva, forse utile per i ricercatori

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

Ho avuto un problema simile con un'applicazione WPF che viene richiamata da un'applicazione Access tramite l'oggetto Shell.

La mia soluzione è di seguito: funziona in XP e Win7 x64 con l'app compilata per la destinazione x86.

Preferisco di gran lunga farlo piuttosto che simulare un 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();
}

Bene, poiché questo è un argomento così caldo ... ecco cosa funziona per me. Ho ricevuto degli errori se non l'ho fatto in questo modo perché Activate () ti sbaglierà se non riesci a vedere la finestra.

Xaml:

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

Codebehind:

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

Questo era l'unico modo per me per mostrare la finestra in alto. Quindi attivalo in modo da poter digitare nella casella senza dover impostare lo stato attivo con il mouse. control.Focus () non funzionerà a meno che la finestra non sia Active ();

Beh, ho trovato un modo per aggirare il problema. Sto effettuando la chiamata da un hook della tastiera utilizzato per implementare un tasto di scelta rapida. La chiamata funziona come previsto se la inserisco in un BackgroundWorker con una pausa. È un kludge, ma non ho idea del motivo per cui originariamente non funzionasse.

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

Per mostrare QUALSIASI finestra attualmente aperta, importa quelle 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);

e nel programma Cerchiamo app con titolo specificato (scrivi titolo senza prima lettera (indice> 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);
                }

Il problema potrebbe essere che il thread che chiama il codice dall'hook non è stato inizializzato dal runtime, quindi la chiamata ai metodi di runtime non funziona.

Forse potresti provare a eseguire una chiamata per eseguire il marshalling del codice sul thread dell'interfaccia utente per chiamare il codice che porta la finestra in primo piano.

Questi codici funzioneranno sempre bene.

All'inizio imposta il gestore di eventi attivato in XAML:

Activated="Window_Activated"

Aggiungi sotto la riga al blocco costruttore della finestra principale:

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

E all'interno del gestore di eventi attivato copia questi codici:

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

Questi passaggi funzioneranno bene e porteranno in primo piano tutte le altre finestre nella finestra dei genitori.

Volevo solo aggiungere un'altra soluzione a questa domanda. Questa implementazione funziona per il mio scenario, in cui CaliBurn è responsabile della visualizzazione della finestra principale.

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

Se stai cercando di nascondere la finestra, ad esempio minimizzi la finestra, l'ho trovato usando

    this.Hide();

lo nasconderà correttamente, quindi semplicemente usando

    this.Show();

mostrerà quindi di nuovo la finestra come l'elemento più in alto.

Ricorda di non inserire il codice che mostra quella finestra all'interno di un gestore PreviewMouseDoubleClick poiché la finestra attiva tornerà alla finestra che ha gestito l'evento. Inseriscilo nel gestore di eventi MouseDoubleClick o interrompi il bubbling impostando e.Handled su True.

Nel mio caso stavo gestendo PreviewMouseDoubleClick su un Listview e non stavo impostando e.Handled = true, quindi ha sollevato l'evento MouseDoubleClick che ha riportato il focus sulla finestra originale.

Ho creato un metodo di estensione per facilitare il riutilizzo.

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

Chiama il Form Constructor

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