WPF ComboBox with CheckBoxes bound to flags enumeration TwoWay - wpf

Question

I am in the middle of creating WPF utility library but I'm stuck on how to create an easy to use enumeration converter which will help in binding any enumeration to a ComboBox control and when enumeration is declared with [Flags] attribute, ComboBox will contain checkboxes data bound to it. Solution needs to be generic so that it will be easy to use for any enumeration and I suppose it would need fresh pair of eyes of an experienced WPF developer.
So far I've come up with a combination of ObjectDataProvider as a source of enum items and 2 converters, one for ItemsSource and another for SelectedValue.
I used CollectionView as a base class for ItemsSource to use CurrentChanged but it does not work as I tried to raise OnCurrentChanged after the collection has been notified about any CheckBox being checked without converter's ConvertBack being executed.
The problem is that data bound property to which ComboBox SelectedValue property is bound, is not updated unless I'll change the selected item (not tick the checkbox).
I've set IsSynchronizedWithCurrentItem but it did not help.
How to force updating of SelectedValue from data bound object? I have a freedom of choice so the solution might involve custom attached properties, inheriting from ComboBox etc. Being really new to WPF I think although the solution is almost right as it almost works, there can be a simpler way of getting to it.
Another issue would be how to customize text displayed on ComboBox so it will contain aggregated selections of ticked checkboxes.
I uploaded VS2012 project here. The structure of a project resembles real application with resources held separately (for simplicity in App.xaml).
Sorry I have not included any code but there is a lot of code involved.
Below is the XAML declaration for a CheckBox bound to standard enumeration (although enumeration used is with [Flags]), which works fine and further a CheckBox bound to [Flags] enumeration.
<ComboBox ItemsSource="{Binding Source={StaticResource someItemsSource}}"
SelectedValue="{Binding BindToSomeItems}"
Style="{StaticResource enumComboBox}"/>
<ComboBox ItemsSource="{Binding BindToSomeItems, Converter={local:LocalizedFlagsEnumConverter}}"
IsSynchronizedWithCurrentItem="True"
SelectedValue="{Binding BindToSomeItems, Mode=TwoWay, Converter={local:SelectedFlagsEnumConverter}}"
Style="{StaticResource flagsComboBox}"
/>
And resources (which explain usage of value converters):
<Application.Resources>
<Style x:Key="enumComboBox" TargetType="{x:Type ComboBox}">
<Setter Property="ItemTemplate">
<Setter.Value>
<DataTemplate>
<TextBlock Text="{Binding Path=.,Mode=OneWay, Converter={local:LocalizedEnumConverter}}" Style="{x:Null}"/>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
<Style x:Key="flagsComboBox" TargetType="{x:Type ComboBox}">
<Setter Property="ItemTemplate">
<Setter.Value>
<DataTemplate>
<StackPanel Orientation="Horizontal">
<CheckBox IsChecked="{Binding Path=Checked,Mode=TwoWay}"/>
<TextBlock Text="{Binding Path=Name,Mode=OneWay}"/>
</StackPanel>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
</Application.Resources>

Answer 1

I use a custom Checkbox to do so. It works perfectly and simply. See comments on top of the class to know how to use it.
Hope it helps...
using System;
using System.Windows;
using System.Windows.Controls;
namespace HQ.Wpf.Util.MyControl
{
/// <summary>
/// Usage: Bind EnumFlag and Two way binding on EnumValue instead of IsChecked
/// Example: <myControl:CheckBoxForEnumWithFlagAttribute
/// EnumValue="{Binding SimulationNatureTypeToCreateStatsCacheAtEndOfSimulation, Mode=TwoWay}"
/// EnumFlag="{x:Static Core:SimulationNatureType.LoadFlow }">Load Flow results</myControl:CheckBoxForEnumWithFlagAttribute>
/// </summary>
public class CheckBoxForEnumWithFlagAttribute : CheckBox
{
// ************************************************************************
public static DependencyProperty EnumValueProperty =
DependencyProperty.Register("EnumValue", typeof(object), typeof(CheckBoxForEnumWithFlagAttribute), new PropertyMetadata(EnumValueChangedCallback));
public static DependencyProperty EnumFlagProperty =
DependencyProperty.Register("EnumFlag", typeof(object), typeof(CheckBoxForEnumWithFlagAttribute), new PropertyMetadata(EnumFlagChangedCallback));
// ************************************************************************
public CheckBoxForEnumWithFlagAttribute()
{
base.Checked += CheckBoxForEnumWithFlag_Checked;
base.Unchecked += CheckBoxForEnumWithFlag_Unchecked;
}
// ************************************************************************
private static void EnumValueChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
var checkBoxForEnumWithFlag = dependencyObject as CheckBoxForEnumWithFlagAttribute;
if (checkBoxForEnumWithFlag != null)
{
checkBoxForEnumWithFlag.RefreshCheckBoxState();
}
}
// ************************************************************************
private static void EnumFlagChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
var checkBoxForEnumWithFlag = dependencyObject as CheckBoxForEnumWithFlagAttribute;
if (checkBoxForEnumWithFlag != null)
{
checkBoxForEnumWithFlag.RefreshCheckBoxState();
}
}
// ************************************************************************
public object EnumValue
{
get { return GetValue(EnumValueProperty); }
set { SetValue(EnumValueProperty, value); }
}
// ************************************************************************
public object EnumFlag
{
get { return GetValue(EnumFlagProperty); }
set { SetValue(EnumFlagProperty, value); }
}
// ************************************************************************
private void RefreshCheckBoxState()
{
if (EnumValue != null)
{
if (EnumValue is Enum)
{
Type underlyingType = Enum.GetUnderlyingType(EnumValue.GetType());
dynamic valueAsInt = Convert.ChangeType(EnumValue, underlyingType);
dynamic flagAsInt = Convert.ChangeType(EnumFlag, underlyingType);
base.IsChecked = ((valueAsInt & flagAsInt) > 0);
}
}
}
// ************************************************************************
private void CheckBoxForEnumWithFlag_Checked(object sender, RoutedEventArgs e)
{
RefreshEnumValue();
}
// ************************************************************************
void CheckBoxForEnumWithFlag_Unchecked(object sender, RoutedEventArgs e)
{
RefreshEnumValue();
}
// ************************************************************************
private void RefreshEnumValue()
{
if (EnumValue != null)
{
if (EnumValue is Enum)
{
Type underlyingType = Enum.GetUnderlyingType(EnumValue.GetType());
dynamic valueAsInt = Convert.ChangeType(EnumValue, underlyingType);
dynamic flagAsInt = Convert.ChangeType(EnumFlag, underlyingType);
dynamic newValueAsInt = valueAsInt;
if (base.IsChecked == true)
{
newValueAsInt = valueAsInt | flagAsInt;
}
else
{
newValueAsInt = valueAsInt & ~flagAsInt;
}
if (newValueAsInt != valueAsInt)
{
object o = Enum.ToObject(EnumValue.GetType(), newValueAsInt);
EnumValue = o;
}
}
}
}
// ************************************************************************
}
}