BooleanToVisibilityConverter should have Inverse Property

[michael-hawker]

See the Universal Sample Implementation here.

Really helps when you need to take the inverse of the bool for visibility flipping/switching.

[michael-hawker]

Ah, this is supported slightly in a different way with a converterparameter (it is nice to have an always inverse via construction in the resource though) via BoolToObjectConverter.

It's just not documented in the Converter section.

[Odonno]

@michael-hawker Hi. I want to know what you mean by "not documented". I can see this example in the docs and I don't know what we can do more :

<converters:BoolToObjectConverter x:Key="BoolToVisibilityConverter" TrueValue="Visible" FalseValue="Collapsed"/>

[michael-hawker]

@Odonno I'm talking explicitly about inverting the value so a bool of true is collapsed.

This is done in the sample app with the ConverterParameter (which is the piece which wasn't documented that this functionality exists):

Visibility="{Binding Path=IsPaneOpen, Converter={StaticResource BoolToVisibilityConverter}, ConverterParameter=True}"

But I usually prefer to declare an 'InverseBoolToVisibiltyConverter' in my resources, so I could use the paradigm like this:

<converters:BoolToObjectConverter x:Key="InverseBoolToVisibilityConverter" TrueValue="Collapsed" FalseValue="Visible"/>

But since there already is a 'BoolToVisibilityConverter' I was expecting to find the ability to do this (like the sample I linked to from the universal windows samples):

<converters:BoolToVisibilityConverterx:Key="InverseBoolToVisibilityConverter" IsInverse="True"/>

[Odonno]

@michael-hawker I know what you mean. I myself used to use another way to handle inversion of converters (using the ConverterParameter).

Anyway, I don't think we should change the code for the inversion, you can perfectly use BoolToObjectConverter like you said.

And if you want to improve the docs, feel free to make a PR. I suppose it is not bad to have good documentation. :)

[robloo]

I really don't think it should be done this way using the parameter. Thankfully, a really powerful/general solution still works from WPF. I use a converter group to chain together both a converter that inverts a boolean value then a converter that converts boolean to visibility. This reminds me again how many corners were cut in the first UWP implementation... BooleanToVisiblityConverter isn't even in the framework.

The converters (I skipped the BoolToVisiblityConverter which you already have the code for)

    /// <summary>
    /// Converter to chain together multiple converters.
    /// </summary>
    public class ValueConverterGroup : List<IValueConverter>,
                                       IValueConverter
    {
        public object Convert(object value,
                              Type targetType,
                              object parameter,
                              string language)
        {
            object curValue;

            curValue = value;
            for (int i = 0; i < this.Count; i++)
            {
                curValue = this[i].Convert(curValue, targetType, parameter, language);
            }

            return (curValue);
        }

        public object ConvertBack(object value,
                                  Type targetType,
                                  object parameter,
                                  string language)
        {
            object curValue;

            curValue = value;
            for (int i = (this.Count - 1); i >= 0; i--)
            {
                curValue = this[i].ConvertBack(curValue, targetType, parameter, language);
            }

            return (curValue);
        }
    }

    /// <summary>
    /// Inverts a boolean value.
    /// </summary>
    public class InvertBoolConverter : IValueConverter
    {
        public object Convert(object value,
                              Type targetType,
                              object parameter,
                              string language)
        {
            if (value is bool)
            {
                return (!(bool)value);
            }
            else
            {
                throw new ArgumentException("Value must be of the type bool");
            }
        }

        public object ConvertBack(object value,
                                  Type targetType,
                                  object parameter,
                                  string language)
        {
            if (value is bool)
            {
                return (!(bool)value);
            }
            else
            {
                throw new ArgumentException();
            }
        }
    }

The XAML:

Define the converter group in a dictionary some place then anytime it's available as a converter by itself.

    <local:ValueConverterGroup x:Key="InvertBoolToVisibility">
        <local:InvertBoolConverter />
        <local:BoolToVisibilityConverter />
    </local:ValueConverterGroup>

Can be used like:

Visibility="{Binding Path='BoolValue', Mode=OneWay, Converter={StaticResource InvertBoolToVisibility}}"