Discussion :

[.brk.]

Bonjour,

Je cherche actuellement à "fixer" mon programme au bureau.

J'aimerais donc que quand on clique sur le bouton "afficher bureau" de la barre des tâches Windows, mon programme(Windows Form) ne disparaisse pas en même temps.

J'ai testé différentes solutions mais rien qui fonctionne correctement.

Auriez-vous une idée ?

Merci

[wallace1]

bonjour,

ce que tu cherches a faire passe par une API (DwmSetWindowAttribute) pour modifier la fonctionnalité AeroPeek
:
https://www.google.fr/search?q=aerop...obile&ie=UTF-8

perso j ai deja tout essaye et rien n y fait sur windows 7.
meme en passant par gpo.

bon courage.

[mactwist69]

Il n'y aurait pas une option à mettre sur la Form principal qui s’appellerait un truc comme AlwaysOnTop ?

[.brk.]

Merci pour l'info Je vais regarder de se coter la je reviendrais vers vous par la suite.

Pour l'alwaysontop il y a la commande Topmost = True mais le programme ne doit pas rester devant les applications.

C'est un programme qui affiche le nom, lip et l'uptime de la machine et donc n'a pas d'utilité d'être devant les programmes.

Il doit juste rester quand on affiche le bureau via le bouton de la barre des tâches.

Cela paraît compliquer à faire :/

[ZenZiTone]

Il doit juste rester quand on affiche le bureau via le bouton de la barre des tâches.

Cela paraît compliquer à faire :/

J'ai fais un petit test en utilisant l'événement Resize, qui est appelé lorsque la fenêtre est réduite. Il semblerait cependant qu'"Afficher le bureau" ne réduit pas les applications ouverte mais fait un genre de "SetForegroundWindow" sur le bureau lui-même.

Il faudrait donc essayer de détecter la commande en question pour effectuer à ton tour un "SetForegroundWindow". Tu peux essayer de checker les processus actif et de vérifier celui qui est au premier plan. Si celui-ci est le bureau lui-même alors tu effectue ta commande. Après ce n'est qu'une piste, je ne sais pas si les processus actifs contiennent la bonne info.

[EddiGordo]

Un bout de code trouvé sur le net, non testé, et qui va dans le sens de ce qu'indique Zenzitone.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows;
 
namespace YourNamespace
{
    internal static class NativeMethods
    {
        [DllImport("user32.dll")]
        internal static extern IntPtr SetWinEventHook(uint eventMin, uint eventMax, IntPtr hmodWinEventProc, ShowDesktop.WinEventDelegate lpfnWinEventProc, uint idProcess, uint idThread, uint dwFlags);
 
        [DllImport("user32.dll")]
        internal static extern bool UnhookWinEvent(IntPtr hWinEventHook);
 
        [DllImport("user32.dll")]
        internal static extern int GetClassName(IntPtr hwnd, StringBuilder name, int count);
    }
 
    public static class ShowDesktop
    {
        private const uint WINEVENT_OUTOFCONTEXT = 0u;
        private const uint EVENT_SYSTEM_FOREGROUND = 3u;
 
        private const string WORKERW = "WorkerW";
        private const string PROGMAN = "Progman";
 
        public static void AddHook(Window window)
        {
            if (IsHooked)
            {
                return;
            }
 
            IsHooked = true;
 
            _delegate = new WinEventDelegate(WinEventHook);
            _hookIntPtr = NativeMethods.SetWinEventHook(EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND, IntPtr.Zero, _delegate, 0, 0, WINEVENT_OUTOFCONTEXT);
            _window = window;
        }
 
        public static void RemoveHook()
        {
            if (!IsHooked)
            {
                return;
            }
 
            IsHooked = false;
 
            NativeMethods.UnhookWinEvent(_hookIntPtr.Value);
 
            _delegate = null;
            _hookIntPtr = null;
            _window = null;
        }
 
        private static string GetWindowClass(IntPtr hwnd)
        {
            StringBuilder _sb = new StringBuilder(32);
            NativeMethods.GetClassName(hwnd, _sb, _sb.Capacity);
            return _sb.ToString();
        }
 
        internal delegate void WinEventDelegate(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime);
 
        private static void WinEventHook(IntPtr hWinEventHook, uint eventType, IntPtr hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
        {
            if (eventType == EVENT_SYSTEM_FOREGROUND)
            {
                string _class = GetWindowClass(hwnd);
 
                if (string.Equals(_class, WORKERW, StringComparison.Ordinal) /*|| string.Equals(_class, PROGMAN, StringComparison.Ordinal)*/ )
                {
                    _window.Topmost = true;
                }
                else
                {
                    _window.Topmost = false;
                }
            }
        }
 
        public static bool IsHooked { get; private set; } = false;
 
        private static IntPtr? _hookIntPtr { get; set; }
 
        private static WinEventDelegate _delegate { get; set; }
 
        private static Window _window { get; set; }
    }
}

L'adresse du fil où j'ai trouvé ce code : http://stackoverflow.com/questions/7...rom-minimizing