MARKUS

using MarkupToPDF.Controls.Common;

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

using MarkupToPDF.Common;

namespace MarkupToPDF.Controls.Text

{

    public class ArrowTextControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IPath, ITextControl, IMarkupControlData

    {

        private const string PART_ArrowPath = "PART_ArrowPath";

        private const string PART_TextBox = "PART_ArrowTextBox";

        //private const string PART_TextBlock = "PART_ArrowTextBlock";

        private const string PART_ArrowSubPath = "PART_ArrowSubPath";

        private const string PART_Border = "PART_Border";

        public Path Base_ArrowPath = null;

        public Path Base_ArrowSubPath = null;

        public TextBox Base_TextBox = null;

        public TextBlock Base_TextBlock = null;

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

        #region Object & Variable

        GeometryGroup instanceGroup = new GeometryGroup();

        Path Cemy = new Path();

        LineGeometry connectorSMGeometry = new LineGeometry();

        LineGeometry connectorMEGeometry = new LineGeometry();

        //안쓰고 있음

        //LineGeometry connectorMCEGeometry = new LineGeometry();

        public enum ArrowTextStyleSet { Normal, Cloud, Rect };

        #endregion

        static ArrowTextControl()

        {

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

            ResourceDictionary dictionary = new ResourceDictionary();

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

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

        }

        public ArrowTextControl()

        {

            this.DefaultStyleKey = typeof(ArrowTextControl);

        }

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_ArrowPath = GetTemplateChild(PART_ArrowPath) as Path;

            Base_ArrowSubPath = GetTemplateChild(PART_ArrowSubPath) as Path;

            Base_TextBox = GetTemplateChild(PART_TextBox) as TextBox;

            //Base_TextBlock = GetTemplateChild(PART_TextBlock) as TextBlock;

            //CustomText custom = new CustomText();

            //Base_TextBox.Template = custom.T_Box.Template;

            //Base_TextBox.Style = custom.T_Box.Style;

            ////Base_TextBox.Template = custom.T_Box.Template.Triggers;

            ////TextBoxBackground = Brushes.Red;

            ////Base_TextBox.Opacity = 0.5;

            Base_TextBox.SizeChanged += new SizeChangedEventHandler(Base_TextBox_SizeChanged);

            Base_TextBox.GotFocus += new RoutedEventHandler(Base_TextBox_GotFocus);

            Base_TextBox.LostFocus += new RoutedEventHandler(Base_TextBox_LostFocus);

            //Base_TextBlock.SizeChanged += Base_TextBlock_SizeChanged;

            SetArrowTextPath();

            //Base_ArrowPath.Focus();

            //Base_TextBox.Focus();

            Base_TextBox.IsTabStop = true;

            //Base_TextBox.IsHitTestVisible = false;

        }

        void Base_TextBox_LostFocus(object sender, RoutedEventArgs e)

        {

            this.ArrowText = Base_TextBox.Text;

            this.IsEditingMode = false;

            ApplyOverViewData();

        }

        void Base_TextBox_GotFocus(object sender, RoutedEventArgs e)

        {

            this.IsEditingMode = true;

        }

        void Base_TextBox_SizeChanged(object sender, SizeChangedEventArgs e)

        {

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

            {

                Base_TextBox.Text = this.ArrowText;

            }

            this.ArrowText = Base_TextBox.Text;

            BoxWidth = e.NewSize.Width;

            BoxHeight = e.NewSize.Height;

            SetArrowTextPath();

        }

        //void Base_TextBlock_SizeChanged(object sender, SizeChangedEventArgs e)

        //{

        //    Base_TextBlock.Text = Base_TextBox.Text;

        //    BoxWidth = e.NewSize.Width;

        //    BoxHeight = e.NewSize.Height;

        //    this.ApplyTemplate();

        //    SetArrowTextPath();

        //}

        #region Properties

        private bool _IsEditingMode;

        public bool IsEditingMode

        {

            get

            {

                return _IsEditingMode;

            }

            set

            {

                _IsEditingMode = value;

                OnPropertyChanged("IsEditingMode");

            }

        }

        #endregion

        #region dp Properties

        //강인구 주석 풀기

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

        {

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

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                }

            }

        }

        public PathGeometry SubPathData

        {

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

            set

            {

                if (this.SubPathData != value)

                {

                    SetValue(SubPathDataProperty, value);

                }

            }

        }

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

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

                OnPropertyChanged("IsSelected");

            }

        }

        public ControlType ControlType

        {

            set

            {

                SetValue(ControlTypeProperty, value);

                OnPropertyChanged("ControlType");

            }

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

        }

        public Point StartPoint

        {

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

            set { SetValue(StartPointProperty, value); }

        }

        public Point EndPoint

        {

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

            set { SetValue(EndPointProperty, value); }

        }

        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 double Angle

        {

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

            set { SetValue(AngleProperty, value); }

        }

        public Thickness BorderSize

        {

            get { return (Thickness)GetValue(BorderSizeProperty); }

            set

            {

                if (this.BorderSize != value)

                {

                    SetValue(BorderSizeProperty, value);

                }

            }

        }

        public Point MidPoint

        {

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

            set { SetValue(MidPointProperty, value); }

        }

        public bool isFixed

        {

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

            set { SetValue(IsFixedProperty, value); }

        }

        public bool isTrans

        {

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

            set { SetValue(TransformerProperty, value); }

        }

        public bool isHighLight

        {

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

            set

            {

                if (this.isHighLight != value)

                {

                    SetValue(isHighlightProperty, value);

                    OnPropertyChanged("isHighLight");

                }

            }

        }

        public FontWeight TextWeight

        {

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

            set

            {

                if (this.TextWeight != value)

                {

                    SetValue(TextWeightProperty, value);

                    OnPropertyChanged("TextWeight");

                }

            }

        }

        public Double LineSize

        {

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

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public Double BoxWidth

        {

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

            set

            {

                if (this.BoxWidth != value)

                {

                    SetValue(BoxWidthProperty, value);

                }

            }

        }

        public Double BoxHeight

        {

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

            set

            {

                if (this.BoxHeight != value)

                {

                    SetValue(BoxHeightProperty, value);

                }

            }

        }

        public ArrowTextStyleSet ArrowTextStyle

        {

            get { return (ArrowTextStyleSet)GetValue(ArrowTextStyleProperty); }

            set

            {

                if (this.ArrowTextStyle != value)

                {

                    SetValue(ArrowTextStyleProperty, value);

                }

            }

        }

        public Geometry PathData

        {

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

            set { SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        public SolidColorBrush BackInnerColor

        {

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

            set

            {

                if (this.BackInnerColor != value)

                {

                    SetValue(BackInnerColorProperty, value);

                    OnPropertyChanged("BackInnerColor");

                }

            }

        }

        public Geometry PathDataInner

        {

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

            set

            {

                SetValue(PathDataInnerProperty, value);

                OnPropertyChanged("PathDataInner");

            }

        }

        public Geometry OverViewPathData

        {

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

            set { SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public FontFamily TextFamily

        {

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

            set

            {

                if (this.TextFamily != value)

                {

                    SetValue(TextFamilyProperty, value);

                    OnPropertyChanged("TextFamily");

                }

            }

        }

        public string ArrowText

        {

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

            set

            {

                if (this.ArrowText != value)

                {

                    SetValue(ArrowTextProperty, value);

                    OnPropertyChanged("ArrowText");

                }

            }

        }

        public string OverViewArrowText

        {

            get { return (string)GetValue(OverViewArrowTextProperty);

            }

            set

            {

                if (this.OverViewArrowText != value)

                {

                    SetValue(OverViewArrowTextProperty, value);

                    OnPropertyChanged("OverViewArrowText");

                }

            }

        }

        public Double TextSize

        {

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

            set

            {

                if (this.TextSize != value)

                {

                    SetValue(TextSizeProperty, value);

                    OnPropertyChanged("TextSize");

                }

            }

        }

        public FontStyle TextStyle

        {

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

            set

            {

                if (this.TextStyle != value)

                {

                    SetValue(TextStyleProperty, value);

                    OnPropertyChanged("TextStyle");

                }

            }

        }

        //강인구 추가

        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 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 Brush SubPathFill

        {

            get { return (Brush)GetValue(SubPathFillProperty); }

            set

            {

                SetValue(SubPathFillProperty, value);

                OnPropertyChanged("SubPathFill");

            }

        }

        public Brush TextBoxBackground

        {

            get { return (Brush)GetValue(TextBoxBackgroundProperty); }

            set

            {

                SetValue(TextBoxBackgroundProperty, value);

                OnPropertyChanged("TextBoxBackground");

            }

        }

        //강인구 추가 주석풀기

        public bool IsEditing

        {

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

            set

            {

                if (this.IsEditing != value)

                {

                    SetValue(IsEditingProperty, value);

                    OnPropertyChanged("IsEditing");

                }

            }

        }

        public bool EnableEditing

        {

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

            set

            {

                if (this.EnableEditing != value)

                {

                    SetValue(EnableEditingProperty, value);

                    OnPropertyChanged("EnableEditing");

                }

            }

        }

        #endregion

        #region Dependency Properties

        public static readonly DependencyProperty BoxWidthProperty = DependencyProperty.Register(

                "BoxWidth", typeof(double), typeof(ArrowTextControl), new PropertyMetadata((Double)20));

        public static readonly DependencyProperty BoxHeightProperty = DependencyProperty.Register(

                "BoxHeight", typeof(double), typeof(ArrowTextControl), new PropertyMetadata((Double)20));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty ArrowTextStyleProperty = DependencyProperty.Register(

               "ArrowTextStyle", typeof(ArrowTextStyleSet), typeof(ArrowTextControl), new PropertyMetadata(ArrowTextStyleSet.Normal));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register(

                "Angle", typeof(double), typeof(ArrowTextControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback(PointValueChanged)));

        public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TextFamilyProperty = DependencyProperty.Register(

                "TextFamily", typeof(FontFamily), typeof(ArrowTextControl), new PropertyMetadata(new FontFamily("Arial"), TextChanged));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty UnderLineProperty = DependencyProperty.Register(

    "UnderLine", typeof(TextDecorationCollection), typeof(ArrowTextControl), new PropertyMetadata(null, PointValueChanged));

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TextStyleProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TextSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TextWeightProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty IsFixedProperty = DependencyProperty.Register(

                "isFixed", typeof(bool), typeof(ArrowTextControl), new PropertyMetadata(false, PointValueChanged));

        public static readonly DependencyProperty IsSelectedProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty ControlTypeProperty = DependencyProperty.Register(

                "ControlType", typeof(ControlType), typeof(ArrowTextControl), new FrameworkPropertyMetadata(ControlType.ArrowTextControl));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty BackInnerColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataInnerProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty isHighlightProperty = DependencyProperty.Register(

                "isHighlight", typeof(bool), typeof(ArrowTextControl), new PropertyMetadata(false, PointValueChanged));

        public static readonly DependencyProperty MidPointProperty = DependencyProperty.Register(

                "MidPoint", typeof(Point), typeof(ArrowTextControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty TransformerProperty = DependencyProperty.Register(

                "isTrans", typeof(bool), typeof(ArrowTextControl), new PropertyMetadata(false, PointValueChanged));

        public static readonly DependencyProperty BorderSizeProperty = DependencyProperty.Register(

                "BorderSize", typeof(Thickness), typeof(ArrowTextControl), new PropertyMetadata(new Thickness(0), PointValueChanged));

        public static readonly DependencyProperty ArrowTextProperty = DependencyProperty.Register(

              "ArrowText", typeof(string), typeof(ArrowTextControl), new PropertyMetadata(null));

        //, new PropertyChangedCallback(TextChanged)

        #region 추가 사항

        public static readonly DependencyProperty SubPathDataProperty = DependencyProperty.Register(

                "SubPathData", typeof(Geometry), typeof(ArrowTextControl), null);

        public static readonly DependencyProperty SubPathFillProperty = DependencyProperty.Register(

                "SubPathFill", typeof(Brush), typeof(ArrowTextControl), new PropertyMetadata(null));

        public static readonly DependencyProperty TextBoxBackgroundProperty = DependencyProperty.Register(

                "TextBoxBackground", typeof(Brush), typeof(ArrowTextControl), new PropertyMetadata(Brushes.White));

        public static readonly DependencyProperty OverViewArrowTextProperty = DependencyProperty.Register(

                "OverViewArrowText", typeof(string), typeof(ArrowTextControl), new PropertyMetadata(null, new PropertyChangedCallback(TextChanged)));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty OverViewStartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty OverViewEndPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TextBoxVisibilityProperty = DependencyProperty.Register(

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

        //강인구 추가(주석풀기)

        public static readonly DependencyProperty TextBlockVisibilityProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty IsEditingProperty = DependencyProperty.Register(

            "IsEditing", typeof(bool), typeof(ArrowTextControl), new PropertyMetadata((false), new PropertyChangedCallback(OnIsEditingChanged)));

        public static readonly DependencyProperty EnableEditingProperty = DependencyProperty.Register(

           "EnableEditing", typeof(bool), typeof(ArrowTextControl), new PropertyMetadata((true)));

        #endregion

        #endregion

        #region CallBack Method

        //강인구 추가(주석풀기)

        public static void OnIsEditingChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)sender;

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

            {

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

                if (instance.EnableEditing)

                {

                    if (instance.IsEditing)

                    {

                        instance.EditingMode();

                    }

                    else

                    {

                        instance.UnEditingMode();

                    }

                }

                else

                {

                    instance.UnEditingMode();

                }

            }

        }

        public static void OnTextBoxVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)sender;

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

            {

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

            }

        }

        public static void OnTextBlockVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)sender;

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

            {

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

            }

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)sender;

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

            {

                instance.SetArrowTextPath();

            }

        }

        public static void TextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)sender;

            if (e.OldValue != e.NewValue)

            {

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

                //instance.BoxWidth = instance.Base_TextBox.ActualWidth;

                //instance.BoxHeight = instance.Base_TextBox.ActualHeight;

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)sender;

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

            {

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

                instance.SetArrowTextPath();

            }

        }

        public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowTextControl)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 IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (ArrowTextControl)sender;

            //if (e.OldValue != e.NewValue)

            //{

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

            //    if (instance.IsSelected && instance.Base_TextBox != null)

            //    {

            //        instance.BorderSize = new Thickness(1);

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

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

            //    }

            //    else

            //    {

            //        instance.BorderSize = new Thickness(0);

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

            //        //instance.Base_ArrowPath.Stroke = new SolidColorBrush(Colors.Transparent);

            //    }

            //}

        }

        #endregion

        #region Internal Method

        //강인구 주석 풀기

        public void EditingMode()

        {

            TextBoxVisibility = Visibility.Visible;

            TextBlockVisibility = Visibility.Collapsed;

            //강인구 언더라인 추가

            if (UnderLine != null)

                Base_TextBlock.TextDecorations = UnderLine;

        }

        //강인구 주석 풀기

        public void UnEditingMode()

        {

            TextBoxVisibility = Visibility.Collapsed;

            TextBlockVisibility = Visibility.Visible;

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

        }

        #region 주석

        //        public void SetArrowTextPath()

        //        {

        //            instanceGroup.Children.Clear();

        //            instanceSubGroup = new PathGeometry();

        //            connectorSMGeometry.StartPoint = this.StartPoint;

        //            connectorSMGeometry.EndPoint = this.MidPoint;

        //            connectorMEGeometry.StartPoint = this.MidPoint; //핵심

        //            //Canvas.SetLeft(Base_TextBox, this.EndPoint.X - BoxWidth / 2);

        //            //Canvas.SetTop(Base_TextBox, this.EndPoint.Y - BoxHeight / 2);

        //            Canvas.SetLeft(Base_TextBox, this.EndPoint.X);

        //            Canvas.SetTop(Base_TextBox, this.EndPoint.Y);

        //            List<Point> ps = new List<Point>();

        //            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth / 2, Canvas.GetTop(Base_TextBox))); //상단

        //            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth / 2, Canvas.GetTop(Base_TextBox) + this.BoxHeight)); // 하단

        //            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxHeight / 2)); //좌단

        //            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox) + this.BoxHeight / 2));  //우단

        //            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox)));

        //            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)));

        //            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxHeight));

        //            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox) + this.BoxHeight));

        //            if (isTrans)

        //            {

        //                switch (Math.Abs(this.Angle).ToString())

        //                {

        //                    case "90":

        //                        {

        //                            ps.Clear();

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); // 위 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth)); // 위 오른쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); //중간 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 중간

        //                        }

        //                        break;

        //                    case "270":

        //                        {

        //                            ps.Clear();

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); // 위 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth)); // 위 오른쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); //중간 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 중간

        //                        }

        //                        break;

        //                    default:

        //                        break;

        //                }

        //                var endP = MathSet.getNearPoint(ps, this.MidPoint);

        //                connectorMEGeometry.EndPoint = endP;

        //                instanceGroup.Children.Add(SingleAllow(this.MidPoint, this.StartPoint, this.LineSize));

        //            }

        //            else

        //            {

        //                switch (Math.Abs(this.Angle).ToString())

        //                {

        //                    case "90":

        //                        {

        //                            ps.Clear();

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); // 위 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth)); // 위 오른쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); //중간 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 중간

        //                        }

        //                        break;

        //                    case "270":

        //                        {

        //                            ps.Clear();

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); // 위 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth)); // 위 오른쪽

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); //중간 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 하단

        //                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 중간

        //                        }

        //                        break;

        //                    default:

        //                        break;

        //                }

        //                var endP = MathSet.getNearPoint(ps, this.MidPoint);

        //                connectorMEGeometry.EndPoint = endP; //최상단

        //                #region 보정치

        //                //enP는 그 점

        //                //Point testP = new Point(endP.X-100,endP.Y);

        //                Point testP = endP;

        //                if (isFixed)

        //                {

        //                    if (ps[0] == endP) //상단

        //                    {

        //                        testP = new Point(endP.X, endP.Y - 50);

        //                        System.Diagnostics.Debug.WriteLine("상단");

        //                    }

        //                    else if (ps[1] == endP) //하단

        //                    {

        //                        testP = new Point(endP.X, endP.Y + 50);

        //                        System.Diagnostics.Debug.WriteLine("하단");

        //                    }

        //                    else if (ps[2] == endP) //좌단

        //                    {

        //                        testP = new Point(endP.X - 50, endP.Y);

        //                        System.Diagnostics.Debug.WriteLine("좌단");

        //                    }

        //                    else if (ps[3] == endP) //우단

        //                    {

        //                        testP = new Point(endP.X + 50, endP.Y);

        //                        System.Diagnostics.Debug.WriteLine("우단");

        //                    }

        //                }

        //                connectorSMGeometry.EndPoint = testP;

        //                connectorMEGeometry.StartPoint = testP;

        //                //connectorSMGeometry.EndPoint = endP;

        //                //connectorMEGeometry.StartPoint = endP;

        //                instanceGroup.Children.Add(SingleAllow(testP, this.StartPoint, this.LineSize));

        //                #endregion

        //            }

        //            switch (this.ArrowTextStyle)

        //            {

        //                case ArrowTextStyleSet.Normal:

        //                    this.BorderSize = new Thickness(0);

        //                    break;

        //                case ArrowTextStyleSet.Cloud:

        //                    this.BorderSize = new Thickness(0);

        //                    DrawingCloud();

        //                    break;

        //                default:

        //                    this.BorderSize = new Thickness(3);

        //                    break;

        //            }

        //            if (isHighLight)

        //            {

        //                Base_TextBox.Background = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

        //                Base_ArrowSubPath.Fill = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

        //            }

        //            else

        //            {

        //                //Base_ArrowSubPath.Fill = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

        //                //Base_TextBox.Background = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

        //            }

        //            instanceGroup.Children.Add(connectorSMGeometry);

        //            instanceGroup.Children.Add(connectorMEGeometry);

        //            this.Base_ArrowPath.Stroke = this.StrokeColor;

        //            this.PathData = instanceGroup;

        //            Base_ArrowSubPath.Data = instanceSubGroup;

        //            var tempAngle = Math.Abs(this.Angle);

        //            if (tempAngle == Convert.ToDouble(90) || tempAngle == Convert.ToDouble(270))

        //            {

        //                this.RenderTransformOrigin = new Point(0.5, 0.5);

        //                this.Base_ArrowPath.RenderTransformOrigin = new Point(0, 0);

        //                this.Base_ArrowSubPath.RenderTransformOrigin = new Point(0, 0);

        //                Base_TextBox.RenderTransformOrigin = new Point(0, 0);

        //            }

        //            Base_ArrowSubPath.RenderTransform = new RotateTransform

        //            {

        //                Angle = this.Angle,

        //                CenterX = this.EndPoint.X,

        //                CenterY = this.EndPoint.Y,

        //            };

        //        }

        //        public void updateControl()

        //        {

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

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

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

        //            //isTrans = true;

        //        }

        //        private void DrawingCloud()

        //        {

        //            List<Point> pCloud = new List<Point>()

        //            {

        //#if SILVERLIGHT

        //                new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위

        //                new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)+ BoxHeight), //왼쪽 아래

        //                new Point(Canvas.GetLeft(Base_TextBox)+ BoxWidth, Canvas.GetTop(Base_TextBox) + BoxHeight),

        //                new Point(Canvas.GetLeft(Base_TextBox) + BoxWidth, Canvas.GetTop(Base_TextBox)),

        //                new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위  

        //#else

        //                new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위

        //                new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)+ BoxHeight), //왼쪽 아래

        //                new Point(Canvas.GetLeft(Base_TextBox)+ BoxWidth, Canvas.GetTop(Base_TextBox) + BoxHeight),

        //                new Point(Canvas.GetLeft(Base_TextBox) + BoxWidth, Canvas.GetTop(Base_TextBox)),

        //                new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위  

        //                //new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위

        //                //new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)+ BoxHeight-4), //왼쪽 아래

        //                //new Point(Canvas.GetLeft(Base_TextBox)+ BoxWidth-1, Canvas.GetTop(Base_TextBox) + BoxHeight-4),

        //                //new Point(Canvas.GetLeft(Base_TextBox) + BoxWidth-1, Canvas.GetTop(Base_TextBox)),

        //                //new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위

        //#endif

        //            };

        //            //instanceGroup.Children.Add(Generate(pCloud));

        //            instanceSubGroup = (Generate(pCloud));

        //        } 

        #endregion

        public void SetArrowTextPath()

        {

            instanceGroup.Children.Clear();

            connectorSMGeometry.StartPoint = this.StartPoint;

            connectorSMGeometry.EndPoint = this.MidPoint;

            connectorMEGeometry.StartPoint = this.MidPoint; //핵심

            //Canvas.SetLeft(Base_TextBox, this.EndPoint.X - BoxWidth / 2);

            //Canvas.SetTop(Base_TextBox, this.EndPoint.Y - BoxHeight / 2);

            //Canvas.SetLeft(Base_TextBox, this.EndPoint.X);

            Canvas.SetLeft(Base_TextBox, this.EndPoint.X);

            Canvas.SetTop(Base_TextBox, this.EndPoint.Y);

            List<Point> ps = new List<Point>();

            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth / 2, Canvas.GetTop(Base_TextBox))); //상단

            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth / 2, Canvas.GetTop(Base_TextBox) + this.BoxHeight)); // 하단

            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxHeight / 2)); //좌단

            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox) + this.BoxHeight / 2));  //우단

            #region 정밀도 추가

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //상단

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox))); //상단

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxHeight)); //좌단

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox) + this.BoxHeight)); //상단 

            #endregion

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox)));

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)));

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxHeight));

            //ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxWidth, Canvas.GetTop(Base_TextBox) + this.BoxHeight));

            if (isTrans)

            {

                switch (Math.Abs(this.Angle).ToString())

                {

                    case "90":

                        {

                            ps.Clear();

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); // 위 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth)); // 위 오른쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); //중간 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 중간

                        }

                        break;

                    case "270":

                        {

                            ps.Clear();

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); // 위 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth)); // 위 오른쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); //중간 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 중간

                        }

                        break;

                    default:

                        break;

                }

                var endP = MathSet.getNearPoint(ps, this.MidPoint);

                //20180911 LJY 꺾이는 부분 수정

                Point testP = endP;                

                switch (Math.Abs(this.Angle).ToString())

                {

                    case "90":

                        testP = new Point(endP.X + 50, endP.Y);

                        break;

                    case "270":

                        testP = new Point(endP.X - 50, endP.Y);

                        break;

                }                

                //20180910 LJY 각도에 따라.

                switch (Math.Abs(this.Angle).ToString())

                {

                    case "90":

                        if (isFixed)

                        {

                            if (ps[0] == endP) //상단

                            {

                                testP = new Point(endP.X , endP.Y + 50);

                                //System.Diagnostics.Debug.WriteLine("상단"+ testP);

                            }

                            else if (ps[1] == endP) //하단

                            {

                                testP = new Point(endP.X , endP.Y - 50);

                                //System.Diagnostics.Debug.WriteLine("하단"+ testP);

                            }

                            else if (ps[2] == endP) //좌단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("좌단"+ testP);

                            }

                            else if (ps[3] == endP) //우단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("우단"+ testP);

                            }

                        }

                        break;

                    case "270":

                        if (isFixed)

                        {

                            if (ps[0] == endP) //상단

                            {

                                testP = new Point(endP.X , endP.Y - 50);

                                //System.Diagnostics.Debug.WriteLine("상단" + testP);

                            }

                            else if (ps[1] == endP) //하단

                            {

                                testP = new Point(endP.X, endP.Y + 50);

                                //System.Diagnostics.Debug.WriteLine("하단" + testP);

                            }

                            else if (ps[2] == endP) //좌단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("좌단" + testP);

                            }

                            else if (ps[3] == endP) //우단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("우단" + testP);

                            }

                        }

                        break;

                    default:

                        if (isFixed)

                        {

                            if (ps[0] == endP) //상단

                            {

                                testP = new Point(endP.X, endP.Y - 50);

                                //System.Diagnostics.Debug.WriteLine("상단");

                            }

                            else if (ps[1] == endP) //하단

                            {

                                testP = new Point(endP.X, endP.Y + 50);

                                //System.Diagnostics.Debug.WriteLine("하단");

                            }

                            else if (ps[2] == endP) //좌단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("좌단");

                            }

                            else if (ps[3] == endP) //우단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("우단");

                            }

                        }

                        break;

                }

                connectorMEGeometry.EndPoint = endP;

                connectorSMGeometry.EndPoint = testP;

                connectorMEGeometry.StartPoint = testP;

                //20180910 LJY 각도에 따라.

                this.MidPoint = testP;

                //instanceGroup.Children.Add(SingleAllow(this.MidPoint, this.StartPoint, this.LineSize));

                instanceGroup.Children.Add(SingleAllow(testP, this.StartPoint, this.LineSize));

            }

            else

            {

                switch (Math.Abs(this.Angle).ToString())

                {

                    case "90":

                        {

                            ps.Clear();

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); // 위 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - this.BoxWidth)); // 위 오른쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth / 2)); //중간 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) + this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) - this.BoxWidth)); //오른쪽 중간 

                        }

                        break;

                    case "270":

                        {

                            ps.Clear();

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox))); //위 왼쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); // 위 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) + this.BoxWidth)); // 위 오른쪽

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox))); //왼쪽 중간

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox))); //왼쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth / 2)); //중간 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 하단

                            ps.Add(new Point(Canvas.GetLeft(Base_TextBox) - this.BoxHeight / 2, Canvas.GetTop(Base_TextBox) + this.BoxWidth)); //오른쪽 중간 

                        }

                        break;

                    default:

                        break;

                }

                var endP = MathSet.getNearPoint(ps, this.MidPoint);

                //connectorMEGeometry.EndPoint = endP;

                //connectorMEGeometry.EndPoint = endP;

                connectorMEGeometry.EndPoint = endP; //최상단

                                                     //connectorMEGeometry.EndPoint = this.EndPoint; //핵심

                                                     //this.MidPoint= MathSet.getMiddlePoint(this.StartPoint, endP);

                #region 보정치

                //enP는 그 점

                //Point testP = new Point(endP.X-100,endP.Y);

                Point testP = endP;

                //Point testP = new Point(endP.X, endP.Y - 50);

                /* 20180910 LJY TEST 주석

                if (isFixed)

                {

                    if (ps[0] == endP) //상단

                    {

                        testP = new Point(endP.X, endP.Y - 50);

                        //System.Diagnostics.Debug.WriteLine("상단");

                    }

                    else if (ps[1] == endP) //하단

                    {

                        testP = new Point(endP.X, endP.Y + 50);

                        //System.Diagnostics.Debug.WriteLine("하단");

                    }

                    else if (ps[2] == endP) //좌단

                    {

                        testP = new Point(endP.X - 50, endP.Y);

                        //System.Diagnostics.Debug.WriteLine("좌단");

                    }

                    else if (ps[3] == endP) //우단

                    {

                        testP = new Point(endP.X + 50, endP.Y);

                        //System.Diagnostics.Debug.WriteLine("우단");

                    }

                }

                */

                //20180910 LJY 각도에 따라.

                switch (Math.Abs(this.Angle).ToString())

                {

                    case "90":

                        if (isFixed)

                        {

                            if (ps[0] == endP) //상단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("상단"+ testP);

                            }

                            else if (ps[1] == endP) //하단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("하단"+ testP);

                            }

                            else if (ps[2] == endP) //좌단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("좌단"+ testP);

                            }

                            else if (ps[3] == endP) //우단

                            {

                                testP = new Point(endP.X + 50 , endP.Y);

                                //System.Diagnostics.Debug.WriteLine("우단"+ testP);

                            }

                        }

                        break;

                    case "270":

                        if (isFixed)

                        {

                            if (ps[0] == endP) //상단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("상단" + testP);

                            }

                            else if (ps[1] == endP) //하단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("하단" + testP);

                            }

                            else if (ps[2] == endP) //좌단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("좌단" + testP);

                            }

                            else if (ps[3] == endP) //우단

                            {

                                testP = new Point(endP.X + 50, endP.Y );

                                //System.Diagnostics.Debug.WriteLine("우단" + testP);

                            }

                        }

                        break;

                    default:

                        if (isFixed)

                        {

                            if (ps[0] == endP) //상단

                            {

                                testP = new Point(endP.X, endP.Y - 50);

                                //System.Diagnostics.Debug.WriteLine("상단");

                            }

                            else if (ps[1] == endP) //하단

                            {

                                testP = new Point(endP.X, endP.Y + 50);

                                //System.Diagnostics.Debug.WriteLine("하단");

                            }

                            else if (ps[2] == endP) //좌단

                            {

                                testP = new Point(endP.X - 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("좌단");

                            }

                            else if (ps[3] == endP) //우단

                            {

                                testP = new Point(endP.X + 50, endP.Y);

                                //System.Diagnostics.Debug.WriteLine("우단");

                            }

                        }

                        break;

                }

                connectorSMGeometry.EndPoint = testP;

                connectorMEGeometry.StartPoint = testP;

                //connectorSMGeometry.EndPoint = endP;

                //connectorMEGeometry.StartPoint = endP;

                instanceGroup.Children.Add(SingleAllow(testP, this.StartPoint, this.LineSize));

                #endregion

            }

            switch (this.ArrowTextStyle)

            {

                case ArrowTextStyleSet.Normal:

                    this.BorderSize = new Thickness(0);

                    break;

                case ArrowTextStyleSet.Cloud:

                    this.BorderSize = new Thickness(0);

                    DrawingCloud();

                    break;

                default:

                    {

                        this.BorderSize = new Thickness(LineSize); //올라

                        DrawingRect();

                    }

                    break;

            }

            if (isHighLight)

            {

                SubPathFill = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

                BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

                //Base_ArrowSubPath.Fill = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

                TextBoxBackground = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

                //Base_TextBox.Background = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));

            }

            else

            {

                BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

                SubPathFill = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

                TextBoxBackground = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.1), Colors.White.R, Colors.White.G, Colors.White.B));

                //Base_ArrowSubPath.Fill = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

                //Base_TextBox.Background = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

            }

            instanceGroup.Children.Add(connectorSMGeometry);

            instanceGroup.Children.Add(connectorMEGeometry);

            //이미 바인딩 되어있음

            //this.Base_ArrowPath.Stroke = this.StrokeColor;

            this.PathData = instanceGroup;

            OverViewPathData = PathData;

            OverViewArrowText = ArrowText;

            OverViewEndPoint = connectorMEGeometry.EndPoint;

            OverViewStartPoint = connectorSMGeometry.StartPoint;

            //OverViewText = Text;

            //Base_ArrowSubPath.Data = instanceSubGroup;

            //Angle = Math.Abs(this.Angle);

            var tempAngle = Math.Abs(this.Angle);

            if (tempAngle == Convert.ToDouble(90) || tempAngle == Convert.ToDouble(270))

            {

                ////this.Angle = 90;

                this.RenderTransformOrigin = new Point(0.5, 0.5);

                this.Base_ArrowPath.RenderTransformOrigin = new Point(0, 0);

                this.Base_ArrowSubPath.RenderTransformOrigin = new Point(0, 0);

                Base_TextBox.RenderTransformOrigin = new Point(0, 0);

            }

            Base_ArrowSubPath.RenderTransform = new RotateTransform

            {

                Angle = this.Angle,

                CenterX = this.EndPoint.X,

                CenterY = this.EndPoint.Y,

            };

            //Base_ArrowPath.StrokeThickness = 3;

            //Base_ArrowSubPath.StrokeThickness = 3;

        }

        private void DrawingCloud()

        {

            //20180906 LJY Textbox guide

            string angle = Math.Abs(this.Angle).ToString();

            if (angle == "180")

            {

                List<Point> pCloud = new List<Point>()

                {

                     new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위

                    new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox) - BoxHeight), //왼쪽 아래