/MarkupToPDF/Controls/Text/ArrowTextControl.cs - MARKUS - 일정관리

markus / MarkupToPDF / Controls / Text / ArrowTextControl.cs @ d2114d3b

       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;
       using MarkupToPDF.Serialize.Core;
       using MarkupToPDF.Serialize.S_Control;
       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();
               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_TextBox.SizeChanged += new SizeChangedEventHandler(Base_TextBox_SizeChanged);
                   Base_TextBox.GotFocus += new RoutedEventHandler(Base_TextBox_GotFocus);
                   Base_TextBox.LostFocus += new RoutedEventHandler(Base_TextBox_LostFocus);
                   SetArrowTextPath();
                   Base_TextBox.IsTabStop = true;
+              }
               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();
+              }
               #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 override 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 override bool IsSelected
+              {
                   get
+                  {
                       return (bool)GetValue(IsSelectedProperty);
+                  }
                   set
+                  {
                       SetValue(IsSelectedProperty, value);
                       OnPropertyChanged("IsSelected");
+                  }
+              }
               public override ControlType ControlType
+              {
                   set
+                  {
                       SetValue(ControlTypeProperty, value);
                       OnPropertyChanged("ControlType");
+                  }
                   get
+                  {
                       return (ControlType)GetValue(ControlTypeProperty);
+                  }
+              }
               public 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 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 EnableEditingProperty = DependencyProperty.Register(
                  "EnableEditing", typeof(bool), typeof(ArrowTextControl), new PropertyMetadata((true), new PropertyChangedCallback(OnIsEditingChanged)));
               #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)
+                      {
                           instance.EditingMode();
+                      }
                       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);
+              }
               private void SetArrowTextPath()
+              {
                   instanceGroup.Children.Clear();
                   connectorSMGeometry.StartPoint = this.StartPoint;
                   connectorSMGeometry.EndPoint = this.MidPoint;
                   connectorMEGeometry.StartPoint = this.MidPoint; //핵심
                   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));  //우단
                   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(DrawSet.DrawArrow(testP, this.StartPoint, this.LineSize));
                       instanceGroup.FillRule = FillRule.Nonzero;
                       this.Base_ArrowPath.Fill = this.StrokeColor;
                       this.Base_ArrowSubPath.Fill = this.StrokeColor;
+                  }
                   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 = this.EndPoint; //핵심
                                                            //this.MidPoint= MathSet.getMiddlePoint(this.StartPoint, endP);
                       #region 보정치
                       Point testP = endP;
                       //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;
                       instanceGroup.Children.Add(DrawSet.DrawArrow(testP, this.StartPoint, this.LineSize));
                       instanceGroup.FillRule = FillRule.Nonzero;
                       this.Base_ArrowPath.Fill = this.StrokeColor;
                       this.Base_ArrowSubPath.Fill = this.StrokeColor;
                       #endregion
+                  }
                   switch (this.ArrowTextStyle)
+                  {
                       case ArrowTextStyleSet.Normal:
                           this.BorderSize = new Thickness(0);
                           DrawingRect();
                           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));
                       TextBoxBackground = 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));
+                  }
                   instanceGroup.Children.Add(connectorSMGeometry);
                   instanceGroup.Children.Add(connectorMEGeometry);
                   this.PathData = instanceGroup;
                   OverViewPathData = PathData;
                   OverViewArrowText = ArrowText;
                   OverViewEndPoint = connectorMEGeometry.EndPoint;
                   OverViewStartPoint = connectorSMGeometry.StartPoint;
                   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,
                   };
+              }
               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), //왼쪽 아래
                           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)), //위
                       };
                       SubPathData = (Generate(pCloud));
                       PathDataInner = (GenerateInnerCloud(pCloud, angle));
                   }//20180906 LJY Textbox guide
                   else
+                  {
                       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));
                       SubPathData = (Generate(pCloud));
                       PathDataInner = (GenerateInnerCloud(pCloud, angle));
                       //   }
+                  }
+              }
               private void DrawingRect()
+              {
                   //20180906 LJY Textbox guide
                   if(this.ArrowTextStyle == ArrowTextStyleSet.Normal)
+                  {
                       this.Base_TextBox.BorderBrush = Brushes.Transparent;
+                  }
                   if (Math.Abs(this.Angle).ToString() == "90")
+                  {
                       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) - BoxWidth), //왼쪽 아래
                           new Point(Canvas.GetLeft(Base_TextBox) + BoxHeight, Canvas.GetTop(Base_TextBox) - BoxWidth),
                           new Point(Canvas.GetLeft(Base_TextBox) + BoxHeight, Canvas.GetTop(Base_TextBox)),
                           new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위
                       };
                       PathDataInner = (GenerateInner(pCloud));
+                  }
                   else if(Math.Abs(this.Angle).ToString() == "270")
+                  {
                       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) + BoxWidth), //왼쪽 아래
                           new Point(Canvas.GetLeft(Base_TextBox) - BoxHeight, Canvas.GetTop(Base_TextBox) + BoxWidth),
                           new Point(Canvas.GetLeft(Base_TextBox) - BoxHeight, Canvas.GetTop(Base_TextBox)),
                           new Point(Canvas.GetLeft(Base_TextBox), Canvas.GetTop(Base_TextBox)), //위
                       };
                       PathDataInner = (GenerateInner(pCloud));
                   }//20180906 LJY Textbox guide
                   else
+                  {
                       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));
                       PathDataInner = (GenerateInner(pCloud));
+                  }
+              }
               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);
+              }
               public override void ApplyOverViewData()
+              {
                   this.OverViewPathData = this.PathData;
                   if (ArrowText == "")
                       this.ArrowText = this.OverViewArrowText;
                   else
                       this.OverViewArrowText = this.ArrowText;
                   this.OverViewStartPoint = this.StartPoint;
                   this.OverViewEndPoint = this.EndPoint;
+              }
               #endregion
               public static PathFigure GenerateLineWithCloud(Point p1, Point p2, double arcLength_, bool reverse)
+              {
                   PathFigure pathFigure = new PathFigure();
                   pathFigure.StartPoint = p1;
                   double arcLength = arcLength_;
                   /// draw arcs which has arcLength between p1 and p2 - 2012.06.21 added by humkyung
                   double dx = p2.X - p1.X;
                   double dy = p2.Y - p1.Y;
                   double l = MathSet.DistanceTo(p1, p2); /// distance between p1 and p2
                   double theta = Math.Atan2(Math.Abs(dy), Math.Abs(dx)) * 180 / Math.PI;
                   Point lastPt = new Point(p1.X, p1.Y);
                   double count = l / arcLength;
                   /// normalize
                   dx /= l;
                   dy /= l;
                   Double j = 1;
                   for (j = 1; j < (count - 1); j++)
+                  {
                       ArcSegment arcSeg = new ArcSegment();
                       arcSeg.Size = new Size(arcLength * _CloudArcDepth, arcLength * _CloudArcDepth);						/// x size and y size of arc
                       arcSeg.Point = new Point(p1.X + j * dx * arcLength, p1.Y + j * dy * arcLength);	/// end point of arc
                       lastPt = arcSeg.Point;  /// save last point
                       arcSeg.RotationAngle = theta + 90;
                       if (true == reverse) arcSeg.SweepDirection = SweepDirection.Clockwise;
                       pathFigure.Segments.Add(arcSeg);
+                  }
                   /// draw arc between last point and end point
                   if ((count > j) || (count > 0))
+                  {
                       arcLength = MathSet.DistanceTo(lastPt, p2);
                       ArcSegment arcSeg = new ArcSegment();
                       arcSeg.Size = new Size(arcLength * _CloudArcDepth, arcLength * _CloudArcDepth);	/// x size and y size of arc
                       arcSeg.Point = new Point(p2.X, p2.Y);						/// end point of arc
                       arcSeg.RotationAngle = theta;
                       if (true == reverse) arcSeg.SweepDirection = SweepDirection.Clockwise;
                       pathFigure.Segments.Add(arcSeg);
+                  }
                   /// up to here
                   return pathFigure;
+              }
               public static PathGeometry Generate(List<Point> pData)
+              {
                   var _pathGeometry = new PathGeometry();
                   double area = MathSet.AreaOf(pData);
                   bool reverse = (area > 0);
                   int count = pData.Count;
                   for (int i = 0; i < (count - 1); i++)
+                  {
                       PathFigure pathFigure = GenerateLineWithCloud(pData[i], pData[i + 1], 20, reverse);
                       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];
                   LineSegment lineSegment0 = new LineSegment();
                   lineSegment0.Point = pData[0];
                   pathFigur2.Segments.Add(lineSegment0);
                   LineSegment lineSegment1 = new LineSegment();
                   lineSegment1.Point = pData[1];
                   pathFigur2.Segments.Add(lineSegment1);
                   LineSegment lineSegment2 = new LineSegment();
                   lineSegment2.Point = pData[2];
                   pathFigur2.Segments.Add(lineSegment2);
                   LineSegment lineSegment3 = new LineSegment();
                   lineSegment3.Point = pData[3];
                   pathFigur2.Segments.Add(lineSegment3);
                   pathFigur2.IsClosed = true;
                   pathFigur2.IsFilled = true;
                   _pathGeometry.Figures.Add(pathFigur2);
                   return _pathGeometry;
+              }
               //20180910 LJY Cloud rotation 추가
               public static PathGeometry GenerateInnerCloud(List<Point> pData, string angle)
+              {
                   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];
                   LineSegment lineSegment0 = new LineSegment();
                   lineSegment0.Point = pData[0];
                   pathFigur2.Segments.Add(lineSegment0);
                   LineSegment lineSegment1 = new LineSegment();
                   lineSegment1.Point = pData[1];
                   pathFigur2.Segments.Add(lineSegment1);
                   LineSegment lineSegment2 = new LineSegment();
                   lineSegment2.Point = pData[2];
                   pathFigur2.Segments.Add(lineSegment2);
                   LineSegment lineSegment3 = new LineSegment();
                   lineSegment3.Point = pData[3];
                   pathFigur2.Segments.Add(lineSegment3);
                   RotateTransform transform = new RotateTransform();
                   switch (angle)
+                  {
                       case "90":
                           transform.Angle = -90;
                           break;
                       case "180":
                           transform.Angle = -180;
                           break;
                       case "270":
                           transform.Angle = -270;
                           break;
+                  }
                   transform.CenterX = pData[0].X;
                   transform.CenterY = pData[0].Y;
                   _pathGeometry.Transform = transform;
                   pathFigur2.IsClosed = true;
                   pathFigur2.IsFilled = true;
                   _pathGeometry.Figures.Add(pathFigur2);
                   return _pathGeometry;
+              }
               /// <summary>
               /// call when mouse is moving while drawing control
               /// </summary>
               /// <author>humkyung</author>
               /// <param name="pt"></param>
               /// <param name="bAxisLocked"></param>
               public override void OnCreatingMouseMove(Point pt, bool bAxisLocked, bool bShiftKeyPressed)
+              {
                   this.EndPoint = pt;
                   if (bAxisLocked || bShiftKeyPressed)
+                  {
                       Point tempPoint = this.EndPoint;
                       string angle = MathSet.returnAngleString(this.StartPoint, ref tempPoint, true);
                       this.EndPoint = tempPoint;
+                  }
                   this.MidPoint = MathSet.getMiddlePoint(this.StartPoint, this.EndPoint);
                   this.isFixed = (this.ControlType == ControlType.ArrowTransTextControl) ||
                       (this.ControlType == ControlType.ArrowTransTextBorderControl) || (this.ControlType == ControlType.ArrowTransTextCloudControl);
                   this.PointSet = new List<Point>
+                  {
                       this.StartPoint,
                       this.MidPoint,
                       this.EndPoint,
                   };
+              }
               /// <summary>
               /// move control point has same location of given pt along given delta
               /// </summary>
               /// <author>humkyung</author>
               /// <date>2019.06.20</date>
               /// <param name="pt"></param>
               /// <param name="dx"></param>
               /// <param name="dy"></param>
               public override void OnMoveCtrlPoint(Point pt, double dx, double dy)
+              {
                   IPath path = (this as IPath);
                   Point selected = MathSet.getNearPoint(path.PointSet, pt);
                   selected.X += dx;
                   selected.Y += dy;
                   int i = 0;
                   for (i = 0; i < (this as IPath).PointSet.Count; i++)
+                  {
                       if (pt.Equals((this as IPath).PointSet[i])) break;
+                  }
                   List<Point> pts = path.PointSet;
                   if ((pts[0].X > pts[1].X && dx > 0) || (pts[0].X < pts[1].X && dx < 0))
+                  {
                       pts[1] = new Point(pts[1].X + dx, pts[1].Y);
+                  }
                   if ((pts[0].Y > pts[1].Y && dy > 0) || (pts[0].Y < pts[1].Y && dy < 0))
+                  {
                       pts[1] = new Point(pts[1].X, pts[1].Y + dy);
+                  }
                   path.PointSet[1] = pts[1];
                   path.PointSet[i] = selected;
                   this.updateControl();
+              }
               /// <summary>
               /// return ArrowTextControl's area
               /// </summary>
               /// <author>humkyung</author>
               /// <date>2019.06.13</date>
               public override Rect ItemRect
+              {
                   get
+                  {
                       double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);
                       double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);
                       double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);
                       double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);
                       return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
+                  }
+              }
               /// <summary>
               /// Serialize this
               /// </summary>
               /// <param name="sUserId"></param>
               /// <returns></returns>
               public override string Serialize()
+              {
                   using (S_ArrowTextControl STemp = new S_ArrowTextControl())
+                  {
                       STemp.TransformPoint = "0|0";
                       STemp.PointSet = this.PointSet;
                       STemp.SizeSet = String.Format("{0}", this.LineSize);
                       STemp.StrokeColor = this.StrokeColor.Color.ToString();
                       STemp.StartPoint = this.StartPoint;
                       STemp.ArrowStyle = this.ArrowTextStyle;
                       //STemp.StrokeColor = "#FF00FF00";
                       STemp.UserID = this.UserID;
                       STemp.ArrowText = this.Base_TextBox.Text;
                       STemp.BorderSize = this.BorderSize;
                       STemp.isHighLight = this.isHighLight;
                       STemp.BoxHeight = this.BoxHeight;
                       STemp.BoxWidth = this.BoxWidth;
                       STemp.Opac = this.Opacity;
                       STemp.EndPoint = this.EndPoint;
                       STemp.isFixed = this.isFixed;
                       //STemp.DashSize = this.DashSize;
                       STemp.Name = this.GetType().Name.ToString();
                       STemp.isTrans = this.isTrans;
                       STemp.MidPoint = this.MidPoint;
                       STemp.Angle = this.Angle;
                       STemp.fontConfig = new List<string>()
+                                  {
                                       this.TextFamily.ToString(),
                                       this.TextStyle.ToString(),
                                       this.TextWeight.ToString(),
                                       this.TextSize.ToString(),
                                   };
                       if (this.UnderLine != null)
+                      {
                           STemp.fontConfig.Add("true");
+                      }
                       ///강인구 추가(2017.11.02)
                       ///Memo 추가
                       STemp.Memo = this.Memo;
                       STemp.BorderSize = this.BorderSize;
                       return "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));
                   };
+              }
               /// <summary>
               /// create a arrowtextcontrol from given string
               /// </summary>
               /// <param name="str"></param>
               /// <returns></returns>
               public static ArrowTextControl FromString(string str, SolidColorBrush brush, string sProjectNo)
+              {
                   ArrowTextControl instance = null;
                   using (S_ArrowTextControl s = JsonSerializerHelper.JsonDeserialize<S_ArrowTextControl>(str))
+                  {
                       string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);
                       instance = new ArrowTextControl();
                       instance.LineSize = Convert.ToDouble(data2.First());
                       instance.PointSet = s.PointSet;
                       instance.StartPoint = s.StartPoint;
                       instance.EndPoint = s.EndPoint;
                       instance.StrokeColor = brush;
                       //instance.DashSize = s.DashSize;
                       instance.ArrowTextStyle = s.ArrowStyle;
                       instance.isHighLight = s.isHighLight;
                       instance.ArrowText = s.ArrowText;
                       instance.Opacity = s.Opac;
                       instance.BorderSize = s.BorderSize;
                       instance.BoxWidth = s.BoxWidth;
                       instance.BoxHeight = s.BoxHeight;
                       instance.isFixed = s.isFixed;
                       instance.Angle = s.Angle;
                       instance.UserID = s.UserID;
                       instance.isTrans = s.isTrans;
                       instance.MidPoint = s.MidPoint;
                       instance.Memo = s.Memo;
                       if (s.fontConfig == null || s.fontConfig.ToList().Count == 0)
+                      {
                           s.fontConfig = new List<string>();
                           s.fontConfig.Add("Arial");
                           s.fontConfig.Add("Normal");
                           s.fontConfig.Add("Normal");
                           s.fontConfig.Add("30");
+                      }
                       instance.TextFamily = new FontFamily(s.fontConfig[0]);
                       //인구 추가(2018.04.17)
                       instance.TextStyle = StringToFont.ConFontStyle(s.fontConfig[1]);
                       instance.TextWeight = StringToFont.ConFontWeight(s.fontConfig[2]);
                       instance.TextSize = Convert.ToDouble(s.fontConfig[3]);
                       if (s.fontConfig.Count() == 5)
+                      {
                           instance.UnderLine = TextDecorations.Underline;
+                      }
+                  }
                   return instance;
+              }
               #region Dispose
               public void Dispose()
+              {
                   GC.Collect();
                   GC.SuppressFinalize(this);
+              }
               #endregion
               #region INotifyPropertyChanged
               private void OnPropertyChanged(string name)
+              {
                   if (PropertyChanged != null)
+                  {
                       PropertyChanged(this, new PropertyChangedEventArgs(name));
+                  }
+              }
               public event PropertyChangedEventHandler PropertyChanged;
               #endregion
+          }
+      }

프로젝트

일반

사용자정보

MARKUS

markus / MarkupToPDF / Controls / Text / ArrowTextControl.cs @ d2114d3b