inabox/inabox.wpf/DigitalForms/Designer/Controls/Fields/DFOptionControl.cs

using InABox.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace InABox.DynamicGrid;

public interface IOptionControl
{
    public string? GetValue();
    public void SetValue(string? value);
    public bool IsEmpty();
}

public class ButtonsOptionControl : Grid, IOptionControl
{
    private Action OnChanged;

    private class OptionButton : Border
    {
        public string Option { get; set; }

        private bool _selected { get; set; }

        public bool Selected
        {
            get => _selected;
            set
            {
                _selected = value;
                if (value == true)
                {
                    Background = new SolidColorBrush(Colors.LightGray);
                }
                else if (value == false)
                {
                    Background = new SolidColorBrush(Colors.DarkGray);
                }
            }
        }

        public OptionButton(string option, bool selected)
        {
            Option = option;
            Selected = selected;
        }
    }

    public ButtonsOptionControl(string[] options, Action onChanged, string? defValue)
    {
        OnChanged = onChanged;

        foreach (var option in options)
        {
            ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
            var button = new OptionButton(option, option == defValue);

            var label = new Label()
            {
                Content = option.Replace("\r", "").Replace("\n", "")
            };
            label.HorizontalContentAlignment = HorizontalAlignment.Center;
            label.VerticalContentAlignment = VerticalAlignment.Center;
            button.Child = label;

            button.Margin = new Thickness(
                Children.Count == 0 ? 0.0F : 2.5F,
                0.0F,
                Children.Count == options.Length - 1 ? 0.0F : 2.5F,
                0.0F
            );
            button.Padding = new Thickness(5.0F, 0.0F, 5.0F, 0.0F);

            button.MouseUp += Button_MouseUp;

            button.SetValue(ColumnProperty, Children.Count);
            Children.Add(button);
        }
    }

    private void Button_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
    {
        SelectButton((OptionButton)sender);
        OnChanged();
    }

    private void DeselectButtons()
    {
        foreach (var child in Children)
        {
            if (child is OptionButton childButton)
            {
                childButton.Selected = false;
            }
        }
    }
    private void SelectButton(OptionButton button)
    {
        foreach (var child in Children)
        {
            if (child is OptionButton childButton && childButton != button)
            {
                childButton.Selected = false;
            }
        }
        button.Selected = true;
    }

    public string? GetValue()
    {
        foreach (var child in Children)
        {
            if (child is OptionButton button)
            {
                if (button.Selected)
                {
                    return button.Option;
                }
            }
        }
        return null;
    }

    public void SetValue(string? value)
    {
        var found = false;
        foreach (var child in Children)
        {
            if (child is OptionButton button)
            {
                if (button.Option == value)
                {
                    SelectButton(button);
                    found = true;
                }
            }
        }
        if (!found)
        {
            DeselectButtons();
        }
    }

    public bool IsEmpty() => GetValue() == null;
}

public class RadioOptionControl : Grid, IOptionControl
{
    private Action OnChanged;

    public RadioOptionControl(string[] options, Action onChanged, string? defValue)
    {
        Margin = new Thickness(4,2,4,2);
        
        OnChanged = onChanged;

        foreach (var option in options)
        {
            RowDefinitions.Add(new RowDefinition() { Height = new GridLength(1, GridUnitType.Auto) });
            var button = new RadioButton();
            button.Margin = new Thickness(0, 2, 0, 2);
            button.Content = option.Replace("\r", "").Replace("\n", "");
            button.VerticalContentAlignment = VerticalAlignment.Center;
            button.Padding = new Thickness(5.0F, 0.0F, 5.0F, 0.0F);
            button.SetValue(RowProperty, Children.Count);
            button.Tag = option;
            button.IsChecked = option == defValue;
            button.Checked += Button_Checked;
            button.Unchecked += Button_Checked;
            Children.Add(button);
        }
    }

    private void Button_Checked(object sender, RoutedEventArgs e)
    {
        OnChanged();
    }

    public string? GetValue()
    {
        foreach (var child in Children)
        {
            if (child is RadioButton radio)
            {
                if (radio.IsChecked == true)
                {
                    return radio.Tag as string;
                }
            }
        }
        return null;
    }

    public void SetValue(string? value)
    {
        var found = false;
        foreach (var child in Children)
        {
            if (child is RadioButton radio)
            {
                if ((string)radio.Tag == value)
                {
                    radio.IsChecked = true;
                    found = true;
                }
            }
        }
        if (!found)
        {
            foreach (var child in Children)
            {
                if (child is RadioButton radio)
                {
                    radio.IsChecked = false;
                }
            }
        }
    }
    public bool IsEmpty() => GetValue() == null;
}

public class ComboBoxOptionControl : ComboBox, IOptionControl
{
    private readonly Action OnChanged;

    public ComboBoxOptionControl(string[] options, Action onChanged, string? defValue)
    {
        SetResourceReference(StyleProperty, typeof(ComboBox));

        OnChanged = onChanged;

        foreach (var option in options)
            Items.Add(option);
        SelectedValue = defValue;
        VerticalContentAlignment = VerticalAlignment.Center;
        SelectionChanged += ComboBoxOptionControl_SelectionChanged;
    }

    private void ComboBoxOptionControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        OnChanged();
    }

    public string? GetValue()
    {
        return SelectedValue as string;
    }

    public void SetValue(string? value)
    {
        SelectedValue = value;
    }
    public bool IsEmpty() => GetValue() == null;
}

public class CheckBoxOptionControl : CheckBox, IOptionControl
{
    private readonly Action OnChanged;

    private readonly string TrueValue;
    private readonly string FalseValue;

    private bool? _value;
    private bool Required;

    public CheckBoxOptionControl(string trueValue, string falseValue, Action onChanged, bool required, bool? defValue)
    {
        OnChanged = onChanged;
        TrueValue = trueValue;
        FalseValue = falseValue;
        Required = required;

        IsChecked = defValue ?? (required ? null : false);
        HorizontalContentAlignment = HorizontalAlignment.Center;
        VerticalContentAlignment = VerticalAlignment.Center;
        Checked += CheckBoxOptionControl_Checked;
        Unchecked += CheckBoxOptionControl_Checked;
    }

    private void CheckBoxOptionControl_Checked(object sender, RoutedEventArgs e)
    {
        _value = IsChecked;
        OnChanged();
    }

    public string? GetValue()
    {
        return _value switch
        {
            true => TrueValue,
            false => FalseValue,
            null => null
        };
    }

    public void SetValue(string? value)
    {
        _value = value == TrueValue ? true
            : value == FalseValue ? false
            : null;
        IsChecked = Required ? _value : (_value ?? false);
    }

    public bool IsEmpty() => IsChecked is null;
}

public class DFOptionControl : DynamicFormFieldControl<DFLayoutOptionField, DFLayoutOptionFieldProperties, string, string?>
{
    private IOptionControl OptionControl = null!; // Late-initialised

    protected override FrameworkElement Create()
    {
        var options = string.IsNullOrWhiteSpace(Field.Properties.Options) 
            ? []
            : Field.Properties.Options.Replace(",","\n").Split('\n').ToArray(x => x.Trim());

        return Field.Properties.OptionType switch
        {
            DFLayoutOptionType.Buttons => SetControl(new ButtonsOptionControl(options, ChangeField, Field.Properties.Default)),
            DFLayoutOptionType.Radio => SetControl(new RadioOptionControl(options, ChangeField, Field.Properties.Default)),
            _ => SetControl(new ComboBoxOptionControl(options, ChangeField, Field.Properties.Default)),
        };
    }

    private T SetControl<T>(T value)
        where T : FrameworkElement, IOptionControl
    {
        OptionControl = value;
        return value;
    }

    public override void SetSerializedValue(string? value)
    {
        SetValue(value);
    }

    public override string? GetSerializedValue()
    {
        return OptionControl.GetValue();
    }

    public override string GetValue() => OptionControl.GetValue() ?? "";

    public override void SetValue(string? value) => OptionControl.SetValue(value);

    protected override bool IsEmpty() => OptionControl.IsEmpty();
}