/ - Diff - MARKUS - 일정관리

개정판 a5b465dc

ID	a5b465dcada5056d3da69f0fc2223fd44b83f6cc
상위	b83bb9e7
하위	f056e2f7, ea6f99ec

백흠경이(가) 5년 이상 전에 추가함

issue #534: Add ItemRect property to all of controls

Change-Id: Id0d640b9fd9959615758b5e55b499f97d6f38dae

                                                     if (control.isTrans)
+                                                    {
                                                         //Controls_PDF.HoneyPDFLib_DrawSet_Arrow.SingleAllow(newStartPoint, tempMidPoint, (int)LineSize, contentByte, _SetColor, Opacity);
                                                         //Controls_PDF.HoneyPDFLib_DrawSet_Line.DrawLine(newStartPoint, tempMidPoint, (int)LineSize, contentByte, new DoubleCollection(9999), _SetColor, Opacity);
                                                         //Controls_PDF.HoneyPDFLib_DrawSet_Line.DrawLine(tempMidPoint, tempEndPoint, (int)LineSize, contentByte, new DoubleCollection(9999), _SetColor, Opacity);
                                                         //인구 수정 Arrow Text Style적용 되도록 변경
                                                         Controls_PDF.HoneyPDFLib_DrawSet_Text.DrawString_ArrowText(tempEndPoint, new Point(tempEndPoint.X + control.BoxWidth / scaleWidth, tempEndPoint.Y - control.BoxHeight / scaleHeight),
                                                             newStartPoint, tempMidPoint,
-...
                                                                     testP = new Point(newEndPoint.X + 10, newEndPoint.Y);
+                                                                }
+                                                            }
                                                             //Controls_PDF.HoneyPDFLib_DrawSet_Arrow.SingleAllow(tempStartPoint, testP, (int)LineSize, contentByte, _SetColor, Opacity);
                                                             //Controls_PDF.HoneyPDFLib_DrawSet_Line.DrawLine(tempStartPoint, testP, (int)LineSize, contentByte, new DoubleCollection(9999), _SetColor, Opacity);
                                                             //Controls_PDF.HoneyPDFLib_DrawSet_Line.DrawLine(testP, tempEndPoint, (int)LineSize, contentByte, new DoubleCollection(9999), _SetColor, Opacity);
                                                             //인구 수정 Arrow Text Style적용 되도록 변경
                                                             Controls_PDF.HoneyPDFLib_DrawSet_Text.DrawString_ArrowText(tempEndPoint, new Point(tempEndPoint.X + control.BoxWidth / scaleWidth, tempEndPoint.Y - control.BoxHeight / scaleHeight),
                                                                 tempStartPoint, testP,
-...
+                                                        }
                                                         else
+                                                        {
                                                             //Controls_PDF.HoneyPDFLib_DrawSet_Arrow.SingleAllow(newStartPoint, newMidPoint, (int)LineSize, contentByte, _SetColor, Opacity);
                                                             //Controls_PDF.HoneyPDFLib_DrawSet_Line.DrawLine(newStartPoint, newMidPoint, (int)LineSize, contentByte, new DoubleCollection(9999), _SetColor, Opacity);
                                                             //Controls_PDF.HoneyPDFLib_DrawSet_Line.DrawLine(newMidPoint, tempEndPoint, (int)LineSize, contentByte, new DoubleCollection(9999), _SetColor, Opacity);
                                                             //인구 수정 Arrow Text Style적용 되도록 변경
                                                             Controls_PDF.HoneyPDFLib_DrawSet_Text.DrawString_ArrowText(tempEndPoint, new Point(tempEndPoint.X + control.BoxWidth / scaleWidth, tempEndPoint.Y - control.BoxHeight / scaleHeight),
                                                                 newStartPoint, newMidPoint,

KCOM/Common/SelectionSet.cs
47	47	return _instance;
48	48	}
49	49	}
	50
	51	/// <summary>
	52	/// Control Select
	53	/// </summary>
	54	/// <author>humkyung</author>
	55	/// <date>2019.06.13</date>
	56	/// <param name="Control"></param>
	57	/// <param name="dragrect"></param>
	58	/// <returns></returns>
	59	public Boolean SelectControl(CommentUserInfo control, Rect dragrect)
	60	{
	61	return dragrect.Contains(control.ItemRect);
	62	}
50	63	}
51	64	}

KCOM/Controls/Symbol.xaml.cs
619	619	//move.
620	620	foreach (var item in Items)
621	621	{
622		Flag = move.control_Select(item, dragRect);
	622	Flag = SelectionSet.Instance.SelectControl(item, dragRect);
623	623
624	624	if (Flag)
625	625	{

                 set;
+            }
             /// <summary>
             /// Control Select
             /// </summary>
             /// <param name="Control"></param>
             /// <param name="dragrect"></param>
             /// <returns></returns>
             public Boolean control_Select(object Control, Rect dragrect)
+            {
                 DragRect = dragrect;
                 ItemRect(Control);
                 if (DragRect.Contains(itemRect))
                     return true;
                 else
                     return false;
+            }
             /// <summary>
             /// return bounding box of given control
             /// </summary>
             /// <param name="control"></param>
             /// <history>humkyung 2018.06.14 return bouding box of the control</history>
             public Rect ItemRect(object control)
+            {
                 s_point = new Point();
                 e_point = new Point();
                 if (control.GetType().Name == "TextControl")
+                {
                     s_point.X = (control as TextControl).CanvasX;
                     s_point.Y = (control as TextControl).CanvasY;
                     Point length = new Point();
                     double angle = (control as TextControl).Angle;
                     angle = Math.PI * angle / 180;
                     length.X = (control as TextControl).BoxWidth * Math.Cos(angle) - (control as TextControl).BoxHeight * Math.Sin(angle);
                     length.Y = (control as TextControl).BoxWidth * Math.Sin(angle) + (control as TextControl).BoxHeight * Math.Cos(angle);
                     e_point.X = s_point.X + length.X;
                     e_point.Y = s_point.Y + length.Y;
                     rectSize = e_point - s_point;
                     itemRect = new Rect(s_point, new Point(s_point.X + rectSize.X, s_point.Y + rectSize.Y));
                     return itemRect;
+                }
                 switch ((control as IMarkupCommonData).ControlType)
+                {
                     #region Shape
                     case (ControlType.Rectangle):
+                        {
                             s_point.X = Math.Min((control as RectangleControl).StartPoint.X, (control as RectangleControl).EndPoint.X);
                             s_point.Y = Math.Min((control as RectangleControl).StartPoint.Y, (control as RectangleControl).EndPoint.Y);
                             e_point.X = Math.Max((control as RectangleControl).StartPoint.X, (control as RectangleControl).EndPoint.X);
                             e_point.Y = Math.Max((control as RectangleControl).StartPoint.Y, (control as RectangleControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Circle):
+                        {
                             s_point.X = Math.Min((control as CircleControl).StartPoint.X, (control as CircleControl).EndPoint.X);
                             s_point.Y = Math.Min((control as CircleControl).StartPoint.Y, (control as CircleControl).EndPoint.Y);
                             e_point.X = Math.Max((control as CircleControl).StartPoint.X, (control as CircleControl).EndPoint.X);
                             e_point.Y = Math.Max((control as CircleControl).StartPoint.Y, (control as CircleControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.RectCloud):
+                        {
                             s_point.X = Math.Min((control as RectCloudControl).StartPoint.X, (control as RectCloudControl).EndPoint.X);
                             s_point.Y = Math.Min((control as RectCloudControl).StartPoint.Y, (control as RectCloudControl).EndPoint.Y);
                             e_point.X = Math.Max((control as RectCloudControl).StartPoint.X, (control as RectCloudControl).EndPoint.X);
                             e_point.Y = Math.Max((control as RectCloudControl).StartPoint.Y, (control as RectCloudControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Triangle):
+                        {
                             s_point.X = Math.Min((control as TriControl).StartPoint.X, (control as TriControl).EndPoint.X);
                             s_point.X = Math.Min((control as TriControl).MidPoint.X, s_point.X);
                             s_point.Y = Math.Min((control as TriControl).StartPoint.Y, (control as TriControl).EndPoint.Y);
                             s_point.Y = Math.Min((control as TriControl).MidPoint.Y, s_point.Y);
                             e_point.X = Math.Max((control as TriControl).StartPoint.X, (control as TriControl).EndPoint.X);
                             e_point.X = Math.Max((control as TriControl).MidPoint.X, e_point.X);
                             e_point.Y = Math.Max((control as TriControl).StartPoint.Y, (control as TriControl).EndPoint.Y);
                             e_point.Y = Math.Max((control as TriControl).MidPoint.Y, e_point.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     #endregion
                     #region Line
                     case (ControlType.SingleLine):
+                        {
                             s_point.X = Math.Min((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             s_point.Y = Math.Min((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             e_point.X = Math.Max((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             e_point.Y = Math.Max((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowLine):
+                        {
                             s_point.X = Math.Min((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             s_point.Y = Math.Min((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             e_point.X = Math.Max((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             e_point.Y = Math.Max((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowMultiLine):
+                        {
                             s_point.X = Math.Min((control as ArrowControl_Multi).StartPoint.X, (control as ArrowControl_Multi).EndPoint.X);
                             s_point.X = Math.Min((control as ArrowControl_Multi).MiddlePoint.X, s_point.X);
                             s_point.Y = Math.Min((control as ArrowControl_Multi).StartPoint.Y, (control as ArrowControl_Multi).EndPoint.Y);
                             s_point.Y = Math.Min((control as ArrowControl_Multi).MiddlePoint.Y, s_point.Y);
                             e_point.X = Math.Max((control as ArrowControl_Multi).StartPoint.X, (control as ArrowControl_Multi).EndPoint.X);
                             e_point.X = Math.Max((control as ArrowControl_Multi).MiddlePoint.X, e_point.X);
                             e_point.Y = Math.Max((control as ArrowControl_Multi).StartPoint.Y, (control as ArrowControl_Multi).EndPoint.Y);
                             e_point.Y = Math.Max((control as ArrowControl_Multi).MiddlePoint.Y, e_point.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.CancelLine):
+                        {
                             s_point.X = Math.Min((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             s_point.Y = Math.Min((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             e_point.X = Math.Max((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             e_point.Y = Math.Max((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.DimLine):
+                        {
                             s_point.X = Math.Min((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             s_point.Y = Math.Min((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             e_point.X = Math.Max((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             e_point.Y = Math.Max((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.TwinLine):
+                        {
                             s_point.X = Math.Min((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             s_point.Y = Math.Min((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             e_point.X = Math.Max((control as LineControl).StartPoint.X, (control as LineControl).EndPoint.X);
                             e_point.Y = Math.Max((control as LineControl).StartPoint.Y, (control as LineControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArcLine):
+                        {
                             s_point.X = Math.Min((control as ArcControl).StartPoint.X, (control as ArcControl).EndPoint.X);
                             s_point.X = Math.Min((control as ArcControl).MidPoint.X, s_point.X);
                             s_point.Y = Math.Min((control as ArcControl).StartPoint.Y, (control as ArcControl).EndPoint.Y);
                             s_point.Y = Math.Min((control as ArcControl).MidPoint.Y, s_point.Y);
                             e_point.X = Math.Max((control as ArcControl).StartPoint.X, (control as ArcControl).EndPoint.X);
                             e_point.X = Math.Max((control as ArcControl).MidPoint.X, e_point.X);
                             e_point.Y = Math.Max((control as ArcControl).StartPoint.Y, (control as ArcControl).EndPoint.Y);
                             e_point.Y = Math.Max((control as ArcControl).MidPoint.Y, e_point.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArcArrow):
+                        {
                             s_point.X = Math.Min((control as ArrowArcControl).StartPoint.X, (control as ArrowArcControl).EndPoint.X);
                             s_point.X = Math.Min((control as ArrowArcControl).MidPoint.X, s_point.X);
                             s_point.Y = Math.Min((control as ArrowArcControl).StartPoint.Y, (control as ArrowArcControl).EndPoint.Y);
                             s_point.Y = Math.Min((control as ArrowArcControl).MidPoint.Y, s_point.Y);
                             e_point.X = Math.Max((control as ArrowArcControl).StartPoint.X, (control as ArrowArcControl).EndPoint.X);
                             e_point.X = Math.Max((control as ArrowArcControl).MidPoint.X, e_point.X);
                             e_point.Y = Math.Max((control as ArrowArcControl).StartPoint.Y, (control as ArrowArcControl).EndPoint.Y);
                             e_point.Y = Math.Max((control as ArrowArcControl).MidPoint.Y, e_point.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     #endregion
                     #region Polygon
                     case (ControlType.Ink):
+                        {
                             s_point.X = Math.Min((control as PolygonControl).StartPoint.X, (control as PolygonControl).EndPoint.X);
                             s_point.Y = Math.Min((control as PolygonControl).StartPoint.Y, (control as PolygonControl).EndPoint.Y);
                             e_point.X = Math.Max((control as PolygonControl).StartPoint.X, (control as PolygonControl).EndPoint.X);
                             e_point.Y = Math.Max((control as PolygonControl).StartPoint.Y, (control as PolygonControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ChainLine):
+                        {
                             //rectSize
                             foreach (Point A in (control as PolygonControl).PointSet)
+                            {
                                 if (s_point == new Point())
+                                {
                                     s_point = A;
                                     e_point = A;
+                                }
                                 s_point.X = Math.Min(s_point.X, A.X);
                                 s_point.Y = Math.Min(s_point.Y, A.Y);
                                 e_point.X = Math.Max(e_point.X, A.X);
                                 e_point.Y = Math.Max(e_point.Y, A.Y);
+                            }
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.PolygonControl):
+                        {
                             //rectSize
                             foreach (Point A in (control as PolygonControl).PointSet)
+                            {
                                 if (s_point == new Point())
+                                {
                                     s_point = A;
                                     e_point = A;
+                                }
                                 s_point.X = Math.Min(s_point.X, A.X);
                                 s_point.Y = Math.Min(s_point.Y, A.Y);
                                 e_point.X = Math.Max(e_point.X, A.X);
                                 e_point.Y = Math.Max(e_point.Y, A.Y);
+                            }
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.PolygonCloud):
+                        {
                             //rectSize
                             foreach (Point A in (control as CloudControl).PointSet)
+                            {
                                 if (s_point == new Point())
+                                {
                                     s_point = A;
                                     e_point = A;
+                                }
                                 s_point.X = Math.Min(s_point.X, A.X);
                                 s_point.Y = Math.Min(s_point.Y, A.Y);
                                 e_point.X = Math.Max(e_point.X, A.X);
                                 e_point.Y = Math.Max(e_point.Y, A.Y);
+                            }
                             rectSize = e_point - s_point;
+                        }
                         break;
                     #endregion
                     #region Text
                     //case (ControlType.TextControl):
                     //    {
                     //        s_point.X = (control as TextControl).CanvasX;
                     //        s_point.Y = (control as TextControl).CanvasY;
                     //        e_point.X = s_point.X + (control as TextControl).BoxWidth;
                     //        e_point.Y = s_point.Y + (control as TextControl).BoxHeight;
                     //        rectSize = e_point - s_point;
                     //    }
                     //    break;
                     //case (ControlType.TextBorder):
                     //    {
                     //        s_point.X = (control as TextControl).CanvasX;
                     //        s_point.Y = (control as TextControl).CanvasY;
                     //        e_point.X = s_point.X + (control as TextControl).BoxWidth;
                     //        e_point.Y = s_point.Y + (control as TextControl).BoxHeight;
                     //        rectSize = e_point - s_point;
                     //    }
                     //    break;
                     //case (ControlType.TextCloud):
                     //    {
                     //        s_point.X = (control as TextControl).CanvasX;
                     //        s_point.Y = (control as TextControl).CanvasY;
                     //        e_point.X = s_point.X + (control as TextControl).BoxWidth;
                     //        e_point.Y = s_point.Y + (control as TextControl).BoxHeight;
                     //        rectSize = e_point - s_point;
                     //    }
                     //    break;
                     #endregion
                     #region ArrowText
                     case (ControlType.ArrowTextControl):
+                        {
                             s_point.X = Math.Min((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowTransTextControl):
+                        {
                             s_point.X = Math.Min((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowTextBorderControl):
+                        {
                             s_point.X = Math.Min((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowTransTextBorderControl):
+                        {
                             s_point.X = Math.Min((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowTextCloudControl):
+                        {
                             s_point.X = Math.Min((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ArrowTransTextCloudControl):
+                        {
                             s_point.X = Math.Min((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ArrowTextControl).StartPoint.X, (control as ArrowTextControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ArrowTextControl).StartPoint.Y, (control as ArrowTextControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     #endregion
                     #region ETC
                     case (ControlType.Date):
+                        {
                             s_point.X = Math.Min((control as DateControl).StartPoint.X, (control as DateControl).EndPoint.X);
                             s_point.Y = Math.Min((control as DateControl).StartPoint.Y, (control as DateControl).EndPoint.Y);
                             e_point.X = Math.Max((control as DateControl).StartPoint.X, (control as DateControl).EndPoint.X);
                             e_point.Y = Math.Max((control as DateControl).StartPoint.Y, (control as DateControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ImgControl):
+                        {
                             s_point.X = Math.Min((control as ImgControl).StartPoint.X, (control as ImgControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ImgControl).StartPoint.Y, (control as ImgControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ImgControl).StartPoint.X, (control as ImgControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ImgControl).StartPoint.Y, (control as ImgControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Sign):
+                        {
                             s_point.X = Math.Min((control as SignControl).StartPoint.X, (control as SignControl).EndPoint.X);
                             s_point.Y = Math.Min((control as SignControl).StartPoint.Y, (control as SignControl).EndPoint.Y);
                             e_point.X = Math.Max((control as SignControl).StartPoint.X, (control as SignControl).EndPoint.X);
                             e_point.Y = Math.Max((control as SignControl).StartPoint.Y, (control as SignControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Symbol):
+                        {
                             s_point.X = Math.Min((control as SymControl).StartPoint.X, (control as SymControl).EndPoint.X);
                             s_point.Y = Math.Min((control as SymControl).StartPoint.Y, (control as SymControl).EndPoint.Y);
                             e_point.X = Math.Max((control as SymControl).StartPoint.X, (control as SymControl).EndPoint.X);
                             e_point.Y = Math.Max((control as SymControl).StartPoint.Y, (control as SymControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Mark):
+                        {
                             s_point.X = Math.Min((control as RectangleControl).StartPoint.X, (control as RectangleControl).EndPoint.X);
                             s_point.Y = Math.Min((control as RectangleControl).StartPoint.Y, (control as RectangleControl).EndPoint.Y);
                             e_point.X = Math.Max((control as RectangleControl).StartPoint.X, (control as RectangleControl).EndPoint.X);
                             e_point.Y = Math.Max((control as RectangleControl).StartPoint.Y, (control as RectangleControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Stamp):
+                        {
                             s_point.X = Math.Min((control as SymControlN).StartPoint.X, (control as SymControlN).EndPoint.X);
                             s_point.Y = Math.Min((control as SymControlN).StartPoint.Y, (control as SymControlN).EndPoint.Y);
                             e_point.X = Math.Max((control as SymControlN).StartPoint.X, (control as SymControlN).EndPoint.X);
                             e_point.Y = Math.Max((control as SymControlN).StartPoint.Y, (control as SymControlN).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     #endregion
                     #region Cad
                     case (ControlType.InsideWhite):
+                        {
                             s_point.X = Math.Min((control as InsideWhiteControl).StartPoint.X, (control as InsideWhiteControl).EndPoint.X);
                             s_point.Y = Math.Min((control as InsideWhiteControl).StartPoint.Y, (control as InsideWhiteControl).EndPoint.Y);
                             e_point.X = Math.Max((control as InsideWhiteControl).StartPoint.X, (control as InsideWhiteControl).EndPoint.X);
                             e_point.Y = Math.Max((control as InsideWhiteControl).StartPoint.Y, (control as InsideWhiteControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.OverlapWhite):
+                        {
                             s_point.X = Math.Min((control as OverlapWhiteControl).StartPoint.X, (control as OverlapWhiteControl).EndPoint.X);
                             s_point.Y = Math.Min((control as OverlapWhiteControl).StartPoint.Y, (control as OverlapWhiteControl).EndPoint.Y);
                             e_point.X = Math.Max((control as OverlapWhiteControl).StartPoint.X, (control as OverlapWhiteControl).EndPoint.X);
                             e_point.Y = Math.Max((control as OverlapWhiteControl).StartPoint.Y, (control as OverlapWhiteControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.ClipWhite):
+                        {
                             s_point.X = Math.Min((control as ClipWhiteControl).StartPoint.X, (control as ClipWhiteControl).EndPoint.X);
                             s_point.Y = Math.Min((control as ClipWhiteControl).StartPoint.Y, (control as ClipWhiteControl).EndPoint.Y);
                             e_point.X = Math.Max((control as ClipWhiteControl).StartPoint.X, (control as ClipWhiteControl).EndPoint.X);
                             e_point.Y = Math.Max((control as ClipWhiteControl).StartPoint.Y, (control as ClipWhiteControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                     case (ControlType.Coordinate):
+                        {
                             s_point.X = Math.Min((control as CoordinateControl).StartPoint.X, (control as CoordinateControl).EndPoint.X);
                             s_point.Y = Math.Min((control as CoordinateControl).StartPoint.Y, (control as CoordinateControl).EndPoint.Y);
                             e_point.X = Math.Max((control as CoordinateControl).StartPoint.X, (control as CoordinateControl).EndPoint.X);
                             e_point.Y = Math.Max((control as CoordinateControl).StartPoint.Y, (control as CoordinateControl).EndPoint.Y);
                             rectSize = e_point - s_point;
+                        }
                         break;
                         #endregion
+                }
                 itemRect = new Rect(s_point.X, s_point.Y, rectSize.X, rectSize.Y);
                 return itemRect;
+            }
             /// <summary>
             /// Control Select 여부 확인
             /// </summary>

     <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
       <PropertyGroup>
         <ReferencePath>C:\Users\Admin\Downloads\KCOM 2018-02-04(통합)\KCOM\x64\;C:\Users\Admin\Downloads\KCOM 2018-02-04(통합)\KCOM\x86\</ReferencePath>
         <ProjectView>ShowAllFiles</ProjectView>
         <ProjectView>ProjectFiles</ProjectView>
       </PropertyGroup>
       <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
         <StartArguments>eyJEb2N1bWVudEl0ZW1JRCI6IjQwMDAwMTQyIiwiYlBhcnRuZXIiOmZhbHNlLCJDcmVhdGVGaW5hbFBERlBlcm1pc3Npb24iOnRydWUsIk5ld0NvbW1lbnRQZXJtaXNzaW9uIjp0cnVlLCJQcm9qZWN0Tk8iOiIwMDAwMDAiLCJVc2VySUQiOiJhZG1pbiIsIk1vZGUiOjB9</StartArguments>

                 CommentUserInfo selected = null;
                 double dMinDiff = double.MaxValue;
                 Move tmp = new Move();
                 foreach (var item in Items)
+                {
                     Rect boundingBox = tmp.ItemRect(item);
                     Rect boundingBox = item.ItemRect;
                     double dx = rect.X - boundingBox.X;
                     double dy = rect.Y - boundingBox.Y;
                     double dxx = rect.Right - boundingBox.Right;
-...
                 foreach (var item in Items)
+                {
                     Flag = move.control_Select(item, dragRect);
                     Flag = SelectionSet.Instance.SelectControl(item, dragRect);
                     if (Flag)
+                    {

     using System.Collections.Generic;
     using System.Linq;
     using System.Text;
     using System.Windows;
     using System.Windows.Media;
     namespace MarkupToPDF.Common
-...
             /// <summary>
             /// subclass has to override this property
             /// </summary>
             public virtual bool IsSelected{ get; set; }
             public virtual bool IsSelected { get; set; }
             /// <summary>
             /// subclass has to override this property
-...
                     GROUP_ID = this.GroupID
                 };
+            }
             /// <summary>
             /// return item's area
             /// </summary>
             public virtual Rect ItemRect
+            {
                 get;
+            }
+        }
+    }

+            }
             /// <summary>
             /// return ClipWhiteControl's area
             /// </summary>
             /// <author>humkyung</author>
             /// <date>2019.06.13</date>
             public override Rect ItemRect
+            {
                 get
+                {
                     double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);
                     double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);
                     double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);
                     double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);
                     return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
+                }
+            }
             /// <summary>
             /// Serialize this
             /// </summary>
             /// <param name="sUserId"></param>

+            }
             /// <summary>
             /// return CoordinateControl's area
             /// </summary>
             /// <author>humkyung</author>
             /// <date>2019.06.13</date>
             public override Rect ItemRect
+            {
                 get
+                {
                     double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);
                     double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);
                     double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);
                     double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);
                     return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
+                }
+            }
             /// <summary>
             /// Serialize this
             /// </summary>
             /// <param name="sUserId"></param>

+            }
             /// <summary>
             /// return InsideWhiteControl's area
             /// </summary>
             /// <author>humkyung</author>
             /// <date>2019.06.13</date>
             public override Rect ItemRect
+            {
                 get
+                {
                     double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);
                     double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);
                     double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);
                     double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);
                     return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
+                }
+            }
             /// <summary>
             /// Serialize this
             /// </summary>
             /// <param name="sUserId"></param>

     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;
     using MarkupToPDF.Serialize.Core;
     using MarkupToPDF.Serialize.S_Control;
     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");
+                }
+            }
             public override bool IsSelected
+            {
                 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();
+            }
             /// <summary>
             /// return OverlapWhiteControl's area
             /// </summary>
             /// <author>humkyung</author>
             /// <date>2019.06.13</date>
             public override Rect ItemRect
+            {
                 get
+                {
                     double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);
                     double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);
                     double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);
                     double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);
                     return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
+                }
+            }
             /// <summary>
             /// Serialize this
             /// </summary>
             /// <param name="sUserId"></param>
             /// <returns></returns>
             public override string Serialize()
+            {
                 using (S_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()));
                 };
+            }
             /// <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
                     };
+                }
+            }
             public event PropertyChangedEventHandler PropertyChanged;
             public void Dispose()
+            {
                 GC.Collect();
                 GC.SuppressFinalize(this);
+            }
             #endregion Internal Method
+        }
+    }

     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;
     using MarkupToPDF.Serialize.Core;
     using MarkupToPDF.Serialize.S_Control;
     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

... 이 차이점은 표시할 수 있는 최대 줄수를 초과해서 이 차이점은 잘렸습니다.

내보내기 Unified diff

프로젝트

일반

사용자정보

MARKUS

개정판 a5b465dc

프로젝트

일반

사용자정보

MARKUS

개정판 a5b465dc

연결된 일감