R – Display the menu for a ToolStripDropDownButton as a context menu

winforms

I have a tool strip which contains a ToolStripDropDownButton. As an alternative access method, I would also like to be able to display this button's dropdown menu as a context menu, when the user right-clicks in the area below the tool strip.

I tried the following code, but it didn't work (it displayed the button's dropdown in the normal location, directly under the button):

Point contextMenuLocation = [get from WM_CONTEXTMENU]
myButton.DropDown.Show( contextMenuLocation );

The best idea I can think of would be to copy the toolstrip items from the button's dropdown into a ContextMenuStrip, but I don't see any simple way to do that (ToolStripItem does not implement ICloneable or a Clone method). Tool strip items store a reference to their Parent, so I can't just add the existing items to the context menu, as that would break the button.

Does anybody have a good idea on how to accomplish this?

Best Answer

A good way of populating two different dropdown with the same items is to extract the items creation into a function that builds the necessary drop down just before you open any instance of that dropdown. This also lets you enable a disable stuff if the application state changes.

class A
{
    public A()
    {
        button = new ToolStripDropDownButton();
        button.DropDown = new ToolStripDropDown();

        ToolStripDropDown dropDown = new ToolStripDropDown();
        dropDown.Opening += DropDownOpening;
        menu.Items.DropDown = dropDown;

    }

    void DropDownOpening(object sender, EventArgs e)
    {
        ToolStripDropDown dropDown = sender as ToolStripDropDown;
        if(dropDown != null) 
        {
            dropDown.Items.Clear();
            BuildMenu(dropDown);
        }
        else
        {
            // throw if you like
        }
    }

    void BuildMenu(ToolStripDropDown dropDown)
    {
        // TODO : Add items to dropdown
        // TODO : Take decisions depending on current application state
    }

    ToolStripDropDownButton button;
    MenuStrip menu;
}

Related Solutions

R – ToolStrip Overflow

I wrote something very similar to this awhile ago. The code I used is pasted below, and you are free to modify it to suit your needs.

The ToolStripCustomiseMenuItem is basically your "More" button that populates a DropDown Context Menu when clicked. Hope this helps you, at the very least this should be a good starting point…

  public class ToolStripCustomiseMenuItem : ToolStripDropDownButton {
        public ToolStripCustomiseMenuItem()
            : base("Add Remove Buttons") {
            this.Overflow = ToolStripItemOverflow.Always;
            DropDown = CreateCheckImageContextMenuStrip();
        }

    ContextMenuStrip checkImageContextMenuStrip = new ContextMenuStrip();
    internal ContextMenuStrip CreateCheckImageContextMenuStrip() {
        ContextMenuStrip checkImageContextMenuStrip = new ContextMenuStrip();
        checkImageContextMenuStrip.ShowCheckMargin = true;
        checkImageContextMenuStrip.ShowImageMargin = true;
        checkImageContextMenuStrip.Closing += new ToolStripDropDownClosingEventHandler(checkImageContextMenuStrip_Closing);
        checkImageContextMenuStrip.Opening += new CancelEventHandler(checkImageContextMenuStrip_Opening);
        DropDownOpening += new EventHandler(ToolStripAddRemoveMenuItem_DropDownOpening);
        return checkImageContextMenuStrip;
    }

    void checkImageContextMenuStrip_Opening(object sender, CancelEventArgs e) {

    }

    void ToolStripAddRemoveMenuItem_DropDownOpening(object sender, EventArgs e) {
        DropDownItems.Clear();
        if (this.Owner == null) return;
        foreach (ToolStripItem ti in Owner.Items) {
            if (ti is ToolStripSeparator) continue;
            if (ti == this) continue;
            MyToolStripCheckedMenuItem itm = new MyToolStripCheckedMenuItem(ti);
            itm.Checked = ti.Visible;
            DropDownItems.Add(itm);
        }
    }

    void checkImageContextMenuStrip_Closing(object sender, ToolStripDropDownClosingEventArgs e) {
        if (e.CloseReason == ToolStripDropDownCloseReason.ItemClicked) {
            e.Cancel = true;
        }
    }
}

internal class MyToolStripCheckedMenuItem : ToolStripMenuItem {
    ToolStripItem tsi;
    public MyToolStripCheckedMenuItem(ToolStripItem tsi)
        : base(tsi.Text) {
        this.tsi = tsi;
        this.Image = tsi.Image;
        this.CheckOnClick = true;
        this.CheckState = CheckState.Checked;
        CheckedChanged += new EventHandler(MyToolStripCheckedMenuItem_CheckedChanged);
    }

    void MyToolStripCheckedMenuItem_CheckedChanged(object sender, EventArgs e) {
        tsi.Visible = this.Checked;
    }

}

C# – How to show a Context Menu when you right click a Menu Item

Edit, due to a comment:

In:

protected override void OnClick(EventArgs e)
{
    if (SecondaryContextMenu == null || MouseButtons != MouseButtons.Right)
    {
        base.OnClick(e);
    }
}

this part

 MouseButtons != MouseButtons.Right

should and does compile as it is a call to Control.MouseButtons. Since the Form inherits Control class, it is sufficient to call MouseButtons property directly.

Hope this helps:

public partial class Form1 : Form
{
    class CustomToolStripMenuItem : ToolStripMenuItem
    {
        private ContextMenuStrip secondaryContextMenu;

        public ContextMenuStrip SecondaryContextMenu
        {
            get
            {
                return secondaryContextMenu;
            }
            set
            {
                secondaryContextMenu = value;
            }
        }

        public CustomToolStripMenuItem(string text)
            : base(text)
        { }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (secondaryContextMenu != null)
                {
                    secondaryContextMenu.Dispose();
                    secondaryContextMenu = null;
                }
            }

            base.Dispose(disposing);
        }

        protected override void OnClick(EventArgs e)
        {
            if (SecondaryContextMenu == null || MouseButtons != MouseButtons.Right)
            {
                base.OnClick(e);
            }
        }
    }

    class CustomContextMenuStrip : ContextMenuStrip
    {
        private bool secondaryContextMenuActive = false;
        private ContextMenuStrip lastShownSecondaryContextMenu = null;

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (lastShownSecondaryContextMenu != null)
                {
                    lastShownSecondaryContextMenu.Close();
                    lastShownSecondaryContextMenu = null;
                }
            }
            base.Dispose(disposing);
        }

        protected override void OnControlAdded(ControlEventArgs e)
        {
            e.Control.MouseClick += new MouseEventHandler(Control_MouseClick);
            base.OnControlAdded(e);
        }

        protected override void OnControlRemoved(ControlEventArgs e)
        {
            e.Control.MouseClick -= new MouseEventHandler(Control_MouseClick);
            base.OnControlRemoved(e);
        }

        private void Control_MouseClick(object sender, MouseEventArgs e)
        {
            ShowSecondaryContextMenu(e);
        }

        protected override void OnMouseClick(MouseEventArgs e)
        {
            ShowSecondaryContextMenu(e);
            base.OnMouseClick(e);
        }

        private bool ShowSecondaryContextMenu(MouseEventArgs e)
        {
            CustomToolStripMenuItem ctsm = this.GetItemAt(e.Location) as CustomToolStripMenuItem;

            if (ctsm == null || ctsm.SecondaryContextMenu == null || e.Button != MouseButtons.Right)
            {
                return false;
            }

            lastShownSecondaryContextMenu = ctsm.SecondaryContextMenu;
            secondaryContextMenuActive = true;
            ctsm.SecondaryContextMenu.Closed += new ToolStripDropDownClosedEventHandler(SecondaryContextMenu_Closed);
            ctsm.SecondaryContextMenu.Show(Cursor.Position);
            return true;
        }

        void SecondaryContextMenu_Closed(object sender, ToolStripDropDownClosedEventArgs e)
        {
            ((ContextMenuStrip)sender).Closed -= new ToolStripDropDownClosedEventHandler(SecondaryContextMenu_Closed);
            lastShownSecondaryContextMenu = null;
            secondaryContextMenuActive = false;
            Focus();
        }

        protected override void OnClosing(ToolStripDropDownClosingEventArgs e)
        {
            if (secondaryContextMenuActive)
            {
                e.Cancel = true;
            }

            base.OnClosing(e);
        }
    }

    public Form1()
    {
        InitializeComponent();


        CustomToolStripMenuItem itemPrimary1 = new CustomToolStripMenuItem("item primary 1");
        itemPrimary1.SecondaryContextMenu = new ContextMenuStrip();
        itemPrimary1.SecondaryContextMenu.Items.AddRange(new ToolStripMenuItem[] { 
            new ToolStripMenuItem("item primary 1.1"),
            new ToolStripMenuItem("item primary 1.2"),
        });

        CustomToolStripMenuItem itemPrimary2 = new CustomToolStripMenuItem("item primary 2");
        itemPrimary2.DropDownItems.Add("item primary 2, sub 1");
        itemPrimary2.DropDownItems.Add("item primary 2, sub 2");
        itemPrimary2.SecondaryContextMenu = new ContextMenuStrip();
        itemPrimary2.SecondaryContextMenu.Items.AddRange(new ToolStripMenuItem[] { 
            new ToolStripMenuItem("item primary 2.1"),
            new ToolStripMenuItem("item primary 2.2"),
        });

        CustomContextMenuStrip primaryContextMenu = new CustomContextMenuStrip();
        primaryContextMenu.Items.AddRange(new ToolStripItem[]{
            itemPrimary1,
            itemPrimary2
        });

        this.ContextMenuStrip = primaryContextMenu;
    }
}

Best Answer

Related Solutions

R – ToolStrip Overflow

C# – How to show a Context Menu when you right click a Menu Item

Related Topic