MARKUS

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Shapes;

using System.Windows.Controls;

using System.Windows.Media;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Common;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

namespace MarkupToPDF.Controls.Shape

{

//강인구 추가 IShapeControl

    public class RectangleControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IMarkupCommonData, IShapeControl, IDashControl

    {

        public Path Base_RectPath { get; set; }

        private const string PART_RectPath = "PART_RectPath";

        #region Property

        public MouseMode mousemode

        {

            get

            {

                return (MouseMode)GetValue(mousemodeProperty);

            }

            set

            {

                SetValue(mousemodeProperty, value);

                OnPropertyChanged("mousemode");

            }

        }

        public SolidColorBrush StrokeColor

        {

            get

            {

                return (SolidColorBrush)GetValue(StrokeColorProperty);

            }

            set

            {

                SetValue(StrokeColorProperty, value);

                OnPropertyChanged("StrokeColor");

            }

        }

        public Double LineSize

        {

            get

            {

                return (Double)GetValue(LineSizeProperty);

            }

            set

            {

                SetValue(LineSizeProperty, value);

                OnPropertyChanged("LineSize");

            }

        }

        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 SolidColorBrush FillColor

        {

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

            set

            {

                SetValue(FillColorProperty, value);

                OnPropertyChanged("FillColor");

            }

        }

		//강인구 추가

        public DoubleCollection DashSize

        {

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

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                }

            }

        }

        public Point StartPoint

        {

            get

            {

                return (Point)GetValue(StartPointProperty);

            }

            set

            {

                SetValue(StartPointProperty, value);

                OnPropertyChanged("StartPoint");

            }

        }

        public Point SetPoint

        {

            get

            {

                return (Point)GetValue(SetPointProperty);

            }

            set

            {

                SetValue(SetPointProperty, value);

                OnPropertyChanged("SetPoint");

            }

        }

        public Point OriginPoint

        {

            get

            {

                return (Point)GetValue(OriginPointProperty);

            }

            set

            {

                SetValue(OriginPointProperty, value);

                OnPropertyChanged("OriginPoint");

            }

        }

        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 Point EndPoint

        {

            get

            {

                return (Point)GetValue(EndPointProperty);

            }

            set

            {

                SetValue(EndPointProperty, value);

                OnPropertyChanged("EndPoint");

            }

        }

        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 List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, value); }

        }

        public double CanvasX

        {

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

            set

            {

                if (this.CanvasX != value)

                {

                    SetValue(CanvasXProperty, value);

                    OnPropertyChanged("CanvasX");

                }

            }

        }

        public double CanvasY

        {

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

            set

            {

                if (this.CanvasY != value)

                {

                    SetValue(CanvasYProperty, value);

                    OnPropertyChanged("CanvasY");

                }

            }

        }

        public PaintSet Paint

        {

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

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, value);

                }

            }

        }

        public double Angle

        {

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

            set

            {

                if (this.Angle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        #endregion

        #region Dependency Property

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty mousemodeProperty =

                DependencyProperty.Register("mousemode", typeof(MouseMode), typeof(RectCloudControl), new PropertyMetadata(MouseMode.None, PointValueChanged));

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

                DependencyProperty.Register("ControlType", typeof(ControlType), typeof(RectangleControl), new FrameworkPropertyMetadata(ControlType.Rectangle));

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(

                "FillColor", typeof(SolidColorBrush), typeof(RectangleControl), new PropertyMetadata(new SolidColorBrush(Colors.White)));

        public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(

                 "CanvasX", typeof(double), typeof(RectangleControl), new PropertyMetadata((double)0, OnSetCansvasChanged));

        public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(

                "CanvasY", typeof(double), typeof(RectangleControl), new PropertyMetadata((double)0, OnSetCansvasChanged));

        public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(

               "TopRightPoint", typeof(Point), typeof(RectangleControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(

                 "LeftBottomPoint", typeof(Point), typeof(RectangleControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty SetPointProperty = DependencyProperty.Register(

        "SetPoint", typeof(Point), typeof(RectangleControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty OriginPointProperty = DependencyProperty.Register(

        "OriginPoint", typeof(Point), typeof(RectangleControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register(

            "Angle", typeof(double), typeof(RectangleControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        #endregion  Dependency Property

        #region Dependency PropertyChanged

        public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (RectangleControl)sender;

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

            {

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

                Canvas.SetLeft(instance, instance.SetPoint.X);

                Canvas.SetTop(instance, instance.SetPoint.Y);

                //Canvas.SetLeft(instance, instance.CanvasX);

                //Canvas.SetTop(instance, instance.CanvasY);

            }

        }

        public static void OnUpdateChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (RectangleControl)sender;

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

            {

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

                instance.SetRectPath();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (RectangleControl)sender;

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

            {

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

                instance.SetRectPath();

            }

        }

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (RectangleControl)sender;

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

            //{

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

            //    if (instance.IsSelected)

            //    {

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

            //    }

            //    else

            //    {

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

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (RectangleControl)sender;

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

            {

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

                instance.SetRectPath();

            }

        }

        #endregion Dependency PropertyChanged

        private void SetRectPath()

        {

            this.ApplyTemplate();

            if (Base_RectPath != null)

            {

                //강인구 추가

                Base_RectPath.StrokeDashArray.Clear();

                if (DashSize != null)

                {

                    foreach (var item in this.DashSize)

                    {

                        Base_RectPath.StrokeDashArray.Add(item);

                    }

                    Base_RectPath.StrokeDashCap = PenLineCap.Square;

                }

                PathFigure pathFigure = new PathFigure

                {

                    IsClosed = true

                };

                if (ControlType == ControlType.Rectangle)

                {

                    switch (this.Paint)

                    {

                        case PaintSet.None:

                            this.FillColor = null;

                            pathFigure.IsFilled = false;

                            break;

                        case PaintSet.Fill:

                            this.FillColor = this.StrokeColor;

                            Base_RectPath.Fill = this.FillColor;

                            pathFigure.IsFilled = true;

                            break;

                        case PaintSet.Hatch:

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

                            pathFigure.IsFilled = true;

                            break;

                        default:

                            {

                            }

                            break;

                    }

                }

                pathFigure.StartPoint = this.StartPoint;

                List<Point> points = new List<Point>() { this.LeftBottomPoint, this.EndPoint, this.TopRightPoint, this.StartPoint };

                PolyLineSegment polyline = new PolyLineSegment(points, true);

                pathFigure.Segments.Add(polyline);

                PathGeometry pathGeometry = new PathGeometry();

                pathGeometry.Figures = new PathFigureCollection();

                pathGeometry.Figures.Add(pathFigure);

                //Base_RectPath.StrokeThickness = 3;

                this.FillColor = null;

                this.PathData = pathGeometry;

                ApplyOverViewData();

                //OverViewPathData = PathData;

                //AdornerControl adornerControl = new Adorner.AdornerControl();

                ////adornerControl

                //adornerControl.Content = pathGeometry;

            }

        }

        public void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        #region Internal Method

        static RectangleControl()

        {

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

            ResourceDictionary dictionary = new ResourceDictionary();

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

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

        }

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_RectPath = GetTemplateChild(PART_RectPath) as Path;

            if (Base_RectPath == null)

                return;

            SetRectPath();

            Base_RectPath.Focus();

        }

        public void updateControl()

        {

            this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].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.TopRightPoint = new Point(this.PointSet[3].X, this.PointSet[3].Y);

        }

        private void OnPropertyChanged(string name)

        {

            if (PropertyChanged != null)

            {

                PropertyChanged(this, new PropertyChangedEventArgs(name));

            }

        }

        public void ChangePaint(PaintSet state)

        {

            this.Paint = state;

            this.SetRectPath();

        }

        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>

        /// Serialize this

        /// </summary>

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

        /// <returns></returns>

        public override string Serialize()

        {

            using (S_RectControl STemp = new S_RectControl())

            {

                STemp.TransformPoint = "0|0";

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

                STemp.PaintState = this.Paint;

                STemp.PointSet = this.PointSet;

                //STemp.StrokeColor = "#FF00FF00";

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

                if (this.FillColor != null)

                {

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

                }

                STemp.StartPoint = this.StartPoint;

                STemp.UserID = this.UserID;

                //STemp.Angle = this.a;

                STemp.EndPoint = this.EndPoint;

                STemp.LB = this.LeftBottomPoint;

                STemp.TR = this.TopRightPoint;

                STemp.DashSize = this.DashSize;

                STemp.Opac = this.Opacity;

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

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                STemp.Memo = this.Memo;

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

            };

        }

        /// <summary>

        /// create a rectanglecontrol from given string

        /// </summary>

        /// <param name="item"></param>

        /// <returns></returns>

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

        {

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

            {

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

                return new RectangleControl

                {

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

                    Paint = s.PaintState,

                    StartPoint = s.StartPoint,

                    EndPoint = s.EndPoint,

                    Angle = s.Angle,

                    StrokeColor = brush,

                    DashSize = s.DashSize,

                    Opacity = s.Opac,

                    LeftBottomPoint = s.LB,

                    TopRightPoint = s.TR,

                    PointSet = s.PointSet,

                    UserID = s.UserID,

                    Memo = s.Memo

                };

            }

        }

        public void Dispose()

        {

            GC.Collect();

            GC.SuppressFinalize(this);

        }

        #endregion Internal Method

    }

}