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.Etc

{

    public class DateControl : CommentUserInfo, IDisposable, IPath, INotifyPropertyChanged, IViewBox, IMarkupCommonData

    {

        private const string PART_ViewBox = "PART_ViewBox";

        private const string PART_TextBox = "PART_TextBox";

        public Viewbox Base_ViewBox = null;

        public TextBlock Base_TextBox = null;

        static DateControl()

        {

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

            //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 DateControl()

        {

            this.DefaultStyleKey = typeof(DateControl);

        }

        #region Dependency Properties

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

            DependencyProperty.Register("ControlType", typeof(ControlType), typeof(DateControl), new FrameworkPropertyMetadata(ControlType.Date));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

        "OverViewPathData", typeof(Geometry), typeof(DateControl), null);

        public static readonly DependencyProperty OverViewStartPointProperty = DependencyProperty.Register(

        "OverViewStartPoint", typeof(Point), typeof(DateControl), new PropertyMetadata(null));

        public static readonly DependencyProperty OverViewEndPointProperty = DependencyProperty.Register(

                "OverViewEndPoint", typeof(Point), typeof(DateControl), new PropertyMetadata(null));

        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(

                "Text", typeof(string), typeof(DateControl), new PropertyMetadata(null));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty FontColorProperty = DependencyProperty.Register(

               "FontColor", typeof(SolidColorBrush), typeof(DateControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

               "LineSize", typeof(double), typeof(DateControl), new PropertyMetadata((double)3));

        public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(

                "TopRightPoint", typeof(Point), typeof(DateControl), new PropertyMetadata(new Point(0, 0), TRPointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(

                 "LeftBottomPoint", typeof(Point), typeof(DateControl), new PropertyMetadata(new Point(0, 0), LBPointValueChanged));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

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

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

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

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

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

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

        #endregion

        #region PropertyChanged Method

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (DateControl)sender;

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

            //{

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

            //    if (instance.IsSelected)

            //    {

            //        //instance.Base_ViewBox.Style. = new SolidColorBrush(Colors.Blue);

            //    }

            //    else

            //    {

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

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (DateControl)sender;

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

            {

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

                instance.SetDate();

            }

        }

        public static void LBPointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (DateControl)sender;

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

            {

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

                //instance.EndPoint = new Point(instance.EndPoint.X, ((Point)e.NewValue).Y);

                //instance.StartPoint = new Point(((Point)e.NewValue).X, instance.StartPoint.Y);

                ////instance.PointSet[0] = instance.StartPoint;

                ////instance.PointSet[2] = instance.EndPoint;

                instance.SetDate();

            }

        }

        public static void TRPointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (DateControl)sender;

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

            {

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

                instance.SetDate();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (DateControl)sender;

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

            {

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

                instance.SetDate();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (DateControl)sender;

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

            {

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

                instance.SetDate();

            }

        }

        #endregion

        #region Properties

        public double LineSize

        {

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

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                    OnPropertyChanged("LineSize");

                }

            }

        }

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public double Angle

        {

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

            set

            {

                if (this.Angle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

                OnPropertyChanged("IsSelected");

            }

        }

        public override ControlType ControlType

        {

            set

            {

                SetValue(ControlTypeProperty, value);

                OnPropertyChanged("ControlType");

            }

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

        }

        public Geometry OverViewPathData

        {

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

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, value); }

        }

        public Point TopRightPoint

        {

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

            set

            {

                SetValue(TopRightPointProperty, value);

                OnPropertyChanged("TopRightPoint");

            }

        }

        public Point LeftBottomPoint

        {

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

            set

            {

                SetValue(LeftBottomPointProperty, value);

                OnPropertyChanged("LeftBottomPoint");

            }

        }

        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 string Text

        {

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

            set

            {

                if (this.Text != value)

                {

                    SetValue(TextProperty, value);

                    OnPropertyChanged("Text");

                }

            }

        }

        public Geometry PathData

        {

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

            set

            {

                SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        public SolidColorBrush FontColor

        {

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

            set

            {

                if (this.FontColor != value)

                {

                    SetValue(FontColorProperty, value);

                    OnPropertyChanged("FontColor");

                }

            }

        }

        public Point EndPoint

        {

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

            set

            {

                if (this.EndPoint != value)

                {

                    SetValue(EndPointProperty, value);

                    OnPropertyChanged("EndPoint");

                }

            }

        }

        public Point StartPoint

        {

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

            set

            {

                if (this.StartPoint != value)

                {

                    SetValue(StartPointProperty, value);

                    OnPropertyChanged("StartPoint");

                }

            }

        }

        public Point OverViewStartPoint

        {

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

            set { SetValue(OverViewStartPointProperty, value); }

        }

        public Point OverViewEndPoint

        {

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

            set { SetValue(OverViewEndPointProperty, value); }

        }

        //public int MyProperty { get; set; }

        #endregion

        #region Data

        LineGeometry p1 = new LineGeometry();

        LineGeometry p2 = new LineGeometry();

        LineGeometry p3 = new LineGeometry();

        LineGeometry p4 = new LineGeometry();

        GeometryGroup instanceGroup = new GeometryGroup();

        FormattedText text;

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_ViewBox = GetTemplateChild(PART_ViewBox) as Viewbox;

            Base_TextBox = GetTemplateChild(PART_TextBox) as TextBlock;

            Base_TextBox.Visibility = System.Windows.Visibility.Hidden;

            SetDate();

        }

        private void SetDate()

        {

            if (Text == null)

            {

                Text = DateTime.Now.ToString("yyyy-MM-dd");

            }

            this.ApplyTemplate();

            instanceGroup.Children.Clear();

            Base_TextBox.Visibility = System.Windows.Visibility.Visible;

            Point mid = MathSet.FindCentroid(new List<Point>()

            {

                this.StartPoint,

                this.LeftBottomPoint,

                this.EndPoint,

                this.TopRightPoint,                

            });

            double AngleData = this.Angle * -1;

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = MathSet.RotateAbout(mid, this.StartPoint, AngleData);

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = MathSet.RotateAbout(mid, this.StartPoint, AngleData);

            pathFigure.Segments.Add(lineSegment0);

            LineSegment lineSegment1 = new LineSegment();

            lineSegment1.Point = MathSet.RotateAbout(mid, this.LeftBottomPoint, AngleData);

            pathFigure.Segments.Add(lineSegment1);

            LineSegment lineSegment2 = new LineSegment();

            lineSegment2.Point = MathSet.RotateAbout(mid, this.EndPoint, AngleData);

            pathFigure.Segments.Add(lineSegment2);

            LineSegment lineSegment3 = new LineSegment();

            lineSegment3.Point = MathSet.RotateAbout(mid, this.TopRightPoint, AngleData);

            pathFigure.Segments.Add(lineSegment3);

            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.Figures = new PathFigureCollection();

            pathFigure.IsClosed = true;

            pathGeometry.Figures.Add(pathFigure);

            this.Base_ViewBox.Width = pathGeometry.Bounds.Width;

            this.Base_ViewBox.Height = pathGeometry.Bounds.Height;

            this.Tag = pathGeometry;

            Canvas.SetLeft(this, MathSet.RotateAbout(mid, mid, AngleData).X - this.Base_ViewBox.Width / 2);

            Canvas.SetTop(this, MathSet.RotateAbout(mid, mid, AngleData).Y - this.Base_ViewBox.Height / 2);

            //CenterX = MathSet.RotateAbout(mid, mid, AngleData).X - this.Base_ViewBox.Width / 2;

            //CenterY = MathSet.RotateAbout(mid, mid, AngleData).Y - this.Base_ViewBox.Height / 2;

            instanceGroup.Children.Add(pathGeometry);

            text = new FormattedText(Text, System.Globalization.CultureInfo.CurrentCulture,

                 FlowDirection.LeftToRight, new Typeface("Tahoma"), 16, Brushes.Black);

            instanceGroup.Children.Add(text.BuildGeometry(new Point(10,10)));

            PathData = instanceGroup;

            //OverViewPathData = PathData;

        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public void Dispose()

        {

            GC.Collect();

            GC.SuppressFinalize(this);

        }

        public override void ApplyOverViewData()

        {

            //this.OverViewPathData = this.PathData;

            this.OverViewStartPoint = this.StartPoint;

            this.OverViewEndPoint = this.EndPoint;

        }

        public override void UpdateControl()

        {

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

            this.TopRightPoint = new Point(this.PointSet[3].X, this.PointSet[3].Y);

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

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

            this.SetDate();

        }

        /// <summary>

        /// call when mouse is moving while drawing control

        /// </summary>

        /// <author>humkyung</author>

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

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

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

        {

            this.EndPoint = pt;

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

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

            this.PointSet = new List<Point>

            {

                this.StartPoint,

                this.LeftBottomPoint,

                this.EndPoint,

                this.TopRightPoint,

            };

        }

        /// <summary>

        /// move control point has same location of given pt along given delta

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.20</date>

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

        /// <param name="dx"></param>

        /// <param name="dy"></param>

        public override void OnMoveCtrlPoint(Point pt, double dx, double dy)

        {

            IPath path = (this as IPath);

            Point selected = MathSet.getNearPoint(path.PointSet, pt);

            selected.X += dx;

            selected.Y += dy;

            int i = 0;

            for (i = 0; i < (this as IPath).PointSet.Count; i++)

            {

                if (pt.Equals((this as IPath).PointSet[i]))

                {

                    path.PointSet[i] = selected;

                    break;

                }

            }

            var ReverseP = (i + path.PointSet.Count / 2) % path.PointSet.Count;

            var PreviousP = (i + (path.PointSet.Count - 1)) % path.PointSet.Count;

            var NextP = (i + 1) % path.PointSet.Count;

            var distance = MathSet.DistanceTo(path.PointSet[ReverseP], path.PointSet[i]);

            var PreviousV = MathSet.GetNormVectorBetween(path.PointSet[ReverseP], path.PointSet[PreviousP]);

            var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[i].X - path.PointSet[ReverseP].X,

                path.PointSet[i].Y - path.PointSet[ReverseP].Y);

            path.PointSet[PreviousP] = new Point(path.PointSet[ReverseP].X + PreviousV.X * l, path.PointSet[ReverseP].Y + PreviousV.Y * l);

            var NextV = MathSet.GetNormVectorBetween(path.PointSet[ReverseP], path.PointSet[NextP]);

            l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[i].X - path.PointSet[ReverseP].X, path.PointSet

                [i].Y - path.PointSet[ReverseP].Y);

            path.PointSet[NextP] = new Point(path.PointSet[ReverseP].X + NextV.X * l, path.PointSet[ReverseP].Y + NextV.Y * l);

            this.UpdateControl();

        }

        /// <summary>

        /// return DateControl's 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_DateControl STemp = new S_DateControl())

            {

                STemp.Angle = this.Angle;

                STemp.EndPoint = this.EndPoint;

                STemp.UserID = this.UserID;

                STemp.LB = this.LeftBottomPoint;

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

                STemp.PointSet = this.PointSet;

                STemp.StartPoint = this.StartPoint;

                STemp.Opac = this.Opacity;

                STemp.TR = this.TopRightPoint;

                STemp.TransformPoint = "0|0";

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

                //STemp.FontColor = "#FFFFFF00";

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

                STemp.Text = this.Text;

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                STemp.Memo = this.Memo;

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

            }

        }

        /// <summary>

        /// create a datecontrol from given string

        /// </summary>

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

        /// <returns></returns>

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

        {

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

            {

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

                return new DateControl

                {

                    Angle = s.Angle,

                    StartPoint = s.StartPoint,

                    EndPoint = s.EndPoint,

                    LeftBottomPoint = s.LB,

                    TopRightPoint = s.TR,

                    Opacity = s.Opac,

                    FontColor = brush,

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

                    Text = s.Text,

                    PointSet = s.PointSet,

                    UserID = s.UserID,

                    Memo = s.Memo

                };

            }

        }

    }

}