Hide certain XAML defined context menu items unless shift was pressed

Question

I have a DataTemplate that defines the context menu:

I want to add another menu item to the context menu that is only shown if the user held down Shift while opening the Context Menu, using only XAML (maybe create a new attached property App.PowerUserOnly?):

Can this be done in XAML only (if so, how?), or do you have to use code behind?

Edit: The Windows shell also shows advanced options when Shift was held down while opening the context menu. I'm trying to emulate that behavior. For instance, one of the advanced options for an application is to run it as a different user.

I simplified my code to help test out people's suggestions. The project is created in VS2010 with the default WPF Application, named ShiftContextMenu. The App.xaml and App.xaml.cs files are unmodified.

MainWindow.xaml:

MainWindow.xaml.cs:

using System.Collections.Generic;
using System.Windows;
using System.Collections.ObjectModel;

namespace ShiftContextMenu
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            DummyItem[] dummyItems = new DummyItem[] {
                new DummyItem("First"),
                new DummyItem("Second"),
                new DummyItem("Third")
            };
            DummyItems = new ReadOnlyCollection(new List(dummyItems));
            this.DataContext = this;
            InitializeComponent();
        }

        public ReadOnlyCollection DummyItems { get; protected set; }
    }
}

ViewModelBase.cs:

using System.ComponentModel;

namespace ShiftContextMenu
{
    public class ViewModelBase : INotifyPropertyChanged
    {
        protected PropertyChangedEventHandler _propertyChangedEvent;

        protected void SendPropertyChanged(string propertyName)
        {
            if (_propertyChangedEvent != null)
            {
                _propertyChangedEvent(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        public event PropertyChangedEventHandler PropertyChanged
        {
            add
            {
                _propertyChangedEvent += value;
            }
            remove
            {
                _propertyChangedEvent -= value;
            }
        }
    }
}

DummyItem.cs:

using System;
using System.Windows.Input;
using System.Windows;

namespace ShiftContextMenu
{
    public class DummyItem : ViewModelBase
    {
        public string Name { get; protected set; }

        public DummyItem(string name)
        {
            Name = name;
            _sendToRecycleBinCommand = new SendToRecycleBinCommand();
            _deleteCommand = new DeleteCommand();
        }

        protected SendToRecycleBinCommand _sendToRecycleBinCommand;
        protected DeleteCommand _deleteCommand;

        public ICommand SendToRecycleBin { get { return _sendToRecycleBinCommand; } }
        public ICommand Delete { get { return _deleteCommand; } }

        protected class SendToRecycleBinCommand : ICommand
        {
            public void Execute(object parameter)
            {
                MessageBox.Show("Send To Recycle Bin");
            }

            public bool CanExecute(object parameter)
            {
                return true;
            }

            public event EventHandler CanExecuteChanged { add { } remove { } }
        }

        protected class DeleteCommand : ICommand
        {
            public void Execute(object parameter)
            {
                MessageBox.Show("Permanently Delete");
            }

            public bool CanExecute(object parameter)
            {
                return true;
            }

            public event EventHandler CanExecuteChanged { add { } remove { } }
        }
    }
}

kmatyaszek · Accepted Answer

Windows shell behaviour solution:

In this solution I'm using two assemblies:

System.Windows.Interactivity
System.Windows.Forms

Add following namespace to window:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

DataTemplate should look like this:

And in DummyItem class you must add two commands and one property:

private bool _isVisibleDelete;
public bool IsVisibleDelete
{
    get { return _isVisibleDelete; }
    set { _isVisibleDelete = value; SendPropertyChanged("IsVisibleDelete"); }
}

public ICommand ShowMoreOptions { get; private set; }
private void OnShowMoreOptions()
{
    if (System.Windows.Forms.Control.ModifierKeys == System.Windows.Forms.Keys.Shift)
        IsVisibleDelete = true;
}

public ICommand HideMoreOptions { get; private set; }
private void OnHideMoreOptions()
{
    IsVisibleDelete = false;
}

In my example I'm using DelegateCommand from Microsoft.Practices.Prism assembly.

So in ctor DummyItem I have:

 ShowMoreOptions = new DelegateCommand(this.OnShowMoreOptions);
 HideMoreOptions = new DelegateCommand(this.OnHideMoreOptions);

Second solution allow you change this menu dynamically:

You can try something like that:

XAML file:

And in your ViewModel class you should add property and command to change MenyItem visibility property:

private bool _isVisibleDelete;
public bool IsVisibleDelete
{
    get { return _isVisibleDelete; }
    set { _isVisibleDelete = value; RaisePropertyChanged(() => IsVisibleDelete); }
}

public ICommand ShowMoreOptions { get; private set; }
private void OnShowMoreOptions()
{
    IsVisibleDelete = !IsVisibleDelete;
}

Hide certain XAML defined context menu items unless shift was pressed

Answers (2)

Related Questions