/MarkupToPDF/Controls/Polygon/CloudControl.cs.bak - 이력해설 - MARKUS - 일정관리

markus / MarkupToPDF / Controls / Polygon / CloudControl.cs.bak @ 6e5f7eaf

-a4489
+using System;
 using System.Net;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Documents;
 using System.Windows.Ink;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Animation;
 using System.Windows.Shapes;
 using System.Collections.Generic;
 using System.ComponentModel;
 using MarkupToPDF.Controls.Common;
 using MarkupToPDF.Common;
 namespace MarkupToPDF.Controls.Polygon
+{
     public class CloudControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IPath, IShapeControl, ICloudControl, IDashControl
+    {
         private const string PART_CloudPath = "PART_CloudPath";
         private const string PART_CloudSubPath = "PART_CloudSubPath";
         public Path Base_CloudPath = null;
         public Path Base_CloudSubPath = null;
         static CloudControl()
+        {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(CloudControl), new FrameworkPropertyMetadata(typeof(CloudControl)));
             //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);
             ResourceDictionary dictionary = new ResourceDictionary();
             dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);
             Application.Current.Resources.MergedDictionaries.Add(dictionary);
+        }
         public CloudControl()
+        {
             this.DefaultStyleKey = typeof(CloudControl);
+        }
         #region Dependency Properties
         public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(
                 "UserID", typeof(string), typeof(CloudControl), new PropertyMetadata(null));
         public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(
                 "LineSize", typeof(double), typeof(CloudControl), new PropertyMetadata((Double)3));
         public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(
                  "DashSize", typeof(DoubleCollection), typeof(CloudControl), new PropertyMetadata(new DoubleCollection {7,7,1,7 }));
         public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(
                 "FillColor", typeof(SolidColorBrush), typeof(CloudControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));
         public static readonly DependencyProperty IsCompletedProperty = DependencyProperty.Register(
                 "IsCompleted", typeof(bool), typeof(CloudControl), null);
         public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(
                 "Paint", typeof(PaintSet), typeof(CloudControl), new PropertyMetadata(PaintSet.None));
         public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(
                 "StrokeColor", typeof(SolidColorBrush), typeof(CloudControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));
         public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(
                 "PathData", typeof(Geometry), typeof(CloudControl), null);
         public static readonly DependencyProperty PathSubDataProperty = DependencyProperty.Register(
                 "PathSubData", typeof(Geometry), typeof(CloudControl), null);
         public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(
                 "EndPoint", typeof(Point), typeof(CloudControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(
                 "StartPoint", typeof(Point), typeof(CloudControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(
                 "PointSet", typeof(List<Point>), typeof(CloudControl), new PropertyMetadata(new List<Point>(), PointValueChanged));
         public static readonly DependencyProperty isTransOnProperty = DependencyProperty.Register(
                 "isTransOn", typeof(bool), typeof(CloudControl), new PropertyMetadata(false));
         public static readonly DependencyProperty isChainProperty = DependencyProperty.Register(
                 "isChain", typeof(bool), typeof(CloudControl), new PropertyMetadata(false));
         /// <summary>
         /// StylusPointSet을 List<Point>로 대체하면 PointValueChanged가 작동안한다.
         /// </summary>
         public static readonly DependencyProperty StylusPointSetProperty = DependencyProperty.Register(
                "PointC", typeof(StylusPointSet), typeof(CloudControl), new PropertyMetadata(new StylusPointSet(), PointValueChanged));
         public static readonly DependencyProperty AngleProperty = DependencyProperty.Register("AngleValue", typeof(double), typeof(CloudControl),
             new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));
         public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register("CenterX", typeof(double), typeof(CloudControl),
             new PropertyMetadata((double)0, OnCenterXYChanged));
         public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register("CenterY", typeof(double), typeof(CloudControl),
             new PropertyMetadata((double)0, OnCenterXYChanged));
         public static readonly DependencyProperty IsSelectedProperty =
     DependencyProperty.Register("IsSelected", typeof(bool), typeof(CloudControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));
         public static readonly DependencyProperty ControlTypeProperty =
             DependencyProperty.Register("ControlType", typeof(ControlType), typeof(CloudControl), new FrameworkPropertyMetadata(ControlType.PolygonCloud));
         public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(
         "OverViewPathData", typeof(Geometry), typeof(ControlType), null);
         public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(
                 "CanvasX", typeof(double), typeof(CloudControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(
                 "CanvasY", typeof(double), typeof(CloudControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         #endregion
         #region PropertyChanged Method
         public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (CloudControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
+            }
+        }
         public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (CloudControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 //instance.SetCloud(); 주석처리
+            }
+        }
         public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             //var instance = (CloudControl)sender;
             //if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)
             //{
             //    instance.SetValue(e.Property, e.NewValue);
             //    if (instance.IsSelected)
             //    {
             //        instance.Base_CloudPath.Stroke = new SolidColorBrush(Colors.Blue);
             //    }
             //    else
             //    {
             //        instance.Base_CloudPath.Stroke = new SolidColorBrush(Colors.Red);
             //    }
             //}
+        }
         public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (CloudControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.DrawingCloud();
+            }
+        }
         public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (CloudControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.DrawingCloud();
+            }
+        }
         #endregion
         #region Properties
         public bool IsCompleted
+        {
             get { return (bool)GetValue(IsCompletedProperty); }
             set
+            {
                 SetValue(IsCompletedProperty, value);
+            }
+        }
         public Geometry OverViewPathData
+        {
             get { return (Geometry)GetValue(OverViewPathDataProperty); }
             set
+            {
                 SetValue(OverViewPathDataProperty, value);
                 OnPropertyChanged("OverViewPathData");
+            }
+        }
         public double CanvasX
+        {
             get { return (double)GetValue(CanvasXProperty); }
             set
+            {
                 if (this.CanvasX != value)
+                {
                     SetValue(CanvasXProperty, value);
+                }
+            }
+        }
         public double CanvasY
+        {
             get { return (double)GetValue(CanvasYProperty); }
             set
+            {
                 if (this.CanvasY != value)
+                {
                     SetValue(CanvasYProperty, value);
+                }
+            }
+        }
         public bool IsSelected
+        {
             get
+            {
                 return (bool)GetValue(IsSelectedProperty);
+            }
             set
+            {
                 SetValue(IsSelectedProperty, value);
+            }
+        }
         public ControlType ControlType
+        {
             set
+            {
                 SetValue(ControlTypeProperty, value);
+            }
             get
+            {
                 return (ControlType)GetValue(ControlTypeProperty);
+            }
+        }
         public Double LineSize
+        {
             get { return (Double)GetValue(LineSizeProperty); }
             set
+            {
                 if (this.LineSize != value)
+                {
                     SetValue(LineSizeProperty, value);
+                }
+            }
+        }
         public bool isChain
+        {
             get { return (bool)GetValue(isChainProperty); }
             set
+            {
                 SetValue(isChainProperty, value);
                 OnPropertyChanged("isChain");
+            }
+        }
         public bool isTransOn
+        {
             get { return (bool)GetValue(isTransOnProperty); }
             set
+            {
                 SetValue(isTransOnProperty, value);
                 OnPropertyChanged("isTransOn");
+            }
+        }
         public DoubleCollection DashSize
+        {
             get { return (DoubleCollection)GetValue(DashSizeProperty); }
             set
+            {
                 if (this.DashSize != value)
+                {
                     SetValue(DashSizeProperty, value);
                     OnPropertyChanged("DashSize");
+                }
+            }
+        }
         public string UserID
+        {
             get { return (string)GetValue(UserIDProperty); }
             set
+            {
                 if (this.UserID != value)
+                {
                     SetValue(UserIDProperty, value);
                     OnPropertyChanged("UserID");
+                }
+            }
+        }
         public PaintSet Paint
+        {
             get { return (PaintSet)GetValue(PaintProperty); }
             set
+            {
                 if (this.Paint != value)
+                {
                     SetValue(PaintProperty, value);
                     OnPropertyChanged("Paint");
+                }
+            }
+        }
         public SolidColorBrush FillColor
+        {
             get { return (SolidColorBrush)GetValue(FillColorProperty); }
             set
+            {
                 if (this.FillColor != value)
+                {
                     SetValue(FillColorProperty, value);
                     OnPropertyChanged("FillColor");
+                }
+            }
+        }
         public SolidColorBrush StrokeColor
+        {
             get { return (SolidColorBrush)GetValue(StrokeColorProperty); }
             set
+            {
                 if (this.StrokeColor != value)
+                {
                     SetValue(StrokeColorProperty, value);
                     OnPropertyChanged("StrokeColor");
+                }
+            }
+        }
         public Geometry PathData
+        {
             get
+            {
                 return (Geometry)GetValue(PathDataProperty);
+            }
             set
+            {
                 SetValue(PathDataProperty, value);
                 OnPropertyChanged("PathData");
+            }
+        }
         public Geometry PathSubData
+        {
             get
+            {
                 return (Geometry)GetValue(PathSubDataProperty);
+            }
             set
+            {
                 SetValue(PathSubDataProperty, value);
                 OnPropertyChanged("PathSubData");
+            }
+        }
         public Point EndPoint
+        {
             get
+            {
                 return (Point)GetValue(EndPointProperty);
+            }
             set
+            {
                 SetValue(EndPointProperty, value);
                 OnPropertyChanged("EndPoint");
+            }
+        }
         public Point StartPoint
+        {
             get
+            {
                 return (Point)GetValue(StartPointProperty);
+            }
             set
+            {
                 SetValue(StartPointProperty, value);
                 OnPropertyChanged("StartPoint");
+            }
+        }
         public List<Point> _pointSet;
         public List<Point> PointSet
+        {
             get
+            {
                 return (List<Point>)GetValue(PointSetProperty);
+            }
             set
+            {
                 SetValue(PointSetProperty, value);
                 OnPropertyChanged("PointSet");
+            }
+        }
         public List<Point> pointSet
+        {
             get
+            {
                 return _pointSet;
+            }
             set
+            {
                 _pointSet = value;
                 OnPropertyChanged("pointSet");
+            }
+        }
         private double _toler = 1;
         public double Toler
+        {
             get { return _toler; }
             set { _toler = value; }
+        }
         private double _arcLength = 10;
         public double ArcLength
+        {
             get { return _arcLength; }
             set { _arcLength = value; }
+        }
         private bool _fill = false;
         public bool Fill
+        {
             get { return _fill; }
             set { _fill = value; }
+        }
         public double Angle
+        {
             get { return (double)GetValue(AngleProperty); }
             set
+            {
                 if (this.Angle != value)
+                {
                     SetValue(AngleProperty, value);
                     OnPropertyChanged("Angle");
+                }
+            }
+        }
         public StylusPointSet PointC
+        {
             get { return (StylusPointSet)GetValue(StylusPointSetProperty); }
             set
+            {
                 SetValue(StylusPointSetProperty, value);
                 OnPropertyChanged("PointC");
+            }
+        }
         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 double AngleValue
+        {
             get
+            {
                 return (double)GetValue(AngleProperty);
+            }
             set
+            {
                 SetValue(AngleProperty, value);
                 OnPropertyChanged("AngleValue");
+            }
+        }
         #endregion
         #region Data
         private PathGeometry _pathGeometry = new PathGeometry();
         private PathGeometry _pathSubGeometry = new PathGeometry();
         #endregion
         public override void OnApplyTemplate()
+        {
             base.OnApplyTemplate();
             Base_CloudPath = GetTemplateChild(PART_CloudPath) as Path;
             Base_CloudSubPath = GetTemplateChild(PART_CloudSubPath) as Path;
+        }
         public void SetCloud()
+        {
             //this.Width = this.Base_CloudPath.Width;
             //this.Height = this.Base_CloudPath.Height;
             this.ApplyTemplate();
             Generate();
             if (!isChain)
+            {
                 //ClosePath();
+            }
+        }
         public int Generate()
+        {
             this._pathGeometry = null;
             this._pathSubGeometry = null;
             switch (this.Paint)
+            {
                 case PaintSet.None:
                     this.FillColor = null;
                     if (Base_CloudSubPath != null)
+                    {
                         Base_CloudPath.Fill = null;
                         Base_CloudSubPath.Fill = null;
                         Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);
                         //Base_CloudSubPath.StrokeThickness = 3;
+                    }
                     break;
                 case PaintSet.Fill:
                     this.FillColor = this.StrokeColor;
                     if (Base_CloudSubPath != null)
+                    {
                         if (isChain)
+                        {
                             Base_CloudPath.Fill = null;
                             Base_CloudSubPath.Fill = null;
                             Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);
                             //Base_CloudSubPath.StrokeThickness = 3;
+                        }
                         else
+                        {
                             Base_CloudSubPath.Stroke = this.StrokeColor;
                             //Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);
                             Base_CloudSubPath.StrokeThickness = 0.5;
                             Base_CloudPath.Stroke = this.StrokeColor;
                             //Base_CloudPath.StrokeThickness = 3;
                             Base_CloudPath.Fill = this.FillColor;
                             Base_CloudSubPath.Fill = this.FillColor;
+                        }
+                    }
                     break;
                 case PaintSet.Hatch:
                     if (Base_CloudSubPath != null && !isChain)
+                    {
                         if (isChain)
+                        {
                             Base_CloudPath.Fill = null;
                             Base_CloudSubPath.Fill = null;
                             Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);
                             //Base_CloudSubPath.StrokeThickness = 3;
+                        }
                         else
+                        {
                             Base_CloudPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor, this.LineSize * 0.1);
                             Base_CloudSubPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor, this.LineSize * 0.1);
                             Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);
+                        }
+                    }
                     break;
                 default:
                     break;
+            }
             //if (Base_CloudPath != null)
             //{
             //    Base_CloudPath.StrokeDashArray.Clear();
             //    Base_CloudSubPath.StrokeDashArray.Clear();
             //    foreach (var item in this.DashSize)
             //    {
             //        Base_CloudPath.StrokeDashArray.Add(item);
             //        Base_CloudSubPath.StrokeDashArray.Add(item);
             //    }
             //}
             /// set reverse if area is greater 0 - 2012.07.04 added by humkyung
             double area = MathSet.AreaOf(this.PointSet);
             bool reverse = (area > 0);
             /// up to here
             this._pathGeometry = new PathGeometry();
             this._pathSubGeometry = new PathGeometry();
             int count = this.PointSet.Count;
             if (isTransOn) // true라면 클라우드 컨트롤
+            {
                 for (int i = 0; i < (count - 1); i++)
+                {
                     PathFigure pathFigure = CloudControl.GenerateLineWithCloud(this.PointSet[i], this.PointSet[i + 1], this.ArcLength, reverse);
                     _pathGeometry.Figures.Add(pathFigure);
+                }
+            }
             else
+            {
                 PathFigure fm = new PathFigure();
                 fm.StartPoint = this.PointSet[0];
                 for (int i = 0; i < (count - 1); i++)
+                {
                     fm.Segments.Add(new LineSegment { Point = this.PointSet[i] });
+                }
                 _pathGeometry.Figures.Add(fm);
+            }
             if (this.Paint == PaintSet.Fill || this.Paint == PaintSet.Hatch)
+            {
                 PointCollection pd = new PointCollection();
                 foreach (var item in this.PointSet)
+                {
                     pd.Add(item);
+                }
                 _pathSubGeometry.Figures.Add(new PathFigure()
+                {
                     Segments = new PathSegmentCollection()
+                    {
                         new PolyLineSegment()
+                        {
                               Points = pd
                         },
                     },
                     StartPoint = this.PointSet[0]
                 });
                 this.PathSubData = _pathSubGeometry;
+            }
             StartPoint = PointSet[0];
             this.PathData = this._pathGeometry;
             this.OverViewPathData = PathData;
             this.StrokeColor = StrokeColor;
             this.LineSize = LineSize;
             return 0;
+        }
         /// <summary>
         /// draw arcs between p1 and p2
         /// </summary>
         /// <author>humkyung</author>
         /// <param name="p1"></param>
         /// <param name="p2"></param>
         /// <param name="reverse"></param>
         /// <returns></returns>
         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 * 0.8, arcLength * 0.8);						/// 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 * 0.8, arcLength * 0.8);	/// 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);
+            }
             pathFigure.IsFilled = true;
             return pathFigure;
+        }
         /// <summary>
         /// close path if it's open
         /// </summary>
         /// <author>humkyung</author>
         /// <returns></returns>
         public int ClosePath()
+        {
             if (this.PointSet.Count > 1)
+            {
                 double d = MathSet.DistanceTo(this.PointSet[0], this.PointSet[this.PointSet.Count - 1]);
                 if (d > _toler)
+                {
                     /// set reverse if area is greater 0 - 2012.07.04 added by humkyung
                     double area = MathSet.AreaOf(this.PointSet);
                     bool reverse = (area > 0);
                     /// up to here
                     int count = this.PointSet.Count;
                     if (isTransOn) // true라면 클라우드 컨트롤
+                    {
                         PathFigure pathFigure = CloudControl.GenerateLineWithCloud(this.PointSet[count - 1], this.PointSet[0], this.ArcLength - 5, reverse);
                         if (this.Paint == PaintSet.Fill)
+                        {
                             pathFigure.IsClosed = true;
+                        }
                         _pathGeometry.Figures.Add(pathFigure);
+                    }
                     else
+                    {
                         PathFigure fm = new PathFigure();
                         fm.StartPoint = this.PointSet[count - 1];
                         //for (int i = 0; i < (count - 1); i++)
                         //{
                             _pathGeometry.Figures[_pathGeometry.Figures.Count - 1].Segments.Add(new LineSegment { Point = this.PointSet[0] });
                             _pathGeometry.Figures[_pathGeometry.Figures.Count - 1].Segments.Add(new LineSegment { Point = this.PointSet[1] });
                             //fm.Segments.Add(new LineSegment { Point = this.PointSet[0] });
                         //}
+                    }
+                }
+            }
             return 0;
+        }
         public void DrawingCloud()
+        {
             AnotherSetCloud();
             if (!isChain)
+            {
                 //ClosePath();
+            }
+        }
         public void AnotherSetCloud()
+        {
             this.StrokeColor = StrokeColor;
             this.LineSize = LineSize;
             this.SetCloud();
             //Generate();
             this.Width = this.Base_CloudPath.Width;
             this.Height = this.Base_CloudPath.Height;
+        }
         public void Dispose()
+        {
             GC.Collect();
             GC.SuppressFinalize(this);
+        }
         public event PropertyChangedEventHandler PropertyChanged;
         protected void OnPropertyChanged(string propName)
+        {
             if (PropertyChanged != null)
                 PropertyChanged(this, new PropertyChangedEventArgs(propName));
+        }
         public void updateControl()
+        {
             var lastIndex = this.PointSet.Count - 1;
             //this.StartPoint = this.PointSet[0];
             //this.EndPoint = this.PointSet[lastIndex];
             CenterX = MathSet.getMiddlePoint(this.PointSet[0], this.PointSet[lastIndex]).X;
             CenterY = MathSet.getMiddlePoint(this.PointSet[0], this.PointSet[lastIndex]).Y;
+        }
         public void ChangePaint(PaintSet state)
+        {
             this.Paint = state;
             this.SetCloud();
+        }
         #region Method
         public void ApplyOverViewData()
+        {
             this.OverViewPathData = this.PathData;
+        }
         #endregion
+    }
+}

프로젝트

일반

사용자정보

MARKUS

markus / MarkupToPDF / Controls / Polygon / CloudControl.cs.bak @ 6e5f7eaf