I'm trying to create a ContextMenu on a UserControl derived object. Note: This is NOT a WinForms App, it is pure WPF.

So I create the ContextMenu thus:

    <UserControl.Resources>
        <ContextMenu x:Key="cmLCD_CopyCutPaste">
            <MenuItem Name="CutOption"  Header="{x:Static p:Resources.Popup_Cut}" Command="Cut" Click="MenuItem_Cut" IsEnabled="True"/>
            <MenuItem Name="CopyOption" Header="{x:Static p:Resources.Popup_Copy}" Command="Copy" Click="MenuItem_Copy" IsEnabled="True"/>
            <MenuItem Name="PasteOption" Header="{x:Static p:Resources.Popup_Paste}" Command="Paste" Click="MenuItem_Paste" IsEnabled="True"/>
        </ContextMenu>
    </UserControl.Resources>   

The mousebutton event is setup thus:

d:DesignHeight="66" d:DesignWidth="340" Focusable="True" KeyDown="Grid_KeyDown" MouseRightButtonDown="EMS_UI_LCDscreen_MouseRightButtonDown" >

In the code behind, the constructor starts like this:

        public EMS_UI_LCDscreen()
        {
            InitializeComponent();

            // Find the ContextMenu created on this object - it is called cmLCD_CopyCutPaste
            ContextMenu cm = FindResource("cmLCD_CopyCutPaste") as ContextMenu;

            // If we found the contextMenu, assign it the ContextMenu placeholder for this instance.
            if (cm != null)
            {
                ContextMenu = cm;
            }

            ...

The mouse click(right button) is handled like this:

        private void EMS_UI_LCDscreen_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (this.ContextMenu is ContextMenu cm)
            {
                if (cm != null)
                {
                    if (DataContext is DeviceEditorData ded)
                    {
                        cm.DataContext = ded.Device.GetStructuredLocation(0);

                        cm.IsEnabled = true;

                        cm.PlacementTarget = sender as Button;
                        cm.IsOpen = true;
                    }
                }
            }
        }

There are the three event handlers to actually respond to the user selection on the ContextMenu:

        private void MenuItem_Cut(object sender, RoutedEventArgs e)
        {
        }

        private void MenuItem_Copy(object sender, RoutedEventArgs e)
        {
        }

        private void MenuItem_Paste(object sender, RoutedEventArgs e)
        {
        }

View of the ContextMenu being shown on the LCD Image component

The component I have created appears in a few different contexts, but the one I'm mainly interested in is inside of a DataGrid that shows various items of data, each with one of these components. when right clicked, the component faithfully displays the popup context menu as expected..... BUT all the items on the menu are grayed out and basically not enabled. So my question is, what is the missing piece of glue that effectively enables the menu items so that they can be clicked to do the required actions. Most of the answers already seen on the net go into detail of how to do it in a WinForms app, but despite hours of searching, I can find no clear solution to what should be a very simple task of enabling the menu items. Can some kind soul please put me out of my anguish and in a few lines of code show me how to do it! Thank you

CodePudding user response：

So, if you are using DataContext and Binding's, you can do the following

• remove the direct control with event handlers, i.e. Click, and direct setting of Enabled.
• use Binding to bind menu action to the handler inside the view model: Command={Binding CutCommand} (or any other handler).
• use ICommand.CanExecute of the command handler (CutCommand in the sample above). to manage Enabled state of menu item.

So, let's put all together.

In the XAML

<MenuItem Name="CutOption"  Header="{x:Static p:Resources.Popup_Cut}" 
    Command="{Binding CutCommand}"/>

In the ViewModel

class ViewModel: INotifyPropertyChanged
{
    ...
    public ICommand CutCommand { get; }

    public ViewModel()
    {
        //you can just omit second arg if you always can call Cut.
        CutCommand = new RelayCommand(CutHandler, ()=>CanCut())); 
    }
    ...
}

Here RelayCommand is a https://docs.microsoft.com/en-us/windows/communitytoolkit/mvvm/relaycommand or any other implementation of simple command.

If you need to update the Enabled state on-the-fly, you can call CommandManager.InvalidateRequerySuggested(); to reevaluate CanExecute of all commands.

CodePudding user response：

You should remove all code that sets IsEnabled to true. It's redundant as the value is true by default.

The buttons are disabled because you have (accidentally?) attached a command to the MenuItem.Command property but no corresponding command handler.
The framework will try to invoke a CanExecute handler. Since there is no one defined, a default handler is returned that sets CanExecuteRoutedEventArgs.CanExecute to false, which will disable the button (ICommandSource).

Not sure if your intention was to use a command here or you wrongfully guessed the Command property is like a name property (since you have also registered Click event handlers). See Commanding Overview to learn more.

Anyway, this is how you can register a command handler:

You have assigned predefined application commands (cut, copy and paste - the MenuItem.Command string values in your XAML implicitly references the static ApplicationCommands commands). These commands are routed commands (behavior is identical to routed events - in fact routed commands are routed events). Therefore, you must define the command bindings on a parent element of the command source (the element that invokes the command) as the command will bubble up the tree.

A UIElement.CommandBinding consists of the specified CommandBinding.Executed handler and the optional CommandBinding.CanExecute handler.
Use the CanExecute handler to control the disabled states of the command source e.g., a Button. If the command source should be always enabled, simply omit the CanExecute handler.

XAML

<Window>
  <Window.CommandBindings>
    <CommandBinding Command="Cut"
                    CanExecute="CutCommand_CanExecute"
                    Executed="CutCommand_Executed" />
  </Window.CommandBindings>
</Window>

C#

partial class MainWindow : Window
{
  public MainWindow()
  {
    InitializeComponent();

    var cutCommandBinding = 
      new CommandBinding(ApplicationCommands.Cut, CutCommand_Executed, CutCommand_CanExecute)
    this.CommandBindings.Add(cutCommandBinding);
  }
}

Then create the corresponding command handlers in the code-behind.

private void CutCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
{
  // Verify relevant conditions and set CanExecuteRoutedEventArgs.CanExecute accordingly
  e.CanExecute = true;
}

private void CutCommand_Executed(object sender, ExecutedRoutedEventArgs e)
{
  // Execute the command action
}