BoolToVisibilityConverter.cs

이 파일의 문서화 페이지로 가기

using System;
using System.Globalization;
using System.Linq;
using System.Windows;
using System.Windows.Data;
 
namespace Dreamine.UI.Wpf.Converters
{
    public sealed class BoolToVisibilityConverter : IValueConverter
    {
        public bool Inverse { get; set; } = false;

        public bool UseHidden { get; set; } = false;

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            // \brief Read options from instance properties first.
            bool inverse = Inverse;
            bool useHidden = UseHidden;
 
            // \brief Allow ConverterParameter to override / augment options.
            ApplyOptionsFromParameter(parameter, ref inverse, ref useHidden);
 
            // \brief Normalize input to bool.
            bool val = ToBoolSafe(value);
 
            if (inverse)
                val = !val;
 
            return val
                ? Visibility.Visible
                : (useHidden ? Visibility.Hidden : Visibility.Collapsed);
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            bool inverse = Inverse;
            bool useHidden = UseHidden; // \brief Not used directly in ConvertBack, but parsed for symmetry.
            ApplyOptionsFromParameter(parameter, ref inverse, ref useHidden);
 
            Visibility vis = value is Visibility v ? v : Visibility.Collapsed;
 
            bool result = (vis == Visibility.Visible);
            return inverse ? !result : result;
        }

        private static bool ToBoolSafe(object? value)
        {
            if (value == null)
                return false;
 
            // \brief Direct bool (covers boxed bool)
            if (value is bool b)
                return b;
 
            // \brief Nullable<bool> comes in boxed as bool when HasValue == true,
            //        so no separate "bool?" pattern is required.
            //        (This avoids CS8116 entirely.)
 
            // \brief String handling
            if (value is string s)
            {
                if (bool.TryParse(s, out bool parsedBool))
                    return parsedBool;
 
                if (int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out int parsedInt))
                    return parsedInt != 0;
            }
 
            // \brief Numeric handling
            if (value is byte by) return by != 0;
            if (value is short sh) return sh != 0;
            if (value is int it) return it != 0;
            if (value is long lo) return lo != 0;
 
            // \brief Last-resort conversion
            try
            {
                return System.Convert.ToBoolean(value, CultureInfo.InvariantCulture);
            }
            catch
            {
                return false;
            }
        }
 

        private static void ApplyOptionsFromParameter(object parameter, ref bool inverse, ref bool useHidden)
        {
            if (parameter == null)
                return;
 
            // \brief bool parameter: treat as inverse override.
            if (parameter is bool b)
            {
                inverse = b;
                return;
            }
 
            // \brief Visibility parameter: Hidden implies UseHidden.
            if (parameter is Visibility vis)
            {
                useHidden = (vis == Visibility.Hidden);
                return;
            }
 
            // \brief string parameter: parse tokens.
            if (parameter is string s)
            {
                var tokens = s
                    .Split(new[] { ',', ';', '|', ' ' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(t => t.Trim())
                    .Where(t => !string.IsNullOrWhiteSpace(t))
                    .ToArray();
 
                foreach (var token in tokens)
                {
                    if (token.Equals("Inverse", StringComparison.OrdinalIgnoreCase))
                        inverse = true;
 
                    if (token.Equals("Hidden", StringComparison.OrdinalIgnoreCase) ||
                        token.Equals("UseHidden", StringComparison.OrdinalIgnoreCase))
                        useHidden = true;
 
                    if (token.Equals("Collapsed", StringComparison.OrdinalIgnoreCase))
                        useHidden = false;
                }
            }
        }
    }
}