Comment faire en sorte qu'une fenêtre reste toujours au top dans .Net?

J'ai une application winforms C # qui exécute une macro dans un autre programme. L'autre programme fera continuellement apparaître des fenêtres et rendra généralement les choses folles, faute d'un meilleur mot. Je souhaite implémenter un bouton d'annulation qui arrêtera l'exécution du processus, mais je n'arrive pas à faire en sorte que la fenêtre reste au top. Comment faire cela en C #?

Edit: j'ai essayé TopMost = true; , mais l'autre programme continue d'afficher ses propres fenêtres par-dessus. Existe-t-il un moyen d'envoyer ma fenêtre vers le haut toutes les n millisecondes?

Edit: La façon dont j'ai résolu ce problème était en ajoutant une icône de la barre d'état système qui annulera le processus en double-cliquant dessus. L'icône de la barre d'état système n'est pas masquée. Merci à tous ceux qui ont répondu. J'ai lu l'article expliquant pourquoi il n'y a pas de fenêtre «super-dessus» ... cela ne fonctionne logiquement pas.

Form.TopMost fonctionnera à moins que l'autre programme crée les fenêtres les plus hautes.

Il n'existe aucun moyen de créer une fenêtre qui n'est pas couverte par les nouvelles fenêtres supérieures d'un autre processus. Raymond Chen a expliqué pourquoi.

Je cherchais à faire de mon application WinForms "Always on Top" mais le réglage "TopMost" n'a rien fait pour moi. Je savais que c'était possible parce que WinAmp fait cela (avec une foule d'autres applications).

Ce que j'ai fait, c'est d'appeler "user32.dll". Je n'ai eu aucun scrupule à le faire et cela fonctionne très bien. C'est une option, de toute façon.

Tout d'abord, importez l'espace de noms suivant:

using System.Runtime.InteropServices;

Ajoutez quelques variables à votre déclaration de classe:

private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
private const UInt32 SWP_NOSIZE = 0x0001;
private const UInt32 SWP_NOMOVE = 0x0002;
private const UInt32 TOPMOST_FLAGS = SWP_NOMOVE | SWP_NOSIZE;

Ajouter un prototype pour la fonction user32.dll:

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

Puis dans votre code (j'ai ajouté l'appel dans Form_Load ()), ajoutez l'appel:

SetWindowPos(this.Handle, HWND_TOPMOST, 0, 0, 0, 0, TOPMOST_FLAGS);

J'espère que cela pourra aider. Référence

Si par "devenir fou" vous voulez dire que chaque fenêtre continue de voler le focus de l'autre, TopMost ne résoudra pas le problème.

Essayez plutôt:

CalledForm.Owner = CallerForm;
CalledForm.Show();

Cela montrera la forme «enfant» sans qu'elle vole l'attention. Le formulaire enfant restera également au-dessus de son parent même si le parent est activé ou focalisé. Ce code ne fonctionne facilement que si vous avez créé une instance du formulaire enfant à partir du formulaire propriétaire. Sinon, vous devrez peut-être définir le propriétaire à l'aide de l'API.

Définir Form.TopMost

J'ai eu un laps de temps momentané de 5 minutes et j'ai oublié de spécifier le formulaire en entier comme ceci:

  myformName.ActiveForm.TopMost = true;

Mais ce que je voulais vraiment, c'était CECI!

  this.TopMost = true;

Définissez la .TopMostpropriété du formulaire sur true.

Vous ne voulez probablement pas le laisser de cette façon tout le temps: définissez-le lorsque votre processus externe démarre et remettez-le lorsqu'il se termine.

La façon dont j'ai résolu ce problème était de créer une icône de la barre d'état système avec une option d'annulation.

Le code suivant permet à la fenêtre de toujours rester en haut et de la rendre sans cadre.

using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace StayOnTop
{
    public partial class Form1 : Form
    {
        private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
        private const UInt32 SWP_NOSIZE = 0x0001;
        private const UInt32 SWP_NOMOVE = 0x0002;
        private const UInt32 TOPMOST_FLAGS = SWP_NOMOVE | SWP_NOSIZE;

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

        public Form1()
        {
            InitializeComponent();
            FormBorderStyle = FormBorderStyle.None;
            TopMost = true;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            SetWindowPos(this.Handle, HWND_TOPMOST, 100, 100, 300, 300, TOPMOST_FLAGS);
        }

        protected override void WndProc(ref Message m)
        {
            const int RESIZE_HANDLE_SIZE = 10;

            switch (m.Msg)
            {
                case 0x0084/*NCHITTEST*/ :
                    base.WndProc(ref m);

                    if ((int)m.Result == 0x01/*HTCLIENT*/)
                    {
                        Point screenPoint = new Point(m.LParam.ToInt32());
                        Point clientPoint = this.PointToClient(screenPoint);
                        if (clientPoint.Y <= RESIZE_HANDLE_SIZE)
                        {
                            if (clientPoint.X <= RESIZE_HANDLE_SIZE)
                                m.Result = (IntPtr)13/*HTTOPLEFT*/ ;
                            else if (clientPoint.X < (Size.Width - RESIZE_HANDLE_SIZE))
                                m.Result = (IntPtr)12/*HTTOP*/ ;
                            else
                                m.Result = (IntPtr)14/*HTTOPRIGHT*/ ;
                        }
                        else if (clientPoint.Y <= (Size.Height - RESIZE_HANDLE_SIZE))
                        {
                            if (clientPoint.X <= RESIZE_HANDLE_SIZE)
                                m.Result = (IntPtr)10/*HTLEFT*/ ;
                            else if (clientPoint.X < (Size.Width - RESIZE_HANDLE_SIZE))
                                m.Result = (IntPtr)2/*HTCAPTION*/ ;
                            else
                                m.Result = (IntPtr)11/*HTRIGHT*/ ;
                        }
                        else
                        {
                            if (clientPoint.X <= RESIZE_HANDLE_SIZE)
                                m.Result = (IntPtr)16/*HTBOTTOMLEFT*/ ;
                            else if (clientPoint.X < (Size.Width - RESIZE_HANDLE_SIZE))
                                m.Result = (IntPtr)15/*HTBOTTOM*/ ;
                            else
                                m.Result = (IntPtr)17/*HTBOTTOMRIGHT*/ ;
                        }
                    }
                    return;
            }
            base.WndProc(ref m);
        }

        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.Style |= 0x20000; // <--- use 0x20000
                return cp;
            }
        }
    }
}

Quelle est l'autre application dont vous essayez de supprimer la visibilité? Avez-vous étudié d'autres moyens d'obtenir l'effet souhaité? Veuillez le faire avant de soumettre vos utilisateurs à un comportement malveillant tel que vous le décrivez: ce que vous essayez de faire ressemble plutôt à ce que certains sites méchants font avec les fenêtres de navigateur ...

Au moins, essayez de respecter la règle de la moindre surprise . Les utilisateurs s'attendent à pouvoir déterminer eux-mêmes l'ordre z de la plupart des applications. Vous ne savez pas ce qui est le plus important pour eux, donc si vous changez quoi que ce soit, vous devriez vous concentrer sur le fait de pousser l'autre application derrière tout plutôt que de promouvoir la vôtre.

Ceci est bien sûr plus délicat, car Windows ne dispose pas d'un gestionnaire de fenêtres particulièrement sophistiqué. Deux approches se suggèrent:

1. énumérer les fenêtres de niveau supérieur et vérifier à quel processus elles appartiennent , en supprimant leur ordre z si c'est le cas . (Je ne suis pas sûr qu'il existe des méthodes de cadre pour ces fonctions WinAPI.)
2. Jouer avec les autorisations de processus enfants pour l'empêcher d'accéder au bureau ... mais je n'essaierais pas cela jusqu'à ce que l'autre approche échoue, car le processus enfant pourrait se retrouver dans un état zombie tout en nécessitant une interaction de l'utilisateur.

Pourquoi ne pas faire de votre formulaire une boîte de dialogue:

myForm.ShowDialog();

Voici l'équivalent de SetForegroundWindow:

form.Activate();

J'ai vu des gens faire des choses bizarres comme:

this.TopMost = true;
this.Focus();
this.BringToFront();
this.TopMost = false;

http://blog.jorgearimany.com/2010/10/win32-setforegroundwindow-equivalent-in.html

Je sais que c'est vieux, mais je n'ai pas vu cette réponse.

Dans la fenêtre (xaml) ajoutez:

Deactivated="Window_Deactivated"

Dans le code derrière pour Window_Deactivated:

private void Window_Deactivated(object sender, EventArgs e)
    {
        Window window = (Window)sender;
        window.Activate();
    }

Cela gardera votre fenêtre au top.

Sur la base de la réponse de clamum et du commentaire de Kevin Vuilleumier sur l'autre drapeau responsable du comportement, j'ai fait cette bascule qui bascule entre en haut et pas en haut en appuyant sur un bouton.

private void button1_Click(object sender, EventArgs e)
    {
        if (on)
        {
            button1.Text = "yes on top";
            IntPtr HwndTopmost = new IntPtr(-1);
            SetWindowPos(this.Handle, HwndTopmost, 0, 0, 0, 0, TopmostFlags);
            on = false;
        }
        else
        {
            button1.Text = "not on top";
            IntPtr HwndTopmost = new IntPtr(-2);
            SetWindowPos(this.Handle, HwndTopmost, 0, 0, 0, 0, TopmostFlags);
            on = true;
        }
    }