comment positionner une MessageBox ?

**DI_2007** · 11/04/2007, 15h40

Bonjour
J'aimerais savoir si il existe un moyen pour positionner une messagebox au dessus de la fenetre principale et non pas au milieu de l'écran par défaut apparemment.
Par exemple si un message d'erreur intervient sur une calculatrice de petite taille la boite s'affiche au dessus de cette dernière.
Merci de votre aide.

**abelman** · 11/04/2007, 23h32

Bonsoir,

Soit vous faites votre propre classe MessageBox, ce qui vous permettra de la placer comme vous le souhaitez.
Soit vous utiliser un Hook (API SetWindowsHookEx) pour intercepter l'affichage de la fenêtre MessageBox.Show et la replacer comme bon vous semble avant son affichage.

**vladvad** · 16/04/2008, 03h34

Envoyé par abelman

Bonsoir,

Soit vous faites votre propre classe MessageBox, ce qui vous permettra de la placer comme vous le souhaitez.
Soit vous utiliser un Hook (API SetWindowsHookEx) pour intercepter l'affichage de la fenêtre MessageBox.Show et la replacer comme bon vous semble avant son affichage.

Hello !

Je ne comprends pas trop la réponse ... Comment intégrer ces "SetWindowsHookEx" dans le code C# ?

Merci !

**smyley** · 16/04/2008, 04h58

Et voilà

Code c# :

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
#region Théorème du bazooka tueur de fourmi
 
        [DllImport("user32.dll", SetLastError = true)]
        static extern IntPtr SetWindowsHookEx(HookType hook, HookProc callback,
           IntPtr hMod, uint dwThreadId);
 
        public enum HookType : int
        {
            WH_JOURNALRECORD = 0,
            WH_JOURNALPLAYBACK = 1,
            WH_KEYBOARD = 2,
            WH_GETMESSAGE = 3,
            WH_CALLWNDPROC = 4,
            WH_CBT = 5,
            WH_SYSMSGFILTER = 6,
            WH_MOUSE = 7,
            WH_HARDWARE = 8,
            WH_DEBUG = 9,
            WH_SHELL = 10,
            WH_FOREGROUNDIDLE = 11,
            WH_CALLWNDPROCRET = 12,
            WH_KEYBOARD_LL = 13,
            WH_MOUSE_LL = 14
        }
 
        delegate int HookProc(int code, IntPtr wParam, IntPtr lParam);
 
        [DllImport("kernel32.dll")]
        static extern uint GetCurrentThreadId();
 
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr GetModuleHandle(string lpModuleName);
 
        [DllImport("user32.dll")]
        static extern bool UnhookWindowsHookEx(IntPtr hhk);
 
        [DllImport("user32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags);
 
        public const int SWP_NOSIZE = 0x1;
        public const int SWP_NOZORDER = 0x4;
        public const int SWP_NOACTIVATE = 0x10;
 
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
 
        [Serializable, StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
 
            public RECT(int left_, int top_, int right_, int bottom_)
            {
                Left = left_;
                Top = top_;
                Right = right_;
                Bottom = bottom_;
            }
 
            public int Height { get { return Bottom - Top; } }
            public int Width { get { return Right - Left; } }
            public Size Size { get { return new Size(Width, Height); } }
 
            public Point Location { get { return new Point(Left, Top); } }
 
            // Handy method for converting to a System.Drawing.Rectangle
            public Rectangle ToRectangle()
            { return Rectangle.FromLTRB(Left, Top, Right, Bottom); }
 
            public static RECT FromRectangle(Rectangle rectangle)
            {
                return new RECT(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom);
            }
 
            public override int GetHashCode()
            {
                return Left ^ ((Top << 13) | (Top >> 0x13))
                  ^ ((Width << 0x1a) | (Width >> 6))
                  ^ ((Height << 7) | (Height >> 0x19));
            }
 
            #region Operator overloads
 
            public static implicit operator Rectangle(RECT rect)
            {
                return rect.ToRectangle();
            }
 
            public static implicit operator RECT(Rectangle rect)
            {
                return FromRectangle(rect);
            }
 
            #endregion
        }
 
        IntPtr hHook = IntPtr.Zero;
 
        Point newPosition = new Point(5, 5);
 
        int HookFunction(int code, IntPtr wParam, IntPtr lParam)
        {
            const int HCBT_ACTIVATE = 5;
 
            if (code == HCBT_ACTIVATE)
            {
                RECT rect;
                GetWindowRect(wParam, out rect);
                SetWindowPos(wParam, IntPtr.Zero, newPosition.X, newPosition.Y, rect.Width, rect.Height,
                    SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
 
                UnhookWindowsHookEx(hHook);
 
                hHook = IntPtr.Zero;
            }
 
            return 0;
        }
 
        #endregion
 
 
        #region Fonction affichant la boite de message
        private void ShowPositionnedMessageBox(string text, string titre, MessageBoxButtons messageBoxButtons, MessageBoxIcon messageBoxIcon, int x, int y)
        {
            newPosition = new Point(x, y);
            hHook = IntPtr.Zero;
 
            hHook = SetWindowsHookEx(HookType.WH_CBT, new HookProc(HookFunction), GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), GetCurrentThreadId());
 
            MessageBox.Show(text, titre, messageBoxButtons, messageBoxIcon);
        }
        #endregion
 
        private void button4_Click(object sender, EventArgs e)
        {
            ShowPositionnedMessageBox("Test de message", "Titre", MessageBoxButtons.OK, MessageBoxIcon.Information, 15, 15);
        }

n'empêche, pour tuer une fourmis on devrait pas avoir besoin d'un bazooka

**SaumonAgile** · 16/04/2008, 10h08

Envoyé par smyley

n'empêche, pour tuer une fourmis on devrait pas avoir besoin d'un bazooka

Certes mais c'est pour cela qu'on peut aussi se diriger vers des composants existants plutôt que de réinventer l'eau chaude à chaque fois.

/me fait sa pub

**neptune** · 16/04/2008, 10h16

Envoyé par smyley

n'empêche, pour tuer une fourmis on devrait pas avoir besoin d'un bazooka

En même temps, on parle de MessageBox, qui est une classe hyper spécialisée et utilisable en une ligne. C'est by design qu'il a été décidé de ne pas pouvoir la positioner.

Pour plus de flexibilité: créer une Form maison.