Say Goodbye to Lingering Menus:

Auto-Hiding .NET Context Menus and Dropdowns with a Timer

Context menus and dropdowns are UI workhorses, providing quick access to actions. But when left open after use, they can become a visual nuisance. We need them to politely disappear after a bit of inactivity.

Instead of wrestling with the sometimes-tricky world of mouse event detection as the cursor leaves the menu area, we'll take a straightforward and reliable route: periodic checking with the good old System.Windows.Forms.Timer. This method ensures our menus auto-hide gracefully after the user has moved on, without excessive complexity.

The Problem: Menus That Overstay Their Welcome

You've probably experienced it: a context menu stays open, obscuring part of the application until you manually dismiss it. Forgetting to click elsewhere can lead to a cluttered interface. We want a more intelligent behavior - the menu should vanish when the user is clearly no longer interacting with it.

The Solution: The Patient Timer

Our approach is simple: we'll use a timer to periodically check if the mouse cursor is still within the bounds of any visible part of our menu system (this includes the main context menu and any open sub-menus). If the mouse remains outside for a few consecutive checks, we'll trigger the menu's closure.

The CheckForMice Class

using System.Windows.Forms;
using System.Drawing;
using System;
using System.Collections.Generic;

public class CheckForMice {
    private readonly List<ToolStrip> toolStrips;
    private readonly Action hideAction;
    private readonly Timer hideTimer = new Timer();
    private int mouseAbsentCounter = 0;
    public bool Enabled {
        set { hideTimer.Enabled = value; }
        get { return hideTimer.Enabled; }
    }

    public CheckForMice(List<ToolStrip> toolStrips, Action hideAction, int hideDelay = 300) {
        this.toolStrips = toolStrips;
        this.hideAction = hideAction;
        hideTimer.Interval = hideDelay;   // msec
        hideTimer.Tick += hideTimer_Tick;
    }

    private bool mouseSeenOrMenusHidden() {
        bool allMenusHidden = true;
        Point ptMouse = Control.MousePosition;
        foreach (ToolStrip ts in toolStrips) {
            if (ts.Visible) {
                allMenusHidden = false;
                if (ts.Bounds.Contains(ptMouse)) return true;
            }
        }
        // When the box is closed, Schrödinger's mouse is irrelevant
        return allMenusHidden;
    }

    private void hideTimer_Tick(object sender, EventArgs e) {
        mouseAbsentCounter++;
        if (mouseSeenOrMenusHidden()) mouseAbsentCounter = 0;
        if (mouseAbsentCounter >= 3) hideAction?.Invoke();
    }
}

How to Use It

1. Create an instance of CheckForMice, passing in a list of the ToolStrip controls you want to monitor (initially, this might just be your main ContextMenuStrip), and an Action to execute when the hide condition is met. You can also specify the hideDelay in milliseconds (default is 300ms).
2. Control the enabling and disabling of the auto-hiding behavior using the Enabled property of the CheckForMice instance, typically in response to the Opened and Closed events of your top-level ContextMenuStrip and any dynamically shown submenus. Ensure you add or remove the relevant ToolStripDropDown controls from the list you passed to CheckForMice.

// Example usage (assuming 'contextMenuStrip1' is your main menu):
List<ToolStrip> menusToTrack = new List<ToolStrip> { contextMenuStrip1 };
Action hideMenu = () => { contextMenuStrip1.Hide(); /* Add other cleanup if needed */ };
CheckForMice mouseWatcher = new CheckForMice(menusToTrack, hideMenu, 300);

contextMenuStrip1.Opened += (sender, args) => mouseWatcher.Enabled = true;
contextMenuStrip1.Closed += (sender, args) => mouseWatcher.Enabled = false;

// Example with a submenu (assuming 'subMenu1' is shown from 'contextMenuStrip1'):
subMenu1.Opened += (sender, args) => menusToTrack.Add(subMenu1);
subMenu1.Closed += (sender, args) => menusToTrack.Remove(subMenu1);

The Logic Explained

• The CheckForMice class takes a list of ToolStrip controls to monitor.
• The hideTimer periodically checks if the mouse is within the bounds of any visible ToolStrip in the list.
• The mouseAbsentCounter increments each time the timer ticks and the mouse is not found within the menus.
• After three consecutive "absent" checks, the provided hideAction is invoked.
• If the mouse re-enters the menu area at any point, the mouseAbsentCounter is reset.
• The Enabled property allows you to start and stop the monitoring as needed.

Why This Approach?

This timer-based polling is a straightforward and reliable way to achieve the desired behavior without getting bogged down in complex mouse event tracking outside of the menu's active scope. It's also relatively efficient, especially when the timer is only enabled while the menu system is visible.

Conclusion

Implementing automatic hiding for context menus and dropdowns doesn't have to be complicated. By using a simple timer to periodically check for mouse presence, we can create a user-friendly experience that keeps our application interfaces clean and focused.