프로젝트

일반

사용자정보

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

markus / KCOM / Views / MainMenu.xaml.cs @ 37bd9e47

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

1

2
using MarkupToPDF.Controls.Common;
3
using MarkupToPDF.Controls.Line;
4
using MarkupToPDF.Controls.Polygon;
5
using MarkupToPDF.Controls.Shape;
6
using MarkupToPDF.Controls.Text;
7
using MarkupToPDF.Controls.Etc;
8
using System;
9
using System.Collections.Generic;
10
using System.Linq;
11
using System.Text;
12
using System.Windows;
13
using System.Windows.Controls;
14
using System.Windows.Data;
15
using System.Windows.Documents;
16
using System.Windows.Input;
17
using System.Windows.Media;
18
using System.Windows.Media.Imaging;
19
using System.Windows.Navigation;
20
using System.Windows.Shapes;
21
using KCOM.Common;
22
using IKCOM;
23
using System.Windows.Ink;
24
using System.Collections.ObjectModel;
25
using Telerik.Windows.Controls;
26
using KCOM.Events;
27
using System.Reflection;
28
using MarkupToPDF.Common;
29
using KCOM.Controls;
30
using KCOMDataModel.DataModel;
31
using System.Xml;
32
using static KCOM.TempFile;
33
using System.Windows.Threading;
34
using System.Diagnostics;
35
using System.Threading;
36
using System.Windows.Resources;
37
using Svg2Xaml;
38
using System.Runtime.InteropServices;
39
using System.Windows.Media.Effects;
40
using MarkupToPDF.Controls.Cad;
41
using MarkupToPDF.Controls.Parsing;
42
using Telerik.Windows.Data;
43
using System.ComponentModel;
44
using static KCOM.Controls.Sample;
45
using winform = System.Windows.Forms;
46
namespace KCOM.Views
47
{
48
    public static class ControlExtensions
49
    {
50
        public static T Clone<T>(this T controlToClone)
51
            where T : System.Windows.Controls.Control
52
        {
53
            System.Reflection.PropertyInfo[] controlProperties = typeof(T).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
54

    
55
            T instance = Activator.CreateInstance<T>();
56

    
57
            foreach (PropertyInfo propInfo in controlProperties)
58
            {
59
                if (propInfo.CanWrite)
60
                {
61
                    if (propInfo.Name != "WindowTarget")
62
                        propInfo.SetValue(instance, propInfo.GetValue(controlToClone, null), null);
63
                }
64
            }
65
            return instance;
66
        }
67
    }
68

    
69
    public class MyConsole
70
    {
71
        private readonly System.Threading.ManualResetEvent _readLineSignal;
72
        private string _lastLine;
73
        public MyConsole()
74
        {
75
            _readLineSignal = new System.Threading.ManualResetEvent(false);
76
            Gui = new TextBox();
77
            Gui.AcceptsReturn = true;
78
            Gui.KeyUp += OnKeyUp;
79
        }
80

    
81
        private void OnKeyUp(object sender, KeyEventArgs e)
82
        {
83
            // this is always fired on UI thread
84
            if (e.Key == Key.Enter)
85
            {
86
                // quick and dirty, but that is not relevant to your question
87
                _lastLine = Gui.Text.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries).Last();
88
                // now, when you detected that user typed a line, set signal
89
                _readLineSignal.Set();
90
            }
91
        }
92

    
93
        public TextBox Gui { get; private set; }
94

    
95
        public string ReadLine()
96
        {
97
            // that should always be called from non-ui thread
98
            if (Gui.Dispatcher.CheckAccess())
99
                throw new Exception("Cannot be called on UI thread");
100
            // reset signal
101
            _readLineSignal.Reset();
102
            // wait until signal is set. This call is blocking, but since we are on non-ui thread - there is no problem with that
103
            _readLineSignal.WaitOne();
104
            // we got signalled - return line user typed.
105
            return _lastLine;
106
        }
107

    
108
        public void WriteLine(string line)
109
        {
110
            if (!Gui.Dispatcher.CheckAccess())
111
            {
112
                Gui.Dispatcher.Invoke(new Action(() => WriteLine(line)));
113
                return;
114
            }
115

    
116
            Gui.Text += line + Environment.NewLine;
117
        }
118
    }
119

    
120
    /// <summary>
121
    /// MainMenu.xaml에 대한 상호 작용 논리
122
    /// </summary>
123
    public partial class MainMenu : UserControl
124
    {
125
        #region 프로퍼티
126
        public CommentUserInfo currentControl { get; set; }
127
        public ControlType controlType { get; set; }
128
        private Move move = new Move();
129
        private double[] rotateValue = { 0, 90, 180, 270 };
130
        public MouseHandlingMode mouseHandlingMode = MouseHandlingMode.None;
131
        private static readonly double DragThreshold = 5;
132
        private System.Windows.Input.Cursor cursor { get; set; }
133
        private Point canvasDrawingMouseDownPoint;
134
        public string filename { get; set; }
135
        private Point canvasZoomPanningMouseDownPoint;
136
        public Point getCurrentPoint;
137
        private Point canvasZoommovingMouseDownPoint;
138
        List<object> ControlList = new List<object>();
139
        private ListBox listBox = new ListBox();
140
        private Dictionary<Geometry, string> selected_item = new Dictionary<Geometry, string>();
141
        private bool isDraggingSelectionRect = false;
142
        DrawingAttributes inkDA = new DrawingAttributes();
143
        private VPRevision CurrentRev { get; set; }
144
        public RadRibbonButton btnConsolidate { get; set; }
145
        public RadRibbonButton btnFinalPDF { get; set; }
146
        public RadRibbonButton btnTeamConsolidate { get; set; }
147
        public RadRibbonButton btnConsolidateFinalPDF { get; set; }
148
        public RadRibbonButton btnAdjust { get; set; }
149

    
150
        public string Filename_ { get; set; }
151
        public double L_Size = 0;
152
        public AdornerFinal adorner_;
153
        public Multi_Undo_data multi_Undo_Data;
154
        public string Symbol_ID = "";
155
        /// <summary>
156
        /// Set to 'true' when the left mouse-button is down.
157
        /// </summary>
158
        public bool isLeftMouseButtonDownOnWindow = false;
159

    
160
        public InkPresenter _InkBoard = null;
161
        Stroke stroke;
162
        Boolean IsDrawing = false;
163
        StylusPointCollection strokePoints;
164
        //StylusPointCollection erasePoints;
165
        RenderTargetBitmap canvasImage;
166
        Point Sync_Offset_Point;
167

    
168
        //강인구 테스트
169
        private Path _SelectionPath { get; set; }
170
        public Path SelectionPath
171
        {
172
            get
173
            {
174
                return _SelectionPath;
175
            }
176
            set
177
            {
178
                if (_SelectionPath != value)
179
                {
180
                    _SelectionPath = value;
181
                    RaisePropertyChanged("SelectionPath");
182

    
183
                }
184
            }
185
        }
186

    
187
        private System.Windows.Controls.Image _imageViewer { get; set; }
188
        public System.Windows.Controls.Image imageViewer
189
        {
190
            get
191
            {
192
                if (_imageViewer == null)
193
                {
194
                    _imageViewer = new System.Windows.Controls.Image();
195
                    return _imageViewer;
196
                }
197
                else
198
                {
199
                    return _imageViewer;
200
                }
201
            }
202
            set
203
            {
204
                if (_imageViewer != value)
205
                {
206
                    _imageViewer = value;
207
                }
208
            }
209
        }
210

    
211
        public bool IsSyncPDFMode { get; set; }
212

    
213
        private System.Windows.Controls.Image _imageViewer_Compare { get; set; }
214
        public System.Windows.Controls.Image imageViewer_Compare
215
        {
216
            get
217
            {
218
                if (_imageViewer_Compare == null)
219
                {
220
                    _imageViewer_Compare = new System.Windows.Controls.Image();
221
                    return _imageViewer_Compare;
222
                }
223
                else
224
                {
225
                    return _imageViewer_Compare;
226
                }
227
            }
228
            set
229
            {
230
                if (_imageViewer_Compare != value)
231
                {
232
                    _imageViewer_Compare = value;
233
                }
234
            }
235
        }
236

    
237
        #endregion
238

    
239
        public MainMenu()
240
        {
241
            App.splashString(ISplashMessage.MAINMENU_0);            
242
            //InitializeComponent();    
243
            this.Loaded += MainMenu_Loaded;
244
        }
245

    
246
        public class TempDt
247
        {
248
            public int PageNumber { get; set; }
249
            public string CommentID { get; set; }
250
            public string ConvertData { get; set; }
251
            public int DATA_TYPE { get; set; }
252
            public string MarkupInfoID { get; set; }
253
            public int IsUpdate { get; set; }
254
        }
255

    
256
        List<TempDt> tempDtList = new List<TempDt>();
257

    
258
        private void SetCursor()
259
        {
260
            this.Cursor = cursor;
261
        }
262

    
263
        private bool IsDrawingEnable(Point _canvasZoomPanningMouseDownPoint)
264
        {
265
            if ((_canvasZoomPanningMouseDownPoint.X > 0 &&
266
                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.X) &&
267
                (_canvasZoomPanningMouseDownPoint.Y > 0 &&
268
                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.Y))
269
            {
270
                return true;
271
            }
272

    
273
            return false;
274
        }
275

    
276
        private bool IsRotationDrawingEnable(Point _canvasZoomPanningMouseDownPoint)
277
        {
278
            if (rotate.Angle == 90 || rotate.Angle == 270)
279
            {
280
                if ((_canvasZoomPanningMouseDownPoint.X > 0 &&
281
                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.X) &&
282
                (_canvasZoomPanningMouseDownPoint.Y > 0 &&
283
                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.Y))
284
                {
285
                    return true;
286
                }
287
            }
288
            else
289
            {
290
                if ((_canvasZoomPanningMouseDownPoint.X > 0 &&
291
                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.X) &&
292
                (_canvasZoomPanningMouseDownPoint.Y > 0 &&
293
                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.Y))
294
                {
295
                    return true;
296
                }
297
            }
298

    
299
            return false;
300
        }
301

    
302
        public void DeleteItem(MarkupInfoItem item)
303
        {
304
            if (PreviewUserMarkupInfoItem != null && item.Consolidate == 1 && item.AvoidConsolidate == 0)
305
            {
306
                App.Custom_ViewInfoId = PreviewUserMarkupInfoItem.MarkupInfoID;           }
307

    
308
            
309
            ViewerDataModel.Instance._markupInfoList.Remove(item);
310

    
311
            ViewerDataModel.Instance.MarkupControls.Where(data => data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(a =>
312
            {
313
                ViewerDataModel.Instance.MarkupControls.Remove(a);
314
            });
315

    
316
            ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(a =>
317
            {
318
                ViewerDataModel.Instance.MarkupControls_USER.Remove(a);
319
                ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator.MarkupListUpdate(
320
                null, Event_Type.Delete, a.CommentID, null);
321
            });
322

    
323
            ViewerDataModel.Instance.MyMarkupList.Where(data => data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(a =>
324
            {
325
                ViewerDataModel.Instance.MyMarkupList.Remove(a);
326
                //임시파일에서도 삭제
327
                TempFile.DelTemp(a.ID, this.ParentOfType<MainWindow>().dzMainMenu.pageNavigator.CurrentPage.PageNumber.ToString());                
328
            });
329

    
330
            gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;
331

    
332
            if (PreviewUserMarkupInfoItem == null && gridViewMarkup.SelectedItems.Where(d => (d as MarkupInfoItem).UserID == App.ViewInfo.UserID).FirstOrDefault() == null)
333
            {
334
                if (gridViewMarkup.Items.Cast<MarkupInfoItem>().ToList().Where(d => d.UserID == App.ViewInfo.UserID).Count() == 0)
335
                {
336
                    var infoId = Commons.shortGuid();
337
                    PreviewUserMarkupInfoItem = new MarkupInfoItem
338
                    {
339
                        CreateTime = DateTime.Now,
340
                        Depatment = userData.DEPARTMENT,
341
                        UpdateTime = DateTime.Now,
342
                        DisplayColor = "#FFFF0000",
343
                        UserID = userData.ID,
344
                        UserName = userData.NAME,
345
                        PageCount = 1,
346
                        Description = "",
347
                        MarkupInfoID = infoId,
348
                        MarkupList = null,
349
                        MarkupVersionID = Commons.shortGuid(),
350
                        Consolidate = 0,
351
                        PartConsolidate = 0,
352
                        userDelete = true,
353
                        AvoidConsolidate = 0,
354
                        IsPreviewUser = true
355
                    };
356
                    App.Custom_ViewInfoId = infoId;
357
                }
358
            }
359
            Logger.sendReqLog("DeleteMarkupAsync", App.ViewInfo.ProjectNO + "," + item.MarkupInfoID, 1);
360
            BaseClient.DeleteMarkupAsync(App.ViewInfo.ProjectNO, item.MarkupInfoID);    
361
        }
362

    
363
        /// <summary>
364
        /// delete selected comments
365
        /// </summary>
366
        /// <param name="sender"></param>
367
        /// <param name="e"></param>
368
        public void DeleteCommentEvent(object sender, RoutedEventArgs e)
369
        {
370
            DialogParameters parameters = new DialogParameters()
371
            {
372
                Owner = Application.Current.MainWindow,
373
                Content = new TextBlock()
374
                { 
375
                    MinWidth = 400,
376
                    FontSize = 11,
377
                    Text = "정말 삭제 하시겠습니까?",
378
                    TextWrapping = System.Windows.TextWrapping.Wrap
379
                },
380
                Header = "Confirm",
381
                Theme = new VisualStudio2013Theme(),
382
                ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },
383
                OkButtonContent = "Yes",
384
                CancelButtonContent = "No",
385
                Closed = delegate (object windowSender, WindowClosedEventArgs wc)
386
                {
387
                    if(wc.DialogResult == true)
388
                    {
389
                        //선택된 어도너가 있을시 삭제가 되지 않음
390
                        SelectionSet.Instance.UnSelect(this);
391

    
392
                        Button content = (sender as Button);
393
                        MarkupInfoItem item = content.CommandParameter as MarkupInfoItem;
394

    
395
                        DeleteItem(item);
396
                    }
397
                }
398
            };
399
            RadWindow.Confirm(parameters);
400
        }
401

    
402
        System.Windows.Media.Animation.DoubleAnimation da = new System.Windows.Media.Animation.DoubleAnimation();
403

    
404
        private static Timer timer;
405
        private int InitInterval = KCOM.Properties.Settings.Default.InitInterval;
406
        private void MainMenu_Loaded(object sender, RoutedEventArgs e)
407
        {
408
            InitializeComponent();            
409
            //System.Diagnostics.Debug.WriteLine("MainMenu() : " + sw.ElapsedMilliseconds.ToString() + "ms");
410

    
411
            if (App.ParameterMode)
412
            {
413
                App.splashString(ISplashMessage.MAINMENU_1);
414
                this.pageNavigator.PageChanging += pageNavigator_PageChanging;
415
                this.pageNavigator.PageChanged += PageNavigator_PageChanged;
416
                imageViewer_Compare = new Image();
417
                ViewerDataModel.Instance.Capture_Opacity = 0;
418
                da.From = 0.8;
419
                da.To = 0;
420
                da.Duration = new Duration(TimeSpan.FromSeconds(1));
421
                da.AutoReverse = true;
422
                da.RepeatBehavior = System.Windows.Media.Animation.RepeatBehavior.Forever;
423

    
424
                if (!App.ViewInfo.CreateFinalPDFPermission && !App.ViewInfo.NewCommentPermission)
425
                {
426
                    this.SymbolPane.Visibility = Visibility.Collapsed;
427
                    this.FavoritePane.Visibility = Visibility.Collapsed;
428
                    this.drawingRotateCanvas.IsHitTestVisible = false;
429
                }
430
                thumbnailPanel.Width = Convert.ToInt32(CommonLib.Common.GetConfigString("SetThumbnail", "WIDTH", "250"));
431
            }
432
            timer = new Timer(timercallback, null, 0, InitInterval * 60000);
433
        }
434

    
435
        
436

    
437
        private void timercallback(Object o)
438
        {
439
            Stopwatch sw = new Stopwatch();
440
            sw.Start();
441
            TempFile.TempFileAdd();
442
            sw.Stop();
443

    
444
            Dispatcher.InvokeAsync(new Action(delegate
445
            {
446
               if (this.ParentOfType<MainWindow>().dzTopMenu.cbAutoSave.IsChecked == true) //Auto Save Checked?
447
                {
448
                    timer.Change(((int)this.ParentOfType<MainWindow>().dzTopMenu.cbSaveInterval.Value * 60000) / 2, sw.ElapsedMilliseconds); //Timer Setting
449
                }
450
            }));
451

    
452
            ////GC.Collect();
453
        }
454
        
455
        /// <summary>
456
        /// update my markuplist
457
        ///  - update existing markup data if already exist
458
        ///  - add new markup data if control is new
459
        /// </summary>
460
        public void UpdateMyMarkupList()
461
        {
462
            Logger.sendCheckLog("pageNavigator_PageChanging_ChangeCommentReact", 1);
463

    
464
            /// add or update markup list
465
            foreach (var control in ViewerDataModel.Instance.MarkupControls_USER)
466
            {
467
                var root = MarkupParser.MarkupToString(control, App.ViewInfo.UserID);
468

    
469
                var exist = ViewerDataModel.Instance.MyMarkupList.Where(data => data.ID == root.CommentID).FirstOrDefault();
470
                if (exist != null) //신규 추가 된 코멘트
471
                {
472
                    if (exist.Data != root.ConvertData) //코멘트가 같은지
473
                    {
474
                        exist.Data = root.ConvertData;
475
                        exist.IsUpdate = true;
476
                    }
477
                }
478
                else if (root.CommentID != null)
479
                {
480
                    ViewerDataModel.Instance.MyMarkupList.Add(new MarkupItemEx
481
                    {
482
                        ID = control.CommentID,
483
                        Data = root.ConvertData,
484
                        Data_Type = root.DATA_TYPE,
485
                        MarkupInfoID = App.Custom_ViewInfoId,
486
                        PageNumber = this.pageNavigator.CurrentPage.PageNumber,
487
                        Symbol_ID = control.SymbolID,
488
                        //Group_ID = control.GroupID,
489
                    });
490
                }
491
            }
492

    
493
            /// delete markup list
494
            int iPageNo = this.pageNavigator.CurrentPage.PageNumber;
495
            var deleted = (from markup in ViewerDataModel.Instance.MyMarkupList
496
                          where (markup.PageNumber == iPageNo) && (null == ViewerDataModel.Instance.MarkupControls_USER.Where(control => control.CommentID == markup.ID).FirstOrDefault())
497
                          select markup).ToList();
498
            foreach(var markup in deleted) ViewerDataModel.Instance.MyMarkupList.Remove(markup);
499
            /// up to here
500

    
501
            //if (modified)
502
            //{
503
            //    if (ViewerDataModel.Instance._markupInfoList.Where(info => info.UserID == PreviewUserMarkupInfoItem.UserID).FirstOrDefault() == null)
504
            //    {
505
            //        ComingNewBieEnd = true;
506
            //        ViewerDataModel.Instance._markupInfoList.Insert(0, PreviewUserMarkupInfoItem);
507
            //        PreviewUserMarkupInfoItem.IsPreviewUser = false;
508
            //        gridViewMarkup.ItemsSource = null;
509
            //        gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;
510
            //        gridViewMarkup.SelectedItem = PreviewUserMarkupInfoItem;
511

    
512
            //        GroupDescriptor descriptor = new GroupDescriptor();
513
            //        descriptor.Member = "Depatment";
514
            //        descriptor.DisplayContent = "DEPT";
515
            //        descriptor.SortDirection = ListSortDirection.Ascending;
516
            //        gridViewMarkup.GroupDescriptors.Add(descriptor);
517
            //    }
518
            //}
519
        }
520

    
521
        DispatcherTimer renderTesttimer;
522

    
523
        /// <summary>
524
        /// start page changing
525
        ///  - save controls if page is modified
526
        ///  - starting download page image
527
        /// </summary>
528
        /// <param name="sender"></param>
529
        /// <param name="e"></param>
530
        private async void pageNavigator_PageChanging(object sender, Controls.Sample.PageChangeEventArgs e)
531
        {
532
            CompareMode.IsChecked = false;
533
            var BalancePoint = ViewerDataModel.Instance.PageBalanceMode == true ? e.PageNumber + ViewerDataModel.Instance.PageBalanceNumber : e.PageNumber;
534

    
535
            #region 페이지가 벗어난 경우
536

    
537
            if (BalancePoint < 1)
538
            {
539
                BalancePoint = 1;
540
                ViewerDataModel.Instance.PageBalanceNumber = 0;
541
            }
542

    
543
            if (pageNavigator.PageCount < BalancePoint)
544
            {
545
                BalancePoint = pageNavigator.PageCount;
546
                ViewerDataModel.Instance.PageBalanceNumber = 0;
547
            }
548

    
549
            #endregion
550

    
551
            ViewerDataModel.Instance.PageNumber = BalancePoint;
552

    
553
            var pageWidth = Convert.ToDouble(e.CurrentPage.PAGE_WIDTH);
554
            var pageHeight = Convert.ToDouble(e.CurrentPage.PAGE_HEIGHT);
555
            var pageUri = pageNavigator.CurrentPage.PageUri;
556
            var contentScale = zoomAndPanControl.ContentScale;
557

    
558
            #region 페이지 이미지 로딩 수정
559

    
560
            // ViewerDataModel.Instance.ImageViewPath = await ImageSourceHelper.GetDownloadImageAsync(pageUri, pageWidth * contentScale, pageHeight * contentScale);
561
            try
562
            {
563
                ViewerDataModel.Instance.ImageViewPath = await ImageSourceHelper.GetDownloadImageAsync(pageUri, pageWidth, pageHeight);
564

    
565
            }
566
            catch (Exception ex)
567
            {
568
                ViewerDataModel.Instance.ImageViewPath = null;
569
                string imgfailedmsg = string.Format(CommonLib.Common.GetAlertMessageString("GetImageResourceFailed", "MSG", "해당 문서의 {0} Page Convert가 정상적이지 않습니다. 관리자에게 문의해 주세요."), pageNavigator.CurrentPage.PageNumber);                
570
                DialogMessage_Alert(imgfailedmsg, "Warning");
571
                App.FileLogger.Fatal(ex);
572
            }
573
            ScaleImage(pageWidth, pageHeight);
574

    
575
            ViewerDataModel.Instance.ImageViewWidth = pageWidth;
576
            ViewerDataModel.Instance.ImageViewHeight = pageHeight;
577

    
578
            zoomAndPanCanvas.Width = pageWidth;
579
            zoomAndPanCanvas.Height = pageHeight;
580

    
581
            Common.ViewerDataModel.Instance.ContentWidth = pageWidth;
582
            Common.ViewerDataModel.Instance.ContentHeight = pageHeight;
583

    
584
            inkBoard.Width = pageWidth;
585
            inkBoard.Height = pageHeight;
586

    
587
            #endregion
588

    
589
            if (!testPanel2.IsHidden)
590
            {
591
                Logger.sendCheckLog("pageNavigator_PageChanging_!testPanel2.IsHidden 일 때", 1);
592
                //PDF모드일때 잠시 대기(강인구)
593
                if (IsSyncPDFMode)
594
                {
595
                    Get_FinalImage.Get_PdfImage get_PdfImage = new Get_FinalImage.Get_PdfImage();
596
                    var pdfpath = new BitmapImage(new Uri(get_PdfImage.Run(CurrentRev.TO_VENDOR, App.ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.PageNumber)));
597

    
598
                    Logger.sendCheckLog("pageNavigator_PageChanging_pdfpath Image Downloading", 1);
599
                    if (pdfpath.IsDownloading)
600
                    {
601
                        pdfpath.DownloadCompleted += (ex, arg) =>
602
                        {
603
                            Logger.sendCheckLog("pageNavigator_PageChanging_pdfpath Image DownloadCompleted", 1);
604
                            ViewerDataModel.Instance.ImageViewPath_C = pdfpath;
605
                            ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;
606
                            ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;
607
                            zoomAndPanCanvas2.Width = pdfpath.PixelWidth;
608
                            zoomAndPanCanvas2.Height = pdfpath.PixelHeight;
609
                        };
610
                    }
611
                    else
612
                    {
613
                        Logger.sendCheckLog("pageNavigator_PageChanging_pdfpath Image Page Setting", 1);
614
                        ViewerDataModel.Instance.ImageViewPath_C = pdfpath;
615
                        ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;
616
                        ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;
617

    
618
                        zoomAndPanCanvas2.Width = pdfpath.PixelWidth;
619
                        zoomAndPanCanvas2.Height = pdfpath.PixelHeight;
620
                    }
621
                }
622
                else
623
                {
624
                    Logger.sendCheckLog("pageNavigator_PageChanging_uri2 값 설정", 1);
625
                    string uri2 = "";
626
                    if (userData.COMPANY != "EXT")
627
                    {
628
                        uri2 = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, (Convert.ToUInt32(CurrentRev.DOCUMENT_ID) / 100).ToString(), CurrentRev.DOCUMENT_ID, BalancePoint);
629
                    }
630
                    else
631
                    {
632
                        uri2 = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, BalancePoint);
633
                    }
634

    
635
                    Logger.sendCheckLog("pageNavigator_PageChanging_defaultBitmapImage_Compare BitmapImage 설정", 1);
636
                    var defaultBitmapImage_Compare = new BitmapImage();
637
                    defaultBitmapImage_Compare.BeginInit();
638
                    defaultBitmapImage_Compare.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
639
                    defaultBitmapImage_Compare.CacheOption = BitmapCacheOption.OnLoad;
640
                    defaultBitmapImage_Compare.UriSource = new Uri(uri2);
641
                    //defaultBitmapImage_Compare.DecodePixelWidth = Int32.Parse(e.CurrentPage.PAGE_WIDTH);
642
                    //defaultBitmapImage_Compare.DecodePixelHeight = Int32.Parse(e.CurrentPage.PAGE_HEIGHT);
643
                    defaultBitmapImage_Compare.EndInit();
644

    
645
                    ViewerDataModel.Instance.ImageViewPath_C = null;                    
646

    
647
                    Logger.sendCheckLog("pageNavigator_PageChanging_zoomAndPanControl ZoomTo 설정", 1);
648
                    zoomAndPanControl.ZoomTo(new Rect
649
                    {
650
                        X = 0,
651
                        Y = 0,
652
                        Width = Math.Max(zoomAndPanCanvas.Width, zoomAndPanCanvas2.Width),
653
                        Height = Math.Max(zoomAndPanCanvas.Height, zoomAndPanCanvas2.Height),
654
                    });
655

    
656
                    Logger.sendCheckLog("pageNavigator_PageChanging_defaultBitmapImage_Compare Downloading", 1);
657
                    if (defaultBitmapImage_Compare.IsDownloading)
658
                    {
659
                        defaultBitmapImage_Compare.DownloadCompleted += (ex, arg) =>
660
                        {
661
                            defaultBitmapImage_Compare.Freeze();
662
                            ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
663
                            ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
664
                            ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
665
                            ComparePanel.UpdateLayout();
666
                            zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;
667
                            zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;
668

    
669
                            zoomAndPanControl.ZoomTo(new Rect
670
                            {
671
                                X = 0,
672
                                Y = 0,
673
                                Width = Math.Max(zoomAndPanCanvas.Width, zoomAndPanCanvas2.Width),
674
                                Height = Math.Max(zoomAndPanCanvas.Height, zoomAndPanCanvas2.Height),
675
                            });
676

    
677
                            //defaultBitmapImage_Compare dispose
678
                            defaultBitmapImage_Compare = null;
679
                            GC.Collect();
680
                        };
681
                    }
682
                }
683
                tlSyncPageNum.Text = String.Format("Current Page : {0}", BalancePoint);
684
            }
685

    
686
            this.pageNavigator.ChangePage(e.PageNumber);
687
        }
688

    
689
        /// <summary>
690
        /// called after page is changed
691
        /// </summary>
692
        /// <param name="sender"></param>
693
        /// <param name="e"></param>
694
        private void PageNavigator_PageChanged(object sender, Sample.PageChangeEventArgs e)
695
        {
696
            if (zoomAndPanCanvas2.Width.IsNaN())
697
            {
698
                zoomAndPanControl.ZoomTo(new Rect { X = 0, Y = 0, Width = zoomAndPanCanvas.Width, Height = zoomAndPanCanvas.Height });
699
            }
700

    
701
            /// 컨트롤을 새로 생성한다.
702
            Common.ViewerDataModel.Instance.MarkupControls_USER.Clear();    //전체 제거
703
            Common.ViewerDataModel.Instance.MarkupControls.Clear();         //전체 제거
704
            foreach (var markup in ViewerDataModel.Instance.MyMarkupList.Where(param => param.PageNumber == ViewerDataModel.Instance.PageNumber))
705
            {
706
                var info = ViewerDataModel.Instance._markupInfoList.Where(param => param.MarkupInfoID == markup.MarkupInfoID).FirstOrDefault();
707
                if (info != null)
708
                {
709
                    string sColor = (info.UserID == App.ViewInfo.UserID) ? "#FFFF0000" : info.DisplayColor;
710
                    if (info.UserID == App.ViewInfo.UserID)
711
                    {
712
                        var control = MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, sColor, "",
713
                                        markup.MarkupInfoID, markup.ID);
714
                        control.Visibility = Visibility.Hidden;
715
                    }
716
                    else
717
                    {
718
                        var control = MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls, sColor, "",
719
                                                                markup.MarkupInfoID, markup.ID);
720
                        control.Visibility = Visibility.Hidden;
721
                    }
722
                }
723
            };
724
            /// up to here
725

    
726
            /// fire selection event
727
            List<MarkupInfoItem> gridSelectionItem = gridViewMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList(); //선택 된 마크업
728
            this.gridViewMarkup.UnselectAll();
729
            this.gridViewMarkup.Select(gridSelectionItem);
730

    
731
            if (!testPanel2.IsHidden)
732
            {
733
                ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;
734
                ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;
735
                ViewerDataModel.Instance.Sync_ContentScale = zoomAndPanControl.ContentScale;
736

    
737
                Common.ViewerDataModel.Instance.MarkupControls_Sync.Clear();
738
                List<MarkupInfoItem> gridSelectionRevItem = gridViewRevMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList();
739

    
740

    
741
                foreach (var item in gridSelectionRevItem)
742
                {
743
                    item.MarkupList.Where(pageItem => pageItem.PageNumber == ViewerDataModel.Instance.PageNumber).ToList().ForEach(delegate (MarkupItem markupitem)
744
                    {
745
                        MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, item.DisplayColor, "", item.MarkupInfoID);
746
                    });
747
                }
748
            }
749

    
750
            var instanceMain = this.ParentOfType<MainWindow>();
751
            instanceMain.dzTopMenu.tlcurrentPage.Text = e.CurrentPage.PAGE_NUMBER.ToString();
752
            instanceMain.dzTopMenu.tlcurrentPage_readonly.Text = e.CurrentPage.PAGE_NUMBER.ToString();
753

    
754
            instanceMain.dzTopMenu.rotateOffSet = 0;
755
            var pageinfo = this.CurrentDoc.docInfo.DOCPAGE.Where(p => p.PAGE_NUMBER == e.CurrentPage.PAGE_NUMBER).FirstOrDefault();
756
            drawingPannelRotate(pageinfo.PAGE_ANGLE);
757

    
758
            SetCommentPages(true);
759
        }
760

    
761
        public void SetCommentPages(bool onlyMe = false)
762
        {
763
            Logger.sendCheckLog("pageNavigator_PageChanging_SetCommentPages Setting", 1);
764
            List<UsersCommentPagesMember> _pages = new List<UsersCommentPagesMember>();
765
            foreach (var item in ViewerDataModel.Instance._markupInfoList)
766
            {
767
                //Comment 가 존재할 경우에만 Thumbnail 에 추가
768
                if(item.MarkupList != null)
769
                {
770
                    UsersCommentPagesMember instance = new UsersCommentPagesMember();
771
                    instance.UserName = item.UserName;
772
                    instance.Depart = item.Depatment;
773
                    instance.MarkupInfoID = item.MarkupInfoID;
774
                    instance.IsSelected = true;
775
                    instance.isConSolidation = item.Consolidate;
776
                    instance.SetColor = item.DisplayColor;
777
                    if (item.UserID == App.ViewInfo.UserID && item.MarkupInfoID == item.MarkupInfoID)
778
                    {
779
                        instance.PageNumber = ViewerDataModel.Instance.MyMarkupList.Select(d => d.PageNumber).ToList();
780
                    }
781
                    else
782
                    {
783
                        instance.PageNumber = ViewerDataModel.Instance.MarkupList_Pre.Where(data => data.MarkupInfoID == item.MarkupInfoID).Select(d => d.PageNumber).ToList();
784
                    }
785
                    _pages.Add(instance);
786
                }                   
787
            }
788
            
789
            this.pageNavigator.SetCommentList(_pages.ToList());
790

    
791
        }
792

    
793
        public void MarkupitemViewUpdate(string markupinfo_id)
794
        {
795
            //db에 업데이트 한 list 를 view 에 업데이트
796
            string sDocID = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu._DocInfo.ID;
797
            List<MarkupInfoItem> results = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.GetMarkupInfoItems(App.ViewInfo.ProjectNO, sDocID);
798
            MarkupInfoItem dbinfo = results.Where(x => x.MarkupInfoID == markupinfo_id).FirstOrDefault();
799
            MarkupInfoItem viewinfo = Common.ViewerDataModel.Instance._markupInfoList.Where(x => x.MarkupInfoID == markupinfo_id).FirstOrDefault();
800
            if (dbinfo.MarkupList.Count > 0)
801
            {
802
                if (viewinfo.MarkupList != null)
803
                {
804
                    viewinfo.MarkupList.Clear();
805
                    viewinfo.MarkupList = null;
806
                }
807
                viewinfo.MarkupList = new List<MarkupItem>();
808
                foreach (var item in dbinfo.MarkupList)
809
                {
810
                    viewinfo.MarkupList.Add(item);
811
                }
812
            }
813
        }
814

    
815
        private void zoomAndPanControl_MouseWheel(object sender, MouseWheelEventArgs e)
816
        {
817
            if (e.MiddleButton == MouseButtonState.Pressed)
818
            {
819

    
820
            }
821
            e.Handled = true;
822
            if (e.Delta > 0)
823
            {
824
                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas);
825
                System.Diagnostics.Debug.WriteLine($"Zoom : {currentContentMousePoint.X} {currentContentMousePoint.Y}");
826
                ZoomIn(currentContentMousePoint);
827
            }
828
            else
829
            {
830
                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas);
831
                System.Diagnostics.Debug.WriteLine($"Zoom : {currentContentMousePoint.X} {currentContentMousePoint.Y}");
832
                ZoomOut(currentContentMousePoint);
833
            }
834
        }
835

    
836
        private void zoomAndPanControl2_MouseWheel(object sender, MouseWheelEventArgs e)
837
        {
838
            e.Handled = true;
839
            if (e.Delta > 0)
840
            {
841
                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas2);
842
                ZoomIn_Sync(currentContentMousePoint);
843
            }
844
            else
845
            {
846
                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas2);
847
                ZoomOut_Sync(currentContentMousePoint);
848
            }
849
        }
850

    
851
        #region ZoomIn & ZoomOut
852

    
853
        private void ZoomOut_Executed(object sender, ExecutedRoutedEventArgs e)
854
        {
855
            ZoomOut(new Point(zoomAndPanControl.ContentZoomFocusX,
856
                zoomAndPanControl.ContentZoomFocusY));
857
        }
858

    
859
        private void ZoomIn_Executed(object sender, ExecutedRoutedEventArgs e)
860
        {
861
            ZoomIn(new Point(zoomAndPanControl.ContentZoomFocusX,
862
                zoomAndPanControl.ContentZoomFocusY));
863
        }
864

    
865

    
866
        //강인구 추가 (줌 인아웃 수치 변경)
867
        //큰해상도의 문서일 경우 줌 인 아웃시 사이즈 변동이 큼
868
        private void ZoomOut(Point contentZoomCenter)
869
        {
870
            if (zoomAndPanControl.ContentScale > 0.39)
871
            {
872
                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale - 0.2, contentZoomCenter);
873
            }
874
            else
875
            {
876
                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale / 2, contentZoomCenter);
877
            }
878

    
879
            if (zoomAndPanControl2 != null && Sync.IsChecked)
880
            {
881
                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl.ContentScale, contentZoomCenter);
882
            }
883
        }
884

    
885
        private void ZoomIn(Point contentZoomCenter)
886
        {
887
            if (zoomAndPanControl.ContentScale > 0.19)
888
            {
889
                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale + 0.2, contentZoomCenter);
890
            }
891
            else
892
            {
893
                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale * 2, contentZoomCenter);
894
            }
895

    
896
            if (zoomAndPanControl2 != null && Sync.IsChecked)
897
            {
898
                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl.ContentScale, contentZoomCenter);
899
            }
900

    
901
        }
902

    
903
        private void ZoomOut_Sync(Point contentZoomCenter)
904
        {
905
            if (zoomAndPanControl2.ContentScale > 0.39)
906
            {
907
                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale - 0.2, contentZoomCenter);
908
            }
909
            else
910
            {
911
                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale / 2, contentZoomCenter);
912
            }
913

    
914
            if (Sync.IsChecked)
915
            {
916
                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl2.ContentScale, contentZoomCenter);
917
            }
918
        }
919

    
920
        private void ZoomIn_Sync(Point contentZoomCenter)
921
        {
922
            if (zoomAndPanControl2.ContentScale > 0.19)
923
            {
924
                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale + 0.2, contentZoomCenter);
925
            }
926
            else
927
            {
928
                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale * 2, contentZoomCenter);
929
            }
930

    
931
            if (Sync.IsChecked)
932
            {
933
                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl2.ContentScale, contentZoomCenter);
934
            }
935
        }
936

    
937
        private void ZoomOut()
938
        {
939
            zoomAndPanControl.ContentScale -= 0.1;
940
            //if (zoomAndPanControl2 != null)
941
            //{
942
            //    zoomAndPanControl2.ContentScale -= 0.1;
943
            //}
944
        }
945

    
946
        private void ZoomIn()
947
        {
948
            zoomAndPanControl.ContentScale += 0.1;
949
            //if (zoomAndPanControl2 != null)
950
            //{
951
            //    zoomAndPanControl2.ContentScale += 0.1;
952
            //}
953
        }
954

    
955
        #endregion
956

    
957
        private void init()
958
        {
959
            foreach (var item in ViewerDataModel.Instance.MarkupControls)
960
            {
961

    
962
                ControlList.Clear();
963
                listBox.Items.Clear();
964
                selected_item.Clear();
965

    
966
                (item as IMarkupCommonData).IsSelected = false;
967
            }
968

    
969
        }
970

    
971
        private HitTestResultBehavior MyCallback(HitTestResult result)
972
        {
973
            //this.cursor = Cursors.UpArrow;
974
            var element = result.VisualHit;
975
            while (element != null && !(element is CommentUserInfo))
976
                element = VisualTreeHelper.GetParent(element);
977

    
978
            if (element == null)
979
            {
980
                return HitTestResultBehavior.Stop;
981
            }
982
            else
983
            {
984
                if (element is CommentUserInfo)
985
                {
986
                    if (!hitList.Contains(element))
987
                    {
988
                        hitList.Add((CommentUserInfo)element);
989
                    }
990
                    else
991
                    {
992
                        return HitTestResultBehavior.Stop;
993
                    }
994
                }
995
            }
996
            return HitTestResultBehavior.Continue;
997
        }
998

    
999
        public void ReleaseSelectPath()
1000
        {
1001
            if (SelectionPath == null)
1002
            {
1003
                SelectionPath = new Path();
1004
                SelectionPath.Name = "";
1005
            }
1006
            if (SelectionPath.Name != "")
1007
            {
1008
                SelectionPath.Name = "None";
1009
            }
1010
            SelectionPath.Opacity = 0.01;
1011
            SelectionPath.RenderTransform = null;
1012
            SelectionPath.RenderTransformOrigin = new Point(0, 0);
1013
        }
1014

    
1015
        #region 컨트롤 초기화 
1016
        public void Control_Init(object control)
1017
        {
1018
            if (L_Size != 0 && (control as IPath) != null)
1019
            {
1020
                (control as IPath).LineSize = L_Size;
1021
                L_Size = 0;
1022
            }
1023

    
1024
            switch (control.GetType().Name)
1025
            {
1026
                case "RectangleControl":
1027
                    {
1028
                        (control as RectangleControl).StrokeColor = Brushes.Red;
1029
                    }
1030
                    break;
1031
                case "CircleControl":
1032
                    {
1033
                        (control as CircleControl).StrokeColor = Brushes.Red;
1034
                    }
1035
                    break;
1036
                case "TriControl":
1037
                    {
1038
                        (control as TriControl).StrokeColor = Brushes.Red;
1039
                    }
1040
                    break;
1041
                case "RectCloudControl":
1042
                    {
1043
                        (control as RectCloudControl).StrokeColor = Brushes.Red;
1044
                    }
1045
                    break;
1046
                case "CloudControl":
1047
                    {
1048
                        (control as CloudControl).StrokeColor = Brushes.Red;
1049
                    }
1050
                    break;
1051
                case "PolygonControl":
1052
                    {
1053
                        (control as PolygonControl).StrokeColor = Brushes.Red;
1054
                    }
1055
                    break;
1056
                case "ArcControl":
1057
                    {
1058
                        (control as ArcControl).StrokeColor = Brushes.Red;
1059
                    }
1060
                    break;
1061
                case "ArrowArcControl":
1062
                    {
1063
                        (control as ArrowArcControl).StrokeColor = Brushes.Red;
1064
                    }
1065
                    break;
1066
                case "LineControl":
1067
                    {
1068
                        (control as LineControl).StrokeColor = Brushes.Red;
1069
                    }
1070
                    break;
1071
                case "ArrowControl_Multi":
1072
                    {
1073
                        (control as ArrowControl_Multi).StrokeColor = Brushes.Red;
1074
                    }
1075
                    break;
1076
                case "TextControl":
1077
                    {
1078
                        (control as TextControl).BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));
1079
                    }
1080
                    break;
1081
                case "ArrowTextControl":
1082
                    {
1083
                        (control as ArrowTextControl).BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));
1084
                    }
1085
                    break;
1086
                case "InsideWhiteControl":
1087
                    {
1088
                        (control as InsideWhiteControl).StrokeColor = Brushes.White;
1089
                    }
1090
                    break;
1091
                case "OverlapWhiteControl":
1092
                    {
1093
                        (control as OverlapWhiteControl).StrokeColor = Brushes.White;
1094
                    }
1095
                    break;
1096
                case "ClipWhiteControl":
1097
                    {
1098
                        (control as ClipWhiteControl).StrokeColor = Brushes.White;
1099
                    }
1100
                    break;
1101
                case "CoordinateControl":
1102
                    {
1103
                        (control as CoordinateControl).StrokeColor = Brushes.Black;
1104
                    }
1105
                    break;
1106
            }
1107
        }
1108
        #endregion
1109

    
1110
        public void firstCondition_MouseLeave(object sender, MouseEventArgs e)
1111
        {
1112
            //Control_Init(e.Source);
1113
        }
1114
        //private Window _dragdropWindow = null;
1115

    
1116
        [DllImport("user32.dll")]
1117
        [return: MarshalAs(UnmanagedType.Bool)]
1118
        internal static extern bool GetCursorPos(ref Win32Point pt);
1119

    
1120
        [StructLayout(LayoutKind.Sequential)]
1121
        internal struct Win32Point
1122
        {
1123
            public Int32 X;
1124
            public Int32 Y;
1125
        };
1126
        /*
1127
       public string symbol_id = null;
1128
       public long symbol_group_id;
1129
       public int symbol_SelectedIndex;
1130
       public ImageSource symbol_img;
1131
       public string symbol_Data = null;
1132
       public void symboldata(string id, long group_id, int SelectedIndex, string Data_, ImageSource img)
1133
       {
1134
           PlaceImageSymbol(symbol_id, symbol_group_id, symbol_SelectedIndex, new Point(zoomAndPanCanvas.ActualWidth / 2,
1135
               zoomAndPanCanvas.ActualHeight / 2));
1136

    
1137

    
1138
               if (this._dragdropWindow != null)
1139
               {
1140
                   this._dragdropWindow.Close();
1141
                   this._dragdropWindow = null;
1142
               }
1143

    
1144
               symbol_id = id;
1145
               symbol_group_id = group_id;
1146
               symbol_SelectedIndex = SelectedIndex;
1147
               symbol_Data = Data_;
1148
               symbol_img = img;
1149

    
1150

    
1151
               CreateDragDropWindow2(img);
1152
              
1153
    }
1154

    
1155
    private void CreateDragDropWindow2(ImageSource image)
1156
        {
1157
            this._dragdropWindow = new Window();
1158
            _dragdropWindow.Cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1159
            _dragdropWindow.WindowStyle = WindowStyle.None;
1160
            _dragdropWindow.AllowsTransparency = true;           
1161
            _dragdropWindow.AllowDrop = false;
1162
            _dragdropWindow.Background = null;
1163
            _dragdropWindow.IsHitTestVisible = false;
1164
            _dragdropWindow.SizeToContent = SizeToContent.WidthAndHeight;
1165
            _dragdropWindow.Topmost = true;
1166
            _dragdropWindow.ShowInTaskbar = false;
1167
            
1168
            Rectangle r = new Rectangle();
1169
            r.Width = image.Width;
1170
            r.Height = image.Height;
1171
            r.Opacity = 0.5;            
1172
            r.Fill = new ImageBrush(image);
1173
            this._dragdropWindow.Content = r;
1174

    
1175
            Win32Point w32Mouse = new Win32Point();
1176
            GetCursorPos(ref w32Mouse);
1177

    
1178
            //w32Mouse.X = getCurrentPoint.X;
1179
            this._dragdropWindow.Left = w32Mouse.X - (image.Width / 2);
1180
            this._dragdropWindow.Top = w32Mouse.Y - (image.Height / 2); 
1181
            this._dragdropWindow.Show();
1182
        }
1183
         */
1184
        private void zoomAndPanControl_MouseMove(object sender, MouseEventArgs e)
1185
        {
1186
            if (Common.ViewerDataModel.Instance.SelectedControl == "Batch")
1187
            {
1188
                if (!floatingTip.IsOpen) { floatingTip.IsOpen = true; }
1189

    
1190
                Point currentPos = e.GetPosition(rect);
1191

    
1192
                floatingTip.HorizontalOffset = currentPos.X + 20;
1193
                floatingTip.VerticalOffset = currentPos.Y;
1194
            }
1195

    
1196
            getCurrentPoint = e.GetPosition(drawingRotateCanvas);
1197
            
1198
            if ((e.MiddleButton == MouseButtonState.Pressed) || (e.RightButton == MouseButtonState.Pressed))
1199
            {
1200
                SetCursor();
1201
                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);
1202
                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);
1203

    
1204
                Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;
1205
                zoomAndPanControl.ContentOffsetX -= dragOffset.X;
1206
                zoomAndPanControl.ContentOffsetY -= dragOffset.Y;
1207

    
1208
                if (Sync.IsChecked)
1209
                {
1210
                    ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;
1211
                    ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;
1212
                }
1213
            }
1214

    
1215
            if (mouseHandlingMode == MouseHandlingMode.Drawing && currentControl != null)
1216
            {
1217
                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);
1218
                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);
1219
                SetCursor();
1220

    
1221
                if (currentControl != null)
1222
                {
1223
                    double moveX = currentCanvasDrawingMouseMovePoint.X - canvasDrawingMouseDownPoint.X;
1224
                    double moveY = currentCanvasDrawingMouseMovePoint.Y - canvasDrawingMouseDownPoint.Y;
1225
                    //강인구 추가
1226
                    currentControl.Opacity = ViewerDataModel.Instance.ControlOpacity;
1227

    
1228
                    if ((currentControl as IPath) != null)
1229
                    {
1230
                        (currentControl as IPath).LineSize = ViewerDataModel.Instance.LineSize;
1231
                    }
1232
                    if ((currentControl as LineControl) != null)
1233
                    {
1234
                        (currentControl as LineControl).Interval = ViewerDataModel.Instance.Interval;
1235
                    }
1236

    
1237
                    if ((currentControl as IShapeControl) != null)
1238
                    {
1239
                        (currentControl as IShapeControl).Paint = ViewerDataModel.Instance.paintSet;
1240
                    }
1241
                    if ((currentControl as TextControl) != null)
1242
                    {
1243
                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnItalic.IsChecked == true)
1244
                        {
1245
                            (currentControl as TextControl).TextStyle = FontStyles.Italic;
1246
                        }
1247
                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnBold.IsChecked == true)
1248
                        {
1249
                            (currentControl as TextControl).TextWeight = FontWeights.Bold;
1250
                        }
1251
                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnUnderLine.IsChecked == true)
1252
                        {
1253
                            (currentControl as TextControl).UnderLine = TextDecorations.Underline;
1254
                        }
1255
                    }
1256
                    else if ((currentControl as ArrowTextControl) != null)
1257
                    {
1258
                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnItalic.IsChecked == true)
1259
                        {
1260
                            (currentControl as ArrowTextControl).TextStyle = FontStyles.Italic;
1261
                        }
1262
                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnBold.IsChecked == true)
1263
                        {
1264
                            (currentControl as ArrowTextControl).TextWeight = FontWeights.Bold;
1265
                        }
1266
                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnUnderLine.IsChecked == true)
1267
                        {
1268
                            (currentControl as ArrowTextControl).UnderLine = TextDecorations.Underline;
1269
                        }
1270
                    }
1271
                    else if ((currentControl as RectCloudControl) != null)
1272
                    {
1273
                        (currentControl as RectCloudControl).ArcLength = ViewerDataModel.Instance.ArcLength;
1274
                    }
1275
                    else if ((currentControl as CloudControl) != null)
1276
                    {
1277
                        (currentControl as CloudControl).ArcLength = ViewerDataModel.Instance.ArcLength;
1278
                    }
1279

    
1280
                    switch (controlType)
1281
                    {
1282
                        case (ControlType.Coordinate):
1283
                            {
1284
                                var control = currentControl as CoordinateControl;
1285
                                if (control != null)
1286
                                {
1287
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1288
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1289
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1290
                                }
1291
                            }
1292
                            break;
1293
                        case (ControlType.InsideWhite):
1294
                            {
1295
                                var control = currentControl as InsideWhiteControl;
1296
                                if (control != null)
1297
                                {
1298
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1299
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1300
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1301
                                    control.Paint = PaintSet.Fill;
1302
                                }
1303
                            }
1304
                            break;
1305
                        case ControlType.OverlapWhite:
1306
                            {
1307
                                var control = currentControl as OverlapWhiteControl;
1308
                                if (control != null)
1309
                                {
1310
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1311
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1312
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1313
                                    control.Paint = PaintSet.Fill;
1314
                                }
1315
                            }
1316
                            break;
1317
                        case ControlType.ClipWhite:
1318
                            {
1319
                                var control = currentControl as ClipWhiteControl;
1320
                                if (control != null)
1321
                                {
1322
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1323
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1324
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1325
                                    control.Paint = PaintSet.Fill;
1326
                                }
1327
                            }
1328
                            break;
1329
                        case ControlType.RectCloud:
1330
                            {
1331
                                var control = currentControl as RectCloudControl;
1332
                                if (control != null)
1333
                                {
1334
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1335
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1336
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1337
                                }
1338
                            }
1339
                            break;
1340
                        case ControlType.SingleLine:
1341
                        case ControlType.CancelLine:
1342
                        case ControlType.ArrowLine:
1343
                        case ControlType.TwinLine:
1344
                        case ControlType.DimLine:
1345
                            {
1346
                                var control = currentControl as LineControl;
1347
                                if (control != null)
1348
                                {
1349
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1350
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1351
                                }
1352
                            }
1353
                            break;
1354

    
1355
                        case ControlType.ArcLine:
1356
                            {
1357
                                var control = currentControl as ArcControl;
1358
                                if (control != null)
1359
                                {
1360
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1361
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1362
                                }
1363
                            }
1364
                            break;
1365

    
1366
                        case ControlType.ArcArrow:
1367
                            {
1368
                                var control = currentControl as ArrowArcControl;
1369
                                if (control != null)
1370
                                {
1371
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1372
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1373
                                }
1374
                            }
1375
                            break;
1376

    
1377
                        case ControlType.ArrowMultiLine:
1378
                            {
1379
                                var control = currentControl as ArrowControl_Multi;
1380
                                if (control != null)
1381
                                {
1382
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1383
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1384
                                }
1385
                            }
1386
                            break;
1387

    
1388
                        case ControlType.Circle:
1389
                            {
1390
                                if (currentControl != null)
1391
                                {
1392
                                    currentControl.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1393
                                    (currentControl as CircleControl).DashSize = ViewerDataModel.Instance.DashSize;
1394
                                    (currentControl as CircleControl).Paint = ViewerDataModel.Instance.paintSet;
1395
                                }
1396
                            }
1397
                            break;
1398

    
1399
                        case ControlType.PolygonCloud:
1400
                            {
1401
                                var control = currentControl as CloudControl;
1402
                                if (control != null)
1403
                                {
1404
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1405
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1406
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1407
                                }
1408
                            }
1409
                            break;
1410

    
1411
                        case ControlType.Triangle:
1412
                            {
1413
                                var control = currentControl as TriControl;
1414
                                if (control != null)
1415
                                {
1416
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1417
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1418
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1419
                                }
1420
                            }
1421
                            break;
1422

    
1423
                        case ControlType.ImgControl:
1424
                            {
1425
                                var control = currentControl as ImgControl;
1426
                                if (control != null)
1427
                                {
1428
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1429
                                }
1430
                            }
1431
                            break;
1432

    
1433
                        case ControlType.Date:
1434
                            {
1435
                                var control = currentControl as DateControl;
1436
                                if (control != null)
1437
                                {
1438
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1439
                                }
1440
                            }
1441
                            break;
1442

    
1443
                        case ControlType.ArrowTextControl:
1444
                        case ControlType.ArrowTransTextControl:
1445
                        case ControlType.ArrowTextBorderControl:
1446
                        case ControlType.ArrowTransTextBorderControl:
1447
                        case ControlType.ArrowTextCloudControl:
1448
                        case ControlType.ArrowTransTextCloudControl:
1449
                            {
1450
                                var control = currentControl as ArrowTextControl;
1451
                                if (control != null)
1452
                                {
1453
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1454
                                }
1455
                            }
1456
                            break;
1457
                        case ControlType.PolygonControl:
1458
                        case ControlType.ChainLine:
1459
                            {
1460
                                var control = currentControl as PolygonControl;
1461
                                if (control != null)
1462
                                {
1463
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1464
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1465
                                    control.Paint = ViewerDataModel.Instance.paintSet;
1466
                                }
1467
                            }
1468
                            break;
1469
                        case ControlType.Sign:
1470
                            {
1471
                                var control = currentControl as SignControl;
1472
                                if (control != null)
1473
                                {
1474
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1475
                                }
1476
                            }
1477
                            break;
1478
                        case ControlType.Symbol:
1479
                            {
1480
                                var control = currentControl as SymControl;
1481
                                if (control != null)
1482
                                {
1483
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1484
                                }
1485
                            }
1486
                            break;
1487
                        case ControlType.Stamp:
1488
                            {
1489
                                var control = currentControl as SymControlN;
1490
                                if (control != null)
1491
                                {
1492
                                    if (control.STAMP != null)
1493
                                    {
1494
                                        control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1495
                                    }
1496
                                    else
1497
                                    {
1498
                                        currentControl = null;
1499
                                        this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1500
                                        DialogMessage_Alert("Approved Stamp 가 등록되어 있지 않습니다. \n관리자에게 문의하세요.", "안내");
1501
                                    }
1502
                                }                                    
1503
                            }
1504
                            break;
1505
                        case ControlType.Rectangle:
1506
                        case ControlType.Mark:
1507
                            {
1508
                                var control = currentControl as RectangleControl;
1509
                                if (control != null)
1510
                                {
1511
                                    control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);
1512
                                    if(control.ControlType == ControlType.Mark) control.Paint = PaintSet.Fill;
1513
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
1514
                                }
1515
                            }
1516
                            break;
1517
                        case ControlType.PenControl:
1518
                            {
1519
                                stroke.StylusPoints.Add(new StylusPoint(currentCanvasDrawingMouseMovePoint.X, currentCanvasDrawingMouseMovePoint.Y));
1520
                                //inkBoard.Strokes.Add(stroke);
1521
                            }
1522
                            break;
1523
                        default:
1524
                            break;
1525
                    }
1526
                }
1527
            }
1528
            else if(mouseHandlingMode == MouseHandlingMode.Drawing && e.LeftButton == MouseButtonState.Pressed)
1529
            {
1530
                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);
1531
                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);
1532
                SetCursor();
1533
                if (currentControl == null)
1534
                {
1535
                    switch (controlType)
1536
                    {
1537
                        case ControlType.PenControl:
1538
                            {
1539
                                if (inkBoard.Tag.ToString() == "Ink")
1540
                                {
1541
                                    stroke.StylusPoints.Add(new StylusPoint(currentCanvasDrawingMouseMovePoint.X, currentCanvasDrawingMouseMovePoint.Y));
1542
                                }
1543
                                else if (inkBoard.Tag.ToString() == "EraseByPoint")
1544
                                {
1545
                                    RemovePointStroke(currentCanvasDrawingMouseMovePoint);
1546
                                }
1547
                                else if (inkBoard.Tag.ToString() == "EraseByStroke")
1548
                                {
1549
                                    RemoveLineStroke(currentCanvasDrawingMouseMovePoint);
1550
                                }
1551

    
1552
                                //inkBoard.Strokes.Add(stroke);
1553
                            }
1554
                            break;
1555
                    }
1556
                    return;
1557
                }
1558
            }
1559
            else if (((e.LeftButton == MouseButtonState.Pressed) && mouseHandlingMode == MouseHandlingMode.Selecting) || 
1560
                ((e.LeftButton == MouseButtonState.Pressed) && mouseHandlingMode == MouseHandlingMode.Capture) || 
1561
                ((e.LeftButton == MouseButtonState.Pressed) && mouseHandlingMode == MouseHandlingMode.DragZoom))
1562
            {
1563
                Point curMouseDownPoint = e.GetPosition(drawingRotateCanvas);
1564

    
1565
                if (isDraggingSelectionRect)
1566
                {
1567
                    UpdateDragSelectionRect(canvasDrawingMouseDownPoint, curMouseDownPoint);
1568
                    e.Handled = true;
1569
                }
1570
                else if (isLeftMouseButtonDownOnWindow)
1571
                {
1572
                    var dragDelta = curMouseDownPoint - canvasDrawingMouseDownPoint;
1573
                    double dragDistance = Math.Abs(dragDelta.Length);
1574

    
1575
                    if (dragDistance > DragThreshold)
1576
                    {
1577
                        isDraggingSelectionRect = true;
1578
                        InitDragSelectionRect(canvasDrawingMouseDownPoint, curMouseDownPoint);
1579
                    }
1580

    
1581
                    e.Handled = true;
1582
                }
1583

    
1584
                if (canvasDrawingMouseDownPoint == curMouseDownPoint)
1585
                {
1586
                }
1587
                else
1588
                {
1589
                    e.Handled = true;
1590
                }
1591
            }
1592
            /*
1593
            else if ((e.LeftButton == MouseButtonState.Pressed) && mouseHandlingMode == MouseHandlingMode.DragSymbol)
1594
            { //symbol      
1595
                if(_dragdropWindow != null)
1596
                {
1597
                    Win32Point w32Mouse = new Win32Point();
1598
                    GetCursorPos(ref w32Mouse);
1599

    
1600
                    this._dragdropWindow.Left = w32Mouse.X - (symbol_img.Width / 2);
1601
                    this._dragdropWindow.Top = w32Mouse.Y - (symbol_img.Height / 2);
1602
                }                
1603
            }
1604
            */
1605
            else if ((e.LeftButton == MouseButtonState.Released) && (e.MiddleButton == MouseButtonState.Released) && 
1606
                (e.RightButton == MouseButtonState.Released) && ViewerDataModel.Instance.MarkupControls_USER.Count > 0)
1607
            {
1608
                var control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.IsMouseOver).FirstOrDefault();
1609
                if(control != null)
1610
                {
1611
                    this.cursor = Cursors.Hand;
1612
                    SetCursor();
1613
                }
1614
                else
1615
                {
1616
                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1617
                    SetCursor();
1618
                }
1619
            }
1620
            else
1621
            {
1622
            }
1623
        }
1624

    
1625
        private void zoomAndPanControl2_MouseMove(object sender, MouseEventArgs e)
1626
        {
1627
            if ((e.MiddleButton == MouseButtonState.Pressed) || (e.RightButton == MouseButtonState.Pressed))
1628
            {
1629
                SetCursor();
1630
                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas2);
1631
                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas2);
1632

    
1633
                Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;
1634

    
1635
                ViewerDataModel.Instance.Sync_ContentOffsetX -= dragOffset.X;
1636
                ViewerDataModel.Instance.Sync_ContentOffsetY -= dragOffset.Y;
1637

    
1638
                if (Sync.IsChecked)
1639
                {
1640
                    zoomAndPanControl.ContentOffsetX = ViewerDataModel.Instance.Sync_ContentOffsetX;
1641
                    zoomAndPanControl.ContentOffsetY = ViewerDataModel.Instance.Sync_ContentOffsetY;
1642
                }
1643
            }
1644
        }
1645

    
1646
        private List<CommentUserInfo> hitList = new List<CommentUserInfo>();
1647

    
1648
        private EllipseGeometry hitArea = new EllipseGeometry();
1649

    
1650
        private void zoomAndPanControl_MouseUp(object sender, MouseButtonEventArgs e)
1651
        {
1652
            IsDrawing = false;
1653

    
1654
            if (mouseHandlingMode != MouseHandlingMode.None)
1655
            {
1656
                if (mouseHandlingMode == MouseHandlingMode.Drawing)
1657
                {
1658
                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1659

    
1660
                    SetCursor();
1661

    
1662
                    switch (controlType)
1663
                    {
1664
                        case ControlType.None:
1665
                            break;
1666
                        case ControlType.Rectangle:
1667
                            {
1668

    
1669
                            }
1670
                            break;
1671
                        case ControlType.PenControl:
1672
                            {
1673

    
1674
                            }
1675
                            break;
1676
                        default:
1677
                            break;
1678
                    }                    
1679
                }
1680
                else if (mouseHandlingMode == MouseHandlingMode.Selecting && e.ChangedButton == MouseButton.Left || mouseHandlingMode == MouseHandlingMode.Capture && e.ChangedButton == MouseButton.Left || mouseHandlingMode == MouseHandlingMode.DragZoom && e.ChangedButton == MouseButton.Left)
1681
                {
1682
                    if (isLeftMouseButtonDownOnWindow)
1683
                    {
1684
                        bool wasDragSelectionApplied = false;
1685

    
1686
                        if (isDraggingSelectionRect)
1687
                        {
1688
                            if (mouseHandlingMode == MouseHandlingMode.Capture && controlType == ControlType.ImgControl)
1689
                            {
1690
                                dragCaptureBorder.Visibility = Visibility.Collapsed;
1691
                                mouseHandlingMode = MouseHandlingMode.None;
1692
                                Point endPoint = e.GetPosition(zoomAndPanCanvas);
1693
                                symbolselectindex = symbolPanel_Instance.RadTab.SelectedIndex;
1694
                                Set_Symbol_Capture(endPoint);
1695
                                ViewerDataModel.Instance.ViewVisible = Visibility.Collapsed;
1696
                                ViewerDataModel.Instance.ViewVisible = Visibility.Visible;                                
1697
                                ViewerDataModel.Instance.Capture_Opacity = 0;
1698
                            }
1699
                            else if (mouseHandlingMode == MouseHandlingMode.Capture)
1700
                            {
1701
                                dragCaptureBorder.Visibility = Visibility.Collapsed;
1702
                                mouseHandlingMode = MouseHandlingMode.None;
1703
                                Set_Capture();
1704

    
1705
                                ViewerDataModel.Instance.ViewVisible = Visibility.Collapsed;
1706
                                ViewerDataModel.Instance.ViewVisible = Visibility.Visible;
1707
                                ViewerDataModel.Instance.Capture_Opacity = 0;
1708
                            }
1709
                            else if (mouseHandlingMode == MouseHandlingMode.Selecting)
1710
                            {
1711
                                ApplyDragSelectionRect();
1712
                            }
1713
                            else
1714
                            {
1715
                                double x = Canvas.GetLeft(dragZoomBorder);
1716
                                double y = Canvas.GetTop(dragZoomBorder);
1717
                                double width = dragZoomBorder.Width;
1718
                                double height = dragZoomBorder.Height;
1719
                                Rect dragRect = new Rect(x, y, width, height);
1720

    
1721
                                ViewerDataModel.Instance.SystemMain.dzMainMenu.zoomAndPanControl.ZoomTo(dragRect);
1722

    
1723
                                dragZoomBorder.Visibility = Visibility.Collapsed;
1724
                            }
1725

    
1726
                            isDraggingSelectionRect = false;
1727
                            e.Handled = true;
1728
                            wasDragSelectionApplied = true;
1729
                        }
1730

    
1731
                        if (isLeftMouseButtonDownOnWindow)
1732
                        {
1733
                            isLeftMouseButtonDownOnWindow = false;
1734
                            this.ReleaseMouseCapture();
1735
                            e.Handled = true;
1736
                        }
1737

    
1738
                        if (!wasDragSelectionApplied)
1739
                        {
1740
                            init();
1741
                        }
1742
                    }
1743
                }
1744
                else if (e.RightButton == MouseButtonState.Pressed)
1745
                {
1746
                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1747
                    SetCursor();
1748
                }
1749

    
1750
                zoomAndPanControl.ReleaseMouseCapture();
1751

    
1752

    
1753
                e.Handled = true;
1754
            }
1755
            else
1756
            {
1757
                this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1758
                SetCursor();
1759
            }
1760

    
1761
            ///mouseButtonDown = MouseButton.Left;
1762
            //controlType = ControlType.SingleLine;
1763
        }
1764

    
1765
        public void Set_Symbol_Capture(Point endPoint)
1766
        {       
1767
            double x = canvasDrawingMouseDownPoint.X;
1768
            double y = canvasDrawingMouseDownPoint.Y;
1769
            if(x > endPoint.X)
1770
            {
1771
                x = endPoint.X;
1772
                y = endPoint.Y;
1773
            }
1774

    
1775
            double width = dragCaptureBorder.Width;
1776
            double height = dragCaptureBorder.Height;
1777

    
1778
            canvasImage = ConverterBitmapImage(zoomAndPanCanvas);
1779

    
1780
            if (x < 0)
1781
            {
1782
                width += x;
1783
                x = 0;
1784
            }
1785
            if (y < 0)
1786
            {
1787
                height += y;
1788
                y = 0;
1789

    
1790
                width = (int)canvasImage.PixelWidth - x;
1791
            }
1792
            if (x + width > canvasImage.PixelWidth)
1793
            {
1794
                width = (int)canvasImage.PixelWidth - x;
1795
            }
1796
            if (y + height > canvasImage.PixelHeight)
1797
            {
1798
                height = (int)canvasImage.PixelHeight - y;
1799
            }
1800
            var rect = new Int32Rect((int)x, (int)y, (int)width, (int)height);
1801

    
1802
            string uri = "";
1803
            if (userData.COMPANY != "EXT")
1804
            {
1805
                uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO,
1806
                    (Convert.ToInt32(_ViewInfo.DocumentItemID) / 100).ToString(), _ViewInfo.DocumentItemID, Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber);
1807
            }
1808
            else
1809
            {
1810
                uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, _ViewInfo.DocumentItemID,
1811
                    Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber);
1812
            }
1813

    
1814
            var defaultBitmapImage = new BitmapImage();
1815
            defaultBitmapImage.BeginInit();
1816
            defaultBitmapImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
1817
            defaultBitmapImage.CacheOption = BitmapCacheOption.OnLoad;
1818
            defaultBitmapImage.UriSource = new Uri(uri);
1819
            defaultBitmapImage.EndInit();
1820

    
1821
            //GC.Collect();
1822

    
1823
            if (defaultBitmapImage.IsDownloading)
1824
            {
1825
                defaultBitmapImage.DownloadCompleted += (ex, arg) =>
1826
                {
1827
                    defaultBitmapImage.Freeze();
1828
                    //GC.Collect();
1829
                    BitmapSource bs = new CroppedBitmap(defaultBitmapImage, rect);
1830
                    Save_Symbol_Capture(bs, (int)x, (int)y, (int)width, (int)height);
1831
                };
1832
            }
1833
        }
1834

    
1835
        private void zoomAndPanControl2_MouseUp(object sender, MouseButtonEventArgs e)
1836
        {
1837
            ///mouseButtonDown = MouseButton.Left;
1838
        }
1839

    
1840
        private void zoomAndPanControl_MouseLeave(object sender, MouseEventArgs e)
1841
        {
1842
            ///mouseButtonDown = MouseButton.Left;
1843
            //this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
1844
        }
1845

    
1846
        private void zoomAndPanControl_MouseDoubleClick(object sender, MouseButtonEventArgs e)
1847
        {
1848

    
1849
        }
1850

    
1851
        /// <summary>
1852
        /// select items by dragging
1853
        /// </summary>
1854
        private void ApplyDragSelectionRect()
1855
        {
1856
            dragSelectionBorder.Visibility = Visibility.Collapsed;
1857

    
1858
            double x = Canvas.GetLeft(dragSelectionBorder);
1859
            double y = Canvas.GetTop(dragSelectionBorder);
1860
            double width = dragSelectionBorder.Width;
1861
            double height = dragSelectionBorder.Height;
1862
            Boolean Flag = false;
1863
            List<MarkupToPDF.Common.CommentUserInfo> adornerSet = new List<MarkupToPDF.Common.CommentUserInfo>();
1864
            var Items = ViewerDataModel.Instance.MarkupControls_USER.Where(d => d.Visibility != Visibility.Hidden).ToList();
1865

    
1866
            Rect dragRect = new Rect(x, y, width, height);
1867
            ///dragRect.Inflate(width / 10, height / 10);
1868

    
1869
            foreach (var item in Items)
1870
            {
1871
                Flag = SelectionSet.Instance.SelectControl(item, dragRect);
1872

    
1873
                if (Flag)
1874
                {
1875
                    adornerSet.Add(item);
1876
                    ViewerDataModel.Instance.MarkupControls_USER.Remove(item);
1877
                    Control_Style(item);
1878
                }
1879
            }
1880
            if (adornerSet.Count > 0)
1881
            {
1882
                Controls.AdornerFinal final = new Controls.AdornerFinal(adornerSet);
1883
                SelectLayer.Children.Add(final);
1884
            }
1885
        }
1886

    
1887
        private void InitDragSelectionRect(Point pt1, Point pt2)
1888
        {
1889
            //캡쳐 중
1890
            if (mouseHandlingMode == MouseHandlingMode.Capture)
1891
            {
1892
                dragCaptureBorder.Visibility = Visibility.Visible;
1893
            }
1894
            //선택 중
1895
            else if (mouseHandlingMode == MouseHandlingMode.Selecting)
1896
            {
1897

    
1898
                dragSelectionBorder.Visibility = Visibility.Visible;
1899
            }
1900
            else
1901
            {
1902
                dragZoomBorder.Visibility = Visibility.Visible;
1903
            }
1904
            UpdateDragSelectionRect(pt1, pt2);
1905
        }
1906

    
1907
        /// <summary>
1908
        /// Update the position and size of the rectangle used for drag selection.
1909
        /// </summary>
1910
        private void UpdateDragSelectionRect(Point pt1, Point pt2)
1911
        {
1912
            double x, y, width, height;
1913

    
1914
            //
1915
            // Determine x,y,width and height of the rect inverting the points if necessary.
1916
            // 
1917

    
1918
            if (pt2.X < pt1.X)
1919
            {
1920
                x = pt2.X;
1921
                width = pt1.X - pt2.X;
1922
            }
1923
            else
1924
            {
1925
                x = pt1.X;
1926
                width = pt2.X - pt1.X;
1927
            }
1928

    
1929
            if (pt2.Y < pt1.Y)
1930
            {
1931
                y = pt2.Y;
1932
                height = pt1.Y - pt2.Y;
1933
            }
1934
            else
1935
            {
1936
                y = pt1.Y;
1937
                height = pt2.Y - pt1.Y;
1938
            }
1939

    
1940
            //
1941
            // Update the coordinates of the rectangle used for drag selection.
1942
            //
1943
            //캡쳐 중
1944
            if (mouseHandlingMode == MouseHandlingMode.Capture)
1945
            {
1946
                Canvas.SetLeft(dragCaptureBorder, x);
1947
                Canvas.SetTop(dragCaptureBorder, y);
1948
                dragCaptureBorder.Width = width;
1949
                dragCaptureBorder.Height = height;
1950
            }
1951
            //선택 중
1952
            else if (mouseHandlingMode == MouseHandlingMode.Selecting)
1953
            {
1954
                Canvas.SetLeft(dragSelectionBorder, x);
1955
                Canvas.SetTop(dragSelectionBorder, y);
1956
                dragSelectionBorder.Width = width;
1957
                dragSelectionBorder.Height = height;
1958
            }
1959
            else
1960
            {
1961
                Canvas.SetLeft(dragZoomBorder, x);
1962
                Canvas.SetTop(dragZoomBorder, y);
1963
                dragZoomBorder.Width = width;
1964
                dragZoomBorder.Height = height;
1965
            }
1966
        }
1967

    
1968
        private void drawingPannelRotate(double angle)
1969
        {
1970
            Logger.sendCheckLog("pageNavigator_PageChanging_drawingPannelRotate Setting", 1);
1971
            rotate.Angle = angle;
1972
            var rotationNum = Math.Abs((rotate.Angle / 90));
1973

    
1974
            if (angle == 90 || angle == 270)
1975
            {
1976
                double emptySize = zoomAndPanCanvas.Width;
1977
                zoomAndPanCanvas.Width = zoomAndPanCanvas.Height;
1978
                zoomAndPanCanvas.Height = emptySize;
1979
            }
1980
            if (angle == 0)
1981
            {
1982
                translate.X = 0;
1983
                translate.Y = 0;
1984
            }
1985
            else if (angle == 90)
1986
            {
1987
                translate.X = zoomAndPanCanvas.Width;
1988
                translate.Y = 0;
1989
            }
1990
            else if (angle == 180)
1991
            {
1992
                translate.X = zoomAndPanCanvas.Width;
1993
                translate.Y = zoomAndPanCanvas.Height;
1994
            }
1995
            else
1996
            {
1997
                translate.X = 0;
1998
                translate.Y = zoomAndPanCanvas.Height;
1999
            }
2000

    
2001
            zoomAndPanControl.RotationAngle = rotate.Angle;
2002

    
2003

    
2004
            if (!testPanel2.IsHidden)
2005
            {
2006
                zoomAndPanControl2.RotationAngle = rotate.Angle;
2007
                zoomAndPanCanvas2.Width = zoomAndPanCanvas.Width;
2008
                zoomAndPanCanvas2.Height = zoomAndPanCanvas.Height;
2009
            }
2010

    
2011
            ViewerDataModel.Instance.ContentWidth = zoomAndPanCanvas.Width;
2012
            ViewerDataModel.Instance.ContentHeight = zoomAndPanCanvas.Height;
2013
            ViewerDataModel.Instance.AngleOffsetX = translate.X;
2014
            ViewerDataModel.Instance.AngleOffsetY = translate.Y;
2015
            ViewerDataModel.Instance.Angle = rotate.Angle;
2016
        }
2017

    
2018
        private void syncPannelRotate(double angle)
2019
        {
2020
            //Logger.sendCheckLog("pageNavigator_PageChanging_drawingPannelRotate Setting", 1);
2021
            rotate.Angle = angle;
2022
            var rotationNum = Math.Abs((rotate.Angle / 90));
2023

    
2024
            if (angle == 90 || angle == 270)
2025
            {
2026
                double emptySize = zoomAndPanCanvas2.Width;
2027
                zoomAndPanCanvas2.Width = zoomAndPanCanvas2.Height;
2028
                zoomAndPanCanvas2.Height = emptySize;
2029
            }
2030
            if (angle == 0)
2031
            {
2032
                translate2.X = 0;
2033
                translate2.Y = 0;
2034
            }
2035
            else if (angle == 90)
2036
            {
2037
                translate2.X = zoomAndPanCanvas2.Width;
2038
                translate2.Y = 0;
2039
            }
2040
            else if (angle == 180)
2041
            {
2042
                translate2.X = zoomAndPanCanvas2.Width;
2043
                translate2.Y = zoomAndPanCanvas2.Height;
2044
            }
2045
            else
2046
            {
2047
                translate2.X = 0;
2048
                translate2.Y = zoomAndPanCanvas2.Height;
2049
            }
2050

    
2051
            zoomAndPanControl2.RotationAngle = rotate.Angle;
2052
        }
2053

    
2054
        public void PlaceImageSymbol(string id, long group_id, int SelectedIndex, Point canvasZoomPanningMouseDownPoint)
2055
        {
2056
            string Data_ = "";
2057

    
2058
            try
2059
            {
2060
                Logger.sendReqLog("GetSymbolImageURL: ", id + "," + SelectedIndex, 1);
2061
                Data_ = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.GetSymbolImageURL(id, SelectedIndex);
2062
                if (Data_ != null || Data_ != "")
2063
                {
2064
                    Logger.sendResLog("GetSymbolImageURL", "TRUE", 1);
2065
                }
2066
                else
2067
                {
2068
                    Logger.sendResLog("GetSymbolImageURL", "FALSE", 1);
2069
                }
2070

    
2071
                //MARKUP_DATA_GROUP mARKUP_DATA_GROUP = new MARKUP_DATA_GROUP
2072
                //{
2073
                //    SYMBOL_ID = id,//InnerItem.Symbol_ID
2074
                //    STATE = 0,
2075
                //};
2076
                if (Data_ != null)
2077
                {
2078
                    Image img = new Image();
2079
                    //img.Source = new System.Windows.Media.Imaging.BitmapImage(new Uri(Data_));
2080
                    if (Data_.Contains(".svg"))
2081
                    {
2082
                        byte[] imageData = null;
2083
                        DrawingImage image = null;
2084
                        using (System.Net.WebClient web = new System.Net.WebClient())
2085
                        {
2086
                            imageData = web.DownloadData(new Uri(Data_));
2087
                            System.IO.Stream stream = new System.IO.MemoryStream(imageData);
2088
                            image = SvgReader.Load(stream);
2089
                        }
2090
                        img.Source = image;
2091
                    }
2092
                    else
2093
                    {
2094
                        img.Source = new BitmapImage(new Uri(Data_));
2095
                    }
2096

    
2097
                    var currentControl = new MarkupToPDF.Controls.Etc.ImgControl
2098
                    {
2099
                        PointSet = new List<Point>(),
2100
                        FilePath = Data_,
2101
                        ImageData = img.Source,
2102
                        StartPoint = canvasZoomPanningMouseDownPoint,
2103
                        EndPoint = new Point(canvasZoomPanningMouseDownPoint.X + img.Source.Width, 
2104
                        canvasZoomPanningMouseDownPoint.Y + img.Source.Height),
2105
                        TopRightPoint = new Point(canvasZoomPanningMouseDownPoint.X+img.Source.Width,
2106
                        canvasZoomPanningMouseDownPoint.Y),
2107
                        LeftBottomPoint = new Point(canvasZoomPanningMouseDownPoint.X,
2108
                        canvasZoomPanningMouseDownPoint.Y + img.Source.Height)
2109
                    };
2110

    
2111
                    currentControl.PointSet = new List<Point>
2112
                                        {
2113
                                            currentControl.StartPoint,
2114
                                            currentControl.LeftBottomPoint,
2115
                                            currentControl.EndPoint,
2116
                                            currentControl.TopRightPoint,
2117
                                        };
2118
                    Multi_Undo_data multi_Undo_Data = new Multi_Undo_data();
2119
                    UndoData = new Undo_data()
2120
                    {
2121
                        IsUndo = false,
2122
                        Event = Event_Type.Create,
2123
                        EventTime = DateTime.Now,
2124
                        Markup_List = new List<Multi_Undo_data>()
2125
                    };
2126
                    ViewerDataModel.Instance.UndoDataList.Where(data1 => data1.IsUndo == true).ToList().ForEach(i =>
2127
                    {
2128
                        ViewerDataModel.Instance.UndoDataList.Remove(i);
2129
                    });
2130

    
2131
                    //multi_Undo_Data = dzMainMenu.Control_Style(currentControl as MarkupToPDF.Common.CommentUserInfo);
2132
                    multi_Undo_Data = Control_Style(currentControl as MarkupToPDF.Common.CommentUserInfo);
2133
                    UndoData.Markup_List.Add(multi_Undo_Data);
2134
                    ViewerDataModel.Instance.UndoDataList.Add(UndoData);
2135

    
2136
                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl as MarkupToPDF.Common.CommentUserInfo);
2137
                    currentControl.CommentID = Commons.shortGuid();
2138
                    currentControl.SymbolID = id;
2139
                    currentControl.GroupID = group_id;
2140
                    currentControl.ApplyTemplate();
2141
                    currentControl.SetImage();
2142

    
2143
                    ViewerDataModel.Instance.MarkupControls_USER.Remove(currentControl as MarkupToPDF.Common.CommentUserInfo);
2144
                    Controls.AdornerFinal final = new Controls.AdornerFinal(currentControl as MarkupToPDF.Common.CommentUserInfo);
2145
                    SelectLayer.Children.Add(final);
2146
                }
2147
            }
2148
            catch (Exception ex)
2149
            {
2150
                this.ParentOfType<MainWindow>().dzMainMenu.DialogMessage_Alert(ex.Message, "Error");
2151
            }
2152
        }
2153

    
2154
        private void zoomAndPanControl_MouseDown(object sender, MouseButtonEventArgs e)
2155
        {            
2156
            var set_option = this.ParentOfType<MainWindow>().dzTopMenu.Parent.ChildrenOfType<RadNumericUpDown>().Where(item => item.IsKeyboardFocusWithin).FirstOrDefault();
2157
            if (set_option != null && !string.IsNullOrEmpty(set_option.ContentText))
2158
            {
2159
                set_option.Value = double.Parse(set_option.ContentText);
2160
                //set_option.Focusable = false;
2161
                zoomAndPanControl.Focus();
2162
            }
2163

    
2164
            ConvertInkControlToPolygon();
2165

    
2166
            ///TODO:
2167
            var text_item = ViewerDataModel.Instance.MarkupControls_USER.Where(data =>
2168
            (data as TextControl) != null && (data as TextControl).Text == "" || (data as ArrowTextControl) != null && (data as ArrowTextControl).ArrowText == "").FirstOrDefault();
2169

    
2170
            if (text_item != null && (currentControl as ArrowTextControl) == null)
2171
            {
2172
                ViewerDataModel.Instance.MarkupControls_USER.Remove(text_item);
2173
            }
2174
            /// up to here
2175

    
2176
            foreach (var item in ViewerDataModel.Instance.MarkupControls_USER)
2177
            {
2178
                if (item as ArrowTextControl != null)
2179
                {
2180
                    (item as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
2181
                }
2182
                else if (item as TextControl != null)
2183
                {
2184
                    (item as TextControl).Base_TextBox.IsHitTestVisible = false;
2185
                }
2186
            }
2187

    
2188
            //if (currentControl != null)
2189
            {
2190
                var text_item_ = ViewerDataModel.Instance.MarkupControls_USER.Where(data => (data as TextControl) != null && (data as TextControl).IsEditingMode == true).FirstOrDefault();
2191
                if (text_item_ != null)
2192
                {
2193
                    (text_item_ as TextControl).Base_TextBlock.Visibility = Visibility.Visible;
2194
                    (text_item_ as TextControl).Base_TextBox.Visibility = Visibility.Collapsed;
2195
                    (text_item_ as TextControl).IsEditingMode = false;                    
2196
                    currentControl = null;
2197
                }
2198

    
2199
                var Arrowtext_item_ = ViewerDataModel.Instance.MarkupControls_USER.Where(data => (data as ArrowTextControl) != null && (data as ArrowTextControl).IsEditingMode == true).FirstOrDefault();
2200
                if (Arrowtext_item_ != null && ((Arrowtext_item_ as ArrowTextControl).IsNew == false))
2201
                {
2202
                    (Arrowtext_item_ as ArrowTextControl).IsEditingMode = false;
2203
                    (Arrowtext_item_ as ArrowTextControl).Base_TextBox.Focusable = false;
2204
                    currentControl = null;
2205
                }
2206
            }
2207

    
2208
            double Ang = 0;                                          
2209
            if (rotate.Angle != 0)
2210
            {
2211
                Ang = 360 - rotate.Angle;
2212
            }
2213

    
2214
            if (e.OriginalSource is System.Windows.Controls.Image)
2215
            {
2216
                (e.OriginalSource as System.Windows.Controls.Image).Focus();
2217
            }
2218
            /*
2219
            if (mouseHandlingMode == MouseHandlingMode.DragSymbol && e.LeftButton == MouseButtonState.Pressed)
2220
            {                
2221
                canvasZoomPanningMouseDownPoint = e.GetPosition(zoomAndPanCanvas);
2222
                if(symbol_id != null)
2223
                {
2224
                    PlaceImageSymbol(symbol_id, symbol_group_id, symbol_SelectedIndex, canvasZoomPanningMouseDownPoint);
2225
                }                
2226
            }
2227

    
2228
            if (mouseHandlingMode == MouseHandlingMode.DragSymbol && e.RightButton == MouseButtonState.Pressed)
2229
            {
2230
                if (this._dragdropWindow != null)
2231
                {
2232
                    this._dragdropWindow.Close();
2233
                    this._dragdropWindow = null;
2234
                    symbol_id = null;
2235
                }
2236
            }
2237
            */
2238

    
2239
            if (e.LeftButton == MouseButtonState.Pressed)
2240
            {
2241
                canvasDrawingMouseDownPoint = e.GetPosition(drawingRotateCanvas);
2242
                canvasZoomPanningMouseDownPoint = e.GetPosition(zoomAndPanCanvas);
2243

    
2244
                this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
2245
                SetCursor();
2246

    
2247
                if (!ViewerDataModel.Instance.IsPressCtrl) SelectionSet.Instance.UnSelect(this);
2248
            }
2249

    
2250
            if (e.MiddleButton == MouseButtonState.Pressed)
2251
            {
2252
                canvasZoommovingMouseDownPoint = e.GetPosition(zoomAndPanCanvas);
2253
                cursor = Cursors.SizeAll;
2254
                SetCursor();
2255
            }
2256
            if (e.RightButton == MouseButtonState.Pressed)
2257
            {
2258
                canvasZoommovingMouseDownPoint = e.GetPosition(zoomAndPanCanvas);
2259
                cursor = Cursors.SizeAll;
2260
                SetCursor();
2261
            }
2262
            else if (e.XButton1 == MouseButtonState.Pressed)
2263
            {
2264
                if (this.pageNavigator.CurrentPage.PageNumber + 1 <= this.pageNavigator.PageCount)
2265
                {
2266
                    this.pageNavigator.GotoPage(this.pageNavigator.CurrentPage.PageNumber + 1);
2267
                }
2268

    
2269
                //this.pageNavigator.GotoPage(this.pageNavigator._NextPage.PageNumber);
2270

    
2271
            }
2272
            else if (e.XButton2 == MouseButtonState.Pressed)
2273
            {
2274
                if (this.pageNavigator.CurrentPage.PageNumber > 1)
2275
                {
2276
                    this.pageNavigator.GotoPage(this.pageNavigator.CurrentPage.PageNumber - 1);
2277
                }
2278
            }
2279

    
2280
            if (e.LeftButton == MouseButtonState.Pressed && mouseHandlingMode != MouseHandlingMode.Drawing && currentControl == null)
2281
            {
2282
                if (mouseHandlingMode == MouseHandlingMode.Selecting)
2283
                {
2284
                    if (SelectLayer.Children.Count == 0)
2285
                    {
2286
                        isLeftMouseButtonDownOnWindow = true;
2287
                        mouseHandlingMode = MouseHandlingMode.Selecting;
2288
                    }
2289

    
2290
                    if (controlType == ControlType.None)
2291
                    {
2292
                        isLeftMouseButtonDownOnWindow = true;
2293
                    }
2294
                }
2295

    
2296
                /// 캡쳐 모드 설정
2297
                if (mouseHandlingMode == MouseHandlingMode.Capture)
2298
                {
2299
                    dragCaptureBorder.Visibility = Visibility.Visible;
2300
                    isLeftMouseButtonDownOnWindow = true;
2301
                }
2302

    
2303
                /// 줌 모드 설정
2304
                if (mouseHandlingMode == MouseHandlingMode.DragZoom)
2305
                {
2306
                    isLeftMouseButtonDownOnWindow = true;
2307
                }
2308

    
2309
                var control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.IsMouseOver).FirstOrDefault();
2310
                if (control != null)
2311
                {
2312
                    AdornerFinal final = null;
2313

    
2314
                    if (!ViewerDataModel.Instance.IsPressCtrl)
2315
                    {
2316
                        /// 기존 selection 해제
2317
                        SelectionSet.Instance.UnSelect(this);
2318

    
2319
                        final = new AdornerFinal(control);
2320

    
2321
                        this.Control_Style(control);
2322

    
2323
                        if ((control as IPath) != null)
2324
                        {
2325
                            if ((control as IPath).LineSize != 0)
2326
                            {
2327
                                ViewerDataModel.Instance.LineSize = (control as IPath).LineSize;
2328
                            }
2329
                        }
2330
                        if ((control as IShapeControl) != null)
2331
                        {
2332
                            if ((control as IShapeControl).Paint == PaintSet.Hatch)
2333
                            {
2334
                                ViewerDataModel.Instance.checkHatchShape = true;
2335
                            }
2336
                            else if ((control as IShapeControl).Paint == PaintSet.Fill)
2337
                            {
2338
                                ViewerDataModel.Instance.checkFillShape = true;
2339
                            }
2340
                            else
2341
                            {
2342
                                ViewerDataModel.Instance.checkHatchShape = false;
2343
                                ViewerDataModel.Instance.checkFillShape = false;
2344
                            }
2345
                            ViewerDataModel.Instance.paintSet = (control as IShapeControl).Paint;
2346
                        }
2347

    
2348
                        ViewerDataModel.Instance.ControlOpacity = control.Opacity;
2349

    
2350
                        if ((control as TextControl) != null)
2351
                        {
2352
                            if(!((control as TextControl).EnableEditing)) {
2353
                                (control as TextControl).EnableEditing = true;
2354
                            }
2355
                            if ((control as TextControl).TextStyle == FontStyles.Italic)
2356
                            {
2357
                                ViewerDataModel.Instance.checkTextStyle = true;
2358
                            }
2359
                            else
2360
                            {
2361
                                ViewerDataModel.Instance.checkTextStyle = false;
2362
                            }
2363
                            if ((control as TextControl).TextWeight == FontWeights.Bold)
2364
                            {
2365
                                ViewerDataModel.Instance.checkTextWeight = true;
2366
                            }
2367
                            else
2368
                            {
2369
                                ViewerDataModel.Instance.checkTextWeight = false;
2370
                            }
2371
                            if ((control as TextControl).UnderLine == TextDecorations.Underline)
2372
                            {
2373
                                ViewerDataModel.Instance.checkUnderLine = true;
2374
                            }
2375
                            else
2376
                            {
2377
                                ViewerDataModel.Instance.checkUnderLine = false;
2378
                            }
2379
                            ViewerDataModel.Instance.TextSize = (control as TextControl).TextSize;
2380
                            ViewerDataModel.Instance.checkHighlight = (control as TextControl).IsHighLight;
2381

    
2382
                        }
2383
                        else if ((control as ArrowTextControl) != null)
2384
                        {
2385
                            if (!((control as ArrowTextControl).EnableEditing))
2386
                            {
2387
                                (control as ArrowTextControl).EnableEditing = true;
2388
                            }
2389
                            if ((control as ArrowTextControl).TextStyle == FontStyles.Italic)
2390
                            {
2391
                                ViewerDataModel.Instance.checkTextStyle = true;
2392
                            }
2393
                            else
2394
                            {
2395
                                ViewerDataModel.Instance.checkTextStyle = false;
2396
                            }
2397
                            if ((control as ArrowTextControl).TextWeight == FontWeights.Bold)
2398
                            {
2399
                                ViewerDataModel.Instance.checkTextWeight = true;
2400
                            }
2401
                            else
2402
                            {
2403
                                ViewerDataModel.Instance.checkTextWeight = false;
2404
                            }
2405
                            if ((control as ArrowTextControl).UnderLine == TextDecorations.Underline)
2406
                            {
2407
                                ViewerDataModel.Instance.checkUnderLine = true;
2408
                            }
2409
                            else
2410
                            {
2411
                                ViewerDataModel.Instance.checkUnderLine = false;
2412
                            }
2413
                            ViewerDataModel.Instance.checkHighlight = (control as ArrowTextControl).isHighLight;
2414
                            ViewerDataModel.Instance.TextSize = (control as ArrowTextControl).TextSize;
2415
                        }
2416
                        else if ((control as RectCloudControl) != null)
2417
                        {
2418
                            ViewerDataModel.Instance.ArcLength = (control as RectCloudControl).ArcLength;
2419
                        }
2420
                        else if ((control as CloudControl) != null)
2421
                        {
2422
                            ViewerDataModel.Instance.ArcLength = (control as CloudControl).ArcLength;
2423
                        }
2424
                    }
2425
                    else
2426
                    {
2427
                        List<CommentUserInfo> comment = SelectionSet.Instance.SelectedItems;
2428
                        SelectionSet.Instance.UnSelect(this);
2429
                        comment.Add(control);
2430

    
2431
                        Control_Style(control);
2432

    
2433
                        final = new AdornerFinal(comment);
2434
                    }
2435

    
2436
                    if (final != null)
2437
                    {
2438
                        this.SelectLayer.Children.Add(final);
2439
                    }
2440
                }              
2441
            }
2442
            else if (mouseHandlingMode == MouseHandlingMode.Drawing)
2443
            {               
2444
                init();
2445
                //강인구 추가(우 클릭 일 경우 커서 변경 하지 않음)
2446
                if (cursor != Cursors.SizeAll)
2447
                {
2448
                    cursor = Cursors.Cross;
2449
                    SetCursor();
2450
                }
2451
                bool init_user = false;
2452
                foreach (var user in gridViewMarkup.Items)
2453
                {
2454
                    if ((user as MarkupInfoItem).UserID == App.ViewInfo.UserID)
2455
                    {
2456
                        init_user = true;
2457
                    }
2458
                }
2459
                if (init_user && gridViewMarkup.SelectedItems.Where(d => (d as MarkupInfoItem).UserID == App.ViewInfo.UserID).FirstOrDefault() == null && e.LeftButton == MouseButtonState.Pressed)
2460
                {
2461
                    RadWindow.Alert(new DialogParameters
2462
                    {
2463
                        Owner = Application.Current.MainWindow,
2464
                        Theme = new VisualStudio2013Theme(),
2465
                        Header = "안내",
2466
                        Content = "기존의 코멘트가 존재합니다. 사용자 리스트에서 먼저 선택해주세요",
2467
                    });
2468
                    return;
2469
                }
2470
                else
2471
                {
2472
                    var item = gridViewMarkup.SelectedItems.Where(d => (d as MarkupInfoItem).UserID == App.ViewInfo.UserID).FirstOrDefault() as MarkupInfoItem;
2473
                    if (item != null)
2474
                    {
2475
                        App.Custom_ViewInfoId = item.MarkupInfoID;
2476
                    }
2477
                }
2478

    
2479
                switch (controlType)
2480
                {
2481
                    case ControlType.Coordinate:
2482
                        {
2483
                            if (e.LeftButton == MouseButtonState.Pressed)
2484
                            {
2485
                                if (currentControl is CoordinateControl)
2486
                                {
2487
                                    if (IsGetoutpoint((currentControl as CoordinateControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2488
                                    {
2489
                                        return;
2490
                                    }
2491

    
2492
                                    CreateCommand.Instance.Execute(currentControl);
2493

    
2494
                                    currentControl = null;
2495
                                    this.cursor = Cursors.Arrow;
2496
                                }
2497
                                else
2498
                                {
2499
                                    this.ParentOfType<MainWindow>().dzTopMenu._SaveEvent(null, null);
2500
                                    if (ViewerDataModel.Instance.MyMarkupList.Where(d => d.PageNumber == Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber
2501
                                     && d.Data_Type == Convert.ToInt32(MarkupToPDF.Controls.Common.ControlType.Coordinate)).Count() > 0)
2502
                                    {
2503
                                        currentControl = null;
2504
                                        this.cursor = Cursors.Arrow;
2505
                                        Common.ViewerDataModel.Instance.SystemMain.DialogMessage_Alert("이미 해당 페이지의 도면 영역을 설정하셨습니다.", "Notice");
2506
                                        return;
2507
                                    }
2508
                                    else
2509
                                    {
2510
                                        currentControl = new CoordinateControl
2511
                                        {
2512
                                            Background = new SolidColorBrush(Colors.Black),
2513
                                            StartPoint = this.canvasDrawingMouseDownPoint,
2514
                                            ControlType = ControlType.Coordinate
2515
                                        };
2516

    
2517
                                        currentControl.CommentID = Commons.shortGuid();
2518
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2519
                                        currentControl.IsNew = true;
2520

    
2521
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2522

    
2523
                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);
2524
                                    }
2525
                                }
2526
                            }
2527
                        }
2528
                        break;
2529
                    case ControlType.InsideWhite:
2530
                        {
2531
                            if (e.LeftButton == MouseButtonState.Pressed)
2532
                            {
2533
                                if (currentControl is InsideWhiteControl)
2534
                                {
2535
                                    if (IsGetoutpoint((currentControl as InsideWhiteControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2536
                                    {
2537
                                        return;
2538
                                    }
2539

    
2540
                                    CreateCommand.Instance.Execute(currentControl);
2541

    
2542
                                    currentControl = null;
2543
                                    this.cursor = Cursors.Arrow;
2544
                                }
2545
                                else
2546
                                {
2547
                                    currentControl = new InsideWhiteControl
2548
                                    {
2549
                                        Background = new SolidColorBrush(Colors.Black),
2550
                                        StartPoint = this.canvasDrawingMouseDownPoint,
2551
                                        ControlType = ControlType.InsideWhite
2552
                                    };
2553

    
2554
                                    currentControl.CommentID = Commons.shortGuid();
2555
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2556
                                    currentControl.IsNew = true;
2557
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2558

    
2559
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
2560
                                }
2561
                            }
2562
                        }
2563
                        break;
2564
                    case ControlType.OverlapWhite:
2565
                        {
2566
                            if (e.LeftButton == MouseButtonState.Pressed)
2567
                            {
2568
                                if (currentControl is OverlapWhiteControl)
2569
                                {
2570
                                    if (IsGetoutpoint((currentControl as OverlapWhiteControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2571
                                    {
2572
                                        return;
2573
                                    }
2574

    
2575
                                    CreateCommand.Instance.Execute(currentControl);
2576

    
2577
                                    currentControl = null;
2578
                                    this.cursor = Cursors.Arrow;
2579
                                }
2580
                                else
2581
                                {
2582
                                    currentControl = new OverlapWhiteControl
2583
                                    {
2584
                                        Background = new SolidColorBrush(Colors.Black),
2585
                                        StartPoint = this.canvasDrawingMouseDownPoint,
2586
                                        ControlType = ControlType.OverlapWhite
2587
                                    };
2588

    
2589
                                    currentControl.CommentID = Commons.shortGuid();
2590
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2591
                                    currentControl.IsNew = true;
2592
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2593

    
2594
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
2595
                                }
2596
                            }
2597
                        }
2598
                        break;
2599
                    case ControlType.ClipWhite:
2600
                        {
2601
                            if (e.LeftButton == MouseButtonState.Pressed)
2602
                            {
2603
                                if (currentControl is ClipWhiteControl)
2604
                                {
2605
                                    if (IsGetoutpoint((currentControl as ClipWhiteControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2606
                                    {
2607
                                        return;
2608
                                    }
2609

    
2610
                                    CreateCommand.Instance.Execute(currentControl);
2611

    
2612
                                    currentControl = null;
2613
                                    this.cursor = Cursors.Arrow;
2614
                                }
2615
                                else
2616
                                {
2617
                                    currentControl = new ClipWhiteControl
2618
                                    {
2619
                                        Background = new SolidColorBrush(Colors.Black),
2620
                                        StartPoint = this.canvasDrawingMouseDownPoint,
2621
                                        ControlType = ControlType.ClipWhite
2622
                                    };
2623

    
2624
                                    currentControl.CommentID = Commons.shortGuid();
2625
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2626
                                    currentControl.IsNew = true;
2627
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2628

    
2629
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
2630
                                }
2631
                            }
2632
                        }
2633
                        break;
2634
                    case ControlType.Rectangle:
2635
                        {
2636
                            if (e.LeftButton == MouseButtonState.Pressed)
2637
                            {
2638
                                if (currentControl is RectangleControl)
2639
                                {
2640
                                    //20180906 LJY TEST IsRotationDrawingEnable
2641
                                    if (IsGetoutpoint((currentControl as RectangleControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2642
                                    {
2643
                                        return;
2644
                                    }
2645

    
2646
                                    CreateCommand.Instance.Execute(currentControl);
2647
                                    currentControl = null;
2648
                                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
2649
                                }
2650
                                else
2651
                                {
2652
                                    currentControl = new RectangleControl
2653
                                    {
2654
                                        Background = new SolidColorBrush(Colors.Black),
2655
                                        StartPoint = this.canvasDrawingMouseDownPoint,
2656
                                        ControlType = ControlType.Rectangle
2657
                                    };
2658

    
2659
                                    currentControl.CommentID = Commons.shortGuid();
2660
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2661
                                    currentControl.IsNew = true;
2662
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2663

    
2664
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
2665
                                }
2666
                            }
2667
                        }
2668
                        break;
2669
                    case ControlType.RectCloud:
2670
                        {
2671
                            if (e.LeftButton == MouseButtonState.Pressed)
2672
                            {
2673
                                if (currentControl is RectCloudControl)
2674
                                {
2675
                                    //20180906 LJY TEST IsRotationDrawingEnable
2676
                                    if (IsGetoutpoint((currentControl as RectCloudControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2677
                                    {
2678
                                        return;
2679
                                    }
2680

    
2681
                                    CreateCommand.Instance.Execute(currentControl);
2682

    
2683
                                    currentControl = null;
2684
                                
2685
                                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
2686
                                }
2687
                                else
2688
                                {
2689
                                    currentControl = new RectCloudControl
2690
                                    {
2691
                                        StartPoint = this.canvasDrawingMouseDownPoint,
2692
                                        ControlType = ControlType.RectCloud,
2693
                                        Background = new SolidColorBrush(Colors.Black)
2694
                                    };
2695

    
2696
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2697
                                    currentControl.CommentID = Commons.shortGuid();
2698
                                    currentControl.IsNew = true;
2699
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2700
                                }
2701
                            }
2702
                        }
2703
                        break;
2704
                    case ControlType.Circle:
2705
                        {
2706
                            if (e.LeftButton == MouseButtonState.Pressed)
2707
                            {
2708
                                if (currentControl is CircleControl)
2709
                                {
2710
                                    //20180906 LJY TEST IsRotationDrawingEnable
2711
                                    if (IsGetoutpoint((currentControl as CircleControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2712
                                    {
2713
                                        return;
2714
                                    }
2715

    
2716
                                    CreateCommand.Instance.Execute(currentControl);
2717

    
2718
                                    currentControl = null;
2719
                                }
2720
                                else
2721
                                {
2722
                                    currentControl = new CircleControl
2723
                                    {
2724
                                        StartPoint = this.canvasDrawingMouseDownPoint,
2725
                                        LeftBottomPoint = this.canvasDrawingMouseDownPoint,
2726
                                        Background = new SolidColorBrush(Colors.Black)
2727
                                    };
2728

    
2729
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2730
                                    currentControl.CommentID = Commons.shortGuid();
2731
                                    currentControl.IsNew = true;
2732
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2733
                                }
2734
                            }
2735
                        }
2736
                        break;
2737
                    case ControlType.Triangle:
2738
                        {
2739
                            if (e.LeftButton == MouseButtonState.Pressed)
2740
                            {
2741
                                if (currentControl is TriControl)
2742
                                {
2743
                                    var content = currentControl as TriControl;
2744
                                    if (content.MidPoint == new Point(0, 0))
2745
                                    {
2746
                                        content.MidPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y);
2747
                                    }
2748
                                    else
2749
                                    {
2750
                                        //20180906 LJY TEST IsRotationDrawingEnable
2751
                                        if (IsGetoutpoint((currentControl as TriControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2752
                                        {
2753
                                            return;
2754
                                        }
2755

    
2756
                                        CreateCommand.Instance.Execute(currentControl);
2757

    
2758
                                        currentControl = null;
2759
                                    }
2760
                                }
2761
                                else
2762
                                {
2763
                                    currentControl = new TriControl
2764
                                    {
2765
                                        StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
2766
                                        Background = new SolidColorBrush(Colors.Black),
2767
                                    };
2768

    
2769
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2770
                                    currentControl.CommentID = Commons.shortGuid();
2771
                                    currentControl.IsNew = true;
2772
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2773
                                }
2774
                            }
2775
                        }
2776
                        break;
2777
                    case ControlType.CancelLine:
2778
                    case ControlType.SingleLine:
2779
                    case ControlType.ArrowLine:
2780
                    case ControlType.TwinLine:
2781
                    case ControlType.DimLine:
2782
                        {
2783
                            if (e.LeftButton == MouseButtonState.Pressed)
2784
                            {
2785
                                if (currentControl is LineControl)
2786
                                {
2787
                                    //20180906 LJY TEST IsRotationDrawingEnable
2788
                                    if (IsGetoutpoint((currentControl as LineControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2789
                                    {
2790
                                        return;
2791
                                    }
2792

    
2793
                                    CreateCommand.Instance.Execute(currentControl);
2794
                                    currentControl = null;
2795
                                    this.MainAngle.Visibility = Visibility.Collapsed;
2796
                                }
2797
                                else
2798
                                {
2799
                                    currentControl = new LineControl
2800
                                    {
2801
                                        ControlType = this.controlType,
2802
                                        StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
2803
                                        Background = new SolidColorBrush(Colors.Black)
2804
                                    };
2805

    
2806
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2807
                                    currentControl.CommentID = Commons.shortGuid();
2808
                                    currentControl.IsNew = true;
2809
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2810
                                    this.MainAngle.Visibility = Visibility.Visible;
2811
                                }
2812
                            }
2813
                        }
2814
                        break;
2815
                    case ControlType.PolygonControl:
2816
                        {
2817
                            if (currentControl is PolygonControl)
2818
                            {
2819
                                var control = currentControl as PolygonControl;
2820

    
2821
                                if (e.RightButton == MouseButtonState.Pressed)
2822
                                {
2823
                                    control.IsCompleted = true;
2824
                                }
2825

    
2826
                                if (!control.IsCompleted)
2827
                                {
2828
                                    control.PointSet.Add(control.EndPoint);
2829
                                }
2830
                                else
2831
                                {
2832
                                    //20180906 LJY TEST IsRotationDrawingEnable
2833
                                    if (IsGetoutpoint((currentControl as PolygonControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2834
                                    {
2835
                                        return;
2836
                                    }
2837

    
2838
                                    var firstPoint = control.PointSet.First();
2839
                                    control.DashSize = ViewerDataModel.Instance.DashSize;
2840
                                    control.LineSize = ViewerDataModel.Instance.LineSize;
2841
                                    control.PointSet.Add(firstPoint);
2842

    
2843
                                    control.ApplyOverViewData();
2844

    
2845
                                    CreateCommand.Instance.Execute(currentControl);
2846
                                    control.UpdateControl();
2847
                                    currentControl = null;
2848
                                }
2849
                            }
2850
                            else
2851
                            {
2852
                                if (e.LeftButton == MouseButtonState.Pressed)
2853
                                {
2854
                                    currentControl = new PolygonControl
2855
                                    {
2856
                                        PointSet = new List<Point>(),
2857
                                    };
2858

    
2859
                                    var polygonControl = (currentControl as PolygonControl);
2860
                                    currentControl.CommentID = Commons.shortGuid();
2861
                                    currentControl.IsNew = true;
2862
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2863
                                    polygonControl.StartPoint = canvasDrawingMouseDownPoint;
2864
                                    polygonControl.EndPoint = canvasDrawingMouseDownPoint;
2865
                                    polygonControl.PointSet.Add(canvasDrawingMouseDownPoint);
2866
                                    polygonControl.PointSet.Add(canvasDrawingMouseDownPoint);
2867
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2868
                                    polygonControl.ApplyTemplate();
2869
                                    polygonControl.Visibility = Visibility.Visible;
2870
                                }
2871
                            }
2872
                        }
2873
                        break;
2874
                    case ControlType.ChainLine:
2875
                        {
2876
                            if (currentControl is PolygonControl)
2877
                            {
2878
                                var control = currentControl as PolygonControl;
2879

    
2880
                                if (e.RightButton == MouseButtonState.Pressed)
2881
                                {
2882
                                    //20180906 LJY TEST IsRotationDrawingEnable
2883
                                    if (IsGetoutpoint((currentControl as PolygonControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2884
                                    {
2885
                                        return;
2886
                                    }
2887

    
2888
                                    CreateCommand.Instance.Execute(currentControl);
2889

    
2890
                                    currentControl = null;
2891
                                    this.MainAngle.Visibility = Visibility.Collapsed;
2892
                                    return;
2893
                                }
2894

    
2895
                                if (!control.IsCompleted)
2896
                                {
2897
                                    control.PointSet.Add(control.EndPoint);
2898
                                    this.MainAngle.Visibility = Visibility.Visible;
2899
                                }
2900
                            }
2901
                            else
2902
                            {
2903
                                if (e.LeftButton == MouseButtonState.Pressed)
2904
                                {
2905
                                    MainAngle.Visibility = Visibility.Visible;
2906
                                    currentControl = new PolygonControl
2907
                                    {
2908
                                        PointSet = new List<Point>(),
2909
                                        //강인구 추가(ChainLine일때는 채우기 스타일을 주지 않기 위해 설정)
2910
                                        ControlType = ControlType.ChainLine,
2911
                                        DashSize = ViewerDataModel.Instance.DashSize,
2912
                                        LineSize = ViewerDataModel.Instance.LineSize,
2913
                                        //PointC = new StylusPointSet()
2914
                                    };
2915

    
2916
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
2917
                                    //{
2918
                                        var polygonControl = (currentControl as PolygonControl);
2919
                                        currentControl.CommentID = Commons.shortGuid();
2920
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2921
                                        currentControl.IsNew = true;
2922
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2923
                                        //currentControl.OnApplyTemplate();
2924
                                        //polygonControl.PointC.pointSet.Add(canvasDrawingMouseDownPoint);
2925
                                        //polygonControl.PointC.pointSet.Add(canvasDrawingMouseDownPoint);
2926
                                        polygonControl.PointSet.Add(canvasDrawingMouseDownPoint);
2927
                                        polygonControl.PointSet.Add(canvasDrawingMouseDownPoint);
2928
                                    //}
2929
                                }
2930
                            }
2931
                        }
2932
                        break;
2933
                    case ControlType.ArcLine:
2934
                        {
2935
                            if (e.LeftButton == MouseButtonState.Pressed)
2936
                            {
2937
                                if (currentControl is ArcControl)
2938
                                {
2939
                                    //20180906 LJY TEST IsRotationDrawingEnable
2940
                                    if (IsGetoutpoint((currentControl as ArcControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2941
                                    {
2942
                                        return;
2943
                                    }
2944

    
2945
                                    CreateCommand.Instance.Execute(currentControl);
2946

    
2947
                                    currentControl = null;
2948
                                    this.MainAngle.Visibility = Visibility.Collapsed;
2949
                                }
2950
                                else
2951
                                {
2952
                                    currentControl = new ArcControl
2953
                                    {
2954
                                        StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
2955
                                        Background = new SolidColorBrush(Colors.Black)
2956
                                    };
2957
                                    currentControl.CommentID = Commons.shortGuid();
2958
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
2959
                                    currentControl.IsNew = true;
2960
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
2961
                                    this.MainAngle.Visibility = Visibility.Visible;
2962
                                }
2963
                            }
2964
                            else if (e.RightButton == MouseButtonState.Pressed)
2965
                            {
2966
                                if (currentControl != null)
2967
                                {
2968
                                    (currentControl as ArcControl).setClock();
2969
                                    (currentControl as ArcControl).MidPoint = new Point(0, 0);
2970
                                }
2971
                            }
2972
                        }
2973
                        break;
2974
                    case ControlType.ArcArrow:
2975
                        {
2976
                            if (e.LeftButton == MouseButtonState.Pressed)
2977
                            {
2978
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
2979
                                //{
2980
                                if (currentControl is ArrowArcControl)
2981
                                {
2982
                                    //20180906 LJY TEST IsRotationDrawingEnable
2983
                                    if (IsGetoutpoint((currentControl as ArrowArcControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
2984
                                    {
2985
                                        return;
2986
                                    }
2987

    
2988
                                    CreateCommand.Instance.Execute(currentControl);
2989

    
2990
                                    currentControl = null;
2991
                                    this.MainAngle.Visibility = Visibility.Collapsed;
2992
                                }
2993
                                else
2994
                                {
2995
                                    currentControl = new ArrowArcControl
2996
                                    {
2997
                                        StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
2998
                                        Background = new SolidColorBrush(Colors.Black)
2999
                                    };
3000
                                    currentControl.CommentID = Commons.shortGuid();
3001
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3002
                                    currentControl.IsNew = true;
3003
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3004
                                    this.MainAngle.Visibility = Visibility.Visible;
3005
                                }
3006
                                //}
3007
                            }
3008
                            else if (e.RightButton == MouseButtonState.Pressed)
3009
                            {
3010
                                if (currentControl != null)
3011
                                {
3012
                                    (currentControl as ArrowArcControl).setClock();
3013
                                    (currentControl as ArrowArcControl).MidPoint = new Point(0, 0);
3014
                                    //(currentControl as ArcControl).ApplyTemplate();
3015
                                }
3016
                            }
3017
                        }
3018
                        break;
3019
                    case ControlType.ArrowMultiLine:
3020
                        {
3021
                            if (e.LeftButton == MouseButtonState.Pressed)
3022
                            {
3023
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3024
                                //{
3025

    
3026
                                    if (currentControl is ArrowControl_Multi)
3027
                                    {
3028
                                        var content = currentControl as ArrowControl_Multi;
3029
                                        if (content.MiddlePoint == new Point(0, 0))
3030
                                        {
3031
                                            if (ViewerDataModel.Instance.checkAxis || ViewerDataModel.Instance.IsPressShift)
3032
                                            {
3033
                                                content.MiddlePoint = content.EndPoint;
3034
                                            }
3035
                                            else
3036
                                            {
3037
                                                content.MiddlePoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y);
3038
                                            }
3039
                                        }
3040
                                        else
3041
                                        {
3042
                                            //20180906 LJY TEST IsRotationDrawingEnable
3043
                                            if (IsGetoutpoint((currentControl as ArrowControl_Multi).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3044
                                            {
3045
                                                return;
3046
                                            }
3047

    
3048
                                            CreateCommand.Instance.Execute(currentControl);
3049

    
3050
                                            currentControl = null;
3051
                                            this.MainAngle.Visibility = Visibility.Collapsed;
3052
                                        }
3053
                                    }
3054
                                    else
3055
                                    {
3056
                                        currentControl = new ArrowControl_Multi
3057
                                        {
3058
                                            StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
3059
                                            Background = new SolidColorBrush(Colors.Black)
3060
                                        };
3061
                                        currentControl.CommentID = Commons.shortGuid();
3062
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3063
                                        currentControl.IsNew = true;
3064
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3065
                                        this.MainAngle.Visibility = Visibility.Visible;
3066
                                    }
3067
                                //}
3068
                            }
3069
                        }
3070
                        break;
3071
                    case ControlType.PolygonCloud:
3072
                        {
3073
                            if (currentControl is CloudControl)
3074
                            {
3075
                                var control = currentControl as CloudControl;
3076
                                if (e.RightButton == MouseButtonState.Pressed)
3077
                                {
3078
                                    control.IsCompleted = true;
3079
                                }
3080

    
3081
                                if (!control.IsCompleted)
3082
                                {
3083
                                    control.PointSet.Add(control.EndPoint);
3084
                                }
3085
                                else
3086
                                {
3087
                                    //20180906 LJY TEST IsRotationDrawingEnable
3088
                                    if (IsGetoutpoint((currentControl as CloudControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3089
                                    {
3090
                                        return;
3091
                                    }
3092

    
3093
                                    CreateCommand.Instance.Execute(currentControl);
3094

    
3095
                                    control.isTransOn = true;
3096
                                    var firstPoint = control.PointSet.First();
3097

    
3098
                                    control.PointSet.Add(firstPoint);
3099
                                    control.DrawingCloud();
3100
                                    control.ApplyOverViewData();
3101

    
3102
                                    currentControl = null;
3103
                                }
3104
                            }
3105
                            else
3106
                            {
3107
                                if (e.LeftButton == MouseButtonState.Pressed)
3108
                                {
3109
                                    currentControl = new CloudControl
3110
                                    {
3111
                                        PointSet = new List<Point>(),
3112
                                        PointC = new StylusPointSet()
3113
                                    };
3114

    
3115
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3116
                                    //{
3117
                                        var polygonControl = (currentControl as CloudControl);
3118
                                        currentControl.CommentID = Commons.shortGuid();
3119
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3120
                                        currentControl.IsNew = true;
3121
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3122

    
3123
                                        polygonControl.PointSet.Add(canvasDrawingMouseDownPoint);
3124
                                        polygonControl.PointSet.Add(canvasDrawingMouseDownPoint);
3125
                                    
3126
                                    //}
3127
                                }
3128
                            }
3129
                        }
3130
                        break;
3131
                    case ControlType.ImgControl:
3132
                        {
3133
                            if (e.LeftButton == MouseButtonState.Pressed)
3134
                            {
3135
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3136
                                //{
3137
                                    if (currentControl is ImgControl)
3138
                                    {
3139
                                        //20180906 LJY TEST IsRotationDrawingEnable
3140
                                        if (IsGetoutpoint((currentControl as ImgControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3141
                                        {
3142
                                            return;
3143
                                        }
3144

    
3145
                                        CreateCommand.Instance.Execute(currentControl);
3146
                                        controlType = ControlType.ImgControl;
3147
                                        currentControl = null;
3148
                                    }
3149
                                    else
3150
                                    {
3151
                                        
3152
                                        string extension = System.IO.Path.GetExtension(filename).ToUpper();
3153
                                        if (extension == ".PNG" || extension == ".JPEG" || extension == ".GIF" || extension == ".BMP" || extension == ".JPG" || extension == ".SVG")
3154
                                        {
3155
                                            Image img = new Image();
3156
                                            if (filename.Contains(".svg"))
3157
                                            {
3158
                                                byte[] imageData = null;
3159
                                                DrawingImage image = null;
3160
                                                using (System.Net.WebClient web = new System.Net.WebClient())
3161
                                                {
3162
                                                    imageData = web.DownloadData(new Uri(filename));
3163
                                                    System.IO.Stream stream = new System.IO.MemoryStream(imageData);
3164
                                                    image = SvgReader.Load(stream);
3165
                                                }
3166
                                                img.Source = image;
3167
                                            }
3168
                                            else
3169
                                            {
3170
                                                img.Source = new BitmapImage(new Uri(filename));
3171
                                            }
3172

    
3173
                                            currentControl = new ImgControl
3174
                                            {
3175
                                                    Background = new SolidColorBrush(Colors.Black),
3176
                                                    PointSet = new List<Point>(),
3177
                                                    FilePath = filename,
3178
                                                    ImageData = img.Source,
3179
                                                    StartPoint = canvasDrawingMouseDownPoint,
3180
                                                    EndPoint = new Point(canvasDrawingMouseDownPoint.X + 100, canvasDrawingMouseDownPoint.Y + 100),
3181
                                                    TopRightPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y + 100),
3182
                                                    LeftBottomPoint = new Point(canvasDrawingMouseDownPoint.X + 100, canvasDrawingMouseDownPoint.Y),
3183
                                                    ControlType = ControlType.ImgControl
3184
                                                };
3185

    
3186
                                        
3187
                                                currentControl.CommentID = Commons.shortGuid();                                            
3188
                                                currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3189
                                                currentControl.IsNew = true;
3190
                                                ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3191

    
3192
                                                //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정  
3193
                                                (currentControl as ImgControl).Angle -= rotate.Angle;
3194
                                        }
3195
                                    }
3196
                                //}
3197
                            }
3198
                        }
3199
                        break;
3200
                    case ControlType.Date:
3201
                        {
3202
                            if (e.LeftButton == MouseButtonState.Pressed)
3203
                            {
3204
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3205
                                //{
3206
                                    if (currentControl is DateControl)
3207
                                    {
3208
                                        //20180906 LJY TEST IsRotationDrawingEnable
3209
                                        if (IsGetoutpoint((currentControl as DateControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3210
                                        {
3211
                                            return;
3212
                                        }
3213

    
3214
                                        CreateCommand.Instance.Execute(currentControl);
3215
                                        currentControl = null;
3216

    
3217
                                        if (Common.ViewerDataModel.Instance.SelectedControl == "Batch")
3218
                                        {
3219
                                            controlType = ControlType.None;
3220
                                            IsSwingMode = false;
3221
                                            Common.ViewerDataModel.Instance.SelectedControl = "";
3222
                                            Common.ViewerDataModel.Instance.ControlTag = null;
3223
                                            mouseHandlingMode = MouseHandlingMode.None;
3224
                                            this.ParentOfType<MainWindow>().dzTopMenu.btn_Batch.IsChecked = false;
3225
                                            txtBatch.Visibility = Visibility.Collapsed;
3226

    
3227
                                        }
3228
                                    }
3229
                                    else
3230
                                    {
3231
                                        currentControl = new DateControl
3232
                                        {
3233
                                            StartPoint = canvasDrawingMouseDownPoint,
3234
                                            Background = new SolidColorBrush(Colors.Black)
3235
                                        };
3236
                                        currentControl.CommentID = Commons.shortGuid();
3237
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3238
                                        currentControl.IsNew = true;
3239
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3240

    
3241
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정 
3242
                                        (currentControl as DateControl).Angle -= rotate.Angle;
3243
                                }
3244
                                //}
3245
                            }
3246
                        }
3247
                        break;
3248
                    case ControlType.TextControl:
3249
                        {
3250
                            if (e.LeftButton == MouseButtonState.Pressed)
3251
                            {
3252
                                if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3253
                                {
3254
                                    currentControl = new TextControl
3255
                                    {
3256
                                        ControlType = controlType
3257
                                    };
3258
                                    (currentControl as TextControl).TextSize = ViewerDataModel.Instance.TextSize;
3259
                                    currentControl.CommentID = Commons.shortGuid();
3260
                                    currentControl.IsNew = true;
3261
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3262
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3263
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
3264

    
3265
                                    currentControl.SetValue(TextControl.CanvasXProperty, canvasDrawingMouseDownPoint.X);
3266
                                    currentControl.SetValue(TextControl.CanvasYProperty, canvasDrawingMouseDownPoint.Y);
3267
                                    
3268
                                    (currentControl as TextControl).ControlType_No = 0;
3269
                                    (currentControl as TextControl).Angle -= rotate.Angle;
3270
                                    (currentControl as TextControl).IsHighLight = ViewerDataModel.Instance.checkHighShape;
3271
                                    (currentControl as TextControl).ApplyTemplate();
3272
                                    (currentControl as TextControl).Base_TextBox.Focus();
3273
                                    (currentControl as TextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3274
                                    CreateCommand.Instance.Execute(currentControl);
3275
                                }
3276
                            }
3277
                        }
3278
                        break;
3279
                    case ControlType.TextBorder:
3280
                        {
3281
                            if (e.LeftButton == MouseButtonState.Pressed)
3282
                            {
3283
                                if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3284
                                {
3285
                                    currentControl = new TextControl
3286
                                    {
3287
                                        ControlType = controlType
3288
                                    };
3289

    
3290
                                    (currentControl as TextControl).TextSize = ViewerDataModel.Instance.TextSize;
3291
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3292
                                    currentControl.CommentID = Commons.shortGuid();
3293
                                    currentControl.IsNew = true;
3294
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3295
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
3296
                                    currentControl.SetValue(TextControl.CanvasXProperty, canvasDrawingMouseDownPoint.X);
3297
                                    currentControl.SetValue(TextControl.CanvasYProperty, canvasDrawingMouseDownPoint.Y);
3298
                                    
3299
                                    (currentControl as TextControl).ControlType_No = 1;
3300
                                    (currentControl as TextControl).Angle = Ang;
3301
                                    (currentControl as TextControl).IsHighLight = ViewerDataModel.Instance.checkHighShape;
3302
                                    (currentControl as TextControl).ApplyTemplate();
3303
                                    (currentControl as TextControl).Base_TextBox.Focus();
3304
                                    (currentControl as TextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3305
                                    CreateCommand.Instance.Execute(currentControl);
3306
                                }
3307
                            }
3308
                        }
3309
                        break;
3310
                    case ControlType.TextCloud:
3311
                        {
3312
                            if (e.LeftButton == MouseButtonState.Pressed)
3313
                            {
3314
                                if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3315
                                {
3316
                                    currentControl = new TextControl
3317
                                    {
3318
                                        ControlType = controlType
3319
                                    };
3320

    
3321
                                    (currentControl as TextControl).TextSize = ViewerDataModel.Instance.TextSize;
3322
                                    currentControl.CommentID = Commons.shortGuid();
3323
                                    currentControl.IsNew = true;
3324
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3325
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3326

    
3327
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
3328
                                    currentControl.SetValue(TextControl.CanvasXProperty, canvasDrawingMouseDownPoint.X);
3329
                                    currentControl.SetValue(TextControl.CanvasYProperty, canvasDrawingMouseDownPoint.Y);                                    
3330

    
3331
                                    (currentControl as TextControl).Angle = Ang;
3332
                                    (currentControl as TextControl).ControlType_No = 2;
3333
                                    (currentControl as TextControl).IsHighLight = ViewerDataModel.Instance.checkHighShape;
3334
                                    (currentControl as TextControl).ApplyTemplate();
3335
                                    (currentControl as TextControl).Base_TextBox.Focus();
3336
                                    CreateCommand.Instance.Execute(currentControl);
3337
                                    (currentControl as TextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3338
                                    //currentControl = null;
3339
                                }
3340
                            }
3341
                        }
3342
                        break;
3343
                    case ControlType.ArrowTextControl:
3344
                         {
3345
                            if (e.LeftButton == MouseButtonState.Pressed)
3346
                            {
3347
                                if (currentControl is ArrowTextControl)
3348
                                {
3349
                                    //20180906 LJY TEST IsRotationDrawingEnable
3350
                                    if (IsGetoutpoint((currentControl as ArrowTextControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3351
                                    {
3352
                                        return;
3353
                                    }
3354

    
3355
                                    CreateCommand.Instance.Execute(currentControl);
3356

    
3357
                                    (currentControl as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
3358
                                    (currentControl as ArrowTextControl).EnableEditing = false;
3359
                                    (currentControl as ArrowTextControl).IsNew = false;
3360
                                    currentControl = null;
3361
                                }
3362
                                else
3363
                                {
3364
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3365
                                    //{
3366
                                        currentControl = new ArrowTextControl();
3367
                                        currentControl.CommentID = Commons.shortGuid();
3368
                                        currentControl.IsNew = true;
3369
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3370
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3371

    
3372
                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);
3373
                                        currentControl.SetValue(ArrowTextControl.StartPointProperty, canvasDrawingMouseDownPoint);
3374
                                        currentControl.SetValue(ArrowTextControl.EndPointProperty, canvasDrawingMouseDownPoint);
3375
                                        (currentControl as ArrowTextControl).TextSize = ViewerDataModel.Instance.TextSize;
3376
                                        (currentControl as ArrowTextControl).isHighLight = ViewerDataModel.Instance.checkHighShape;
3377

    
3378
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정 
3379
                                        (currentControl as ArrowTextControl).Angle -= rotate.Angle;
3380

    
3381
                                        (currentControl as ArrowTextControl).ApplyTemplate();
3382
                                        (currentControl as ArrowTextControl).Base_TextBox.Focus();
3383
                                        (currentControl as ArrowTextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3384
                                        this.MainAngle.Visibility = Visibility.Visible;
3385

    
3386
                                    
3387
                                    //}
3388
                                }
3389
                            }
3390
                        }
3391
                        break;
3392
                    case ControlType.ArrowTransTextControl:
3393
                        {
3394
                            if (e.LeftButton == MouseButtonState.Pressed)
3395
                            {
3396
                                if (currentControl is ArrowTextControl)
3397
                                {
3398
                                    //20180906 LJY TEST IsRotationDrawingEnable
3399
                                    if (IsGetoutpoint((currentControl as ArrowTextControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3400
                                    {
3401
                                        return;
3402
                                    }
3403

    
3404
                                    CreateCommand.Instance.Execute(currentControl);
3405

    
3406
                                    (currentControl as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
3407
                                    
3408
                                    currentControl.IsNew = false;
3409
                                    currentControl = null;
3410
                                    this.MainAngle.Visibility = Visibility.Collapsed;
3411
                                }
3412
                                else
3413
                                {
3414
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3415
                                    //{
3416
                                    currentControl = new ArrowTextControl()
3417
                                    {
3418
                                        ControlType = ControlType.ArrowTransTextControl
3419
                                    };
3420
                                    currentControl.CommentID = Commons.shortGuid();
3421
                                    currentControl.IsNew = true;
3422
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3423
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3424
                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);
3425
                                    currentControl.SetValue(ArrowTextControl.StartPointProperty, canvasDrawingMouseDownPoint);
3426
                                    currentControl.SetValue(ArrowTextControl.EndPointProperty, canvasDrawingMouseDownPoint);                  
3427
                                    (currentControl as ArrowTextControl).TextSize = ViewerDataModel.Instance.TextSize;
3428
                                    (currentControl as ArrowTextControl).isFixed = true;
3429
                                    (currentControl as ArrowTextControl).isHighLight = ViewerDataModel.Instance.checkHighShape;
3430

    
3431
                                    //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정 
3432
                                    (currentControl as ArrowTextControl).Angle -= rotate.Angle;
3433

    
3434
                                    (currentControl as ArrowTextControl).ApplyTemplate();
3435
                                    (currentControl as ArrowTextControl).Base_TextBox.Focus();
3436
                                    (currentControl as ArrowTextControl).isTrans = true;
3437
                                    (currentControl as ArrowTextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3438
                                }
3439
                            }
3440
                        }
3441
                        break;
3442
                    case ControlType.ArrowTextBorderControl:
3443
                         {
3444
                            if (e.LeftButton == MouseButtonState.Pressed)
3445
                            {
3446
                                if (currentControl is ArrowTextControl)
3447
                                {
3448
                                    //20180906 LJY TEST IsRotationDrawingEnable
3449
                                    if (IsGetoutpoint((currentControl as ArrowTextControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3450
                                    {
3451
                                        return;
3452
                                    }
3453

    
3454
                                    CreateCommand.Instance.Execute(currentControl);
3455
                                    (currentControl as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
3456
                                    currentControl.IsNew = false;
3457
                                    currentControl = null;
3458
                                    this.MainAngle.Visibility = Visibility.Collapsed;
3459
                                }
3460
                                else
3461
                                {
3462
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3463
                                    //{
3464
                                        currentControl = new ArrowTextControl()
3465
                                        {
3466
                                            ArrowTextStyle = MarkupToPDF.Controls.Text.ArrowTextControl.ArrowTextStyleSet.Rect
3467
                                        };
3468
                                        currentControl.CommentID = Commons.shortGuid();
3469
                                        currentControl.IsNew = true;
3470
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3471
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3472

    
3473
                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);
3474

    
3475
                                        currentControl.SetValue(ArrowTextControl.StartPointProperty, canvasDrawingMouseDownPoint);
3476

    
3477
                                        currentControl.SetValue(ArrowTextControl.EndPointProperty, canvasDrawingMouseDownPoint);
3478
                                        (currentControl as ArrowTextControl).isHighLight = ViewerDataModel.Instance.checkHighShape;
3479
                                        (currentControl as ArrowTextControl).TextSize = ViewerDataModel.Instance.TextSize;
3480
                                        (currentControl as ArrowTextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3481
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정 
3482
                                        (currentControl as ArrowTextControl).Angle -= rotate.Angle;
3483
                                        (currentControl as ArrowTextControl).ApplyTemplate();
3484
                                        (currentControl as ArrowTextControl).Base_TextBox.Focus();
3485
                                        this.MainAngle.Visibility = Visibility.Visible;                                    
3486
                                    //}
3487
                                }
3488
                            }
3489
                        }
3490
                        break;
3491
                    case ControlType.ArrowTransTextBorderControl:
3492
                        {
3493
                            if (e.LeftButton == MouseButtonState.Pressed)
3494
                            {
3495
                                if (currentControl is ArrowTextControl)
3496
                                {
3497
                                    //20180906 LJY TEST IsRotationDrawingEnable
3498
                                    if (IsGetoutpoint((currentControl as ArrowTextControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3499
                                    {
3500
                                        return;
3501
                                    }
3502
                                    CreateCommand.Instance.Execute(currentControl);
3503
                                    (currentControl as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
3504
                                    currentControl.IsNew = false;
3505
                                    currentControl = null;
3506

    
3507
                                    this.MainAngle.Visibility = Visibility.Collapsed;
3508
                                }
3509
                                else
3510
                                {
3511
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3512
                                    //{
3513
                                    
3514

    
3515
                                    currentControl = new ArrowTextControl()
3516
                                    {
3517
                                        ArrowTextStyle = MarkupToPDF.Controls.Text.ArrowTextControl.ArrowTextStyleSet.Rect,
3518
                                        ControlType = ControlType.ArrowTransTextBorderControl
3519

    
3520
                                    };
3521
                                        currentControl.CommentID = Commons.shortGuid();
3522
                                        currentControl.IsNew = true;
3523
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3524
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3525

    
3526
                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);
3527

    
3528
                                        currentControl.SetValue(ArrowTextControl.StartPointProperty, canvasDrawingMouseDownPoint);
3529
                                        currentControl.SetValue(ArrowTextControl.EndPointProperty, canvasDrawingMouseDownPoint);                                    
3530
                                        (currentControl as ArrowTextControl).TextSize = ViewerDataModel.Instance.TextSize;
3531
                                        (currentControl as ArrowTextControl).isFixed = true;
3532
                                        (currentControl as ArrowTextControl).isHighLight = ViewerDataModel.Instance.checkHighShape;
3533
                                     
3534
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정  
3535
                                        (currentControl as ArrowTextControl).Angle -= rotate.Angle;
3536
                                        (currentControl as ArrowTextControl).ApplyTemplate();
3537
                                        (currentControl as ArrowTextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3538
                                        (currentControl as ArrowTextControl).Base_TextBox.Focus();                                 
3539
                                        this.MainAngle.Visibility = Visibility.Visible;
3540
                                    
3541
                                    //20180911 LJY
3542
                                        (currentControl as ArrowTextControl).isTrans = true;
3543
                                    
3544

    
3545
                                    //}
3546
                                }
3547
                            }
3548
                        }
3549
                        break;
3550
                    case ControlType.ArrowTextCloudControl:
3551
                        {
3552
                            if (e.LeftButton == MouseButtonState.Pressed)
3553
                            {
3554
                                if (currentControl is ArrowTextControl)
3555
                                {
3556
                                    //20180906 LJY TEST IsRotationDrawingEnable
3557
                                    if (IsGetoutpoint((currentControl as ArrowTextControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3558
                                    {
3559
                                        return;
3560
                                    }
3561
                                    CreateCommand.Instance.Execute(currentControl);
3562
                                    (currentControl as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
3563
                                    currentControl.IsNew = false;
3564
                                    currentControl = null;
3565
                                    this.MainAngle.Visibility = Visibility.Collapsed;
3566
                                }
3567
                                else
3568
                                {
3569
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3570
                                    //{
3571
                                        currentControl = new ArrowTextControl()
3572
                                        {
3573
                                            ArrowTextStyle = MarkupToPDF.Controls.Text.ArrowTextControl.ArrowTextStyleSet.Cloud
3574
                                        };
3575
                                        currentControl.CommentID = Commons.shortGuid();
3576
                                        currentControl.IsNew = true;
3577
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3578
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3579

    
3580
                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);
3581
                                        currentControl.SetValue(ArrowTextControl.StartPointProperty, canvasDrawingMouseDownPoint);
3582
                                        currentControl.SetValue(ArrowTextControl.EndPointProperty, canvasDrawingMouseDownPoint);                                 
3583
                                        (currentControl as ArrowTextControl).TextSize = ViewerDataModel.Instance.TextSize;
3584
                                        (currentControl as ArrowTextControl).isHighLight = ViewerDataModel.Instance.checkHighShape;
3585
                                        (currentControl as ArrowTextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3586
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정  
3587
                                        (currentControl as ArrowTextControl).Angle -= rotate.Angle;
3588
                                    
3589
                                        (currentControl as ArrowTextControl).ApplyTemplate();
3590
                                        (currentControl as ArrowTextControl).Base_TextBox.Focus();
3591
                                        this.MainAngle.Visibility = Visibility.Visible;                                        
3592
                                    //}
3593
                                }
3594
                            }
3595
                        }
3596
                        break;
3597
                    case ControlType.ArrowTransTextCloudControl:
3598
                        {
3599
                            if (e.LeftButton == MouseButtonState.Pressed)
3600
                            {
3601
                                if (currentControl is ArrowTextControl)
3602
                                {
3603
                                    //20180906 LJY TEST IsRotationDrawingEnable
3604
                                    if (IsGetoutpoint((currentControl as ArrowTextControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3605
                                    {
3606
                                        return;
3607
                                    }
3608
                                    CreateCommand.Instance.Execute(currentControl);
3609
                                    (currentControl as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;
3610
                                    currentControl.IsNew = false;
3611
                                    currentControl = null;
3612
                                    this.MainAngle.Visibility = Visibility.Collapsed;
3613
                                }
3614
                                else
3615
                                {
3616
                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3617
                                    //{
3618
                                        currentControl = new ArrowTextControl()
3619
                                        {
3620
                                            ArrowTextStyle = MarkupToPDF.Controls.Text.ArrowTextControl.ArrowTextStyleSet.Cloud,
3621
                                            ControlType = ControlType.ArrowTransTextCloudControl
3622

    
3623
                                        };
3624
                                        currentControl.CommentID = Commons.shortGuid();
3625
                                        currentControl.IsNew = true; 
3626
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3627
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3628
                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);
3629

    
3630
                                        currentControl.SetValue(ArrowTextControl.StartPointProperty, canvasDrawingMouseDownPoint);
3631
                                        currentControl.SetValue(ArrowTextControl.EndPointProperty, canvasDrawingMouseDownPoint);                                        
3632
                                        (currentControl as ArrowTextControl).TextSize = ViewerDataModel.Instance.TextSize;
3633
                                        (currentControl as ArrowTextControl).isFixed = true;
3634
                                        (currentControl as ArrowTextControl).isHighLight = ViewerDataModel.Instance.checkHighShape;
3635

    
3636
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정 
3637
                                        (currentControl as ArrowTextControl).Angle -= rotate.Angle;
3638
                                        (currentControl as ArrowTextControl).SetFontFamily(new FontFamily(this.ParentOfType<MainWindow>().dzTopMenu.comboFontFamily.Text));
3639
                                        (currentControl as ArrowTextControl).ApplyTemplate();
3640
                                        (currentControl as ArrowTextControl).Base_TextBox.Focus();
3641
                                        this.MainAngle.Visibility = Visibility.Visible;  
3642
                                    
3643
                                    //20180911 LJY
3644
                                        (currentControl as ArrowTextControl).isTrans = true;
3645
                                    //}
3646
                                }
3647
                            }
3648
                        }
3649
                        break;
3650
                    //강인구 추가
3651
                    case ControlType.Sign:
3652
                        {
3653
                            if (e.LeftButton == MouseButtonState.Pressed)
3654
                            {
3655
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3656
                                //{
3657
                                    var _sign = GetUserSign.GetSign(App.ViewInfo.UserID, App.ViewInfo.ProjectNO,App.isExternal);
3658

    
3659
                                    if (_sign == null)
3660
                                    {
3661
                                        txtBatch.Visibility = Visibility.Collapsed;
3662
                                        mouseHandlingMode = IKCOM.MouseHandlingMode.None;
3663
                                        controlType = ControlType.None;
3664

    
3665
                                        this.ParentOfType<MainWindow>().DialogMessage_Alert("등록된 Sign이 없습니다.", "Alert");
3666
                                        this.ParentOfType<MainWindow>().ChildrenOfType<RadToggleButton>().Where(data => data.IsChecked == true).FirstOrDefault().IsChecked = false;
3667
                                        return;
3668
                                    }
3669

    
3670
                                    if (currentControl is SignControl)
3671
                                    {
3672
                                        //20180906 LJY TEST IsRotationDrawingEnable
3673
                                        if (IsGetoutpoint((currentControl as SignControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3674
                                        {
3675
                                            return;
3676
                                        }
3677

    
3678
                                        CreateCommand.Instance.Execute(currentControl);
3679
                                        currentControl = null;
3680
                                        if (Common.ViewerDataModel.Instance.SelectedControl == "Batch")
3681
                                        {
3682
                                            txtBatch.Text = "Place Date";
3683
                                            controlType = ControlType.Date;
3684
                                        }
3685
                                    }
3686
                                    else
3687
                                    {
3688
                                        currentControl = new SignControl
3689
                                        {
3690
                                            Background = new SolidColorBrush(Colors.Black),
3691
                                            UserNumber = App.ViewInfo.UserID,
3692
                                            ProjectNO = App.ViewInfo.ProjectNO,
3693
                                            StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
3694
                                            EndPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
3695
                                            ControlType = ControlType.Sign
3696
                                        };
3697

    
3698
                                        currentControl.CommentID = Commons.shortGuid();
3699
                                        currentControl.IsNew = true;
3700
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3701
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3702

    
3703
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정 
3704
                                        (currentControl as SignControl).Angle -= rotate.Angle;                                    
3705
                                }
3706
                                //}
3707
                            }
3708
                        }
3709
                        break;
3710
                    case ControlType.Mark:
3711
                        {
3712
                            if (e.LeftButton == MouseButtonState.Pressed)
3713
                            {
3714
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3715
                                //{
3716
                                    if (currentControl is RectangleControl)
3717
                                    {
3718
                                        //20180906 LJY TEST IsRotationDrawingEnable
3719
                                        if (IsGetoutpoint((currentControl as RectangleControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3720
                                        {
3721
                                            return;
3722
                                        }
3723

    
3724
                                        CreateCommand.Instance.Execute(currentControl);
3725
                                        (currentControl as RectangleControl).ApplyOverViewData();
3726
                                        currentControl = null;
3727
                                    
3728
                                        this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
3729

    
3730
                                        if (Common.ViewerDataModel.Instance.SelectedControl == "Batch")
3731
                                        {
3732
                                            txtBatch.Text = "Place Signature";
3733
                                            controlType = ControlType.Sign;
3734
                                        }
3735
                                    }
3736
                                    else
3737
                                    {
3738
                                        currentControl = new RectangleControl
3739
                                        {
3740
                                            StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
3741
                                            Background = new SolidColorBrush(Colors.Black),
3742
                                            ControlType = ControlType.Mark ,
3743
                                            Paint = PaintSet.Fill
3744
                                        };
3745

    
3746
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3747
                                        currentControl.CommentID = Commons.shortGuid();
3748
                                        currentControl.IsNew = true;
3749
                                        (currentControl as RectangleControl).DashSize = ViewerDataModel.Instance.DashSize;
3750
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3751
                                    }
3752
                                //}
3753
                            }
3754
                        }
3755
                        break;
3756
                    case ControlType.Symbol:
3757
                        {
3758
                            if (e.LeftButton == MouseButtonState.Pressed)
3759
                            {
3760
                                if (currentControl is SymControl)
3761
                                {
3762
                                    //20180906 LJY TEST IsRotationDrawingEnable
3763
                                    if (IsGetoutpoint((currentControl as SymControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3764
                                    {
3765
                                        return;
3766
                                    }
3767
                                    CreateCommand.Instance.Execute(currentControl);
3768
                                    currentControl = null;
3769
                                
3770
                                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
3771
                                }
3772
                                else
3773
                                {
3774
                                    currentControl = new SymControl
3775
                                    {
3776
                                        StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
3777
                                        Background = new SolidColorBrush(Colors.Black),
3778
                                        LineSize = ViewerDataModel.Instance.LineSize + 3,
3779
                                        ControlType = ControlType.Symbol
3780
                                    };
3781

    
3782
                                    currentControl.IsNew = true;
3783
                                    currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3784
                                    currentControl.CommentID = Commons.shortGuid();
3785
                                    ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3786

    
3787
                                    //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정  
3788
                                    (currentControl as SymControl).Angle -= rotate.Angle;
3789
                                }
3790
                                //}
3791
                            }
3792
                        }
3793
                        break;
3794
                    case ControlType.Stamp:
3795
                        {
3796
                            if (e.LeftButton == MouseButtonState.Pressed)
3797
                            {
3798
                                //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))
3799
                                //{
3800
                                    if (currentControl is SymControlN)
3801
                                    {
3802
                                        //20180906 LJY TEST IsRotationDrawingEnable
3803
                                        if (IsGetoutpoint((currentControl as SymControlN).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))
3804
                                        {
3805
                                            return;
3806
                                        }
3807

    
3808
                                        CreateCommand.Instance.Execute(currentControl);
3809
                                        currentControl = null;
3810
                                   
3811

    
3812
                                    this.cursor = new Cursor(MainWindow.CursorChange().StreamSource);
3813
                                    }
3814
                                    else
3815
                                    {
3816
                                        currentControl = new SymControlN
3817
                                        {
3818
                                            StartPoint = new Point(canvasDrawingMouseDownPoint.X, canvasDrawingMouseDownPoint.Y),
3819
                                            Background = new SolidColorBrush(Colors.Black),
3820
                                            STAMP = App.SystemInfo.STAMP,                                            
3821
                                            ControlType = ControlType.Stamp
3822
                                        };
3823

    
3824
                                        currentControl.IsNew = true;
3825
                                        currentControl.MarkupInfoID = App.Custom_ViewInfoId;
3826
                                        currentControl.CommentID = Commons.shortGuid();
3827
                                        ViewerDataModel.Instance.MarkupControls_USER.Add(currentControl);
3828
                                        //20180903 LJY 회전된 방향으로 화면에 출력되지 않는 문제 수정  
3829
                                        (currentControl as SymControlN).Angle -= rotate.Angle;
3830
                                }                                    
3831
                                //}
3832
                            }
3833
                        }
3834
                        break;
3835
                    case ControlType.PenControl:
3836
                        {
3837
                            if (inkBoard.Tag.ToString() == "Ink")
3838
                            {
3839
                                inkBoard.IsEnabled = true;
3840
                                StartNewStroke(canvasDrawingMouseDownPoint);
3841
                            }
3842
                            else if (inkBoard.Tag.ToString() == "EraseByPoint")
3843
                            {
3844
                                RemovePointStroke(canvasDrawingMouseDownPoint);
3845
                            }
3846
                            else if (inkBoard.Tag.ToString() == "EraseByStroke")
3847
                            {
3848
                                RemoveLineStroke(canvasDrawingMouseDownPoint);
3849
                            }
3850
                            IsDrawing = true;
3851
                            return;
3852
                        }
3853
                    default:
3854
                        if (currentControl != null)
3855
                        {
3856
                            currentControl.CommentID = null;
3857
                            currentControl.IsNew = false;
3858
                        }
3859
                        break;
3860
                }
3861
            }
3862
            if (mouseHandlingMode != MouseHandlingMode.None && e.LeftButton == MouseButtonState.Pressed)
3863
            {
3864
                if (mouseHandlingMode == MouseHandlingMode.Adorner && SelectLayer.Children.Count > 0)
3865
                {
3866
                    bool mouseOff = false;
3867
                    foreach (var item in SelectLayer.Children)
3868
                    {
3869
                        if (item is AdornerFinal)
3870
                        {
3871

    
3872
                            var over = (item as AdornerFinal).Members.Where(data => data.DrawingData.IsMouseOver).FirstOrDefault();
3873
                            if (over != null)
3874
                            {
3875
                                mouseOff = true;
3876
                            }
3877
                        }
3878
                    }
3879

    
3880
                    if (!mouseOff)
3881
                    {
3882
                        SelectionSet.Instance.UnSelect(this);
3883
                    }
3884
                }
3885
                zoomAndPanControl.CaptureMouse();
3886
                e.Handled = true;
3887
            }
3888
          
3889
        }
3890

    
3891
        private void zoomAndPanControl2_MouseDown(object sender, MouseButtonEventArgs e)
3892
        {
3893
            ///mouseButtonDown = e.ChangedButton;
3894
            canvasZoommovingMouseDownPoint = e.GetPosition(zoomAndPanCanvas2);
3895
        }
3896

    
3897
        private void RemoveLineStroke(Point P)
3898
        {
3899
            var control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.IsMouseOver).FirstOrDefault();
3900
            if (control != null)
3901
            {
3902
                DeleteCommand.Instance.Execute(new List<CommentUserInfo>() { control });
3903
            }
3904
        }
3905

    
3906
        private void RemovePointStroke(Point P)
3907
        {
3908
            foreach (Stroke hits in inkBoard.Strokes)
3909
            {
3910
                foreach (StylusPoint sty in hits.StylusPoints)
3911
                {
3912

    
3913
                }
3914
                if (hits.HitTest(P))
3915
                {
3916
                    inkBoard.Strokes.Remove(hits);
3917
                    return;
3918
                }
3919
            }
3920
        }
3921

    
3922
        private void StartNewStroke(Point P)
3923
        {
3924
            strokePoints = new StylusPointCollection();
3925
            StylusPoint segment1Start = new StylusPoint(P.X, P.Y);
3926
            strokePoints.Add(segment1Start);
3927
            stroke = new Stroke(strokePoints);
3928

    
3929
            stroke.DrawingAttributes.Color = Colors.Red;
3930
            stroke.DrawingAttributes.Width = 4;
3931
            stroke.DrawingAttributes.Height = 4;
3932

    
3933
            inkBoard.Strokes.Add(stroke);
3934
        }
3935

    
3936
        private void btnConsolidate_Click(object sender, RoutedEventArgs e)
3937
        {
3938
            ConsolidationMethod();
3939
        }
3940

    
3941
        /// <summary>
3942
        /// execute TeamConsolidationCommand
3943
        /// </summary>
3944
        public void TeamConsolidationMethod()
3945
        {
3946
            this.UpdateMyMarkupList();
3947
            if (this.gridViewMarkup.SelectedItems.Count == 0)
3948
            {
3949
                this.ParentOfType<MainWindow>().DialogMessage_Alert("Please select at least one user", "Alert");
3950
            }
3951
            else
3952
            {
3953

    
3954
                ViewerDataModel.Instance.IsConsolidate = true;
3955
                this.ParentOfType<MainWindow>().dzTopMenu._SaveEvent(null, null);
3956

    
3957
                foreach (MarkupInfoItem item in this.gridViewMarkup.SelectedItems)
3958
                {
3959
                    if (!this.userData.DEPARTMENT.Equals(item.Depatment))
3960
                    {
3961
                        this.ParentOfType<MainWindow>().DialogMessage_Alert("Please select at your department", "Alert");
3962
                        return;
3963
                    }                    
3964
                }
3965
                List<MarkupInfoItem> MarkupInfoList = new List<MarkupInfoItem>();
3966
                foreach (MarkupInfoItem item in this.gridViewMarkup.SelectedItems)
3967
                {
3968
                    MarkupInfoList.Add(item);
3969
                }
3970
                TeamConsolidateCommand.Instance.Execute(MarkupInfoList);
3971
            }
3972
        }
3973

    
3974
        public void ConsolidationMethod()
3975
        {
3976
            if (this.gridViewMarkup.SelectedItems.Count == 0)
3977
            {
3978
                this.ParentOfType<MainWindow>().DialogMessage_Alert("Please select at least one user", "Alert");
3979
            }
3980
            else
3981
            {
3982
                List<IKCOM.MarkupInfoItem> MySelectItem = new List<IKCOM.MarkupInfoItem>();
3983
                foreach (var item in this.gridViewMarkup.SelectedItems)
3984
                {
3985
                    MySelectItem.Add(item as IKCOM.MarkupInfoItem);
3986
                }
3987
                int iPageNo = Convert.ToInt32(this.ParentOfType<MainWindow>().dzTopMenu.tlcurrentPage.Text);
3988
                
3989
                ConsolidateCommand.Instance.Execute(MySelectItem, iPageNo);
3990
            }
3991
        }
3992

    
3993
        private void btnConsolidate_Loaded(object sender, RoutedEventArgs e)
3994
        {
3995
            if (App.ViewInfo != null)
3996
            {
3997
                btnConsolidate = (sender as RadRibbonButton);
3998
                if (!App.ViewInfo.NewCommentPermission)
3999
                {
4000
                    (sender as RadRibbonButton).Visibility = System.Windows.Visibility.Collapsed;
4001
                }
4002
            }
4003
        }
4004

    
4005
        private void btnTeamConsolidate_Click(object sender, RoutedEventArgs e)
4006
        {
4007
            TeamConsolidationMethod();
4008
        }
4009

    
4010
        private void btnTeamConsolidate_Loaded(object sender, RoutedEventArgs e)
4011
        {
4012
            btnTeamConsolidate = sender as RadRibbonButton;
4013
            if (App.ViewInfo != null)
4014
            {
4015
                if (!App.ViewInfo.CreateFinalPDFPermission) //파이널이 True가 아니면
4016
                {
4017
                    if (btnConsolidate != null)
4018
                    {
4019
                        btnConsolidate.Visibility = Visibility.Collapsed;
4020
                    }
4021

    
4022
                    if (!App.ViewInfo.NewCommentPermission)
4023
                    {
4024
                        btnTeamConsolidate.Visibility = Visibility.Collapsed;
4025
                    }
4026
                }
4027
                else
4028
                {
4029
                    btnTeamConsolidate.Visibility = Visibility.Collapsed;
4030
                }
4031
            }
4032
        }
4033

    
4034
        private void FinalPDFEvent(object sender, RoutedEventArgs e)
4035
        {
4036
            var item = gridViewMarkup.Items.Cast<MarkupInfoItem>().Where(d => d.Consolidate == 1 && d.AvoidConsolidate == 0).FirstOrDefault();
4037
            if(item != null)
4038
            {
4039
                if (BaseClient.FinalPDF_GetFinalPDFStatus(_DocInfo.ID, item.MarkupInfoID, _ViewInfo.UserID))
4040
                {
4041
                    Logger.sendReqLog("SetFinalPDFAsync", _ViewInfo.ProjectNO + "," + _DocInfo.ID + "," + item.MarkupInfoID + "," + _ViewInfo.UserID, 1);
4042
                    BaseClient.SetFinalPDFAsync(_ViewInfo.ProjectNO, _DocInfo.ID, item.MarkupInfoID, _ViewInfo.UserID);
4043
                }
4044
                else
4045
                {
4046
                    DialogMessage_Alert("Merged PDF가 수행중입니다", "안내");
4047
                }
4048
            }else{
4049
                //Consolidate 가 없는 경우
4050
                DialogMessage_Alert("Consolidation 된 코멘트가 존재하지 않습니다", "안내");
4051
            }
4052
            
4053
        }
4054

    
4055
        private void btnFinalPDF_Loaded(object sender, RoutedEventArgs e)
4056
        {
4057
            btnFinalPDF = sender as RadRibbonButton;
4058
            if (App.ViewInfo != null)
4059
            {
4060
                if (!App.ViewInfo.CreateFinalPDFPermission) //파이널이 True가 아니면
4061
                {
4062
                    btnFinalPDF.Visibility = System.Windows.Visibility.Collapsed;
4063
                    if (btnConsolidate != null)
4064
                    {
4065
                        btnConsolidate.Visibility = Visibility.Collapsed;
4066
                    }
4067
                }
4068
            }
4069
        }
4070

    
4071
        private void ConsolidateFinalPDFEvent(object sender, RoutedEventArgs e)
4072
        {
4073
            UpdateMyMarkupList();
4074

    
4075
            if (this.gridViewMarkup.SelectedItems.Count == 0)
4076
            {
4077
                this.ParentOfType<MainWindow>().DialogMessage_Alert("Please select at least one user", "Alert");
4078
            }
4079
            else
4080
            {
4081
                ViewerDataModel.Instance.IsConsolidate = true;
4082
                this.ParentOfType<MainWindow>().dzTopMenu._SaveEvent(null, null);
4083
                List<KCOMDataModel.DataModel.MARKUP_DATA> instanceDataSet = new List<KCOMDataModel.DataModel.MARKUP_DATA>();
4084

    
4085
                string project_no = App.ViewInfo.ProjectNO;
4086
                string doc_id = _DocInfo.ID;
4087
                string user_id = App.ViewInfo.UserID;
4088
                List<MarkupInfoItem> markupInfoItems = new List<MarkupInfoItem>();
4089
                foreach (MarkupInfoItem item in this.gridViewMarkup.SelectedItems)
4090
                {
4091
                    markupInfoItems.Add(item);
4092
                }
4093
                Logger.sendReqLog("Consolidate", project_no + "," + user_id + "," + doc_id + "," + markupInfoItems, 1);
4094
                Logger.sendResLog("Consolidate", this.BaseClient.Consolidate(project_no, user_id, doc_id, markupInfoItems).ToString(), 1);
4095
                Logger.sendReqLog("GetMarkupInfoItemsAsync", App.ViewInfo.ProjectNO + "," + _DocInfo.ID, 1);
4096
                var items = this.BaseClient.GetMarkupInfoItems(App.ViewInfo.ProjectNO, _DocInfo.ID);
4097

    
4098
                var item2 = items.Where(d => d.Consolidate == 1 && d.AvoidConsolidate == 0).FirstOrDefault();
4099
                if (item2 != null)
4100
                {
4101
                    Logger.sendReqLog("SetFinalPDFAsync", _ViewInfo.ProjectNO + "," + _DocInfo.ID + "," + item2.MarkupInfoID + "," + _ViewInfo.UserID, 1);
4102

    
4103
                    BaseClient.SetFinalPDFAsync(_ViewInfo.ProjectNO, _DocInfo.ID, item2.MarkupInfoID, _ViewInfo.UserID);
4104
                    BaseClient.GetMarkupInfoItemsAsync(App.ViewInfo.ProjectNO, _DocInfo.ID);
4105
                }
4106
                else
4107
                {
4108
                    DialogMessage_Alert("Consolidation 된 코멘트가 존재하지 않습니다", "안내");
4109
                }
4110
            }
4111
        }
4112

    
4113
        private void btnConsolidateFinalPDF_Loaded(object sender, RoutedEventArgs e)
4114
        {
4115
            btnConsolidateFinalPDF = (sender as RadRibbonButton);
4116

    
4117
            if (App.ViewInfo != null)
4118
            {
4119
                if (!App.ViewInfo.NewCommentPermission || !App.ViewInfo.CreateFinalPDFPermission)
4120
                {
4121
                    btnConsolidateFinalPDF.Visibility = System.Windows.Visibility.Collapsed;
4122
                }
4123
            }
4124
        }
4125

    
4126
        private void btnAdjustEvent(object sender, RoutedEventArgs e)
4127
        {
4128
            //Controls.AdjustList adjustList = new AdjustList();
4129
            //adjustList.ShowDialogCenter();
4130

    
4131
            //if (adjustList.DialogResult == true)
4132
            //{
4133
            //    System.Diagnostics.Debug.WriteLine("성공");
4134
            //}
4135
        }
4136

    
4137

    
4138
        private void btnAdjust_Loaded(object sender, RoutedEventArgs e)
4139
        {
4140
            btnAdjust = (sender as RadRibbonButton);
4141

    
4142
            if (App.ViewInfo != null)
4143
            {
4144
                if (!App.ViewInfo.NewCommentPermission || !App.ViewInfo.CreateFinalPDFPermission)
4145
                {
4146
                    btnAdjust.Visibility = System.Windows.Visibility.Collapsed;
4147
                }
4148
            }
4149
        }
4150

    
4151
        private void SyncCompare_Click(object sender, RoutedEventArgs e)
4152
        {
4153
            SetCompareRect();
4154
        }
4155

    
4156
        /// <summary>
4157
        /// 문서 Comprare 
4158
        /// </summary>
4159
        private void SetCompareRect()
4160
        { 
4161
            if (CompareMode.IsChecked)
4162
            {
4163
                if (ViewerDataModel.Instance.PageBalanceMode && ViewerDataModel.Instance.PageBalanceNumber == 0)
4164
                {
4165
                    ViewerDataModel.Instance.PageBalanceNumber = 1;
4166
                }
4167
                if (ViewerDataModel.Instance.PageNumber == 0)
4168
                {
4169
                    ViewerDataModel.Instance.PageNumber = 1;
4170
                }
4171

    
4172
                Logger.sendReqLog("GetCompareRectAsync", _ViewInfo.ProjectNO + "," + _ViewInfo.DocumentItemID + "," + CurrentRev.DOCUMENT_ID +
4173
                    "," + pageNavigator.CurrentPage.PageNumber.ToString() + "," + ViewerDataModel.Instance.PageNumber.ToString() + "," +
4174
                    userData.COMPANY != "EXT" ? "true" : "false", 1);
4175

    
4176
                BaseClient.GetCompareRectAsync(_ViewInfo.ProjectNO, _ViewInfo.DocumentItemID, CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber.ToString(), ViewerDataModel.Instance.PageNumber.ToString(), userData.COMPANY != "EXT" ? "true" : "false");
4177
            }
4178
            else
4179
            {
4180
                ClearCompareRect();
4181
            }
4182
        }
4183

    
4184
        /// <summary>
4185
        /// Compare된 영역을 초기화
4186
        /// </summary>
4187
        private void ClearCompareRect()
4188
        {
4189
            da.From = 1;
4190
            da.To = 1;
4191
            da.Duration = new Duration(TimeSpan.FromSeconds(9999));
4192
            da.AutoReverse = false;
4193
            canvas_compareBorder.Children.Clear();
4194
            canvas_compareBorder.BeginAnimation(OpacityProperty, da);
4195
        }
4196

    
4197
        private void Sync_Click(object sender, RoutedEventArgs e)
4198
        {
4199
            if (Sync.IsChecked)
4200
            {
4201
                ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;
4202
                ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;
4203
                ViewerDataModel.Instance.Sync_ContentScale = zoomAndPanControl.ContentScale;
4204
            }
4205
        }
4206

    
4207
        private void SyncUserListExpender_Click(object sender, RoutedEventArgs e)
4208
        {
4209
            if (UserList.IsChecked)
4210
            {
4211
                this.gridViewRevMarkup.Visibility = Visibility.Visible;
4212
            }
4213
            else
4214
            {
4215
                this.gridViewRevMarkup.Visibility = Visibility.Collapsed;
4216
            }
4217
        }
4218

    
4219
        private void SyncPageBalance_Click(object sender, RoutedEventArgs e)
4220
        {
4221

    
4222
            if (BalanceMode.IsChecked)
4223
            {
4224
                ViewerDataModel.Instance.PageBalanceMode = true;
4225
            }
4226
            else
4227
            {
4228
                ViewerDataModel.Instance.PageBalanceMode = false;
4229
                ViewerDataModel.Instance.PageBalanceNumber = 0;
4230
            }
4231
        }
4232

    
4233
        private void SyncExit_Click(object sender, RoutedEventArgs e)
4234
        {
4235
            //초기화
4236
            testPanel2.IsHidden = true;
4237
            ViewerDataModel.Instance.PageBalanceMode = false;
4238
            ViewerDataModel.Instance.PageBalanceNumber = 0;
4239
            ViewerDataModel.Instance.PageNumber = 0;
4240
            ViewerDataModel.Instance.MarkupControls_Sync.Clear();
4241
            this.gridViewRevMarkup.Visibility = Visibility.Collapsed;
4242
            UserList.IsChecked = false;
4243
            BalanceMode.IsChecked = false;
4244
        }
4245

    
4246
        private void SyncPageChange_Click(object sender, RoutedEventArgs e)
4247
        {
4248
            if ((sender as System.Windows.Controls.Control).Tag != null)
4249
            {
4250
                //Compare 초기화
4251
                CompareMode.IsChecked = false;
4252
                var balancePoint = Convert.ToInt32((sender as System.Windows.Controls.Control).Tag);
4253

    
4254
                if (ViewerDataModel.Instance.PageNumber == 0)
4255
                {
4256
                    ViewerDataModel.Instance.PageNumber = 1;
4257
                }
4258

    
4259
                if (ViewerDataModel.Instance.PageBalanceNumber == pageNavigator.PageCount)
4260
                {
4261
                }
4262
                else
4263
                {
4264
                    ViewerDataModel.Instance.PageBalanceNumber += balancePoint;
4265
                }
4266

    
4267
                if (ViewerDataModel.Instance.PageNumber == pageNavigator.PageCount && balancePoint > 0)
4268
                {
4269

    
4270
                }
4271
                else if ((ViewerDataModel.Instance.PageNumber + balancePoint) >= 1)
4272
                {
4273
                    ViewerDataModel.Instance.PageNumber += balancePoint;
4274
                }
4275

    
4276
                if (!testPanel2.IsHidden)
4277
                {
4278
                    if (IsSyncPDFMode)
4279
                    {
4280
                        Get_FinalImage.Get_PdfImage get_PdfImage = new Get_FinalImage.Get_PdfImage();
4281
                        var pdfpath = new BitmapImage(new Uri(get_PdfImage.Run(CurrentRev.TO_VENDOR, App.ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.PageNumber)));
4282

    
4283
                        if (pdfpath.IsDownloading)
4284
                        {
4285
                            pdfpath.DownloadCompleted += (ex, arg) =>
4286
                            {
4287
                                ViewerDataModel.Instance.ImageViewPath_C = pdfpath;
4288
                                ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;
4289
                                ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;
4290
                                zoomAndPanCanvas2.Width = pdfpath.PixelWidth;
4291
                                zoomAndPanCanvas2.Height = pdfpath.PixelHeight;
4292
                            };
4293
                        }
4294
                        else
4295
                        {
4296
                            ViewerDataModel.Instance.ImageViewPath_C = pdfpath;
4297
                            ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;
4298
                            ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;
4299

    
4300
                            zoomAndPanCanvas2.Width = pdfpath.PixelWidth;
4301
                            zoomAndPanCanvas2.Height = pdfpath.PixelHeight;
4302
                        }
4303

    
4304
                    }
4305
                    else
4306
                    {
4307
                        string uri = "";
4308

    
4309
                        if (userData.COMPANY != "EXT")
4310
                        {
4311
                            uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, (Convert.ToUInt32(CurrentRev.DOCUMENT_ID) / 100).ToString(), CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.PageNumber);
4312
                        }
4313
                        else
4314
                        {
4315
                            uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.PageNumber);
4316
                        }
4317

    
4318
                        var defaultBitmapImage_Compare = new BitmapImage(new Uri(uri));
4319

    
4320
                        ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4321
                        ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4322
                        ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4323

    
4324
                        zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;
4325
                        zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;
4326

    
4327
                        if (defaultBitmapImage_Compare.IsDownloading)
4328
                        {
4329
                            defaultBitmapImage_Compare.DownloadCompleted += (ex, arg) =>
4330
                            {
4331
                                ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4332
                                ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4333
                                ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4334

    
4335
                                zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;
4336
                                zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;
4337
                            };
4338
                        }
4339
                    }
4340

    
4341
                    //강인구 추가(페이지 이동시 코멘트 재 호출)
4342
                    ViewerDataModel.Instance.MarkupControls_Sync.Clear();
4343
                    List<MarkupInfoItem> gridSelectionRevItem = gridViewRevMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList();
4344

    
4345
                    foreach (var item in gridSelectionRevItem)
4346
                    {
4347
                        item.MarkupList.Where(pageItem => pageItem.PageNumber == ViewerDataModel.Instance.PageNumber).ToList().ForEach(delegate (MarkupItem markupitem)
4348
                        {
4349
                            MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, item.DisplayColor, "", item.MarkupInfoID);
4350
                        });
4351
                    }
4352

    
4353
                    //강인구 추가
4354
                    zoomAndPanControl2.ZoomTo(new Rect
4355
                    {
4356
                        X = 0,
4357
                        Y = 0,
4358
                        Width = Math.Max(zoomAndPanCanvas.Width, zoomAndPanCanvas2.Width),
4359
                        Height = Math.Max(zoomAndPanCanvas.Height, zoomAndPanCanvas2.Height),
4360
                    });
4361

    
4362
                    tlSyncPageNum.Text = String.Format("Current Page : {0}", ViewerDataModel.Instance.PageNumber);
4363

    
4364
                }
4365
            }
4366
        }
4367

    
4368
        private void SyncChange_Click(object sender, RoutedEventArgs e)
4369
        {
4370
            if (MarkupMode.IsChecked)
4371
            {
4372
                IsSyncPDFMode = true;
4373

    
4374
                var uri = CurrentRev.TO_VENDOR;
4375

    
4376
                if (ViewerDataModel.Instance.PageNumber == 0)
4377
                {
4378
                    ViewerDataModel.Instance.PageNumber = 1;
4379
                }
4380

    
4381
                //PDF모드 잠시 대기(강인구)
4382
                Get_FinalImage.Get_PdfImage get_PdfImage = new Get_FinalImage.Get_PdfImage();
4383
                var pdfpath = new BitmapImage(new Uri(get_PdfImage.Run(CurrentRev.TO_VENDOR, App.ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.PageNumber)));
4384

    
4385
                if (pdfpath.IsDownloading)
4386
                {
4387
                    pdfpath.DownloadCompleted += (ex, arg) =>
4388
                    {
4389
                        ViewerDataModel.Instance.ImageViewPath_C = pdfpath;
4390
                        ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;
4391
                        ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;
4392
                        zoomAndPanCanvas2.Width = pdfpath.PixelWidth;
4393
                        zoomAndPanCanvas2.Height = pdfpath.PixelHeight;
4394
                    };
4395
                }
4396
                else
4397
                {
4398
                    ViewerDataModel.Instance.ImageViewPath_C = pdfpath;
4399
                    ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;
4400
                    ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;
4401

    
4402
                    zoomAndPanCanvas2.Width = pdfpath.PixelWidth;
4403
                    zoomAndPanCanvas2.Height = pdfpath.PixelHeight;
4404
                }
4405
            }
4406
            else
4407
            {
4408
                IsSyncPDFMode = false;
4409
                string uri = "";
4410
                if (userData.COMPANY != "EXT")
4411
                {
4412
                    uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, (Convert.ToUInt32(CurrentRev.DOCUMENT_ID) / 100).ToString(), CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber);
4413
                }
4414
                else
4415
                {
4416
                    uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber);
4417
                }
4418

    
4419
                var defaultBitmapImage_Compare = new BitmapImage(new Uri(uri));
4420

    
4421
                ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4422
                ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4423
                ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4424

    
4425
                if (defaultBitmapImage_Compare.IsDownloading)
4426
                {
4427
                    defaultBitmapImage_Compare.DownloadCompleted += (ex, arg) =>
4428
                    {
4429
                        ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4430
                        ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4431
                        ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4432
                    };
4433
                }
4434
                zoomAndPanControl2.ApplyTemplate();
4435
                zoomAndPanControl2.UpdateLayout();
4436
                zoomAndPanCanvas2.Width = Convert.ToDouble(Common.ViewerDataModel.Instance.ContentWidth);
4437
                zoomAndPanCanvas2.Height = Convert.ToDouble(Common.ViewerDataModel.Instance.ContentHeight);
4438
            }
4439
        }
4440

    
4441
        private async void RadButton_Click(object sender, RoutedEventArgs e)
4442
        {
4443
            gridViewHistory_Busy.IsBusy = true;
4444

    
4445
            RadButton instance = sender as RadButton;
4446
            if (instance.CommandParameter != null)
4447
            {
4448
                CurrentRev = instance.CommandParameter as VPRevision;
4449
                System.EventHandler<ServiceDeepView.GetSyncMarkupInfoItemsCompletedEventArgs> GetSyncMarkupInfoItemshandler = null;
4450

    
4451
                GetSyncMarkupInfoItemshandler = (sen, ea) =>
4452
                {
4453
                    if (ea.Error == null && ea.Result != null)
4454
                    {
4455
                        testPanel2.IsHidden = false;
4456

    
4457
                        ViewerDataModel.Instance._markupInfoRevList.Clear();
4458
                        foreach(var info in ea.Result)
4459
                        {
4460
                            if(info.UserID == App.ViewInfo.UserID)
4461
                            {
4462
                                info.userDelete = true;
4463
                                info.DisplayColor = "FFFF0000";
4464
                            }
4465
                            else
4466
                            {
4467
                                info.userDelete = false;
4468
                            }
4469
                            ViewerDataModel.Instance._markupInfoRevList.Add(info);
4470
                        }
4471
                        gridViewRevMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoRevList;
4472

    
4473
                        string uri = "";
4474
                        if (userData.COMPANY != "EXT")
4475
                        {
4476
                            uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, (Convert.ToUInt32(CurrentRev.DOCUMENT_ID) / 100).ToString(), CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber);
4477
                        }
4478
                        else
4479
                        {
4480
                            uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber);
4481
                        }
4482

    
4483
                        Sync_Offset_Point = new Point(zoomAndPanControl.ContentOffsetX, zoomAndPanControl.ContentOffsetY);
4484

    
4485
                        var defaultBitmapImage_Compare = ImageSourceHelper.GetDownloadImage(uri);
4486

    
4487
                        ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4488
                        ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4489
                        ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4490
                        zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;
4491
                        zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;
4492
                        
4493
                        zoomAndPanControl2.ApplyTemplate();
4494
                        zoomAndPanControl2.UpdateLayout();
4495
                        //syncPannelRotate(zoomAndPanControl.RotationAngle);
4496
                        if (Sync_Offset_Point != new Point(zoomAndPanControl.ContentOffsetX, zoomAndPanControl.ContentOffsetY))
4497
                        {
4498
                            zoomAndPanControl.ContentOffsetX = Sync_Offset_Point.X;
4499
                            zoomAndPanControl.ContentOffsetY = Sync_Offset_Point.Y;
4500
                        }
4501

    
4502
                        ViewerDataModel.Instance.Sync_ContentOffsetX = Sync_Offset_Point.X;
4503
                        ViewerDataModel.Instance.Sync_ContentOffsetY = Sync_Offset_Point.Y;
4504
                        ViewerDataModel.Instance.Sync_ContentScale = zoomAndPanControl.ContentScale;
4505

    
4506
                        tlSyncRev.Text = String.Format("Rev. {0}", CurrentRev.RevNo);
4507
                        tlSyncPageNum.Text = String.Format("Current Page : {0}", pageNavigator.CurrentPage.PageNumber);
4508
                        gridViewHistory_Busy.IsBusy = false;
4509
                    }
4510

    
4511
                    Logger.sendResLog("GetSyncMarkupInfoItemsCompleted", "UserState : " + ea.UserState + "\r Result :" + ea.Result + "\r Cancelled :" + ea.Cancelled + "\r Error :" + ea.Error, 1);
4512

    
4513
                    if (GetSyncMarkupInfoItemshandler != null)
4514
                    {
4515
                        BaseClient.GetSyncMarkupInfoItemsCompleted -= GetSyncMarkupInfoItemshandler;
4516
                    }
4517

    
4518
                    ClearCompareRect();
4519
                    SetCompareRect();
4520
                };
4521

    
4522
                /// 중복 실행이 발생하여 수정함.
4523
                BaseClient.GetSyncMarkupInfoItemsCompleted += GetSyncMarkupInfoItemshandler;
4524
                BaseClient.GetSyncMarkupInfoItemsAsync(_ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, _ViewInfo.UserID);
4525

    
4526
                Logger.sendReqLog("GetSyncMarkupInfoItemsAsync", _ViewInfo.ProjectNO + "," + CurrentRev.DOCUMENT_ID + "," + _ViewInfo.UserID, 1);
4527
            }
4528
        }
4529

    
4530
        private void EnsembleLink_Button_Click(object sender, RoutedEventArgs e)
4531
        {
4532
            try
4533
            {
4534
                if (sender is RadButton)
4535
                {
4536
                    if ((sender as RadButton).Tag != null)
4537
                    {
4538
                        var url = (sender as RadButton).Tag.ToString();
4539
                        System.Diagnostics.Process.Start(url);
4540
                    }
4541
                    else
4542
                    {
4543
                        this.ParentOfType<MainWindow>().DialogMessage_Alert("Link 정보가 잘못 되었습니다", "안내");
4544
                    }
4545
                }
4546
            }
4547
            catch (Exception ex)
4548
            {
4549
                Logger.sendResLog("EnsembleLink_Button_Click", ex.Message, 0);
4550
            }
4551
        }
4552

    
4553
        public void Sync_Event(VPRevision Currnet_Rev)
4554
        {
4555
            CurrentRev = Currnet_Rev;
4556

    
4557
            BaseClient.GetSyncMarkupInfoItemsCompleted += (sen, ea) =>
4558
            {
4559
                if (ea.Error == null && ea.Result != null)
4560
                {
4561
                    testPanel2.IsHidden = false;
4562

    
4563
                    ViewerDataModel.Instance._markupInfoRevList.Clear();
4564
                    foreach(var info in ea.Result)
4565
                    {
4566
                        if(info.UserID == App.ViewInfo.UserID)
4567
                        {
4568
                            info.userDelete = true;
4569
                            info.DisplayColor = "FFFF0000";
4570
                        }
4571
                        else
4572
                        {
4573
                            info.userDelete = false;
4574
                        }
4575
                        ViewerDataModel.Instance._markupInfoRevList.Add(info);
4576
                    }
4577
                    gridViewRevMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoRevList;
4578

    
4579
                    string uri = "";
4580
                    if (userData.COMPANY != "EXT")
4581
                    {
4582
                        uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, (Convert.ToUInt32(CurrentRev.DOCUMENT_ID) / 100).ToString(), CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber);
4583
                    }
4584
                    else
4585
                    {
4586
                        uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, pageNavigator.CurrentPage.PageNumber);
4587
                    }
4588

    
4589
                    Sync_Offset_Point = new Point(zoomAndPanControl.ContentOffsetX, zoomAndPanControl.ContentOffsetY);
4590

    
4591
                    var defaultBitmapImage_Compare = new BitmapImage(new Uri(uri));
4592

    
4593
                    ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4594
                    ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4595
                    ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4596

    
4597
                    if (defaultBitmapImage_Compare.IsDownloading)
4598
                    {
4599
                        defaultBitmapImage_Compare.DownloadCompleted += (ex, arg) =>
4600
                        {
4601
                            ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;
4602
                            ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;
4603
                            ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;
4604
                        };
4605
                    }
4606

    
4607

    
4608
                    zoomAndPanCanvas2.Width = Convert.ToDouble(Common.ViewerDataModel.Instance.ContentWidth);
4609
                    zoomAndPanCanvas2.Height = Convert.ToDouble(Common.ViewerDataModel.Instance.ContentHeight);
4610
                    zoomAndPanControl2.ApplyTemplate();
4611
                    zoomAndPanControl2.UpdateLayout();
4612

    
4613
                    if (Sync_Offset_Point != new Point(zoomAndPanControl.ContentOffsetX, zoomAndPanControl.ContentOffsetY))
4614
                    {
4615
                        zoomAndPanControl.ContentOffsetX = Sync_Offset_Point.X;
4616
                        zoomAndPanControl.ContentOffsetY = Sync_Offset_Point.Y;
4617
                    }
4618
                    //}
4619

    
4620
                    tlSyncRev.Text = String.Format("Rev. {0}", CurrentRev.RevNo);
4621
                    tlSyncPageNum.Text = String.Format("Current Page : {0}", pageNavigator.CurrentPage.PageNumber);
4622
                    gridViewHistory_Busy.IsBusy = false;
4623
                }
4624
                Logger.sendResLog("GetSyncMarkupInfoItemsCompleted", "UserState : " + ea.UserState + "\r Result :" + ea.Result + "\r Cancelled :" + ea.Cancelled + "\r Error :" + ea.Error, 1);
4625

    
4626
            };
4627
            Logger.sendReqLog("GetSyncMarkupInfoItemsAsync", _ViewInfo.ProjectNO + "," + CurrentRev.DOCUMENT_ID + "," + _ViewInfo.UserID, 1);
4628
            BaseClient.GetSyncMarkupInfoItemsAsync(_ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, _ViewInfo.UserID);
4629
        }
4630

    
4631
        private void PdfLink_ButtonDown(object sender, MouseButtonEventArgs e)
4632
        {
4633
            if (sender is Image)
4634
            {
4635
                if ((sender as Image).Tag != null)
4636
                {
4637
                    var pdfUrl = (sender as Image).Tag.ToString();
4638
                    System.Diagnostics.Process.Start(pdfUrl);
4639
                }
4640
                else
4641
                {
4642
                    this.ParentOfType<MainWindow>().DialogMessage_Alert("문서 정보가 잘못 되었습니다", "안내");
4643
                }
4644
            }
4645
        }
4646

    
4647
        private void Create_Symbol(object sender, RoutedEventArgs e)
4648
        {
4649
            MarkupToPDF.Controls.Parsing.MarkupParser.MarkupReturn markupReturn = new MarkupToPDF.Controls.Parsing.MarkupParser.MarkupReturn();
4650

    
4651
            if (SelectLayer.Children.Count < 1) //선택된 것이 없으면
4652
            {
4653
                DialogMessage_Alert("Please Select Controls", "Alert");
4654
            }
4655
            else //선택된 것이 있으면
4656
            {
4657
                string MarkupData = "";
4658
                adorner_ = new AdornerFinal();
4659

    
4660
                foreach (var item in SelectLayer.Children)
4661
                {
4662
                    if (item.GetType().Name == "AdornerFinal")
4663
                    {
4664
                        adorner_ = (item as Controls.AdornerFinal);
4665
                        foreach (var InnerItem in (item as Controls.AdornerFinal).Members.Cast<Controls.AdornerMember>())
4666
                        {
4667
                            if (!ViewerDataModel.Instance.MarkupControls.Contains(InnerItem.DrawingData))
4668
                            {
4669
                                markupReturn = MarkupParser.MarkupToString(InnerItem.DrawingData as MarkupToPDF.Common.CommentUserInfo, App.ViewInfo.UserID);
4670
                                MarkupData += markupReturn.ConvertData;
4671
                            }
4672
                        }
4673
                    }
4674
                }
4675
                DialogParameters parameters = new DialogParameters()
4676
                {
4677
                    Owner = Application.Current.MainWindow,
4678
                    Closed = (obj, args) => this.MarkupNamePromptClose(MarkupData, args),
4679
                    DefaultPromptResultValue = "Custom State",
4680
                    Content = "Name :",
4681
                    Header = "Insert Custom Symbol Name",
4682
                    Theme = new VisualStudio2013Theme(),
4683
                    ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },
4684
                };
4685
                RadWindow.Prompt(parameters);
4686
            }
4687

    
4688
        }
4689
        public int symbolselectindex = 0;
4690
        private void SymbolMarkupNamePromptClose(byte[] Img_byte, string data, WindowClosedEventArgs args)
4691
        {
4692
            //Save save = new Save();
4693
            try
4694
            {
4695
                string svgfilename = null;
4696
                if (symbolname != null)
4697
                {
4698
                    if (symbolpng == true || symbolsvg == true)
4699
                    {
4700
                        kr.co.devdoftech.cloud.FileUpload fileUploader = new kr.co.devdoftech.cloud.FileUpload();
4701
                        string guid = Commons.shortGuid();
4702

    
4703
                        fileUploader.RunAsync(App.ViewInfo.ProjectNO, _DocItem.DOCUMENT_NO, App.ViewInfo.UserID, guid + ".png", Img_byte);
4704
                        //Check_Uri.UriCheck();
4705
                        fileUploader.RunCompleted += (ex, arg) =>
4706
                        {
4707
                            filename = arg.Result;
4708
                            if (symbolpng == true)
4709
                            {
4710
                                if (filename != null)
4711
                                { 
4712
                                    if (symbolselectindex == 0)
4713
                                    {
4714
                                        SymbolSave(symbolname, filename, data);
4715
                                    }
4716
                                    else
4717
                                    {
4718
                                        SymbolSave_Public(symbolname, filename, data, ViewerDataModel.Instance.SystemMain.dzMainMenu.userData.DEPARTMENT);
4719
                                    }
4720
                                    DataBind();
4721
                                }                                
4722
                            }
4723

    
4724
                            if (symbolsvg == true)
4725
                            {
4726
                                try
4727
                                {
4728
                                    var defaultBitmapImage = new BitmapImage();
4729
                                    defaultBitmapImage.BeginInit();
4730
                                    defaultBitmapImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
4731
                                    defaultBitmapImage.CacheOption = BitmapCacheOption.OnLoad;
4732
                                    Check_Uri.UriCheck(filename);
4733
                                    defaultBitmapImage.UriSource = new Uri(filename);
4734
                                    defaultBitmapImage.EndInit();
4735

    
4736
                                    System.Drawing.Bitmap image;
4737

    
4738
                                    if (defaultBitmapImage.IsDownloading)
4739
                                    {
4740
                                        defaultBitmapImage.DownloadCompleted += (ex2, arg2) =>
4741
                                        {
4742
                                            defaultBitmapImage.Freeze();
4743
                                            image = GetBitmap(defaultBitmapImage);
4744
                                            image.Save(@AppDomain.CurrentDomain.BaseDirectory + "potrace.bmp", System.Drawing.Imaging.ImageFormat.Bmp);
4745
                                            Process potrace = new Process
4746
                                            {
4747
                                                StartInfo = new ProcessStartInfo
4748
                                                {
4749
                                                    FileName = @AppDomain.CurrentDomain.BaseDirectory + "potrace.exe",
4750
                                                    Arguments = "-b svg " + @AppDomain.CurrentDomain.BaseDirectory + "potrace.bmp",
4751
                                                    RedirectStandardInput = true,
4752
                                                    RedirectStandardOutput = true,
4753
                                                    RedirectStandardError = true,
4754
                                                    UseShellExecute = false,
4755
                                                    CreateNoWindow = true,
4756
                                                    WindowStyle = ProcessWindowStyle.Hidden
4757
                                                },
4758
                                            };
4759

    
4760
                                            StringBuilder svgBuilder = new StringBuilder();
4761
                                            potrace.OutputDataReceived += (object sender2, DataReceivedEventArgs e2) =>
4762
                                            {
4763
                                                svgBuilder.AppendLine(e2.Data);
4764
                                            };
4765

    
4766
                                            potrace.EnableRaisingEvents = true;
4767
                                            potrace.Start();
4768
                                            potrace.Exited += (sender, e) =>
4769
                                            {
4770
                                                byte[] bytes = System.IO.File.ReadAllBytes(@AppDomain.CurrentDomain.BaseDirectory + "potrace.svg");
4771
                                                svgfilename = fileUploader.Run(App.ViewInfo.ProjectNO, _DocItem.DOCUMENT_NO, App.ViewInfo.UserID, guid + ".svg", bytes);
4772
                                                Check_Uri.UriCheck(svgfilename);
4773
                                                if (symbolselectindex == 0)
4774
                                                {
4775
                                                    SymbolSave(symbolname, svgfilename, data);
4776
                                                }
4777
                                                else
4778
                                                {
4779
                                                    SymbolSave_Public(symbolname, svgfilename, data, ViewerDataModel.Instance.SystemMain.dzMainMenu.userData.DEPARTMENT);
4780
                                                }
4781

    
4782
                                                DataBind();
4783
                                            };
4784
                                            potrace.WaitForExit();
4785
                                        };
4786
                                    }
4787
                                    else
4788
                                    {
4789
                                        //GC.Collect();
4790
                                    }
4791
                                }
4792
                                catch(Exception ee)
4793
                                {
4794
                                    DialogMessage_Alert("" + ee, "Alert");
4795
                                }
4796
                            }
4797
                        };                                             
4798
                    }
4799
                }
4800
            }
4801
            catch (Exception e)
4802
            {
4803
                //DialogMessage_Alert(e + "", "Alert");
4804
            }            
4805
        }
4806

    
4807
        public void SymbolSave(string Name, string Url, string Data)
4808
        {
4809
            try
4810
            {
4811
                SYMBOL_PRIVATE symbol_private = new SYMBOL_PRIVATE
4812
                {
4813
                    ID = Commons.shortGuid(),
4814
                    MEMBER_USER_ID = App.ViewInfo.UserID,
4815
                    NAME = Name,
4816
                    IMAGE_URL = Url,
4817
                    DATA = Data
4818
                };
4819

    
4820
                Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.SaveSymbolCompleted += BaseClient_SaveSymbolCompleted;
4821
                Logger.sendReqLog("SaveSymbolAsync: ", symbol_private.ID + "," + symbol_private.MEMBER_USER_ID + "," + symbol_private.NAME + "," + symbol_private.IMAGE_URL + "," + symbol_private.DATA, 1);
4822
                Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.SaveSymbolAsync(symbol_private);
4823
            }
4824
            catch (Exception)
4825
            {
4826
                throw;
4827
            }
4828
        }
4829

    
4830
        public void SymbolSave_Public(string Name, string Url, string Data, string Department)
4831
        {
4832
            try
4833
            {
4834
                SYMBOL_PUBLIC symbol_public = new SYMBOL_PUBLIC
4835
                {
4836
                    ID = Commons.shortGuid(),
4837
                    DEPARTMENT = Department,
4838
                    NAME = Name,
4839
                    IMAGE_URL = Url,
4840
                    DATA = Data
4841
                };
4842
                Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.AddPublicSymbolCompleted += BaseClient_AddPublicSymbolCompleted;
4843
                Logger.sendReqLog("AddPublicSymbol: ", symbol_public.ID + "," + symbol_public.DEPARTMENT + "," + symbol_public.NAME + "," + symbol_public.IMAGE_URL + "," + symbol_public.DATA, 1);
4844
                Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.AddPublicSymbol(symbol_public);
4845
            }
4846
            catch (Exception)
4847
            {
4848
                throw;
4849
            }
4850
        }
4851

    
4852
        private void BaseClient_AddPublicSymbolCompleted(object sender, ServiceDeepView.AddPublicSymbolCompletedEventArgs e)
4853
        {           
4854
            Logger.sendResLog("AddPublicSymbolCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);
4855
            DataBind();
4856
        }
4857

    
4858
        private void BaseClient_SaveSymbolCompleted(object sender, ServiceDeepView.SaveSymbolCompletedEventArgs e)
4859
        {
4860
            Logger.sendResLog("RenameSymbolCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);
4861
            DataBind();
4862
        }
4863
        private void DataBind()
4864
        {
4865
            try
4866
            {
4867
                Symbol_Custom Custom = new Symbol_Custom();
4868
                List<Symbol_Custom> Custom_List = new List<Symbol_Custom>();
4869
                
4870
                var symbol_Private = BaseClient.GetSymbolList(App.ViewInfo.UserID);
4871
                foreach (var item in symbol_Private)
4872
                {
4873
                    Custom.Name = item.NAME;
4874
                    Custom.ImageUri = item.IMAGE_URL;
4875
                    Custom.ID = item.ID;
4876
                    Custom_List.Add(Custom);
4877
                    Custom = new Symbol_Custom();
4878
                }
4879
                symbolPanel_Instance.lstSymbolPrivate.ItemsSource = Custom_List;
4880
                
4881
                Custom = new Symbol_Custom();
4882
                Custom_List = new List<Symbol_Custom>();
4883

    
4884
                symbolPanel_Instance.deptlist.ItemsSource = BaseClient.GetPublicSymbolDeptList();
4885

    
4886
                List<SYMBOL_PUBLIC> symbol_Public;
4887

    
4888
                if (symbolPanel_Instance.deptlist.SelectedValue != null)
4889
                {
4890
                    symbol_Public = BaseClient.GetPublicSymbolList(symbolPanel_Instance.deptlist.SelectedValue.ToString());
4891
                }
4892
                else
4893
                {
4894
                    symbol_Public = BaseClient.GetPublicSymbolList(null);
4895
                }
4896
                foreach (var item in symbol_Public)
4897
                {
4898
                    Custom.Name = item.NAME;
4899
                    Custom.ImageUri = item.IMAGE_URL;
4900
                    Custom.ID = item.ID;
4901
                    Custom_List.Add(Custom);
4902
                    Custom = new Symbol_Custom();
4903
                }
4904
                symbolPanel_Instance.lstSymbolPublic.ItemsSource = Custom_List;
4905
                BaseClient.Close();                
4906
            }
4907
            catch(Exception e)
4908
            {
4909
                //DialogMessage_Alert("DataBind", "Alert");
4910
            }
4911
            
4912
        }
4913
        private void MarkupNamePromptClose(string data, WindowClosedEventArgs args)
4914
        {
4915
            try
4916
            {
4917
                if (args.PromptResult != null)
4918
                {
4919
                    if (args.DialogResult.Value)
4920
                    {
4921
                        PngBitmapEncoder _Encoder = symImage(data);
4922

    
4923
                        System.IO.MemoryStream fs = new System.IO.MemoryStream();
4924
                        _Encoder.Save(fs);
4925
                        System.Drawing.Image ImgOut = System.Drawing.Image.FromStream(fs);
4926

    
4927
                        byte[] Img_byte = fs.ToArray();
4928

    
4929
                        kr.co.devdoftech.cloud.FileUpload fileUploader = new kr.co.devdoftech.cloud.FileUpload();
4930
                        filename = fileUploader.Run(App.ViewInfo.ProjectNO, _DocItem.DOCUMENT_NO, App.ViewInfo.UserID, Commons.shortGuid() + ".png", Img_byte);
4931
                        Check_Uri.UriCheck(filename);
4932
                        if (symbolPanel_Instance.RadTab.SelectedIndex == 0)
4933
                        {
4934
                            SaveCommand.Instance.SymbolSave(args.PromptResult, filename, data);
4935
                        }
4936
                        else
4937
                        {
4938
                            SaveCommand.Instance.SymbolSave_Public(args.PromptResult, filename, data, ViewerDataModel.Instance.SystemMain.dzMainMenu.userData.DEPARTMENT);
4939
                        }
4940
                        DataBind();
4941
                    }
4942
                }
4943
            }
4944
            catch(Exception ex)
4945
            {
4946
                DialogMessage_Alert("" + ex, "Alert");
4947
            }
4948
        }
4949

    
4950
        public PngBitmapEncoder symImage(string data)
4951
        {
4952

    
4953
            Canvas _canvas = new Canvas();
4954
            _canvas.Background = Brushes.White;
4955
            _canvas.Width = adorner_.BorderSize.Width;
4956
            _canvas.Height = adorner_.BorderSize.Height;
4957
            MarkupParser.Parse(App.ViewInfo.ProjectNO, data, _canvas, "#FFFF0000", "");
4958

    
4959
            BitmapEncoder encoder = new PngBitmapEncoder();
4960

    
4961

    
4962
            RenderTargetBitmap renderBitmap = new RenderTargetBitmap((int)_canvas.Width + 50, (int)_canvas.Height + 50, 96d, 96d, PixelFormats.Pbgra32);
4963

    
4964
            DrawingVisual dv = new DrawingVisual();
4965

    
4966
            _canvas.Measure(new System.Windows.Size(adorner_.BorderSize.Width + 50, adorner_.BorderSize.Height + 50));
4967
            _canvas.Arrange(new Rect(new System.Windows.Point { X = -adorner_.BorderSize.X - 20, Y = -adorner_.BorderSize.Y - 20 }, new Point(adorner_.BorderSize.Width + 20, adorner_.BorderSize.Height + 20)));
4968

    
4969
            using (DrawingContext ctx = dv.RenderOpen())
4970
            {
4971
                VisualBrush vb = new VisualBrush(_canvas);
4972
                ctx.DrawRectangle(vb, null, new Rect(new System.Windows.Point { X = -adorner_.BorderSize.X, Y = -adorner_.BorderSize.Y }, new Point(adorner_.BorderSize.Width + 20, adorner_.BorderSize.Height + 20)));
4973
            }
4974

    
4975
            try
4976
            {
4977
                renderBitmap.Render(dv);
4978

    
4979
                //GC.Collect();
4980
                GC.WaitForPendingFinalizers();
4981
                //GC.Collect();
4982
                // encode png data
4983
                PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
4984
                // puch rendered bitmap into it
4985
                pngEncoder.Interlace = PngInterlaceOption.Off;
4986
                pngEncoder.Frames.Add(BitmapFrame.Create(renderBitmap));
4987
                return pngEncoder;
4988

    
4989
            }
4990
            catch //(Exception ex)
4991
            {
4992
                return null;
4993
            }
4994

    
4995
        }
4996

    
4997
        public void DialogMessage_Alert(string content, string header)
4998
        {
4999
            DialogParameters parameters = new DialogParameters()
5000
            {
5001
                Owner = this.ParentOfType<MainWindow>(),
5002
                Content = new TextBlock()
5003
                { 
5004
                    MinWidth = 400,
5005
                    FontSize = 11,
5006
                    Text = content,
5007
                    TextWrapping = System.Windows.TextWrapping.Wrap
5008
                },
5009
                Header = header,
5010
                Theme = new VisualStudio2013Theme(),
5011
                ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },
5012
            };            
5013
            RadWindow.Alert(parameters);
5014
        }
5015

    
5016
        #region 캡쳐 기능
5017

    
5018
        public BitmapSource CutAreaToImage(int x, int y, int width, int height)
5019
        {
5020
            if (x < 0)
5021
            {
5022
                width += x;
5023
                x = 0;
5024
            }
5025
            if (y < 0)
5026
            {
5027
                height += y;
5028
                y = 0;
5029

    
5030
                width = (int)zoomAndPanCanvas.ActualWidth - x;
5031
            }
5032
            if (x + width > zoomAndPanCanvas.ActualWidth)
5033
            {
5034
                width = (int)zoomAndPanCanvas.ActualWidth - x;
5035
            }
5036
            if (y + height > zoomAndPanCanvas.ActualHeight)
5037
            {
5038
                height = (int)zoomAndPanCanvas.ActualHeight - y;
5039
            }
5040

    
5041
            byte[] pixels = CopyPixels(x, y, width, height);
5042

    
5043
            int stride = (width * canvasImage.Format.BitsPerPixel + 7) / 8;
5044

    
5045
            return BitmapSource.Create(width, height, 96, 96, PixelFormats.Pbgra32, null, pixels, stride);
5046
        }
5047

    
5048
        public byte[] CopyPixels(int x, int y, int width, int height)
5049
        {
5050
            byte[] pixels = new byte[width * height * 4];
5051
            int stride = (width * canvasImage.Format.BitsPerPixel + 7) / 8;
5052

    
5053
            // Canvas 이미지에서 객체 역역만큼 픽셀로 복사
5054
            canvasImage.CopyPixels(new Int32Rect(x, y, width, height), pixels, stride, 0);
5055

    
5056
            return pixels;
5057
        }
5058

    
5059
        public RenderTargetBitmap ConverterBitmapImage(FrameworkElement element)
5060
        {
5061
            DrawingVisual drawingVisual = new DrawingVisual();
5062
            DrawingContext drawingContext = drawingVisual.RenderOpen();
5063

    
5064
            // 해당 객체의 그래픽요소로 사각형의 그림을 그립니다.
5065
            drawingContext.DrawRectangle(new VisualBrush(element), null,
5066
                new Rect(new Point(0, 0), new Point(element.ActualWidth, element.ActualHeight)));
5067
            drawingContext.Close();
5068

    
5069
            // 비트맵으로 변환합니다.
5070
            RenderTargetBitmap target =
5071
                new RenderTargetBitmap((int)element.ActualWidth, (int)element.ActualHeight,
5072
                96, 96, System.Windows.Media.PixelFormats.Pbgra32);
5073

    
5074
            target.Render(drawingVisual);
5075
            return target;
5076
        }
5077

    
5078
        System.Drawing.Bitmap GetBitmap(BitmapSource source)
5079
        {
5080
            System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(source.PixelWidth, source.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
5081
            System.Drawing.Imaging.BitmapData data = bmp.LockBits(new System.Drawing.Rectangle(System.Drawing.Point.Empty, bmp.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
5082
            source.CopyPixels(Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
5083
            bmp.UnlockBits(data);
5084
            return bmp;
5085
        }
5086
        public string symbolname = null;
5087
        public bool symbolsvg = true;
5088
        public bool symbolpng = true;
5089

    
5090
        public void Save_Symbol_Capture(BitmapSource source, int x, int y, int width, int height)
5091
        {
5092
            System.Drawing.Bitmap image = GetBitmap(source);
5093
            //흰색 제거
5094
            //image.MakeTransparent(System.Drawing.Color.White);
5095

    
5096
            var imageStream = new System.IO.MemoryStream();
5097
            byte[] imageBytes = null;
5098
            using (imageStream)
5099
            {
5100
                image.Save(imageStream, System.Drawing.Imaging.ImageFormat.Png);
5101
                // test.Save(@"E:\test.png", System.Drawing.Imaging.ImageFormat.Png);
5102
                imageStream.Position = 0;
5103
                imageBytes = imageStream.ToArray();
5104
            }
5105

    
5106
            SymbolPrompt symbolPrompt = new SymbolPrompt();
5107

    
5108
            RadWindow CheckPop = new RadWindow();
5109
            //Alert check = new Alert(Msg);
5110

    
5111
            CheckPop = new RadWindow
5112
            {
5113
                MinWidth = 400,
5114
                MinHeight = 100,
5115
               // Closed = (obj, args) => this.SymbolMarkupNamePromptClose(imageBytes, "", args),
5116
                Header = "Alert",
5117
                Content = symbolPrompt,
5118
                //DialogResult = 
5119
                ResizeMode = System.Windows.ResizeMode.NoResize,
5120
                WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen,
5121
                IsTopmost = true,
5122
            };
5123
            CheckPop.Closed += (obj, args) => this.SymbolMarkupNamePromptClose(imageBytes, "", args);
5124
            StyleManager.SetTheme(CheckPop, new Office2013Theme());
5125
            CheckPop.ShowDialog();
5126

    
5127
            /*
5128
            DialogParameters parameters = new DialogParameters()
5129
            {
5130
                Owner = Application.Current.MainWindow,
5131
                Closed = (obj, args) => this.SymbolMarkupNamePromptClose(imageBytes, "", args),
5132
                DefaultPromptResultValue = "Custom State",
5133
                Content = "Name :",
5134
                Header = "Insert Custom Symbol Name",
5135
                Theme = new VisualStudio2013Theme(),
5136
                ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },
5137
            };            
5138
            RadWindow.Prompt(parameters);
5139
            */
5140
        }
5141

    
5142
        public void Save_Capture(BitmapSource source, int x, int y, int width, int height)
5143
        {
5144
            KCOM.Common.Converter.FileStreamToBase64 streamToBase64 = new Common.Converter.FileStreamToBase64();
5145
            KCOMDataModel.DataModel.CHECK_LIST check_;
5146
            string Result = streamToBase64.ImageToBase64(source);
5147
            KCOMDataModel.DataModel.CHECK_LIST Item = new KCOMDataModel.DataModel.CHECK_LIST();
5148
            string projectno = App.ViewInfo.ProjectNO;
5149
            string checklist_id = ViewerDataModel.Instance.CheckList_ID;
5150

    
5151
            Logger.sendReqLog("GetCheckList", projectno + "," + checklist_id, 1);
5152
            Item = this.BaseClient.GetCheckList(projectno, checklist_id);
5153
            if (Item != null)
5154
            {
5155
                Logger.sendResLog("GetCheckList", "TRUE", 1);
5156
            }
5157
            else
5158
            {
5159
                Logger.sendResLog("GetCheckList", "FALSE", 1);
5160
            }
5161

    
5162
            if (Item == null)
5163
            {
5164
                check_ = new KCOMDataModel.DataModel.CHECK_LIST
5165
                {
5166
                    ID = Commons.shortGuid(),
5167
                    USER_ID = App.ViewInfo.UserID,
5168
                    IMAGE_URL = Result,
5169
                    IMAGE_ANCHOR = x + "," + y + "," + width + "," + height,
5170
                    PAGENUMBER = this.pageNavigator.CurrentPage.PageNumber,
5171
                    REVISION = ViewerDataModel.Instance.SystemMain.dzMainMenu.CurrentDoc.Revision,
5172
                    DOCUMENT_ID = App.ViewInfo.DocumentItemID,
5173
                    PROJECT_NO = App.ViewInfo.ProjectNO,
5174
                    STATUS = "False",
5175
                    CREATE_TIME = DateTime.Now,
5176
                    UPDATE_TIME = DateTime.Now,
5177
                    DOCUMENT_NO = _DocItem.DOCUMENT_NO,
5178
                    STATUS_DESC_OPEN = "Vendor 반영 필요",
5179
                };
5180
                Logger.sendReqLog("AddCheckList", projectno + "," + check_, 1);
5181
                Logger.sendResLog("AddCheckList", this.BaseClient.AddCheckList(projectno, check_).ToString(), 1);
5182
                //this.BaseClient.AddCheckList(projectno, check_);
5183
            }
5184
            else
5185
            {
5186
                Item.IMAGE_URL = Result;
5187
                Item.IMAGE_ANCHOR = x + "," + y + "," + width + "," + height;
5188
                Item.PAGENUMBER = this.pageNavigator.CurrentPage.PageNumber;
5189
                Logger.sendReqLog("SaveCheckList", projectno + "," + checklist_id + "," + Item, 1);
5190
                Logger.sendResLog("SaveCheckList", this.BaseClient.SaveCheckList(projectno, checklist_id, Item).ToString(), 1);
5191
                //this.BaseClient.SaveCheckList(projectno, checklist_id, Item);
5192
            }
5193

    
5194
        }
5195

    
5196
        public void Set_Capture()
5197
        {
5198
            double x = canvasDrawingMouseDownPoint.X;
5199
            double y = canvasDrawingMouseDownPoint.Y;
5200
            double width = dragCaptureBorder.Width;
5201
            double height = dragCaptureBorder.Height;
5202

    
5203
            if (width > 5 || height > 5)
5204
            {
5205
                canvasImage = ConverterBitmapImage(zoomAndPanCanvas);
5206
                BitmapSource source = CutAreaToImage((int)x, (int)y, (int)width, (int)height);
5207
                Save_Capture(source, (int)x, (int)y, (int)width, (int)height);
5208
            }
5209
        }
5210
        #endregion
5211

    
5212
        public Multi_Undo_data Control_Style(CommentUserInfo control)
5213
        {
5214
            multi_Undo_Data = new Multi_Undo_data();
5215

    
5216
            multi_Undo_Data.Markup = control;
5217

    
5218
            if ((control as IShapeControl) != null)
5219
            {
5220
                multi_Undo_Data.paint = (control as IShapeControl).Paint;
5221
            }
5222
            if ((control as IDashControl) != null)
5223
            {
5224
                multi_Undo_Data.DashSize = (control as IDashControl).DashSize;
5225
            }
5226
            if ((control as IPath) != null)
5227
            {
5228
                multi_Undo_Data.LineSize = (control as IPath).LineSize;
5229
            }
5230
            if ((control as UIElement) != null)
5231
            {
5232
                multi_Undo_Data.Opacity = (control as UIElement).Opacity;
5233
            }
5234

    
5235
            return multi_Undo_Data;
5236
        }
5237

    
5238
        private void Comment_Move(object sender, MouseButtonEventArgs e)
5239
        {
5240
            string Select_ID = (((e.Source as Telerik.Windows.Controls.RadButton).DataContext) as IKCOM.MarkupInfoItem).UserID;
5241
            foreach (var items in ViewerDataModel.Instance._markupInfoRevList)
5242
            {
5243
                if (items.UserID == Select_ID)
5244
                {
5245
                    foreach (var item in items.MarkupList)
5246
                    {
5247
                        if (item.PageNumber == pageNavigator.CurrentPage.PageNumber)
5248
                        {
5249
                            MarkupParser.ParseEx(App.ViewInfo.ProjectNO, item.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, "#FFFF0000", "", 
5250
                                items.MarkupInfoID, Commons.shortGuid());
5251
                        }
5252
                    }
5253
                }
5254
            }
5255
        }
5256

    
5257
        /// <summary>
5258
        /// convert inkcontrol to polygoncontrol
5259
        /// </summary>
5260
        public void ConvertInkControlToPolygon()
5261
        {
5262
            if (inkBoard.Strokes.Count > 0)
5263
            {
5264
                inkBoard.Strokes.ToList().ForEach(stroke =>
5265
                {
5266
                    InkToPath ip = new InkToPath();
5267

    
5268
                    List<Point> inkPointSet = new List<Point>();
5269
                    inkPointSet.AddRange(ip.GetPointsFrom(stroke));
5270

    
5271
                    PolygonControl pc = new PolygonControl()
5272
                    {
5273
                        Angle = 0,
5274
                        PointSet = inkPointSet,
5275
                        ControlType = ControlType.Ink
5276
                    };
5277
                    pc.StartPoint = inkPointSet[0];
5278
                    pc.EndPoint = inkPointSet[inkPointSet.Count - 1];
5279
                    pc.LineSize = 3;
5280
                    pc.CommentID = Commons.shortGuid();
5281
                    pc.StrokeColor = new SolidColorBrush(Colors.Red);
5282

    
5283
                    if (pc.PointSet.Count > 0)
5284
                    {
5285
                        CreateCommand.Instance.Execute(pc);
5286
                        ViewerDataModel.Instance.MarkupControls_USER.Add(pc);
5287
                    }
5288
                });
5289
                inkBoard.Strokes.Clear();
5290
            }
5291
        }
5292

    
5293
        /// <summary>
5294
        /// 캔버스에 그릴때 모든 포인트가 캔버스를 벗어 났는지 체크하여 넘겨줌
5295
        /// </summary>
5296
        /// <author>ingu</author>
5297
        /// <date>2018.06.05</date>
5298
        /// <param name="getPoint"></param>
5299
        /// <returns></returns>
5300
        private bool IsGetoutpoint(Point getPoint)
5301
        {
5302
            if (getPoint == new Point())
5303
            {
5304
                ViewerDataModel.Instance.MarkupControls_USER.Remove(currentControl);
5305
                currentControl = null;
5306
                return true;
5307
            }
5308

    
5309
            return false;
5310
        }
5311

    
5312
        private void zoomAndPanControl_DragOver(object sender, DragEventArgs e)
5313
        {
5314
            e.Effects = DragDropEffects.Copy;
5315
        }
5316

    
5317
        private void zoomAndPanControl_DragEnter(object sender, DragEventArgs e)
5318
        {
5319
            e.Effects = DragDropEffects.Copy;
5320
        }
5321

    
5322
        private void zoomAndPanControl_DragLeave(object sender, DragEventArgs e)
5323
        {
5324
            e.Effects = DragDropEffects.None;
5325
        }
5326

    
5327
        private void ZoomAndPanControl_ScaleChanged(object sender, RoutedEventArgs e)
5328
        {
5329
            var pageWidth = ViewerDataModel.Instance.ImageViewWidth;
5330
            var pageHeight = ViewerDataModel.Instance.ImageViewHeight;
5331

    
5332
            ScaleImage(pageWidth, pageHeight);
5333
        }
5334

    
5335
        /// <summary>
5336
        /// 페이지를 scale의 변화에 맞춰서 DecodePixel을 변경한다.
5337
        /// </summary>
5338
        /// <param name="pageWidth">원본 사이즈</param>
5339
        /// <param name="pageHeight">원본 사이즈</param>
5340
        /// <returns></returns>
5341
        private void ScaleImage(double pageWidth,double pageHeight)
5342
        {
5343
            //mainPanel.Scale = zoomAndPanControl.ContentScale;// (zoomAndPanControl.ContentScale >= 0.1) ? 1 : zoomAndPanControl.ContentScale;
5344
        }
5345

    
5346
        private void thumbnailPanel_SizeChanged(object sender, SizeChangedEventArgs e)
5347
        {
5348
            CommonLib.Common.WriteConfigString("SetThumbnail", "WIDTH", thumbnailPanel.Width.ToString());
5349
        }
5350

    
5351
        private void UserControl_LayoutUpdated(object sender, EventArgs e)
5352
        {
5353
            System.Diagnostics.Debug.WriteLine("layupdated");
5354
            if (Common.ViewerDataModel.Instance.MarkupControls_USER?.Count() > 0)
5355
            {
5356
                ViewerDataModel.Instance.OnLoadPage();
5357
            }
5358
        }
5359

    
5360

    
5361

    
5362
        /*
5363
        private void zoomAndPanControl_Drop(object sender, DragEventArgs e)
5364
        {
5365
            try
5366
            {
5367
                if (e.Data.GetDataPresent(typeof(string)))
5368
                {
5369
                    this.getCurrentPoint = e.GetPosition(drawingRotateCanvas);
5370
                    string dragData = e.Data.GetData(typeof(string)) as string;
5371
                    Move_Symbol(sender, dragData);
5372
                }
5373
            }
5374
            catch (Exception ex)
5375
            {
5376
                Logger.sendResLog("zoomAndPanControl_Drop", ex.ToString(), 0);
5377
            }            
5378
        }
5379
        */
5380
    }
5381
}