/MarkupToPDF_Old/Controls/Text/TextControl.cs - 이력해설 - MARKUS - 일정관리

markus / MarkupToPDF_Old / Controls / Text / TextControl.cs @ b3fb7321

-a4489
+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;
 namespace MarkupToPDF.Controls.Text
+{
     public class TextControl : Control, INotifyPropertyChanged, IMarkupControlData
+    {
         public event PropertyChangedEventHandler PropertyChanged;
         private const string PART_Grid = "PART_Grid";
         private const string PART_Border = "PART_Border";
         private const string PART_TextBox = "PART_TextBox";
         private const string PART_TextPath = "PART_TextPath";
         private const string PART_TextBlock = "PART_TextBlock";
         //private const string PART_TextPrefix = "PART_TextPrefix";
         public Path Base_TextPath = null;
         public Grid Base_Grid = null;
         public Border Base_Border = null;
         //public TextBlock Base_TextPrefixBlock = null;
         public TextBlock Base_TextBlock = null;
         public TextBox Base_TextBox = null;
         public RotateTransform _rotation = null;
         public TranslateTransform _translation = null;
         public ScaleTransform _scale = null;
         public bool IsSelected
+        {
             get
+            {
                 return (bool)GetValue(IsSelectedProperty);
+            }
             set
+            {
                 SetValue(IsSelectedProperty, value);
                 OnPropertyChanged("IsSelected");
+            }
+        }
         #region Internal Method
         public TextControl()
+        {
             this.DefaultStyleKey = typeof(TextControl);
+        }
         static TextControl()
+        {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(TextControl), new FrameworkPropertyMetadata(typeof(TextControl)));
             ResourceDictionary dictionary = new ResourceDictionary();
             dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);
             Application.Current.Resources.MergedDictionaries.Add(dictionary);
+        }
         public override void OnApplyTemplate()
+        {
             base.OnApplyTemplate();
             Base_TextPath = GetTemplateChild(PART_TextPath) as Path;
             Base_TextBox = GetTemplateChild(PART_TextBox) as TextBox;
             Base_TextBlock = GetTemplateChild(PART_TextBlock) as TextBlock;
             Base_Grid = GetTemplateChild(PART_Grid) as Grid;
             Base_Border = GetTemplateChild(PART_Border) as Border;
             //Base_TextPrefixBlock = GetTemplateChild(PART_TextPrefix) as TextBlock;
             //Canvas.SetLeft(this, this.StartPoint.X);
             //Canvas.SetTop(this, this.StartPoint.Y);
             //CanvasX = StartPoint.X;
             //CanvasY = StartPoint.Y;
             this.LostFocus += new RoutedEventHandler(TextControl_LostFocus);
             this.GotFocus += new RoutedEventHandler(TextControl_GotFocus);
             this.Base_TextBox.SizeChanged += new SizeChangedEventHandler(Base_TextBox_SizeChanged);
             this.Base_TextBlock.SizeChanged += Base_TextBlock_SizeChanged;
             this.MouseDown += TextControl_MouseDown;
             SetText();
             Base_TextBox.Focus();
+        }
         public void ApplyOverViewData()
+        {
             this.OverViewPathData = this.PathData;
             this.OverViewText = this.Text;
             this.OverViewPaint = this.Paint;
+        }
         void Base_TextBlock_SizeChanged(object sender, SizeChangedEventArgs e)
+        {
             this.Text = Base_TextBox.Text;
             BoxWidth = e.NewSize.Width;
             BoxHeight = e.NewSize.Height;
             this.ApplyTemplate();
             DrawingCloud();
+        }
         void TextControl_MouseDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
+        {
             this.Focus();
+        }
         void Base_TextBox_SizeChanged(object sender, SizeChangedEventArgs e)
+        {
             this.Text = Base_TextBox.Text;
             BoxWidth = e.NewSize.Width;
             BoxHeight = e.NewSize.Height;
             this.ApplyTemplate();
             DrawingCloud();
+        }
         void TextControl_GotFocus(object sender, RoutedEventArgs e)
+        {
             if (EnableEditing)
+            {
                 IsEditing = true;
                 EditingMode();
+            }
             else
+            {
                 IsEditing = false;
                 UnEditingMode();
+            }
+        }
         void TextControl_LostFocus(object sender, RoutedEventArgs e)
+        {
             IsEditing = false;
             UnEditingMode();
             ApplyOverViewData();
+        }
         public void EditingMode()
+        {
             TextBoxVisibility = Visibility.Visible;
             //Base_TextBox.Visibility = System.Windows.Visibility.Visible;
             TextBlockVisibility = Visibility.Collapsed;
             //Base_TextBlock.Visibility = System.Windows.Visibility.Collapsed;
             this.Base_TextBox.BorderThickness = new Thickness(1);
             if (UnderLine != null)
                 Base_TextBlock.TextDecorations = UnderLine;
             if (this.Text != null)
                 Base_TextBox.Text = this.Text;
+        }
         public void UnEditingMode()
+        {
             if (EnableEditing)
                 this.Text = Base_TextBox.Text;
             TextBoxVisibility = Visibility.Collapsed;
             //Base_TextBox.Visibility = System.Windows.Visibility.Collapsed;
             TextBlockVisibility = Visibility.Visible;
             //Base_TextBlock.Visibility = System.Windows.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);
+        }
         public void SetText()
+        {
             this.ApplyTemplate();
             if (IsHighLight)
+            {
                 this.BackColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6),
                     Colors.Yellow.R, Colors.Yellow.G, Colors.Yellow.B));
+            }
             else
+            {
                 this.BackColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6),
                     Colors.White.R, Colors.White.G, Colors.White.B));
+            }
             OverViewPathData = PathData;
             OverViewText = Text;
+        }
         public void DrawingCloud()
+        {
             this.ApplyTemplate();
             //pathGeometry = new PathGeometry();
             List<Point> pCloud = new List<Point>
+            {
                 new Point(0, 0),
                 new Point(0, 0 + BoxHeight + 2),
                 new Point(0 + BoxWidth + 4, 0 + BoxHeight + 2),
                 new Point(0 + BoxWidth + 4 ,0),
                 new Point(0, 0)
             };
             if (Base_TextPath != null)
+            {
                 switch (ControlType_No)
+                {
                     case 1:
+                        {
                             PathData = (Generate_Rect(pCloud));
+                        }
                         break;
                     case 2:
+                        {
                             PathData = (Generate(pCloud));
+                        }
                         break;
+                }
+            }
             SetText();
+        }
         #endregion Internal Method
         #region Drawing Cloud Method
         public static PathGeometry Generate_Rect(List<Point> pData)
+        {
             PathFigure pathFigure = new PathFigure();
             pathFigure.StartPoint = pData[0];
             LineSegment lineSegment0 = new LineSegment();
             lineSegment0.Point = pData[0];
             pathFigure.Segments.Add(lineSegment0);
             LineSegment lineSegment1 = new LineSegment();
             lineSegment1.Point = pData[1];
             pathFigure.Segments.Add(lineSegment1);
             LineSegment lineSegment2 = new LineSegment();
             lineSegment2.Point = pData[2];
             pathFigure.Segments.Add(lineSegment2);
             LineSegment lineSegment3 = new LineSegment();
             lineSegment3.Point = pData[3];
             pathFigure.Segments.Add(lineSegment3);
             PathGeometry rectPathGeometry = new PathGeometry();
             rectPathGeometry.Figures = new PathFigureCollection();
             pathFigure.IsClosed = true;
             pathFigure.IsFilled = false;
             rectPathGeometry.Figures.Add(pathFigure);
             return rectPathGeometry;
+        }
         public static PathGeometry Generate(List<Point> pData)
+        {
             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 PathFigure GenerateLineWithCloud(Point p1, Point p2, double _arcLength, bool reverse)
+        {
             PathFigure pathFigure = new PathFigure();
             pathFigure.StartPoint = p1;
             double arcLength = _arcLength;
             double dx = p2.X - p1.X;
             double dy = p2.Y - p1.Y;
             double l = MathSet.DistanceTo(p1, 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;
             dx /= l;
             dy /= l;
             Double j = 1;
             for (j = 1; j < (count - 1); j++)
+            {
                 ArcSegment arcSeg = new ArcSegment();
                 arcSeg.Size = new Size(arcLength * 0.8, arcLength * 0.8);
                 arcSeg.Point = new Point(p1.X + j * dx * arcLength, p1.Y + j * dy * arcLength);
                 lastPt = arcSeg.Point;
                 arcSeg.RotationAngle = theta + 90;
                 if (true == reverse)
                     arcSeg.SweepDirection = SweepDirection.Clockwise;
                 pathFigure.Segments.Add(arcSeg);
+            }
             if ((count > j) || count > 0)
+            {
                 arcLength = MathSet.DistanceTo(lastPt, p2);
                 ArcSegment arcSeg = new ArcSegment();
                 arcSeg.Size = new Size(arcLength * 0.8, arcLength * 0.8);
                 arcSeg.Point = new Point(p2.X, p2.Y);
                 arcSeg.RotationAngle = theta;
                 if (true == reverse)
                     arcSeg.SweepDirection = SweepDirection.Clockwise;
                 pathFigure.Segments.Add(arcSeg);
+            }
             return pathFigure;
+        }
         #endregion
         #region Dependency Properties
         public static readonly DependencyProperty ControlTypeProperty =
         DependencyProperty.Register("ControlType", typeof(ControlType), typeof(TextControl), new FrameworkPropertyMetadata(ControlType.TextControl));
         public static readonly DependencyProperty ControlType_NoProperty =
         DependencyProperty.Register("ControlType_No", typeof(int), typeof(TextControl), new FrameworkPropertyMetadata(0));
         public static readonly DependencyProperty IsSelectedProperty = DependencyProperty.Register(
             "IsSelected", typeof(bool), typeof(TextControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));
         public static readonly DependencyProperty PathGeometryProperty = DependencyProperty.Register(
             "PathGeometry", typeof(PathGeometry), typeof(TextControl), new PropertyMetadata(null, SetPathGeometryChanged));
         public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
             "Text", typeof(string), typeof(TextControl), new PropertyMetadata(null));
         public static readonly DependencyProperty OverViewTextProperty = DependencyProperty.Register(
             "OverViewText", typeof(string), typeof(TextControl), new PropertyMetadata(null));
         public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(
             "UserID", typeof(string), typeof(TextControl), new PropertyMetadata(null));
         public static readonly DependencyProperty FontColorProperty = DependencyProperty.Register(
             "FontColor", typeof(SolidColorBrush), typeof(TextControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));
         public static readonly DependencyProperty IsHighlightProperty = DependencyProperty.Register(
             "IsHighLight", typeof(bool), typeof(TextControl), new PropertyMetadata(false));
         public static readonly DependencyProperty BackColorProperty = DependencyProperty.Register(
             "BackColor", typeof(SolidColorBrush), typeof(TextControl), new PropertyMetadata(new SolidColorBrush(Colors.White)));
         public static readonly DependencyProperty UnderLineProperty = DependencyProperty.Register(
             "UnderLine", typeof(TextDecorationCollection), typeof(TextControl), new PropertyMetadata(null));
         public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(
             "LineSize", typeof(Thickness), typeof(TextControl), new PropertyMetadata(new Thickness(4)));
         public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(
             "PointSet", typeof(List<Point>), typeof(TextControl), new PropertyMetadata(new List<Point>()));
         public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(
             "PathData", typeof(Geometry), typeof(TextControl), null);
         public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(
             "OverViewPathDataProperty", typeof(Geometry), typeof(TextControl), null);
         public static readonly DependencyProperty TextStyleProperty = DependencyProperty.Register(
             "TextStyle", typeof(FontStyle), typeof(TextControl), new PropertyMetadata(FontStyles.Normal));
         public static readonly DependencyProperty TextFamilyProperty = DependencyProperty.Register(
             "TextFamily",typeof(FontFamily), typeof(TextControl), new PropertyMetadata(new FontFamily("Arial")));
         public static readonly DependencyProperty TextWeightProperty = DependencyProperty.Register(
             "TextWeight", typeof(FontWeight), typeof(TextControl), new PropertyMetadata(FontWeights.Normal));
         public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register(
             "CenterX", typeof(double), typeof(TextControl), new PropertyMetadata((double)0, OnCenterXYChanged));
         public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register(
             "CenterY", typeof(double), typeof(TextControl), new PropertyMetadata((double)0, OnCenterXYChanged));
         public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(
            "CanvasX", typeof(double), typeof(TextControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(
             "CanvasY", typeof(double), typeof(TextControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(
               "StartPoint", typeof(Point), typeof(TextControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(
              "EndPoint", typeof(Point), typeof(TextControl), new PropertyMetadata(new Point(100, 100), PointValueChanged));
         public static readonly DependencyProperty TextSizeProperty = DependencyProperty.Register(
                "TextSize", typeof(Double), typeof(TextControl), new PropertyMetadata((Double)20, PointValueChanged));
         public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(
                 "Paint", typeof(PaintSet), typeof(TextControl), new PropertyMetadata((PaintSet.None), PointValueChanged));
         public static readonly DependencyProperty OverViewPaintProperty = DependencyProperty.Register(
                 "OverViewPaint", typeof(PaintSet), typeof(TextControl), new PropertyMetadata((PaintSet.None), PointValueChanged));
         public static readonly DependencyProperty AngleProperty = DependencyProperty.Register(
             "Angle", typeof(double), typeof(TextControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));
         public static readonly DependencyProperty IsEditingProperty = DependencyProperty.Register(
            "IsEditing", typeof(bool), typeof(TextControl), new PropertyMetadata((false), new PropertyChangedCallback(OnIsEditingChanged)));
         public static readonly DependencyProperty EnableEditingProperty = DependencyProperty.Register(
            "EnableEditing", typeof(bool), typeof(TextControl), new PropertyMetadata((true)));
         public static readonly DependencyProperty TextBoxVisibilityProperty = DependencyProperty.Register(
         "TextBoxVisibility", typeof(Visibility), typeof(TextControl), new PropertyMetadata((Visibility.Visible), OnTextBoxVisibilityChanged));
         public static readonly DependencyProperty TextBlockVisibilityProperty = DependencyProperty.Register(
         "TextBlockVisibility", typeof(Visibility), typeof(TextControl), new PropertyMetadata((Visibility.Collapsed), OnTextBlockVisibilityChanged));
         #endregion Dependency Properties
         #region dp Properties
         public 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");
+                }
+            }
+        }
         public Thickness LineSize
+        {
             get { return (Thickness)GetValue(LineSizeProperty); }
             set
+            {
                 if (this.LineSize != value)
+                {
                     SetValue(LineSizeProperty, value);
                     OnPropertyChanged("LineSize");
+                }
+            }
+        }
         public ControlType ControlType
+        {
             get
+            {
                 return (ControlType)GetValue(ControlTypeProperty);
+            }
             set
+            {
                 SetValue(ControlTypeProperty, value);
+            }
+        }
         public int ControlType_No
+        {
             get
+            {
                 return (int)GetValue(ControlType_NoProperty);
+            }
             set
+            {
                 SetValue(ControlType_NoProperty, value);
+            }
+        }
         public string UserID
+        {
             get { return (string)GetValue(UserIDProperty); }
             set
+            {
                 if (this.UserID != value)
+                {
                     SetValue(UserIDProperty, value);
                     OnPropertyChanged("UserID");
+                }
+            }
+        }
         public double CenterX
+        {
             get { return (double)GetValue(CenterXProperty); }
             set { SetValue(CenterXProperty, value);
             OnPropertyChanged("CenterX");
+            }
+        }
         public double CenterY
+        {
             get { return (double)GetValue(CenterYProperty); }
             set { SetValue(CenterYProperty, value);
             OnPropertyChanged("CenterY");
+            }
+        }
         public string Text
+        {
             get { return (string)GetValue(TextProperty); }
             set
+            {
                 if (this.Text != value)
+                {
                     SetValue(TextProperty, value);
                     OnPropertyChanged("Text");
+                }
+            }
+        }
         public string OverViewText
+        {
             get { return (string)GetValue(OverViewTextProperty); }
             set
+            {
                 if (this.OverViewText != value)
+                {
                     SetValue(OverViewTextProperty, value);
                     OnPropertyChanged("OverViewText");
+                }
+            }
+        }
         public Geometry OverViewPathData
+        {
             get { return (Geometry)GetValue(OverViewPathDataProperty); }
             set
+            {
                 if (this.OverViewPathData != value)
+                {
                     SetValue(OverViewPathDataProperty, value);
                     OnPropertyChanged("OverViewPathData");
+                }
+            }
+        }
         public Visibility TextBoxVisibility
+        {
             get { return (Visibility)GetValue(TextBoxVisibilityProperty); }
             set
+            {
                 if (this.TextBoxVisibility != value)
+                {
                     SetValue(TextBoxVisibilityProperty, value);
                     OnPropertyChanged("TextBoxVisibility");
+                }
+            }
+        }
         public Visibility TextBlockVisibility
+        {
             get { return (Visibility)GetValue(TextBlockVisibilityProperty); }
             set
+            {
                 if (this.TextBlockVisibility != value)
+                {
                     SetValue(TextBlockVisibilityProperty, value);
                     OnPropertyChanged("TextBlockVisibility");
+                }
+            }
+        }
         public Double TextSize
+        {
             get { return (Double)GetValue(TextSizeProperty); }
             set
+            {
                 if (this.TextSize != value)
+                {
                     SetValue(TextSizeProperty, value);
                     OnPropertyChanged("TextSize");
+                }
+            }
+        }
         public SolidColorBrush FontColor
+        {
             get { return (SolidColorBrush)GetValue(FontColorProperty); }
             set
+            {
                 if (this.FontColor != value)
+                {
                     SetValue(FontColorProperty, value);
                     OnPropertyChanged("FontColor");
+                }
+            }
+        }
         public SolidColorBrush BackColor
+        {
             get { return (SolidColorBrush)GetValue(BackColorProperty); }
             set
+            {
                 if (this.BackColor != value)
+                {
                     SetValue(BackColorProperty, value);
                     OnPropertyChanged("BackColor");
+                }
+            }
+        }
         public TextDecorationCollection UnderLine
+        {
             get
+            {
                 return (TextDecorationCollection)GetValue(UnderLineProperty);
+            }
             set
+            {
                 if (this.UnderLine != value)
+                {
                     SetValue(UnderLineProperty, value);
                     OnPropertyChanged("UnderLine");
+                }
+            }
+        }
         public double CanvasX
+        {
             get { return (double)GetValue(CanvasXProperty); }
             set
+            {
                 if (this.CanvasX != value)
+                {
                     SetValue(CanvasXProperty, value);
                     OnPropertyChanged("CanvasX");
+                }
+            }
+        }
         public double CanvasY
+        {
             get { return (double)GetValue(CanvasYProperty); }
             set
+            {
                 if (this.CanvasY != value)
+                {
                     SetValue(CanvasYProperty, value);
                     OnPropertyChanged("CanvasY");
+                }
+            }
+        }
         public Point EndPoint
+        {
             get { return (Point)GetValue(EndPointProperty); }
             set
+            {
                 if (this.EndPoint != value)
+                {
                     SetValue(EndPointProperty, value);
                     OnPropertyChanged("EndPoint");
+                }
+            }
+        }
         public Point StartPoint
+        {
             get { return (Point)GetValue(StartPointProperty); }
             set
+            {
                 if (this.StartPoint != value)
+                {
                     SetValue(StartPointProperty, value);
                     OnPropertyChanged("StartPoint");
+                }
+            }
+        }
         public FontStyle TextStyle
+        {
             get { return (FontStyle)GetValue(TextStyleProperty); }
             set
+            {
                 if (this.TextStyle != value)
+                {
                     SetValue(TextStyleProperty, value);
                     OnPropertyChanged("TextStyle");
+                }
+            }
+        }
         public FontFamily TextFamily
+        {
             get { return (FontFamily)GetValue(TextFamilyProperty); }
             set
+            {
                 if (this.TextFamily != value)
+                {
                     SetValue(TextFamilyProperty, value);
                     OnPropertyChanged("TextFamily");
+                }
+            }
+        }
         public FontWeight TextWeight
+        {
             get { return (FontWeight)GetValue(TextWeightProperty); }
             set
+            {
                 if (this.TextWeight != value)
+                {
                     SetValue(TextWeightProperty, value);
                     OnPropertyChanged("TextWeight");
+                }
+            }
+        }
         public PaintSet Paint
+        {
             get { return (PaintSet)GetValue(PaintProperty); }
             set
+            {
                 if (this.Paint != value)
+                {
                     SetValue(PaintProperty, value);
                     OnPropertyChanged("Paint");
+                }
+            }
+        }
         public PaintSet OverViewPaint
+        {
             get { return (PaintSet)GetValue(OverViewPaintProperty); }
             set
+            {
                 if (this.OverViewPaint != value)
+                {
                     SetValue(OverViewPaintProperty, value);
                     OnPropertyChanged("OverViewPaint");
+                }
+            }
+        }
         public Geometry PathData
+        {
             get { return (Geometry)GetValue(PathDataProperty); }
             set { SetValue(PathDataProperty, value);
             OnPropertyChanged("PathData");
+            }
+        }
         public double Angle
+        {
             get { return (double)GetValue(AngleProperty); }
             set
+            {
                 if (this.Angle != value)
+                {
                     SetValue(AngleProperty, value);
                     OnPropertyChanged("Angle");
                     UpdateLayout();
+                }
+            }
+        }
         public bool IsHighLight
+        {
             get { return (bool)GetValue(IsHighlightProperty); }
             set
+            {
                 if (this.IsHighLight != value)
+                {
                     SetValue(IsHighlightProperty, value);
                     OnPropertyChanged("IsHighLight");
+                }
+            }
+        }
         public List<Point> PointSet
+        {
             get { return (List<Point>)GetValue(PointSetProperty); }
             set { SetValue(PointSetProperty, value);
             OnPropertyChanged("PointSet");
+            }
+        }
         #endregion Properties
         #region Properties
         public PathGeometry PathGeometry
+        {
             get { return (PathGeometry)GetValue(PathGeometryProperty); }
             set
+            {
                 SetValue(PathGeometryProperty, value);
                 OnPropertyChanged("PathGeometry");
+            }
+        }
         private double _BoxWidth;
         public double BoxWidth
+        {
             get
+            {
                 return _BoxWidth;
+            }
             set
+            {
                 _BoxWidth = value;
                 OnPropertyChanged("BoxWidth");
+            }
+        }
         private double _BoxHeight;
         public double BoxHeight
+        {
             get
+            {
                 return _BoxHeight;
+            }
             set
+            {
                 _BoxHeight = value;
                 OnPropertyChanged("BoxHeight");
+            }
+        }
         #endregion
         #region CallBack Method
         public static void SetPathGeometryChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_TextPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
+            }
+        }
         public static void OnTextBoxVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_TextPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
+            }
+        }
         public static void OnTextBlockVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_TextPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
+            }
+        }
         public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_Border != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 if (instance.IsSelected)
+                {
                     instance.Base_Border.BorderBrush = new SolidColorBrush(Colors.Blue);
+                }
                 else
+                {
                     instance.Base_Border.BorderBrush = new SolidColorBrush(Colors.Transparent);
+                }
+            }
+        }
         public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 Canvas.SetLeft(instance, instance.CanvasX);
                 Canvas.SetTop(instance, instance.CanvasY);
+            }
+        }
         public static void OnIsEditingChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_TextBlock != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 if (instance.EnableEditing)
+                {
                     if (instance.IsEditing)
+                    {
                         instance.EditingMode();
+                    }
                     else
+                    {
                         instance.UnEditingMode();
+                    }
+                }
                 else
+                {
                     instance.UnEditingMode();
+                }
+            }
+        }
         public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_TextBlock != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetText();
+            }
+        }
         public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_TextBlock != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetText();
+            }
+        }
         public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (TextControl)sender;
             if (e.OldValue != e.NewValue && instance!= null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetText();
+            }
+        }
         #endregion CallBack Method
         protected void OnPropertyChanged(string propName)
+        {
             if (PropertyChanged != null)
                 PropertyChanged(this, new PropertyChangedEventArgs(propName));
+        }
+    }
+}

프로젝트

일반

사용자정보

MARKUS

markus / MarkupToPDF_Old / Controls / Text / TextControl.cs @ b3fb7321