Software/Visual_Studio/Scripting/Tango.Scripting.Editors/TextEditorWeakEventManager.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

using System;
using System.Collections.Generic;
using System.Diagnostics;
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 Tango.Logging;
using Tango.SharedUI.Controls;

namespace Tango.MachineStudio.Common.Controls
{
    /// <summary>
    /// Interaction logic for HiveComboControl.xaml
    /// </summary>
    public partial class HiveComboControl : UserControl
    {
        public event EventHandler<HexagonControl> SelectedHexagonChanged;
        public event EventHandler<int> LAxisValueChanged;
        public event EventHandler<int> ResolutionChanged;
        public event EventHandler HiveGenerated;

        public int Resolution
        {
            get { return (int)GetValue(ResolutionProperty); }
            set { SetValue(ResolutionProperty, value); }
        }
        public static readonly DependencyProperty ResolutionProperty =
            DependencyProperty.Register("Resolution", typeof(int), typeof(HiveComboControl), new PropertyMetadata(1, (d, e) => (d as HiveComboControl).OnResolutionChanged()));

        public HexagonControl SelectedHexagon
        {
            get { return (HexagonControl)GetValue(SelectedHexagonProperty); }
            set { SetValue(SelectedHexagonProperty, value); }
        }
        public static readonly DependencyProperty SelectedHexagonProperty =
            DependencyProperty.Register("SelectedHexagon", typeof(HexagonControl), typeof(HiveComboControl), new PropertyMetadata(null, (d, e) => (d as HiveComboControl).OnSelectedHexagonChanged()));

        public int LAxisValue
        {
            get { return (int)GetValue(LAxisValueProperty); }
            set { SetValue(LAxisValueProperty, value); }
        }
        public static readonly DependencyProperty LAxisValueProperty =
            DependencyProperty.Register("LAxisValue", typeof(int), typeof(HiveComboControl), new PropertyMetadata(0, (d, e) => (d as HiveComboControl).OnLAxisValueChanged()));

        public HexagonControl CenterHexagon
        {
            get { return hive.CenterHexagon; }
        }


        public HiveComboControl()
        {
            InitializeComponent();

            hive.HiveGenerated += (x, e) => HiveGenerated?.Invoke(this, new EventArgs());
        }

        private void OnLAxisValueChanged()
        {
            LAxisValueChanged?.Invoke(this, LAxisValue);
        }

        private void OnSelectedHexagonChanged()
        {
            SelectedHexagonChanged?.Invoke(this, SelectedHexagon);
        }

        private void OnResolutionChanged()
        {
            ResolutionChanged?.Invoke(this, Resolution);
        }

        public void GenerateDemoModeHiveColors(Color originalColor)
        {
            if (hive.CenterHexagon != null)
            {
                Random rnd = new Random();

                (hive.CenterHexagon.Fill as SolidColorBrush).Color = originalColor;

                int counter = 0;

                foreach (var hexagon in hive.Hexagons.Where(x => x != hive.CenterHexagon).OrderBy(x => rnd.Next()))
                {
                    (hexagon.Fill as SolidColorBrush).Color = Color.FromRgb((byte)Math.Min(originalColor.R + counter++, 255), (byte)Math.Min((originalColor.G + counter++), 255), (byte)Math.Min((originalColor.B + counter++), 255));

                    counter += (int)(4d * ((double)Resolution / 4d));
                }
            }
        }

        private void OnResolutionUpClicked(object sender, RoutedEventArgs e)
        {
            if (Resolution < 10)
            {
                Resolution++;
            }
        }

        private void OnResolutionDownClicked(object sender, RoutedEventArgs e)
        {
            if (Resolution > 1)
            {
                Resolution--;
            }
        }

        private void OnRowHiveHexagonSelected(object sender, HexagonControl hexagon)
        {
            LAxisValue = 2 - hexagon.Row;
        }

        private void OnHexagonSelected(object sender, HexagonControl e)
        {
            SelectedHexagon = e;
        }

        public void SelectHeagon(HexagonControl hexagon)
        {
            hive.SelectHexagon(hexagon);
            SelectedHexagonChanged?.Invoke(this, hexagon);
        }
    }
}