MARKUS



using MarkupToPDF.Controls.Common;

using MarkupToPDF.Controls.Line;

using MarkupToPDF.Controls.Polygon;

using MarkupToPDF.Controls.Shape;

using MarkupToPDF.Controls.Text;

using MarkupToPDF.Controls.Etc;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using KCOM.Common;

using IKCOM;

using System.Windows.Ink;

using System.Collections.ObjectModel;

using Telerik.Windows.Controls;

using KCOM.Events;

using System.Reflection;

using MarkupToPDF.Common;

using KCOM.Controls;

using KCOMDataModel.DataModel;

using System.Xml;

using static KCOM.TempFile;

using System.Windows.Threading;

using System.Diagnostics;

using System.Threading;

using System.Windows.Resources;

using Svg2Xaml;

using System.Runtime.InteropServices;

using System.Windows.Media.Effects;

using MarkupToPDF.Controls.Cad;

using MarkupToPDF.Controls.Parsing;

namespace KCOM.Views

{

    public static class ControlExtensions

    {

        public static T Clone<T>(this T controlToClone)

            where T : System.Windows.Controls.Control

        {

            System.Reflection.PropertyInfo[] controlProperties = typeof(T).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);

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

            foreach (PropertyInfo propInfo in controlProperties)

            {

                if (propInfo.CanWrite)

                {

                    if (propInfo.Name != "WindowTarget")

                        propInfo.SetValue(instance, propInfo.GetValue(controlToClone, null), null);

                }

            }

            return instance;

        }

    }

    public class MyConsole

    {

        private readonly System.Threading.ManualResetEvent _readLineSignal;

        private string _lastLine;

        public MyConsole()

        {

            _readLineSignal = new System.Threading.ManualResetEvent(false);

            Gui = new TextBox();

            Gui.AcceptsReturn = true;

            Gui.KeyUp += OnKeyUp;

        }

        private void OnKeyUp(object sender, KeyEventArgs e)

        {

            // this is always fired on UI thread

            if (e.Key == Key.Enter)

            {

                // quick and dirty, but that is not relevant to your question

                _lastLine = Gui.Text.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries).Last();

                // now, when you detected that user typed a line, set signal

                _readLineSignal.Set();

            }

        }

        public TextBox Gui { get; private set; }

        public string ReadLine()

        {

            // that should always be called from non-ui thread

            if (Gui.Dispatcher.CheckAccess())

                throw new Exception("Cannot be called on UI thread");

            // reset signal

            _readLineSignal.Reset();

            // wait until signal is set. This call is blocking, but since we are on non-ui thread - there is no problem with that

            _readLineSignal.WaitOne();

            // we got signalled - return line user typed.

            return _lastLine;

        }

        public void WriteLine(string line)

        {

            if (!Gui.Dispatcher.CheckAccess())

            {

                Gui.Dispatcher.Invoke(new Action(() => WriteLine(line)));

                return;

            }

            Gui.Text += line + Environment.NewLine;

        }

    }

    /// <summary>

    /// MainMenu.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class MainMenu : UserControl

    {

        #region 프로퍼티

        public Undo_data UndoData { get; set; }

        public CommentUserInfo currentControl { get; set; }

        public ControlType controlType { get; set; }

        private Move move;

        private double[] rotateValue = { 0, 90, 180, 270 };

        public MouseHandlingMode mouseHandlingMode = MouseHandlingMode.None;

        public MouseButton mouseButtonDown { get; set; }

        private static readonly double DragThreshold = 5;

        private System.Windows.Input.Cursor cursor { get; set; }

        private Point canvasDrawingMouseDownPoint;

        public string filename { get; set; }

        private Point canvasZoomPanningMouseDownPoint;

        public Point getCurrentPoint;

        private Point canvasZoommovingMouseDownPoint;

        List<object> ControlList = new List<object>();

        private ListBox listBox = new ListBox();

        private Dictionary<Geometry, string> selected_item = new Dictionary<Geometry, string>();

        private bool isDraggingSelectionRect = false;

        DrawingAttributes inkDA = new DrawingAttributes();

        private VPRevision CurrentRev { get; set; }

        public RadRibbonButton btnConsolidate { get; set; }

        public RadRibbonButton btnFinalPDF { get; set; }

        public RadRibbonButton btnTeamConsolidate { get; set; }

        public RadRibbonButton btnConsolidateFinalPDF { get; set; }

        public string Filename_ { get; set; }

        public double L_Size = 0;

        public AdornerFinal adorner_;

        public Multi_Undo_data multi_Undo_Data;

        public string Symbol_ID = "";

        /// <summary>

        /// Set to 'true' when the left mouse-button is down.

        /// </summary>

        public bool isLeftMouseButtonDownOnWindow = false;

        public InkPresenter _InkBoard = null;

        Stroke stroke;

        Boolean IsDrawing = false;

        StylusPointCollection strokePoints;

        //StylusPointCollection erasePoints;

        RenderTargetBitmap canvasImage;

        Point Sync_Offset_Point;

        //강인구 테스트

        private Path _SelectionPath { get; set; }

        public Path SelectionPath

        {

            get

            {

                return _SelectionPath;

            }

            set

            {

                if (_SelectionPath != value)

                {

                    _SelectionPath = value;

                    RaisePropertyChanged("SelectionPath");

                }

            }

        }

        private System.Windows.Controls.Image _imageViewer { get; set; }

        public System.Windows.Controls.Image imageViewer

        {

            get

            {

                if (_imageViewer == null)

                {

                    _imageViewer = new System.Windows.Controls.Image();

                    return _imageViewer;

                }

                else

                {

                    return _imageViewer;

                }

            }

            set

            {

                if (_imageViewer != value)

                {

                    _imageViewer = value;

                }

            }

        }

        public bool IsSyncPDFMode { get; set; }

        private System.Windows.Controls.Image _imageViewer_Compare { get; set; }

        public System.Windows.Controls.Image imageViewer_Compare

        {

            get

            {

                if (_imageViewer_Compare == null)

                {

                    _imageViewer_Compare = new System.Windows.Controls.Image();

                    return _imageViewer_Compare;

                }

                else

                {

                    return _imageViewer_Compare;

                }

            }

            set

            {

                if (_imageViewer_Compare != value)

                {

                    _imageViewer_Compare = value;

                }

            }

        }

        #endregion

        public MainMenu()

        {

            //InitializeComponent();    

            this.Loaded += MainMenu_Loaded;

        }

        public class TempDt

        {

            public int PageNumber { get; set; }

            public string CommentID { get; set; }

            public string ConvertData { get; set; }

            public int DATA_TYPE { get; set; }

            public string MarkupInfoID { get; set; }

            public int IsUpdate { get; set; }

        }

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

        private void SetCursor()

        {

            this.Cursor = cursor;

        }

        private bool IsDrawingEnable(Point _canvasZoomPanningMouseDownPoint)

        {

            if ((_canvasZoomPanningMouseDownPoint.X > 0 &&

                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.X) &&

                (_canvasZoomPanningMouseDownPoint.Y > 0 &&

                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.Y))

            {

                return true;

            }

            return false;

        }

        private bool IsRotationDrawingEnable(Point _canvasZoomPanningMouseDownPoint)

        {

            if (rotate.Angle == 90 || rotate.Angle == 270)

            {

                if ((_canvasZoomPanningMouseDownPoint.X > 0 &&

                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.X) &&

                (_canvasZoomPanningMouseDownPoint.Y > 0 &&

                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.Y))

                {

                    return true;

                }

            }

            else

            {

                if ((_canvasZoomPanningMouseDownPoint.X > 0 &&

                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.X) &&

                (_canvasZoomPanningMouseDownPoint.Y > 0 &&

                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.Y))

                {

                    return true;

                }

            }

            return false;

        }

        public void DeleteItem(MarkupInfoItem item)

        {

            if (PreviewUserMarkupInfoItem != null && item.Consolidate == 1 && item.AvoidConsolidate == 0)

            {

                App.Custom_ViewInfoId = PreviewUserMarkupInfoItem.MarkupInfoID;

            }

            ViewerDataModel.Instance._markupInfoList.Remove(item);

            ViewerDataModel.Instance.MarkupControls.Where(data => data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(a =>

            {

                ViewerDataModel.Instance.MarkupControls.Remove(a);

            });

            ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(a =>

            {

                ViewerDataModel.Instance.MarkupControls_USER.Remove(a);

            });

            ViewerDataModel.Instance.MarkupList_USER.Where(data => data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(a =>

            {

                ComingNewBieEnd = false;

                ViewerDataModel.Instance.MarkupList_USER.Remove(a);

                //임시파일에서도 삭제

                TempFile.DelTemp(a.ID, this.ParentOfType<MainWindow>().dzMainMenu.pageNavigator.CurrentPage.PageNumber.ToString());

            });

            gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;

            if (PreviewUserMarkupInfoItem == null && gridViewMarkup.SelectedItems.Where(d => (d as MarkupInfoItem).UserID == App.ViewInfo.UserID).FirstOrDefault() == null)

            {

                if (gridViewMarkup.Items.Cast<MarkupInfoItem>().ToList().Where(d => d.UserID == App.ViewInfo.UserID).Count() == 0)

                {

                    var infoId = Commons.shortGuid();

                    PreviewUserMarkupInfoItem = new MarkupInfoItem

                    {

                        CreateTime = DateTime.Now,

                        Depatment = userData.DEPARTMENT,

                        UpdateTime = DateTime.Now,

                        DisplayColor = "#FFFF0000",

                        UserID = userData.ID,

                        UserName = userData.NAME,

                        PageCount = 1,

                        Description = "",

                        MarkupInfoID = infoId,

                        MarkupList = null,

                        MarkupVersionID = Commons.shortGuid(),

                        Consolidate = 0,

                        PartConsolidate = 0,

                        userDelete = true,

                        AvoidConsolidate = 0,

                        IsPreviewUser = true

                    };

                    App.Custom_ViewInfoId = infoId;

                }

            }

            Logger.sendReqLog("DeleteMarkupAsync", App.ViewInfo.ProjectNO + "," + item.MarkupInfoID, 1);

            BaseClient.DeleteMarkupAsync(App.ViewInfo.ProjectNO, item.MarkupInfoID);

        }

        /// <summary>

        /// delete selected comments

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        public void DeleteCommentEvent(object sender, RoutedEventArgs e)

        {

            //선택된 어도너가 있을시 삭제가 되지 않음(강인구 추가)

            SelectionSet.Instance.UnSelect(this);

            Button content = (sender as Button);

            MarkupInfoItem item = content.CommandParameter as MarkupInfoItem;

            DeleteItem(item);

        }

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

        private static Timer timer;

        private int InitInterval = KCOM.Properties.Settings.Default.InitInterval;

        private void MainMenu_Loaded(object sender, RoutedEventArgs e)

        {

            InitializeComponent();

            //System.Diagnostics.Debug.WriteLine("MainMenu() : " + sw.ElapsedMilliseconds.ToString() + "ms");

            if (App.ParameterMode)

            {

                this.pageNavigator.PageChanging += pageNavigator_PageChanging;

                imageViewer_Compare = new Image();

                ViewerDataModel.Instance.Capture_Opacity = 0;

                da.From = 0.8;

                da.To = 0;

                da.Duration = new Duration(TimeSpan.FromSeconds(1));

                da.AutoReverse = true;

                da.RepeatBehavior = System.Windows.Media.Animation.RepeatBehavior.Forever;

                if (!App.ViewInfo.CreateFinalPDFPermission && !App.ViewInfo.NewCommentPermission)

                {

                    this.SymbolPane.Visibility = Visibility.Collapsed;

                    this.FavoritePane.Visibility = Visibility.Collapsed;

                    this.drawingRotateCanvas.IsHitTestVisible = false;

                }

            }

            timer = new Timer(timercallback, null, 0, InitInterval * 60000);

        }

        private void timercallback(Object o)

        {

            Stopwatch sw = new Stopwatch();

            sw.Start();

            TempFile.TempFileAdd();

            sw.Stop();

            Dispatcher.InvokeAsync(new Action(delegate

            {

               if (this.ParentOfType<MainWindow>().dzTopMenu.cbAutoSave.IsChecked == true) //Auto Save Checked?

                {

                    timer.Change(((int)this.ParentOfType<MainWindow>().dzTopMenu.cbSaveInterval.Value * 60000) / 2, sw.ElapsedMilliseconds); //Timer Setting

                }

            }));

            ////GC.Collect();

        }

        public List<CommentUserInfo> AddAdorner()

        {

            List<MarkupToPDF.Common.CommentUserInfo> adornerSet = new List<MarkupToPDF.Common.CommentUserInfo>();

            if (SelectLayer.Children.Count > 0)

            {

                foreach (var item in SelectLayer.Children)

                {

                    if (item.GetType().Name == "AdornerFinal")

                    {

                        (item as AdornerFinal).unRegister();

                        foreach (var InnerItem in (item as AdornerFinal).MemberSet.Cast<AdornerMember>())

                        {

                            if (!ViewerDataModel.Instance.MarkupControls_USER.Contains(InnerItem.DrawingData))

                            {

                                adornerSet.Add(InnerItem.DrawingData as CommentUserInfo);

                            }

                            Control_Style(InnerItem.DrawingData as CommentUserInfo);

                            UndoData.Markup_List.Add(multi_Undo_Data);

                            multi_Undo_Data = new Multi_Undo_data();

                        }

                    }

                }

                SelectLayer.Children.Clear();

            }

            return adornerSet;

        }

        public void ChangeCommentReact()

        {

            Logger.sendCheckLog("pageNavigator_PageChanging_ChangeCommentReact", 1);

            bool isComingNewBie = false;

            if (ViewerDataModel.Instance.MarkupControls_USER.Count > 0)

            {

                foreach (var control in ViewerDataModel.Instance.MarkupControls_USER)

                {

                    var root = MarkupParser.MarkupToString(control, App.ViewInfo.UserID);

                    var existItem = ViewerDataModel.Instance.MarkupList_USER.Where(data => data.ID == root.CommentID).FirstOrDefault();

                    if (existItem != null) //신규 추가 된 코멘트

                    {

                        if (existItem.Data != root.ConvertData) //코멘트가 같은지

                        {

                            existItem.Data = root.ConvertData;

                            existItem.IsUpdate = true;

                            ComingNewBieEnd = false;

                        }

                    }

                    else

                    {

                        if (root.CommentID != null)

                        {

                            isComingNewBie = true;

                            var currentCommentCheck = ViewerDataModel.Instance.MarkupList_USER.Where(dt => dt.ID == control.CommentID).FirstOrDefault();

                            if (currentCommentCheck != null)

                            {

                                currentCommentCheck.Data = root.ConvertData;

                            }

                            else

                            {

                                ViewerDataModel.Instance.MarkupList_USER.Add(new MarkupItemEx

                                {

                                    ID = control.CommentID,

                                    Data = root.ConvertData,

                                    Data_Type = root.DATA_TYPE,

                                    MarkupInfoID = App.Custom_ViewInfoId,

                                    PageNumber = this.pageNavigator.CurrentPage.PageNumber,

                                    Symbol_ID = control.SymbolID,

                                    Group_ID = control.GroupID,

                                });

                                ComingNewBieEnd = false;

                            }

                        }

                    }

                }

            }

            if (PreviewUserMarkupInfoItem != null && isComingNewBie && !ComingNewBieEnd)

            {

                if (ViewerDataModel.Instance._markupInfoList.Where(info => info.UserID == PreviewUserMarkupInfoItem.UserID).FirstOrDefault() == null)

                {

                    ComingNewBieEnd = true;

                    ViewerDataModel.Instance._markupInfoList.Insert(0, PreviewUserMarkupInfoItem);

                    PreviewUserMarkupInfoItem.IsPreviewUser = false;

                    gridViewMarkup.ItemsSource = null;

                    gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;

                    gridViewMarkup.SelectedItem = PreviewUserMarkupInfoItem;

                }

            }

        }

        bool ComingNewBieEnd = false;

        private void pageNavigator_PageChanging(object sender, Controls.Sample.PageChangeEventArgs e)

        {

            Logger.sendCheckLog("pageNavigator_PageChanging_Start", 1);

            if (ViewerDataModel.Instance.UndoDataList.Count > 0)

            {

                Logger.sendCheckLog("pageNavigator_PageChanging_이전페이지Save", 1);

                this.ParentOfType<MainWindow>().dzTopMenu.SaveEvent(null, null);

            }

            Logger.sendCheckLog("pageNavigator_PageChanging_UndoDataListClear", 1);

            ViewerDataModel.Instance.UndoDataList.Clear();

            InkControl_Convert();

            SelectionSet.Instance.UnSelect(this);

            ChangeCommentReact();

            Logger.sendCheckLog("pageNavigator_PageChanging_변수생성 및 값 설정", 1);

            CompareMode.IsChecked = false;

            var BalancePoint = ViewerDataModel.Instance.PageBalanceMode == true ? e.PageNumber + ViewerDataModel.Instance.PageBalanceNumber : e.PageNumber;

            #region 페이지가 벗어난 경우

            if (BalancePoint < 1)

            {

                BalancePoint = 1;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            if (pageNavigator.PageCount < BalancePoint)

            {

                BalancePoint = pageNavigator.PageCount;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            #endregion

            ViewerDataModel.Instance.PageNumber = BalancePoint;

            Logger.sendCheckLog("pageNavigator_PageChanging_페이지 Image url 설정", 1);

            string uri = "";

            if (userData.COMPANY != "EXT")

            {

                uri = String.Format(Properties.Settings.Default.mainServerImageWebPath, _ViewInfo.ProjectNO, (Convert.ToInt32(_ViewInfo.DocumentItemID) / 100).ToString(), _ViewInfo.DocumentItemID, e.PageNumber);

            }

            else

            {

                uri = String.Format(Properties.Settings.Default.subServerImageWebPath, _ViewInfo.ProjectNO, _ViewInfo.DocumentItemID, e.PageNumber);

            }

            var defaultBitmapImage = new BitmapImage();

            defaultBitmapImage.BeginInit();

            defaultBitmapImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;

            defaultBitmapImage.CacheOption = BitmapCacheOption.OnLoad;

            defaultBitmapImage.UriSource = new Uri(uri);

            defaultBitmapImage.EndInit();

            ViewerDataModel.Instance.ImageViewPath = null;

            GC.Collect();

            Logger.sendCheckLog("pageNavigator_PageChanging_BitmapImage Downloading", 1);

            if (defaultBitmapImage.IsDownloading)

            {

                Logger.sendCheckLog("pageNavigator_PageChanging_BitmapImage IsDownloading", 1);

                defaultBitmapImage.DownloadCompleted += (ex, arg) =>

                {

                    defaultBitmapImage.Freeze();

                    mainPanel.UpdateLayout();

                    GC.Collect();

                    ViewerDataModel.Instance.ImageViewPath = defaultBitmapImage;

                    ViewerDataModel.Instance.ImageViewWidth = defaultBitmapImage.PixelWidth;

                    ViewerDataModel.Instance.ImageViewHeight = defaultBitmapImage.PixelHeight;

                };

            }

            zoomAndPanCanvas.Width = Convert.ToDouble(e.CurrentPage.PAGE_WIDTH);

            zoomAndPanCanvas.Height = Convert.ToDouble(e.CurrentPage.PAGE_HEIGHT);

            Common.ViewerDataModel.Instance.ContentWidth = zoomAndPanCanvas.Width;

            Common.ViewerDataModel.Instance.ContentHeight = zoomAndPanCanvas.Height;

            inkBoard.Width = zoomAndPanCanvas.Width;

            inkBoard.Height = zoomAndPanCanvas.Height;

            if (!testPanel2.IsHidden)

            {

                Logger.sendCheckLog("pageNavigator_PageChanging_!testPanel2.IsHidden 일 때", 1);

                //PDF모드일때 잠시 대기(강인구)

                if (IsSyncPDFMode)

                {

                    Get_FinalImage.Get_PdfImage get_PdfImage = new Get_FinalImage.Get_PdfImage();

                    var pdfpath = new BitmapImage(new Uri(get_PdfImage.Run(CurrentRev.TO_VENDOR, App.ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.PageNumber)));

                    Logger.sendCheckLog("pageNavigator_PageChanging_pdfpath Image Downloading", 1);

                    if (pdfpath.IsDownloading)

                    {

                        pdfpath.DownloadCompleted += (ex, arg) =>

                        {

                            Logger.sendCheckLog("pageNavigator_PageChanging_pdfpath Image DownloadCompleted", 1);

                            ViewerDataModel.Instance.ImageViewPath_C = pdfpath;

                            ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;

                            ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;

                            zoomAndPanCanvas2.Width = pdfpath.PixelWidth;

                            zoomAndPanCanvas2.Height = pdfpath.PixelHeight;

                        };

                    }

                    else

                    {

                        Logger.sendCheckLog("pageNavigator_PageChanging_pdfpath Image Page Setting", 1);

                        ViewerDataModel.Instance.ImageViewPath_C = pdfpath;

                        ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;

                        ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;

                        zoomAndPanCanvas2.Width = pdfpath.PixelWidth;

                        zoomAndPanCanvas2.Height = pdfpath.PixelHeight;

                    }

                }

                else

                {

                    Logger.sendCheckLog("pageNavigator_PageChanging_uri2 값 설정", 1);

                    string uri2 = "";

                    if (userData.COMPANY != "EXT")

                    {

                        uri2 = String.Format(Properties.Settings.Default.mainServerImageWebPath, _ViewInfo.ProjectNO, (Convert.ToInt32(CurrentRev.DOCUMENT_ID) / 100).ToString(), CurrentRev.DOCUMENT_ID, BalancePoint);

                    }

                    else

                    {

                        uri2 = String.Format(Properties.Settings.Default.subServerImageWebPath, _ViewInfo.ProjectNO, CurrentRev.DOCUMENT_ID, BalancePoint);

                    }

                    Logger.sendCheckLog("pageNavigator_PageChanging_defaultBitmapImage_Compare BitmapImage 설정", 1);

                    var defaultBitmapImage_Compare = new BitmapImage(new Uri(uri2));

                    Logger.sendCheckLog("pageNavigator_PageChanging_zoomAndPanCanvas2 Page Setting", 1);

                    ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;

                    ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;

                    ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;

                    zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;

                    zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;

                    Logger.sendCheckLog("pageNavigator_PageChanging_zoomAndPanControl ZoomTo 설정", 1);

                    zoomAndPanControl.ZoomTo(new Rect

                    {

                        X = 0,

                        Y = 0,

                        Width = Math.Max(zoomAndPanCanvas.Width, zoomAndPanCanvas2.Width),

                        Height = Math.Max(zoomAndPanCanvas.Height, zoomAndPanCanvas2.Height),

                    });

                    Logger.sendCheckLog("pageNavigator_PageChanging_defaultBitmapImage_Compare Downloading", 1);

                    if (defaultBitmapImage_Compare.IsDownloading)

                    {

                        defaultBitmapImage_Compare.DownloadCompleted += (ex, arg) =>

                        {

                            Logger.sendCheckLog("pageNavigator_PageChanging_defaultBitmapImage_Compare DownloadCompleted", 1);

                            ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;

                            ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;

                            ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;

                            zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;

                            zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;

                            zoomAndPanControl.ZoomTo(new Rect

                            {

                                X = 0,

                                Y = 0,

                                Width = Math.Max(zoomAndPanCanvas.Width, zoomAndPanCanvas2.Width),

                                Height = Math.Max(zoomAndPanCanvas.Height, zoomAndPanCanvas2.Height),

                            });

                        };

                    }

                }

                tlSyncPageNum.Text = String.Format("Current Page : {0}", BalancePoint);

            }

            this.pageNavigator.SetNextPage();

            if (zoomAndPanCanvas2.Width.IsNaN())

            {

                zoomAndPanControl.ZoomTo(new Rect { X = 0, Y = 0, Width = zoomAndPanCanvas.Width, Height = zoomAndPanCanvas.Height });

            }

            Logger.sendCheckLog("pageNavigator_PageChanging_ControlData Setting", 1);

            Common.ViewerDataModel.Instance.MarkupControls_USER.Clear();  //전체 제거

            Common.ViewerDataModel.Instance.MarkupControls.Clear();  //전체 제거

            List<MarkupInfoItem> gridSelectionItem = gridViewMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList(); //선택 된 마크업

            foreach (var item in gridSelectionItem)

            {

                if (item.UserID == App.ViewInfo.UserID)

                {

                    ViewerDataModel.Instance.current_page_commentcnt = ViewerDataModel.Instance.MarkupList_USER.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList().Count;

                    ViewerDataModel.Instance.MarkupList_USER.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(delegate (MarkupItemEx markupitem)

                    {

                        MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, item.DisplayColor, "", 

                            item.MarkupInfoID, markupitem.ID);

                    });

                }

                else

                {

                    ViewerDataModel.Instance.MarkupList_Pre.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(delegate (MarkupItemEx markupitem)

                    {

                        MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls, item.DisplayColor, "", item.MarkupInfoID);

                    });

                }

            }

            if (!testPanel2.IsHidden)

            {

                ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;

                ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;

                ViewerDataModel.Instance.Sync_ContentScale = zoomAndPanControl.ContentScale;

                Common.ViewerDataModel.Instance.MarkupControls_Sync.Clear();

                List<MarkupInfoItem> gridSelectionRevItem = gridViewRevMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList();

                foreach (var item in gridSelectionRevItem)

                {

                    item.MarkupList.Where(pageItem => pageItem.PageNumber == BalancePoint).ToList().ForEach(delegate (MarkupItem markupitem)

                    {

                        MarkupParser.ParseEx(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, item.DisplayColor, "", item.MarkupInfoID);

                    });

                }

            }

            var instanceMain = this.ParentOfType<MainWindow>();

            instanceMain.dzTopMenu.tlcurrentPage.Text = e.CurrentPage.PAGE_NUMBER.ToString();

            instanceMain.dzTopMenu.tlcurrentPage_readonly.Text = e.CurrentPage.PAGE_NUMBER.ToString();

            instanceMain.dzTopMenu.rotateOffSet = 0;

            var pageinfo = this.CurrentDoc.docInfo.DOCPAGE.Where(p => p.PAGE_NUMBER == e.CurrentPage.PAGE_NUMBER).FirstOrDefault();

            drawingPannelRotate(pageinfo.PAGE_ANGLE);

            //}

            SetCommentPages(true);

        }

        private void SetCommentPages(bool onlyMe = false)

        {

            Logger.sendCheckLog("pageNavigator_PageChanging_SetCommentPages Setting", 1);

            List<UsersCommentPagesMember> _pages = new List<UsersCommentPagesMember>();

            foreach (var item in ViewerDataModel.Instance._markupInfoList)

            {

                UsersCommentPagesMember instance = new UsersCommentPagesMember();

                instance.UserName = item.UserName;

                instance.Depart = item.Depatment;

                instance.MarkupInfoID = item.MarkupInfoID;

                instance.IsSelected = true;

                instance.isConSolidation = item.Consolidate;

                instance.SetColor = item.DisplayColor;

                if (item.UserID == App.ViewInfo.UserID && item.MarkupInfoID == item.MarkupInfoID)

                {

                    instance.PageNumber = ViewerDataModel.Instance.MarkupList_USER.Select(d => d.PageNumber).ToList();

                }

                else

                {

                    instance.PageNumber = ViewerDataModel.Instance.MarkupList_Pre.Where(data => data.MarkupInfoID == item.MarkupInfoID).Select(d => d.PageNumber).ToList();

                }

                _pages.Add(instance);

            }

            this.pageNavigator.SetCommentList(_pages.ToList());

        }

        private void zoomAndPanControl_MouseWheel(object sender, MouseWheelEventArgs e)

        {

            if (e.MiddleButton == MouseButtonState.Pressed)

            {

            }

            e.Handled = true;

            if (e.Delta > 0)

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas);

                ZoomIn(currentContentMousePoint);

            }

            else

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas);

                ZoomOut(currentContentMousePoint);

            }

        }

        private void zoomAndPanControl2_MouseWheel(object sender, MouseWheelEventArgs e)

        {

            e.Handled = true;

            if (e.Delta > 0)

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas2);

                ZoomIn_Sync(currentContentMousePoint);

            }

            else

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas2);

                ZoomOut_Sync(currentContentMousePoint);

            }

        }

        #region ZoomIn & ZoomOut

        private void ZoomOut_Executed(object sender, ExecutedRoutedEventArgs e)

        {

            ZoomOut(new Point(zoomAndPanControl.ContentZoomFocusX,

                zoomAndPanControl.ContentZoomFocusY));

        }

        private void ZoomIn_Executed(object sender, ExecutedRoutedEventArgs e)

        {

            ZoomIn(new Point(zoomAndPanControl.ContentZoomFocusX,

                zoomAndPanControl.ContentZoomFocusY));

        }

        //강인구 추가 (줌 인아웃 수치 변경)

        //큰해상도의 문서일 경우 줌 인 아웃시 사이즈 변동이 큼

        private void ZoomOut(Point contentZoomCenter)

        {

            if (zoomAndPanControl.ContentScale > 0.39)

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale - 0.2, contentZoomCenter);

            }

            else

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale / 2, contentZoomCenter);

            }

            if (zoomAndPanControl2 != null && Sync.IsChecked)

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomIn(Point contentZoomCenter)

        {

            if (zoomAndPanControl.ContentScale > 0.19)

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale + 0.2, contentZoomCenter);

            }

            else

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl.ContentScale * 2, contentZoomCenter);

            }

            if (zoomAndPanControl2 != null && Sync.IsChecked)

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomOut_Sync(Point contentZoomCenter)

        {

            if (zoomAndPanControl2.ContentScale > 0.39)

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale - 0.2, contentZoomCenter);

            }

            else

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale / 2, contentZoomCenter);

            }

            if (Sync.IsChecked)

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl2.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomIn_Sync(Point contentZoomCenter)

        {

            if (zoomAndPanControl2.ContentScale > 0.19)

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale + 0.2, contentZoomCenter);

            }

            else

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl2.ContentScale * 2, contentZoomCenter);

            }

            if (Sync.IsChecked)

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl2.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomOut()

        {

            zoomAndPanControl.ContentScale -= 0.1;

            //if (zoomAndPanControl2 != null)

            //{

            //    zoomAndPanControl2.ContentScale -= 0.1;

            //}

        }

        private void ZoomIn()

        {

            zoomAndPanControl.ContentScale += 0.1;

            //if (zoomAndPanControl2 != null)

            //{

            //    zoomAndPanControl2.ContentScale += 0.1;

            //}

        }

        #endregion

        private void init()

        {

            foreach (var item in ViewerDataModel.Instance.MarkupControls)

            {

                ControlList.Clear();

                listBox.Items.Clear();

                selected_item.Clear();

                (item as IMarkupCommonData).IsSelected = false;

            }

        }

        private HitTestResultBehavior MyCallback(HitTestResult result)

        {

            //this.cursor = Cursors.UpArrow;

            var element = result.VisualHit;

            while (element != null && !(element is CommentUserInfo))

                element = VisualTreeHelper.GetParent(element);

            if (element == null)

            {

                return HitTestResultBehavior.Stop;

            }

            else

            {

                if (element is CommentUserInfo)

                {

                    if (!hitList.Contains(element))

                    {

                        hitList.Add((CommentUserInfo)element);

                    }

                    else

                    {

                        return HitTestResultBehavior.Stop;

                    }

                    //IntersectionDetail intersectionDetail =

                    //((GeometryHitTestResult)result).IntersectionDetail;

                    //switch (intersectionDetail)

                    //{

                    //    case IntersectionDetail.FullyContains:

                    //        // Add the hit test result to the list:

                    //        hitList.Add((CommentUserInfo)result.VisualHit);

                    //        return HitTestResultBehavior.Continue;

                    //    case IntersectionDetail.Intersects:

                    //        // Set the behavior to return visuals at all z-order levels:

                    //        return HitTestResultBehavior.Continue;

                    //    case IntersectionDetail.FullyInside:

                    //        // Set the behavior to return visuals at all z-order levels:

                    //        return HitTestResultBehavior.Continue;

                    //    default:

                    //        return HitTestResultBehavior.Stop;

                    //}

                }

            }

            return HitTestResultBehavior.Continue;

        }

        public void ReleaseSelectPath()

        {

            if (SelectionPath == null)

            {

                SelectionPath = new Path();

                SelectionPath.Name = "";

            }

            if (SelectionPath.Name != "")

            {

                SelectionPath.Name = "None";

            }

            SelectionPath.Opacity = 0.01;

            SelectionPath.RenderTransform = null;

            SelectionPath.RenderTransformOrigin = new Point(0, 0);

        }

        #region 컨트롤 초기화 

        public void Control_Init(object control)

        {

            if (L_Size != 0 && (control as IPath) != null)

            {

                (control as IPath).LineSize = L_Size;

                L_Size = 0;

            }

            switch (control.GetType().Name)

            {

                case "RectangleControl":

                    {

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

                    }

                    break;

                case "CircleControl":

                    {

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

                    }

                    break;

                case "TriControl":

                    {

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

                    }

                    break;

                case "RectCloudControl":

                    {

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

                    }

                    break;

                case "CloudControl":

                    {

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

                    }

                    break;

                case "PolygonControl":

                    {

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

                    }

                    break;

                case "ArcControl":

                    {

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

                    }

                    break;

                case "ArrowArcControl":

                    {

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

                    }

                    break;

                case "LineControl":

                    {

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

                    }

                    break;

                case "ArrowControl_Multi":

                    {

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

                    }

                    break;

                case "TextControl":

                    {

                        (control as TextControl).BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

                    }

                    break;

                case "ArrowTextControl":

                    {

                        (control as ArrowTextControl).BackInnerColor = new SolidColorBrush(Color.FromArgb(Convert.ToByte(255 * 0.6), Colors.White.R, Colors.White.G, Colors.White.B));

                    }

                    break;

                case "InsideWhiteControl":

                    {

                        (control as InsideWhiteControl).StrokeColor = Brushes.White;

                    }

                    break;

                case "OverlapWhiteControl":

                    {

                        (control as OverlapWhiteControl).StrokeColor = Brushes.White;

                    }

                    break;

                case "ClipWhiteControl":

                    {

                        (control as ClipWhiteControl).StrokeColor = Brushes.White;

                    }

                    break;

                case "CoordinateControl":

                    {

                        (control as CoordinateControl).StrokeColor = Brushes.Black;

                    }

                    break;

            }

        }

        #endregion

        public void firstCondition_MouseLeave(object sender, MouseEventArgs e)

        {

            //Control_Init(e.Source);

        }

        private Window _dragdropWindow = null;

        [DllImport("user32.dll")]

        [return: MarshalAs(UnmanagedType.Bool)]

        internal static extern bool GetCursorPos(ref Win32Point pt);

        [StructLayout(LayoutKind.Sequential)]

        internal struct Win32Point

        {

            public Int32 X;

            public Int32 Y;

        };

        public string symbol_id = null;

        public long symbol_group_id;

        public int symbol_SelectedIndex;

        public ImageSource symbol_img;

        public string symbol_Data = null;

        public void symboldata(string id, long group_id, int SelectedIndex, string Data_, ImageSource img)

        {

            if (this._dragdropWindow != null)

            {

                this._dragdropWindow.Close();

                this._dragdropWindow = null;

            }

            symbol_id = id;

            symbol_group_id = group_id;

            symbol_SelectedIndex = SelectedIndex;

            symbol_Data = Data_;

            symbol_img = img;

            CreateDragDropWindow2(img);

        }

        private void CreateDragDropWindow2(ImageSource image)

        {

            this._dragdropWindow = new Window();

            _dragdropWindow.Cursor = new Cursor(MainWindow.CursorChange().StreamSource);

            _dragdropWindow.WindowStyle = WindowStyle.None;

            _dragdropWindow.AllowsTransparency = true;           

            _dragdropWindow.AllowDrop = false;

            _dragdropWindow.Background = null;

            _dragdropWindow.IsHitTestVisible = false;

            _dragdropWindow.SizeToContent = SizeToContent.WidthAndHeight;

            _dragdropWindow.Topmost = true;

            _dragdropWindow.ShowInTaskbar = false;

            Rectangle r = new Rectangle();

            r.Width = image.Width;

            r.Height = image.Height;

            r.Opacity = 0.5;            

            r.Fill = new ImageBrush(image);

            this._dragdropWindow.Content = r;

            Win32Point w32Mouse = new Win32Point();

            GetCursorPos(ref w32Mouse);

            //w32Mouse.X = getCurrentPoint.X;

            this._dragdropWindow.Left = w32Mouse.X - (image.Width / 2);

            this._dragdropWindow.Top = w32Mouse.Y - (image.Height / 2); 

            this._dragdropWindow.Show();

        }

        private void zoomAndPanControl_MouseMove(object sender, MouseEventArgs e)

        {

            if (Common.ViewerDataModel.Instance.SelectedControl == "Batch")

            {

                if (!floatingTip.IsOpen) { floatingTip.IsOpen = true; }

                Point currentPos = e.GetPosition(rect);

                floatingTip.HorizontalOffset = currentPos.X + 20;

                floatingTip.VerticalOffset = currentPos.Y;

                //ToolTip tool = new System.Windows.Controls.ToolTip();

                //tool.Content = "ToolTip";

                //panel.ToolTip = tool;

            }

            if (mouseHandlingMode != MouseHandlingMode.Drawing)

            {

                #region 마우스 오버 시 색상 변경

                //var firstCondition = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.IsMouseOver).FirstOrDefault();

                //Color TempColor = MarkupToPDF.Controls.Common.ValueConverter.StringToColorConverter.Parse("FF07B4FF");

                //if (firstCondition != null)

                //{

                //    firstCondition.MouseLeave += new System.Windows.Input.MouseEventHandler(firstCondition_MouseLeave);

                //    if (firstCondition.GetType().Name == "TextControl")

                //    {

                //        (firstCondition as TextControl).BackInnerColor = new SolidColorBrush(TempColor);

                //        return;

                //    }

                //    else if (firstCondition.GetType().Name == "ArrowTextControl")

                //    {

                //        (firstCondition as ArrowTextControl).BackInnerColor = new SolidColorBrush(TempColor);

                //        return;

                //    }

                //    if (L_Size == 0)

                //    {

                //        L_Size = (firstCondition as IPath).LineSize;

                //        (firstCondition as IPath).LineSize *= 4;

                //    }

                //    switch (firstCondition.GetType().Name)

                //    {

                //        case "RectangleControl":

                //            {

                //                (firstCondition as RectangleControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "CircleControl":

                //            {

                //                (firstCondition as CircleControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "TriControl":

                //            {

                //                (firstCondition as TriControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "RectCloudControl":

                //            {

                //                (firstCondition as RectCloudControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "CloudControl":

                //            {

                //                (firstCondition as CloudControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "PolygonControl":

                //            {

                //                (firstCondition as PolygonControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "ArcControl":

                //            {

                //                (firstCondition as ArcControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "LineControl":

                //            {

                //                (firstCondition as LineControl).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        case "ArrowControl_Multi":

                //            {

                //                (firstCondition as ArrowControl_Multi).StrokeColor = new SolidColorBrush(TempColor);

                //            }

                //            break;

                //        default:

                //            {

                //            }

                //            break;

                //    }

                //} 

                #endregion

            }

            getCurrentPoint = e.GetPosition(drawingRotateCanvas);

            #region 주석

            //if (mouseButtonDown == MouseButton.Middle)

            //{

            //    SetCursor();

            //    Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

            //    Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

            //    Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

            //    zoomAndPanControl.ContentOffsetX -= dragOffset.X;

            //    zoomAndPanControl.ContentOffsetY -= dragOffset.Y;

            //    //SetCursor();

            //    //Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

            //    //Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

            //    //Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

            //    //zoomAndPanControl.ContentOffsetX += 1;

            //    //zoomAndPanControl.ContentOffsetY += 1;

            //    //zoomAndPanControl.ContentOffsetX += dragOffset.X;

            //    //zoomAndPanControl.ContentOffsetY += dragOffset.Y;

            //}

            #endregion

            if ((mouseButtonDown == MouseButton.Middle) || (mouseButtonDown == MouseButton.Right))

            {

                SetCursor();

                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

                Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

                zoomAndPanControl.ContentOffsetX -= dragOffset.X;

                zoomAndPanControl.ContentOffsetY -= dragOffset.Y;

                if (Sync.IsChecked)

                {

                    ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;

                    ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;

                }

            }

            if (mouseHandlingMode == MouseHandlingMode.Drawing && mouseButtonDown == MouseButton.Left)

            {

                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

                SetCursor();

                if (IsDrawing)

                {

                    if (currentControl == null)

                    {

                        switch (controlType)

                        {

                            case ControlType.PenControl:

                                {

                                    if (inkBoard.Tag.ToString() == "Ink")

                                    {

                                        stroke.StylusPoints.Add(new StylusPoint(currentCanvasDrawingMouseMovePoint.X, currentCanvasDrawingMouseMovePoint.Y));

                                    }

                                    else if (inkBoard.Tag.ToString() == "EraseByPoint")

                                    {

                                        RemovePointStroke(currentCanvasDrawingMouseMovePoint);

                                    }

                                    else if (inkBoard.Tag.ToString() == "EraseByStroke")

                                    {

                                        RemoveLineStroke(currentCanvasDrawingMouseMovePoint);

                                    }

                                    //inkBoard.Strokes.Add(stroke);

                                }

                                break;

                        }

                        return;

                    }

                }

                if (currentControl != null)

                {

                    double moveX = currentCanvasDrawingMouseMovePoint.X - canvasDrawingMouseDownPoint.X;

                    double moveY = currentCanvasDrawingMouseMovePoint.Y - canvasDrawingMouseDownPoint.Y;

                    //강인구 추가

                    currentControl.Opacity = ViewerDataModel.Instance.ControlOpacity;

                    if ((currentControl as IPath) != null)

                    {

                        (currentControl as IPath).LineSize = ViewerDataModel.Instance.LineSize;

                    }

                    if ((currentControl as LineControl) != null)

                    {

                        (currentControl as LineControl).Interval = ViewerDataModel.Instance.Interval;

                    }

                    if ((currentControl as IShapeControl) != null)

                    {

                        (currentControl as IShapeControl).Paint = ViewerDataModel.Instance.paintSet;

                    }

                    if ((currentControl as TextControl) != null)

                    {

                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnItalic.IsChecked == true)

                        {

                            (currentControl as TextControl).TextStyle = FontStyles.Italic;

                        }

                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnBold.IsChecked == true)

                        {

                            (currentControl as TextControl).TextWeight = FontWeights.Bold;

                        }

                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnUnderLine.IsChecked == true)

                        {

                            (currentControl as TextControl).UnderLine = TextDecorations.Underline;

                        }

                    }

                    else if ((currentControl as ArrowTextControl) != null)

                    {

                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnItalic.IsChecked == true)

                        {

                            (currentControl as ArrowTextControl).TextStyle = FontStyles.Italic;

                        }

                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnBold.IsChecked == true)

                        {

                            (currentControl as ArrowTextControl).TextWeight = FontWeights.Bold;

                        }

                        if (this.ParentOfType<MainWindow>().dzTopMenu.btnUnderLine.IsChecked == true)

                        {

                            (currentControl as ArrowTextControl).UnderLine = TextDecorations.Underline;

                        }

                    }

                    else if ((currentControl as RectCloudControl) != null)

                    {

                        (currentControl as RectCloudControl).ArcLength = ViewerDataModel.Instance.ArcLength;

                    }

                    else if ((currentControl as CloudControl) != null)

                    {

                        (currentControl as CloudControl).ArcLength = ViewerDataModel.Instance.ArcLength;

                    }

                    switch (controlType)

                    {

                        case (ControlType.Coordinate):

                            {

                                var control = currentControl as CoordinateControl;

                                if (control != null)

                                {

                                    if (move.mousemode == MouseMode.Drawing)

                                    {

                                        //move.control_Move(ControlList, true, moveX, moveY);

                                    }

                                    else

                                    {

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

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

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

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

                                        if (ViewerDataModel.Instance.IsPressShift)

                                        {

                                            Point setpoint = GetSquareEndPoint(control.StartPoint, control.EndPoint);

                                            control.LeftBottomPoint = new Point(control.LeftBottomPoint.X, setpoint.Y);

                                            control.TopRightPoint = new Point(setpoint.X, control.TopRightPoint.Y);

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

                                        }

                                        control.PointSet = new List<Point>

                                        {

                                            control.StartPoint,

                                            control.LeftBottomPoint,

                                            control.EndPoint,

                                            control.TopRightPoint,

                                        };

                                        control.updateControl();

                                    }

                                    //강인구 추가

                                    control.ControlType = controlType;

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.Paint = ViewerDataModel.Instance.paintSet;

                                    //  control.Paint = PaintSet.Fill;

                                }

                            }

                            break;

                        case (ControlType.InsideWhite):

                            {

                                var control = currentControl as InsideWhiteControl;

                                if (control != null)

                                {

                                    if (move.mousemode == MouseMode.Drawing)

                                    {

                                        //move.control_Move(ControlList, true, moveX, moveY);

                                    }

                                    else

                                    {

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

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

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

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

                                        if (ViewerDataModel.Instance.IsPressShift)

                                        {

                                            Point setpoint = GetSquareEndPoint(control.StartPoint, control.EndPoint);

                                            control.LeftBottomPoint = new Point(control.LeftBottomPoint.X, setpoint.Y);

                                            control.TopRightPoint = new Point(setpoint.X, control.TopRightPoint.Y);

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

                                        }

                                        control.PointSet = new List<Point>

                                        {

                                            control.StartPoint,

                                            control.LeftBottomPoint,

                                            control.EndPoint,

                                            control.TopRightPoint,

                                        };

                                        control.updateControl();

                                    }

                                    //강인구 추가

                                    control.ControlType = controlType;

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.Paint = ViewerDataModel.Instance.paintSet;

                                    control.Paint = PaintSet.Fill;

                                }

                            }

                            break;

                        case (ControlType.OverlapWhite):

                            {

                                var control = currentControl as OverlapWhiteControl;

                                if (control != null)

                                {

                                    if (move.mousemode == MouseMode.Drawing)

                                    {

                                        //move.control_Move(ControlList, true, moveX, moveY);

                                    }

                                    else

                                    {

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

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

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

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

                                        if (ViewerDataModel.Instance.IsPressShift)

                                        {

                                            Point setpoint = GetSquareEndPoint(control.StartPoint, control.EndPoint);

                                            control.LeftBottomPoint = new Point(control.LeftBottomPoint.X, setpoint.Y);

                                            control.TopRightPoint = new Point(setpoint.X, control.TopRightPoint.Y);

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

                                        }

                                        control.PointSet = new List<Point>

                                        {

                                            control.StartPoint,

                                            control.LeftBottomPoint,

                                            control.EndPoint,

                                            control.TopRightPoint,

                                        };

                                        control.updateControl();

                                    }

                                    //강인구 추가

                                    control.ControlType = controlType;

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.Paint = ViewerDataModel.Instance.paintSet;

                                    control.Paint = PaintSet.Fill;

                                }

                            }

                            break;

                        case (ControlType.ClipWhite):

                            {

                                var control = currentControl as ClipWhiteControl;

                                if (control != null)

                                {

                                    if (move.mousemode == MouseMode.Drawing)

                                    {

                                        //move.control_Move(ControlList, true, moveX, moveY);

                                    }

                                    else

                                    {

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

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

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

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

                                        if (ViewerDataModel.Instance.IsPressShift)

                                        {

                                            Point setpoint = GetSquareEndPoint(control.StartPoint, control.EndPoint);

                                            control.LeftBottomPoint = new Point(control.LeftBottomPoint.X, setpoint.Y);

                                            control.TopRightPoint = new Point(setpoint.X, control.TopRightPoint.Y);

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

                                        }

                                        control.PointSet = new List<Point>

                                        {

                                            control.StartPoint,

                                            control.LeftBottomPoint,

                                            control.EndPoint,

                                            control.TopRightPoint,

                                        };

                                        control.updateControl();

                                    }

                                    //강인구 추가

                                    control.ControlType = controlType;