FancyTextSettings.cs

// ============================================================================
// FancyTextSettings.cs
// Settings panel for the FancyText component.
//
// All controls built in code — no .Designer.cs / .resx needed.
//
// Color pickers use SettingsHelper.ColorButtonClick (FlatStyle.Popup),
// matching the style used by standard LiveSplit components (same as SplitDetail).
//
// XML version history:
//   Version 1 — initial release.  All properties below.
//
// Targeting note:
//   ScopeMode and TargetComponents are stored in XML and used by the runtime
//   hook to decide which other components receive FancyText effects.
// ============================================================================

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;
using System.Xml;
using LiveSplit.Model;
using LiveSplit.UI;

namespace LiveSplit.UI.Components
{
    public class FancyTextSettings : UserControl
    {
        // =====================================================================
        // Public properties  (read by FancyTextComponent every draw)
        // =====================================================================

        // ── Display ───────────────────────────────────────────────────────────
        public string              InstanceName        { get; private set; } = string.Empty;
        public string              DisplayText         { get { return InstanceName; } }
        public FancyTextAlignment  Alignment           { get; private set; } = FancyTextAlignment.Left;
        public FancyTextControllerMode ControllerMode   { get; private set; } = FancyTextControllerMode.Unset;

        // ── Text color ────────────────────────────────────────────────────────
        public bool                     OverrideTextColors  { get; private set; } = false;
        public FancyTextColorMode       ColorMode           { get; private set; } = FancyTextColorMode.Solid;
        public FancyTextGradientMode    GradientMode        { get; private set; } = FancyTextGradientMode.ExistingColors;
        public Color                    TextColor1          { get; private set; } = Color.White;
        public Color                    TextColor2          { get; private set; } = Color.FromArgb(255, 180, 180, 180);
        public Color                    TextColor3          { get; private set; } = Color.FromArgb(255, 40, 160, 200);
        public FancyTextGradientDirection GradientDirection { get; private set; } = FancyTextGradientDirection.Vertical;

        // ── Outline ───────────────────────────────────────────────────────────
        // When OverrideOutline is false, the component uses the layout's
        // TextOutlineColor and the standard size formula.
        public bool  OverrideOutline    { get; private set; } = false;
        public Color OutlineColor       { get; private set; } = Color.Black;
        // Absolute size in pixels.  0 = no outline.
        // Standard formula for reference: 2.1 + fontSize * 0.055  ≈ 3–5px at typical sizes.
        public float OutlineSize        { get; private set; } = 3.0f;

        // ── Shadow ────────────────────────────────────────────────────────────
        // When OverrideShadow is false, the component uses the layout's
        // DropShadows flag and ShadowsColor.
        public bool  OverrideShadow     { get; private set; } = false;
        public bool  ShadowNormalEnabled { get; private set; } = true;
        public bool  ShadowOutsideEnabled { get; private set; } = false;
        public bool  ShadowInsideEnabled { get; private set; } = false;
        public bool  ShadowEnabled      { get { return ShadowNormalEnabled || ShadowOutsideEnabled || ShadowInsideEnabled; } }
        public Color ShadowColor        { get; private set; } = Color.Black;
        // How many pixels the shadow shifts from the text.
        public float ShadowSize         { get; private set; } = 2.0f;
        // Real bitmap blur radius in pixels.
        public float ShadowBlur         { get; private set; } = 2.0f;
        public int   ShadowPasses       { get; private set; } = 3;
        public int   ShadowSoftness     { get { return (int)Math.Ceiling(ShadowBlur); } }

        // Layout-wide background/border layer. Drawn behind the layout when
        // this FancyText controller is first in the layout list.
        public bool  LayoutBoxEnabled         { get; private set; } = false;
        public bool  BoxBackgroundEnabled     { get; private set; } = true;
        public FancyTextColorMode BoxBackgroundColorMode { get; private set; } = FancyTextColorMode.Solid;
        public Color BoxBackgroundColor       { get; private set; } = Color.FromArgb(90, 0, 0, 0);
        public Color BoxBackgroundColor2      { get; private set; } = Color.FromArgb(90, 35, 35, 35);
        public Color BoxBackgroundColor3      { get; private set; } = Color.FromArgb(90, 0, 0, 0);
        public FancyTextGradientDirection BoxBackgroundGradientDirection { get; private set; } = FancyTextGradientDirection.Vertical;
        public FancyTextColorMode BoxBorderColorMode { get; private set; } = FancyTextColorMode.Solid;
        public Color BoxBorderColor           { get; private set; } = Color.FromArgb(180, 255, 255, 255);
        public Color BoxBorderColor2          { get; private set; } = Color.FromArgb(180, 180, 180, 180);
        public Color BoxBorderColor3          { get; private set; } = Color.FromArgb(180, 255, 255, 255);
        public FancyTextGradientDirection BoxBorderGradientDirection { get; private set; } = FancyTextGradientDirection.Vertical;
        public float BoxBorderSize            { get; private set; } = 0f;
        public bool  BoxSamePadding           { get; private set; } = true;
        public float BoxPaddingAll            { get; private set; } = 0f;
        public float BoxPaddingTop            { get; private set; } = 0f;
        public float BoxPaddingRight          { get; private set; } = 0f;
        public float BoxPaddingBottom         { get; private set; } = 0f;
        public float BoxPaddingLeft           { get; private set; } = 0f;
        public bool  BoxSameRadius            { get; private set; } = true;
        public float BoxRadiusAll             { get; private set; } = 8f;
        public float BoxRadiusTopLeft         { get; private set; } = 8f;
        public float BoxRadiusTopRight        { get; private set; } = 8f;
        public float BoxRadiusBottomRight     { get; private set; } = 8f;
        public float BoxRadiusBottomLeft      { get; private set; } = 8f;
        public bool  BoxShadowNormalEnabled   { get; private set; } = false;
        public bool  BoxShadowOutsideEnabled  { get; private set; } = false;
        public bool  BoxShadowInsideEnabled   { get; private set; } = false;
        public bool  BoxShadowEnabled         { get { return BoxShadowNormalEnabled || BoxShadowOutsideEnabled || BoxShadowInsideEnabled; } }
        public FancyTextBackgroundShadowMode BoxShadowMode { get; private set; } = FancyTextBackgroundShadowMode.Behind;
        public Color BoxShadowColor           { get; private set; } = Color.FromArgb(160, 0, 0, 0);
        public float BoxShadowOffsetX         { get; private set; } = 0f;
        public float BoxShadowOffsetY         { get; private set; } = 4f;
        public float BoxShadowSize            { get; private set; } = 8f;
        public float BoxShadowBlur            { get; private set; } = 0f;
        public int   BoxShadowPasses          { get; private set; } = 3;
        public int   BoxShadowSoftness        { get { return BoxShadowPasses; } }

        // Scope / targeting
        public FancyTextScopeMode    ScopeMode         { get; private set; } = FancyTextScopeMode.AllComponents;
        // Names of components selected when ScopeMode == SelectedComponents.
        // Populated from state.Layout.Components in the settings panel.
        public HashSet<string>       TargetComponents  { get; private set; } = new HashSet<string>();

        // =====================================================================
        // Private
        // =====================================================================
        private readonly LiveSplitState _state;
        private IComponent              _owner;
        private LayoutMode              _layoutMode;
        private bool                    _refreshingComponentList;
        private Panel                   _scrollPanel;
        private Panel                   _contentPanel;
        private bool                    _resetScrollPosition;

        // Controls we need to reference after construction
        private TextBox       _textBox;
        private RadioButton   _rdoModeText;
        private RadioButton   _rdoModeBackground;
        private GroupBox      _targetsSection;
        private GroupBox      _textGradientSection;
        private GroupBox      _outlineSection;
        private GroupBox      _textShadowSection;
        private GroupBox      _backgroundGradientSection;
        private GroupBox      _backgroundOutlineSection;
        private GroupBox      _backgroundShadowSection;
        private CheckBox      _overrideTextColorsChk;
        private ComboBox      _gradientModeCombo;
        private Button        _color1Btn;
        private Button        _color2Btn;
        private Button        _color3Btn;
        private Label         _color2Label;
        private Label         _color3Label;
        private Label         _existingColorLabel;
        private ComboBox      _gradDirCombo;
        private Label         _gradDirLabel;
        private CheckBox      _overrideOutlineChk;
        private Button        _outlineColorBtn;
        private Label         _outlineColorLabel;
        private NumericUpDown _outlineSizeNum;
        private CheckBox      _overrideShadowChk;
        private CheckBox      _shadowEnabledChk;
        private CheckBox      _shadowOutsideEnabledChk;
        private CheckBox      _shadowInsideEnabledChk;
        private Button        _shadowColorBtn;
        private Label         _shadowColorLabel;
        private NumericUpDown _shadowSizeNum;
        private NumericUpDown _shadowSoftnessNum;
        private NumericUpDown _shadowPassesNum;
        private CheckBox      _boxBackgroundEnabledChk;
        private ComboBox      _boxBackgroundModeCombo;
        private Button        _boxBackgroundColorBtn;
        private Button        _boxBackgroundColor2Btn;
        private Button        _boxBackgroundColor3Btn;
        private ComboBox      _boxBackgroundDirectionCombo;
        private ComboBox      _boxBorderModeCombo;
        private Button        _boxBorderColorBtn;
        private Button        _boxBorderColor2Btn;
        private Button        _boxBorderColor3Btn;
        private ComboBox      _boxBorderDirectionCombo;
        private NumericUpDown _boxBorderSizeNum;
        private NumericUpDown _boxPaddingAllNum;
        private NumericUpDown _boxPaddingTopNum;
        private NumericUpDown _boxPaddingRightNum;
        private NumericUpDown _boxPaddingBottomNum;
        private NumericUpDown _boxPaddingLeftNum;
        private NumericUpDown _boxRadiusAllNum;
        private NumericUpDown _boxRadiusTopLeftNum;
        private NumericUpDown _boxRadiusTopRightNum;
        private NumericUpDown _boxRadiusBottomRightNum;
        private NumericUpDown _boxRadiusBottomLeftNum;
        private CheckBox      _boxShadowEnabledChk;
        private CheckBox      _boxShadowOutsideEnabledChk;
        private CheckBox      _boxShadowInsideEnabledChk;
        private Button        _boxShadowColorBtn;
        private NumericUpDown _boxShadowOffsetXNum;
        private NumericUpDown _boxShadowOffsetYNum;
        private NumericUpDown _boxShadowSizeNum;
        private NumericUpDown _boxShadowBlurNum;
        private NumericUpDown _boxShadowPassesNum;

        // Target controls
        private RadioButton _rdoScopeThis;
        private RadioButton _rdoScopeAll;
        private RadioButton _rdoScopeSelected;
        private Button _refreshComponentsBtn;
        private CheckedListBox _componentList;
        private Label          _scopePhase2Note;

        // ── Constructor ───────────────────────────────────────────────────────
        public FancyTextSettings(LiveSplitState state, IComponent owner)
        {
            _state = state;
            _owner = owner;
            BuildUI();
        }

        public void NotifyLayoutMode(LayoutMode mode)
        {
            _layoutMode = mode;
            RefreshRuntimeHooks();
            PopulateComponentList();
            UpdateTargetNote();
        }

        internal void AttachOwner(IComponent owner)
        {
            _owner = owner;
        }

        // =====================================================================
        // UI construction
        // =====================================================================

        private void BuildUI()
        {
            FancyTextSimpleLabelHook.Install();
            SuspendLayout();
            Controls.Clear();

            AutoScaleMode = AutoScaleMode.Font;
            AutoScroll = false;
            Dock = DockStyle.Fill;
            Padding = Padding.Empty;
            Size = new Size(476, 640);

            _scrollPanel = new Panel
            {
                AutoScroll = true,
                Dock = DockStyle.Fill,
                Margin = Padding.Empty,
                Padding = new Padding(7),
            };

            _contentPanel = new Panel
            {
                Location = Point.Empty,
                Margin = Padding.Empty,
                AutoSize = false,
                Padding = Padding.Empty,
            };

            _scrollPanel.Controls.Add(_contentPanel);
            Controls.Add(_scrollPanel);

            AddSettingsSection(MakeSection("Instance", BuildInstanceSection()));
            _targetsSection = MakeSection("Targets", BuildScopeSection());
            _textGradientSection = MakeSection("Text Gradient", BuildColorSection());
            _outlineSection = MakeSection("Outline", BuildOutlineSection());
            _textShadowSection = MakeSection("Shadow", BuildShadowSection());
            _backgroundGradientSection = MakeSection("Background Gradient", BuildBackgroundGradientSection());
            _backgroundOutlineSection = MakeSection("Background Outline", BuildBackgroundOutlineSection());
            _backgroundShadowSection = MakeSection("Shadow", BuildBackgroundShadowSection());
            AddSettingsSection(_targetsSection);
            AddSettingsSection(_textGradientSection);
            AddSettingsSection(_outlineSection);
            AddSettingsSection(_textShadowSection);
            AddSettingsSection(_backgroundGradientSection);
            AddSettingsSection(_backgroundOutlineSection);
            AddSettingsSection(_backgroundShadowSection);
            UpdateModeControlStates(false);

            Resize += (sender, args) => ResizeSections();
            _scrollPanel.Resize += (sender, args) => ResizeSections();
            _resetScrollPosition = true;
            ResizeSections();
            ResumeLayout(false);
            PerformLayout();
        }

        private Control BuildInstanceSection()
        {
            var row = MakeCompactRow();
            row.Controls.Add(MakeTinyLbl("Mode"));

            _rdoModeText = new RadioButton
            {
                Text = "Text",
                AutoSize = true,
                Checked = ControllerMode == FancyTextControllerMode.Text,
                Margin = new Padding(0, 3, 10, 0),
            };
            _rdoModeText.CheckedChanged += (s, e) =>
            {
                if (_rdoModeText.Checked)
                    SetControllerMode(FancyTextControllerMode.Text);
            };
            row.Controls.Add(_rdoModeText);

            _rdoModeBackground = new RadioButton
            {
                Text = "Background",
                AutoSize = true,
                Checked = ControllerMode == FancyTextControllerMode.Background,
                Margin = new Padding(0, 3, 16, 0),
            };
            _rdoModeBackground.CheckedChanged += (s, e) =>
            {
                if (_rdoModeBackground.Checked)
                    SetControllerMode(FancyTextControllerMode.Background);
            };
            row.Controls.Add(_rdoModeBackground);

            row.Controls.Add(MakeTinyLbl("Name"));
            _textBox = new TextBox { Text = InstanceName, MaxLength = 80, Width = 240, Margin = new Padding(0, 0, 0, 0) };
            _textBox.TextChanged += (s, e) => InstanceName = _textBox.Text;
            row.Controls.Add(_textBox);

            UpdateModeControlStates(false);
            return row;
        }

        private void SetControllerMode(FancyTextControllerMode mode)
        {
            if (ControllerMode == mode)
            {
                UpdateModeControlStates(true);
                return;
            }

            ControllerMode = mode;
            ApplyControllerModeSideEffects();
            UpdateModeControlStates(true);
            RefreshRuntimeHooks();
        }

        private void ApplyControllerModeSideEffects()
        {
            LayoutBoxEnabled = ControllerMode == FancyTextControllerMode.Background;
        }

        private void UpdateModeControlStates(bool resize)
        {
            ApplyControllerModeSideEffects();

            if (_rdoModeText != null && _rdoModeText.Checked != (ControllerMode == FancyTextControllerMode.Text))
                _rdoModeText.Checked = ControllerMode == FancyTextControllerMode.Text;
            if (_rdoModeBackground != null && _rdoModeBackground.Checked != (ControllerMode == FancyTextControllerMode.Background))
                _rdoModeBackground.Checked = ControllerMode == FancyTextControllerMode.Background;

            bool modeLocked = ControllerMode != FancyTextControllerMode.Unset;
            SetEnabled(_rdoModeText, !modeLocked);
            SetEnabled(_rdoModeBackground, !modeLocked);

            bool textMode = ControllerMode == FancyTextControllerMode.Text;
            bool backgroundMode = ControllerMode == FancyTextControllerMode.Background;
            SetVisible(_targetsSection, textMode || backgroundMode);
            SetVisible(_textGradientSection, textMode);
            SetVisible(_outlineSection, textMode);
            SetVisible(_textShadowSection, textMode);
            SetVisible(_backgroundGradientSection, backgroundMode);
            SetVisible(_backgroundOutlineSection, backgroundMode);
            SetVisible(_backgroundShadowSection, backgroundMode);
            UpdateLayoutBoxControlStates();
            UpdateTargetNote();

            if (resize)
                ResizeSections();
        }

        // ── Text Color ───────────────────────────────────────────────────────
        private Control BuildColorSection()
        {
            var panel = MakeCompactPanel();
            var row1 = MakeCompactRow();

            _overrideTextColorsChk = MakeCompactCheck("Activate", OverrideTextColors);
            _overrideTextColorsChk.CheckedChanged += (s, e) =>
            {
                OverrideTextColors = _overrideTextColorsChk.Checked;
                ColorMode = OverrideTextColors ? FancyTextColorMode.Gradient : FancyTextColorMode.Solid;
                UpdateGradientControlStates();
            };
            row1.Controls.Add(_overrideTextColorsChk);

            _gradientModeCombo = MakeCompactCombo("Gradient with existing colours", "New Gradient");
            _gradientModeCombo.Width = 205;
            _gradientModeCombo.SelectedIndex = (int)GradientMode;
            _gradientModeCombo.SelectedIndexChanged += (s, e) =>
            {
                GradientMode = (FancyTextGradientMode)_gradientModeCombo.SelectedIndex;
                UpdateGradientControlStates();
            };
            AddCompactControl(row1, "Mode", _gradientModeCombo);
            panel.Controls.Add(row1);

            var row2 = MakeCompactRow();
            _color1Btn = MakeColorBtn(TextColor1);
            _color1Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_color1Btn, this);
                TextColor1 = _color1Btn.BackColor;
            };
            AddCompactControl(row2, "1", _color1Btn);

            _color2Label = MakeTinyLbl("2");
            row2.Controls.Add(_color2Label);
            _color2Btn = MakeColorBtn(TextColor2);
            _color2Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_color2Btn, this);
                TextColor2 = _color2Btn.BackColor;
            };
            _existingColorLabel = new Label
            {
                Text = "Existing color",
                AutoSize = true,
                Margin = new Padding(0, 4, 0, 0),
            };
            var middleColorPanel = new FlowLayoutPanel
            {
                AutoSize = true,
                FlowDirection = FlowDirection.LeftToRight,
                WrapContents = false,
                Margin = Padding.Empty,
                Padding = Padding.Empty,
            };
            middleColorPanel.Controls.Add(_color2Btn);
            middleColorPanel.Controls.Add(_existingColorLabel);
            row2.Controls.Add(middleColorPanel);

            _color3Label = MakeTinyLbl("3");
            row2.Controls.Add(_color3Label);
            _color3Btn = MakeColorBtn(TextColor3);
            _color3Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_color3Btn, this);
                TextColor3 = _color3Btn.BackColor;
            };
            row2.Controls.Add(_color3Btn);

            _gradDirLabel = MakeTinyLbl("Dir");
            row2.Controls.Add(_gradDirLabel);
            _gradDirCombo = MakeCompactCombo("Horizontal", "Vertical", "Diagonal Down", "Diagonal Up");
            _gradDirCombo.SelectedIndex = (int)GradientDirection;
            _gradDirCombo.SelectedIndexChanged += (s, e) =>
                GradientDirection = (FancyTextGradientDirection)_gradDirCombo.SelectedIndex;
            row2.Controls.Add(_gradDirCombo);
            panel.Controls.Add(row2);

            UpdateGradientControlStates();
            return panel;
        }

        private void UpdateGradientControlStates()
        {
            bool on = OverrideTextColors;
            bool newGradient = GradientMode == FancyTextGradientMode.NewGradient;
            if (_gradientModeCombo != null) _gradientModeCombo.Enabled = on;
            if (_color1Btn != null) _color1Btn.Enabled = on;
            if (_color2Btn != null)
            {
                _color2Btn.Enabled = on && newGradient;
                _color2Btn.Visible = newGradient;
            }
            if (_existingColorLabel != null)
            {
                _existingColorLabel.Enabled = on;
                _existingColorLabel.Visible = !newGradient;
            }
            if (_color3Btn != null) _color3Btn.Enabled = on;
            if (_color2Label != null) _color2Label.Enabled = on;
            if (_color3Label != null) _color3Label.Enabled = on;
            if (_gradDirCombo != null) _gradDirCombo.Enabled = on;
            if (_gradDirLabel != null) _gradDirLabel.Enabled = on;
        }

        // ── Outline ──────────────────────────────────────────────────────────
        private Control BuildOutlineSection()
        {
            var t = MakeGrid(4);

            // Override toggle
            t.Controls.Add(MakeLbl("Custom outline:"), 0, 0);
            _overrideOutlineChk = new CheckBox { Checked = OverrideOutline, AutoSize = true };
            _overrideOutlineChk.CheckedChanged += (s, e) =>
            {
                OverrideOutline = _overrideOutlineChk.Checked;
                UpdateOutlineControlStates();
            };
            t.Controls.Add(_overrideOutlineChk, 1, 0);

            // Outline color
            _outlineColorLabel = MakeLbl("Outline Color:");
            t.Controls.Add(_outlineColorLabel, 0, 1);
            _outlineColorBtn = MakeColorBtn(OutlineColor);
            _outlineColorBtn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_outlineColorBtn, this);
                OutlineColor = _outlineColorBtn.BackColor;
            };
            t.Controls.Add(_outlineColorBtn, 1, 1);

            // Outline size
            t.Controls.Add(MakeLbl("Outline Size (px):"), 0, 2);
            _outlineSizeNum = MakeNumeric(OutlineSize, 0f, 20f, 1, 0.5m);
            _outlineSizeNum.ValueChanged += (s, e) => OutlineSize = (float)_outlineSizeNum.Value;
            t.Controls.Add(_outlineSizeNum, 1, 2);

            var note = new Label
            {
                Text      = "0 = no outline.\n" +
                            "LiveSplit default ≈ 3–5px depending on font size.\n" +
                            "Only applies when Custom outline is checked.",
                AutoSize  = true,
                ForeColor = SystemColors.GrayText,
            };
            t.SetColumnSpan(note, 2);
            t.Controls.Add(note, 0, 3);

            UpdateOutlineControlStates();
            return t;
        }

        private void UpdateOutlineControlStates()
        {
            bool ov = OverrideOutline;
            if (_outlineColorBtn   != null) _outlineColorBtn.Enabled   = ov;
            if (_outlineColorLabel != null) _outlineColorLabel.Enabled = ov;
            if (_outlineSizeNum    != null) _outlineSizeNum.Enabled    = ov;
        }

        // ── Shadow ────────────────────────────────────────────────────────────
        private Control BuildShadowSection()
        {
            var panel = MakeCompactPanel();

            var topRow = MakeCompactRow();
            _overrideShadowChk = MakeCompactCheck("Custom shadow", OverrideShadow);
            _overrideShadowChk.CheckedChanged += (s, e) =>
            {
                OverrideShadow = _overrideShadowChk.Checked;
                UpdateShadowControlStates();
            };
            topRow.Controls.Add(_overrideShadowChk);

            _shadowColorLabel = MakeLbl("Shadow Color:");
            _shadowColorBtn = MakeColorBtn(ShadowColor);
            _shadowColorBtn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_shadowColorBtn, this);
                ShadowColor = _shadowColorBtn.BackColor;
            };
            AddCompactControl(topRow, "Color", _shadowColorBtn);
            panel.Controls.Add(topRow);

            var layerRow = MakeCompactRow();
            _shadowEnabledChk = MakeCompactCheck("Normal", ShadowNormalEnabled);
            _shadowEnabledChk.CheckedChanged += (s, e) =>
            {
                ShadowNormalEnabled = _shadowEnabledChk.Checked;
                UpdateShadowControlStates();
            };
            layerRow.Controls.Add(_shadowEnabledChk);

            _shadowOutsideEnabledChk = MakeCompactCheck("Outside Only", ShadowOutsideEnabled);
            _shadowOutsideEnabledChk.CheckedChanged += (s, e) =>
            {
                ShadowOutsideEnabled = _shadowOutsideEnabledChk.Checked;
                UpdateShadowControlStates();
            };
            layerRow.Controls.Add(_shadowOutsideEnabledChk);

            _shadowInsideEnabledChk = MakeCompactCheck("Inside Only", ShadowInsideEnabled);
            _shadowInsideEnabledChk.CheckedChanged += (s, e) =>
            {
                ShadowInsideEnabled = _shadowInsideEnabledChk.Checked;
                UpdateShadowControlStates();
            };
            layerRow.Controls.Add(_shadowInsideEnabledChk);
            panel.Controls.Add(layerRow);

            var valueRow = MakeCompactRow();
            _shadowSizeNum = MakeCompactNumeric(ShadowSize, 0f, 20f, 1, 0.5m);
            _shadowSizeNum.ValueChanged += (s, e) => ShadowSize = (float)_shadowSizeNum.Value;
            AddCompactControl(valueRow, "Offset", _shadowSizeNum);

            _shadowSoftnessNum = MakeCompactNumeric(ShadowBlur, 0f, 32f, 1, 0.1m);
            _shadowSoftnessNum.ValueChanged += (s, e) =>
                ShadowBlur = (float)_shadowSoftnessNum.Value;
            AddCompactControl(valueRow, "Blur", _shadowSoftnessNum);

            _shadowPassesNum = MakeCompactNumeric(ShadowPasses, 1f, 16f, 0, 1m);
            _shadowPassesNum.ValueChanged += (s, e) => ShadowPasses = (int)_shadowPassesNum.Value;
            AddCompactControl(valueRow, "Passes", _shadowPassesNum);
            panel.Controls.Add(valueRow);

            var note = new Label
            {
                Text      = "Outside and inside shadows are clipped to the text shape.",
                AutoSize  = true,
                ForeColor = SystemColors.GrayText,
                Margin = new Padding(0, 2, 0, 0),
            };
            panel.Controls.Add(note);

            UpdateShadowControlStates();
            return panel;
        }

        private void UpdateShadowControlStates()
        {
            bool ov = OverrideShadow;
            bool any = ov && ShadowEnabled;
            if (_shadowEnabledChk  != null) _shadowEnabledChk.Enabled  = ov;
            if (_shadowOutsideEnabledChk != null) _shadowOutsideEnabledChk.Enabled = ov;
            if (_shadowInsideEnabledChk != null) _shadowInsideEnabledChk.Enabled = ov;
            if (_shadowColorBtn    != null) _shadowColorBtn.Enabled    = ov;
            if (_shadowColorLabel  != null) _shadowColorLabel.Enabled  = ov;
            if (_shadowSizeNum     != null) _shadowSizeNum.Enabled     = any;
            if (_shadowSoftnessNum != null) _shadowSoftnessNum.Enabled = any;
            if (_shadowPassesNum   != null) _shadowPassesNum.Enabled   = any;
        }

        private Control BuildBackgroundGradientSection()
        {
            var panel = MakeCompactPanel();
            var row1 = MakeCompactRow();

            _boxBackgroundEnabledChk = MakeCompactCheck("Draw background", BoxBackgroundEnabled);
            _boxBackgroundEnabledChk.CheckedChanged += (s, e) =>
            {
                BoxBackgroundEnabled = _boxBackgroundEnabledChk.Checked;
                UpdateLayoutBoxControlStates();
            };
            row1.Controls.Add(_boxBackgroundEnabledChk);

            _boxBackgroundModeCombo = MakeCompactCombo("Solid", "Gradient");
            _boxBackgroundModeCombo.SelectedIndex = (int)BoxBackgroundColorMode;
            _boxBackgroundModeCombo.SelectedIndexChanged += (s, e) =>
            {
                BoxBackgroundColorMode = (FancyTextColorMode)_boxBackgroundModeCombo.SelectedIndex;
                UpdateLayoutBoxControlStates();
            };
            AddCompactControl(row1, "Mode", _boxBackgroundModeCombo);
            panel.Controls.Add(row1);

            var row2 = MakeCompactRow();
            _boxBackgroundColorBtn = MakeColorBtn(BoxBackgroundColor);
            _boxBackgroundColorBtn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxBackgroundColorBtn, this);
                BoxBackgroundColor = _boxBackgroundColorBtn.BackColor;
            };
            AddCompactControl(row2, "1", _boxBackgroundColorBtn);

            _boxBackgroundColor2Btn = MakeColorBtn(BoxBackgroundColor2);
            _boxBackgroundColor2Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxBackgroundColor2Btn, this);
                BoxBackgroundColor2 = _boxBackgroundColor2Btn.BackColor;
            };
            AddCompactControl(row2, "2", _boxBackgroundColor2Btn);

            _boxBackgroundColor3Btn = MakeColorBtn(BoxBackgroundColor3);
            _boxBackgroundColor3Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxBackgroundColor3Btn, this);
                BoxBackgroundColor3 = _boxBackgroundColor3Btn.BackColor;
            };
            AddCompactControl(row2, "3", _boxBackgroundColor3Btn);

            _boxBackgroundDirectionCombo = MakeCompactCombo("Horizontal", "Vertical", "Diagonal Down", "Diagonal Up");
            _boxBackgroundDirectionCombo.SelectedIndex = (int)BoxBackgroundGradientDirection;
            _boxBackgroundDirectionCombo.SelectedIndexChanged += (s, e) =>
                BoxBackgroundGradientDirection = (FancyTextGradientDirection)_boxBackgroundDirectionCombo.SelectedIndex;
            AddCompactControl(row2, "Dir", _boxBackgroundDirectionCombo);
            panel.Controls.Add(row2);

            panel.Controls.Add(new Label
            {
                Text = "Color alpha controls background opacity.",
                AutoSize = true,
                ForeColor = SystemColors.GrayText,
                Margin = new Padding(0, 2, 0, 0),
            });

            UpdateLayoutBoxControlStates();
            return panel;
        }

        private Control BuildBackgroundOutlineSection()
        {
            var panel = MakeCompactPanel();

            var outlineRow = MakeCompactRow();
            _boxBorderSizeNum = MakeCompactNumeric(BoxBorderSize, 0f, 80f, 1, 0.5m);
            _boxBorderSizeNum.ValueChanged += (s, e) =>
            {
                BoxBorderSize = (float)_boxBorderSizeNum.Value;
                UpdateLayoutBoxControlStates();
            };
            AddCompactControl(outlineRow, "Size", _boxBorderSizeNum);

            _boxBorderModeCombo = MakeCompactCombo("Solid", "Gradient");
            _boxBorderModeCombo.SelectedIndex = (int)BoxBorderColorMode;
            _boxBorderModeCombo.SelectedIndexChanged += (s, e) =>
            {
                BoxBorderColorMode = (FancyTextColorMode)_boxBorderModeCombo.SelectedIndex;
                UpdateLayoutBoxControlStates();
            };
            AddCompactControl(outlineRow, "Mode", _boxBorderModeCombo);

            _boxBorderColorBtn = MakeColorBtn(BoxBorderColor);
            _boxBorderColorBtn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxBorderColorBtn, this);
                BoxBorderColor = _boxBorderColorBtn.BackColor;
            };
            AddCompactControl(outlineRow, "1", _boxBorderColorBtn);

            _boxBorderColor2Btn = MakeColorBtn(BoxBorderColor2);
            _boxBorderColor2Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxBorderColor2Btn, this);
                BoxBorderColor2 = _boxBorderColor2Btn.BackColor;
            };
            AddCompactControl(outlineRow, "2", _boxBorderColor2Btn);

            _boxBorderColor3Btn = MakeColorBtn(BoxBorderColor3);
            _boxBorderColor3Btn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxBorderColor3Btn, this);
                BoxBorderColor3 = _boxBorderColor3Btn.BackColor;
            };
            AddCompactControl(outlineRow, "3", _boxBorderColor3Btn);

            _boxBorderDirectionCombo = MakeCompactCombo("Horizontal", "Vertical", "Diagonal Down", "Diagonal Up");
            _boxBorderDirectionCombo.SelectedIndex = (int)BoxBorderGradientDirection;
            _boxBorderDirectionCombo.SelectedIndexChanged += (s, e) =>
                BoxBorderGradientDirection = (FancyTextGradientDirection)_boxBorderDirectionCombo.SelectedIndex;
            AddCompactControl(outlineRow, "Dir", _boxBorderDirectionCombo);
            panel.Controls.Add(outlineRow);

            var paddingRow = MakeCompactRow();
            paddingRow.Controls.Add(MakeSectionLabel("Padding"));

            _boxPaddingAllNum = MakeCompactNumeric(BoxPaddingAll, 0f, 400f, 1, 0.5m);
            _boxPaddingAllNum.ValueChanged += (s, e) =>
            {
                BoxPaddingAll = (float)_boxPaddingAllNum.Value;
                ApplyPaddingAll();
            };
            AddCompactControl(paddingRow, "All", _boxPaddingAllNum);

            _boxPaddingTopNum = MakeCompactNumeric(BoxPaddingTop, 0f, 400f, 1, 0.5m);
            _boxPaddingTopNum.ValueChanged += (s, e) => BoxPaddingTop = (float)_boxPaddingTopNum.Value;
            AddCompactControl(paddingRow, "T", _boxPaddingTopNum);

            _boxPaddingRightNum = MakeCompactNumeric(BoxPaddingRight, 0f, 400f, 1, 0.5m);
            _boxPaddingRightNum.ValueChanged += (s, e) => BoxPaddingRight = (float)_boxPaddingRightNum.Value;
            AddCompactControl(paddingRow, "R", _boxPaddingRightNum);

            _boxPaddingBottomNum = MakeCompactNumeric(BoxPaddingBottom, 0f, 400f, 1, 0.5m);
            _boxPaddingBottomNum.ValueChanged += (s, e) => BoxPaddingBottom = (float)_boxPaddingBottomNum.Value;
            AddCompactControl(paddingRow, "B", _boxPaddingBottomNum);

            _boxPaddingLeftNum = MakeCompactNumeric(BoxPaddingLeft, 0f, 400f, 1, 0.5m);
            _boxPaddingLeftNum.ValueChanged += (s, e) => BoxPaddingLeft = (float)_boxPaddingLeftNum.Value;
            AddCompactControl(paddingRow, "L", _boxPaddingLeftNum);
            panel.Controls.Add(paddingRow);

            var radiusRow = MakeCompactRow();
            radiusRow.Controls.Add(MakeSectionLabel("Radius"));

            _boxRadiusAllNum = MakeCompactNumeric(BoxRadiusAll, 0f, 400f, 1, 0.5m);
            _boxRadiusAllNum.ValueChanged += (s, e) =>
            {
                BoxRadiusAll = (float)_boxRadiusAllNum.Value;
                ApplyRadiusAll();
            };
            AddCompactControl(radiusRow, "All", _boxRadiusAllNum);

            _boxRadiusTopLeftNum = MakeCompactNumeric(BoxRadiusTopLeft, 0f, 400f, 1, 0.5m);
            _boxRadiusTopLeftNum.ValueChanged += (s, e) => BoxRadiusTopLeft = (float)_boxRadiusTopLeftNum.Value;
            AddCompactControl(radiusRow, "TL", _boxRadiusTopLeftNum);

            _boxRadiusTopRightNum = MakeCompactNumeric(BoxRadiusTopRight, 0f, 400f, 1, 0.5m);
            _boxRadiusTopRightNum.ValueChanged += (s, e) => BoxRadiusTopRight = (float)_boxRadiusTopRightNum.Value;
            AddCompactControl(radiusRow, "TR", _boxRadiusTopRightNum);

            _boxRadiusBottomRightNum = MakeCompactNumeric(BoxRadiusBottomRight, 0f, 400f, 1, 0.5m);
            _boxRadiusBottomRightNum.ValueChanged += (s, e) => BoxRadiusBottomRight = (float)_boxRadiusBottomRightNum.Value;
            AddCompactControl(radiusRow, "BR", _boxRadiusBottomRightNum);

            _boxRadiusBottomLeftNum = MakeCompactNumeric(BoxRadiusBottomLeft, 0f, 400f, 1, 0.5m);
            _boxRadiusBottomLeftNum.ValueChanged += (s, e) => BoxRadiusBottomLeft = (float)_boxRadiusBottomLeftNum.Value;
            AddCompactControl(radiusRow, "BL", _boxRadiusBottomLeftNum);
            panel.Controls.Add(radiusRow);

            panel.Controls.Add(new Label
            {
                Text = "Padding expands outward. Size 0 keeps the rounded background and shadow.",
                AutoSize = true,
                ForeColor = SystemColors.GrayText,
                Margin = new Padding(0, 2, 0, 0),
            });

            UpdateLayoutBoxControlStates();
            return panel;
        }

        private Control BuildBackgroundShadowSection()
        {
            var panel = MakeCompactPanel();

            var row1 = MakeCompactRow();
            row1.Controls.Add(MakeSectionLabel("Layers"));

            _boxShadowEnabledChk = MakeCompactCheck("Normal", BoxShadowNormalEnabled);
            _boxShadowEnabledChk.CheckedChanged += (s, e) =>
            {
                BoxShadowNormalEnabled = _boxShadowEnabledChk.Checked;
                UpdateLayoutBoxControlStates();
            };
            row1.Controls.Add(_boxShadowEnabledChk);

            _boxShadowOutsideEnabledChk = MakeCompactCheck("Outside Only", BoxShadowOutsideEnabled);
            _boxShadowOutsideEnabledChk.CheckedChanged += (s, e) =>
            {
                BoxShadowOutsideEnabled = _boxShadowOutsideEnabledChk.Checked;
                UpdateLayoutBoxControlStates();
            };
            row1.Controls.Add(_boxShadowOutsideEnabledChk);

            _boxShadowInsideEnabledChk = MakeCompactCheck("Inside Only", BoxShadowInsideEnabled);
            _boxShadowInsideEnabledChk.CheckedChanged += (s, e) =>
            {
                BoxShadowInsideEnabled = _boxShadowInsideEnabledChk.Checked;
                UpdateLayoutBoxControlStates();
            };
            row1.Controls.Add(_boxShadowInsideEnabledChk);
            panel.Controls.Add(row1);

            var row2 = MakeCompactRow();
            _boxShadowColorBtn = MakeColorBtn(BoxShadowColor);
            _boxShadowColorBtn.Click += (s, e) =>
            {
                SettingsHelper.ColorButtonClick(_boxShadowColorBtn, this);
                BoxShadowColor = _boxShadowColorBtn.BackColor;
            };
            AddCompactControl(row2, "Color", _boxShadowColorBtn);

            _boxShadowOffsetXNum = MakeCompactNumeric(BoxShadowOffsetX, -200f, 200f, 1, 0.5m);
            _boxShadowOffsetXNum.ValueChanged += (s, e) => BoxShadowOffsetX = (float)_boxShadowOffsetXNum.Value;
            AddCompactControl(row2, "X", _boxShadowOffsetXNum);

            _boxShadowOffsetYNum = MakeCompactNumeric(BoxShadowOffsetY, -200f, 200f, 1, 0.5m);
            _boxShadowOffsetYNum.ValueChanged += (s, e) => BoxShadowOffsetY = (float)_boxShadowOffsetYNum.Value;
            AddCompactControl(row2, "Y", _boxShadowOffsetYNum);

            _boxShadowSizeNum = MakeCompactNumeric(BoxShadowSize, 0f, 200f, 1, 0.5m);
            _boxShadowSizeNum.ValueChanged += (s, e) => BoxShadowSize = (float)_boxShadowSizeNum.Value;
            AddCompactControl(row2, "Size", _boxShadowSizeNum);
            panel.Controls.Add(row2);

            var row3 = MakeCompactRow();
            _boxShadowBlurNum = MakeCompactNumeric(BoxShadowBlur, 0f, 64f, 1, 0.1m);
            _boxShadowBlurNum.ValueChanged += (s, e) => BoxShadowBlur = (float)_boxShadowBlurNum.Value;
            AddCompactControl(row3, "Blur", _boxShadowBlurNum);

            _boxShadowPassesNum = MakeCompactNumeric(BoxShadowPasses, 1f, 32f, 0, 1m);
            _boxShadowPassesNum.ValueChanged += (s, e) => BoxShadowPasses = (int)_boxShadowPassesNum.Value;
            AddCompactControl(row3, "Passes", _boxShadowPassesNum);
            panel.Controls.Add(row3);

            panel.Controls.Add(new Label
            {
                Text = "Outside Only keeps the shadow from darkening transparent backgrounds.",
                AutoSize = true,
                ForeColor = SystemColors.GrayText,
                Margin = new Padding(0, 2, 0, 0),
            });

            UpdateLayoutBoxControlStates();
            return panel;
        }

        private void ApplyPaddingAll()
        {
            BoxPaddingTop = BoxPaddingRight = BoxPaddingBottom = BoxPaddingLeft = BoxPaddingAll;
            SetNumericValue(_boxPaddingTopNum, BoxPaddingTop);
            SetNumericValue(_boxPaddingRightNum, BoxPaddingRight);
            SetNumericValue(_boxPaddingBottomNum, BoxPaddingBottom);
            SetNumericValue(_boxPaddingLeftNum, BoxPaddingLeft);
        }

        private void ApplyRadiusAll()
        {
            BoxRadiusTopLeft = BoxRadiusTopRight = BoxRadiusBottomRight = BoxRadiusBottomLeft = BoxRadiusAll;
            SetNumericValue(_boxRadiusTopLeftNum, BoxRadiusTopLeft);
            SetNumericValue(_boxRadiusTopRightNum, BoxRadiusTopRight);
            SetNumericValue(_boxRadiusBottomRightNum, BoxRadiusBottomRight);
            SetNumericValue(_boxRadiusBottomLeftNum, BoxRadiusBottomLeft);
        }

        private void UpdateLayoutBoxControlStates()
        {
            bool on = ControllerMode == FancyTextControllerMode.Background && LayoutBoxEnabled;
            bool shadowOn = on && BoxShadowEnabled;
            bool backgroundOn = on && BoxBackgroundEnabled;
            bool backgroundGradient = backgroundOn && BoxBackgroundColorMode == FancyTextColorMode.Gradient;
            bool outlineOn = on && BoxBorderSize > 0f;
            bool outlineGradient = outlineOn && BoxBorderColorMode == FancyTextColorMode.Gradient;

            SetEnabled(_boxBackgroundEnabledChk, on);
            SetEnabled(_boxBackgroundModeCombo, backgroundOn);
            SetEnabled(_boxBackgroundColorBtn, backgroundOn);
            SetEnabled(_boxBackgroundColor2Btn, backgroundGradient);
            SetEnabled(_boxBackgroundColor3Btn, backgroundGradient);
            SetEnabled(_boxBackgroundDirectionCombo, backgroundGradient);
            SetEnabled(_boxBorderSizeNum, on);
            SetEnabled(_boxBorderModeCombo, outlineOn);
            SetEnabled(_boxBorderColorBtn, outlineOn);
            SetEnabled(_boxBorderColor2Btn, outlineGradient);
            SetEnabled(_boxBorderColor3Btn, outlineGradient);
            SetEnabled(_boxBorderDirectionCombo, outlineGradient);
            SetEnabled(_boxPaddingAllNum, on);
            SetEnabled(_boxPaddingTopNum, on);
            SetEnabled(_boxPaddingRightNum, on);
            SetEnabled(_boxPaddingBottomNum, on);
            SetEnabled(_boxPaddingLeftNum, on);
            SetEnabled(_boxRadiusAllNum, on);
            SetEnabled(_boxRadiusTopLeftNum, on);
            SetEnabled(_boxRadiusTopRightNum, on);
            SetEnabled(_boxRadiusBottomRightNum, on);
            SetEnabled(_boxRadiusBottomLeftNum, on);
            SetEnabled(_boxShadowEnabledChk, on);
            SetEnabled(_boxShadowOutsideEnabledChk, on);
            SetEnabled(_boxShadowInsideEnabledChk, on);
            SetEnabled(_boxShadowColorBtn, shadowOn);
            SetEnabled(_boxShadowOffsetXNum, shadowOn);
            SetEnabled(_boxShadowOffsetYNum, shadowOn);
            SetEnabled(_boxShadowSizeNum, shadowOn);
            SetEnabled(_boxShadowBlurNum, shadowOn);
            SetEnabled(_boxShadowPassesNum, shadowOn);
        }

        // Scope / targeting
        private Control BuildScopeSection()
        {
            var panel = MakeCompactPanel();

            _rdoScopeThis     = new RadioButton { Text = "Disabled",            AutoSize = true, Checked = true };
            _rdoScopeAll      = new RadioButton { Text = "All Components",      AutoSize = true };
            _rdoScopeSelected = new RadioButton { Text = "Selected Components", AutoSize = true };

            // Restore persisted scope mode
            switch (ScopeMode)
            {
                case FancyTextScopeMode.AllComponents:
                    _rdoScopeAll.Checked  = true; break;
                case FancyTextScopeMode.SelectedComponents:
                    _rdoScopeSelected.Checked = true; break;
                default:
                    _rdoScopeThis.Checked = true; break;
            }

            _rdoScopeThis.CheckedChanged     += (s, e) => { if (_rdoScopeThis.Checked)     UpdateScopeMode(); };
            _rdoScopeAll.CheckedChanged      += (s, e) => { if (_rdoScopeAll.Checked)      UpdateScopeMode(); };
            _rdoScopeSelected.CheckedChanged += (s, e) => { if (_rdoScopeSelected.Checked) UpdateScopeMode(); };

            var modeRow = MakeCompactRow();
            modeRow.Controls.Add(_rdoScopeThis);
            modeRow.Controls.Add(_rdoScopeAll);
            modeRow.Controls.Add(_rdoScopeSelected);

            _refreshComponentsBtn = new Button
            {
                Text = "Refresh",
                AutoSize = true,
                Margin = new Padding(10, 0, 0, 0),
            };
            _refreshComponentsBtn.Click += (s, e) => RefreshComponentTargets();
            modeRow.Controls.Add(_refreshComponentsBtn);
            panel.Controls.Add(modeRow);

            // Component checklist (visible when SelectedComponents)
            _componentList = new CheckedListBox
            {
                Height       = 92,
                Width        = 420,
                CheckOnClick = true,
                Enabled      = true,
                Visible      = true,
                IntegralHeight = false,
                Margin = new Padding(0, 2, 0, 0),
            };
            _componentList.ItemCheck += ComponentList_ItemCheck;
            _componentList.MouseEnter += (s, e) => _componentList.Focus();
            _componentList.MouseDown += (s, e) => _componentList.Focus();
            _componentList.MouseWheel += ComponentList_MouseWheel;
            PopulateComponentList();
            panel.Controls.Add(_componentList);

            // Targeting note
            _scopePhase2Note = new Label
            {
                Text      = GetTargetNoteText(),
                AutoSize  = true,
                ForeColor = SystemColors.GrayText,
                Margin    = new Padding(0, 3, 0, 0),
            };
            panel.Controls.Add(_scopePhase2Note);

            UpdateScopeControlStates();
            return panel;
        }

        private void UpdateScopeMode()
        {
            if (_rdoScopeThis.Checked)          ScopeMode = FancyTextScopeMode.ThisComponentOnly;
            else if (_rdoScopeAll.Checked)      ScopeMode = FancyTextScopeMode.AllComponents;
            else if (_rdoScopeSelected.Checked) ScopeMode = FancyTextScopeMode.SelectedComponents;
            RefreshRuntimeHooks();
            UpdateScopeControlStates();
        }

        private void UpdateScopeControlStates()
        {
            if (_componentList != null)
                _componentList.Enabled = true;

            UpdateTargetNote();
        }

        private void UpdateTargetNote()
        {
            if (_scopePhase2Note != null)
            {
                _scopePhase2Note.Text = GetTargetNoteText();
            }
        }

        private string GetTargetNoteText()
        {
            if (ControllerMode == FancyTextControllerMode.Background)
            {
                return "Background mode draws the layout layer. Disabled hides it.";
            }

            if (FancyTextSimpleLabelHook.IsInstalled)
            {
                return "Text hook active. Refresh recreates FancyText with the same settings.";
            }

            if (!string.IsNullOrEmpty(FancyTextSimpleLabelHook.LastError))
            {
                return "Text hook failed: " + FancyTextSimpleLabelHook.LastError;
            }

            if (!string.IsNullOrEmpty(FancyTextExternalTextHook.LastError))
            {
                return "External text hook failed: " + FancyTextExternalTextHook.LastError;
            }

            return "Text hook pending. Refresh recreates FancyText with the same settings.";
        }

        /// <summary>
        /// Fills the component checklist from state.Layout.Components.
        /// Called once at construction, whenever settings opens, and when refreshed.
        /// </summary>
        private void PopulateComponentList()
        {
            if (_componentList == null) return;
            if (_refreshingComponentList) return;
            _refreshingComponentList = true;
            _componentList.Items.Clear();

            try
            {
                foreach (FancyTextTargetInfo target in FancyTextRuntime.GetTargets(_state, _owner))
                {
                    bool isChecked = TargetComponents.Contains(target.Key)
                        || TargetComponents.Contains(target.ComponentName);
                    _componentList.Items.Add(target, isChecked);
                }

            }
            catch
            {
                // Layout or components not yet available.
            }
            finally
            {
                _refreshingComponentList = false;
            }
        }

        private void ComponentList_ItemCheck(object sender, ItemCheckEventArgs e)
        {
            if (_refreshingComponentList || e.Index < 0 || e.Index >= _componentList.Items.Count)
                return;

            ScopeMode = FancyTextScopeMode.SelectedComponents;
            if (_rdoScopeSelected != null)
                _rdoScopeSelected.Checked = true;

            var target = _componentList.Items[e.Index] as FancyTextTargetInfo;
            if (target == null)
                return;

            TargetComponents.Remove(target.ComponentName);
            if (e.NewValue == CheckState.Checked)
                TargetComponents.Add(target.Key);
            else
                TargetComponents.Remove(target.Key);

            RefreshRuntimeHooks();
        }

        private void RefreshComponentTargets()
        {
            var owner = _owner as FancyTextComponent;
            if (owner != null)
            {
                FancyTextComponent refreshedOwner = FancyTextRuntime.RecreateController(_state, owner, this);
                if (refreshedOwner != null)
                {
                    _owner = refreshedOwner;
                }
            }
            else
            {
                RefreshRuntimeHooks();
            }

            PopulateComponentList();
            UpdateScopeControlStates();
        }

        private void RefreshRuntimeHooks()
        {
            FancyTextRuntime.InstallHooks(_state);

            var owner = _owner as FancyTextComponent;
            if (owner != null)
                FancyTextRuntime.Publish(owner, _state, this);

            Form form = _state != null ? _state.Form : null;
            if (form != null && !form.IsDisposed)
                form.Invalidate();
        }

        private void ComponentList_MouseWheel(object sender, MouseEventArgs e)
        {
            if (_componentList == null || _componentList.Items.Count == 0)
                return;

            int lines = Math.Max(1, SystemInformation.MouseWheelScrollLines);
            int direction = e.Delta > 0 ? -1 : 1;
            int next = _componentList.TopIndex + (direction * lines);
            next = Math.Max(0, Math.Min(_componentList.Items.Count - 1, next));
            _componentList.TopIndex = next;
        }

        // =====================================================================
        // XML persistence
        // =====================================================================

        public XmlNode GetSettings(XmlDocument document)
        {
            XmlElement root = document.CreateElement("Settings");
            W(document, root, "Version",            "1");
            W(document, root, "InstanceName",       InstanceName);
            W(document, root, "DisplayText",        InstanceName);
            W(document, root, "Alignment",          Alignment.ToString());
            W(document, root, "ControllerMode",     ControllerMode.ToString());
            W(document, root, "ColorMode",          ColorMode.ToString());
            W(document, root, "OverrideTextColors", OverrideTextColors.ToString());
            W(document, root, "GradientMode",       GradientMode.ToString());
            W(document, root, "TextColor1",         ColorToHex(TextColor1));
            W(document, root, "TextColor2",         ColorToHex(TextColor2));
            W(document, root, "TextColor3",         ColorToHex(TextColor3));
            W(document, root, "GradientDirection",  GradientDirection.ToString());
            W(document, root, "OverrideOutline",    OverrideOutline.ToString());
            W(document, root, "OutlineColor",       ColorToHex(OutlineColor));
            W(document, root, "OutlineSize",        OutlineSize.ToString(CultureInfo.InvariantCulture));
            W(document, root, "OverrideShadow",     OverrideShadow.ToString());
            W(document, root, "ShadowEnabled",      ShadowEnabled.ToString());
            W(document, root, "ShadowNormalEnabled", ShadowNormalEnabled.ToString());
            W(document, root, "ShadowOutsideEnabled", ShadowOutsideEnabled.ToString());
            W(document, root, "ShadowInsideEnabled", ShadowInsideEnabled.ToString());
            W(document, root, "ShadowColor",        ColorToHex(ShadowColor));
            W(document, root, "ShadowSize",         ShadowSize.ToString(CultureInfo.InvariantCulture));
            W(document, root, "ShadowBlur",         ShadowBlur.ToString(CultureInfo.InvariantCulture));
            W(document, root, "ShadowPasses",       ShadowPasses.ToString(CultureInfo.InvariantCulture));
            W(document, root, "ShadowSoftness",     ShadowSoftness.ToString());
            W(document, root, "LayoutBoxEnabled",   LayoutBoxEnabled.ToString());
            W(document, root, "BoxBackgroundEnabled", BoxBackgroundEnabled.ToString());
            W(document, root, "BoxBackgroundColorMode", BoxBackgroundColorMode.ToString());
            W(document, root, "BoxBackgroundColor", ColorToHex(BoxBackgroundColor));
            W(document, root, "BoxBackgroundColor2", ColorToHex(BoxBackgroundColor2));
            W(document, root, "BoxBackgroundColor3", ColorToHex(BoxBackgroundColor3));
            W(document, root, "BoxBackgroundGradientDirection", BoxBackgroundGradientDirection.ToString());
            W(document, root, "BoxBorderColorMode", BoxBorderColorMode.ToString());
            W(document, root, "BoxBorderColor",     ColorToHex(BoxBorderColor));
            W(document, root, "BoxBorderColor2",    ColorToHex(BoxBorderColor2));
            W(document, root, "BoxBorderColor3",    ColorToHex(BoxBorderColor3));
            W(document, root, "BoxBorderGradientDirection", BoxBorderGradientDirection.ToString());
            W(document, root, "BoxBorderSize",      BoxBorderSize.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxSamePadding",     "False");
            W(document, root, "BoxPaddingAll",      BoxPaddingAll.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxPaddingTop",      BoxPaddingTop.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxPaddingRight",    BoxPaddingRight.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxPaddingBottom",   BoxPaddingBottom.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxPaddingLeft",     BoxPaddingLeft.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxSameRadius",      "False");
            W(document, root, "BoxRadiusAll",       BoxRadiusAll.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxRadiusTopLeft",   BoxRadiusTopLeft.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxRadiusTopRight",  BoxRadiusTopRight.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxRadiusBottomRight", BoxRadiusBottomRight.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxRadiusBottomLeft", BoxRadiusBottomLeft.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxShadowEnabled",   BoxShadowEnabled.ToString());
            W(document, root, "BoxShadowNormalEnabled", BoxShadowNormalEnabled.ToString());
            W(document, root, "BoxShadowOutsideEnabled", BoxShadowOutsideEnabled.ToString());
            W(document, root, "BoxShadowInsideEnabled", BoxShadowInsideEnabled.ToString());
            W(document, root, "BoxShadowMode",      BoxShadowMode.ToString());
            W(document, root, "BoxShadowColor",     ColorToHex(BoxShadowColor));
            W(document, root, "BoxShadowOffsetX",   BoxShadowOffsetX.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxShadowOffsetY",   BoxShadowOffsetY.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxShadowSize",      BoxShadowSize.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxShadowBlur",      BoxShadowBlur.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxShadowPasses",    BoxShadowPasses.ToString(CultureInfo.InvariantCulture));
            W(document, root, "BoxShadowSoftness",  BoxShadowPasses.ToString());
            W(document, root, "ScopeMode",          ScopeMode.ToString());
            W(document, root, "TargetComponents",   string.Join("|", TargetComponents));
            return root;
        }

        public void SetSettings(XmlNode node)
        {
            if (node == null) return;

            bool hasControllerMode = TryParseEnum(R(node, "ControllerMode"), out FancyTextControllerMode controllerMode);
            if (hasControllerMode)
                ControllerMode = controllerMode;

            string t = R(node, "InstanceName") ?? R(node, "DisplayText");
            if (t != null) { InstanceName = t; if (_textBox != null) _textBox.Text = t; }

            if (TryParseEnum(R(node, "Alignment"), out FancyTextAlignment align))
                Alignment = align;

            if (TryParseEnum(R(node, "ColorMode"), out FancyTextColorMode cm))
                ColorMode = cm;
            string overrideTextColors = R(node, "OverrideTextColors");
            if (overrideTextColors != null)
                ParseBool(overrideTextColors, b => OverrideTextColors = b);
            else
                OverrideTextColors = ColorMode == FancyTextColorMode.Gradient;
            ColorMode = OverrideTextColors ? FancyTextColorMode.Gradient : FancyTextColorMode.Solid;

            if (TryParseEnum(R(node, "GradientMode"), out FancyTextGradientMode gm))
                GradientMode = gm;
            if (overrideTextColors == null && ColorMode == FancyTextColorMode.Gradient)
                GradientMode = FancyTextGradientMode.NewGradient;

            if (_overrideTextColorsChk != null) _overrideTextColorsChk.Checked = OverrideTextColors;
            if (_gradientModeCombo != null) _gradientModeCombo.SelectedIndex = (int)GradientMode;

            SetColorBtn(R(node, "TextColor1"),  ref _color1Btn,        c => TextColor1 = c);
            SetColorBtn(R(node, "TextColor2"),  ref _color2Btn,        c => TextColor2 = c);
            SetColorBtn(R(node, "TextColor3"),  ref _color3Btn,        c => TextColor3 = c);

            if (TryParseEnum(R(node, "GradientDirection"), out FancyTextGradientDirection gd))
                GradientDirection = gd;
            if (_gradDirCombo != null) _gradDirCombo.SelectedIndex = (int)GradientDirection;
            UpdateGradientControlStates();

            ParseBool(R(node, "OverrideOutline"),  b => { OverrideOutline = b; if (_overrideOutlineChk != null) _overrideOutlineChk.Checked = b; });
            SetColorBtn(R(node, "OutlineColor"),  ref _outlineColorBtn, c => OutlineColor = c);
            ParseFloat(R(node, "OutlineSize"),    f => { OutlineSize = f;    if (_outlineSizeNum    != null) _outlineSizeNum.Value    = (decimal)Math.Min(20f, f); });
            UpdateOutlineControlStates();

            ParseBool(R(node, "OverrideShadow"),   b => { OverrideShadow  = b; if (_overrideShadowChk  != null) _overrideShadowChk.Checked  = b; });
            string legacyShadowEnabled = R(node, "ShadowEnabled");
            if (R(node, "ShadowNormalEnabled") != null)
                ParseBool(R(node, "ShadowNormalEnabled"), b => ShadowNormalEnabled = b);
            else
                ParseBool(legacyShadowEnabled, b => ShadowNormalEnabled = b);
            ParseBool(R(node, "ShadowOutsideEnabled"), b => ShadowOutsideEnabled = b);
            ParseBool(R(node, "ShadowInsideEnabled"), b => ShadowInsideEnabled = b);
            if (_shadowEnabledChk != null) _shadowEnabledChk.Checked = ShadowNormalEnabled;
            if (_shadowOutsideEnabledChk != null) _shadowOutsideEnabledChk.Checked = ShadowOutsideEnabled;
            if (_shadowInsideEnabledChk != null) _shadowInsideEnabledChk.Checked = ShadowInsideEnabled;
            SetColorBtn(R(node, "ShadowColor"),   ref _shadowColorBtn,  c => ShadowColor = c);
            ParseFloat(R(node, "ShadowSize"),     f => { ShadowSize     = f;   if (_shadowSizeNum     != null) _shadowSizeNum.Value     = (decimal)Math.Min(20f, f); });
            string shadowBlur = R(node, "ShadowBlur") ?? R(node, "ShadowSoftness");
            ParseFloat(shadowBlur, f => { ShadowBlur = Math.Max(0f, Math.Min(32f, f)); SetNumericValue(_shadowSoftnessNum, ShadowBlur); });
            ParseInt(R(node, "ShadowPasses"), i => { ShadowPasses = Math.Max(1, Math.Min(16, i)); SetNumericValue(_shadowPassesNum, ShadowPasses); });
            UpdateShadowControlStates();

            ParseBool(R(node, "LayoutBoxEnabled"), b => LayoutBoxEnabled = b);
            ParseBool(R(node, "BoxBackgroundEnabled"), b => { BoxBackgroundEnabled = b; if (_boxBackgroundEnabledChk != null) _boxBackgroundEnabledChk.Checked = b; });
            if (TryParseEnum(R(node, "BoxBackgroundColorMode"), out FancyTextColorMode backgroundMode))
                BoxBackgroundColorMode = backgroundMode;
            if (_boxBackgroundModeCombo != null) _boxBackgroundModeCombo.SelectedIndex = (int)BoxBackgroundColorMode;
            SetColorBtn(R(node, "BoxBackgroundColor"), ref _boxBackgroundColorBtn, c => BoxBackgroundColor = c);
            SetColorBtn(R(node, "BoxBackgroundColor2"), ref _boxBackgroundColor2Btn, c => BoxBackgroundColor2 = c);
            SetColorBtn(R(node, "BoxBackgroundColor3"), ref _boxBackgroundColor3Btn, c => BoxBackgroundColor3 = c);
            if (TryParseEnum(R(node, "BoxBackgroundGradientDirection"), out FancyTextGradientDirection backgroundDirection))
                BoxBackgroundGradientDirection = backgroundDirection;
            if (_boxBackgroundDirectionCombo != null) _boxBackgroundDirectionCombo.SelectedIndex = (int)BoxBackgroundGradientDirection;
            if (TryParseEnum(R(node, "BoxBorderColorMode"), out FancyTextColorMode borderMode))
                BoxBorderColorMode = borderMode;
            if (_boxBorderModeCombo != null) _boxBorderModeCombo.SelectedIndex = (int)BoxBorderColorMode;
            SetColorBtn(R(node, "BoxBorderColor"), ref _boxBorderColorBtn, c => BoxBorderColor = c);
            SetColorBtn(R(node, "BoxBorderColor2"), ref _boxBorderColor2Btn, c => BoxBorderColor2 = c);
            SetColorBtn(R(node, "BoxBorderColor3"), ref _boxBorderColor3Btn, c => BoxBorderColor3 = c);
            if (TryParseEnum(R(node, "BoxBorderGradientDirection"), out FancyTextGradientDirection borderDirection))
                BoxBorderGradientDirection = borderDirection;
            if (_boxBorderDirectionCombo != null) _boxBorderDirectionCombo.SelectedIndex = (int)BoxBorderGradientDirection;
            ParseFloat(R(node, "BoxBorderSize"), f => { BoxBorderSize = f; SetNumericValue(_boxBorderSizeNum, f); });
            ParseBool(R(node, "BoxSamePadding"), b => BoxSamePadding = b);
            ParseFloat(R(node, "BoxPaddingAll"), f => { BoxPaddingAll = f; SetNumericValue(_boxPaddingAllNum, f); });
            ParseFloat(R(node, "BoxPaddingTop"), f => { BoxPaddingTop = f; SetNumericValue(_boxPaddingTopNum, f); });
            ParseFloat(R(node, "BoxPaddingRight"), f => { BoxPaddingRight = f; SetNumericValue(_boxPaddingRightNum, f); });
            ParseFloat(R(node, "BoxPaddingBottom"), f => { BoxPaddingBottom = f; SetNumericValue(_boxPaddingBottomNum, f); });
            ParseFloat(R(node, "BoxPaddingLeft"), f => { BoxPaddingLeft = f; SetNumericValue(_boxPaddingLeftNum, f); });
            ParseBool(R(node, "BoxSameRadius"), b => BoxSameRadius = b);
            ParseFloat(R(node, "BoxRadiusAll"), f => { BoxRadiusAll = f; SetNumericValue(_boxRadiusAllNum, f); });
            ParseFloat(R(node, "BoxRadiusTopLeft"), f => { BoxRadiusTopLeft = f; SetNumericValue(_boxRadiusTopLeftNum, f); });
            ParseFloat(R(node, "BoxRadiusTopRight"), f => { BoxRadiusTopRight = f; SetNumericValue(_boxRadiusTopRightNum, f); });
            ParseFloat(R(node, "BoxRadiusBottomRight"), f => { BoxRadiusBottomRight = f; SetNumericValue(_boxRadiusBottomRightNum, f); });
            ParseFloat(R(node, "BoxRadiusBottomLeft"), f => { BoxRadiusBottomLeft = f; SetNumericValue(_boxRadiusBottomLeftNum, f); });
            bool legacyBoxShadowEnabled = false;
            ParseBool(R(node, "BoxShadowEnabled"), b => legacyBoxShadowEnabled = b);
            if (TryParseEnum(R(node, "BoxShadowMode"), out FancyTextBackgroundShadowMode shadowMode))
                BoxShadowMode = shadowMode;
            if (R(node, "BoxShadowNormalEnabled") != null
                || R(node, "BoxShadowOutsideEnabled") != null
                || R(node, "BoxShadowInsideEnabled") != null)
            {
                ParseBool(R(node, "BoxShadowNormalEnabled"), b => BoxShadowNormalEnabled = b);
                ParseBool(R(node, "BoxShadowOutsideEnabled"), b => BoxShadowOutsideEnabled = b);
                ParseBool(R(node, "BoxShadowInsideEnabled"), b => BoxShadowInsideEnabled = b);
            }
            else if (legacyBoxShadowEnabled)
            {
                BoxShadowNormalEnabled = BoxShadowMode == FancyTextBackgroundShadowMode.Behind;
                BoxShadowOutsideEnabled = BoxShadowMode == FancyTextBackgroundShadowMode.OutsideOnly;
                BoxShadowInsideEnabled = BoxShadowMode == FancyTextBackgroundShadowMode.InsideOnly;
            }
            if (_boxShadowEnabledChk != null) _boxShadowEnabledChk.Checked = BoxShadowNormalEnabled;
            if (_boxShadowOutsideEnabledChk != null) _boxShadowOutsideEnabledChk.Checked = BoxShadowOutsideEnabled;
            if (_boxShadowInsideEnabledChk != null) _boxShadowInsideEnabledChk.Checked = BoxShadowInsideEnabled;
            SetColorBtn(R(node, "BoxShadowColor"), ref _boxShadowColorBtn, c => BoxShadowColor = c);
            ParseFloat(R(node, "BoxShadowOffsetX"), f => { BoxShadowOffsetX = f; SetNumericValue(_boxShadowOffsetXNum, f); });
            ParseFloat(R(node, "BoxShadowOffsetY"), f => { BoxShadowOffsetY = f; SetNumericValue(_boxShadowOffsetYNum, f); });
            ParseFloat(R(node, "BoxShadowSize"), f => { BoxShadowSize = f; SetNumericValue(_boxShadowSizeNum, f); });
            ParseFloat(R(node, "BoxShadowBlur"), f => { BoxShadowBlur = Math.Max(0f, Math.Min(64f, f)); SetNumericValue(_boxShadowBlurNum, BoxShadowBlur); });
            string shadowPasses = R(node, "BoxShadowPasses") ?? R(node, "BoxShadowSoftness");
            ParseInt(shadowPasses, i => { BoxShadowPasses = Math.Max(1, Math.Min(32, i)); SetNumericValue(_boxShadowPassesNum, BoxShadowPasses); });
            if (!hasControllerMode)
            {
                bool hasTextEffects = OverrideTextColors || OverrideOutline || OverrideShadow;
                ControllerMode = LayoutBoxEnabled && !hasTextEffects
                    ? FancyTextControllerMode.Background
                    : FancyTextControllerMode.Text;
            }

            ApplyControllerModeSideEffects();
            UpdateModeControlStates(false);
            UpdateLayoutBoxControlStates();

            if (TryParseEnum(R(node, "ScopeMode"), out FancyTextScopeMode scope))
                ScopeMode = scope;
            if (_rdoScopeThis     != null) _rdoScopeThis.Checked     = ScopeMode == FancyTextScopeMode.ThisComponentOnly;
            if (_rdoScopeAll      != null) _rdoScopeAll.Checked      = ScopeMode == FancyTextScopeMode.AllComponents;
            if (_rdoScopeSelected != null) _rdoScopeSelected.Checked = ScopeMode == FancyTextScopeMode.SelectedComponents;

            string targets = R(node, "TargetComponents");
            TargetComponents.Clear();
            if (!string.IsNullOrEmpty(targets))
                foreach (string name in targets.Split('|'))
                    if (!string.IsNullOrWhiteSpace(name))
                        TargetComponents.Add(name);

            PopulateComponentList();
            UpdateScopeControlStates();
            UpdateModeControlStates(true);
        }

        // =====================================================================
        // UI helpers
        // =====================================================================

        protected override void OnParentChanged(EventArgs e)
        {
            base.OnParentChanged(e);

            if (Parent != null)
                QueueScrollReset();
        }

        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);

            if (Visible)
                QueueScrollReset();
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);

            if (Visible)
                QueueScrollReset();
        }

        public void PrepareForDisplay()
        {
            QueueScrollReset();
        }

        private void QueueScrollReset()
        {
            _resetScrollPosition = true;

            if (!IsHandleCreated || IsDisposed)
                return;

            BeginInvoke(new Action(() =>
            {
                if (IsDisposed)
                    return;

                _resetScrollPosition = true;
                ResizeSections();
            }));
        }

        private void AddSettingsSection(Control section)
        {
            section.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top;
            section.TabIndex = _contentPanel.Controls.Count;
            _contentPanel.Controls.Add(section);
        }

        private void ResizeSections()
        {
            if (_scrollPanel == null || _contentPanel == null)
                return;

            int previousScrollY = _resetScrollPosition ? 0 : -_scrollPanel.AutoScrollPosition.Y;

            _scrollPanel.SuspendLayout();
            _contentPanel.SuspendLayout();

            _scrollPanel.AutoScrollPosition = Point.Empty;

            int width = Math.Max(320, _scrollPanel.ClientSize.Width - _scrollPanel.Padding.Horizontal - SystemInformation.VerticalScrollBarWidth - 4);
            int y = 0;
            _contentPanel.Location = new Point(_scrollPanel.Padding.Left, _scrollPanel.Padding.Top);
            _contentPanel.Width = width;

            foreach (Control control in _contentPanel.Controls)
            {
                if (!control.Visible)
                {
                    control.Location = new Point(0, y);
                    continue;
                }

                control.Location = new Point(0, y);
                control.Width = width;
                if (control is GroupBox group && group.Controls.Count > 0)
                {
                    Control content = group.Controls[0];
                    int contentWidth = Math.Max(240, width - 18);
                    Size preferred = content.GetPreferredSize(new Size(contentWidth, 0));
                    content.Width = contentWidth;
                    content.Height = preferred.Height;
                    group.Height = Math.Max(48, content.Height + 30);
                }

                y = control.Bottom + control.Margin.Bottom;
            }

            _contentPanel.Height = y;
            _scrollPanel.AutoScrollMinSize = new Size(0, y + _scrollPanel.Padding.Vertical);

            int maxScrollY = Math.Max(0, y + _scrollPanel.Padding.Vertical - _scrollPanel.ClientSize.Height);
            if (previousScrollY > maxScrollY)
                previousScrollY = maxScrollY;
            if (previousScrollY > 0)
                _scrollPanel.AutoScrollPosition = new Point(0, previousScrollY);
            else
                _scrollPanel.AutoScrollPosition = Point.Empty;

            _resetScrollPosition = false;

            _contentPanel.ResumeLayout(true);
            _scrollPanel.ResumeLayout(true);
        }

        private static GroupBox MakeSection(string title, Control content)
        {
            int sectionWidth = 440;
            int contentWidth = sectionWidth - 18;
            Size preferred = content.GetPreferredSize(new Size(contentWidth, 0));
            content.Location = new Point(8, 19);
            content.Size = new Size(contentWidth, preferred.Height);

            var gb = new GroupBox
            {
                Text     = title,
                Margin   = new Padding(0, 0, 0, 6),
                Padding  = new Padding(6),
                Size     = new Size(sectionWidth, Math.Max(48, preferred.Height + 30)),
            };
            gb.Controls.Add(content);
            return gb;
        }

        private static FlowLayoutPanel MakeCompactPanel()
        {
            return new FlowLayoutPanel
            {
                AutoSize = true,
                FlowDirection = FlowDirection.TopDown,
                WrapContents = false,
                Margin = Padding.Empty,
                Padding = Padding.Empty,
            };
        }

        private static FlowLayoutPanel MakeCompactRow()
        {
            return new FlowLayoutPanel
            {
                AutoSize = true,
                FlowDirection = FlowDirection.LeftToRight,
                WrapContents = false,
                Margin = new Padding(0, 0, 0, 2),
                Padding = Padding.Empty,
            };
        }

        private static CheckBox MakeCompactCheck(string text, bool isChecked)
        {
            return new CheckBox
            {
                Text = text,
                Checked = isChecked,
                AutoSize = true,
                Margin = new Padding(0, 3, 8, 0),
            };
        }

        private static Label MakeTinyLbl(string text)
        {
            return new Label
            {
                Text = text,
                AutoSize = true,
                Anchor = AnchorStyles.Left,
                TextAlign = ContentAlignment.MiddleLeft,
                Margin = new Padding(0, 4, 2, 0),
            };
        }

        private static Label MakeSectionLabel(string text)
        {
            return new Label
            {
                Text = text,
                AutoSize = true,
                Anchor = AnchorStyles.Left,
                TextAlign = ContentAlignment.MiddleLeft,
                Font = new Font(SystemFonts.DefaultFont, FontStyle.Bold),
                Margin = new Padding(0, 4, 8, 0),
            };
        }

        private static NumericUpDown MakeCompactNumeric(float value, float min, float max, int decimals, decimal increment)
        {
            NumericUpDown control = MakeNumeric(value, min, max, decimals, increment);
            control.Width = 54;
            control.Margin = new Padding(0, 0, 6, 0);
            return control;
        }

        private static ComboBox MakeCompactCombo(params string[] items)
        {
            ComboBox control = MakeCombo(items);
            control.Dock = DockStyle.None;
            control.Width = 118;
            control.Margin = new Padding(0, 0, 6, 0);
            return control;
        }

        private static void AddCompactControl(FlowLayoutPanel row, string label, Control control)
        {
            row.Controls.Add(MakeTinyLbl(label));
            control.Margin = control is Button
                ? new Padding(0, 1, 8, 0)
                : new Padding(0, 0, 8, 0);
            row.Controls.Add(control);
        }

        private static TableLayoutPanel MakeGrid(int rows)
        {
            var t = new TableLayoutPanel
            {
                AutoSize    = true,
                ColumnCount = 2,
                RowCount    = rows,
                Padding     = Padding.Empty,
                Margin      = Padding.Empty,
            };
            t.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 112f));
            t.ColumnStyles.Add(new ColumnStyle(SizeType.Percent,  100f));
            return t;
        }

        private static Label MakeLbl(string text) => new Label
        {
            Text      = text,
            AutoSize  = true,
            Anchor    = AnchorStyles.Left | AnchorStyles.Right,
            TextAlign = ContentAlignment.MiddleLeft,
        };

        private static ComboBox MakeCombo(params string[] items)
        {
            var c = new ComboBox { DropDownStyle = ComboBoxStyle.DropDownList, Dock = DockStyle.Fill };
            c.Items.AddRange(items);
            return c;
        }

        private static Button MakeColorBtn(Color initial) => new Button
        {
            BackColor               = initial,
            FlatStyle               = FlatStyle.Popup,
            UseVisualStyleBackColor = false,
            Width  = 23,
            Height = 23,
        };

        private static NumericUpDown MakeNumeric(float value, float min, float max,
                                                  int decimals, decimal increment)
        {
            return new NumericUpDown
            {
                Minimum       = (decimal)min,
                Maximum       = (decimal)max,
                DecimalPlaces = decimals,
                Increment     = increment,
                Value         = (decimal)Math.Max(min, Math.Min(max, value)),
                Width         = 70,
            };
        }

        private static void SetEnabled(Control control, bool enabled)
        {
            if (control != null)
                control.Enabled = enabled;
        }

        private static void SetVisible(Control control, bool visible)
        {
            if (control != null)
                control.Visible = visible;
        }

        private static void SetNumericValue(NumericUpDown control, float value)
        {
            if (control == null)
                return;

            decimal next = (decimal)value;
            if (next < control.Minimum)
                next = control.Minimum;
            if (next > control.Maximum)
                next = control.Maximum;

            if (control.Value != next)
                control.Value = next;
        }

        // =====================================================================
        // XML helpers
        // =====================================================================

        private static void W(XmlDocument doc, XmlElement parent, string name, string value)
        {
            var el = doc.CreateElement(name);
            el.InnerText = value ?? string.Empty;
            parent.AppendChild(el);
        }

        private static string R(XmlNode parent, string childName)
        {
            string s = parent[childName]?.InnerText;
            return string.IsNullOrEmpty(s) ? null : s;
        }

        private static string ColorToHex(Color c)  => c.ToArgb().ToString("X8");
        private static Color  HexToColor(string s)
        {
            try   { return Color.FromArgb(Convert.ToInt32(s, 16)); }
            catch { return Color.White; }
        }

        private static void ParseBool(string s, Action<bool> apply)
        {
            if (bool.TryParse(s, out bool b)) apply(b);
        }

        private static void ParseFloat(string s, Action<float> apply)
        {
            if (float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out float f))
                apply(f);
        }

        private static void ParseInt(string s, Action<int> apply)
        {
            if (int.TryParse(s, out int i)) apply(i);
        }

        private static void ParseEnum<T>(string s, out T result) where T : struct
        {
            result = default(T);
            if (!string.IsNullOrEmpty(s))
                Enum.TryParse(s, out result);
        }

        private static bool TryParseEnum<T>(string s, out T result) where T : struct
        {
            result = default(T);
            return !string.IsNullOrEmpty(s) && Enum.TryParse(s, out result);
        }

        private void SetColorBtn(string hex, ref Button btn, Action<Color> setProperty)
        {
            if (string.IsNullOrEmpty(hex)) return;
            Color c = HexToColor(hex);
            setProperty(c);
            if (btn != null) btn.BackColor = c;
        }
    }
}