MARKUS

using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.ComponentModel;

using System.Collections.Generic;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Common;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

using System.Linq;

namespace MarkupToPDF.Controls.Shape

{

    //[TemplatePart(Name = "PART_TriPath", Type = typeof(Path))]

    public class TriControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IPath, IMarkupCommonData, IShapeControl, IDashControl

    {

        public Path Base_TriPath { get; set; }

        //public enum PaintSet { None, Fill, Hatch };

        private const string PART_TriPath = "PART_TriPath";

        //public Path Base_TriPath = null;

        static TriControl()

        {

            DefaultStyleKeyProperty.OverrideMetadata(typeof(TriControl), new FrameworkPropertyMetadata(typeof(TriControl)));

            ResourceDictionary dictionary = new ResourceDictionary();

            dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);

            Application.Current.Resources.MergedDictionaries.Add(dictionary);

        }

        #region Dependency Properties

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

        "OverViewPathData", typeof(Geometry), typeof(TriControl), new PropertyMetadata(null));

        public static readonly DependencyProperty IsSelectedProperty =

      DependencyProperty.Register("IsSelected", typeof(bool), typeof(TriControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));

        public static readonly DependencyProperty ControlTypeProperty =

    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(TriControl), new FrameworkPropertyMetadata(ControlType.Triangle));

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

         "LineSize", typeof(double), typeof(TriControl), new PropertyMetadata((Double)3));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

                "UserID", typeof(string), typeof(TriControl), new PropertyMetadata(null));

        //강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

              "DashSize", typeof(DoubleCollection), typeof(TriControl), new PropertyMetadata(new DoubleCollection { 1, 1 }, PointValueChanged));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

        "PathData", typeof(Geometry), typeof(TriControl), null);

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

         "StrokeColor", typeof(SolidColorBrush), typeof(TriControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(

         "FillColor", typeof(SolidColorBrush), typeof(TriControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

            "EndPoint", typeof(Point), typeof(TriControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty MidPointProperty = DependencyProperty.Register(

            "MidPoint", typeof(Point), typeof(TriControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

            "StartPoint", typeof(Point), typeof(TriControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        //강인구 추가

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

                "Paint", typeof(PaintSet), typeof(TriControl), new PropertyMetadata(PaintSet.None, PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

            "PointSet", typeof(List<Point>), typeof(TriControl), new PropertyMetadata(new List<Point>(), PointValueChanged));

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register("Angle", typeof(double), typeof(TriControl), new

            PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register("CenterX", typeof(double), typeof(TriControl),

            new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register("CenterY", typeof(double), typeof(TriControl),

            new PropertyMetadata((double)0, OnCenterXYChanged));

        #endregion

        #region PropertyChanged Method

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (TriControl)sender;

            //if (e.OldValue != e.NewValue && instance.Base_TriPath != null)

            //{

            //    instance.SetValue(e.Property, e.NewValue);

            //    if (instance.IsSelected)

            //    {

            //        instance.Base_TriPath.Stroke = new SolidColorBrush(Colors.Blue);

            //    }

            //    else

            //    {

            //        instance.Base_TriPath.Stroke = new SolidColorBrush(Colors.Red);

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TriControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_TriPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetTri();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TriControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_TriPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetTri();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TriControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_TriPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetTri();

            }

        }

        #endregion

        #region Properties

        public Double LineSize

        {

            get { return (Double)GetValue(LineSizeProperty); }

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public string UserID

        {

            get { return (string)GetValue(UserIDProperty); }

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public SolidColorBrush FillColor

        {

            get { return (SolidColorBrush)GetValue(FillColorProperty); }

            set

            {

                if (this.FillColor != value)

                {

                    SetValue(FillColorProperty, value);

                }

            }

        }

        public DoubleCollection DashSize

        {

            get { return (DoubleCollection)GetValue(DashSizeProperty); }

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                }

            }

        }

        public PaintSet Paint

        {

            get { return (PaintSet)GetValue(PaintProperty); }

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, value);

                }

            }

        }

        public override SolidColorBrush StrokeColor

        {

            get { return (SolidColorBrush)GetValue(StrokeColorProperty); }

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                }

            }

        }

        public Geometry OverViewPathData

        {

            get

            {

                return (Geometry)GetValue(OverViewPathDataProperty);

            }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public Geometry PathData

        {

            get { return (Geometry)GetValue(PathDataProperty); }

            set { SetValue(PathDataProperty, value); }

        }

        public Point EndPoint

        {

            get { return (Point)GetValue(EndPointProperty); }

            set { SetValue(EndPointProperty, value); }

        }

        public Point StartPoint

        {

            get { return (Point)GetValue(StartPointProperty); }

            set { SetValue(StartPointProperty, value); }

        }

        public Point MidPoint

        {

            get { return (Point)GetValue(MidPointProperty); }

            set { SetValue(MidPointProperty, value); }

        }

        public List<Point> PointSet

        {

            get { return (List<Point>)GetValue(PointSetProperty); }

            set { SetValue(PointSetProperty, value); }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public override ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, value);

            }

        }

        public double Angle

        {

            get { return (double)GetValue(AngleProperty); }

            set

            {

                if (this.Angle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public double CenterX

        {

            get { return (double)GetValue(CenterXProperty); }

            set { SetValue(CenterXProperty, value); }

        }

        public double CenterY

        {

            get { return (double)GetValue(CenterYProperty); }

            set { SetValue(CenterYProperty, value); }

        }

        #endregion

        #region Dependency PropertyChanged

        //public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        //{

        //    var instance = (TriControl)sender;

        //    if (e.OldValue != e.NewValue && instance.Base_TriPath != null)

        //    {

        //        instance.SetValue(e.Property, e.NewValue);

        //        if (instance.IsSelected)

        //        {

        //            instance.Base_TriPath.Stroke = new SolidColorBrush(Colors.Blue);

        //        }

        //        else

        //        {

        //            instance.Base_TriPath.Stroke = new SolidColorBrush(Colors.Red);

        //        }

        //    }

        //}

        #endregion Dependency PropertyChanged

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_TriPath = GetTemplateChild(PART_TriPath) as Path;

            if (Base_TriPath == null)

            {

                return;

            }

            this.SetTri();

        }

        private void SetTri()

        {

            this.ApplyTemplate();

            Base_TriPath.StrokeDashArray.Clear();

            foreach (var item in this.DashSize)

            {

                Base_TriPath.StrokeDashArray.Add(item);

            }

            Base_TriPath.StrokeDashCap = PenLineCap.Square;

            PathFigure pathFigure = new PathFigure();

            //this.FillColor = this.StrokeColor;

            ////Base_TriPath.Fill = this.FillColor;

            //Base_TriPath.Fill = Brushes.Red;

            //pathFigure.IsFilled = true;

            switch (this.Paint)

            {

                case PaintSet.None:

                    this.FillColor = null;

                    pathFigure.IsFilled = false;

                    break;

                case PaintSet.Fill:

                    this.FillColor = this.StrokeColor;

                    Base_TriPath.Fill = this.FillColor;

                    pathFigure.IsFilled = true;

                    break;

                case PaintSet.Hatch:

                    Base_TriPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor);

                    pathFigure.IsFilled = true;

                    break;

                default:

                    break;

            }

            pathFigure.StartPoint = this.StartPoint;

            List<Point> points = new List<Point>() { this.StartPoint };

            if (MidPoint.X != 0 && MidPoint.Y != 0) points.Add(this.MidPoint);

            points.Add(this.EndPoint);

            PolyLineSegment polyline = new PolyLineSegment(points , true);

            pathFigure.Segments.Add(polyline);

            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.Figures = new PathFigureCollection();

            pathFigure.IsClosed = true;

            pathGeometry.Figures.Add(pathFigure);

            this.PathData = pathGeometry;

            ApplyOverViewData();

        }

        public void Dispose()

        {

            GC.Collect();

            GC.SuppressFinalize(this);

        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public override void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        public void updateControl()

        {

            this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);

            this.MidPoint = new Point(this.PointSet[1].X, this.PointSet[1].Y);

            this.EndPoint = new Point(this.PointSet[2].X, this.PointSet[2].Y);

        }

        /// <summary>

        /// call when mouse is moving while drawing control

        /// </summary>

        /// <param name="pt"></param>

        /// <param name="bAxisLocked"></param>

        public override void OnCreatingMouseMove(Point pt, bool bAxisLocked, bool bShiftKeyPressed)

        {

            this.EndPoint = pt;

            if (bAxisLocked)

            {

                Point tmp = this.EndPoint;

                string angle = MathSet.returnAngleString(this.StartPoint, ref tmp, true);

                this.EndPoint = tmp;

            }

            if (bShiftKeyPressed)

            {

                List<Point> Points = this.GetRegularTrianglePoints(this.StartPoint, this.EndPoint);

                if (2 == Points.Count())

                {

                    this.MidPoint = Points[0];

                    this.EndPoint = Points[1];

                }

            }

            this.PointSet = new List<Point>

            {

                this.StartPoint,

                this.MidPoint,

                this.EndPoint,

            };

        }

        /// <summary>

        /// return tricontrols' area

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.13</date>

        public override Rect ItemRect

        {

            get

            {

                double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);

                dMinX = Math.Min(this.MidPoint.X, dMinX);

                double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);

                dMinY = Math.Min(this.MidPoint.Y, dMinY);

                double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);

                dMaxX = Math.Max(this.MidPoint.X, dMaxX);

                double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);

                dMaxY = Math.Max(this.MidPoint.Y, dMaxY);

                return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));

            }

        }

        /// <summary>

        /// Serialize this

        /// </summary>

        /// <param name="sUserId"></param>

        /// <returns></returns>

        public override string Serialize()

        {

            using (S_TriControl STemp = new S_TriControl())

            {

                STemp.TransformPoint = "0|0";

                STemp.Paint = this.Paint;

                STemp.SizeSet = String.Format("{0}", this.LineSize);

                //STemp.StrokeColor = "#FF00FF00";

                STemp.StrokeColor = this.StrokeColor.Color.ToString();

                if (this.FillColor != null)

                {

                    STemp.FillColor = this.FillColor.Color.ToString();

                }

                STemp.StartPoint = this.StartPoint;

                STemp.EndPoint = this.EndPoint;

                STemp.MidPoint = this.MidPoint;

                STemp.Opac = this.Opacity;

                STemp.UserID = this.UserID;

                STemp.PointSet = this.PointSet;

                STemp.Angle = this.Angle;

                STemp.DashSize = this.DashSize;

                STemp.Name = this.GetType().Name.ToString();

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                STemp.Memo = this.Memo;

                return "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));

            }

        }

        /// <summary>

        /// create a tricontrol from given string

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static TriControl FromString(string str, SolidColorBrush brush, string sProjectNo)

        {

            using (S_TriControl s = JsonSerializerHelper.JsonDeserialize<S_TriControl>(str))

            {

                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                return new TriControl

                {

                    LineSize = Convert.ToDouble(data2.First()),

                    MidPoint = s.MidPoint,

                    StartPoint = s.StartPoint,

                    Paint = s.Paint,

                    EndPoint = s.EndPoint,

                    Opacity = s.Opac,

                    Angle = s.Angle,

                    DashSize = s.DashSize,

                    PointSet = s.PointSet,

                    StrokeColor = brush,

                    UserID = s.UserID,

                    Memo = s.Memo

                };

            }

        }

        /// <summary>

        /// 정삼각형을 그리기위한 두 포인트를 계산하여 넘겨줌

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2018.04.26</date>

        /// <param name="StartP"></param>

        /// <param name="EndP"></param>

        /// <returns></returns>

        /// <history>humkyung 2018.05.11 apply axis lock</history>

        private List<Point> GetRegularTrianglePoints(Point StartP, Point EndP, bool bCheckAxis = false)

        {

            List<Point> res = new List<Point>();

            double dx = EndP.X - StartP.X;

            double dy = EndP.Y - StartP.Y;

            double length = Math.Sqrt(dx * dx + dy * dy);

            double baseLength = length * Math.Tan(30.0 * Math.PI / 180.0);

            dx /= length;

            dy /= length;

            double tmp = dx;

            dx = -dy; dy = tmp; /// rotate by 90 degree

            res.Add(new Point(EndP.X + dx * baseLength, EndP.Y + dy * baseLength));

            res.Add(new Point(EndP.X - dx * baseLength, EndP.Y - dy * baseLength));

            return res;

        }

    }

}