Question

My WPF-Application contains a DataGrid with 3 Columns and a disabled Button.
One Column of my DataGrid is a DataGridCheckBoxColumn. Now I want to bind Button’s IsEnabled-Property, to be enable if at least one of them is checked, else remain disabled.

Actually I’ve following implementation:

<Button x:Name="buttonStart" Content="Start" IsEnabled="{Binding Converter={StaticResource ButtonEnableConverter}, ElementName=gridTestCaseChooser}" />

But the Converter is only called once at startup the application. If the DataGrid content change, or I check/uncheck a CheckBox, there isn’t a new call to my converter.

How could I do this?

Answer 1

Using MVVM can be very easy:

1. Declare an ICommand property to execute the logic of the button with a RelayCommand.
2. The items you add must implement INotifyPropertyChanged interface and have a bool IsChecked property firing PropertyChanged event.
3. Every time a new item is added, subscribe to its PropertyChanged event and when removed, remove the hook as well.
4. Every time the hooking method is called, fire the PropertyChanged for the ICommand property.
5. In XAML just bind the button to the ICommand property.

ViewModels

    public class Item: INotifyPropertyChanged
    {
        private bool isChecked;
        public event PropertyChangedEventHandler PropertyChanged;
        public bool IsChecked
        {
            get
            {
                return this.isChecked;
            }
            set
            {
                this.isChecked = value;
                var propertyChangedEvent = PropertyChanged;
                if(propertyChangedEvent != null)
                {
                    propertyChangedEvent(this, new PropertyChangedEventArgs("UpdateSomething");
                }                
            }
        }
    }

    public class MyViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public ICommand UpdateSomething { get; private set; }
        public ObservableCollection<Item> MyItems { get; set; }

        public MyViewModel()
        {
            UpdateSomething = new RelayCommand(MyCommandExecute, MyCommandCanExecute);
            MyItems = new ObservableCollection<Item>();
        }

        private void MyCommandExecute(object parameter)
        {
            // Your logic here.
        }

        private void MyCommandCanExecute(object parameter)
        {
            return MyItems.Any(item => item.IsChecked);
        }

        private void AddItem(Item item)
        {
            item.PropertyChanged += ItemsPropertyChanged;
            MyItems.Add(item);
        }

        private void ItemsPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            var propertyChangedEvent = PropertyChanged;
            if(propertyChangedEvent != null &&
               e.PropertyName == "IsChecked")
            {
                propertyChangedEvent(this, new PropertyChangedEventArgs("UpdateSomething");
            }                
    }