MARKUS

using MarkupToPDF.Common;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

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

using System.Windows.Media;

using System.Windows.Shapes;

using Markus.Fonts;

using System.Windows.Markup;

namespace MarkupToPDF.Controls.Text

{    

    public class TextControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, ITextControl, IMarkupControlData

    {

        public event PropertyChangedEventHandler PropertyChanged;

        private const string PART_Grid = "PART_Grid";

        private const string PART_Border = "PART_Border";

        private const string PART_TextBox = "PART_TextBox";

        private const string PART_TextPath = "PART_TextPath";

        private const string PART_TextBlock = "PART_TextBlock";

        private const string PART_Canvas = "PART_TextControlCanvas";

        private const string PART_BaseTextbox_Caret = "Caret";

        //private const string PART_TextPrefix = "PART_TextPrefix";

        public Path Base_TextPath = null;

        public Grid Base_Grid = null;

        public Border Base_Border = null;

        public Canvas Base_Canvas = null;

        //public TextBlock Base_TextPrefixBlock = null;

        public TextBlock Base_TextBlock = null;

        public TextBox Base_TextBox = null;

        public Border BaseTextbox_Caret = null;

        public RotateTransform _rotation = null;

        public TranslateTransform _translation = null;

        public ScaleTransform _scale = null;

        private const double _CloudArcDepth = 0.8;  /// 2018.05.14 added by humkyung

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

                OnPropertyChanged("IsSelected");

            }

        }

        #region Internal Method

        public TextControl()

        {

            //this.DefaultStyleKey = typeof(TextControl);

        }

        static TextControl()

        {

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

            //ResourceDictionary dictionary = new ResourceDictionary();

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

            //if (!Application.Current.Resources.MergedDictionaries.Any(x => x.Source == dictionary.Source))

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

        }

        public override void Copy(CommentUserInfo lhs)

        {

            if(lhs is TextControl item)

            {

                Text = item.Text;

                StartPoint = new Point(item.StartPoint.X, item.StartPoint.Y);

                EndPoint = new Point(item.EndPoint.X, item.EndPoint.Y);

                CanvasX = item.CanvasX;

                CanvasY = item.CanvasY;

                BoxWidth = item.BoxWidth;

                BoxHeight = item.BoxHeight;

                ControlType_No = item.ControlType_No;

                LineSize = item.LineSize;

                TextSize = item.TextSize;

                StrokeColor = item.StrokeColor;

                ArcLength = item.ArcLength;

                FontSize = item.FontSize;

                UserID = item.UserID;

                IsHighLight = item.IsHighLight;

                CommentAngle = item.CommentAngle;

                PointSet = item.PointSet.ConvertAll(x => new Point(x.X, x.Y));

                Opacity = item.Opacity;

                TextFamily = item.FontFamily;

                TextStyle = item.TextStyle;

                TextWeight = item.TextWeight;

                UnderLine = item.UnderLine;

            }

        }

        public override CommentUserInfo Clone()

        {

            var clone = new TextControl();

            clone.Copy(this);

            return clone;

        }

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_TextPath = GetTemplateChild(PART_TextPath) as Path;

            Base_TextBox = GetTemplateChild(PART_TextBox) as TextBox;

            Base_TextBlock = GetTemplateChild(PART_TextBlock) as TextBlock;

            Base_Grid = GetTemplateChild(PART_Grid) as Grid;

            Base_Border = GetTemplateChild(PART_Border) as Border;

            Base_Canvas = GetTemplateChild(PART_Canvas) as Canvas;

            BaseTextbox_Caret = GetTemplateChild(PART_BaseTextbox_Caret) as Border;

            //BaseTextbox_Caret.Height = this.Base_TextBox.FontSize;

            this.Base_TextBox.Text = this.Text;

            this.Base_TextBox.CaretIndex = this.Base_TextBox.Text.Length;

            this.Base_TextBox.CaretBrush = new SolidColorBrush(Colors.Transparent);

            this.Base_TextBox.ApplyTemplate();

            MoveCustomCaret();

            if(this.Base_TextBox.FontSize > this.BaseTextbox_Caret.Height)

            {

                BaseTextbox_Caret.Height = this.Base_TextBox.FontSize;

            }

            //BaseTextbox_Caret.Height = Base_TextBox.ActualHeight - 5;

            this.Base_TextBox.SizeChanged += new SizeChangedEventHandler(Base_TextBox_SizeChanged);

            this.Base_TextBox.TextChanged += new TextChangedEventHandler(Base_TextBox_TextChanged);

            this.Base_TextBlock.SizeChanged += new SizeChangedEventHandler(Base_TextBlock_SizeChanged);

            this.Base_TextBox.GotFocus += new RoutedEventHandler(Base_TextBox_GotFocus);

            this.Base_TextBox.LostFocus += new RoutedEventHandler(Base_TextBox_LostFocus);            

            this.Base_TextBox.SelectionChanged += (sender, e) => MoveCustomCaret();

            if (Base_TextPath != null)

            {

                Base_TextPath.StrokeThickness = LineSize.Left;

            }

            //if (string.IsNullOrEmpty(this.Base_TextBox.Text))

            //{

            //    Base_TextPath.StrokeThickness = 20;

            //    LineSize = new Thickness(20, 20, 20, 20);

            //    //if (Base_TextPath != null)

            //    //{

            //    //    Base_TextPath.StrokeThickness = LineSize.Left;

            //    //}

            //}

            //else

            //{

            //    Base_TextPath.StrokeThickness = LineSize.Left;

            //}

            SetText();

            DrawingCloud();

        }

        public void SetFontFamily(FontFamily fontFamily)

        {

            if (this.Base_TextBlock != null) {

                this.Base_TextBlock.FontFamily = fontFamily;

            }

            if (this.Base_TextBox != null) {

                this.Base_TextBox.FontFamily = fontFamily;

            }

            this.FontFamily = fontFamily;

            this.TextFamily = fontFamily;

        }

        /// <summary>

        /// Moves the custom caret on the canvas.

        /// </summary>

        public void MoveCustomCaret()

        {

            var caretLocation = this.Base_TextBox.GetRectFromCharacterIndex(this.Base_TextBox.CaretIndex).Location;

            if (!double.IsInfinity(caretLocation.X)) {

                Canvas.SetLeft(this.BaseTextbox_Caret, caretLocation.X);

            }

            if (!double.IsInfinity(caretLocation.Y)) {

                Canvas.SetTop(this.BaseTextbox_Caret, caretLocation.Y);

                //Canvas.SetTop(this.BaseTextbox_Caret, (LineSize.Top - caretLocation.Y));

            }

        }

        public override void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

            if (Text == "")

                this.Text = this.OverViewText;

            else

                this.OverViewText = this.Text;

            this.OverViewPaint = this.Paint;

        }        

        void Base_TextBox_SizeChanged(object sender, SizeChangedEventArgs e)

        {

            BoxWidth = e.NewSize.Width;

            BoxHeight = e.NewSize.Height;

            DrawingCloud();

        }

        private void Base_TextBlock_SizeChanged(object sender, SizeChangedEventArgs e)

        {

            BoxWidth = e.NewSize.Width;

            BoxHeight = e.NewSize.Height;

            DrawingCloud();

        }

        private void Base_TextBox_TextChanged(object sender, TextChangedEventArgs e)

        {

            if (IsEditingMode)

            {

                if (Base_TextBox.Text.Contains("|OR||DZ|"))

                {

                    Base_TextBox.Text = this.Text;

                }

                this.Text = Base_TextBox.Text;

            }            

            DrawingCloud();

        }

        void Base_TextBox_GotFocus(object sender, RoutedEventArgs e)

        {

            this.BaseTextbox_Caret.Visibility = Visibility.Visible;

            MoveCustomCaret();

            Base_TextBox.Focus();

            this.IsEditingMode = true;

        }

        void Base_TextBox_LostFocus(object sender, RoutedEventArgs e)

        {

            this.Text = Base_TextBox.Text;

            this.BaseTextbox_Caret.Visibility = Visibility.Collapsed;

            this.IsEditingMode = false;

            ApplyOverViewData();

        }

        //void TextControl_GotFocus(object sender, RoutedEventArgs e)

        //{

        //    Base_TextBox.Visibility = Visibility.Visible;

        //    Base_TextBlock.Visibility = Visibility.Collapsed;

        //    this.Base_TextBox.BorderThickness = new Thickness(1);

        //    if (UnderLine != null)

        //    {

        //        Base_TextBlock.TextDecorations = UnderLine;

        //    }

        //    if (this.Text != null)

        //    {

        //        Base_TextBox.Text = this.Text;

        //    }

        //    IsEditing = true;

        //}

        //void TextControl_LostFocus(object sender, RoutedEventArgs e)

        //{

        //    Base_TextBox.Visibility = Visibility.Collapsed;

        //    Base_TextBlock.Visibility = Visibility.Visible;

        //    this.Text = Base_TextBox.Text;

        //    if (UnderLine != null)

        //    {

        //        Base_TextBlock.TextDecorations = UnderLine;

        //    }

        //    Base_TextBlock.Margin =

        //       new Thickness(Base_TextBox.Margin.Left + 4, Base_TextBox.Margin.Top + 4, Base_TextBox.Margin.Right + 4, Base_TextBox.Margin.Bottom + 4);

        //    IsEditing = false;

        //}

        public void EditingMode()

        {            

            TextBoxVisibility = Visibility.Visible;

            TextBlockVisibility = Visibility.Collapsed;

            this.BaseTextbox_Caret.Visibility = Visibility.Visible;

            if (UnderLine != null)

                Base_TextBlock.TextDecorations = UnderLine;

        }

        public void UnEditingMode()

        {            

            TextBoxVisibility = Visibility.Collapsed;         

            TextBlockVisibility = Visibility.Visible; 

            this.BaseTextbox_Caret.Visibility = Visibility.Collapsed;

            if (UnderLine != null)

                Base_TextBlock.TextDecorations = UnderLine;

        }

        public void SetText()

        {

            if (IsHighLight)

            {

                this.BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6),

                    Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

                this.BackColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.1),

                    Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

            }

            else

            {

                //this.BackInnerColor = new SolidColorBrush(Color.FromArgb(0x003, 0xFF, 0xFF, 0xFF));

                //this.BackColor = new SolidColorBrush(Color.FromArgb(0x003, 0xFF, 0xFF, 0xFF));

                this.BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6),

                    Colors.White.R, Colors.White.G, Colors.White.B));

                this.BackColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.1),

                    Colors.White.R, Colors.White.G, Colors.White.B));

            }

            //if (Base_TextPath != null)

            //{

            //    Base_TextPath.StrokeThickness = LineSize.Left;

            //}

        }

        public void DrawingCloud()

        {

            List<Point> pCloud = new List<Point>

            {

                new Point(-LineSize.Left * 0.5, -LineSize.Left * 0.5),

                new Point(-LineSize.Left * 0.5, BoxHeight + LineSize.Left * 0.5),

                new Point(BoxWidth + LineSize.Left * 0.5, BoxHeight + LineSize.Left * 0.5),

                new Point(BoxWidth + LineSize.Left * 0.5 ,-LineSize.Left * 0.5)

            };

            if (this.ArcLength == 0) this.ArcLength = 10;

            //this.Base_TextBox.Select(Base_TextBox.Text.Length, 0);

            if (Base_TextPath != null)

            {

                switch (ControlType_No)

                {

                    case 0:

                        {

                            PathData = new PathGeometry();

                            PathDataInner = (GenerateInner(pCloud));

                        }

                        break;

                    case 1:

                        {

                            PathData = (Generate_Rect(pCloud));                         

                            PathDataInner = (GenerateInner(pCloud));

                        }

                        break;

                    case 2:

                        {

                            List<Point> pCloud2 = new List<Point>

                            {

                                new Point(-LineSize.Left* 2 , -LineSize.Left* 2 ),

                                new Point(-LineSize.Left* 2 , BoxHeight + LineSize.Left * 2 ),

                                new Point(BoxWidth + LineSize.Left* 2 , BoxHeight + LineSize.Left * 2 ),

                                new Point(BoxWidth + LineSize.Left* 2  ,-LineSize.Left* 2 )

                            };

                            PathData = (Generate(pCloud, this.ArcLength, this.LineSize.Left));

                            PathDataInner = (GenerateInner(pCloud));

                        }

                        break;

                }

            }

        }

        #endregion Internal Method

        public void Dispose()

        {

            //GC.Collect();

            ////GC.SuppressFinalize(this);

            this.Base_Border = null;

            this.Base_Canvas = null;

            this.Base_Grid = null;

            this.Base_TextBlock = null;

            this.Base_TextBox = null;

        }

        public override void UpdateControl()

        {

            if (this.PointSet.Count > 1)

            {

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

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

            }

        }

        #region Drawing Cloud Method

        public static PathGeometry Generate_Rect(List<Point> pData)

        {

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = pData[0];

            PolyLineSegment polyline = new PolyLineSegment(pData, true);

            pathFigure.Segments.Add(polyline);

            PathGeometry rectPathGeometry = new PathGeometry();

            rectPathGeometry.Figures = new PathFigureCollection();

            pathFigure.IsClosed = true;

            pathFigure.IsFilled = false;

            rectPathGeometry.Figures.Add(pathFigure);

            return rectPathGeometry;

        }

        public static PathGeometry Generate(List<Point> pData, double _ArcLength = 20, double _LineSize = 20)

        {

            var _pathGeometry = new PathGeometry();

            double area = MathSet.AreaOf(pData);

            bool reverse = (area > 0);

            int count = pData.Count;

            for (int i = 0; i < count; i++)

            {

                PathFigure pathFigure = Polygon.CloudControl.GenerateLineWithCloud(pData[i % count], pData[(i + 1) % count], _ArcLength, reverse, _LineSize);

                pathFigure.IsClosed = false;

                pathFigure.IsFilled = true;

                _pathGeometry.Figures.Add(pathFigure);

            }

            return _pathGeometry;

        }

        public static PathGeometry GenerateInner(List<Point> pData)

        {

            var _pathGeometry = new PathGeometry();

            double area = MathSet.AreaOf(pData);

            bool reverse = (area > 0);

            int count = pData.Count;

            PathFigure pathFigur2 = new PathFigure();

            pathFigur2.StartPoint = pData[0];

            PolyLineSegment polyline = new PolyLineSegment(pData, true);

            pathFigur2.Segments.Add(polyline);

            pathFigur2.IsClosed = true;

            pathFigur2.IsFilled = true;

            _pathGeometry.Figures.Add(pathFigur2);

            return _pathGeometry;

        }

        #endregion

        #region Dependency Properties

        public static readonly DependencyProperty ControlTypeProperty =

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

        public static readonly DependencyProperty ControlType_NoProperty =

        DependencyProperty.Register("ControlType_No", typeof(int), typeof(TextControl), new FrameworkPropertyMetadata(0));

        public static readonly DependencyProperty IsSelectedProperty = DependencyProperty.Register(

            "IsSelected", typeof(bool), typeof(TextControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));

        public static readonly DependencyProperty PathGeometryProperty = DependencyProperty.Register(

            "PathGeometry", typeof(PathGeometry), typeof(TextControl), new PropertyMetadata(null, SetPathGeometryChanged));

        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty OverViewTextProperty = DependencyProperty.Register(

            "OverViewText", typeof(string), typeof(TextControl), new PropertyMetadata(null, new PropertyChangedCallback(TextChanged)));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        /*public static readonly DependencyProperty FontColorProperty = DependencyProperty.Register(

            "FontColor", typeof(SolidColorBrush), typeof(TextControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));*/

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty ArcLengthProperty = DependencyProperty.Register(

            "ArcLength", typeof(double), typeof(TextControl), new PropertyMetadata((Double)10, PointValueChanged));

        //강인구 추가

        public static readonly DependencyProperty IsHighlightProperty = DependencyProperty.Register(

            "IsHighLight", typeof(bool), typeof(TextControl), new PropertyMetadata(false, PointValueChanged));

        public static readonly DependencyProperty BackColorProperty = DependencyProperty.Register(

            "BackColor", typeof(SolidColorBrush), typeof(TextControl), new PropertyMetadata(new SolidColorBrush(Colors.White)));

        public static readonly DependencyProperty BackInnerColorProperty = DependencyProperty.Register(

            "BackInnerColor", typeof(SolidColorBrush), typeof(TextControl), new PropertyMetadata(new SolidColorBrush(Colors.White)));

        public static readonly DependencyProperty UnderLineProperty = DependencyProperty.Register(

            "UnderLine", typeof(TextDecorationCollection), typeof(TextControl), new PropertyMetadata(null));

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

            "LineSize", typeof(Thickness), typeof(TextControl), new PropertyMetadata(new Thickness(4), PointValueChanged)); //여기만 4인지 모르겠지만 4 그대로 두겠음

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataInnerProperty = DependencyProperty.Register(

            "PathDataInner", typeof(Geometry), typeof(TextControl), null);

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

            "OverViewPathDataProperty", typeof(Geometry), typeof(TextControl), null);

        public static readonly DependencyProperty TextStyleProperty = DependencyProperty.Register(

            "TextStyle", typeof(FontStyle), typeof(TextControl), new PropertyMetadata(FontStyles.Normal));

        public static readonly DependencyProperty TextFamilyProperty = DependencyProperty.Register(

            "TextFamily", typeof(FontFamily), typeof(TextControl), 

                        new PropertyMetadata(new PropertyChangedCallback(TextFamilyPropertyChanged)));

        public static readonly DependencyProperty TextWeightProperty = DependencyProperty.Register(

            "TextWeight", typeof(FontWeight), typeof(TextControl), new PropertyMetadata(FontWeights.Normal));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register(

            "CenterX", typeof(double), typeof(TextControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register(

            "CenterY", typeof(double), typeof(TextControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TextSizeProperty = DependencyProperty.Register(

            "TextSize", typeof(Double), typeof(TextControl), new PropertyMetadata((Double)30, PointValueChanged));

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty OverViewPaintProperty = DependencyProperty.Register(

            "OverViewPaint", typeof(PaintSet), typeof(TextControl), new PropertyMetadata((PaintSet.None), PointValueChanged));

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EnableEditingProperty = DependencyProperty.Register(

           "EnableEditing", typeof(bool), typeof(TextControl), new PropertyMetadata((true), new PropertyChangedCallback(OnIsEditingChanged)));

        public static readonly DependencyProperty TextBoxVisibilityProperty = DependencyProperty.Register(

            "TextBoxVisibility", typeof(Visibility), typeof(TextControl), new PropertyMetadata((Visibility.Visible), OnTextBoxVisibilityChanged));

        public static readonly DependencyProperty TextBlockVisibilityProperty = DependencyProperty.Register(

            "TextBlockVisibility", typeof(Visibility), typeof(TextControl), new PropertyMetadata((Visibility.Collapsed), OnTextBlockVisibilityChanged));

        #endregion Dependency Properties

        #region dp Properties

        public override SolidColorBrush StrokeColor

        {

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

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                }

            }

        }

        public Double ArcLength

        {

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

            set

            {

                if (this.ArcLength != value)

                {

                    SetValue(ArcLengthProperty, value);

                    OnPropertyChanged("ArcLength");

                }

            }

        }

        public bool EnableEditing

        {

            get { return (bool)GetValue(EnableEditingProperty); }

            set

            {

                if (this.EnableEditing != value)

                {

                    SetValue(EnableEditingProperty, value);

                    OnPropertyChanged("EnableEditing");

                }

            }

        }

        public Thickness LineSize

        {

            get

            {

                return (Thickness)GetValue(LineSizeProperty);

            }

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                    OnPropertyChanged("LineSize");

                }

            }

        }

        public override ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, value);

            }

        }

        public int ControlType_No

        {

            get

            {

                return (int)GetValue(ControlType_NoProperty);

            }

            set

            {

                SetValue(ControlType_NoProperty, value);

            }

        }

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public double CenterX

        {

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

            set

            {

                SetValue(CenterXProperty, value);

                OnPropertyChanged("CenterX");

            }

        }

        public double CenterY

        {

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

            set

            {

                SetValue(CenterYProperty, value);

                OnPropertyChanged("CenterY");

            }

        }

        public string Text

        {

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

            set

            {

                if (this.Text != value)

                {

                    SetValue(TextProperty, value);

                    OnPropertyChanged("Text");

                }

            }

        }

        public string OverViewText

        {

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

            set

            {

                if (this.OverViewText != value)

                {

                    SetValue(OverViewTextProperty, value);

                    OnPropertyChanged("OverViewText");

                }

            }

        }

        public Geometry OverViewPathData

        {

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

            set

            {

                if (this.OverViewPathData != value)

                {

                    SetValue(OverViewPathDataProperty, value);

                    OnPropertyChanged("OverViewPathData");

                }

            }

        }

        public Visibility TextBoxVisibility

        {

            get { return (Visibility)GetValue(TextBoxVisibilityProperty); }

            set

            {

                if (this.TextBoxVisibility != value)

                {

                    SetValue(TextBoxVisibilityProperty, value);

                    OnPropertyChanged("TextBoxVisibility");

                }

            }

        }

        public Visibility TextBlockVisibility

        {

            get { return (Visibility)GetValue(TextBlockVisibilityProperty); }

            set

            {

                if (this.TextBlockVisibility != value)

                {

                    SetValue(TextBlockVisibilityProperty, value);

                    OnPropertyChanged("TextBlockVisibility");

                }

            }

        }

        public Double TextSize

        {

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

            set

            {

                if (this.TextSize != value)

                {

                    SetValue(TextSizeProperty, value);

                    OnPropertyChanged("TextSize");

                }

            }

        }

        /*

        public SolidColorBrush FontColor

        {

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

            set

            {

                if (this.FontColor != value)

                {

                    SetValue(FontColorProperty, value);

                    OnPropertyChanged("FontColor");

                }

            }

        }*/

        public SolidColorBrush BackColor

        {

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

            set

            {

                if (this.BackColor != value)

                {

                    SetValue(BackColorProperty, value);

                    OnPropertyChanged("BackColor");

                }

            }

        }

        public SolidColorBrush BackInnerColor

        {

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

            set

            {

                if (this.BackInnerColor != value)

                {

                    SetValue(BackInnerColorProperty, value);

                    OnPropertyChanged("BackInnerColor");

                }

            }

        }

        public TextDecorationCollection UnderLine

        {

            get

            {

                return (TextDecorationCollection)GetValue(UnderLineProperty);

            }

            set

            {

                if (this.UnderLine != value)

                {

                    SetValue(UnderLineProperty, value);

                    OnPropertyChanged("UnderLine");

                }

            }

        }

        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 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 FontStyle TextStyle

        {

            get { return (FontStyle)GetValue(TextStyleProperty); }

            set

            {

                if (this.TextStyle != value)

                {

                    SetValue(TextStyleProperty, value);

                    OnPropertyChanged("TextStyle");

                }

            }

        }

        public FontFamily TextFamily

        {

            get { return (FontFamily)GetValue(TextFamilyProperty); }

            set

            {

                if (this.TextFamily != value)

                {

                    SetValue(TextFamilyProperty, value);

                    OnPropertyChanged("TextFamily");

                }

            }

        }

        public FontWeight TextWeight

        {

            get { return (FontWeight)GetValue(TextWeightProperty); }

            set

            {

                if (this.TextWeight != value)

                {

                    SetValue(TextWeightProperty, value);

                    OnPropertyChanged("TextWeight");

                }

            }

        }

        public PaintSet Paint

        {

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

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, value);

                    OnPropertyChanged("Paint");

                }

            }

        }

        public PaintSet OverViewPaint

        {

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

            set

            {

                if (this.OverViewPaint != value)

                {

                    SetValue(OverViewPaintProperty, value);

                    OnPropertyChanged("OverViewPaint");

                }

            }

        }

        double IPath.LineSize

        {

            get

            {

                return this.LineSize.Left;

            }

            set

            {

                this.LineSize = new Thickness(value);

                OnPropertyChanged("LineSize");

            }

        }

        public Geometry PathData

        {

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

            set

            {

                SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        public Geometry PathDataInner

        {

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

            set

            {

                SetValue(PathDataInnerProperty, value);

                OnPropertyChanged("PathDataInner");

            }

        }

        public override double CommentAngle

        {

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

            set

            {

                if (this.CommentAngle != value)

                {

                    SetValue(AngleProperty, value);

                    OnPropertyChanged("Angle");

                    UpdateLayout();

                }

            }

        }

        public bool IsHighLight

        {

            get { return (bool)GetValue(IsHighlightProperty); }

            set

            {

                if (this.IsHighLight != value)

                {

                    SetValue(IsHighlightProperty, value);

                    OnPropertyChanged("IsHighLight");

                }

            }

        }

        public List<Point> PointSet

        {

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

            set

            {

                SetValue(PointSetProperty, value);

                OnPropertyChanged("PointSet");

            }

        }

        #endregion Properties

        #region Properties

        private bool _IsEditingMode;

        public bool IsEditingMode

        {

            get

            {

                return _IsEditingMode;

            }

            set

            {

                _IsEditingMode = value;

                OnPropertyChanged("IsEditingMode");

            }

        }

        public PathGeometry PathGeometry

        {

            get { return (PathGeometry)GetValue(PathGeometryProperty); }

            set

            {

                SetValue(PathGeometryProperty, value);

                OnPropertyChanged("PathGeometry");

            }

        }

        private double _BoxWidth;

        public double BoxWidth

        {

            get

            {

                return _BoxWidth;

            }

            set

            {

                _BoxWidth = value;

                OnPropertyChanged("BoxWidth");

            }

        }

        private double _BoxHeight;

        public double BoxHeight

        {

            get

            {

                return _BoxHeight;

            }

            set

            {

                _BoxHeight = value;

                OnPropertyChanged("BoxHeight");

            }

        }

        #endregion

        #region CallBack Method

        private static void TextFamilyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (TextControl)d;

            //instance.SetFontFamily(e.NewValue as FontFamily);

        }

        public static void SetPathGeometryChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

            }

        }

        public static void OnTextBoxVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

            }

        }

        public static void OnTextBlockVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

            }

        }

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (TextControl)sender;

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

            //{

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

            //    if (instance.IsSelected)

            //    {

            //        instance.StrokeColor = new SolidColorBrush(Colors.Blue);

            //        //instance.Base_Border.BorderBrush = new SolidColorBrush(Colors.Blue);

            //    }

            //    else

            //    {

            //        instance.StrokeColor = new SolidColorBrush(Colors.Red);

            //        //instance.Base_Border.BorderBrush = new SolidColorBrush(Colors.Red);

            //        //instance.FontColor = new SolidColorBrush(Colors.Transparent);

            //        //instance.Base_Border.BorderBrush = new SolidColorBrush(Colors.Transparent);

            //    }

            //}

        }

        public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

                Canvas.SetLeft(instance, instance.CanvasX);

                Canvas.SetTop(instance, instance.CanvasY);

            }

        }

        public static void OnIsEditingChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

                if (instance.EnableEditing)

                {

                    instance.EditingMode();

                }

                else

                {

                    instance.UnEditingMode();

                }

            }

        }

        public static void TextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

            if (e.OldValue != e.NewValue)

            {

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

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

                //instance.DrawingCloud();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {

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

                //instance.DrawingCloud();

            }

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (TextControl)sender;

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

            {                       

                instance.SetText();

                instance.DrawingCloud();

            }

        }

        #endregion CallBack Method

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

            if (propName == "UnderLine" && Base_TextBlock != null)

            {

                Base_TextBlock.TextDecorations = UnderLine;

                //(sender as TextControl).Base_TextBlock.TextDecorations = (sender as TextControl).UnderLine;

            }

        }

        /// <summary>

        /// return textcontrols' area

        /// </summary>

        public override Rect ItemRect

        {

            get

            {

                Point start = new Point(this.CanvasX, this.CanvasY);

                Point length = new Point();

                double angle = this.CommentAngle * Math.PI / 180;

                double sin = Math.Sin(angle);

                double cos = Math.Cos(angle);

                length.X = this.BoxWidth * cos - this.BoxHeight * sin;

                length.Y = this.BoxWidth * sin + this.BoxHeight * cos;

                Point end = new Point(start.X + length.X, start.Y + length.Y);

                return new Rect(start, end);

            }

        }

        /// <summary>

        /// translate control along given dx,dy

        /// </summary>

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

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

        public override void OnTranslate(double dx, double dy)

        {

            //this.CanvasX = Canvas.GetLeft(this) + dx;

            //this.CanvasY = Canvas.GetTop(this) + dy;

            this.StartPoint = new Point(this.StartPoint.X + dx, this.StartPoint.Y + dy);

            this.EndPoint = new Point(this.EndPoint.X + dx, this.EndPoint.Y + dy);

            this.SetValue(TextControl.CanvasXProperty, Canvas.GetLeft(this) + dx);

            this.SetValue(TextControl.CanvasYProperty, Canvas.GetTop(this) + dy);

        }

        /// <summary>

        /// Serialize this

        /// </summary>

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

        /// <returns></returns>

        public override string Serialize()

        {

            using (S_TextControl STemp = new S_TextControl())

            {

                STemp.TransformPoint = "0|0";

                STemp.SizeSet = String.Format("{0}|{1}", this.LineSize.Left.ToString(), this.TextSize.ToString());

                STemp.Text = this.Text;

                STemp.UserID = this.UserID;

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

                //STemp.FontColor = "#FFFFFF00";

                if (this.StartPoint == new Point())

                    STemp.StartPoint = new Point(this.CanvasX, this.CanvasY);

                else

                    STemp.StartPoint = this.StartPoint;

                STemp.EndPoint = this.EndPoint;

                STemp.Opac = this.Opacity;

                STemp.PointSet = this.PointSet;

                STemp.Angle = this.CommentAngle;

                STemp.paintMethod = this.ControlType_No;

                STemp.BoxW = this.BoxWidth;

                STemp.BoxH = this.BoxHeight;

                STemp.isHighLight = this.IsHighLight;

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

                STemp.fontConfig = new List<string>()

                            {

                                this.TextFamily.FontName(),

                                this.TextStyle.ToString(),

                                this.TextWeight.ToString(),

                            };

                STemp.ArcLength = this.ArcLength;

                if (this.UnderLine != null)

                {

                    STemp.fontConfig.Add("true");

                }

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                STemp.Memo = this.Memo;

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

            }

        }

        /// <summary>

        /// create a textcontrol from given string

        /// </summary>

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

        /// <returns></returns>

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

        {

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

            {

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

                TextControl instance = new TextControl()

                {

                    Text = s.Text,

                    StartPoint = s.StartPoint,

                    EndPoint = s.EndPoint,

                    CanvasX = s.StartPoint.X,

                    CanvasY = s.StartPoint.Y,

                    BoxWidth = s.BoxW,

                    BoxHeight = s.BoxH,

                    ControlType_No = s.paintMethod,

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

                    TextSize = Convert.ToDouble(data2[1]),

                    StrokeColor = brush,

                    FontSize = 10,

                    UserID = s.UserID,

                    IsHighLight = s.isHighLight,

                    CommentAngle = s.Angle,

                    PointSet = s.PointSet,

                    Opacity = s.Opac,

                    TextFamily = Markus.Fonts.FontHelper.GetFontFamily(s.fontConfig[0]),

                    //인구 추가(2018.04.17)

                    TextStyle = StringToFont.ConFontStyle(s.fontConfig[1]),

                    TextWeight = StringToFont.ConFontWeight(s.fontConfig[2]),

                    ArcLength = s.ArcLength

                };

                if (s.fontConfig.Count() == 4)

                {

                    instance.UnderLine = TextDecorations.Underline;

                }

                return instance;

            }

        }

    }

}