MARKUS

using IKCOM;

using KCOM.Common;

using KCOM.Controls;

using KCOM.Events;

using KCOMDataModel.DataModel;

using MarkupToPDF.Common;

using MarkupToPDF.Controls.Cad;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Controls.Etc;

using MarkupToPDF.Controls.Line;

using MarkupToPDF.Controls.Parsing;

using MarkupToPDF.Controls.Polygon;

using MarkupToPDF.Controls.Shape;

using MarkupToPDF.Controls.Text;

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Diagnostics;

using System.Linq;

using System.Reflection;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Web;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Media.Imaging;

using System.Windows.Shapes;

using System.Windows.Threading;

using Telerik.Windows.Controls;

using Telerik.Windows.Controls.GridView;

using Telerik.Windows.Data;

using ZoomAndPan;

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 프로퍼티

        private BitmapFrame tempPageImage = null;

        public UndoDataGroup UndoDataGroup { get; set; }

        public CommentUserInfo previousControl { get; set; }

        public CommentUserInfo currentControl { get; set; }

        public ControlType controlType { get; set; }

        public MouseHandlingMode mouseHandlingMode { get; set; } = MouseHandlingMode.None;

        private static readonly double DragThreshold = 5;

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

        /// <summary>

        ///  문서의 마우스 위치

        /// </summary>

        public Point CanvasDrawingMouseDownPoint;

        public string filename { get; set; }

        private Point canvasZoomPanningMouseDownPoint { get; set; }

        private Point zoomAndPanControlMouseDownPoint { get; set; }

        public Point getCurrentPoint;

        private Point canvasZoommovingMouseDownPoint;

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

        private ListBox listBox = new ListBox();

        private bool isDraggingSelectionRect = false;

        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 UndoData multi_UndoData;

        public string Symbol_ID = "";

        public event EventHandler<EventArgs> MarkupLoadComplated;

        /// <summary>

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

        /// </summary>

        public bool isLeftMouseButtonDownOnWindow = false;

        public InkPresenter _InkBoard = null;

        private Stroke stroke;

        private Boolean IsDrawing = false;

        private StylusPointCollection strokePoints;

        //StylusPointCollection erasePoints;

        private RenderTargetBitmap canvasImage;

        private Point Sync_Offset_Point;

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

        {

            //App.splashString(ISplashMessage.MAINMENU_0);

            InitializeComponent();

            tempPageImage = BitmapFrame.Create(new Uri(@"pack://application:,,,/KCOM;component/Resources/Images/ExtImage/blank.png"), BitmapCreateOptions.None, BitmapCacheOption.OnLoad);

            //List<testItem> testItems = new List<testItem>

            //{

            //    new testItem{Title = "test1"},

            //    new testItem{Title = "test2"},

            //    new testItem{Title = "test3"},

            //    new testItem{Title = "test4"},

            //};

            //lstSymbolPrivate.ItemsSource = testItems;

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

        }

        public void SetCursor()

        {

            this.Cursor = cursor;

        }

        /// <summary>

        /// get image url

        /// </summary>

        /// <author>humkyung</author>

        /// <param name="sDocumentID"></param>

        /// <returns></returns>

        public string GetImageURL(string sDocumentID, int iPageNo)

        {

            string uri = string.Empty;

            string sFolder = sDocumentID.All(char.IsDigit) ? (Convert.ToUInt64(sDocumentID) / 100).ToString() : (sDocumentID.Length >= 5 ? sDocumentID.Substring(0, 5) : sDocumentID);

            if (userData.COMPANY != "EXT")

            {

                uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, sFolder, sDocumentID, iPageNo);

            }

            else

            {

                uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, sDocumentID, iPageNo);

            }

            return uri;

        }

        /// <summary>

        /// 외부망에서의 Original PDF Download 를 위한 리소스 web path 경로로 치환

        /// </summary>

        /// <returns></returns>

        public string GetOriginalPDFURL()

        {

            string uri = string.Empty;

            string sDocumentID = this._DocItem.DOCUMENT_ID;

            string filename = string.Empty;

            if (this._DocInfo.ORIGINAL_FILE.Contains("fileName"))

            {

                filename = HttpUtility.ParseQueryString(this._DocInfo.ORIGINAL_FILE).Get("fileName");

            }

            else

            {

                filename = System.IO.Path.GetFileName(this._DocInfo.ORIGINAL_FILE);

            }

            var directUri = CommonLib.Common.GetConfigString("DocumentDownloadPath", "url", "");

            if (!string.IsNullOrWhiteSpace(directUri))

            {

                uri = string.Format(directUri, filename);

            }

            else

            {

                string sFolder = sDocumentID.All(char.IsDigit) ? (Convert.ToUInt64(sDocumentID) / 100).ToString() : (sDocumentID.Length >= 5 ? sDocumentID.Substring(0, 5) : sDocumentID);

                if (userData.COMPANY != "EXT")

                {

                    uri = String.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, sFolder, sDocumentID, filename);

                }

                else

                {

                    uri = String.Format(CommonLib.Common.GetConfigString("subServerImageWebPath", "URL", "", App.isExternal), _ViewInfo.ProjectNO, sDocumentID, filename);

                }

                uri = uri.Replace(".png", "");

            }

            return uri;

        }

        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;

        }

        /// <summary>

        /// 주어진 레이어를 삭제한다.

        /// </summary>

        /// <param name="item"></param>

        public void DeleteItem(MarkupInfoItem item)

        {

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

            {

                App.Custom_ViewInfoId = PreviewUserMarkupInfoItem.MarkupInfoID;

            }

            #region Consolidate 또는 AvoidConsolidate한 레이어만 삭제한다. Team Consolidate 추가

            if (item.Consolidate == 1 || item.AvoidConsolidate == 1 || item.PartConsolidate == 1)

            {

                ViewerDataModel.Instance._markupInfoList.Remove(item);

                if (item.PartConsolidate == 1)

                {

                    if (ViewerDataModel.Instance._markupInfoList.Where(x => x.UserID == App.ViewInfo.UserID && x.PartConsolidate == 1).Count() > 0)

                    {

                        foreach (var comment in ViewerDataModel.Instance._markupInfoList.Where(x => x.UserID == App.ViewInfo.UserID && x.PartConsolidate == 1))

                        {

                            comment.userDelete = true;

                        }

                    }

                    else

                    {

                        foreach (var comment in ViewerDataModel.Instance._markupInfoList.Where(x => x.UserID == App.ViewInfo.UserID))

                        {

                            comment.userDelete = true;

                        }

                    }

                }

                gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;

                gridViewMarkup.Rebind();

            }

            #endregion

            #region 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.SystemMain.dzMainMenu.pageNavigator.MarkupListUpdate(

                null, EventType.Delete, a.CommentID, null);

            });

            #endregion

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

            {

                ViewerDataModel.Instance.MyMarkupList.Remove(a);

                //임시파일에서도 삭제

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

            });

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

            {

                if (!gridViewMarkup.Items.Cast<MarkupInfoItem>().Any(d => d.UserID == App.ViewInfo.UserID))

                {

                    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;

                }

            }

            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)

        {

            //ReadOnly 권한이 어떻게 들어오는지 모르겠음.

            //NewCommentPermission으로 일단 처리 함. (2024-06-05 IRON)

            if (App.ViewInfo.NewCommentPermission)

            {

                //정말 삭제 하시겠습니까?

                DialogParameters parameters = new DialogParameters()

                {

                    Owner = Application.Current.MainWindow,

                    Content = new TextBlock()

                    {

                        MinWidth = 400,

                        FontSize = 11,

                        Text = "Are you sure you want to delete?",

                        TextWrapping = System.Windows.TextWrapping.Wrap

                    },

                    Header = "Confirm",

                    Theme = new VisualStudio2013Theme(),

                    ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },

                    OkButtonContent = "Yes",

                    CancelButtonContent = "No",

                    Closed = delegate (object windowSender, WindowClosedEventArgs wc)

                    {

                        if (wc.DialogResult == true)

                        {

                            //선택된 어도너가 있을시 삭제가 되지 않음

                            SelectionSet.Instance.UnSelect(this);

                            Button content = (sender as Button);

                            MarkupInfoItem item = content.CommandParameter as MarkupInfoItem;

                            DeleteItem(item);

                        }

                    }

                };

                RadWindow.Confirm(parameters);

            }

        }

        private 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 ContextMenu m_ContextMenu = null;

        private void MainMenu_Loaded(object sender, RoutedEventArgs e)

        {

            //InitializeComponent();

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

            if (App.ParameterMode)

            {

                App.splashString(ISplashMessage.MAINMENU_1);

                this.pageNavigator.ThumbInitialized += pageNavigator_ThumbInitialized;

                this.pageNavigator.PageChanging += pageNavigator_PageChanging;

                this.pageNavigator.PageChanged += PageNavigator_PageChanged;

                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;

                }

                thumbnailPanel.Width = Convert.ToInt32(CommonLib.Common.GetConfigString("SetThumbnail", "WIDTH", "250"));

                InitContextMenu();

            }

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

        }

        /// <summary>

        /// 검색을 위해 원본 PDF 파일을 다운로드한다.

        /// </summary>

        private void DownloadOriginalFile()

        {

            #region 임시파일 다운로드

            instnaceFile = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "MARKUS", System.IO.Path.GetRandomFileName().Split('.')[0] + ".pdf");

            var directUri = CommonLib.Common.GetConfigString("DocumentDownloadPath", "url", "");

            bool isRestDownload = Convert.ToBoolean(CommonLib.Common.GetConfigString("DocumentDownloadPath", "IsRest", "False"));

            if (!string.IsNullOrWhiteSpace(directUri))

            {

                if (directUri.ToLower() == "full")

                {

                    downloadurl = this._DocInfo.ORIGINAL_FILE;

                }

                else

                {

                    isRestDownload = true;

                    filename = System.IO.Path.GetFileName(this._DocInfo.ORIGINAL_FILE);

                    downloadurl = string.Format(directUri, filename);

                }

            }

            else

            {

                downloadurl = GetOriginalPDFURL();

            }

            ViewerDataModel.Instance.OriginalTempFile = instnaceFile;

            string endpoint = Common.Commons.ShortGuid() + "file";

            IIpc.WcfServer wcfServer = new IIpc.WcfServer(endpoint);

            wcfServer.IpcFileDownloadReceived += WcfServer_IpcFileDownloadReceived;

            wcfServer.Start();

            DownloadProcess.FileDownloader(endpoint, ViewerDataModel.Instance.IsAdmin, downloadurl, instnaceFile, isRestDownload);

            #endregion

        }

        string instnaceFile;

        string downloadurl;

        private void WcfServer_IpcFileDownloadReceived(object sender, IIpc.IpcDownloadStatusArgs e)

        {

            try

            {

                Dispatcher.BeginInvoke((Action)delegate ()

                {

                    if ((sender as IIpc.WcfServer).IsOpen)

                    {

                        ViewerDataModel.Instance.DownloadFileProgress = (int)e.Progress;

                    }

                });

                if ((sender as IIpc.WcfServer).IsOpen)

                {

                    if (e.IsFinish)

                    {

                        ViewerDataModel.Instance.SystemMain.dzMainMenu.searchPanel_Instance.SetSerachPDFFile(instnaceFile);

                        ViewerDataModel.Instance.IsDownloadOriginal = true;

                        (sender as IIpc.WcfServer).Stop();

                        (sender as IIpc.WcfServer).IpcFileDownloadReceived -= WcfServer_IpcFileDownloadReceived;

                    }

                }

            }

            catch (Exception ex)

            {

                throw;

            }

        }

        /// <summary>

        /// update my markuplist

        ///  - update existing markup data if already exist

        ///  - add new markup data if control is new

        /// </summary>

        public void UpdateMyMarkupList()

        {

            Logger.sendCheckLog("pageNavigator_PageChanging_ChangeCommentReact", 1);

            #region 선택된 객체를 선택 해제한다.(그래야 작업 내용이 적용됨)

            SelectionSet.Instance.UnSelect(Common.ViewerDataModel.Instance.SystemMain.dzMainMenu);

            #endregion

            /// add or update markup list

            foreach (var control in ViewerDataModel.Instance.MarkupControls_USER)

            {

                #region Index를 저장한다.

                control.Index = ViewerDataModel.Instance.MarkupControls_USER.IndexOf(control);

                #endregion

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

                var exist = ViewerDataModel.Instance.MyMarkupList.Find(data => data.ID == markup.CommentID);

                #region 기존 코멘트

                if (exist != null)

                {

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

                    {

                        exist.Data = markup.ConvertData;

                        exist.ZIndex = control.ZIndex;

                        exist.IsUpdate = true;

                    }

                }

                #endregion

                else if (markup.CommentID != null)

                {

                    ViewerDataModel.Instance.MyMarkupList.Add(new MarkupItemEx

                    {

                        ID = control.CommentID,

                        Data = markup.ConvertData,

                        Data_Type = markup.DATA_TYPE,

                        MarkupInfoID = App.Custom_ViewInfoId,

                        PageNumber = this.pageNavigator.CurrentPage.PageNumber,

                        Symbol_ID = control.SymbolID,

                        ZIndex = control.ZIndex,

                    });

                }

            }

        }

        /// <summary>

        /// start page changing

        ///  - save controls if page is modified

        ///  - starting download page image

        /// </summary>

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

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

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

        {

            System.Diagnostics.Debug.WriteLine("pageNavigator PageChanging");

            //    await PageLoadAsync(e.CurrentPage,e.PageNumber);

            //}

            //private async Task PageLoadAsync(DOCPAGE page, int PageNo)

            //{

            DOCPAGE page = e.CurrentPage;

            int PageNo = e.PageNumber;

            ViewerDataModel.Instance.PageAngle = page.PAGE_ANGLE;

            // 페이지 이미지 변경

            /// 컨트롤을 새로 생성한다.

            ViewerDataModel.Instance.ImageViewPath = tempPageImage;

            ViewerDataModel.Instance.ImageViewWidth = 1;

            ViewerDataModel.Instance.ImageViewHeight = 1;

            ViewerDataModel.Instance.SystemMain.dzMainMenu.SelectLayer.Children.Clear();

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

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

            await PageChangingAsync(page, PageNo, ViewerDataModel.Instance.NewPagImageCancelToken());

            await MarkupLoadAsync(PageNo, ViewerDataModel.Instance.PageAngle, ViewerDataModel.Instance.NewMarkupCancelToken());

            //var pagechangeTask = PageChangingAsync(page, page.PAGE_NUMBER, ViewerDataModel.Instance.NewPagImageCancelToken());

            //var markupLoadTask = MarkupLoadAsync(page.PAGE_NUMBER, ViewerDataModel.Instance.PageAngle, ViewerDataModel.Instance.NewMarkupCancelToken());

            //await Task.WhenAll(pagechangeTask, markupLoadTask);

        }

        private async Task PageChangingAsync(DOCPAGE currentPage, int changePageNumber, CancellationToken token)

        {

            var BalancePoint = ViewerDataModel.Instance.PageBalanceMode ? changePageNumber + ViewerDataModel.Instance.PageBalanceNumber : changePageNumber;

            #region 페이지가 벗어난 경우

            if (BalancePoint < 1)

            {

                BalancePoint = 1;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            if (pageNavigator.PageCount < BalancePoint)

            {

                BalancePoint = pageNavigator.PageCount;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            #endregion 페이지가 벗어난 경우

            if (pageNavigator.PageCount < BalancePoint)

            {

                BalancePoint = pageNavigator.PageCount;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            if (ViewerDataModel.Instance.SyncPageCount < BalancePoint)

            {

                BalancePoint = ViewerDataModel.Instance.SyncPageCount;

            }

            ViewerDataModel.Instance.SyncPageNumber = BalancePoint;

            var pageWidth = Convert.ToDouble(currentPage.PAGE_WIDTH);

            var pageHeight = Convert.ToDouble(currentPage.PAGE_HEIGHT);

            var contentScale = zoomAndPanControl.ContentScale;

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

            ViewerDataModel.Instance.ImageViewPath = await App.PageStorage.GetPageImageAsync(token, changePageNumber);

            if (token.IsCancellationRequested)

            {

                return;

            }

            ScaleImage(pageWidth, pageHeight);

            ViewerDataModel.Instance.ImageViewWidth = pageWidth;

            ViewerDataModel.Instance.ImageViewHeight = pageHeight;

            zoomAndPanCanvas.Width = pageWidth;

            zoomAndPanCanvas.Height = pageHeight;

            Common.ViewerDataModel.Instance.ContentWidth = pageWidth;

            Common.ViewerDataModel.Instance.ContentHeight = pageHeight;

            inkBoard.Width = pageWidth;

            inkBoard.Height = pageHeight;

            #endregion 페이지 이미지 로딩 수정

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

                    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("Compare Image Download", 1);

                    ClearCompareRect();

                    ComparePageLoad(CurrentRev.DOCUMENT_ID, ViewerDataModel.Instance.SyncPageNumber, OriginalSizeMode.IsChecked);

                }

            }

            SearchFocusBorder.Visibility = Visibility.Collapsed;

            this.pageNavigator.ChangePage(changePageNumber);

        }

        private void ComparePageLoad(string documentID, int PageNo, bool IsOriginalSize)

        {

            if (PageNo > ViewerDataModel.Instance.SyncPageCount)

            {

                return;

            }

            tlSyncPageNum.Text = String.Format($"Current Page : {ViewerDataModel.Instance.SyncPageNumber}/{ViewerDataModel.Instance.SyncPageCount}");

            string pageUri = this.GetImageURL(documentID, ViewerDataModel.Instance.SyncPageNumber);

            /// 현재 보고 있는 VP와 같은 크기로 로딩

            ViewerDataModel.Instance.ImageViewPath_C = null;

            if (IsOriginalSize && OriginalSizeMode.IsChecked)

            {

                ViewerDataModel.Instance.ImageViewPath_C = ImageSourceHelper.GetDownloadImage(pageUri);

            }

            else

            {

                var imageSize = new Size(ViewerDataModel.Instance.ImageViewWidth, ViewerDataModel.Instance.ImageViewHeight);

                ViewerDataModel.Instance.ImageViewPath_C = ImageSourceHelper.GetDownloadImage(pageUri, imageSize);

            }

            if (ViewerDataModel.Instance.ImageViewPath_C != null)

            {

                ViewerDataModel.Instance.ImageViewWidth_C = ViewerDataModel.Instance.ImageViewPath_C.PixelWidth;

                ViewerDataModel.Instance.ImageViewHeight_C = ViewerDataModel.Instance.ImageViewPath_C.PixelHeight;

                zoomAndPanCanvas2.Width = ViewerDataModel.Instance.ImageViewPath_C.PixelWidth;

                zoomAndPanCanvas2.Height = ViewerDataModel.Instance.ImageViewPath_C.PixelHeight;

                SyncRotation(ViewerDataModel.Instance.SyncPageAngle);

                if (Sync.IsChecked)

                {

                    Sync_Click(null, new RoutedEventArgs());

                }

                else

                {

                    zoomAndPanControl2.ZoomTo(new Rect

                    {

                        X = 0,

                        Y = 0,

                        Width = zoomAndPanCanvas2.Width,

                        Height = zoomAndPanCanvas2.Height,

                    });

                }

                if (CompareMode.IsChecked)

                {

                    SyncCompare_Click(null, new RoutedEventArgs());

                }

                //zoomAndPanControl.ScaleToFit();

                //zoomAndPanControl.ZoomTo(new Rect

                //{

                //    X = 0,

                //    Y = 0,

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

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

                //});

            }

        }

        /// <summary>

        /// called after page is changed

        /// </summary>

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

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

        private void PageNavigator_PageChanged(object sender, Sample.PageChangeEventArgs e)

        {

            //if (zoomAndPanCanvas.Width.IsNaN())

            //{

            //await zoomAndPanControl.Dispatcher.InvokeAsync(() =>

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

            //    );

            //}

            var instanceMain = ViewerDataModel.Instance.SystemMain;

            instanceMain.dzMainMenu.CanvasDrawingMouseDownPoint = new Point(ViewerDataModel.Instance.ImageViewWidth / 2, ViewerDataModel.Instance.ImageViewHeight / 2);

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

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

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

            drawingPannelRotate(pageinfo.PAGE_ANGLE);

            /// 페이지의 모든 마크업을 로드한 후 호출

            /// 좌측 마크업 list의 아이템을 클릭하는 경우 MarkupControls_USER가 0으로 나와서 추가함.

            ViewerDataModel.Instance.LoadPageMarkupFinish(new Rect { X = 0, Y = 0, Width = zoomAndPanCanvas.Width, Height = zoomAndPanCanvas.Height });

        }

        private void SetTextControl(TextControl textControl)

        {

            textControl.Base_TextBlock.Margin = new Thickness(0, 0, 10, 0);

            textControl.Base_TextBox.Visibility = Visibility.Collapsed;

            textControl.Base_TextBlock.Visibility = Visibility.Visible;

        }

        /// <summary>

        /// 주어진 pageNumber의 마크업 데이터를 읽어 화면에 표시한다.

        /// </summary>

        /// <param name="pageNumber"></param>

        /// <param name="PageAngle"></param>

        /// <param name="cts"></param>

        /// <returns></returns>

        private async Task MarkupLoadAsync(int pageNumber, Double PageAngle, CancellationToken cts)

        {

            System.Diagnostics.Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();

            #region 컨트롤을 새로 생성한다.

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

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

            System.Diagnostics.Debug.WriteLine("MarkupLoad - Clear " + new TimeSpan(stopwatch.ElapsedTicks).ToString());

            foreach (var markup in ViewerDataModel.Instance.MyMarkupList.Where(param => param.PageNumber == pageNumber))

            {

                if (cts.IsCancellationRequested)

                {

                    return;

                }

                var info = ViewerDataModel.Instance._markupInfoList.FirstOrDefault(param => param.MarkupInfoID == markup.MarkupInfoID);

                if (info != null)

                {

                    string sColor = (info.UserID == App.ViewInfo.UserID) ? "#FFFF0000" : info.DisplayColor;

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

                    {

                        var control = await MarkupParser.ParseExAsync(App.BaseAddress, cts, App.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, PageAngle, sColor, "",

                                        markup.MarkupInfoID, markup.ID, STAMP_Contents: App.SystemInfo.STAMP_CONTENTS);

                        if (control != null)

                        {

                            Canvas.SetZIndex(control, (control as CommentUserInfo).ZIndex);

                            control.Visibility = Visibility.Hidden;

                        }

                    }

                    else

                    {

                        var control = await MarkupParser.ParseExAsync(App.BaseAddress, cts, App.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls, PageAngle, sColor, "",

                                                                markup.MarkupInfoID, markup.ID, STAMP_Contents: App.SystemInfo.STAMP_CONTENTS);

                        if (control != null)

                        {

                            Canvas.SetZIndex(control, (control as CommentUserInfo).ZIndex);

                            control.Visibility = Visibility.Hidden;

                        }

                    }

                }

            }

            #endregion

            /// fire selection event

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

            this.gridViewMarkup.UnselectAll();

            this.gridViewMarkup.Select(gridSelectionItem);

            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)

                {

                    var markupitems = item.MarkupList.Where(pageItem => pageItem.PageNumber == pageNumber).ToList();

                    foreach (var markupitem in markupitems)

                    {

                        await MarkupParser.ParseExAsync(App.BaseAddress, ViewerDataModel.Instance.NewMarkupCancelToken(), App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, PageAngle, item.DisplayColor, "", item.MarkupInfoID,

                            STAMP_Contents: App.SystemInfo.STAMP_CONTENTS);

                        //if (cts.IsCancellationRequested)

                        //{

                        //    return;

                        //}

                    }

                }

            }

            SetCommentPages(cts);

            if(MarkupLoadComplated != null)

            {

                MarkupLoadComplated(this, new EventArgs());

            }

        }

        public void SetCommentPages(CancellationToken? cts)

        {

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

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

            foreach (var item in ViewerDataModel.Instance._markupInfoList)

            {

                //Comment 가 존재할 경우에만 Thumbnail 에 추가

                if (item.MarkupList != null)

                {

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

                }

                if (cts != null)

                {

                    if (cts.Value.IsCancellationRequested)

                        return;

                }

            }

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

        }

        public void MarkupitemViewUpdate(string markupinfo_id)

        {

            //db에 업데이트 한 list 를 view 에 업데이트

            string sDocID = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu._DocInfo.ID;

            List<MarkupInfoItem> results = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.GetMarkupInfoItems(App.ViewInfo.ProjectNO, sDocID);

            MarkupInfoItem dbinfo = results.Find(x => x.MarkupInfoID == markupinfo_id);

            MarkupInfoItem viewinfo = Common.ViewerDataModel.Instance._markupInfoList.FirstOrDefault(x => x.MarkupInfoID == markupinfo_id);

            if (dbinfo.MarkupList.Count > 0)

            {

                if (viewinfo.MarkupList != null)

                {

                    viewinfo.MarkupList.Clear();

                    viewinfo.MarkupList = null;

                }

                viewinfo.MarkupList = new List<MarkupItem>();

                foreach (var item in dbinfo.MarkupList)

                {

                    System.Diagnostics.Debug.WriteLine(item.ID);

                    viewinfo.MarkupList.Add(item);

                }

            }

        }

        /// <summary>

        /// 객체 정렬을 위한 컨택스트 메뉴 생성

        /// </summary>

        private void InitContextMenu()

        {

            MenuItem menuBringForward = new MenuItem();

            menuBringForward.Header = "Bring Forward";

            menuBringForward.Click += MenuBringForward_Click;

            MenuItem menuBringToForward = new MenuItem();

            menuBringToForward.Header = "Bring To Forward";

            menuBringToForward.Click += MenuBringToForward_Click;

            MenuItem menuSendBackward = new MenuItem();

            menuSendBackward.Header = "Send Backward";

            menuSendBackward.Click += MenuSendBackward_Click;

            MenuItem menuSendToBackward = new MenuItem();

            menuSendToBackward.Header = "Send To Backward";

            menuSendToBackward.Click += MenuSendToBackward_Click;

            ContextMenu cm = new ContextMenu();

            cm.Items.Add(menuBringForward);

            cm.Items.Add(menuBringToForward);

            cm.Items.Add(new System.Windows.Controls.Separator());

            cm.Items.Add(menuSendBackward);

            cm.Items.Add(menuSendToBackward);

            m_ContextMenu = cm;

            if (this.zoomAndPanControl.ContextMenu == null)

                this.zoomAndPanControl.ContextMenu = m_ContextMenu;

        }

        private async void zoomAndPanControl_MouseWheel(object sender, MouseWheelEventArgs e)

        {

            var instance = ViewerDataModel.Instance;

            if (instance.IsWheelPageChanage)

            {

                return;

            }

            if (instance.IsPressCtrl) // && !instance.IsWheelPageChanage)

            {

                int changePage = 0;

                if (e.Delta > 0)

                {

                    if (0 < instance.ContentOffsetY)

                    {

                        Vector dragOffset = new Vector(0, e.Delta);

                        MoveZoomAndPanControl(dragOffset);

                    }

                    //else

                    //{

                    //    if (instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber > 1)

                    //    {

                    //        instance.IsWheelPageChanage = true;

                    //        changePage -= 1;

                    //    }

                    //}

                }

                else if (e.Delta < 0)

                {

                    if (instance.ContentHeight > instance.ContentOffsetY + instance.ContentViewportHeight)

                    {

                        Vector dragOffset = new Vector(0, e.Delta);

                        MoveZoomAndPanControl(dragOffset);

                    }

                    //else

                    //{

                    //    if (instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber < instance.SystemMain.dzMainMenu.pageNavigator.PageCount)

                    //    {

                    //        instance.IsWheelPageChanage = true;

                    //        changePage += 1;

                    //    }

                    //}

                }

                //if (changePage != 0)

                //{

                //    await Task.Factory.StartNew(() =>

                //    {

                //        double beforeScale = instance.ContentScale;

                //        EventHandler<Sample.PageChangeEventArgs> handler = null;

                //        handler = (snd, evt) =>

                //        {

                //            /// 최상단으로 이전 zoomScale로 위치한다

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

                //            //zoomAndPanControl.ZoomAboutPoint(beforeScale, new Point(currentContentMousePoint.X, 0));

                //            instance.IsWheelPageChanage = false;

                //            pageNavigator.PageChanged -= handler;

                //        };

                //        pageNavigator.PageChanged += handler;

                //        pageNavigator.GotoPage(Convert.ToInt32(instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber) + changePage);

                //    });

                //}

            }

            else

            {

                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 ZoomIn & ZoomOut

        public void init()

        {

            foreach (var item in ViewerDataModel.Instance.MarkupControls)

            {

                ControlList.Clear();

                listBox.Items.Clear();

                (item as IMarkupCommonData).IsSelected = false;

            }

        }

        //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 void MoveZoomAndPanControl(Vector dragOffset)

        {

            zoomAndPanControl.ContentOffsetX -= dragOffset.X;

            zoomAndPanControl.ContentOffsetY -= dragOffset.Y;

            if (Sync.IsChecked)

            {

                ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;

                ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;

            }

        }

        private void zoomAndPanControl_MouseMove(object sender, MouseEventArgs e)

        {

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

                || Common.ViewerDataModel.Instance.SelectedControl == "MACRO")

            //if(this.txtBatch.Visibility == Visibility.Visible)

            {

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

                Point currentPos = e.GetPosition(rect);

                floatingTip.HorizontalOffset = currentPos.X + 20;

                floatingTip.VerticalOffset = currentPos.Y;

            }

            getCurrentPoint = e.GetPosition(drawingRotateCanvas);

            if ((e.MiddleButton == MouseButtonState.Pressed) || (e.RightButton == MouseButtonState.Pressed))

            {

                SetCursor();

                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

                Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

                MoveZoomAndPanControl(dragOffset);

            }

            if (mouseHandlingMode == MouseHandlingMode.Drawing && currentControl != null)

            {

                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

                SetCursor();

                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 is TextControl TextCtrl)

                    {

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

                        {

                            TextCtrl.TextStyle = FontStyles.Italic;

                        }

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

                        {

                            TextCtrl.TextWeight = FontWeights.Bold;

                        }

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

                        {

                            TextCtrl.UnderLine = TextDecorations.Underline;

                        }

                        TextCtrl.ArcLength = ViewerDataModel.Instance.ArcLength;

                    }

                    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 is RectCloudControl RectCloudCtrl)

                    {

                        RectCloudCtrl.ArcLength = ViewerDataModel.Instance.ArcLength;

                    }

                    else if (currentControl is CloudControl CloudCtrl)

                    {

                        CloudCtrl.ArcLength = ViewerDataModel.Instance.ArcLength;

                    }

                    #region // 모든 컨트롤의 공통기능 제어

                    if (controlType != ControlType.PenControl)

                    {

                        currentControl.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.IsAxisLock || ViewerDataModel.Instance.IsPressShift);

                        if (currentControl is MarkupToPDF.Controls.Polygon.PolygonControl && ((MarkupToPDF.Controls.Polygon.PolygonControl)currentControl).IsCompleted)

                        {

                            var vControl = currentControl as MarkupToPDF.Controls.Polygon.PolygonControl;

                            var firstPoint = vControl.PointSet.First();

                            vControl.DashSize = ViewerDataModel.Instance.DashSize;

                            vControl.LineSize = ViewerDataModel.Instance.LineSize;

                            vControl.PointSet.Add(firstPoint);

                            vControl.ApplyOverViewData();

                            CreateCommand.Instance.Execute(currentControl);

                            vControl.UpdateControl();

                            currentControl = null;

                        }

                        else if (currentControl is MarkupToPDF.Controls.Polygon.CloudControl && ((MarkupToPDF.Controls.Polygon.CloudControl)currentControl).IsCompleted)

                        {

                            var vControl = currentControl as MarkupToPDF.Controls.Polygon.CloudControl;

                            CreateCommand.Instance.Execute(currentControl);

                            vControl.isTransOn = true;

                            var firstPoint = vControl.PointSet.First();

                            vControl.PointSet.Add(firstPoint);

                            vControl.DrawingCloud();

                            vControl.ApplyOverViewData();

                            currentControl = null;

                        }

                        ViewerDataModel.Instance.IsMarkupUpdate = true;

                    }

                    #endregion // 모든 컨트롤의 공통기능 제어

                    #region // 각 컨트롤의 특별한 기능을 제어한다.

                    switch (controlType)

                    {

                        case (ControlType.Coordinate):

                            {

                                var control = currentControl as CoordinateControl;

                                if (control != null)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.Paint = ViewerDataModel.Instance.paintSet;

                                }

                            }

                            break;

                        case (ControlType.InsideWhite):

                            {

                                var control = currentControl as InsideWhiteControl;

                                if (control != null)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    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)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    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)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.Paint = ViewerDataModel.Instance.paintSet;

                                    control.Paint = PaintSet.Fill;

                                }

                            }

                            break;

                        case ControlType.RectCloud:

                            {

                                var control = currentControl as RectCloudControl;

                                if (control != null)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.Paint = ViewerDataModel.Instance.paintSet;

                                }

                            }

                            break;

                        case ControlType.SingleLine:

                        case ControlType.CancelLine:

                        case ControlType.ArrowLine:

                        case ControlType.TwinLine:

                        case ControlType.DimLine:

                            {

                                var control = currentControl as LineControl;

                                if (control != null)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                }

                            }

                            break;

                        case ControlType.ArcLine:

                            {

                                var control = currentControl as ArcControl;

                                if (control != null)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                }

                            }

                            break;

                        case ControlType.ArcArrow:

                            {

                                var control = currentControl as ArrowArcControl;

                                if (control != null)

                                {

                                    //control.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                }