프로젝트

일반

사용자정보

통계
| 브랜치(Branch): | 개정판:

markus / MarkupToPDF / Controls / Line / ArcControl.cs @ 056e4dfd

이력 | 보기 | 이력해설 | 다운로드 (23.2 KB)

1
using System;
2
using System.Net;
3
using System.Windows;
4
using System.Windows.Controls;
5
using System.Windows.Documents;
6
using System.Windows.Ink;
7
using System.Windows.Input;
8
using System.Windows.Media;
9
using System.Windows.Media.Animation;
10
using System.Windows.Shapes;
11
using System.ComponentModel;
12
using System.Collections.Generic;
13
using MarkupToPDF.Controls.Common;
14
using MarkupToPDF.Common;
15
using MarkupToPDF.Serialize.S_Control;
16
using MarkupToPDF.Serialize.Core;
17
using System.Linq;
18

    
19
namespace MarkupToPDF.Controls.Line
20
{
21

    
22
    public class ArcControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IMarkupCommonData, IDashControl
23
    {
24
        #region 초기선언
25
        public event PropertyChangedEventHandler PropertyChanged;
26
        private const string PART_ArcPath = "PART_ArcPath";
27
        public Path Base_ArcPath = null;
28
        #endregion
29
        static ArcControl()
30
        {
31
            DefaultStyleKeyProperty.OverrideMetadata(typeof(ArcControl), new FrameworkPropertyMetadata(typeof(ArcControl)));
32
            //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);
33
            //ResourceDictionary dictionary = new ResourceDictionary();
34
            //dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);
35
            //Application.Current.Resources.MergedDictionaries.Add(dictionary);
36
             //System.Diagnostics.Debug.WriteLine("resource Count :" + Application.Current.Resources.MergedDictionaries.Count);
37
        }
38

    
39
        public ArcControl()
40
        {
41
            //this.DefaultStyleKey = typeof(ArcControl);
42
        }
43

    
44
        public void Dispose()
45
        {
46
            //GC.Collect();
47
            //GC.SuppressFinalize(this);
48
            //Control control = new Control();
49
            this.Base_ArcPath = null;
50
        }
51
        protected void OnPropertyChanged(string propName)
52
        {
53
            if (PropertyChanged != null)
54
                PropertyChanged(this, new PropertyChangedEventArgs(propName));
55
        }
56

    
57
        #region Dependency Properties
58

    
59
        
60

    
61
        public static readonly DependencyProperty IsSelectedProperty =
62
    DependencyProperty.Register("IsSelected", typeof(bool), typeof(ArcControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));
63

    
64
        public static readonly DependencyProperty ControlTypeProperty =
65
    DependencyProperty.Register("ControlType", typeof(ControlType), typeof(ArcControl), new FrameworkPropertyMetadata(ControlType.ArcLine));
66

    
67
        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(
68
                "OverViewPathData", typeof(Geometry), typeof(ArcControl), new PropertyMetadata(null));
69

    
70
        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(
71
                "UserID", typeof(string), typeof(ArcControl), new PropertyMetadata(null));
72
        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(
73
              "LineSize", typeof(double), typeof(ArcControl), new PropertyMetadata((Double)3));
74

    
75
//강인구 추가
76
        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(
77
              "DashSize", typeof(DoubleCollection), typeof(ArcControl), new PropertyMetadata(new DoubleCollection { 99999999 }, PointValueChanged));
78

    
79
        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(
80
               "StrokeColor", typeof(SolidColorBrush), typeof(ArcControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));
81

    
82
        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(
83
              "PathData", typeof(Geometry), typeof(ArcControl), null);
84

    
85
        //public static readonly DependencyProperty ClockProperty = DependencyProperty.Register(
86
        //       "Clock", typeof(SweepDirection), typeof(ArcControl), new PropertyMetadata(SweepDirection.Clockwise));
87
        public static readonly DependencyProperty ClockProperty = DependencyProperty.Register(
88
               "Clock", typeof(bool), typeof(ArcControl), new PropertyMetadata(false));
89

    
90
        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(
91
               "StartPoint", typeof(Point), typeof(ArcControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
92
        public static readonly DependencyProperty MidPointProperty = DependencyProperty.Register(
93
               "MidPoint", typeof(Point), typeof(ArcControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
94

    
95
        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(
96
               "EndPoint", typeof(Point), typeof(ArcControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));
97
        
98
        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(
99
                "PointSet", typeof(List<Point>), typeof(ArcControl), new PropertyMetadata(new List<Point>(), PointValueChanged));
100

    
101
        public static readonly DependencyProperty isTransOnProperty = DependencyProperty.Register(
102
                "isTransOn", typeof(bool), typeof(ArcControl), new PropertyMetadata(false));
103

    
104
        public static readonly DependencyProperty AngleProperty =
105
            DependencyProperty.Register("AngleValue", typeof(double), typeof(ArcControl), new PropertyMetadata((double)0.0, new PropertyChangedCallback
106
                (AngleValueChanged)));
107

    
108
        public static readonly DependencyProperty CenterXProperty =
109
            DependencyProperty.Register("CenterX", typeof(double), typeof(ArcControl), new PropertyMetadata((double)0, OnCenterXYChanged));
110

    
111
        public static readonly DependencyProperty CenterYProperty =
112
            DependencyProperty.Register("CenterY", typeof(double), typeof(ArcControl), new PropertyMetadata((double)0, OnCenterXYChanged));
113
        #endregion
114
        #region PropertyChanged Method
115
        
116
        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
117
        {
118
            //var instance = (ArcControl)sender;
119

    
120
            //if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)
121
            //{
122

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

    
125
            //    if (instance.IsSelected)
126
            //    {
127
            //        instance.Base_ArcPath.Stroke = new SolidColorBrush(Colors.Blue);
128
            //    }
129
            //    else
130
            //    {
131
            //        instance.Base_ArcPath.Stroke = new SolidColorBrush(Colors.Red);
132
            //    }
133
            //}
134
        }
135

    
136

    
137
        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
138
        {
139
            var instance = (ArcControl)sender;
140
            if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)
141
            {
142
                instance.SetValue(e.Property, e.NewValue);
143
                instance.SetArcPath();
144
            }
145
        }
146
        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
147
        {
148
            var instance = (ArcControl)sender;
149
            if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)
150
            {
151
                instance.SetValue(e.Property, e.NewValue);
152
                instance.SetArcPath();
153
            }
154
        }
155
        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
156
        {
157
            var instance = (ArcControl)sender;
158
            if (e.OldValue != e.NewValue && instance.Base_ArcPath != null)
159
            {
160
                instance.SetValue(e.Property, e.NewValue);
161
                instance.SetArcPath();
162
            }
163
        }
164

    
165
      
166

    
167
        #endregion
168
        #region Properties
169
        public string UserID
170
        {
171
            get { return (string)GetValue(UserIDProperty); }
172
            set
173
            {
174
                if (this.UserID != value)
175
                {
176
                    SetValue(UserIDProperty, value);
177
                    OnPropertyChanged("UserID");
178
                }
179
            }
180
        }
181
        public Double LineSize
182
        {
183
            get { return (Double)GetValue(LineSizeProperty); }
184
            set
185
            {
186
                if (this.LineSize != value)
187
                {
188
                    SetValue(LineSizeProperty, value);
189
                }
190
            }
191
        }
192

    
193

    
194
        public bool Clock
195
        {
196
            get { return (bool)GetValue(ClockProperty); }
197
            set
198
            {
199
                if (this.Clock != value)
200
                {
201
                    SetValue(ClockProperty, value);
202
                    OnPropertyChanged("Clock");
203
                }
204
            }
205
        }
206

    
207
        //public SweepDirection Clock
208
        //{
209
        //    get { return (SweepDirection)GetValue(ClockProperty); }
210
        //    set
211
        //    {
212
        //        if (this.Clock != value)
213
        //        {
214
        //            SetValue(ClockProperty, value);
215
        //            OnPropertyChanged("Clock");
216
        //        }
217
        //    }
218
        //}
219
        public DoubleCollection DashSize
220
        {
221
            get { return (DoubleCollection)GetValue(DashSizeProperty); }
222
            set
223
            {
224
                if (this.DashSize != value)
225
                {
226
                    SetValue(DashSizeProperty, value);
227
                }
228
            }
229
        }
230
        public List<Point> PointSet
231
        {
232
            get { return (List<Point>)GetValue(PointSetProperty); }
233
            set { SetValue(PointSetProperty, value); }
234
        }
235
        public double CenterX
236
        {
237
            get { return (double)GetValue(CenterXProperty); }
238
            set { SetValue(CenterXProperty, value); }
239
        }
240
        public double CenterY
241
        {
242
            get { return (double)GetValue(CenterYProperty); }
243
            set { SetValue(CenterYProperty, value); }
244
        }
245
        public override SolidColorBrush StrokeColor
246
        {
247
            get { return (SolidColorBrush)GetValue(StrokeColorProperty); }
248
            set
249
            {
250
                if (this.StrokeColor != value)
251
                {
252
                    SetValue(StrokeColorProperty, value);
253
                }
254
            }
255
        }
256

    
257
        public Geometry OverViewPathData
258
        {
259
            get
260
            {
261
                return (Geometry)GetValue(OverViewPathDataProperty);
262
            }
263
            set
264
            {
265
                SetValue(OverViewPathDataProperty, value);
266
                OnPropertyChanged("OverViewPathData");
267
            }
268
        }
269

    
270
        public Geometry PathData
271
        {
272
            get { return (Geometry)GetValue(PathDataProperty); }
273
            set
274
            {
275
                SetValue(PathDataProperty, value);
276
                OnPropertyChanged("PathData");
277
            }
278
        }
279
        public override bool IsSelected
280
        {
281
            get
282
            {
283
                return (bool)GetValue(IsSelectedProperty);
284
            }
285
            set
286
            {
287
                SetValue(IsSelectedProperty, value);
288
            }
289
        }
290

    
291
        public override ControlType ControlType
292
        {
293
            get
294
            {
295
                return (ControlType)GetValue(ControlTypeProperty);
296
            }
297
            set
298
            {
299
                SetValue(ControlTypeProperty, value);
300
                OnPropertyChanged("ControlType");
301
            }
302
        }
303
        public double AngleValue
304
        {
305
            get { return (double)GetValue(AngleProperty); }
306
            set { SetValue(AngleProperty, value); }
307
        }
308
        public double Angle
309
        {
310
            get { return (double)GetValue(AngleProperty); }
311
            set
312
            {
313
                if (this.Angle != value)
314
                {
315
                    SetValue(AngleProperty, value);
316
                }
317
            }
318
        }
319
        public Point EndPoint
320
        {
321
            get { return (Point)GetValue(EndPointProperty); }
322
            set
323
            {
324
                SetValue(EndPointProperty, value);
325
                OnPropertyChanged("EndPoint");
326
            }
327
        }
328
        public Point StartPoint
329
        {
330
            get { return (Point)GetValue(StartPointProperty); }
331
            set
332
            {
333
                SetValue(StartPointProperty, value);
334
                OnPropertyChanged("StartPoint");
335
            }
336
        }
337
        public Point MidPoint
338
        {
339
            get { return (Point)GetValue(MidPointProperty); }
340
            set
341
            {
342
                SetValue(MidPointProperty, value);
343
                OnPropertyChanged("MidPoint");
344
            }
345
        }
346
        public bool isTransOn
347
        {
348
            get { return (bool)GetValue(isTransOnProperty); }
349
            set
350
            {
351
                SetValue(isTransOnProperty, value);
352
                OnPropertyChanged("isTransOn");
353
            }
354
        }
355

    
356
        #endregion
357
        #region Object & Variable
358
        PathGeometry pathGeometry = new PathGeometry();
359
        GeometryGroup instanceGroup = new GeometryGroup();
360
        #endregion
361
        public override void OnApplyTemplate()
362
        {
363
            base.OnApplyTemplate();
364
            Base_ArcPath = GetTemplateChild(PART_ArcPath) as Path;
365
            SetArcPath();
366
        }
367

    
368
        public override void UpdateControl()
369
        {
370
            this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);
371
            this.MidPoint = new Point(this.PointSet[1].X, this.PointSet[1].Y);
372
            this.EndPoint = new Point(this.PointSet[2].X, this.PointSet[2].Y);
373
        }
374

    
375
        public void setClock()
376
        {
377
            if (Clock)
378
            {
379
                this.Clock = false;
380
            }
381
            else
382
            {
383
                this.Clock = true;
384
            }
385
        }
386

    
387
        //public void setClock()
388
        //{
389
        //    if(this.Clock == SweepDirection.Clockwise)
390
        //    {
391
        //        this.Clock = SweepDirection.Counterclockwise;
392
        //    }
393
        //    else
394
        //    {
395
        //        this.Clock =SweepDirection.Clockwise;
396
        //    }
397
        //}
398
        private void SetArcPath()
399
        {
400
            this.ApplyTemplate();
401

    
402

    
403
            //강인구 추가
404
            Base_ArcPath.StrokeDashArray.Clear();
405
            foreach (var item in this.DashSize)
406
            {
407
                Base_ArcPath.StrokeDashArray.Add(item);
408
            }
409
            instanceGroup.Children.Clear();
410

    
411

    
412
            PathFigure pathFigure = new PathFigure();
413

    
414
            pathFigure.StartPoint = this.StartPoint;
415
            QuadraticBezierSegment qb = new QuadraticBezierSegment();
416

    
417

    
418
          
419

    
420

    
421
            
422
            
423

    
424

    
425
            if (MidPoint != null)
426
            {
427
                if (MidPoint == new Point(0,0))
428
                {
429
                    double xSharp = 0;
430
                    double ySharp = 0;
431

    
432
                    //Point t_start = new Point(0, 0);
433
                    //Point t_end = new Point(30, 10);
434

    
435
                    var midP = MathSet.getMiddlePoint(StartPoint, EndPoint);
436
                    Point normalV = MathSet.GetNormVectorBetween(StartPoint, EndPoint);
437
                    var dis = MathSet.DistanceTo(StartPoint, EndPoint);
438

    
439
                    if (!this.Clock)
440
                    {
441
                        xSharp = -normalV.Y;
442
                        ySharp = normalV.X;
443
                    }
444
                    else
445
                    {
446
                        xSharp = normalV.Y;
447
                        ySharp = -normalV.X;
448
                    }
449

    
450
                    var pointN = new Point(xSharp * dis, ySharp * dis);
451
                    MidPoint = new Point(pointN.X + midP.X, pointN.Y + midP.Y);
452
                }
453
                ////System.Diagnostics.Debug.WriteLine(this.MidPoint.ToString());
454
                //qb.Point1 = new Point(200, 200);
455
                //qb.Point1 = this.MidPoint;
456
                qb.Point1 = this.MidPoint;
457
            }
458

    
459
            qb.Point2 = this.EndPoint;
460
            pathFigure.Segments.Add(qb);
461
            pathGeometry.Figures = new PathFigureCollection();
462
            pathGeometry.Figures.Add(pathFigure);
463
            pathFigure.IsFilled = false;
464
            pathFigure.IsClosed = false;
465
            instanceGroup.Children.Add(pathGeometry);
466

    
467
            //Arc Arrow
468
            //if(ControlType == ControlType.ArcArrow)
469
            if (isTransOn)
470
            {
471
                //isTransOn = true;
472
                instanceGroup.Children.Add(DrawSet.DrawArrow(this.MidPoint, this.StartPoint, this.LineSize));
473
                instanceGroup.Children.Add(DrawSet.DrawArrow(this.EndPoint, this.MidPoint, this.LineSize));
474
                this.Base_ArcPath.Fill = this.StrokeColor;
475
            }
476
            //Base_ArcPath.StrokeThickness = 3;
477

    
478
            instanceGroup.FillRule = FillRule.Nonzero;
479
            this.PathData = instanceGroup;
480
            this.OverViewPathData = PathData;
481

    
482
        }
483

    
484
        public static PathGeometry ConverseAllow(Point p2, Point p1, double lineSize)
485
        {
486
            double theta = Math.Atan2((p2.Y - p1.Y), (p2.X - p1.X)) * 180 / Math.PI;
487
            PathGeometry pathGeometry2 = new PathGeometry();
488
            PathFigure pathFigure2 = new PathFigure();
489
            pathFigure2.StartPoint = p2;
490

    
491
            Point lpoint2 = new Point(p2.X + lineSize * 2, p2.Y + lineSize * 4);
492
            Point rpoint2 = new Point(p2.X - lineSize * 2, p2.Y + lineSize * 4);
493
            LineSegment seg1_1 = new LineSegment();
494
            seg1_1.Point = lpoint2;
495
            pathFigure2.Segments.Add(seg1_1);
496

    
497
            LineSegment seg2_1 = new LineSegment();
498
            seg2_1.Point = rpoint2;
499
            pathFigure2.Segments.Add(seg2_1);
500

    
501
            LineSegment seg3_1 = new LineSegment();
502
            seg3_1.Point = p2;
503
            pathFigure2.Segments.Add(seg3_1);
504

    
505
            LineSegment seg4_1 = new LineSegment();
506

    
507
            seg4_1.Point = new Point(lpoint2.X, lpoint2.Y);
508
            pathFigure2.Segments.Add(seg4_1);
509

    
510
            //pathFigure2.IsFilled = true;
511
            //pathFigure2.IsClosed = true;
512

    
513
            RotateTransform transform2 = new RotateTransform();
514
            transform2.Angle = theta + 90;
515
            transform2.CenterX = p2.X;
516
            transform2.CenterY = p2.Y;
517
            pathGeometry2.Figures.Add(pathFigure2);
518
            pathGeometry2.Transform = transform2;
519
            return pathGeometry2;
520
        }
521

    
522
        public override void ApplyOverViewData()
523
        {
524
            this.OverViewPathData = this.PathData;
525
        }
526

    
527
        /// <summary>
528
        /// call when mouse is moving while drawing control
529
        /// </summary>
530
        /// <author>humkyung</author>
531
        /// <param name="pt"></param>
532
        /// <param name="bAxisLocked"></param>
533
        public override void OnCreatingMouseMove(Point pt, bool bAxisLocked, bool bShiftKeyPressed)
534
        {
535
            this.isTransOn = false;
536
            this.EndPoint = pt;
537
            this.MidPoint = new Point(0, 0);
538

    
539
            if (bAxisLocked || bShiftKeyPressed)
540
            {
541
                Point tmp = this.EndPoint;
542
                string angle = MathSet.returnAngleString(this.StartPoint, ref tmp, true);
543
                this.EndPoint = tmp;
544
            }
545

    
546
            this.PointSet = new List<Point>
547
            {
548
                this.StartPoint,
549
                this.MidPoint,
550
                this.EndPoint,
551
            };
552
        }
553

    
554
        /// <summary>
555
        /// move control point has same location of given pt along given delta
556
        /// </summary>
557
        /// <author>humkyung</author>
558
        /// <date>2019.06.20</date>
559
        /// <param name="pt"></param>
560
        /// <param name="dx"></param>
561
        /// <param name="dy"></param>
562
        public override void OnMoveCtrlPoint(Point pt, double dx, double dy)
563
        {
564
            Point selected = MathSet.getNearPoint((this as IPath).PointSet, pt);
565
            selected.X += dx;
566
            selected.Y += dy;
567
            for (int i = 0; i < (this as IPath).PointSet.Count; i++)
568
            {
569
                if (pt.Equals((this as IPath).PointSet[i]))
570
                {
571
                    (this as IPath).PointSet[i] = selected;
572
                }
573
            }
574
            this.UpdateControl();
575
        }
576

    
577
        /// <summary>
578
        /// return Arc's area
579
        /// </summary>
580
        /// <author>humkyung</author>
581
        /// <date>2019.06.13</date>
582
        public override Rect ItemRect
583
        {
584
            get
585
            {
586
                double dMinX = Math.Min(this.StartPoint.X, this.EndPoint.X);
587
                dMinX = Math.Min(this.MidPoint.X, dMinX);
588
                double dMinY = Math.Min(this.StartPoint.Y, this.EndPoint.Y);
589
                dMinY = Math.Min(this.MidPoint.Y, dMinY);
590
                double dMaxX = Math.Max(this.StartPoint.X, this.EndPoint.X);
591
                dMaxX = Math.Max(this.MidPoint.X, dMaxX);
592
                double dMaxY = Math.Max(this.StartPoint.Y, this.EndPoint.Y);
593
                dMaxY = Math.Max(this.MidPoint.Y, dMaxY);
594

    
595
                return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));
596
            }
597
        }
598

    
599
        /// <summary>
600
        /// Serialize this
601
        /// </summary>
602
        /// <param name="sUserId"></param>
603
        /// <returns></returns>
604
        public override string Serialize()
605
        {
606
            using (S_ArcControl STemp = new S_ArcControl())
607
            {
608
                STemp.TransformPoint = "0|0";
609
                STemp.PointSet = this.PointSet;
610
                STemp.SizeSet = String.Format("{0}", this.LineSize);
611
                //STemp.StrokeColor = "#FF000FFF";
612
                STemp.StrokeColor = this.StrokeColor.Color.ToString();
613
                STemp.StartPoint = this.StartPoint;
614
                STemp.UserID = this.UserID;
615
                STemp.Opac = this.Opacity;
616
                STemp.MidPoint = this.MidPoint;
617
                STemp.EndPoint = this.EndPoint;
618
                STemp.IsTransOn = this.isTransOn;
619
                STemp.DashSize = this.DashSize;
620
                STemp.Clock = this.Clock;
621
                //STemp.ArcStyleSet = instance.ControlType;
622
                STemp.Name = this.GetType().Name.ToString();
623

    
624
                ///강인구 추가(2017.11.02)
625
                ///Memo 추가
626
                STemp.Memo = this.Memo;
627

    
628
                return "|DZ|" + JsonSerializerHelper.CompressString((STemp.JsonSerialize()));
629
            }
630
        }
631

    
632
        /// <summary>
633
        /// create a arccontrol from given string
634
        /// </summary>
635
        /// <param name="str"></param>
636
        /// <returns></returns>
637
        public static ArcControl FromString(string str, SolidColorBrush brush, string sProjectNo)
638
        {
639
            ArcControl instance = null;
640
            using (S_ArcControl s = JsonSerializerHelper.JsonDeserialize<S_ArcControl>(str))
641
            {
642
                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);
643
                instance = new ArcControl()
644
                {
645
                    StartPoint = s.StartPoint,
646
                    EndPoint = s.EndPoint,
647
                    DashSize = s.DashSize,
648
                    PointSet = s.PointSet,
649
                    isTransOn = s.IsTransOn,
650
                    MidPoint = s.MidPoint,
651
                    StrokeColor = brush,
652
                    Opacity = s.Opac,
653
                    Clock = s.Clock,
654
                    LineSize = Convert.ToDouble(data2.First()),
655
                    UserID = s.UserID,
656
                    Memo = s.Memo
657
                };
658
            }
659

    
660
            return instance;
661
        }
662
    }
663
}
클립보드 이미지 추가 (최대 크기: 500 MB)