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

markus / MarkupToPDF / Controls / Polygon / PolygonControl.cs @ 91efe37a

-a4489
+using MarkupToPDF.Common;
 using MarkupToPDF.Controls.Common;
-a0
+using MarkupToPDF.Serialize.Core;
 using MarkupToPDF.Serialize.S_Control;
-a4489
+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.Polygon
+{
      public class PolygonControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IShapeControl, IMarkupControlData, IPath
+    {
         #region Constructure
         static PolygonControl()
+        {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(PolygonControl), new FrameworkPropertyMetadata(typeof(PolygonControl)));
             ResourceDictionary dictionary = new ResourceDictionary();
             dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);
             Application.Current.Resources.MergedDictionaries.Add(dictionary);
+        }
         public PolygonControl()
+        {
             this.DefaultStyleKey = typeof(PolygonControl);
+        }
         #endregion
         #region Variable
         private const string PART_PolyPath = "PART_PolyPath";
         public Path Base_PolyPath = null;
         #endregion
         #region Internal Method
         public override void OnApplyTemplate()
+        {
             base.OnApplyTemplate();
             Base_PolyPath = GetTemplateChild(PART_PolyPath) as Path;
             if (Base_PolyPath == null)
                 return;
             this.SetPolyPath();
+        }
         #endregion
         #region Method
         public void ApplyOverViewData()
+        {
             this.OverViewPathData = this.PathData;
+        }
         #endregion
         #region Dependency Properties
         public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(
                 "UserID", typeof(string), typeof(PolygonControl), new PropertyMetadata(null));
         public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(
               "LineSize", typeof(double), typeof(PolygonControl), new PropertyMetadata((Double)3));
         public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(
                "StrokeColor", typeof(SolidColorBrush), typeof(PolygonControl),
                new PropertyMetadata(new SolidColorBrush(Colors.Red)));
         public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(
                 "PathData", typeof(Geometry), typeof(PolygonControl), null);
         //강인구 추가
         public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(
                 "DashSize", typeof(DoubleCollection), typeof(PolygonControl), new PropertyMetadata(new DoubleCollection { 99999999  }, PointValueChanged));
         public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(
                 "OverViewPathData", typeof(Geometry), typeof(PolygonControl), null);
         //강인구 추가
         public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(
         "Paint", typeof(PaintSet), typeof(PolygonControl), new PropertyMetadata(PaintSet.None, PointValueChanged));
         public static readonly DependencyProperty IsCompletedProperty = DependencyProperty.Register(
                "IsCompleted", typeof(bool), typeof(PolygonControl), null);
         public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(
                "StartPoint", typeof(Point), typeof(PolygonControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(
                "EndPoint", typeof(Point), typeof(PolygonControl), new PropertyMetadata(new Point(100, 100), PointValueChanged));
         public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(
                 "PointSet", typeof(List<Point>), typeof(PolygonControl), new PropertyMetadata(new List<Point>(), PointValueChanged));
         /// <summary>
         /// StylusPointSet을 List<Point>로 대체하면 PointValueChanged가 작동안한다.
         /// </summary>
         //public static readonly DependencyProperty StylusPointSetProperty = DependencyProperty.Register(
         //        "PointC", typeof(StylusPointSet), typeof(PolygonControl), new PropertyMetadata(new StylusPointSet(), PointValueChanged));
         public static readonly DependencyProperty AngleProperty =
             DependencyProperty.Register("Angle", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback
                 (AngleValueChanged)));
         public static readonly DependencyProperty CenterXProperty =
             DependencyProperty.Register("CenterX", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnCenterXYChanged));
         public static readonly DependencyProperty CenterYProperty =
             DependencyProperty.Register("CenterY", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnCenterXYChanged));
         public static readonly DependencyProperty IsSelectedProperty =
             DependencyProperty.Register("IsSelected", typeof(bool), typeof(PolygonControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));
         public static readonly DependencyProperty ControlTypeProperty =
             DependencyProperty.Register("ControlType", typeof(ControlType), typeof(PolygonControl), new FrameworkPropertyMetadata(ControlType.PolygonControl));
         public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(
                 "CanvasX", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(
                 "CanvasY", typeof(double), typeof(PolygonControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         #endregion
         #region PropertyChanged Method
         public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (PolygonControl)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 PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (PolygonControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 //강인구 추가
                 instance.SetPolyPath();
                 //instance.SetPolyPath(); 주석처리
+            }
+        }
         public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (PolygonControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetPolyPath();
+            }
+        }
         public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (PolygonControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetPolyPath();
+            }
+        }
         public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             //var instance = (PolygonControl)sender;
             //if (e.OldValue != e.NewValue && instance.Base_PolyPath != null)
             //{
             //    instance.SetValue(e.Property, e.NewValue);
             //    if (instance.IsSelected)
             //    {
             //        instance.Base_PolyPath.Stroke = new SolidColorBrush(Colors.Blue);
             //    }
             //    else
             //    {
             //        instance.Base_PolyPath.Stroke = new SolidColorBrush(Colors.Transparent);
             //    }
             //}
+        }
         #endregion
         #region Properties
         public bool IsCompleted
+        {
             get { return (bool)GetValue(IsCompletedProperty); }
             set
+            {
                 SetValue(IsCompletedProperty, value);
                 OnPropertyChanged("IsCompleted");
+            }
+        }
         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);
                     OnPropertyChanged("CanvasX");
+                }
+            }
+        }
         public double CanvasY
+        {
             get { return (double)GetValue(CanvasYProperty); }
             set
+            {
                 if (this.CanvasY != value)
+                {
                     SetValue(CanvasYProperty, value);
                     OnPropertyChanged("CanvasY");
+                }
+            }
+        }
-b3ef2
+        public override bool IsSelected
-a4489
+            KangIngu
             get
+            {
                 return (bool)GetValue(IsSelectedProperty);
+            }
             set
+            {
                 SetValue(IsSelectedProperty, value);
                 OnPropertyChanged("IsSelected");
+            }
+        }
         public PaintSet Paint
+        {
             get { return (PaintSet)GetValue(PaintProperty); }
             set
+            {
                 if (this.Paint != value)
+                {
                     SetValue(PaintProperty, value);
                     OnPropertyChanged("Paint");
+                }
+            }
+        }
-d2a2
+        public override ControlType ControlType
-a4489
+            KangIngu
             set
+            {
                 SetValue(ControlTypeProperty, value);
                 OnPropertyChanged("ControlType");
+            }
             get
+            {
                 return (ControlType)GetValue(ControlTypeProperty);
+            }
+        }
         public Double LineSize
+        {
             get { return (Double)GetValue(LineSizeProperty); }
             set
+            {
                 if (this.LineSize != value)
+                {
                     SetValue(LineSizeProperty, value);
                     OnPropertyChanged("LineSize");
+                }
+            }
+        }
         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 List<Point> PointSet
+        {
             get { return (List<Point>)GetValue(PointSetProperty); }
             set { SetValue(PointSetProperty, value);
             OnPropertyChanged("PointSet");
+            }
         }        //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 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 double Angle
+        {
             get { return (double)GetValue(AngleProperty); }
             set
+            {
                 if (this.Angle != value)
+                {
                     SetValue(AngleProperty, value);
                     OnPropertyChanged("Angle");
+                }
+            }
+        }
         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");
+            }
+        }
         #endregion
         public void updateControl()
+        {
             //this.PointSet = new List<Point>();
             //this.PointSet.Clear();
             //this.PointSet.AddRange(PointC.pointSet);
             //this.PointSet.AddRange(PointSet);
             this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);
             this.EndPoint = new Point(this.PointSet[this.PointSet.Count - 1].X, this.PointSet[this.PointSet.Count - 1].Y);
             SetPolyPath();
+        }
-b7416
+        private void SetPolyPath()
-a4489
+            KangIngu
             this.ApplyTemplate();
             if (Base_PolyPath != null)
+            {
                 Base_PolyPath.StrokeDashArray.Clear();
                 foreach (var item in this.DashSize)
+                {
                     Base_PolyPath.StrokeDashArray.Add(item);
+                }
                 PathGeometry pathGeometry = new PathGeometry();
                 PathFigure pathFigure = new PathFigure();
                 PolyLineSegment instance = new PolyLineSegment();
                 foreach (var Inneritem in PointSet)
+                {
                     instance.Points.Add(Inneritem);
+                }
                 StartPoint = instance.Points.First();
                 pathFigure.StartPoint = StartPoint;
                 EndPoint = instance.Points.Last();
                 pathFigure.Segments.Add(instance);
                 pathGeometry.Figures.Add(pathFigure);
                 //강인구 추가(Chain이 아닌 Polygon일때만 채우기 및 빗금 하기)
                 if (ControlType == ControlType.PolygonControl)
+                {
                     switch (this.Paint)
+                    {
                         case PaintSet.None:
+                            {
                                 //강인구 추가
                                 Base_PolyPath.Fill = null;
+                            }
                             break;
                         case PaintSet.Fill:
+                            {
                                 Base_PolyPath.Fill = this.StrokeColor;
+                            }
                             break;
                         case PaintSet.Hatch:
+                            {
                                 Base_PolyPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor, this.LineSize * 0.1);
+                            }
                             break;
                         default:
                             break;
+                    }
+                }
                 this.PathData = pathGeometry;
                 this.OverViewPathData = PathData;
+            }
+        }
         public void ChangePaint(PaintSet state)
+        {
+        }
-a0
+        /// <summary>
-efe37a
+        /// return Polygon's area
         /// </summary>
         /// <author>humkyung</author>
         /// <date>2019.06.13</date>
         public override Rect ItemRect
+        {
             get
+            {
                 double dMinX = double.MaxValue;
                 double dMinY = double.MaxValue;
                 double dMaxX = double.MinValue;
                 double dMaxY = double.MinValue;
                 foreach (Point pt in this.PointSet)
+                {
                     dMinX = Math.Min(dMinX, pt.X);
                     dMinY = Math.Min(dMinY, pt.Y);
                     dMaxX = Math.Max(dMaxX, pt.X);
                     dMaxY = Math.Max(dMaxY, pt.Y);
+                }
                 return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
+            }
+        }
         /// <summary>
-a0
+        /// Serialize this
         /// </summary>
         /// <param name="sUserId"></param>
         /// <returns></returns>
         public override string Serialize()
+        {
             using (S_PolyControl STemp = new S_PolyControl())
+            {
                 STemp.TransformPoint = "0|0";
                 STemp.SizeSet = String.Format("{0}", this.LineSize);
                 STemp.StrokeColor = this.StrokeColor.Color.ToString();
                 //STemp.StrokeColor = "#FF000FFF";
                 STemp.Name = this.GetType().Name.ToString();
                 //STemp.Toler = this.Toler;
                 STemp.PaintState = this.Paint;
                 STemp.Opac = this.Opacity;
                 STemp.UserID = this.UserID;
                 STemp.PaintState = this.Paint;
                 //강인구 추가(Chain인지 Polygon인지 구분)
                 STemp.Type = this.ControlType;
                 //STemp.IsTrans = this.isTransOn;
                 //STemp.IsChain = this.isChain;
                 STemp.PointSet = new List<Point>();
                 STemp.DashSize = this.DashSize;
                 STemp.StartPoint = this.StartPoint;
                 STemp.EndPoint = this.EndPoint;
                 STemp.IsCompleted = this.IsCompleted;
                 foreach (var point in this.PointSet)
+                {
                     STemp.PointSet.Add(point);
+                }
                 ///강인구 추가(2017.11.02)
                 ///Memo 추가
                 STemp.Memo = this.Memo;
                 return "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));
+            }
+        }
-b7416
+        /// <summary>
         /// create a polygoncontrol from given string
         /// </summary>
         /// <param name="str"></param>
         /// <returns></returns>
         public static PolygonControl FromString(string str, SolidColorBrush brush, string sProjectNo)
+        {
             using (S_PolyControl s = JsonSerializerHelper.JsonDeserialize<S_PolyControl>(str))
+            {
                 string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);
                 return new PolygonControl
+                {
                     LineSize = Convert.ToDouble(data2.First()),
                     //Toler = s.Toler,
                     IsCompleted = s.IsCompleted,
                     //PointSet = new List<Point>(),
                     Opacity = s.Opac,
                     StrokeColor = brush,
                     //강인구 추가(Chain인지 Polygon인지 구분)
                     ControlType = s.Type,
                     DashSize = s.DashSize,
                     StartPoint = s.StartPoint,
                     EndPoint = s.EndPoint,
                     PointSet = s.PointSet,
                     UserID = s.UserID,
                     Paint = s.PaintState,
                     //PointC = s.PointC,
                     Memo = s.Memo
                 };
+            }
+        }
-a4489
+        //public PaintSet Paint { get; set; }
         #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
+    }
     public class StylusPointSet : INotifyPropertyChanged
+    {
         public StylusPointSet()
+        {
             if (pointSet == null)
                 pointSet = new List<Point>();
+        }
         public List<Point> _pointSet;
         public List<Point> pointSet
+        {
             get
+            {
                 return _pointSet;
+            }
             set
+            {
                 _pointSet = value;
                 OnPropertyChanged("pointSet");
+            }
+        }
         #region INotifyPropertyChanged
         private void OnPropertyChanged(string name)
+        {
             if (PropertyChanged != null)
+            {
                 PropertyChanged(this, new PropertyChangedEventArgs(name));
+            }
+        }
         public event PropertyChangedEventHandler PropertyChanged;
         #endregion
+    }
+}

프로젝트

일반

사용자정보

MARKUS

markus / MarkupToPDF / Controls / Polygon / PolygonControl.cs @ 91efe37a