VRDash/VDash/UI/WindowOverlayEditor.xaml.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using VDash.Overlay.Actions;
using VDash.Overlay.Config;
using VDash.UI.ActionEditors;
using VDash.WindowSelectors;

namespace VDash.UI
{
    /// <summary>
    /// Interaction logic for CreateWindowOverlay.xaml
    /// </summary>
    public partial class WindowOverlayEditor : UserControl,IOverlayEditor
    {
        public WindowOverlayConfig OverlayConfig { get; set; }

        public SelectorWrapper[] Selectors { get; private set; } =
        {
            new SelectorWrapper("By Process Name", typeof(FromProcessName), typeof(ProcessSelectorEditor)),
            new SelectorWrapper("By Window Title", typeof(FromWindowTitle), typeof(WindowSelectorEditor))
        };

        public IOverlayConfig Config { get { return OverlayConfig; } }
        

        public WindowOverlayEditor()
        {
            InitializeComponent();
            OverlayConfig = new WindowOverlayConfig();
            OverlayConfig.OverlayShownActions.Add(new BringWindowToFrontAction(true));
            DataContext = OverlayConfig;

            cbSelector.ItemsSource = Selectors;
            SetupDropDown();
        }

        public WindowOverlayEditor(ref WindowOverlayConfig config)
        {
            InitializeComponent();
            OverlayConfig = config;
            DataContext = OverlayConfig;
            cbSelector.ItemsSource = Selectors;
            SetupDropDown();
        }

        private void SetupDropDown()
        {
            if (OverlayConfig.Selector != null)
            {
                SelectorWrapper wrapper = Selectors.Single(x => x.SelectorType == OverlayConfig.Selector.GetType());
                IWindowSelector selector = OverlayConfig.Selector;
                UserControl editor = (UserControl)Activator.CreateInstance(wrapper.EditorType, new object[] { selector });
                wrapper.Editor = editor;
                wrapper.Selector = selector;
                cbSelector.SelectedItem = wrapper;
            }
        }

        public class SelectorWrapper
        {
            public string FriendlyName { get; set; }
            //public IWindowSelector Selector{ get; private set; }
            public Type SelectorType { get; set; }
            //public UserControl Control { get; set; }
            public Type EditorType { get; set; }

            public IWindowSelector Selector { get; set; }

            public UserControl Editor { get; set; } = null;

            public SelectorWrapper(string friendlyName, Type selectorType, Type editorType)
            {
                FriendlyName = friendlyName;
                SelectorType = selectorType;
                EditorType = editorType;

                Selector = (IWindowSelector)Activator.CreateInstance(selectorType);
                Editor = (UserControl)Activator.CreateInstance(EditorType, new object[] { Selector });
            }

            public override string ToString()
            {
                return FriendlyName;
            }
        }

        private void cbSelector_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var wrapper = (SelectorWrapper)cbSelector.SelectedItem;
            OverlayConfig.Selector = wrapper.Selector;
            bdrSelector.Child = wrapper.Editor;
        }

        public string[] ValidateInput()
        {
            List<string> issues = new List<string>();
            if (String.IsNullOrWhiteSpace(Config.Name))
            {
                issues.Add("Please enter a name.");
            }
            
            if((SelectorWrapper)cbSelector.SelectedItem == null)
            {
                issues.Add("Please select a window selector.");
            }
            else
            {
                //Type selectorType = ((SelectorWrapper)cbSelector.SelectedItem).Editor;
                var selectorEditor = (ISelectorEditor)((SelectorWrapper)cbSelector.SelectedItem).Editor;
                issues.AddRange(selectorEditor.ValidateInput());
            }
            return issues.ToArray();
        }

        private void ContextMenuBuilder(Collection<IWindowAction> col)
        {
            List<MenuItem> items = new List<MenuItem>();
            ContextMenu menu = new ContextMenu();
            menu.ItemsSource = items;
            menu.Placement = System.Windows.Controls.Primitives.PlacementMode.MousePoint;

            foreach(var actionType in OverlayActionInfo.GetTypesWithAttribute())
            {
                OverlayActionInfo attribute = (OverlayActionInfo)actionType.GetCustomAttributes(typeof(OverlayActionInfo), false).Single();
                if(attribute.EditorType == null)
                {
                    var item = new MenuItem() { Header = attribute.Description };
                    item.Click += (s, e) => {
                        IWindowAction action = (IWindowAction)Activator.CreateInstance(actionType);
                        col.Add(action);
                    };
                    items.Add(item);
                }
                else
                {
                    var item = new MenuItem() { Header = attribute.Description };
                    IWindowAction action = (IWindowAction)Activator.CreateInstance(actionType);
                    IActionEditor editor = (IActionEditor)Activator.CreateInstance(attribute.EditorType, new object[] { action });
                    item.ItemsSource = new object[] { new MenuItem() { Header = editor } };
                    editor.Submitted += (s, e) =>
                    {
                        col.Add(action);
                        menu.IsOpen = false;
                    };
                    items.Add(item);
                }
            }

            menu.IsOpen = true;
        }

        private void btnOnShowAdd_Click(object sender, RoutedEventArgs e)
        {
            ContextMenuBuilder(OverlayConfig.OverlayShownActions);
        }

        private void btnOnShowRemove_Click(object sender, RoutedEventArgs e)
        {
            if(lvOnOpenActions.SelectedItem == null)
            {
                return;
            }
            OverlayConfig.OverlayShownActions.Remove((IWindowAction)lvOnOpenActions.SelectedItem);
        }

        private void btnOnHideAdd_Click(object sender, RoutedEventArgs e)
        {
            ContextMenuBuilder(OverlayConfig.OverlayHiddenActions);
        }

        private void btnOnHideRemove_Click(object sender, RoutedEventArgs e)
        {
            if (lvOnCloseActions.SelectedItem == null)
            {
                return;
            }
            OverlayConfig.OverlayHiddenActions.Remove((IWindowAction)lvOnCloseActions.SelectedItem);
        }
    }
}