FancyBackgroundRuntime.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Reflection;
using System.Windows.Forms;
using System.Xml;
using LiveSplit.Model;
using LiveSplit.UI;

namespace LiveSplit.UI.Components
{
    internal struct FancyBackgroundPadding
    {
        public static readonly FancyBackgroundPadding Empty = new FancyBackgroundPadding(0f, 0f, 0f, 0f);

        public readonly float Top;
        public readonly float Right;
        public readonly float Bottom;
        public readonly float Left;

        public FancyBackgroundPadding(float top, float right, float bottom, float left)
        {
            Top = Math.Max(0f, top);
            Right = Math.Max(0f, right);
            Bottom = Math.Max(0f, bottom);
            Left = Math.Max(0f, left);
        }

        public float Horizontal { get { return Left + Right; } }
        public float Vertical { get { return Top + Bottom; } }

        public FancyBackgroundPadding Add(FancyBackgroundPadding other)
        {
            return new FancyBackgroundPadding(Top + other.Top, Right + other.Right, Bottom + other.Bottom, Left + other.Left);
        }

        public bool NearlyEquals(FancyBackgroundPadding other)
        {
            return NearlyEquals(Top, other.Top)
                && NearlyEquals(Right, other.Right)
                && NearlyEquals(Bottom, other.Bottom)
                && NearlyEquals(Left, other.Left);
        }

        private static bool NearlyEquals(float left, float right)
        {
            return Math.Abs(left - right) < 0.001f;
        }
    }

    internal static class FancyBackgroundRuntime
    {
        private static readonly object Sync = new object();
        private static readonly Dictionary<FancyBackgroundComponent, FancyBackgroundSettings> ActiveInstances =
            new Dictionary<FancyBackgroundComponent, FancyBackgroundSettings>();
        private static readonly HashSet<FancyBackgroundComponent> PendingReorders =
            new HashSet<FancyBackgroundComponent>();

        public static void Publish(FancyBackgroundComponent owner, LiveSplitState state, FancyBackgroundSettings settings)
        {
            if (owner == null || settings == null)
            {
                return;
            }

            lock (Sync)
            {
                PruneInactiveInstances(state);
                if (settings.IsLayerActive)
                {
                    ActiveInstances[owner] = settings;
                }
                else
                {
                    ActiveInstances.Remove(owner);
                }
            }
        }

        public static void Unpublish(FancyBackgroundComponent owner)
        {
            if (owner == null)
            {
                return;
            }

            lock (Sync)
            {
                ActiveInstances.Remove(owner);
                PendingReorders.Remove(owner);
            }
        }

        public static bool IsActiveLayoutOwner(LiveSplitState state, FancyBackgroundComponent owner)
        {
            return ReferenceEquals(GetActiveOwner(state), owner);
        }

        public static FancyBackgroundPadding GetActivePadding(LiveSplitState state)
        {
            FancyBackgroundSettings settings = GetActiveSettings(state);
            return settings != null ? settings.GetTotalPadding() : FancyBackgroundPadding.Empty;
        }

        public static float GetActiveScale(LiveSplitState state, LayoutMode mode)
        {
            Form form = state != null ? state.Form : null;
            if (form == null || form.IsDisposed)
            {
                return 1f;
            }

            float overallSize = CalculateOverallSize(state, mode);
            float primarySize = mode == LayoutMode.Vertical ? form.Height : form.Width;
            if (overallSize <= 0.001f || primarySize <= 0f)
            {
                return 1f;
            }

            return primarySize / overallSize;
        }

        public static void UpdateLayoutProxies(LiveSplitState state, LayoutMode mode)
        {
            FancyBackgroundSettings settings = GetActiveSettings(state);
            bool enabled = settings != null
                && settings.NeedsContentBoundsProxy(mode);

            if (enabled)
            {
                InstallLayoutProxies(state);
            }
            else
            {
                RemoveLayoutProxies(state);
            }
        }

        private static void InstallLayoutProxies(LiveSplitState state)
        {
            ILayout layout = state != null ? state.Layout : null;
            if (layout == null || layout.LayoutComponents == null)
            {
                return;
            }

            foreach (ILayoutComponent layoutComponent in layout.LayoutComponents)
            {
                if (layoutComponent == null || layoutComponent.Component == null)
                {
                    continue;
                }

                IComponent component = layoutComponent.Component;
                IComponent unwrapped = Unwrap(component);

                if (component is FancyBackgroundComponentProxy
                    || unwrapped is FancyBackgroundComponent
                    || IsFancyTextController(component)
                    || IsFancyTextController(unwrapped))
                {
                    continue;
                }

                if (IsFancyTextProxy(component))
                {
                    IComponent inner;
                    if (TryGetKnownProxyInner(component, out inner)
                        && !(inner is FancyBackgroundComponentProxy)
                        && !(Unwrap(inner) is FancyBackgroundComponent))
                    {
                        IComponent recreatedProxy;
                        if (TryCreateFancyTextProxy(component, new FancyBackgroundComponentProxy(inner), out recreatedProxy))
                        {
                            layoutComponent.Component = recreatedProxy;
                        }
                    }
                    continue;
                }

                layoutComponent.Component = new FancyBackgroundComponentProxy(component);
            }
        }

        private static void RemoveLayoutProxies(LiveSplitState state)
        {
            ILayout layout = state != null ? state.Layout : null;
            if (layout == null || layout.LayoutComponents == null)
            {
                return;
            }

            foreach (ILayoutComponent layoutComponent in layout.LayoutComponents)
            {
                if (layoutComponent == null || layoutComponent.Component == null)
                {
                    continue;
                }

                IComponent component = layoutComponent.Component;
                FancyBackgroundComponentProxy proxy = component as FancyBackgroundComponentProxy;
                if (proxy != null)
                {
                    layoutComponent.Component = proxy.Inner;
                    continue;
                }

                if (IsFancyTextProxy(component))
                {
                    IComponent inner;
                    if (TryGetKnownProxyInner(component, out inner))
                    {
                        FancyBackgroundComponentProxy innerProxy = inner as FancyBackgroundComponentProxy;
                        if (innerProxy != null)
                        {
                            IComponent recreatedProxy;
                            if (TryCreateFancyTextProxy(component, innerProxy.Inner, out recreatedProxy))
                            {
                                layoutComponent.Component = recreatedProxy;
                            }
                        }
                    }
                }
            }
        }

        public static void ScheduleControllerFirst(LiveSplitState state, FancyBackgroundComponent owner)
        {
            if (state == null || owner == null || state.Layout == null || state.Layout.LayoutComponents == null)
            {
                return;
            }

            IList<ILayoutComponent> components = state.Layout.LayoutComponents;
            int ownerIndex = IndexOfComponent(components, owner);
            if (ownerIndex <= 0)
            {
                return;
            }

            lock (Sync)
            {
                if (!PendingReorders.Add(owner))
                {
                    return;
                }
            }

            Form form = state.Form;
            if (form == null || form.IsDisposed || !form.IsHandleCreated)
            {
                try
                {
                    ReorderControllerFirst(state, owner);
                }
                finally
                {
                    lock (Sync)
                    {
                        PendingReorders.Remove(owner);
                    }
                }
                return;
            }

            form.BeginInvoke(new Action(() =>
            {
                try
                {
                    ReorderControllerFirst(state, owner);
                    Invalidate(state);
                }
                finally
                {
                    lock (Sync)
                    {
                        PendingReorders.Remove(owner);
                    }
                }
            }));
        }

        public static void Invalidate(LiveSplitState state)
        {
            Form form = state != null ? state.Form : null;
            if (form == null || form.IsDisposed)
            {
                return;
            }

            if (form.InvokeRequired)
            {
                form.BeginInvoke(new Action(() => Invalidate(state)));
                return;
            }

            form.Invalidate();
        }

        internal static IComponent Unwrap(IComponent component)
        {
            int depth = 0;
            while (component != null && depth < 16)
            {
                depth++;

                FancyBackgroundComponentProxy proxy = component as FancyBackgroundComponentProxy;
                if (proxy != null)
                {
                    component = proxy.Inner;
                    continue;
                }

                IComponent knownProxyInner;
                if (TryGetKnownProxyInner(component, out knownProxyInner))
                {
                    component = knownProxyInner;
                    continue;
                }

                break;
            }
            return component;
        }

        private static FancyBackgroundSettings GetActiveSettings(LiveSplitState state)
        {
            FancyBackgroundComponent owner = GetActiveOwner(state);
            if (owner == null)
            {
                return null;
            }

            lock (Sync)
            {
                FancyBackgroundSettings settings;
                return ActiveInstances.TryGetValue(owner, out settings) ? settings : null;
            }
        }

        private static FancyBackgroundComponent GetActiveOwner(LiveSplitState state)
        {
            ILayout layout = state != null ? state.Layout : null;
            if (layout == null || layout.LayoutComponents == null)
            {
                return null;
            }

            lock (Sync)
            {
                PruneInactiveInstances(state);
                foreach (ILayoutComponent layoutComponent in layout.LayoutComponents)
                {
                    IComponent component = layoutComponent != null ? Unwrap(layoutComponent.Component) : null;
                    FancyBackgroundComponent owner = component as FancyBackgroundComponent;
                    if (owner != null && ActiveInstances.ContainsKey(owner))
                    {
                        return owner;
                    }
                }

                return null;
            }
        }

        private static void ReorderControllerFirst(LiveSplitState state, FancyBackgroundComponent owner)
        {
            if (state == null || owner == null || state.Layout == null || state.Layout.LayoutComponents == null)
            {
                return;
            }

            IList<ILayoutComponent> components = state.Layout.LayoutComponents;
            int ownerIndex = IndexOfComponent(components, owner);
            if (ownerIndex < 0)
            {
                return;
            }

            ILayoutComponent item = components[ownerIndex];
            components.RemoveAt(ownerIndex);
            components.Insert(0, item);
        }

        private static int IndexOfComponent(IList<ILayoutComponent> components, IComponent target)
        {
            if (components == null || target == null)
            {
                return -1;
            }

            for (int index = 0; index < components.Count; index++)
            {
                IComponent component = components[index] != null ? Unwrap(components[index].Component) : null;
                if (ReferenceEquals(component, target))
                {
                    return index;
                }
            }

            return -1;
        }

        private static void PruneInactiveInstances(LiveSplitState state)
        {
            if (state == null || state.Layout == null || state.Layout.LayoutComponents == null)
            {
                return;
            }

            HashSet<IComponent> layoutComponents = new HashSet<IComponent>(
                state.Layout.LayoutComponents
                    .Where(x => x != null && x.Component != null)
                    .Select(x => Unwrap(x.Component)));

            List<FancyBackgroundComponent> stale = ActiveInstances.Keys
                .Where(x => !layoutComponents.Contains(x))
                .ToList();
            foreach (FancyBackgroundComponent owner in stale)
            {
                ActiveInstances.Remove(owner);
                PendingReorders.Remove(owner);
            }
        }

        private static float CalculateOverallSize(LiveSplitState state, LayoutMode mode)
        {
            if (state == null || state.Layout == null || state.Layout.Components == null)
            {
                return 1f;
            }

            List<IComponent> components = state.Layout.Components
                .Where(component => component != null)
                .ToList();

            float totalSize = 0f;
            for (int index = 0; index < components.Count; index++)
            {
                if (mode == LayoutMode.Vertical)
                {
                    float bottomPadding = Math.Min(GetPaddingBelow(components, index), components[index].PaddingBottom) / 2f;
                    totalSize += components[index].VerticalHeight - (bottomPadding * 2f);
                }
                else
                {
                    float rightPadding = Math.Min(GetPaddingToRight(components, index), components[index].PaddingRight) / 2f;
                    totalSize += components[index].HorizontalWidth - (rightPadding * 2f);
                }
            }

            return Math.Max(totalSize, 1f);
        }

        private static float GetPaddingBelow(List<IComponent> components, int index)
        {
            while (index < components.Count - 1)
            {
                index++;
                IComponent component = components[index];
                if (component.VerticalHeight != 0f)
                {
                    return component.PaddingTop;
                }
            }

            return 0f;
        }

        private static float GetPaddingToRight(List<IComponent> components, int index)
        {
            while (index < components.Count - 1)
            {
                index++;
                IComponent component = components[index];
                if (component.HorizontalWidth != 0f)
                {
                    return component.PaddingRight;
                }
            }

            return 0f;
        }

        private static bool IsFancyTextController(IComponent component)
        {
            return IsTypeName(component, "LiveSplit.UI.Components.FancyTextComponent");
        }

        private static bool IsFancyTextProxy(IComponent component)
        {
            return IsTypeName(component, "LiveSplit.UI.Components.FancyTextComponentProxy");
        }

        private static bool TryCreateFancyTextProxy(IComponent templateProxy, IComponent inner, out IComponent recreatedProxy)
        {
            recreatedProxy = null;
            if (!IsFancyTextProxy(templateProxy) || inner == null)
            {
                return false;
            }

            try
            {
                recreatedProxy = Activator.CreateInstance(templateProxy.GetType(), inner) as IComponent;
            }
            catch
            {
                recreatedProxy = null;
            }

            return recreatedProxy != null;
        }

        private static bool TryGetKnownProxyInner(IComponent component, out IComponent inner)
        {
            inner = null;
            if (!IsTypeName(component, "LiveSplit.UI.Components.FancyTextComponentProxy"))
            {
                return false;
            }

            PropertyInfo property = component.GetType().GetProperty("Inner",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            try
            {
                inner = property != null ? property.GetValue(component, null) as IComponent : null;
            }
            catch
            {
                inner = null;
            }
            return inner != null && !ReferenceEquals(inner, component);
        }

        private static bool IsTypeName(IComponent component, string fullName)
        {
            return component != null
                && string.Equals(component.GetType().FullName, fullName, StringComparison.Ordinal);
        }
    }

    internal sealed class FancyBackgroundComponentProxy : IDeactivatableComponent
    {
        public IComponent Inner { get; private set; }

        public FancyBackgroundComponentProxy(IComponent inner)
        {
            Inner = inner;
        }

        public string ComponentName { get { return Inner.ComponentName; } }
        public float HorizontalWidth { get { return Inner.HorizontalWidth; } }
        public float MinimumHeight { get { return Inner.MinimumHeight; } }
        public float VerticalHeight { get { return Inner.VerticalHeight; } }
        public float MinimumWidth { get { return Inner.MinimumWidth; } }
        public float PaddingTop { get { return Inner.PaddingTop; } }
        public float PaddingBottom { get { return Inner.PaddingBottom; } }
        public float PaddingLeft { get { return Inner.PaddingLeft; } }
        public float PaddingRight { get { return Inner.PaddingRight; } }
        public IDictionary<string, Action> ContextMenuControls { get { return Inner.ContextMenuControls; } }

        public bool Activated
        {
            get
            {
                IDeactivatableComponent deactivatable = Inner as IDeactivatableComponent;
                return deactivatable == null || deactivatable.Activated;
            }
            set
            {
                IDeactivatableComponent deactivatable = Inner as IDeactivatableComponent;
                if (deactivatable != null)
                {
                    deactivatable.Activated = value;
                }
            }
        }

        public void DrawHorizontal(Graphics g, LiveSplitState state, float height, Region clipRegion)
        {
            FancyBackgroundPadding padding = FancyBackgroundRuntime.GetActivePadding(state);
            float contentHeight = Math.Max(1f, height - padding.Top - padding.Bottom);
            Inner.DrawHorizontal(g, state, contentHeight, clipRegion);
        }

        public void DrawVertical(Graphics g, LiveSplitState state, float width, Region clipRegion)
        {
            FancyBackgroundPadding padding = FancyBackgroundRuntime.GetActivePadding(state);
            float contentWidth = Math.Max(1f, width - padding.Left - padding.Right);
            Inner.DrawVertical(g, state, contentWidth, clipRegion);
        }

        public Control GetSettingsControl(LayoutMode mode)
        {
            return Inner.GetSettingsControl(mode);
        }

        public XmlNode GetSettings(XmlDocument document)
        {
            return Inner.GetSettings(document);
        }

        public void SetSettings(XmlNode settings)
        {
            Inner.SetSettings(settings);
        }

        public void Update(IInvalidator invalidator, LiveSplitState state, float width, float height, LayoutMode mode)
        {
            FancyBackgroundPadding padding = FancyBackgroundRuntime.GetActivePadding(state);
            float scale = FancyBackgroundRuntime.GetActiveScale(state, mode);
            float contentWidth = mode == LayoutMode.Vertical
                ? Math.Max(1f, width - ((padding.Left + padding.Right) * scale))
                : width;
            float contentHeight = mode == LayoutMode.Horizontal
                ? Math.Max(1f, height - ((padding.Top + padding.Bottom) * scale))
                : height;

            Inner.Update(invalidator, state, contentWidth, contentHeight, mode);
        }

        public void Dispose()
        {
            Inner.Dispose();
        }
    }
}