OnMouseEnter for all controls on a form

Question

I have OnMouseEnter and OnMouseLeave event handlers setup for my form. When the mouse moves over the form I want to set the opacity to 100% and when it moves away I want to set it to 25%. It works well, except when the mouse moves over one of the buttons on the form. The OnMouseLeave event fires and hides the form again. Is there a good way to handle this, without having to wire up OnMouseEnter for every control on the form?

Answer 1

I think it is impossible to do, without handling the MouseEnter and MouseLeave events of all the children, but you do not have to wire them manually.

Here is some code I copied & pasted from a project of mine. It does almost what you described here. I actually copied the idea and the framework from this site.

In the constructor I call the AttachMouseOnChildren() to attach the events.

The OnContainerEnter and OnContainerLeave are used to handle the mouse entering/leaving the form itself.

    #region MouseEnter & Leave

    private bool _childControlsAttached = false;

    /// <summary>
    /// Attach enter & leave events to child controls (recursive), this is needed for the ContainerEnter & 
    /// ContainerLeave methods.
    /// </summary>
    private void AttachMouseOnChildren() {
        if (_childControlsAttached) {
            return;
        }
        this.AttachMouseOnChildren(this.Controls);
        _childControlsAttached = true;
    }

    /// <summary>
    /// Attach the enter & leave events on a specific controls collection. The attachment
    /// is recursive.
    /// </summary>
    /// <param name="controls">The collection of child controls</param>
    private void AttachMouseOnChildren(System.Collections.IEnumerable controls) {
        foreach (Control item in controls) {
            item.MouseLeave += new EventHandler(item_MouseLeave);
            item.MouseEnter += new EventHandler(item_MouseEnter);
            this.AttachMouseOnChildren(item.Controls);
        }
    }

    /// <summary>
    /// Will be called by a MouseEnter event, with any of the controls within this
    /// </summary>
    void item_MouseEnter(object sender, EventArgs e) {
        this.OnMouseEnter(e);
    }

    /// <summary>
    /// Will be called by a MouseLeave event, with any of the controls within this
    /// </summary>
    void item_MouseLeave(object sender, EventArgs e) {
        this.OnMouseLeave(e);
    }

    /// <summary>
    /// Flag if the mouse is "entered" in this control, or any of its children
    /// </summary>
    private bool _containsMouse = false;

    /// <summary>
    /// Is called when the mouse entered the Form, or any of its children without entering
    /// the form itself first.
    /// </summary>
    protected void OnContainerEnter(EventArgs e) {
        // No longer transparent
        this.Opacity = 1;
    }

    /// <summary>
    /// Is called when the mouse leaves the form. When the mouse leaves the form via one of
    /// its children, this will also call OnContainerLeave
    /// </summary>
    /// <param name="e"></param>
    protected void OnContainerLeave(EventArgs e) {
        this.Opacity = DEFAULT_OPACITY;
    }

    /// <summary>
    /// <para>Is called when a MouseLeave occurs on this form, or any of its children</para>
    /// <para>Calculates if OnContainerLeave should be called</para>
    /// </summary>
    protected override void OnMouseLeave(EventArgs e) {
        Point clientMouse = PointToClient(Control.MousePosition);
        if (!ClientRectangle.Contains(clientMouse)) {
            this._containsMouse = false;
            OnContainerLeave(e);
        }
    }
    /// <summary>
    /// <para>Is called when a MouseEnter occurs on this form, or any of its children</para>
    /// <para>Calculates if OnContainerEnter should be called</para>
    /// </summary>
    protected override void OnMouseEnter(EventArgs e) {
        if (!this._containsMouse) {
            _containsMouse = true;
            OnContainerEnter(e);
        }
    }

    #endregion

Answer 2

EDIT: I'm going to leave this answer here, even though it can't be made to work reliably. The reason: to prevent somebody else from trying the same thing. See end of message for the reason it won't work.

You can do this fairly easily for the client rectangle by getting the cursor position and checking to see if it's within the Form's client area:

private void Form1_MouseLeave(object sender, EventArgs e)
{
    Point clientPos = PointToClient(Cursor.Position);
    if (!ClientRectangle.Contains(clientPos))
    {
        this.Opacity = 0.25;
    }
}

This assumes that none of your child controls will be changing the opacity.

However, you'll find that it's a less than perfect solution, because when the mouse goes to the title bar, the Form goes to 0.25%. You could fix that by checking to see if the mouse position is within the window rect (using the Bounds property), but then your window will remain opaque if the mouse moves off the title bar and out of the window.

You have a similar problem when entering the title bar from outside.

I think you'll have to handle the WM_NCMOUSEENTER and WM_NCMOUSELEAVE messages in order to make this work reliably.

Why it can't work: Even handling the non-client area notifications can fail. It's possible for the mouse to enter on a child control, which would prevent the Form from being notified.

Answer 3

I think one way to reliably handle the mouse events you're interested is to set up an IMessageFilter on your Application object from which you can intercept all mouse messages (WM_MOUSEMOVE etc ..) even if they are sent to child controls of the form.

Here's some demo code:

using System;
using System.Windows.Forms;

namespace Test
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        public static Form frm = null;
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            frm = new Form1 {Opacity = 0.25};
            frm.Controls.Add(new Button{Dock = DockStyle.Fill, Text = "Ok"});

            Application.AddMessageFilter(new MouseMoveFilter());
            Application.Run(frm);
        }
    }

    public class MouseMoveFilter : IMessageFilter
    {
        #region IMessageFilter Members
        private const int WM_MOUSELEAVE     = 0x02A3;
        private const int WM_NCMOUSEMOVE    = 0x0A0;
        private const int WM_MOUSEMOVE      = 0x0200;
        private const int WM_NCMOUSELEAVE   = 0x2A2;

        public bool PreFilterMessage(ref Message m)
        {
            switch (m.Msg)
            {
                case WM_NCMOUSEMOVE:
                case WM_MOUSEMOVE:
                    Program.frm.Opacity = 1;
                    break;

                case WM_NCMOUSELEAVE:
                case WM_MOUSELEAVE:
                    if (!Program.frm.Bounds.Contains(Control.MousePosition))
                        Program.frm.Opacity = 0.25;
                    break;

            }
            return false;
        }

        #endregion
    }
}

Alternatively you can inherit from Form class and override PreProcessMessage() to accomplish the same thing ...