/MarkupToPDF/Controls/Cad/OverlapWhiteControlcs.cs - 이력해설 - MARKUS - 일정관리

markus / MarkupToPDF / Controls / Cad / OverlapWhiteControlcs.cs @ 959b3ef2

-ef11c
+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.Shapes;
 using System.Windows.Controls;
 using System.Windows.Media;
 using MarkupToPDF.Controls.Common;
 using MarkupToPDF.Common;
-a0
+using MarkupToPDF.Serialize.Core;
 using MarkupToPDF.Serialize.S_Control;
-ef11c
+            ljiyeon
 namespace MarkupToPDF.Controls.Cad
+{
     //강인구 추가 IShapeControl
     public class OverlapWhiteControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IMarkupCommonData, IShapeControl, IDashControl
+    {
         public Path Base_RectPath { get; set; }
         private const string PART_RectPath = "PART_RectPath";
         #region Property
         public MouseMode mousemode
+        {
             get
+            {
                 return (MouseMode)GetValue(mousemodeProperty);
+            }
             set
+            {
                 SetValue(mousemodeProperty, value);
                 OnPropertyChanged("mousemode");
+            }
+        }
         public SolidColorBrush StrokeColor
+        {
             get
+            {
                 return (SolidColorBrush)GetValue(StrokeColorProperty);
+            }
             set
+            {
                 SetValue(StrokeColorProperty, value);
                 OnPropertyChanged("StrokeColor");
+            }
+        }
         public Double LineSize
+        {
             get
+            {
                 return (Double)GetValue(LineSizeProperty);
+            }
             set
+            {
                 SetValue(LineSizeProperty, value);
                 OnPropertyChanged("LineSize");
+            }
+        }
         public Geometry PathData
+        {
             get
+            {
                 return (Geometry)GetValue(PathDataProperty);
+            }
             set
+            {
                 SetValue(PathDataProperty, value);
                 OnPropertyChanged("PathData");
+            }
+        }
         public Geometry OverViewPathData
+        {
             get
+            {
                 return (Geometry)GetValue(OverViewPathDataProperty);
+            }
             set
+            {
                 SetValue(OverViewPathDataProperty, value);
                 OnPropertyChanged("OverViewPathData");
+            }
+        }
         public SolidColorBrush FillColor
+        {
             get { return (SolidColorBrush)GetValue(FillColorProperty); }
             set
+            {
                 SetValue(FillColorProperty, value);
                 OnPropertyChanged("FillColor");
+            }
+        }
         //강인구 추가
         public DoubleCollection DashSize
+        {
             get { return (DoubleCollection)GetValue(DashSizeProperty); }
             set
+            {
                 if (this.DashSize != value)
+                {
                     SetValue(DashSizeProperty, value);
+                }
+            }
+        }
         public Point StartPoint
+        {
             get
+            {
                 return (Point)GetValue(StartPointProperty);
+            }
             set
+            {
                 SetValue(StartPointProperty, value);
                 OnPropertyChanged("StartPoint");
+            }
+        }
         public Point SetPoint
+        {
             get
+            {
                 return (Point)GetValue(SetPointProperty);
+            }
             set
+            {
                 SetValue(SetPointProperty, value);
                 OnPropertyChanged("SetPoint");
+            }
+        }
         public Point OriginPoint
+        {
             get
+            {
                 return (Point)GetValue(OriginPointProperty);
+            }
             set
+            {
                 SetValue(OriginPointProperty, value);
                 OnPropertyChanged("OriginPoint");
+            }
+        }
         public Point TopRightPoint
+        {
             get
+            {
                 return (Point)GetValue(TopRightPointProperty);
+            }
             set
+            {
                 SetValue(TopRightPointProperty, value);
                 OnPropertyChanged("TopRightPoint");
+            }
+        }
         public Point LeftBottomPoint
+        {
             get
+            {
                 return (Point)GetValue(LeftBottomPointProperty);
+            }
             set
+            {
                 SetValue(LeftBottomPointProperty, value);
                 OnPropertyChanged("LeftBottomPoint");
+            }
+        }
         public Point EndPoint
+        {
             get
+            {
                 return (Point)GetValue(EndPointProperty);
+            }
             set
+            {
                 SetValue(EndPointProperty, value);
                 OnPropertyChanged("EndPoint");
+            }
+        }
-b3ef2
+        public override bool IsSelected
-ef11c
+            ljiyeon
             get
+            {
                 return (bool)GetValue(IsSelectedProperty);
+            }
             set
+            {
                 SetValue(IsSelectedProperty, value);
                 OnPropertyChanged("IsSelected");
+            }
+        }
         public ControlType ControlType
+        {
             set
+            {
                 SetValue(ControlTypeProperty, value);
                 OnPropertyChanged("ControlType");
+            }
             get
+            {
                 return (ControlType)GetValue(ControlTypeProperty);
+            }
+        }
         public List<Point> PointSet
+        {
             get { return (List<Point>)GetValue(PointSetProperty); }
             set { SetValue(PointSetProperty, value); }
+        }
         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 PaintSet Paint
+        {
             get { return (PaintSet)GetValue(PaintProperty); }
             set
+            {
                 if (this.Paint != value)
+                {
                     SetValue(PaintProperty, value);
+                }
+            }
+        }
         public double Angle
+        {
             get { return (double)GetValue(AngleProperty); }
             set
+            {
                 if (this.Angle != value)
+                {
                     SetValue(AngleProperty, value);
+                }
+            }
+        }
         public string UserID
+        {
             get { return (string)GetValue(UserIDProperty); }
             set
+            {
                 if (this.UserID != value)
+                {
                     SetValue(UserIDProperty, value);
                     OnPropertyChanged("UserID");
+                }
+            }
+        }
         #endregion
         #region Dependency Property
         public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(
         "UserID", typeof(string), typeof(OverlapWhiteControl), new PropertyMetadata(null));
         public static readonly DependencyProperty mousemodeProperty =
                 DependencyProperty.Register("mousemode", typeof(MouseMode), typeof(OverlapWhiteControl), new PropertyMetadata(MouseMode.None, PointValueChanged));
         public static readonly DependencyProperty IsSelectedProperty =
           DependencyProperty.Register("IsSelected", typeof(bool), typeof(OverlapWhiteControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));
         public static readonly DependencyProperty ControlTypeProperty =
                 DependencyProperty.Register("ControlType", typeof(ControlType), typeof(OverlapWhiteControl), new FrameworkPropertyMetadata(ControlType.OverlapWhite));
         public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(
                 "StrokeColor", typeof(SolidColorBrush), typeof(OverlapWhiteControl), new PropertyMetadata(new SolidColorBrush(Colors.White)));
         public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(
               "LineSize", typeof(double), typeof(OverlapWhiteControl), new PropertyMetadata((Double)3));
         //강인구 추가
         public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(
                 "DashSize", typeof(DoubleCollection), typeof(OverlapWhiteControl), new PropertyMetadata(new DoubleCollection { 1, 1 }, PointValueChanged));
         public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(
                "PathData", typeof(Geometry), typeof(OverlapWhiteControl), null);
         public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(
                "OverViewPathData", typeof(Geometry), typeof(OverlapWhiteControl), null);
         //강인구 추가
         public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(
         "Paint", typeof(PaintSet), typeof(OverlapWhiteControl), new PropertyMetadata(PaintSet.None, PointValueChanged));
         public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(
                 "FillColor", typeof(SolidColorBrush), typeof(OverlapWhiteControl), new PropertyMetadata(new SolidColorBrush(Colors.White)));
         public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(
                  "CanvasX", typeof(double), typeof(OverlapWhiteControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(
                 "CanvasY", typeof(double), typeof(OverlapWhiteControl), new PropertyMetadata((double)0, OnSetCansvasChanged));
         public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(
                "TopRightPoint", typeof(Point), typeof(OverlapWhiteControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(
                  "LeftBottomPoint", typeof(Point), typeof(OverlapWhiteControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(
             "StartPoint", typeof(Point), typeof(OverlapWhiteControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty SetPointProperty = DependencyProperty.Register(
         "SetPoint", typeof(Point), typeof(OverlapWhiteControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty OriginPointProperty = DependencyProperty.Register(
         "OriginPoint", typeof(Point), typeof(OverlapWhiteControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         public static readonly DependencyProperty AngleProperty = DependencyProperty.Register(
             "Angle", typeof(double), typeof(OverlapWhiteControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));
         public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(
          "PointSet", typeof(List<Point>), typeof(OverlapWhiteControl), new PropertyMetadata(new List<Point>()));
         public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(
               "EndPoint", typeof(Point), typeof(OverlapWhiteControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
         #endregion  Dependency Property
         #region Dependency PropertyChanged
         public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (OverlapWhiteControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 Canvas.SetLeft(instance, instance.SetPoint.X);
                 Canvas.SetTop(instance, instance.SetPoint.Y);
                 //Canvas.SetLeft(instance, instance.CanvasX);
                 //Canvas.SetTop(instance, instance.CanvasY);
+            }
+        }
         public static void OnUpdateChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (OverlapWhiteControl)sender;
             if (e.OldValue != e.NewValue && instance != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetRectPath();
+            }
+        }
         public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (OverlapWhiteControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_RectPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetRectPath();
+            }
+        }
         public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             //var instance = (OverlapWhiteControl)sender;
             //if (e.OldValue != e.NewValue && instance.Base_RectPath != null)
             //{
             //    instance.SetValue(e.Property, e.NewValue);
             //    if (instance.IsSelected)
             //    {
             //        instance.Base_RectPath.Stroke = new SolidColorBrush(Colors.Blue);
             //    }
             //    else
             //    {
             //        instance.Base_RectPath.Stroke = new SolidColorBrush(Colors.Red);
             //    }
             //}
+        }
         public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
             var instance = (OverlapWhiteControl)sender;
             if (e.OldValue != e.NewValue && instance.Base_RectPath != null)
+            {
                 instance.SetValue(e.Property, e.NewValue);
                 instance.SetRectPath();
+            }
+        }
         #endregion Dependency PropertyChanged
         public void SetRectPath()
+        {
             this.ApplyTemplate();
             if (Base_RectPath != null)
+            {
                 //강인구 추가
                 Base_RectPath.StrokeDashArray.Clear();
                 if (DashSize != null)
+                {
                     foreach (var item in this.DashSize)
+                    {
                         Base_RectPath.StrokeDashArray.Add(item);
+                    }
                     Base_RectPath.StrokeDashCap = PenLineCap.Square;
+                }
                 PathFigure pathFigure = new PathFigure
+                {
                     IsClosed = true
                 };
                 if (ControlType == ControlType.OverlapWhite)
+                {
                     switch (this.Paint)
+                    {
                         case PaintSet.None:
                             this.FillColor = null;
                             pathFigure.IsFilled = false;
                             break;
                         default:
+                            {
+                            }
                             break;
+                    }
+                }
                 pathFigure.StartPoint = this.StartPoint;
                 LineSegment lineSegment1 = new LineSegment();
                 lineSegment1.Point = this.LeftBottomPoint;
                 pathFigure.Segments.Add(lineSegment1);
                 LineSegment lineSegment2 = new LineSegment();
                 lineSegment2.Point = this.EndPoint;
                 pathFigure.Segments.Add(lineSegment2);
                 LineSegment lineSegment3 = new LineSegment();
                 lineSegment3.Point = this.TopRightPoint;
                 pathFigure.Segments.Add(lineSegment3);
                 LineSegment lineSegment0 = new LineSegment();
                 lineSegment0.Point = this.StartPoint;
                 pathFigure.Segments.Add(lineSegment0);
                 PathGeometry pathGeometry = new PathGeometry();
                 pathGeometry.Figures = new PathFigureCollection();
                 pathGeometry.Figures.Add(pathFigure);
                 //Base_RectPath.StrokeThickness = 3;
                 this.FillColor = null;
                 this.PathData = pathGeometry;
                 ApplyOverViewData();
                 //OverViewPathData = PathData;
                 //AdornerControl adornerControl = new Adorner.AdornerControl();
                 ////adornerControl
                 //adornerControl.Content = pathGeometry;
+            }
+        }
         public void ApplyOverViewData()
+        {
             this.OverViewPathData = this.PathData;
+        }
         #region Internal Method
         static OverlapWhiteControl()
+        {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(OverlapWhiteControl), new FrameworkPropertyMetadata(typeof(OverlapWhiteControl)));
             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_RectPath = GetTemplateChild(PART_RectPath) as Path;
             if (Base_RectPath == null)
                 return;
             SetRectPath();
             Base_RectPath.Focus();
+        }
         public void updateControl()
+        {
             this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);
             this.LeftBottomPoint = new Point(this.PointSet[1].X, this.PointSet[1].Y);
             this.EndPoint = new Point(this.PointSet[2].X, this.PointSet[2].Y);
             this.TopRightPoint = new Point(this.PointSet[3].X, this.PointSet[3].Y);
+        }
         private void OnPropertyChanged(string name)
+        {
             if (PropertyChanged != null)
+            {
                 PropertyChanged(this, new PropertyChangedEventArgs(name));
+            }
+        }
         public void ChangePaint(PaintSet state)
+        {
             this.Paint = state;
             this.SetRectPath();
+        }
-a0
+        /// <summary>
         /// Serialize this
         /// </summary>
         /// <param name="sUserId"></param>
         /// <returns></returns>
         public override string Serialize()
+        {
             using (S_OverlapWhiteControl STemp = new S_OverlapWhiteControl())
+            {
                 STemp.TransformPoint = "0|0";
                 STemp.SizeSet = String.Format("{0}", this.LineSize);
                 STemp.PaintState = this.Paint;
                 STemp.PointSet = this.PointSet;
                 //STemp.StrokeColor = "#FF00FF00";
                 STemp.StrokeColor = this.StrokeColor.Color.ToString();
                 if (this.FillColor != null)
+                {
                     STemp.FillColor = this.FillColor.Color.ToString();
+                }
                 STemp.StartPoint = this.StartPoint;
                 STemp.UserID = this.UserID;
                 STemp.EndPoint = this.EndPoint;
                 STemp.LB = this.LeftBottomPoint;
                 STemp.TR = this.TopRightPoint;
                 STemp.DashSize = this.DashSize;
                 STemp.Opac = this.Opacity;
                 STemp.Name = this.GetType().Name.ToString();
                 STemp.Memo = this.Memo;
                 return "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));
             };
+        }
-b7416
+        /// <summary>
         /// create a OverlapWhiteControl from given string
         /// </summary>
         /// <param name="str"></param>
         /// <returns></returns>
         public static OverlapWhiteControl FromString(string str, SolidColorBrush brush, string sProjectNo)
+        {
             using (S_OverlapWhiteControl s = JsonSerializerHelper.JsonDeserialize<S_OverlapWhiteControl>(str))
+            {
                 string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);
                 return new OverlapWhiteControl
+                {
                     LineSize = Convert.ToDouble(data2.First()),
                     Paint = s.PaintState,
                     StartPoint = s.StartPoint,
                     EndPoint = s.EndPoint,
                     Angle = s.Angle,
                     StrokeColor = Brushes.White,
                     DashSize = s.DashSize,
                     Opacity = s.Opac,
                     LeftBottomPoint = s.LB,
                     TopRightPoint = s.TR,
                     PointSet = s.PointSet,
                     UserID = s.UserID,
                     FillColor = Brushes.White,
                     Memo = s.Memo
                 };
+            }
+        }
-ef11c
+        public event PropertyChangedEventHandler PropertyChanged;
         public void Dispose()
+        {
             GC.Collect();
             GC.SuppressFinalize(this);
+        }
         #endregion Internal Method
+    }
+}

프로젝트

일반

사용자정보

MARKUS

markus / MarkupToPDF / Controls / Cad / OverlapWhiteControlcs.cs @ 959b3ef2