MARKUS

                        resourcePath += "arrowarc.png";

                case "ArrowArcControl":

                    MemberSet.Add(new AdornerMember { DrawingData = member, Drawingtype = ControlType.ArcArrow, ThumbList = new List<Thumb>() });

                    break;

                    case "ArrowArcControl":

                        MemberSet.Add(new AdornerMember { DrawingData = member, Drawingtype = ControlType.ArcArrow, ThumbList = new List<Thumb>() });

                        break;

                if ((markT == ControlType.ArcLine && list[i] == (member as ArcControl).MidPoint) || (markT == ControlType.ArcArrow && list[i] == (member as ArrowArcControl).MidPoint))

                        case ControlType.ArcArrow:

                    if (item.Drawingtype == ControlType.SingleLine || item.Drawingtype == ControlType.ArcLine || item.Drawingtype == ControlType.ArrowMultiLine || item.Drawingtype == ControlType.ArcArrow)

                        case ControlType.ArcArrow:

                        case ControlType.ArcArrow:

                else if ((MemberSet.First() as AdornerMember).DrawingData.GetType().Name == "ArrowArcControl")

                {

                    ArrowArcControl instance = ((MemberSet.First() as AdornerMember).DrawingData as ArrowArcControl);

                    if (instance.isTransOn)

                    {

                        instance.isTransOn = false;

                    }

                    else

                    {

                        instance.isTransOn = true;

                    }

                    instance.SetArcPath();

                    BorderUpdate();

                }

                        case ("ArrowArcControl"):

                            {

                                (InnerItem.DrawingData as MarkupToPDF.Controls.Line.ArrowArcControl).LineSize = ViewerDataModel.Instance.LineSize;

                            }

                            break;

                                    case ("ArrowArcControl"):

                                        {

                                            (InnerItem.DrawingData as MarkupToPDF.Controls.Line.ArrowArcControl).DashSize = (cbDashStyle.SelectedValue as DashStyle).dashData;

                                        }

                                        break;

                    #region ArrowArc

                    case "ArrowArc":

                        Common.ViewerDataModel.Instance.SelectedControl = "ArrowArc";

                        instanceMain.dzMainMenu.controlType = MarkupToPDF.Controls.Common.ControlType.ArcArrow;

                        //HiddenAxisLock.Visibility = Visibility.Visible;

                        TaskMessage("ArcArrow 코멘트 도구는 오른쪽 마우스를 사용해 좌우 반전을 사용하실 수 있습니다", TaskMessageType.Normal);

                        break;

                    #endregion

                        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);

  <ItemGroup>

    <Resource Include="Resources\Images\MenuImage_New\arrowarc.png" />

  </ItemGroup>

                case "ArrowArcControl":

                    {

                        (control as ArrowArcControl).StrokeColor = Brushes.Red;

                    }

                    break;

                                var control = currentControl as ArrowArcControl;

                                    control.isTransOn = false;

                                    control.StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y);

                                    control.MidPoint = new Point(0, 0);

                                    control.EndPoint = new Point(currentCanvasDrawingMouseMovePoint.X, currentCanvasDrawingMouseMovePoint.Y);

                                    Point tempPoint = control.EndPoint;

                                    if (ViewerDataModel.Instance.checkAxis || ViewerDataModel.Instance.IsPressShift)

                                        ViewerDataModel.Instance.AngleValue = MathSet.returnAngleString(control.StartPoint, ref tempPoint, true);

                                        control.EndPoint = tempPoint;

                                        ViewerDataModel.Instance.AngleValue = MathSet.returnAngleString(control.StartPoint, ref tempPoint, false);

                                if (currentControl is ArrowArcControl)

                                {

                                    //20180906 LJY TEST IsRotationDrawingEnable

                                    if (IsGetoutpoint((currentControl as ArrowArcControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                        return;

                                    }

                                    CreateControl();

                                    (currentControl as ArrowArcControl).ApplyOverViewData();

                                    currentControl = null;

                                    this.MainAngle.Visibility = Visibility.Collapsed;

                                }

                                else

                                {

                                    currentControl = new ArrowArcControl

                                        Background = new SolidColorBrush(Colors.Black)

                                    };

                                    currentControl.CommentID = Save.shortGuid();

                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;

                                    currentControl.IsNew = true;

                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);

                                    this.MainAngle.Visibility = Visibility.Visible;

                                }

                                if (currentControl != null)

                                {

                                    (currentControl as ArrowArcControl).setClock();

                                    (currentControl as ArrowArcControl).MidPoint = new Point(0, 0);

                                    //(currentControl as ArcControl).ApplyTemplate();

                                }

                                <telerik:RadToggleButton CommandParameter="ArrowArc" Grid.Column="1" Grid.Row="2"  Tag="ArrowArc" Width="30" Height="30" Click="ControlEvent">

                                    <Image Source="/KCOM;component/Resources/Images/MenuImage_New/arrowarc.png" />

                                </telerik:RadToggleButton>

                                <telerik:RadToggleButton CommandParameter="ChainLine" Grid.Column="2" Grid.Row="2" Tag="Chain"  Width="30" Height="30" Click="ControlEvent">

using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.ComponentModel;

using System.Collections.Generic;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Common;

namespace MarkupToPDF.Controls.Line

{

    public class ArrowArcControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IMarkupCommonData, IDashControl

    {

        #region 초기선언

        public event PropertyChangedEventHandler PropertyChanged;

        private const string PART_ArcPath = "PART_ArcPath";

        public Path Base_ArcPath = null;

        #endregion

        static ArrowArcControl()

        {

            DefaultStyleKeyProperty.OverrideMetadata(typeof(ArrowArcControl), new FrameworkPropertyMetadata(typeof(ArrowArcControl)));

            //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);

            ResourceDictionary dictionary = new ResourceDictionary();

            dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);

            Application.Current.Resources.MergedDictionaries.Add(dictionary);

             //System.Diagnostics.Debug.WriteLine("resource Count :" + Application.Current.Resources.MergedDictionaries.Count);

        }

        public ArrowArcControl()

        {

            this.DefaultStyleKey = typeof(ArrowArcControl);

        }

        public void Dispose()

        {

            GC.Collect();

            GC.SuppressFinalize(this);

            Control control = new Control();

        }

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        #region Dependency Properties

        public static readonly DependencyProperty IsSelectedProperty =

    DependencyProperty.Register("IsSelected", typeof(bool), typeof(ArrowArcControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));

        public static readonly DependencyProperty ControlTypeProperty =

    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(ArrowArcControl), new FrameworkPropertyMetadata(ControlType.ArcArrow));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

                "OverViewPathData", typeof(Geometry), typeof(ArrowArcControl), new PropertyMetadata(null));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

                "UserID", typeof(string), typeof(ArrowArcControl), new PropertyMetadata(null));

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

              "LineSize", typeof(double), typeof(ArrowArcControl), new PropertyMetadata((Double)3, PointValueChanged));

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

              "DashSize", typeof(DoubleCollection), typeof(ArrowArcControl), new PropertyMetadata(new DoubleCollection { 99999999 }, PointValueChanged));

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

               "StrokeColor", typeof(SolidColorBrush), typeof(ArrowArcControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

              "PathData", typeof(Geometry), typeof(ArrowArcControl), null);

        //public static readonly DependencyProperty ClockProperty = DependencyProperty.Register(

        //       "Clock", typeof(SweepDirection), typeof(ArrowArcControl), new PropertyMetadata(SweepDirection.Clockwise));

        public static readonly DependencyProperty ClockProperty = DependencyProperty.Register(

               "Clock", typeof(bool), typeof(ArrowArcControl), new PropertyMetadata(false));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

               "StartPoint", typeof(Point), typeof(ArrowArcControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty MidPointProperty = DependencyProperty.Register(

               "MidPoint", typeof(Point), typeof(ArrowArcControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

               "EndPoint", typeof(Point), typeof(ArrowArcControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

                "PointSet", typeof(List<Point>), typeof(ArrowArcControl), new PropertyMetadata(new List<Point>(), PointValueChanged));

        public static readonly DependencyProperty isTransOnProperty = DependencyProperty.Register(

                "isTransOn", typeof(bool), typeof(ArrowArcControl), new PropertyMetadata(false));

        public static readonly DependencyProperty AngleProperty =

            DependencyProperty.Register("AngleValue", typeof(double), typeof(ArrowArcControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback

                (AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty =

            DependencyProperty.Register("CenterX", typeof(double), typeof(ArrowArcControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty =

            DependencyProperty.Register("CenterY", typeof(double), typeof(ArrowArcControl), new PropertyMetadata((double)0, OnCenterXYChanged));

        #endregion

        #region PropertyChanged Method

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (ArrowArcControl)sender;

            //if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)

            //{

            //    instance.SetValue(e.Property, e.NewValue);

            //    if (instance.IsSelected)

            //    {

            //        instance.Base_ArcPath.Stroke = new SolidColorBrush(Colors.Blue);

            //    }

            //    else

            //    {

            //        instance.Base_ArcPath.Stroke = new SolidColorBrush(Colors.Red);

            //    }

            //}

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowArcControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetArcPath();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowArcControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetArcPath();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ArrowArcControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetArcPath();

            }

        }

        #endregion

        #region Properties

        public string UserID

        {

            get { return (string)GetValue(UserIDProperty); }

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public Double LineSize

        {

            get { return (Double)GetValue(LineSizeProperty); }

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public bool Clock

        {

            get { return (bool)GetValue(ClockProperty); }

            set

            {

                if (this.Clock != value)

                {

                    SetValue(ClockProperty, value);

                    OnPropertyChanged("Clock");

                }

            }

        }

        //public SweepDirection Clock

        //{

        //    get { return (SweepDirection)GetValue(ClockProperty); }

        //    set

        //    {

        //        if (this.Clock != value)

        //        {

        //            SetValue(ClockProperty, value);

        //            OnPropertyChanged("Clock");

        //        }

        //    }

        //}

        public DoubleCollection DashSize

        {

            get { return (DoubleCollection)GetValue(DashSizeProperty); }

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                }

            }

        }

        public List<Point> PointSet

        {

            get { return (List<Point>)GetValue(PointSetProperty); }

            set { SetValue(PointSetProperty, value); }

        }

        public double CenterX

        {

            get { return (double)GetValue(CenterXProperty); }

            set { SetValue(CenterXProperty, value); }

        }

        public double CenterY

        {

            get { return (double)GetValue(CenterYProperty); }

            set { SetValue(CenterYProperty, value); }

        }

        public SolidColorBrush StrokeColor

        {

            get { return (SolidColorBrush)GetValue(StrokeColorProperty); }

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                }

            }

        }

        public Geometry OverViewPathData

        {

            get

            {

                return (Geometry)GetValue(OverViewPathDataProperty);

            }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public Geometry PathData

        {

            get { return (Geometry)GetValue(PathDataProperty); }

            set

            {

                SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        public bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, value);

                OnPropertyChanged("ControlType");

            }

        }

        public double AngleValue

        {

            get { return (double)GetValue(AngleProperty); }

            set { SetValue(AngleProperty, value); }

        }

        public double Angle

        {

            get { return (double)GetValue(AngleProperty); }

            set

            {

                if (this.Angle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public Point EndPoint

        {

            get { return (Point)GetValue(EndPointProperty); }

            set

            {

                SetValue(EndPointProperty, value);

                OnPropertyChanged("EndPoint");

            }

        }

        public Point StartPoint

        {

            get { return (Point)GetValue(StartPointProperty); }

            set

            {

                SetValue(StartPointProperty, value);

                OnPropertyChanged("StartPoint");

            }

        }

        public Point MidPoint

        {

            get { return (Point)GetValue(MidPointProperty); }

            set

            {

                SetValue(MidPointProperty, value);

                OnPropertyChanged("MidPoint");

            }

        }

        public bool isTransOn

        {

            get { return (bool)GetValue(isTransOnProperty); }

            set

            {

                SetValue(isTransOnProperty, value);

                OnPropertyChanged("isTransOn");

            }

        }

        #endregion

        #region Object & Variable

        PathGeometry pathGeometry = new PathGeometry();

        GeometryGroup instanceGroup = new GeometryGroup();

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_ArcPath = GetTemplateChild(PART_ArcPath) as Path;

            SetArcPath();

        }

        public void updateControl()

        {

            this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);

            this.MidPoint = new Point(this.PointSet[1].X, this.PointSet[1].Y);

            this.EndPoint = new Point(this.PointSet[2].X, this.PointSet[2].Y);

        }

        public void setClock()

        {

            if (Clock)

            {

                this.Clock = false;

            }

            else

            {

                this.Clock = true;

            }

        }

        //public void setClock()

        //{

        //    if(this.Clock == SweepDirection.Clockwise)

        //    {

        //        this.Clock = SweepDirection.Counterclockwise;

        //    }

        //    else

        //    {

        //        this.Clock =SweepDirection.Clockwise;

        //    }

        //}

        public void SetArcPath()

        {

            this.ApplyTemplate();

            //강인구 추가

            Base_ArcPath.StrokeDashArray.Clear();

            if (this.DashSize != null)

            {

                foreach (var item in this.DashSize)

                {

                    Base_ArcPath.StrokeDashArray.Add(item);

                }

                Base_ArcPath.StrokeDashCap = PenLineCap.Square;

                instanceGroup.Children.Clear();

            }

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = this.StartPoint;

            QuadraticBezierSegment qb = new QuadraticBezierSegment();

            if (MidPoint != null)

            {

                if (MidPoint == new Point(0,0))

                {

                    double xSharp = 0;

                    double ySharp = 0;

                    //Point t_start = new Point(0, 0);

                    //Point t_end = new Point(30, 10);

                    var midP = MathSet.getMiddlePoint(StartPoint, EndPoint);

                    Point normalV = MathSet.GetNormVectorBetween(StartPoint, EndPoint);

                    var dis = MathSet.DistanceTo(StartPoint, EndPoint);

                    if (!this.Clock)

                    {

                        xSharp = -normalV.Y;

                        ySharp = normalV.X;

                    }

                    else

                    {

                        xSharp = normalV.Y;

                        ySharp = -normalV.X;

                    }

                    var pointN = new Point(xSharp * dis, ySharp * dis);

                    MidPoint = new Point(pointN.X + midP.X, pointN.Y + midP.Y);

                }

                qb.Point1 = this.MidPoint;

            }

            qb.Point2 = this.EndPoint;

            pathFigure.Segments.Add(qb);

            pathGeometry.Figures = new PathFigureCollection();

            pathGeometry.Figures.Add(pathFigure);

            pathFigure.IsFilled = false;

            pathFigure.IsClosed = false;

            instanceGroup.Children.Add(pathGeometry);

            //화살표하나추가

            instanceGroup.Children.Add(SingleAllow(this.MidPoint, this.StartPoint, this.LineSize));

            //화살표 두개 추가시에는 밑에 꺼 쓰면 됨

            //instanceGroup.Children.Add(ConverseAllow(this.EndPoint, this.MidPoint, this.LineSize));

            this.Base_ArcPath.Fill = this.StrokeColor;

            //Base_ArcPath.StrokeThickness = 3;

            instanceGroup.FillRule = FillRule.Nonzero;

            this.PathData = instanceGroup;

            this.OverViewPathData = PathData;

        }

        public static PathGeometry SingleAllow(Point p2, Point p1, double lineSize)

        {

            double theta = Math.Atan2((p2.Y - p1.Y), (p2.X - p1.X)) * 180 / Math.PI;

            PathGeometry pathGeometry = new PathGeometry();

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = p1;

            Point lpoint = new Point(p1.X + lineSize * 2, p1.Y + lineSize * 4);

            Point rpoint = new Point(p1.X - lineSize * 2, p1.Y + lineSize * 4);

            LineSegment seg1 = new LineSegment();

            seg1.Point = lpoint;

            pathFigure.Segments.Add(seg1);

            LineSegment seg2 = new LineSegment();

            seg2.Point = rpoint;

            pathFigure.Segments.Add(seg2);

            LineSegment seg3 = new LineSegment();

            seg3.Point = p1;

            pathFigure.Segments.Add(seg3);

            pathFigure.IsClosed = true;

            pathFigure.IsFilled = true;

            pathGeometry.Figures.Add(pathFigure);

            pathGeometry.FillRule = FillRule.Nonzero;

            RotateTransform transform = new RotateTransform();

            transform.Angle = theta - 90;

            transform.CenterX = p1.X;

            transform.CenterY = p1.Y;

            pathGeometry.Transform = transform;

            return pathGeometry;

        }

        public static PathGeometry ConverseAllow(Point p2, Point p1, double lineSize)

        {

            double theta = Math.Atan2((p2.Y - p1.Y), (p2.X - p1.X)) * 180 / Math.PI;

            PathGeometry pathGeometry2 = new PathGeometry();

            PathFigure pathFigure2 = new PathFigure();

            pathFigure2.StartPoint = p2;

            Point lpoint2 = new Point(p2.X + lineSize * 2, p2.Y + lineSize * 4);

            Point rpoint2 = new Point(p2.X - lineSize * 2, p2.Y + lineSize * 4);

            LineSegment seg1_1 = new LineSegment();

            seg1_1.Point = lpoint2;

            pathFigure2.Segments.Add(seg1_1);

            LineSegment seg2_1 = new LineSegment();

            seg2_1.Point = rpoint2;

            pathFigure2.Segments.Add(seg2_1);

            LineSegment seg3_1 = new LineSegment();

            seg3_1.Point = p2;

            pathFigure2.Segments.Add(seg3_1);

            LineSegment seg4_1 = new LineSegment();

            seg4_1.Point = new Point(lpoint2.X, lpoint2.Y);

            pathFigure2.Segments.Add(seg4_1);

            //pathFigure2.IsFilled = true;

            //pathFigure2.IsClosed = true;

            RotateTransform transform2 = new RotateTransform();

            transform2.Angle = theta + 90;

            transform2.CenterX = p2.X;

            transform2.CenterY = p2.Y;

            pathGeometry2.Figures.Add(pathFigure2);

            pathGeometry2.Transform = transform2;

            return pathGeometry2;

        }

        public void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

    }

}

                #region ArrowArc

                case "ArrowArcControl":

                    using (S_ArrowArcControl STemp = new S_ArrowArcControl())

                    {

                        var instance = Control as ArrowArcControl;

                        STemp.TransformPoint = "0|0";

                        STemp.PointSet = instance.PointSet;

                        STemp.SizeSet = String.Format("{0}", instance.LineSize);

                        //STemp.StrokeColor = "#FF000FFF";

                        STemp.StrokeColor = instance.StrokeColor.Color.ToString();

                        STemp.StartPoint = instance.StartPoint;

                        STemp.UserID = UserId;

                        STemp.Opac = instance.Opacity;

                        STemp.MidPoint = instance.MidPoint;

                        STemp.EndPoint = instance.EndPoint;

                        STemp.IsTransOn = instance.isTransOn;

                        STemp.DashSize = instance.DashSize;

                        STemp.Clock = instance.Clock;

                        //STemp.ArcStyleSet = instance.ControlType;

                        STemp.Name = instance.GetType().Name.ToString();

                        ///강인구 추가(2017.11.02)

                        ///Memo 추가

                        STemp.Memo = instance.Memo;

                        ///강인구 추가(2017.11.02)

                        ///DATA_TYPE추가로 인한 클래스 변수 대입

                        //ConvertData += "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));

                        Data.DATA_TYPE = (int)(instance.ControlType);

                        Data.ConvertData += "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));

                    };

                    break;

                #endregion

                #endregion

                    #region ArrowArc

                    case "ArrowArcControl":

                        using (S_ArrowArcControl STemp = new S_ArrowArcControl())

                        {

                            var instance = item as ArrowArcControl;

                            STemp.TransformPoint = "0|0";

                            STemp.PointSet = instance.PointSet;

                            STemp.SizeSet = String.Format("{0}", instance.LineSize);

                            //STemp.StrokeColor = "#FF000FFF";

                            STemp.StrokeColor = instance.StrokeColor.Color.ToString();

                            STemp.StartPoint = instance.StartPoint;

                            STemp.UserID = UserId;

                            STemp.Opac = instance.Opacity;

                            STemp.MidPoint = instance.MidPoint;

                            STemp.EndPoint = instance.EndPoint;

                            STemp.IsTransOn = instance.isTransOn;

                            STemp.DashSize = instance.DashSize;

                            STemp.Clock = instance.Clock;

                            //STemp.ArcStyleSet = instance.ControlType;

                            STemp.Name = instance.GetType().Name.ToString();

                            ConvertData += "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));

                        };

                        break;

                    #endregion

                        #region ArrowArc

                        case "ArrowArcControl":

                            using (S_ArrowArcControl s = JsonSerializerHelper.JsonDeserialize<S_ArrowArcControl>(item))

                            {

                                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                                ArrowArcControl instance = new ArrowArcControl()

                                {

                                    StartPoint = s.StartPoint,

                                    EndPoint = s.EndPoint,

                                    DashSize = s.DashSize,

                                    PointSet = s.PointSet,

                                    isTransOn = s.IsTransOn,

                                    MidPoint = s.MidPoint,

                                    StrokeColor = _SetColor,

                                    Opacity = s.Opac,

                                    Clock = s.Clock,

                                    LineSize = Convert.ToDouble(data2.First()),

                                    UserID = s.UserID,

                                };

                                Layer.Children.Add(instance);

                                instance.ApplyTemplate();

                                instance.SetArcPath();

                            }

                            break;

                        #endregion

                        #endregion

                        #region ArrowArc

                        case "ArrowArcControl":

                            using (S_ArrowArcControl s = JsonSerializerHelper.JsonDeserialize<S_ArrowArcControl>(item))

                            {

                                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                                ArrowArcControl instance = new ArrowArcControl()

                                {

                                    StartPoint = s.StartPoint,

                                    EndPoint = s.EndPoint,

                                    DashSize = s.DashSize,

                                    PointSet = s.PointSet,

                                    isTransOn = s.IsTransOn,

                                    MidPoint = s.MidPoint,

                                    StrokeColor = _SetColor,

                                    Clock = s.Clock,

                                    Opacity = s.Opac,

                                    LineSize = Convert.ToDouble(data2.First()),

                                    UserID = s.UserID,

                                };

                                instance.Memo = s.Memo;

                                //Layer.Children.Add(instance);

                                instance.MarkupInfoID = markupInfoID;

                                baseLayer.Add(instance);

                                instance.ApplyTemplate();

                                instance.SetArcPath();

                            }

                            break;

                        #endregion                        

                        #region ArrowArc

                        case "ArrowArcControl":

                            using (S_ArrowArcControl s = JsonSerializerHelper.JsonDeserialize<S_ArrowArcControl>(item))

                            {

                                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                                ArrowArcControl instance = new ArrowArcControl()

                                {

                                    StartPoint = s.StartPoint,

                                    EndPoint = s.EndPoint,

                                    DashSize = s.DashSize,

                                    PointSet = s.PointSet,

                                    isTransOn = s.IsTransOn,

                                    MidPoint = s.MidPoint,

                                    StrokeColor = _SetColor,

                                    Clock = s.Clock,

                                    Opacity = s.Opac,

                                    LineSize = Convert.ToDouble(data2.First()),

                                    UserID = s.UserID,

                                };

                                instance.Memo = s.Memo;

                                //Layer.Children.Add(instance);

                                instance.MarkupInfoID = markupInfoID;

                                baseLayer.Add(instance);

                                instance.CommentID = commentId;

                                instance.ApplyTemplate();

                                instance.SetArcPath();

                            }

                            break;

                        #endregion

                        #region ArrowArc

                        case "ArrowArcControl":

                            using (S_ArrowArcControl s = JsonSerializerHelper.JsonDeserialize<S_ArrowArcControl>(item))

                            {

                                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                                ArrowArcControl instance = new ArrowArcControl()

                                {

                                    StartPoint = s.StartPoint,

                                    EndPoint = s.EndPoint,

                                    DashSize = s.DashSize,

                                    PointSet = s.PointSet,

                                    isTransOn = s.IsTransOn,

                                    MidPoint = s.MidPoint,

                                    StrokeColor = _SetColor,

                                    Opacity = s.Opac,

                                    Clock = s.Clock,

                                    LineSize = Convert.ToDouble(data2.First()),

                                    UserID = s.UserID,

                                };

                                baseLayer.Add(instance);

                                instance.ApplyTemplate();

                                instance.OnApplyTemplate();

                                instance.SetArcPath();

                                return_control = instance;

                            }

                            break;

                        #endregion

                        #endregion

                        #region Arc

                        case "ArrowArcControl":

                            using (S_ArrowArcControl s = JsonSerializerHelper.JsonDeserialize<S_ArrowArcControl>(item))

                            {

                                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                                ArrowArcControl instance = new ArrowArcControl()

                                {

                                    StartPoint = s.StartPoint,

                                    EndPoint = s.EndPoint,

                                    DashSize = s.DashSize,

                                    PointSet = s.PointSet,

                                    isTransOn = s.IsTransOn,

                                    MidPoint = s.MidPoint,

                                    StrokeColor = _SetColor,

                                    Clock = s.Clock,

                                    Opacity = s.Opac,

                                    LineSize = Convert.ToDouble(data2.First()),

                                    UserID = s.UserID,

                                };

                                instance.Memo = s.Memo;

                                //Layer.Children.Add(instance);

                                instance.MarkupInfoID = markupInfoID;

                                baseLayer.Add(instance);

                                instance.CommentID = commentId;

                                instance.ApplyTemplate();

                                instance.SetArcPath();

                                return_control = instance;

                            }

                            break;

                        #endregion

    <Compile Include="Controls\Line\ArrowArcControl.cs" />

    <Compile Include="Serialize\S_Control\Detail\S_ArrowArcControl.cs" />

using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.Runtime.Serialization;

using System.Collections.Generic;

using MarkupToPDF.Controls.Common;

namespace MarkupToPDF.Serialize.S_Control

{

    [DataContract]

    public class S_ArrowArcControl : S_BaseControl, IDisposable

    {

        [DataMember]

        public Point MidPoint { get; set; } // Mid Point

        [DataMember]

        public string SizeSet { get; set; } // "LineSize|"

        [DataMember]

        public string StrokeColor { get; set; } //Hex Data

        [DataMember]

        public DoubleCollection DashSize { get; set; }

        [DataMember]

        public bool Clock { get; set; } //변형여부

        [DataMember]

        public Boolean IsTransOn { get; set; } //변형여부

        public void Dispose()

        {

            GC.Collect(0, GCCollectionMode.Forced);

            GC.SuppressFinalize(this);

        }

    }

}

    <Style TargetType="{x:Type Line:ArrowArcControl}">

        <Setter Property="Template">

            <Setter.Value>

                <ControlTemplate TargetType="{x:Type Line:ArrowArcControl}">

                    <Path x:Name="PART_ArcPath" 

                          Stroke="{TemplateBinding StrokeColor}"  

                          StrokeThickness="{TemplateBinding LineSize}"

                          Data="{TemplateBinding PathData}" 

                          RenderTransformOrigin="0.5,0.5" 

                          Fill="{TemplateBinding StrokeColor}">

                    </Path>

                </ControlTemplate>

            </Setter.Value>

        </Setter>

    </Style>