MARKUS

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;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

using System.Linq;

using System.ServiceModel.Activation;

using System.Windows.Markup;

namespace MarkupToPDF.Controls.Shape

{

    public class RectCloudControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IShapeControl, IDashControl

    {

        #region 초기 선언

        private const string PART_ArcPath = "PART_ArcPath";

        private const string PART_BodyPath = "PART_BodyPath";

        public event PropertyChangedEventHandler PropertyChanged;

        public Path Base_ArcPath = null;

        public Path Base_BodyPath = null;

        private const double _CloudArcDepth = 0.8;  /// 2018.05.14 added by humkyung

        #endregion

        static RectCloudControl()

        {

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

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

            //ResourceDictionary dictionary = new ResourceDictionary();

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

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

        }

        public override void Copy(CommentUserInfo lhs)

        {

            if (lhs is RectCloudControl rectCloudControl)

            {

                this.StartPoint = new System.Windows.Point(rectCloudControl.StartPoint.X, rectCloudControl.StartPoint.Y);

                this.EndPoint = new System.Windows.Point(rectCloudControl.EndPoint.X, rectCloudControl.EndPoint.Y);

                this.LeftBottomPoint = new System.Windows.Point(rectCloudControl.LeftBottomPoint.X, rectCloudControl.LeftBottomPoint.Y);

                this.TopRightPoint = new System.Windows.Point(rectCloudControl.TopRightPoint.X, rectCloudControl.TopRightPoint.Y);

                this.Paint = rectCloudControl.Paint;

                this.Opacity = rectCloudControl.Opacity;

                this.DashSize = rectCloudControl.DashSize;

                this.PointSet = rectCloudControl.PointSet.ConvertAll(x => new System.Windows.Point(x.X, x.Y));

                this.StrokeColor = rectCloudControl.StrokeColor;

                this.ArcLength = rectCloudControl.ArcLength;

                this.LineSize = rectCloudControl.LineSize;

                this.UserID = rectCloudControl.UserID;

                this.Memo = rectCloudControl.Memo;

                this.ZIndex = rectCloudControl.ZIndex;

            }

        }

        public override CommentUserInfo Clone()

        {

            var clone = new RectCloudControl();

            clone.Copy(this);

            return clone;

        }

        #region Dependency Properties

        public static readonly DependencyProperty mousemodeProperty =

                DependencyProperty.Register("mousemode", typeof(MouseMode), typeof(RectangleControl), new PropertyMetadata(MouseMode.None, PointValueChanged));

        public static readonly DependencyProperty IsSelectedProperty =

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

        public static readonly DependencyProperty ControlTypeProperty =

    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(RectCloudControl), new FrameworkPropertyMetadata(ControlType.RectCloud));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

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

        //강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(

                "FillColor", typeof(SolidColorBrush), typeof(RectCloudControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        //강인구 추가

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

                "Paint", typeof(PaintSet), typeof(RectCloudControl), new PropertyMetadata(PaintSet.None, PointValueChanged));

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty PathSubDataProperty = DependencyProperty.Register(

                "PathSubData", typeof(Geometry), typeof(RectCloudControl), null);

        public static readonly DependencyProperty ArcLengthProperty = DependencyProperty.Register(

        "ArcLength", typeof(double), typeof(RectCloudControl), new PropertyMetadata((Double)10, PointValueChanged));

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(

              "TopRightPoint", typeof(Point), typeof(RectCloudControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(

                "LeftBottomPoint", typeof(Point), typeof(RectCloudControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register("AngleValue", typeof(double), typeof(RectCloudControl),

            new PropertyMetadata((double)0.0, new PropertyChangedCallback(PointValueChanged)));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register("CenterX", typeof(double), typeof(RectCloudControl),

            new PropertyMetadata((double)0, PointValueChanged));

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register("CenterY", typeof(double), typeof(RectCloudControl),

            new PropertyMetadata((double)0, PointValueChanged));

        #endregion

        #region PropertyChanged Method

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (RectCloudControl)sender;

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

            {

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

                instance.SetRectCloud();

            }

        }

        #endregion

        #region Properties

        public MouseMode mousemode

        {

            get

            {

                return (MouseMode)GetValue(mousemodeProperty);

            }

            set

            {

                SetValue(mousemodeProperty, value);

                OnPropertyChanged("mousemode");

            }

        }

        public Double LineSize

        {

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

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public DoubleCollection DashSize

        {

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

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                }

            }

        }

        public string UserID

        {

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

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public PaintSet Paint

        {

            get { return (PaintSet)GetValue(PaintProperty); }

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, value);

                }

            }

        }

        public SolidColorBrush FillColor

        {

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

            set

            {

                if (this.FillColor != value)

                {

                    SetValue(FillColorProperty, value);

                }

            }

        }

        public override 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); }

        }

        public Geometry PathSubData

        {

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

            set { SetValue(PathSubDataProperty, value); }

        }

        public Point EndPoint

        {

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

            set { SetValue(EndPointProperty, value); }

        }

        public Point StartPoint

        {

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

            set { SetValue(StartPointProperty, value); }

        }

        public List<Point> PointSet

        {

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

            set { SetValue(PointSetProperty, value); }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public override ControlType ControlType

        {

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

            set

            {

                SetValue(ControlTypeProperty, value);

            }

        }

        public Double ArcLength

        {

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

            set

            {

                if (this.ArcLength != value)

                {

                    SetValue(ArcLengthProperty, value);

                    OnPropertyChanged("ArcLength");

                }

            }

        }

        private double _toler = 1;

        public double Toler

        {

            get { return _toler; }

            set { _toler = value; }

        }

        //private double _arcLength = 30;

        //public double ArcLength

        //{

        //    get { return _arcLength; }

        //    set { _arcLength = value; }

        //}

        private bool _fill = false;

        public bool Fill

        {

            get { return _fill; }

            set { _fill = value; }

        }

        public double CommentAngle

        {

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

            set

            {

                if (this.CommentAngle != value)

                {

                    SetValue(AngleProperty, 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 Point LeftBottomPoint

        {

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

            set

            {

                SetValue(LeftBottomPointProperty, value);

                OnPropertyChanged("LeftBottomPoint");

            }

        }

        public Point TopRightPoint

        {

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

            set

            {

                SetValue(TopRightPointProperty, value);

                OnPropertyChanged("TopRightPoint");

            }

        }

        #endregion

        #region Data

        private PathGeometry _pathGeometry = new PathGeometry();

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_ArcPath = GetTemplateChild(PART_ArcPath) as Path;

            Base_BodyPath = GetTemplateChild(PART_BodyPath) as Path;

            this.SetRectCloud();

        }

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public void Dispose()

        {

            //GC.Collect();

            ////GC.SuppressFinalize(this);

            this.Base_ArcPath = null;

            this.Base_BodyPath = null;

        }

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (RectCloudControl)sender;

            //if (e.OldValue != e.NewValue && instance.Base_BodyPath != 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);

            //    }

            //}

        }

        private void SetRectCloud()

        {

            this.ApplyTemplate();

            PathFigure pathFigure = new PathFigure();

            Base_ArcPath.StrokeDashArray.Clear();

            Base_BodyPath.StrokeDashArray.Clear();

            foreach (var item in this.DashSize)

            {

                Base_ArcPath.StrokeDashArray.Add(item);

                Base_BodyPath.StrokeDashArray.Add(item);

            }

            switch (this.Paint)

            {

                case PaintSet.None:

                    //강인구 추가

                    pathFigure.IsFilled = false;

                    Base_BodyPath.Fill = null;

                    Base_BodyPath.Stroke = null;

                    break;

                case PaintSet.Fill:

                    {

                        Base_BodyPath.Stroke = this.StrokeColor;

                        Base_BodyPath.StrokeThickness = 0.5;

                        Base_ArcPath.Stroke = this.StrokeColor;

                        Base_ArcPath.Fill = this.FillColor;

                        Base_BodyPath.Fill = this.FillColor;

                    }

                    //this.FillColor = this.StrokeColor;

                    //Base_BodyPath.Fill = this.FillColor;

                    //Base_ArcPath.Fill = this.FillColor;

                    //Base_BodyPath.Stroke = this.StrokeColor;

                    //Base_BodyPath.StrokeThickness = 2;

                    //Base_ArcPath.Stroke = this.StrokeColor;

                    //Base_ArcPath.StrokeThickness = 2;

                    //pathFigure.IsFilled = true;

                    break;

                case PaintSet.Hatch:

                    Base_BodyPath.Stroke = new SolidColorBrush(Colors.Transparent);

                    Base_BodyPath.StrokeThickness = 2;

                    Base_BodyPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor);

                    Base_ArcPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor);

                    pathFigure.IsFilled = true;

                    break;

                default:

                    break;

            }

            #region 사각형 만들기

            if (this.Paint != PaintSet.None)

            {

                pathFigure.StartPoint = this.StartPoint;

                List<Point> points = new List<Point>() { this.StartPoint, this.LeftBottomPoint, this.EndPoint, this.TopRightPoint };

                PolyLineSegment polyline = new PolyLineSegment(points, true);

                pathFigure.Segments.Add(polyline);

                PathGeometry pathGeometry = new PathGeometry();

                pathGeometry.Figures = new PathFigureCollection();

                pathFigure.IsClosed = true;

                pathGeometry.Figures.Add(pathFigure);

                //this.FillColor = new SolidColorBrush(Colors.Red);

                this.PathSubData = pathGeometry;

            }

            ArcLength = ArcLength == 0 ? 10 : ArcLength;

            #endregion

            #region Cloud 만들기

            /// set reverse if area is greater 0 - 2012.07.04 added by humkyung

            /// 

            System.Diagnostics.Debug.WriteLine(ArcLength);

            double area = MathSet.AreaOf(new List<Point>() { this.StartPoint, this.LeftBottomPoint, this.EndPoint, this.TopRightPoint });

            bool reverse = (area > 0);

            /// up to here

            this._pathGeometry = new PathGeometry();

            int count = this.PointSet.Count;

            PathFigure pathSubFigure = Polygon.CloudControl.GenerateLineWithCloud(this.StartPoint, this.LeftBottomPoint, this.ArcLength, reverse);

            _pathGeometry.Figures.Add(pathSubFigure);

            pathSubFigure = Polygon.CloudControl.GenerateLineWithCloud(this.LeftBottomPoint, this.EndPoint, this.ArcLength, reverse);

            _pathGeometry.Figures.Add(pathSubFigure);

            pathSubFigure = Polygon.CloudControl.GenerateLineWithCloud(this.EndPoint, this.TopRightPoint, this.ArcLength, reverse);

            _pathGeometry.Figures.Add(pathSubFigure);

            pathSubFigure = Polygon.CloudControl.GenerateLineWithCloud(this.TopRightPoint, this.StartPoint, this.ArcLength, reverse);

            _pathGeometry.Figures.Add(pathSubFigure);

            if (this.Paint != PaintSet.None)

            {

                foreach (var item in _pathGeometry.Figures)

                {

                    item.IsFilled = true;

                }

            }

            this.PathData = _pathGeometry;

            ApplyOverViewData();

            #endregion

        }

        public void ChangePaint(PaintSet state)

        {

            this.Paint = state;

            this.SetRectCloud();

        }

        public void CloseSettingPoint()

        {

            this.PointSet[0] = this.StartPoint;

            this.PointSet[1] = this.LeftBottomPoint;

            this.PointSet[2] = this.EndPoint;

            this.PointSet[3] = this.TopRightPoint;

        }

        public override void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

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

        }

        /// <summary>

        /// call when mouse is moving while drawing control

        /// </summary>

        /// <author>humkyung</author>

        /// <param name="pt"></param>

        /// <param name="bAxisLocked"></param>

        public override void OnCreatingMouseMove(Point pt, bool bAxisLocked)

        {

            this.EndPoint = bAxisLocked ? this.GetSquareEndPoint(this.StartPoint, pt) : pt;

            this.LeftBottomPoint = new Point(this.StartPoint.X, this.EndPoint.Y);

            this.TopRightPoint = new Point(this.EndPoint.X, this.StartPoint.Y);

            this.PointSet = new List<Point>

            {

                this.StartPoint,

                this.LeftBottomPoint,

                this.EndPoint,

                this.TopRightPoint,

            };

        }

        /// <summary>

        /// move control point has same location of given pt along given delta

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.20</date>

        /// <param name="pt"></param>

        /// <param name="dx"></param>

        /// <param name="dy"></param>

        public override void OnMoveCtrlPoint(Point pt, double dx, double dy, bool bAxisLocked = false)

        {

            IPath path = (this as IPath);

            Point selected = MathSet.getNearPoint(path.PointSet, pt);

            selected.X += dx;

            selected.Y += dy;

            int i = 0;

            for (i = 0; i < (this as IPath).PointSet.Count; i++)

            {

                if (pt.Equals((this as IPath).PointSet[i]))

                {

                    (this as IPath).PointSet[i] = selected;

                    break;

                }

            }

            var OppositeP = (i + path.PointSet.Count / 2) % path.PointSet.Count;

            var PreviousP = (i + (path.PointSet.Count - 1)) % path.PointSet.Count;

            var NextP = (i + 1) % path.PointSet.Count;

            if (bAxisLocked)

            {

                double _dx = path.PointSet[i].X - path.PointSet[OppositeP].X;

                double _dy = path.PointSet[i].Y - path.PointSet[OppositeP].Y;

                double distance = Math.Max(Math.Abs(_dx), Math.Abs(_dy));

                var PreviousV = path.PointSet[PreviousP] - path.PointSet[OppositeP];

                PreviousV.Normalize();

                path.PointSet[PreviousP] = path.PointSet[OppositeP] + PreviousV * distance;

                var NextV = path.PointSet[NextP] - path.PointSet[OppositeP];

                NextV.Normalize();

                path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * distance;

                path.PointSet[i] = path.PointSet[OppositeP] + PreviousV * distance + NextV * distance;

            }

            else

            {

                var PreviousV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[PreviousP]);

                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X,

                    path.PointSet[i].Y - path.PointSet[OppositeP].Y);

                Point pPrevious = new Point(path.PointSet[OppositeP].X + PreviousV.X * l, path.PointSet

                    [OppositeP].Y + PreviousV.Y * l);

                if (path.PointSet.FindAll(x => x.Equals(pPrevious)).Count() == 0)

                {

                    path.PointSet[PreviousP] = pPrevious;

                }

                var NextV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[NextP]);

                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X, path.PointSet

                    [i].Y - path.PointSet[OppositeP].Y);

                Point pNext = new Point(path.PointSet[OppositeP].X + NextV.X * l, path.PointSet[OppositeP].Y + NextV.Y * l);

                if (path.PointSet.FindAll(x => x.Equals(pNext)).Count() == 0)

                {

                    path.PointSet[NextP] = pNext;

                }

            }

            this.UpdateControl();

        }

        /// <summary>

        /// return rectcloudcontrols' 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_RectCloudControl ctrl = new S_RectCloudControl())

            {

                ctrl.TransformPoint = "0|0";

                ctrl.PointSet = this.PointSet;

                ctrl.SizeSet = String.Format("{0}", this.LineSize);

                //ctrl.StrokeColor = "#FF00FF00";

                ctrl.StrokeColor = this.StrokeColor.Color.ToString();

                ctrl.StartPoint = this.StartPoint;

                ctrl.UserID = this.UserID;

                ctrl.Opac = this.Opacity;

                ctrl.TR = this.TopRightPoint;

                ctrl.LB = this.LeftBottomPoint;

                ctrl.EndPoint = this.EndPoint;

                ctrl.PaintState = this.Paint;

                ctrl.DashSize = this.DashSize;

                ctrl.ArcLength = this.ArcLength;

                ctrl.Name = this.GetType().Name.ToString();

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                ctrl.Memo = this.Memo;

                ctrl.ZIndex = this.ZIndex;

                return "|DZ|" + JsonSerializerHelper.CompressString((ctrl.JsonSerialize()));

            }

        }

        /// <summary>

        /// create a rectcloudcontrol from given string

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static RectCloudControl FromString(string str, SolidColorBrush brush, string sProjectNo)

        {

            using (S_RectCloudControl s = JsonSerializerHelper.JsonDeserialize<S_RectCloudControl>(str))

            {

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

                return new RectCloudControl()

                {

                    StartPoint = s.StartPoint,

                    EndPoint = s.EndPoint,

                    LeftBottomPoint = s.LB,

                    Paint = s.PaintState,

                    Opacity = s.Opac,

                    DashSize = s.DashSize,

                    TopRightPoint = s.TR,

                    PointSet = s.PointSet,

                    StrokeColor = brush,

                    ArcLength = s.ArcLength,

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

                    UserID = s.UserID,

                    Memo = s.Memo,

                    ZIndex = s.ZIndex

                };

            }

        }

    }

}