MARKUS

using MarkupToPDF.Common;

using MarkupToPDF.Controls.Common;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Windows;

using System.Windows.Media;

using System.Windows.Shapes;

namespace MarkupToPDF.Controls.Shape

{

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

    public class CircleControl : CommentUserInfo, IDisposable, IPath, INotifyPropertyChanged, IMarkupCommonData, IShapeControl, ICircleControl

    {

        private const string PART_CirclePath = "PART_CirclePath";

        public Path Base_CirclePath = null;

        static CircleControl()

        {

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

            //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);

        }

        #region Dependency Properties

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(CircleControl), new FrameworkPropertyMetadata(ControlType.Circle));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

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

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

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

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

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

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

        public static readonly DependencyProperty mousemodeProperty =

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

        #endregion

        #region PropertyChanged Method

         public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (CircleControl)sender;

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

            //{

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

            //    if (instance.IsSelected)

            //    {

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

            //    }

            //    else

            //    {

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

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CircleControl)sender;

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

            {

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

                instance.SetCircle();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CircleControl)sender;

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

            {

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

                instance.SetCircle();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CircleControl)sender;

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

            {

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

                instance.SetCircle();

            }

        }

        #endregion

        #region Properties

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public MouseMode mousemode

        {

            get

            {

                return (MouseMode)GetValue(mousemodeProperty);

            }

            set

            {

                SetValue(mousemodeProperty, value);

                OnPropertyChanged("mousemode");

            }

        }

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

        {

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

            set

            {

                if (this.FillColor != value)

                {

                    SetValue(FillColorProperty, 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 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); }

        }

        public Geometry OverViewPathData

        {

            get

            {

                return (Geometry)GetValue(OverViewPathDataProperty);

            }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public PaintSet Paint

        {

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

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, 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 double CenterX

        //{

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

        //    set { SetValue(CenterXProperty, value); }

        //}

        //public double CenterY

        //{

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

        //    set { SetValue(CenterYProperty, 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 List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, value); }

        }

        public bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, 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 Object & Variable

        EllipseGeometry instance = new EllipseGeometry();

        GeometryGroup CircleGroup = new GeometryGroup();

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_CirclePath = GetTemplateChild(PART_CirclePath) as Path;

            if (Base_CirclePath == null)

            {

                return;

            }

            this.SetCircle();

        }

        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 void SetCircle()

        {

            Base_CirclePath.StrokeDashArray.Clear();

            foreach (var item in this.DashSize)

            {

                Base_CirclePath.StrokeDashArray.Add(item);

            }

            Base_CirclePath.StrokeDashCap = PenLineCap.Square;

            Point middle = MathSet.getMiddlePoint(this.EndPoint, this.StartPoint);

            instance.RadiusX = (MathSet.DistanceTo(this.LeftBottomPoint, this.EndPoint) / 2);

            instance.RadiusY = (MathSet.DistanceTo(this.EndPoint, this.TopRightPoint) / 2);

            instance.Center = middle;

            switch (this.Paint)

            {

                case PaintSet.None:

                    this.FillColor = null;

                    Base_CirclePath.Fill = this.FillColor;

                    break;

                case PaintSet.Fill:

                    this.FillColor = this.StrokeColor;

                    Base_CirclePath.Fill = this.FillColor;

                    break;

                case PaintSet.Hatch:

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

                    break;

                default:

                    break;

            }

            CircleGroup.Children.Clear();

            CircleGroup.FillRule = FillRule.Nonzero;

            CircleGroup.Children.Add(instance);

            try

            {                

                //강인구 수정(원 테두리가 잘리는것 방지)

                //this.Width = Math.Abs(this.CircleGroup.Bounds.Right + 2);

                //this.Height = Math.Abs(this.CircleGroup.Bounds.Bottom + 2);

                this.Width = Math.Abs(this.CircleGroup.Bounds.Right + 20);

                this.Height = Math.Abs(this.CircleGroup.Bounds.Bottom + 20);

            }

            catch (Exception)

            {

            }            

            CenterX = Math.Abs(this.CircleGroup.Bounds.X / 2);

            CenterY = Math.Abs(this.CircleGroup.Bounds.Y / 2);

            this.PathData = CircleGroup;

            ApplyOverViewData();

        }

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

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

        }

        public void SetCenterXY()

        {

            CenterX = MathSet.getMiddlePoint(this.StartPoint, this.EndPoint).X;

            CenterY = MathSet.getMiddlePoint(this.StartPoint, this.EndPoint).Y;

        }

        public void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        public void ChangePaint(PaintSet state)

        {

            this.Paint = state;

            this.SetCircle();

        }

    }

}