Why are Maximize/Minimize events causing the Close Button to be re-enabled after disabling it?

I have used P/Invoke to call GetSystemMenu and EnableMenuItem (win32api) to disable the close functionality. However, after minimizing or maximizing my Windows Forms application the button is re-enabled.

Obviously minimizing or maximizing is causing the behavior, but how? I'm not sure where to look to prevent this behavior.

Should I be preventing the maximize and minimize behavior or is there something particularly wrong with the way in which I P/Invoked the calls? Once the application (main form) has loaded, I call the static method from a button click.

class PInvoke
{
    // P/Invoke signatures
    [DllImport("user32.dll")]
    static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
    [DllImport("user32.dll")]
    static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);

    // SysCommand (WM_SYSCOMMAND) constant
    internal const UInt32 SC_CLOSE = 0xF060;

    // Constants used with Add/Check/EnableMenuItem
    internal const UInt32 MF_BYCOMMAND = 0x00000000;
    internal const UInt32 MF_ENABLED = 0x00000000;
    internal const UInt32 MF_GRAYED = 0x00000001;
    internal const UInt32 MF_DISABLED = 0x00000002;

    /// <summary>
    /// Sets the state of the Close (X) button and t开发者_开发知识库he System Menu close functionality.
    /// </summary>
    /// <param name="window">Window or Form</param>
    /// <param name="bEnabled">Enabled state</param>
    public static void EnableCloseButton(IWin32Window window, bool bEnabled)
    {
        IntPtr hSystemMenu = GetSystemMenu(window.Handle, false);

        EnableMenuItem(hSystemMenu, SC_CLOSE, MF_BYCOMMAND | (bEnabled ? MF_ENABLED : MF_GRAYED));
    }
}

Each window has a window class, which defines styles for all windows of that class. You can use CS_NOCLOSE class style to remove the close button for windows of that class. See here and here for details how to set this class flag.

If this doesn't give you what you want, I wouldn't disable minimize/maximize for sake of usability, but you could listen for minimize/maximimize events and re-run the code to disable the close button. Finally, it is possible to handle the close event, and simply not close. Then you know your window will definitely not be closed, even if the close button does inadvertently become enabled.

The accepted answer does propose a possible workaround to the problem (and one that I've used many times), but it simply doesn't answer the question that was originally asked:

How/why does maximizing or minimizing the form cause the close button to be re-enabled after it was disabled using the GetSystemMenu and EnableMenuItem API functions?

I arrived at this question during the course of a completely fruitless Google search after discovering this seemingly unexplainable behavior for myself. Not finding an answer that actually explained the behavior,
I was forced to resort to some digging of my own.

For reference, note that the exact same code as shown in the original question works fine in a native Win32 application. The re-enabling of the Close menu item seems limited to WinForms applications.

Studying the source code for the System.Windows.Forms.Form class uncovers an interesting implementation detail: The .NET Framework designers apparently decided to adjust the form's system menu each time that the form's WindowState changes, which includes maximize and minimize events sent by the system.

Specifically, there are two methods by the name AdjustSystemMenu that are responsible for altering the system menu in response to the these events (and messing up any customization that you may have done yourself). If you're interested in examining the code (which I have abstained from posting here for the benefit of those involved with projects such as Mono), grab a free copy of .NET Reflector.

I'm not entirely sure why this decision was made, but at least I have my explanation now.

I had the same requirement. After trying several ways to disable the close menu option and then deleting and trying to recreate it (correctly), I found this hack from Microsoft http://support.microsoft.com/kb/184686 .

Works like a charm. It's still a hack, but it works.

Here's my (loose) C# conversion of the VB original

        [System.Runtime.InteropServices.DllImport("user32.dll")]
    static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);

    [System.Runtime.InteropServices.DllImport("user32.dll")]
    static extern int GetMenuItemCount(IntPtr hMenu);

    [System.Runtime.InteropServices.DllImport("user32.dll")]
    static extern bool DrawMenuBar(IntPtr hWnd);


    public static void EnableCloseButton(Form frm, bool enabled) {
        IntPtr hMenu;
        int n;
        hMenu = GetSystemMenu(frm.Handle, false);
        if (hMenu != IntPtr.Zero) {
            n = GetMenuItemCount(hMenu);
            if (n > 0) {
                if (enabled) {
                    EnableClose(frm);
                }
                else {
                    DisableClose(frm);
                }
                SendMessage(frm.Handle, WM_NCACTIVATE, (IntPtr)1, (IntPtr)0);
                DrawMenuBar(frm.Handle);
                Application.DoEvents();
            }
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct MENUITEMINFO {
        public uint cbSize;
        public uint fMask;
        public uint fType;
        public uint fState;
        public int wID;
        public int hSubMenu;
        public int hbmpChecked;
        public int hbmpUnchecked;
        public int dwItemData;
        public string dwTypeData;
        public uint cch;
        //    public int hbmpItem;
    }

    internal const UInt32 SC_CLOSE = 0xF060;

    //SetMenuItemInfo fMask constants.
    const UInt32 MIIM_STATE = 0x1;
    const UInt32 MIIM_ID = 0x2;

    //'SetMenuItemInfo fState constants.
    const UInt32 MFS_ENABLED = 0x0;
    const UInt32 MFS_GRAYED = 0x3;
    const UInt32 MFS_CHECKED = 0x8;

    internal const int MFS_DEFAULT = 0x1000;

    [DllImport("user32.dll")]
    static extern bool SetMenuItemInfo(IntPtr hMenu, int uItem, bool fByPosition, [In] ref MENUITEMINFO lpmii);

    [DllImport("user32.dll")]
    static extern bool GetMenuItemInfo(IntPtr hMenu, int uItem, bool fByPosition, ref MENUITEMINFO lpmii);

    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);

    private const UInt32 WM_NCACTIVATE = 0x0086;

    private static void DisableClose(Form frm) {
        IntPtr hMenu;
        int n;
        hMenu = GetSystemMenu(frm.Handle, false);
        if (hMenu != IntPtr.Zero) {
            MENUITEMINFO mif = new MENUITEMINFO();
            mif.cbSize = (uint)Marshal.SizeOf(typeof(MENUITEMINFO));
            mif.fMask = MIIM_ID | MIIM_STATE;
            mif.fType = 0;
            mif.dwTypeData = null;
            bool a = GetMenuItemInfo(hMenu, (int)SC_CLOSE, false, ref mif);
            mif.fState = MFS_GRAYED;
            SetMenuItemInfo(hMenu, (int)SC_CLOSE, false, ref mif);
            SendMessage(frm.Handle, WM_NCACTIVATE, (IntPtr)1, (IntPtr)0);

            mif.wID = -10;
            mif.fState = MFS_GRAYED;
            SetMenuItemInfo(hMenu, (int)SC_CLOSE, false, ref mif);
        }
    }

    private static void EnableClose(Form frm) {
        IntPtr hMenu;
        int n;
        hMenu = GetSystemMenu(frm.Handle, false);
        if (hMenu != IntPtr.Zero) {
            MENUITEMINFO mif = new MENUITEMINFO();
            mif.cbSize = (uint)Marshal.SizeOf(typeof(MENUITEMINFO));
            mif.fMask = MIIM_ID | MIIM_STATE;
            mif.fType = 0;
            mif.dwTypeData = null;
            bool a = GetMenuItemInfo(hMenu, -10, false, ref mif);
            mif.wID = (int)SC_CLOSE;
            SetMenuItemInfo(hMenu, -10, false, ref mif);
            SendMessage(frm.Handle, WM_NCACTIVATE, (IntPtr)1, (IntPtr)0);

            mif.fState = MFS_ENABLED;
            SetMenuItemInfo(hMenu, (int)SC_CLOSE, false, ref mif);
            SendMessage(frm.Handle, WM_NCACTIVATE, (IntPtr)1, (IntPtr)0);
        }
    }