MTP2.0_CSharp/Muchinfo.Common/Fx4.0/Muchinfo.ChartClient/MuchInfo.Chart/MuchInfo.Chart.WPF/Primitives/Drawing/DrawingArrow.cs

using Microsoft.VisualBasic.CompilerServices;
using MuchInfo.Chart.Data;
using MuchInfo.Chart.Data.EnumTypes;
using MuchInfo.Chart.Infrastructure.Controls;
using MuchInfo.Chart.Infrastructure.Helpers;
using MuchInfo.Chart.Infrastructure.Utilities;
using MuchInfo.Chart.WPF.Controls.Utilities;
using MuchInfo.Chart.WPF.Helpers;
using MuchInfo.Chart.WPF.Primitives.Interfaces;
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;
using System.Xml.Linq;

namespace MuchInfo.Chart.WPF.Primitives.Drawing
{
    public class DrawingArrow : Drawing1PointBase
    {
        #region Fields

        private double _angle;
        private Ellipse _angleGrab;
        private bool _angleGrabMouseDown;
        private bool _angleGrabMouseEnter;
        private Polygon _arrow;
        private bool _arrowMouseDown;
        private bool _arrowMove;
        private Canvas _canvas;
        private RotateTransform _canvasRotateTransform;
        private List<Polyline> _ploylineList;
        private Point _position;

        //鼠标移到上面时记录上次画线工具
        private IDrawingTool _preDrawingTool;
        private RotateTransform _rotateTransform;

        #endregion Fields

        #region Constructors

        public DrawingArrow()
        {
            this._angle = 0.0;
            this._ploylineList = new List<Polyline>();
            this._angleGrabMouseDown = false;
            this._angleGrabMouseEnter = false;
            this._arrowMouseDown = false;
        }

        #endregion Constructors

        #region Properties

        #region Public Properties

        public float Angle
        {
            get
            {
                return (float)this._angle;
            }
            set
            {
                bool flag = !this._angle.Equals(value);
                if (flag)
                {
                    bool flag2 = value > 360f;
                    if (flag2)
                    {
                        value -= 360f;
                    }
                    flag2 = (value < 0f);
                    if (flag2)
                    {
                        value += 360f;
                    }
                    flag2 = (Math.Abs(value - 0f) < 10f);
                    if (flag2)
                    {
                        this._angle = 0.0;
                    }
                    else
                    {
                        flag2 = (Math.Abs(value - 360f) < 10f);
                        if (flag2)
                        {
                            this._angle = 0.0;
                        }
                        else
                        {
                            flag2 = (Math.Abs(value - 90f) < 10f);
                            if (flag2)
                            {
                                this._angle = 90.0;
                            }
                            else
                            {
                                flag2 = (Math.Abs(value - 180f) < 10f);
                                if (flag2)
                                {
                                    this._angle = 180.0;
                                }
                                else
                                {
                                    flag2 = (Math.Abs(value - 270f) < 10f);
                                    if (flag2)
                                    {
                                        this._angle = 270.0;
                                    }
                                    else
                                    {
                                        this._angle = (double)value;
                                    }
                                }
                            }
                        }
                    }
                    this.PropertyChanged();
                }
            }
        }

        public virtual Ellipse AngleGrab
        {
            get
            {
                return this._angleGrab;
            }
            set
            {
                var mouseEventHandler = new MouseEventHandler(this.AngleGrab_MouseMove);
                var mouseButtonEventHandler = new MouseButtonEventHandler(this.AngleGrab_MouseLeftButtonUp);
                var mouseButtonEventHandler2 = new MouseButtonEventHandler(this.AngleGrab_MouseLeftButtonDown);
                var mouseEventHandler2 = new MouseEventHandler(this.AngleGrab_MouseLeave);
                var mouseEventHandler3 = new MouseEventHandler(this.AngleGrab_MouseEnter);
                var mouseEventHandler4 = new MouseEventHandler(this.AngleGrab_LostMouseCapture);
                bool flag = this._angleGrab != null;
                if (flag)
                {
                    this._angleGrab.MouseMove -= (mouseEventHandler);
                    this._angleGrab.MouseLeftButtonUp -= (mouseButtonEventHandler);
                    this._angleGrab.MouseLeftButtonDown -= (mouseButtonEventHandler2);
                    this._angleGrab.MouseLeave -= (mouseEventHandler2);
                    this._angleGrab.MouseEnter -= (mouseEventHandler3);
                    this._angleGrab.LostMouseCapture -= (mouseEventHandler4);
                }
                this._angleGrab = value;
                flag = (this._angleGrab != null);
                if (flag)
                {
                    this._angleGrab.MouseMove += (mouseEventHandler);
                    this._angleGrab.MouseLeftButtonUp += (mouseButtonEventHandler);
                    this._angleGrab.MouseLeftButtonDown += (mouseButtonEventHandler2);
                    this._angleGrab.MouseLeave += (mouseEventHandler2);
                    this._angleGrab.MouseEnter += (mouseEventHandler3);
                    this._angleGrab.LostMouseCapture += (mouseEventHandler4);
                }
            }
        }

        public virtual Polygon Arrow
        {
            get
            {
                return this._arrow;
            }

            set
            {
                var mouseEventHandler = new MouseEventHandler(this.Arrow_MouseLeave);
                var mouseEventHandler2 = new MouseEventHandler(this.Arrow_MouseEnter);
                var mouseEventHandler3 = new MouseEventHandler(this.Arrow_MouseMove);
                var mouseButtonEventHandler = new MouseButtonEventHandler(this.Arrow_MouseLeftButtonUp);
                var mouseEventHandler4 = new MouseEventHandler(this.Arrow_LostMouseCapture);
                var mouseButtonEventHandler2 = new MouseButtonEventHandler(this.Arrow_MouseLeftButtonDown);
                var mouseRightButtonUp = new MouseButtonEventHandler(this.Arrow_MouseRightButtonUp);
                bool flag = this._arrow != null;
                if (flag)
                {
                    this._arrow.MouseLeave -= (mouseEventHandler);
                    this._arrow.MouseEnter -= (mouseEventHandler2);
                    this._arrow.MouseMove -= (mouseEventHandler3);
                    this._arrow.MouseLeftButtonUp -= (mouseButtonEventHandler);
                    this._arrow.LostMouseCapture -= (mouseEventHandler4);
                    this._arrow.MouseLeftButtonDown -= (mouseButtonEventHandler2);
                    this._arrow.MouseRightButtonDown -= mouseRightButtonUp;
                }
                this._arrow = value;
                flag = (this._arrow != null);
                if (flag)
                {
                    this._arrow.MouseLeave += (mouseEventHandler);
                    this._arrow.MouseEnter += (mouseEventHandler2);
                    this._arrow.MouseMove += (mouseEventHandler3);
                    this._arrow.MouseLeftButtonUp += (mouseButtonEventHandler);
                    this._arrow.LostMouseCapture += (mouseEventHandler4);
                    this._arrow.MouseLeftButtonDown += (mouseButtonEventHandler2);
                    //Up弹出Popup，PopupManager里用Down关闭Popup
                    this._arrow.MouseRightButtonUp += mouseRightButtonUp;
                }
            }
        }

        public override string RootName
        {
            get { return "DrawArrow"; }
        }

        #endregion Public Properties

        #endregion Properties

        #region Methods

        #region Public Methods

        public override string Abbreviation()
        {
            return MenuDescription();
        }

        public override List<ControlPair> AdditionalEditors()
        {
            var list = new List<ControlPair>()
            {
                new ControlPair()
                {
                    ControlLeft = new TextBlock
                    {
                        Text =  LanguageManager.FindResource(LanguageConst.DrawingTool_Edit_Angle)
                    },
                    ControlRight = new ChartSingleUpDown(this, "Angle", 0, 360, 5f)
                }
            };
            return list;
        }

        public override bool CanPlotOnAllSymbols()
        {
            return false;
        }

        public override bool CanSaveByPercent()
        {
            return false;
        }

        public override IDrawingTool Clone()
        {
            return new DrawingArrow
            {
                mColor = ColorHelper.Red
            };
        }

        public override string Description()
        {
            return this.MenuDescription();
        }

        public override ImageSource Icon()
        {
            ImageSource result;
            try
            {
                result = ImageHelper.GetImage("arrow_up_blue.png");
            }
            catch (Exception expr_3A)
            {
                ProjectData.SetProjectError(expr_3A);
                result = null;
                ProjectData.ClearProjectError();
            }
            return result;
        }

        public override string MenuDescription()
        {
            return LanguageManager.FindResource(LanguageConst.DrawingTool_Edit_Description_Arrow);
        }

        public override DrawingToolType ToolType()
        {
            return DrawingToolType.Arrow;
        }

        #endregion Public Methods

        #region Protected Methods

        protected override void AddFromInfo(DrawingToolInfo info)
        {
            base.AddFromInfo(info);
            try
            {
                XElement xElement = XElement.Parse(info.XML);
                bool flag = xElement.Name == "Root";
                if (flag)
                {
                    bool flag2 = xElement.Attribute("Value1") != null;
                    if (flag2)
                    {
                        this._angle = XMLHelp.ParseDouble(xElement.Attribute("Value1").Value);
                    }
                }
            }
            catch (Exception expr_9C)
            {
                ProjectData.SetProjectError(expr_9C);
                ProjectData.ClearProjectError();
            }
        }

        protected override void AddFromXml(XElement xml)
        {
            bool flag = xml.Attribute("ANG") != null;
            if (flag)
            {
                this._angle = XMLHelp.ParseDouble(xml.Attribute("ANG").Value);
            }
        }

        protected override void AddToInfo(DrawingToolInfo info)
        {
            base.AddToInfo(info);
            XElement xElement = new XElement("Root");
            xElement.Add(new XAttribute("Value1", XMLHelp.NumToString(this._angle)));
            info.XML = xElement.ToString();
        }

        protected override void AddToXml(XElement xml, List<object> args)
        {
            xml.Add(new XAttribute("ANG", XMLHelp.NumToString(this._angle)));
        }

        protected override void ColorChanged()
        {
            bool flag = this.Arrow != null;
            if (flag)
            {
                this.Arrow.Fill = new SolidColorBrush(this.mColor);
                this.PropertyChanged();
            }
        }

        protected override List<FrameworkElement> GetDrawingPlots(Chart owner, ScaleLayer aScale, Rect aRect)
        {
            var list = new List<FrameworkElement>();
            bool flag = this.Arrow == null;
            if (flag)
            {
                this.Arrow = new Polygon { Fill = new SolidColorBrush(this.mColor) };
                this.Arrow.Points.Add(new Point(8.0, 0.0));
                this.Arrow.Points.Add(new Point(15.0, 9.0));
                this.Arrow.Points.Add(new Point(11.0, 9.0));
                this.Arrow.Points.Add(new Point(11.0, 16.0));
                this.Arrow.Points.Add(new Point(5.0, 16.0));
                this.Arrow.Points.Add(new Point(5.0, 9.0));
                this.Arrow.Points.Add(new Point(1.0, 9.0));

                this.Arrow.Cursor = Cursors.Hand;
                this._rotateTransform = new RotateTransform { CenterX = (8.0) };
                this.Arrow.RenderTransform = (this._rotateTransform);
                this.BuildCanvas();
                this.UpdatePloylines(Colors.Transparent);
            }
            this.MoveDrawingToNewLocations(aRect);
            list.Add(this._canvas);
            list.Add(this.Arrow);
            return list;
        }

        protected override void MoveDrawingToNewLocations(Rect aRect)
        {
            bool flag = this.Arrow != null;
            if (flag)
            {
                this._rotateTransform.Angle = (this._angle);
                this._canvasRotateTransform.Angle = (this._angle);
                this.Arrow.SetValue(Canvas.LeftProperty, this.mLastX1 - 7.5); //箭头宽15， 减去宽度一半
                this.Arrow.SetValue(Canvas.TopProperty, this.mLastY1);
                this._canvas.SetValue(Canvas.LeftProperty, this.mLastX1 - 2.0 - 7.5);//箭头宽15， 减去宽度一半
                this._canvas.SetValue(Canvas.TopProperty, this.mLastY1);
                var startPoint = new Point(this.mLastX1, this.mLastY1);
                GeometryHelper.PointFromAngleAndDistance(startPoint, this._angle, 22.0);
            }
            flag = (this.SelectionArea != null);
            if (flag)
            {
                this.SelectionArea.SetPosition(this.mLastX1, this.mLastY1, this.mLastX1, this.mLastY1);
            }
        }

        protected override bool ShowDragHandle()
        {
            return false;
        }

        #endregion Protected Methods

        #region Private Methods

        private void AngleGrab_LostMouseCapture(object sender, MouseEventArgs e)
        {
            this._angleGrabMouseDown = false;
            this.Chart.LockPainting = false;
            this.Chart.Refresh();
            bool flag = !this._angleGrabMouseEnter;
            if (flag)
            {
                this.UpdatePloylines(Colors.Transparent);
            }
        }

        private void AngleGrab_MouseEnter(object sender, MouseEventArgs e)
        {
            if (this.Chart != null && this.Chart.PointerType == PointerType.Drawing)
            {
                _preDrawingTool = this.Chart.CurrentDrawingTool;
                this.Chart.PointerType = PointerType.Cursor;
                this.Chart.SetCursorImagePos(true, e);
            }
            else
            {
                bool isDarkBackground = this.Chart.IsDarkBackground;
                this.UpdatePloylines(isDarkBackground ? Colors.Cyan : ColorHelper.DarkBlue);
                this._angleGrabMouseEnter = true;
            }
        }

        private void AngleGrab_MouseLeave(object sender, MouseEventArgs e)
        {
            if (_preDrawingTool == null)
            {
                this._angleGrabMouseEnter = false;
                bool flag = !this._angleGrabMouseDown;
                if (flag)
                {
                    this.UpdatePloylines(Colors.Transparent);
                }
            }
            else
            {
                this.Chart.CurrentDrawingTool = _preDrawingTool;
                this.Chart.SetCursorImagePos(true, e);
                _preDrawingTool = null;
            }
        }

        private void AngleGrab_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            bool flag = this.AngleGrab.CaptureMouse();
            if (flag)
            {
                this._angleGrabMouseDown = true;
                this.Chart.LockPainting = true;
            }
        }

        private void AngleGrab_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            this._angleGrabMouseDown = false;
            this.AngleGrab.ReleaseMouseCapture();
            this.Chart.LockPainting = false;
            this.Chart.Refresh();
        }

        private void AngleGrab_MouseMove(object sender, MouseEventArgs e)
        {
            try
            {
                bool flag = this._angleGrabMouseDown;
                if (flag)
                {
                    Point p = default(Point);
                    p.X = (this.mLastX1 + 8.0);
                    p.Y = (this.mLastY1);
                    this.Angle = (float)GeometryHelper.AngleFromPoints(p, e.GetPosition((UIElement)this.Arrow.Parent));
                    this.MoveDrawingToNewLocations(this.mLastRect);
                }
            }
            catch (Exception expr_92)
            {
                ProjectData.SetProjectError(expr_92);
                ProjectData.ClearProjectError();
            }
        }

        private void Arrow_LostMouseCapture(object sender, MouseEventArgs e)
        {
            this.Chart.LockPainting = false;
            this._arrowMouseDown = false;
            this._arrowMove = false;
            this.Chart.Refresh();
        }

        private void Arrow_MouseEnter(object sender, MouseEventArgs e)
        {
            if (this.Chart != null && this.Chart.PointerType == PointerType.Drawing)
            {
                _preDrawingTool = this.Chart.CurrentDrawingTool;
                this.Chart.PointerType = PointerType.Cursor;
                this.Chart.SetCursorImagePos(true, e);
            }
            else
            {
                bool isDarkBackground = this.Chart.IsDarkBackground;
                this.Arrow.Stroke = isDarkBackground
                    ? new SolidColorBrush(Colors.White)
                    : new SolidColorBrush(Colors.Black);
                this.UpdatePloylines(Colors.Gray);
            }
        }

        private void Arrow_MouseLeave(object sender, MouseEventArgs e)
        {
            if (_preDrawingTool == null)
            {
                this.Arrow.Stroke = null;
                this.UpdatePloylines(Colors.Transparent);
            }
            else
            {
                this.Chart.CurrentDrawingTool = _preDrawingTool;
                this.Chart.SetCursorImagePos(true, e);
                _preDrawingTool = null;
            }
        }

        private void Arrow_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            this.Chart.LockPainting = true;
            this._position = e.GetPosition((UIElement)this.Arrow.Parent);
            //加上左边纵坐标位移
            _position.X += this.Chart.GetChartPanelOffset();

            this._arrowMouseDown = true;
            this._arrowMove = false;
            this.Arrow.CaptureMouse();
            this.PrepareToMove();
        }

        private void Arrow_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            this.Chart.LockPainting = false;
            bool flag = !this._arrowMove;
            if (flag)
            {
                bool flag2 = Chart.PointerType == PointerType.Erase;
                if (flag2)
                {
                    this.Delete();
                }
                else
                {
                    //右键菜单
                    //this.ShowPopupMenu(e);
                }
            }
            else
            {
                var position = e.GetPosition((UIElement)this.Arrow.Parent);
                //加上左边纵坐标位移
                position.X += this.Chart.GetChartPanelOffset();

                this.MoveArrow(position);
                this.OwnerSpec.ToolChanged(this);
                this._arrowMouseDown = false;
                this.Chart.Refresh();
            }
            this.Arrow.ReleaseMouseCapture();
            this._arrowMouseDown = false;
            this._arrowMove = false;
        }

        /// <summary>
        /// Up弹出Popup，PopupManager里用Down关闭Popup
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="MouseButtonEventArgs"/> instance containing the event data.</param>
        private void Arrow_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
        {
            ////使用上下文菜单代替Popup,以免以免父控件有右键菜单
            //this.ShowContextMenu(e);

            //修改popup父容器，即每个Chart提供RootPanel,不使用PopupRoot和TrueRootVisual
            //因为应用程序可能开多个图表窗口
            this.ShowPopupMenu(e);
            e.Handled = true;
        }

        private void Arrow_MouseMove(object sender, MouseEventArgs e)
        {
            bool flag = this.Chart != null && Chart.PointerType == PointerType.Erase;
            if (flag)
            {
                this.Chart.SetCursorImagePos(true, e);
            }
            flag = this._arrowMouseDown;
            if (flag)
            {
                Point position = e.GetPosition((UIElement)this.Arrow.Parent);
                //加上左边纵坐标位移
                position.X += this.Chart.GetChartPanelOffset();

                float num = GeometryHelper.DistanceBetweenPoints(this._position, position);
                flag = (num > 8f);
                if (flag)
                {
                    this._arrowMove = true;
                }
                flag = this._arrowMove;
                if (flag)
                {
                    this.MoveArrow(position);
                }
            }
        }

        private void BuildCanvas()
        {
            this._canvas = new Canvas();
            this._canvasRotateTransform = new RotateTransform { CenterX = (10.0) };
            this._canvas.RenderTransform = this._canvasRotateTransform;

            var polyline = new Polyline();
            polyline.Points.Add(new Point(1.0, 20.0));
            polyline.Points.Add(new Point(5.0, 22.0));
            polyline.Points.Add(new Point(10.0, 23.0));
            polyline.Points.Add(new Point(15.0, 22.0));
            polyline.Points.Add(new Point(19.0, 20.0));

            polyline.Stroke = new SolidColorBrush(Colors.White);
            polyline.StrokeThickness = 2.0;
            polyline.StrokeStartLineCap = PenLineCap.Triangle;
            polyline.StrokeEndLineCap = PenLineCap.Triangle;
            polyline.IsHitTestVisible = (false);
            this._canvas.Children.Add(polyline);
            this._ploylineList.Add(polyline);

            polyline = new Polyline();
            polyline.Points.Add(new Point(0.0, 20.0));
            polyline.Points.Add(new Point(5.0, 17.0));
            polyline.Points.Add(new Point(2.0, 25.0));
            polyline.Points.Add(new Point(0.0, 20.0));

            polyline.Fill = (new SolidColorBrush(Colors.White));
            polyline.IsHitTestVisible = (false);
            this._canvas.Children.Add(polyline);
            this._ploylineList.Add(polyline);

            polyline = new Polyline();
            polyline.Points.Add(new Point(20.0, 20.0));
            polyline.Points.Add(new Point(15.0, 17.0));
            polyline.Points.Add(new Point(18.0, 25.0));
            polyline.Points.Add(new Point(20.0, 20.0));

            polyline.Fill = new SolidColorBrush(Colors.White);
            polyline.IsHitTestVisible = (false);
            this._canvas.Children.Add(polyline);
            this._ploylineList.Add(polyline);
            this.AngleGrab = new Ellipse { Width = (20.0), Height = (10.0) };
            this.AngleGrab.SetValue(Canvas.TopProperty, 15.0);
            this.AngleGrab.Stroke = (null);
            this.AngleGrab.Fill = (new SolidColorBrush(Colors.Transparent));
            this._canvas.Children.Add(this.AngleGrab);
        }

        private void MoveArrow(Point curPos)
        {
            var frameworkElement = (FrameworkElement)this.Arrow.Parent;
            var num = (float)(frameworkElement.ActualHeight - 6.0);
            bool flag = num < 0f;
            if (flag)
            {
                num = 0f;
            }
            var num2 = (float)frameworkElement.ActualWidth;
            flag = (num2 < 0f);
            if (flag)
            {
                num2 = 0f;
            }
            flag = (curPos.X < 0.0);
            if (flag)
            {
                curPos.X = (0.0);
            }
            flag = (curPos.Y < 0.0);
            if (flag)
            {
                curPos.Y = (0.0);
            }
            flag = (curPos.X > (double)num2);
            if (flag)
            {
                curPos.X = ((double)num2);
            }
            flag = (curPos.Y > (double)num);
            if (flag)
            {
                curPos.Y = ((double)num);
            }
            this.MovePlot(this._position, curPos);
        }

        private void RemoveArrow(object sender, EventArgs e)
        {
            this.Delete();
        }

        private void ShowEditor(object sender, EventArgs e)
        {
            this.ShowEditor((MouseEventArgs)e);
        }

        private void ShowPopupMenu(MouseEventArgs e)
        {
            var popUpMenu = new PopupMenu(this.Chart.RootPanel) { FontSize = this.GetChartFontSize() };
            popUpMenu.AddItem(LanguageManager.FindResource(LanguageConst.DrawingTool_MenuItem_Edit), ImageHelper.GetImage("PropertiesHS.png"), new EventHandler(this.ShowEditor));
            popUpMenu.AddSeperator();
            popUpMenu.AddItem(LanguageManager.FindResource(LanguageConst.DrawingTool_MenuItem_Remove), ImageHelper.GetImage("DeleteHS.png"), new EventHandler(this.RemoveArrow));

            popUpMenu.Show(e, new Point(-5.0, -5.0));
        }

        /// <summary>
        /// Shows the context menu.
        /// </summary>
        /// <param name="e">The <see cref="MouseEventArgs"/> instance containing the event data.</param>
        private void ShowContextMenu(MouseEventArgs e)
        {
            var contextMenu = new ContextMenu();

            contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(LanguageManager.FindResource(LanguageConst.DrawingTool_MenuItem_Edit), ImageHelper.GetImage("PropertiesHS.png"), new EventHandler(this.ShowEditor)));
            contextMenu.Items.Add(new Separator());
            contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(LanguageManager.FindResource(LanguageConst.DrawingTool_MenuItem_Remove), ImageHelper.GetImage("DeleteHS.png"), new EventHandler(this.RemoveArrow)));
            this._canvas.ContextMenu = contextMenu;
            this._canvas.ContextMenu.IsOpen = true;
        }

        private void UpdatePloylines(Color aColor)
        {
            if (_ploylineList == null || _ploylineList.Count == 0) return;
            foreach (var current in _ploylineList)
            {
                if (current.Fill != null)
                {
                    current.Fill = new SolidColorBrush(aColor);
                }

                if (current.Stroke != null)
                {
                    current.Stroke = new SolidColorBrush(aColor);
                }
            }
        }

        #endregion Private Methods

        #endregion Methods
    }
}