Custom design time visibility attribute in WPF

Question

I have a complex window with various controls that are visible or collapsed based on bool values. I want to add a custom attribute to show all of these controls during design time. My implementation of the attribute looks like this:

public static class CustomAttributes
{
    private static bool? _inDesignMode;

    public static readonly DependencyProperty Visibility = DependencyProperty.RegisterAttached(
        "Visibility",
        typeof(Visibility),
        typeof(CustomAttributes),
        new PropertyMetadata(VisibilityChanged));

    private static bool InDesignMode
    {
        get
        {
            if (!_inDesignMode.HasValue)
            {
                var prop = DesignerProperties.IsInDesignModeProperty;
                _inDesignMode =
                  (bool)DependencyPropertyDescriptor.FromProperty(prop, typeof(FrameworkElement)).Metadata.DefaultValue;
            }

            return _inDesignMode.Value;
        }
    }

    public static Visibility GetVisibility(DependencyObject dependencyObject)
    {
        return (Visibility)dependencyObject.GetValue(Visibility);
    }

    public static void SetVisibility(DependencyObject dependencyObject, Visibility value)
    {
        dependencyObject.SetValue(Visibility, value);
    }

    private static void VisibilityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (!InDesignMode)
            return;

        d.SetValue(Control.VisibilityProperty, e.NewValue);
    }
}

In XAML I use it like this:

<Button Visibility="{Binding SomeBoolValue, Converter={StaticResource BoolToVisibility}}"
        helper:CustomAttributes.Visibility="Visible" 
/>

However, it does not seem to work. I use some other custom attributes like this and they do their job, but visibility doesn't trigger, it just stays collapsed in the design view. What am I missing?

Edit:

Thank you for pointing me to the right direction. The solution to my problem did not require the custom attribute as I first assumed it would. To achieve the design-time behavior that I wanted, I modified the converter implementation as suggested in the accepted answer below.

Answer 1

Think a little deeper about the logic you created.

The UI element does not have TWO Visibility properties, it is the only one.
But you want to manipulate this property in two ways at the same time: through the binding and the attached property.
Thus, you have created competition between them for this property.
And the property will take on the value that will be assigned to it last.

The attached property will be triggered only once when the Button is initialized (from the example).
And the binding will be triggered when the Data Context and/or its SomeBoolValue property changes.
But the Data Context of the Window is set later than the initialization of the UI elements of this Window.

I see several solutions.
The easiest one, if you need to ALWAYS show elements in Design Mode, is to add the appropriate logic to the converter.
In its simplest form, an example of such a converter:

/// <summary>Bool to Visibility converter.</summary>
[ValueConversion(typeof(bool), typeof(Visibility))]
public class BooleanToVisibilityConverter : IValueConverter
{
    public static bool IsDesignMode { get; } = DesignerProperties.GetIsInDesignMode(new DependencyObject());

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is bool val)
            return IsDesignMode || val 
                ? Visibility.Visible
                : Visibility.Collapsed;

        return DependencyProperty.UnsetValue;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}