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

using System;

using System.Collections.Generic;

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.Imaging;

using System.Windows.Shapes;

using System.Windows.Threading;

using Telerik.Windows.Controls;

using Telerik.Windows.Data;

using static KCOM.TempFile;

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 CommentUserInfo currentControl { get; set; }

        public ControlType controlType { get; set; }

        private Move move = new Move();

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

        public MouseHandlingMode mouseHandlingMode = 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;

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

        {

            //App.splashString(ISplashMessage.MAINMENU_0);            

           InitializeComponent();

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

        }

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

        private 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.ToUInt32(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);

            }

            string sFolder = sDocumentID.All(char.IsDigit) ? (Convert.ToUInt32(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;

        }

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

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

            });

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

            });

            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)

        {

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

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

        }

        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)

            {

                App.splashString(ISplashMessage.MAINMENU_1);

                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"));

            }

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

        }

        private async Task DownloadOriginalFileAsync()

        {

            try

            {

                using (System.Net.WebClient client = new System.Net.WebClient())

                {

                    string instnaceFile = System.IO.Path.GetTempFileName().Replace(".pdf", ".tmp");

                    string downloadurl = GetOriginalPDFURL();

                    // canceltoken을 위해서 상위에 선언

                    var task = client.DownloadFileTaskAsync(new Uri(downloadurl), instnaceFile);

                    client.DownloadProgressChanged += (snd, evt) =>

                    {

                        ViewerDataModel.Instance.DownloadFileProgress = evt.ProgressPercentage;

                        //System.Diagnostics.Debug.WriteLine($"Download Progress {evt.ProgressPercentage}% {evt.BytesReceived}/{evt.TotalBytesToReceive}(Byte)");

                    };

                    await task;

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

                    ViewerDataModel.Instance.IsDownloadOriginal = true;

                    ViewerDataModel.Instance.OriginalTempFile = instnaceFile;

                }

            }

            catch (Exception ex)

            {

                Logger.sendResLog("DownloadOriginalFileAsync", ex.Message, 0);

            }

        }

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

        }

        /// <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);

            /// add or update markup list

            foreach (var control in ViewerDataModel.Instance.MarkupControls_USER)

            {

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

                var exist = ViewerDataModel.Instance.MyMarkupList.Where(data => data.ID == root.CommentID).FirstOrDefault();

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

                {

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

                    {

                        exist.Data = root.ConvertData;

                        exist.IsUpdate = true;

                    }

                }

                else if (root.CommentID != null)

                {

                    ViewerDataModel.Instance.MyMarkupList.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,

                    });

                }

            }

            /// delete markup list

            int iPageNo = this.pageNavigator.CurrentPage.PageNumber;

            var deleted = (from markup in ViewerDataModel.Instance.MyMarkupList

                          where (markup.PageNumber == iPageNo) 

                          && (null == ViewerDataModel.Instance.MarkupControls_USER.Where(control => control.CommentID == markup.ID).FirstOrDefault())

                          select markup).ToList();

            foreach (var markup in deleted)

            {

                ViewerDataModel.Instance.MyMarkupList.Remove(markup);

            }

            /// up to here

            //if (modified)

            //{

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

            //        GroupDescriptor descriptor = new GroupDescriptor();

            //        descriptor.Member = "Depatment";

            //        descriptor.DisplayContent = "DEPT";

            //        descriptor.SortDirection = ListSortDirection.Ascending;

            //        gridViewMarkup.GroupDescriptors.Add(descriptor);

            //    }

            //}

        }

        DispatcherTimer renderTesttimer;

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

        {

            await Task.Delay(10);

            // 마크업 로드

            //await this.Dispatcher.InvokeAsync(()=>MarkupLoad(e.PageNumber));

            await MarkupLoadAsync(e.PageNumber);

            // 페이지 이미지 변경

            await PageChangingAsync(e.CurrentPage, e.PageNumber);

        }

        private async Task PageChangingAsync(DOCPAGE currentPage, int changePageNumber)

        { 

            CompareMode.IsChecked = false;

            var BalancePoint = ViewerDataModel.Instance.PageBalanceMode == true ? 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

            ViewerDataModel.Instance.PageNumber = 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.GetPageAsync(changePageNumber);

            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.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 = this.GetImageURL(CurrentRev.DOCUMENT_ID, BalancePoint);

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

                    var defaultBitmapImage_Compare = new BitmapImage();

                    defaultBitmapImage_Compare.BeginInit();

                    defaultBitmapImage_Compare.CreateOptions = BitmapCreateOptions.IgnoreImageCache;

                    defaultBitmapImage_Compare.CacheOption = BitmapCacheOption.OnLoad;

                    defaultBitmapImage_Compare.UriSource = new Uri(uri2);

                    //defaultBitmapImage_Compare.DecodePixelWidth = Int32.Parse(e.CurrentPage.PAGE_WIDTH);

                    //defaultBitmapImage_Compare.DecodePixelHeight = Int32.Parse(e.CurrentPage.PAGE_HEIGHT);

                    defaultBitmapImage_Compare.EndInit();

                    ViewerDataModel.Instance.ImageViewPath_C = null;                    

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

                        {

                            defaultBitmapImage_Compare.Freeze();

                            ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;

                            ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;

                            ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;

                            ComparePanel.UpdateLayout();

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

                            });

                            //defaultBitmapImage_Compare dispose

                            defaultBitmapImage_Compare = null;

                            GC.Collect();

                        };

                    }

                }

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

            }

            SearchFocusBorder.Visibility = Visibility.Collapsed;

            this.pageNavigator.ChangePage(changePageNumber);

        }

        /// <summary>

        /// called after page is changed

        /// </summary>

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

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

        private async 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.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);

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

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

            ViewerDataModel.Instance.LoadPageMarkup();

        }

        private async Task MarkupLoadAsync(int pageNumber)

        {

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

            stopwatch.Start();

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

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

            { 

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

                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.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, sColor, "",

                                        markup.MarkupInfoID, markup.ID);

                        control.Visibility = Visibility.Hidden;

                    }

                    else

                    {

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

                                                                markup.MarkupInfoID, markup.ID);

                        control.Visibility = Visibility.Hidden;

                    }

                }

            };

            /// up to here

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

            /// 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.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, item.DisplayColor, "", item.MarkupInfoID);

                    }

                }

            }

            SetCommentPages();

        }

        public void SetCommentPages()

        {

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

                }                   

            }

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

        }

        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.Where(x => x.MarkupInfoID == markupinfo_id).FirstOrDefault();

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

            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)

                {

                    viewinfo.MarkupList.Add(item);

                }

            }

        }

        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

        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;

                    }

                }

            }

            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)

       {

           PlaceImageSymbol(symbol_id, symbol_group_id, symbol_SelectedIndex, new Point(zoomAndPanCanvas.ActualWidth / 2,

               zoomAndPanCanvas.ActualHeight / 2));

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

        }

         */

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

            {

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

                    }

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

                    if (controlType != ControlType.PenControl)

                    {

                        currentControl.OnCreatingMouseMove(currentCanvasDrawingMouseMovePoint, ViewerDataModel.Instance.checkAxis, ViewerDataModel.Instance.IsPressShift);

                    }

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