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.S_Control;

using MarkupToPDF.Serialize.Core;

using System.Linq;

namespace MarkupToPDF.Controls.Line

{

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

    public class LineControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IMarkupCommonData, IDashControl

    {

        public event PropertyChangedEventHandler PropertyChanged;

        private const string PART_LinePath = "PART_LinePath";

        public Path Base_LinePath = null;

        static LineControl()

        {

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

            //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);

            ResourceDictionary dictionary = new ResourceDictionary();

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

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

             //System.Diagnostics.Debug.WriteLine("resource Count :" + Application.Current.Resources.MergedDictionaries.Count);

                     }

        public double DimSize

        {

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

            set

            {

                if (this.DimSize != value)

                {

                    SetValue(DimSizeProperty, value);

                    OnPropertyChanged("DimSize");

                }

            }

        }

        public LineControl()

        {

            this.DefaultStyleKey = typeof(LineControl);

        }

        public void Dispose()

        {

            GC.Collect();

            GC.SuppressFinalize(this);

        }

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        #region Dependency Properties

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(LineControl), new FrameworkPropertyMetadata(ControlType.SingleLine));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty IntervalProperty = DependencyProperty.Register(

                "Interval", typeof(double), typeof(LineControl), new PropertyMetadata((Double)10, PointValueChanged));

//강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

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

        //public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

        //        "DashSize", typeof(DoubleCollection), typeof(LineControl), new PropertyMetadata(new DoubleCollection { 1, 1 }));

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineStyleProperty = DependencyProperty.Register(

               "LineStyleSet", typeof(LineStyleSet), typeof(LineControl), new PropertyMetadata(LineStyleSet.SingleLine));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

               "EndPoint", typeof(Point), typeof(LineControl), new PropertyMetadata(new Point(100, 100), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty MiddlePointProperty = DependencyProperty.Register(

                "MiddlePoint", typeof(Point), typeof(LineControl), new PropertyMetadata(new Point(0, 0)));

        public static readonly DependencyProperty DimSizeProperty = DependencyProperty.Register(

                "DimSize", typeof(double), typeof(LineControl), new PropertyMetadata((double)5));

        public static readonly DependencyProperty AngleProperty =

            DependencyProperty.Register("AngleValue", typeof(double), typeof(LineControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty =

            DependencyProperty.Register("CenterX", typeof(double), typeof(LineControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty =

            DependencyProperty.Register("CenterY", typeof(double), typeof(LineControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        #endregion

        #region PropertyChanged Method

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (LineControl)sender;

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

            //{

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

            //    if (instance.IsSelected)

            //    {

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

            //    }

            //    else

            //    {

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

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (LineControl)sender;

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

            {

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

                instance.SetLinePath();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (LineControl)sender;

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

            {

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

                instance.SetLinePath();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (LineControl)sender;

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

            {

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

                instance.SetLinePath();

            }

        }

        #endregion

        #region Properties

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public Double Interval

        {

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

            set

            {

                if (this.Interval != value)

                {

                    SetValue(IntervalProperty, value);

                    OnPropertyChanged("Interval");

                }

            }

        }

        public Double LineSize

        {

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

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public DoubleCollection DashSize

        {

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

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                }

            }

        }

        public List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, 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); }

        }

        public override SolidColorBrush StrokeColor

        {

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

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                }

            }

        }

        public Geometry PathData

        {

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

            set

            {

                SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        public Geometry OverViewPathData

        {

            get

            {

                return (Geometry)GetValue(OverViewPathDataProperty);

            }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public LineStyleSet LineStyleSet

        {

            get

            {

                return (LineStyleSet)GetValue(LineStyleProperty);

            }

            set

            {

                SetValue(LineStyleProperty, value);

            }

        }

        public override ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, value);

            }

        }

        public double AngleValue

        {

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

            set { SetValue(AngleProperty, value); }

        }

        public double Angle

        {

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

            set

            {

                if (this.Angle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public Point EndPoint

        {

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

            set

            {

                SetValue(EndPointProperty, value);

                OnPropertyChanged("EndPoint");

            }

        }

        public Point StartPoint

        {

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

            set

            {

                SetValue(StartPointProperty, value);

                OnPropertyChanged("StartPoint");

            }

        }

        GeometryGroup instanceGroup = new GeometryGroup();

        LineGeometry connectorGeometry = new LineGeometry();

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_LinePath = GetTemplateChild("PART_LinePath") as Path;

            SetLinePath();

        }

        public void updateControl()

        {

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

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

        }

        public static List<LineGeometry> DimAllow(Point p1, Point p2, Double lineSize, double DimSize)

        {

            //lineSize = 2;

            List<LineGeometry> GeometrySet = new List<LineGeometry>();

            double theta = Math.Atan2((p2.Y - p1.Y), (p2.X - p1.X)) * 180 / Math.PI;

            LineGeometry ld = new LineGeometry();

            //ld.StartPoint = new Point(p2.X + lineSize, p2.Y - lineSize * 4 - DimSize);

            //ld.EndPoint = new Point(p2.X + lineSize, p2.Y + lineSize * 4 + DimSize);

            ld.StartPoint = new Point(p2.X + lineSize, p2.Y - lineSize * 4);

            ld.EndPoint = new Point(p2.X + lineSize, p2.Y + lineSize * 4 + DimSize);

            RotateTransform transform3 = new RotateTransform();

            transform3.Angle = theta;

            transform3.CenterX = p2.X;

            transform3.CenterY = p2.Y;

            ld.Transform = transform3;

            GeometrySet.Add(ld);

            LineGeometry ld1 = new LineGeometry();

            //ld1.StartPoint = new Point(p1.X - lineSize, p1.Y - lineSize * 4 - DimSize);

            //ld1.EndPoint = new Point(p1.X - lineSize, p1.Y + lineSize * 4 + DimSize);

            ld1.StartPoint = new Point(p1.X - lineSize, p1.Y - lineSize * 4);

            ld1.EndPoint = new Point(p1.X - lineSize, p1.Y + lineSize * 4 + DimSize);

            RotateTransform transform4 = new RotateTransform();

            transform4.Angle = theta;

            transform4.CenterX = p1.X;

            transform4.CenterY = p1.Y;

            ld1.Transform = transform4;

            GeometrySet.Add(ld1);

            return GeometrySet;

        }

        public void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        private void SetLinePath()

        {

            this.ApplyTemplate();           

            if (this.DashSize != null)

            {

                Base_LinePath.StrokeDashArray.Clear();

                foreach (var item in this.DashSize)

                {

                    Base_LinePath.StrokeDashArray.Add(item);

                }

                Base_LinePath.StrokeDashCap = PenLineCap.Square;

            }

            PathFigure pathFigure = new PathFigure(); 

            pathFigure.StartPoint = this.StartPoint;

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = this.EndPoint;

            pathFigure.Segments.Add(lineSegment0);

            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.Figures = new PathFigureCollection();

            pathGeometry.Figures.Add(pathFigure);

            instanceGroup.Children.Clear();

            switch (LineStyleSet)

            {

                case LineStyleSet.ArrowLine:

                    instanceGroup.Children.Add(DrawSet.DrawArrow(this.StartPoint, this.EndPoint, this.LineSize));

                    break;

                case LineStyleSet.TwinLine:

                    instanceGroup.Children.Add(DrawSet.DrawArrow(this.StartPoint, this.EndPoint, this.LineSize));

                    instanceGroup.Children.Add(DrawSet.DrawArrow(this.EndPoint, this.StartPoint, this.LineSize));

                    break;

                case LineStyleSet.DimLine:

                    List<LineGeometry> metrySet = DimAllow(this.StartPoint, this.EndPoint, this.LineSize, this.DimSize);

                    instanceGroup.Children.Add(metrySet[0]);

                    instanceGroup.Children.Add(metrySet[1]);

                    instanceGroup.Children.Add(DrawSet.DrawArrow(this.StartPoint, this.EndPoint, this.LineSize));

                    instanceGroup.Children.Add(DrawSet.DrawArrow(this.EndPoint, this.StartPoint, this.LineSize));

                    break;

                case LineStyleSet.CancelLine:

                    PathFigure pathFigure_Multi = new PathFigure();

                    LineSegment lineSegment1 = new LineSegment();

                    var x = Math.Abs((Math.Abs(this.StartPoint.X) - Math.Abs(this.EndPoint.X)));

                    var y = Math.Abs((Math.Abs(this.StartPoint.Y) - Math.Abs(this.EndPoint.Y)));

                    if (x > y)

                    {

                        pathFigure_Multi.StartPoint = new Point(this.StartPoint.X, this.StartPoint.Y + (this.Interval));

                        lineSegment1.Point = new Point(this.EndPoint.X, this.EndPoint.Y + (this.Interval));

                    }

                    else

                    {

                        pathFigure_Multi.StartPoint = new Point(this.StartPoint.X + (this.Interval), this.StartPoint.Y);

                        lineSegment1.Point = new Point(this.EndPoint.X + (this.Interval), this.EndPoint.Y);

                    }

                    pathFigure_Multi.Segments.Add(lineSegment1);

                    pathGeometry.Figures.Add(pathFigure_Multi);

                    this.PathData = pathGeometry;

                    this.OverViewPathData = PathData;

                    break;

                default:

                    break;

            }

            if (PathData != pathGeometry)

            {

                connectorGeometry.StartPoint = new Point(this.StartPoint.X, this.StartPoint.Y);

                connectorGeometry.EndPoint = new Point(this.EndPoint.X, this.EndPoint.Y);

                instanceGroup.Children.Add(connectorGeometry);

                this.PathData = instanceGroup;

                this.OverViewPathData = PathData;

            }

        }

        /// <summary>

        /// return linecontrols' 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);

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

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

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

                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_LineControl STemp = new S_LineControl())

            {

                STemp.TransformPoint = "0|0";

                STemp.PointSet = this.PointSet;

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

                STemp.LineStyleSet = this.LineStyleSet;

                //STemp.StrokeColor = "#FF00FF00";

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

                STemp.StartPoint = this.StartPoint;

                STemp.EndPoint = this.EndPoint;

                STemp.UserID = this.UserID;

                STemp.Opac = this.Opacity;

                STemp.DashSize = this.DashSize;

                STemp.Interval = this.Interval;

                STemp.DimSize = this.DimSize;

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

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                STemp.Memo = this.Memo;

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

            }

        }

        /// <summary>

        /// create a linecontrol from given string

        /// </summary>

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

        /// <returns></returns>

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

        {

            LineControl instance = null;

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

            {

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

                instance = new LineControl()

                {

                    LineStyleSet = s.LineStyleSet,

                    StartPoint = s.StartPoint,

                    DimSize = s.DimSize,

                    EndPoint = s.EndPoint,

                    DashSize = s.DashSize,

                    Interval = s.Interval,

                    PointSet = s.PointSet,

                    Opacity = s.Opac,

                    StrokeColor = brush,

                    UserID = s.UserID,

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

                };

            }

            return instance;

        }

    }

}