MARKUS



using MarkupToPDF.Controls.Common;

using MarkupToPDF.Controls.Line;

using MarkupToPDF.Controls.Polygon;

using MarkupToPDF.Controls.Shape;

using MarkupToPDF.Controls.Text;

using MarkupToPDF.Controls.Etc;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using KCOM.Common;

using IKCOM;

using System.Windows.Ink;

using System.Collections.ObjectModel;

using Telerik.Windows.Controls;

using KCOM.Events;

using System.Reflection;

using MarkupToPDF.Common;

using KCOM.Controls;

using KCOMDataModel.DataModel;

using System.Xml;

using static KCOM.TempFile;

using System.Windows.Threading;

using System.Diagnostics;

using System.Threading;

using System.Windows.Resources;

using Svg2Xaml;

using System.Runtime.InteropServices;

using System.Windows.Media.Effects;

using MarkupToPDF.Controls.Cad;

using MarkupToPDF.Controls.Parsing;

namespace KCOM.Views

{

    public static class ControlExtensions

    {

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

            where T : System.Windows.Controls.Control

        {

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

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

            foreach (PropertyInfo propInfo in controlProperties)

            {

                if (propInfo.CanWrite)

                {

                    if (propInfo.Name != "WindowTarget")

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

                }

            }

            return instance;

        }

    }

    public class MyConsole

    {

        private readonly System.Threading.ManualResetEvent _readLineSignal;

        private string _lastLine;

        public MyConsole()

        {

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

            Gui = new TextBox();

            Gui.AcceptsReturn = true;

            Gui.KeyUp += OnKeyUp;

        }

        private void OnKeyUp(object sender, KeyEventArgs e)

        {

            // this is always fired on UI thread

            if (e.Key == Key.Enter)

            {

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

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

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

                _readLineSignal.Set();

            }

        }

        public TextBox Gui { get; private set; }

        public string ReadLine()

        {

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

            if (Gui.Dispatcher.CheckAccess())

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

            // reset signal

            _readLineSignal.Reset();

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

            _readLineSignal.WaitOne();

            // we got signalled - return line user typed.

            return _lastLine;

        }

        public void WriteLine(string line)

        {

            if (!Gui.Dispatcher.CheckAccess())

            {

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

                return;

            }

            Gui.Text += line + Environment.NewLine;

        }

    }

    /// <summary>

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

    /// </summary>

    public partial class MainMenu : UserControl

    {

        #region 프로퍼티

        public Undo_data UndoData { get; set; }

        public CommentUserInfo currentControl { get; set; }

        public ControlType controlType { get; set; }

        private Move move;

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

        public MouseHandlingMode mouseHandlingMode = MouseHandlingMode.None;

        public MouseButton mouseButtonDown { get; set; }

        private static readonly double DragThreshold = 5;

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

        private Point canvasDrawingMouseDownPoint;

        public string filename { get; set; }

        private Point canvasZoomPanningMouseDownPoint;

        public Point getCurrentPoint;

        private Point canvasZoommovingMouseDownPoint;

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

        private ListBox listBox = new ListBox();

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

        private bool isDraggingSelectionRect = false;

        DrawingAttributes inkDA = new DrawingAttributes();

        private VPRevision CurrentRev { get; set; }

        public RadRibbonButton btnConsolidate { get; set; }

        public RadRibbonButton btnFinalPDF { get; set; }

        public RadRibbonButton btnTeamConsolidate { get; set; }

        public RadRibbonButton btnConsolidateFinalPDF { get; set; }

        public string Filename_ { get; set; }

        public double L_Size = 0;

        public AdornerFinal adorner_;

        public Multi_Undo_data multi_Undo_Data;

        public string Symbol_ID = "";

        /// <summary>

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

        /// </summary>

        public bool isLeftMouseButtonDownOnWindow = false;

        public InkPresenter _InkBoard = null;

        Stroke stroke;

        Boolean IsDrawing = false;

        StylusPointCollection strokePoints;

        //StylusPointCollection erasePoints;

        RenderTargetBitmap canvasImage;

        Point Sync_Offset_Point;

        //강인구 테스트

        private Path _SelectionPath { get; set; }

        public Path SelectionPath

        {

            get

            {

                return _SelectionPath;

            }

            set

            {

                if (_SelectionPath != value)

                {

                    _SelectionPath = value;

                    RaisePropertyChanged("SelectionPath");

                }

            }

        }

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

        public System.Windows.Controls.Image imageViewer

        {

            get

            {

                if (_imageViewer == null)

                {

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

                    return _imageViewer;

                }

                else

                {

                    return _imageViewer;

                }

            }

            set

            {

                if (_imageViewer != value)

                {

                    _imageViewer = value;

                }

            }

        }

        public bool IsSyncPDFMode { get; set; }

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

        public System.Windows.Controls.Image imageViewer_Compare

        {

            get

            {

                if (_imageViewer_Compare == null)

                {

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

                    return _imageViewer_Compare;

                }

                else

                {

                    return _imageViewer_Compare;

                }

            }

            set

            {

                if (_imageViewer_Compare != value)

                {

                    _imageViewer_Compare = value;

                }

            }

        }

        #endregion

        public MainMenu()

        {

            //InitializeComponent();    

            this.Loaded += MainMenu_Loaded;

        }

        public class TempDt

        {

            public int PageNumber { get; set; }

            public string CommentID { get; set; }

            public string ConvertData { get; set; }

            public int DATA_TYPE { get; set; }

            public string MarkupInfoID { get; set; }

            public int IsUpdate { get; set; }

        }

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

        private void SetCursor()

        {

            this.Cursor = cursor;

        }

        private bool IsDrawingEnable(Point _canvasZoomPanningMouseDownPoint)

        {

            if ((_canvasZoomPanningMouseDownPoint.X > 0 &&

                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.X) &&

                (_canvasZoomPanningMouseDownPoint.Y > 0 &&

                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.Y))

            {

                return true;

            }

            return false;

        }

        private bool IsRotationDrawingEnable(Point _canvasZoomPanningMouseDownPoint)

        {

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

            {

                if ((_canvasZoomPanningMouseDownPoint.X > 0 &&

                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.X) &&

                (_canvasZoomPanningMouseDownPoint.Y > 0 &&

                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.Y))

                {

                    return true;

                }

            }

            else

            {

                if ((_canvasZoomPanningMouseDownPoint.X > 0 &&

                zoomAndPanCanvas.ActualWidth > _canvasZoomPanningMouseDownPoint.X) &&

                (_canvasZoomPanningMouseDownPoint.Y > 0 &&

                zoomAndPanCanvas.ActualHeight > _canvasZoomPanningMouseDownPoint.Y))

                {

                    return true;

                }

            }

            return false;

        }

        public void DeleteItem(MarkupInfoItem item)

        {

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

            {

                App.Custom_ViewInfoId = PreviewUserMarkupInfoItem.MarkupInfoID;

            }

            ViewerDataModel.Instance._markupInfoList.Remove(item);

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

            {

                ViewerDataModel.Instance.MarkupControls.Remove(a);

            });

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

            {

                ViewerDataModel.Instance.MarkupControls_USER.Remove(a);

            });

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

            {

                ComingNewBieEnd = false;

                ViewerDataModel.Instance.MarkupList_USER.Remove(a);

                //임시파일에서도 삭제

                temp.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 = Events.Save.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 = Events.Save.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);

        }

        public void DeleteCommentEvent(object sender, RoutedEventArgs e)

        {

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

            this.ReleaseAdorner();

            Button content = (sender as Button);

            MarkupInfoItem item = content.CommandParameter as MarkupInfoItem;

            DeleteItem(item);

        }

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

        private static Timer timer;

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

        private void MainMenu_Loaded(object sender, RoutedEventArgs e)

        {

            InitializeComponent();

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

            if (App.ParameterMode)

            {

                this.pageNavigator.PageChanging += pageNavigator_PageChanging;

                imageViewer_Compare = new Image();

                layerControl.ProjectNo = App.ViewInfo.ProjectNO;

                ViewerDataModel.Instance.Capture_Opacity = 0;

                da.From = 0.8;

                da.To = 0;

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

                da.AutoReverse = true;

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

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

                {

                    this.SymbolPane.Visibility = Visibility.Collapsed;

                    this.FavoritePane.Visibility = Visibility.Collapsed;

                    this.drawingRotateCanvas.IsHitTestVisible = false;

                }

            }

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

        }

        private void timercallback(Object o)

        {

            Stopwatch sw = new Stopwatch();

            sw.Start();

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

        }

        void TempFileAdd()

        {

            Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate

            {

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

                {

                    DateTime undoTime = ViewerDataModel.Instance.UndoDataList.OrderByDescending(order => order.EventTime).FirstOrDefault().EventTime;

                    DateTime updatetime = DateTime.Now.AddDays(-1);

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

                    {

                        updatetime = ViewerDataModel.Instance._markupInfoList.OrderByDescending(order => order.UpdateTime).FirstOrDefault().UpdateTime;

                    }

                    EmptyControlCheck();

                    if (undoTime > updatetime)

                    {

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

                        {

                            foreach (var control in ViewerDataModel.Instance.MarkupControls_USER)

                            {

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

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

                                if (existItem != null)

                                {

                                    if (existItem.Data != root.ConvertData)

                                    {

                                        tempDtList.Add(new TempDt()

                                        {

                                            CommentID = control.CommentID,

                                            ConvertData = root.ConvertData,

                                            DATA_TYPE = root.DATA_TYPE,

                                            MarkupInfoID = App.Custom_ViewInfoId,

                                            PageNumber = this.pageNavigator.CurrentPage.PageNumber,

                                            IsUpdate = 1

                                        });

                                    }

                                }

                                else //신규 추가 된 코멘트

                                {

                                    if (root.CommentID != null)

                                    {

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

                                        if (currentCommentCheck != null)

                                        {

                                            tempDtList.Add(new TempDt()

                                            {

                                                CommentID = control.CommentID,

                                                ConvertData = root.ConvertData,

                                                DATA_TYPE = root.DATA_TYPE,

                                                MarkupInfoID = App.Custom_ViewInfoId,

                                                PageNumber = this.pageNavigator.CurrentPage.PageNumber,

                                                IsUpdate = 1

                                            });

                                        }

                                        else

                                        {

                                            tempDtList.Add(new TempDt()

                                            {

                                                CommentID = control.CommentID,

                                                ConvertData = root.ConvertData,

                                                DATA_TYPE = root.DATA_TYPE,

                                                MarkupInfoID = App.Custom_ViewInfoId,

                                                PageNumber = this.pageNavigator.CurrentPage.PageNumber,

                                                IsUpdate = 0

                                            });

                                        }

                                    }

                                }

                            }

                        }

                        temp.WriteTemp(tempDtList);

                        tempDtList.Clear();

                    }

                }

            }));

        }

        public class TempLoadData

        {

            public int PageNumber { get; set; }

            public string CommentID { get; set; }

            public string ConvertData { get; set; }

            public string DATA_TYPE { get; set; }

            public string MarkupInfoID { get; set; }

            public int IsUpdate { get; set; }

        }

        List<TempLoadData> tempLoadData = new List<TempLoadData>();

        public string FilePath = AppDomain.CurrentDomain.BaseDirectory + "Temp\\" + App.ViewInfo.DocumentItemID + ".tmp";

        public void TempLoad()

        {

            if ((System.IO.File.Exists(FilePath)) == true)

            {

                XmlDocument xdoc = new XmlDocument();

                xdoc.Load(FilePath);

                XmlNodeList nodes = xdoc.SelectNodes("/Root/CommentID");

                int PageNumber = 0;

                if (nodes.Count > 0)

                {

                    if (MessageBox.Show("저장하지 못한 데이터가 있습니다. 불러오시겠습니까?", "MARKUS", MessageBoxButton.OKCancel) == MessageBoxResult.OK)

                    {

                        foreach (XmlNode node in nodes)

                        {

                            string CommentID = node.Attributes["Value"].Value;

                            string ConvertData = node.SelectSingleNode("ConvertData").InnerText;

                            string DATA_TYPE = node.SelectSingleNode("DATA_TYPE").InnerText;

                            string MarkupInfoID = node.SelectSingleNode("MarkupInfoID").InnerText;

                            int IsUpdate = Convert.ToInt32(node.SelectSingleNode("IsUpdate").InnerText);

                            PageNumber = Convert.ToInt32(node.SelectSingleNode("PageNumber").InnerText);

                            tempLoadData.Add(new TempLoadData()

                            {

                                PageNumber = PageNumber,

                                CommentID = CommentID,

                                ConvertData = ConvertData,

                                DATA_TYPE = DATA_TYPE,

                                MarkupInfoID = MarkupInfoID,

                                IsUpdate = IsUpdate

                            });

                        }

                        if (PageNumber > 0)

                        {

                            this.pageNavigator.GotoPage(PageNumber);

                        }

                        // Temp Object add               

                        if (pageNavigator.CurrentPage.PageNumber == PageNumber)

                        {

                            TempControlLoad();

                        }

                        tempLoadData.Clear();

                    }

                }

                else //파일 삭제

                {

                    temp.Remove();

                }

            }            

        }

        public void ReleaseAdorner()

        {

            try

            {

                Logger.sendCheckLog("pageNavigator_PageChanging_ReleaseAdorner", 1);

                if (SelectLayer.Children.Count > 0)

                {

                    foreach (var item in SelectLayer.Children)

                    {

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

                        {

                            (item as AdornerFinal).unRegister();

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

                            {

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

                                {

                                    if (InnerItem.DrawingData.GetType().Name == "PolygonControl")

                                    {

                                        if ((InnerItem.DrawingData as PolygonControl).CommentID == null)

                                        {

                                            (InnerItem.DrawingData as PolygonControl).CommentID = KCOM.Events.Save.shortGuid();

                                        }

                                    }

                                    ViewerDataModel.Instance.MarkupControls_USER.Add(InnerItem.DrawingData as CommentUserInfo);

                                }

                            }

                        }

                    }

                    SelectLayer.Children.Clear();

                }

            }

            catch (Exception ex)

            {

                Logger.sendResLog("ReleaseAdorner", ex.ToString(), 0);

            }            

        }

        public List<CommentUserInfo> AddAdorner()

        {

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

            if (SelectLayer.Children.Count > 0)

            {

                foreach (var item in SelectLayer.Children)

                {

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

                    {

                        (item as AdornerFinal).unRegister();

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

                        {

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

                            {

                                adornerSet.Add(InnerItem.DrawingData as CommentUserInfo);

                            }

                            Control_Style(InnerItem.DrawingData as CommentUserInfo);

                            UndoData.Markup_List.Add(multi_Undo_Data);

                            multi_Undo_Data = new Multi_Undo_data();

                        }

                    }

                }

                SelectLayer.Children.Clear();

            }

            return adornerSet;

        }

        public void ChangeCommentReact()

        {

            Logger.sendCheckLog("pageNavigator_PageChanging_ChangeCommentReact", 1);

            bool isComingNewBie = false;

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

            {

                foreach (var control in ViewerDataModel.Instance.MarkupControls_USER)

                {

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

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

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

                    {

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

                        {

                            existItem.Data = root.ConvertData;

                            existItem.IsUpdate = true;

                            ComingNewBieEnd = false;

                        }

                    }

                    else

                    {

                        if (root.CommentID != null)

                        {

                            isComingNewBie = true;

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

                            if (currentCommentCheck != null)

                            {

                                currentCommentCheck.Data = root.ConvertData;

                            }

                            else

                            {

                                ViewerDataModel.Instance.MarkupList_USER.Add(new MarkupItemEx

                                {

                                    ID = control.CommentID,

                                    Data = root.ConvertData,

                                    Data_Type = root.DATA_TYPE,

                                    MarkupInfoID = App.Custom_ViewInfoId,

                                    PageNumber = this.pageNavigator.CurrentPage.PageNumber,

                                    Symbol_ID = control.SymbolID,

                                    Group_ID = control.GroupID,

                                });

                                ComingNewBieEnd = false;

                            }

                        }

                    }

                }

            }

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

            {

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

                {

                    ComingNewBieEnd = true;

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

                    PreviewUserMarkupInfoItem.IsPreviewUser = false;

                    gridViewMarkup.ItemsSource = null;

                    gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;

                    gridViewMarkup.SelectedItem = PreviewUserMarkupInfoItem;

                }

            }

        }

        MarkupToPDF.Controls.Parsing.LayerControl layerControl = new MarkupToPDF.Controls.Parsing.LayerControl();

        bool ComingNewBieEnd = false;

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

        {

            Logger.sendCheckLog("pageNavigator_PageChanging_Start", 1);

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

            {

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

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

            }

            Logger.sendCheckLog("pageNavigator_PageChanging_UndoDataListClear", 1);

            ViewerDataModel.Instance.UndoDataList.Clear();

            InkControl_Convert();

            ReleaseAdorner();

            ChangeCommentReact();

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

            CompareMode.IsChecked = false;

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

            #region 페이지가 벗어난 경우

            if (BalancePoint < 1)

            {

                BalancePoint = 1;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            if (pageNavigator.PageCount < BalancePoint)

            {

                BalancePoint = pageNavigator.PageCount;

                ViewerDataModel.Instance.PageBalanceNumber = 0;

            }

            #endregion

            ViewerDataModel.Instance.PageNumber = BalancePoint;

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

            string uri = "";

            if (userData.COMPANY != "EXT")

            {

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

            }

            else

            {

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

            }

            var defaultBitmapImage = new BitmapImage();

            defaultBitmapImage.BeginInit();

            defaultBitmapImage.CreateOptions = BitmapCreateOptions.IgnoreImageCache;

            defaultBitmapImage.CacheOption = BitmapCacheOption.OnLoad;

            defaultBitmapImage.UriSource = new Uri(uri);

            defaultBitmapImage.EndInit();

            ViewerDataModel.Instance.ImageViewPath = null;

            GC.Collect();

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

            if (defaultBitmapImage.IsDownloading)

            {

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

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

                {

                    defaultBitmapImage.Freeze();

                    mainPanel.UpdateLayout();

                    GC.Collect();

                    ViewerDataModel.Instance.ImageViewPath = defaultBitmapImage;

                    ViewerDataModel.Instance.ImageViewWidth = defaultBitmapImage.PixelWidth;

                    ViewerDataModel.Instance.ImageViewHeight = defaultBitmapImage.PixelHeight;

                };

            }

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

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

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

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

            inkBoard.Width = zoomAndPanCanvas.Width;

            inkBoard.Height = zoomAndPanCanvas.Height;

            if (!testPanel2.IsHidden)

            {

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

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

                if (IsSyncPDFMode)

                {

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

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

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

                    if (pdfpath.IsDownloading)

                    {

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

                        {

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

                            ViewerDataModel.Instance.ImageViewPath_C = pdfpath;

                            ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;

                            ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;

                            zoomAndPanCanvas2.Width = pdfpath.PixelWidth;

                            zoomAndPanCanvas2.Height = pdfpath.PixelHeight;

                        };

                    }

                    else

                    {

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

                        ViewerDataModel.Instance.ImageViewPath_C = pdfpath;

                        ViewerDataModel.Instance.ImageViewWidth_C = pdfpath.PixelWidth;

                        ViewerDataModel.Instance.ImageViewHeight_C = pdfpath.PixelHeight;

                        zoomAndPanCanvas2.Width = pdfpath.PixelWidth;

                        zoomAndPanCanvas2.Height = pdfpath.PixelHeight;

                    }

                }

                else

                {

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

                    string uri2 = "";

                    if (userData.COMPANY != "EXT")

                    {

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

                    }

                    else

                    {

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

                    }

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

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

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

                    ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;

                    ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;

                    ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;

                    zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;

                    zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;

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

                    zoomAndPanControl.ZoomTo(new Rect

                    {

                        X = 0,

                        Y = 0,

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

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

                    });

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

                    if (defaultBitmapImage_Compare.IsDownloading)

                    {

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

                        {

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

                            ViewerDataModel.Instance.ImageViewPath_C = defaultBitmapImage_Compare;

                            ViewerDataModel.Instance.ImageViewWidth_C = defaultBitmapImage_Compare.PixelWidth;

                            ViewerDataModel.Instance.ImageViewHeight_C = defaultBitmapImage_Compare.PixelHeight;

                            zoomAndPanCanvas2.Width = defaultBitmapImage_Compare.PixelWidth;

                            zoomAndPanCanvas2.Height = defaultBitmapImage_Compare.PixelHeight;

                            zoomAndPanControl.ZoomTo(new Rect

                            {

                                X = 0,

                                Y = 0,

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

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

                            });

                        };

                    }

                }

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

            }

            this.pageNavigator.SetNextPage();

            if (zoomAndPanCanvas2.Width.IsNaN())

            {

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

            }

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

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

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

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

            foreach (var item in gridSelectionItem)

            {

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

                {

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

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

                    {

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

                            item.MarkupInfoID, markupitem.ID);

                    });

                }

                else

                {

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

                    {

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

                    });

                }

            }

            if (!testPanel2.IsHidden)

            {

                ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;

                ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;

                ViewerDataModel.Instance.Sync_ContentScale = zoomAndPanControl.ContentScale;

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

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

                foreach (var item in gridSelectionRevItem)

                {

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

                    {

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

                    });

                }

            }

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

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

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

            instanceMain.dzTopMenu.rotateOffSet = 0;

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

            drawingPannelRotate(pageinfo.PAGE_ANGLE);

            //}

            SetCommentPages(true);

        }

        //Temp Control Load

        public void TempControlLoad()

        {

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

            for (int k = 0; k < tempLoadData.Count; k++)

            {

                System.Windows.Controls.Control item = null;

                Multi_Undo_data multi_Undo_Data;

                switch (tempLoadData[k].IsUpdate)

                {

                    case 0://추가

                        var control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.CommentID == tempLoadData[k].CommentID).FirstOrDefault();

                        if (control != null)

                        {

                            ViewerDataModel.Instance.MarkupControls_USER.Remove(control);

                            var Item_ = ViewerDataModel.Instance.MarkupList_USER.Where(d => d.ID == (control as MarkupToPDF.Common.CommentUserInfo).CommentID).FirstOrDefault();

                            ViewerDataModel.Instance.MarkupList_USER.Remove(Item_);

                        }

                        //Control                   

                        item = MarkupParser.ParseEx(App.ViewInfo.ProjectNO, tempLoadData[k].ConvertData, Common.ViewerDataModel.Instance.MarkupControls_USER, "#FFFF0000", "", tempLoadData[k].MarkupInfoID, tempLoadData[k].CommentID);

                        UndoData = new Undo_data()

                        {

                            IsUndo = false,

                            Event = Event_Type.Create,

                            EventTime = DateTime.Now,

                            Opacity = ViewerDataModel.Instance.ControlOpacity,

                            Markup_List = new List<Multi_Undo_data>()

                        };

                        multi_Undo_Data = new Multi_Undo_data();

                        multi_Undo_Data = this.ParentOfType<MainWindow>().dzMainMenu.Control_Style(item as MarkupToPDF.Common.CommentUserInfo);

                        UndoData.Markup_List.Add(multi_Undo_Data);

                        ViewerDataModel.Instance.UndoDataList.Add(UndoData);

                        break;

                    case 1://수정

                        control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.CommentID == tempLoadData[k].CommentID).FirstOrDefault();

                        if (control != null)

                        {

                            ViewerDataModel.Instance.MarkupControls_USER.Remove(control);

                            var Item_ = ViewerDataModel.Instance.MarkupList_USER.Where(d => d.ID == (control as MarkupToPDF.Common.CommentUserInfo).CommentID).FirstOrDefault();

                            ViewerDataModel.Instance.MarkupList_USER.Remove(Item_);

                        }

                        //Control                   

                        item = MarkupParser.ParseEx(App.ViewInfo.ProjectNO, tempLoadData[k].ConvertData, Common.ViewerDataModel.Instance.MarkupControls_USER, "#FFFF0000", "", tempLoadData[k].MarkupInfoID, tempLoadData[k].CommentID);

                        UndoData = new Undo_data()

                        {

                            IsUndo = false,

                            Event = Event_Type.Thumb,

                            EventTime = DateTime.Now,

                            Opacity = ViewerDataModel.Instance.ControlOpacity,

                            Markup_List = new List<Multi_Undo_data>()

                        };

                        multi_Undo_Data = new Multi_Undo_data();

                        multi_Undo_Data = this.ParentOfType<MainWindow>().dzMainMenu.Control_Style(item as MarkupToPDF.Common.CommentUserInfo);

                        UndoData.Markup_List.Add(multi_Undo_Data);

                        ViewerDataModel.Instance.UndoDataList.Add(UndoData);

                        break;

                    case 2://삭제

                        control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.CommentID == tempLoadData[k].CommentID).FirstOrDefault();

                        if (control != null)

                        {

                            ViewerDataModel.Instance.MarkupControls_USER.Remove(control);

                            var Item_ = ViewerDataModel.Instance.MarkupList_USER.Where(d => d.ID == (control as MarkupToPDF.Common.CommentUserInfo).CommentID).FirstOrDefault();

                            ViewerDataModel.Instance.MarkupList_USER.Remove(Item_);

                        }

                        break;

                }

            }

        }

        private void SetCommentPages(bool onlyMe = false)

        {

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

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

            foreach (var item in ViewerDataModel.Instance._markupInfoList)

            {

                UsersCommentPagesMember instance = new UsersCommentPagesMember();

                instance.UserName = item.UserName;

                instance.Depart = item.Depatment;

                instance.MarkupInfoID = item.MarkupInfoID;

                instance.IsSelected = true;

                instance.isConSolidation = item.Consolidate;

                instance.SetColor = item.DisplayColor;

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

                {

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

                }

                else

                {

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

                }

                _pages.Add(instance);

            }

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

        }

        private void zoomAndPanControl_MouseWheel(object sender, MouseWheelEventArgs e)

        {

            if (e.MiddleButton == MouseButtonState.Pressed)

            {

            }

            e.Handled = true;

            if (e.Delta > 0)

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas);

                ZoomIn(currentContentMousePoint);

            }

            else

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas);

                ZoomOut(currentContentMousePoint);

            }

        }

        private void zoomAndPanControl2_MouseWheel(object sender, MouseWheelEventArgs e)

        {

            e.Handled = true;

            if (e.Delta > 0)

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas2);

                ZoomIn_Sync(currentContentMousePoint);

            }

            else

            {

                Point currentContentMousePoint = e.GetPosition(zoomAndPanCanvas2);

                ZoomOut_Sync(currentContentMousePoint);

            }

        }

        #region ZoomIn & ZoomOut

        private void ZoomOut_Executed(object sender, ExecutedRoutedEventArgs e)

        {

            ZoomOut(new Point(zoomAndPanControl.ContentZoomFocusX,

                zoomAndPanControl.ContentZoomFocusY));

        }

        private void ZoomIn_Executed(object sender, ExecutedRoutedEventArgs e)

        {

            ZoomIn(new Point(zoomAndPanControl.ContentZoomFocusX,

                zoomAndPanControl.ContentZoomFocusY));

        }

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

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

        private void ZoomOut(Point contentZoomCenter)

        {

            if (zoomAndPanControl.ContentScale > 0.39)

            {

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

            }

            else

            {

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

            }

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

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomIn(Point contentZoomCenter)

        {

            if (zoomAndPanControl.ContentScale > 0.19)

            {

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

            }

            else

            {

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

            }

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

            {

                zoomAndPanControl2.ZoomAboutPoint(zoomAndPanControl.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomOut_Sync(Point contentZoomCenter)

        {

            if (zoomAndPanControl2.ContentScale > 0.39)

            {

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

            }

            else

            {

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

            }

            if (Sync.IsChecked)

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl2.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomIn_Sync(Point contentZoomCenter)

        {

            if (zoomAndPanControl2.ContentScale > 0.19)

            {

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

            }

            else

            {

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

            }

            if (Sync.IsChecked)

            {

                zoomAndPanControl.ZoomAboutPoint(zoomAndPanControl2.ContentScale, contentZoomCenter);

            }

        }

        private void ZoomOut()

        {

            zoomAndPanControl.ContentScale -= 0.1;

            //if (zoomAndPanControl2 != null)

            //{

            //    zoomAndPanControl2.ContentScale -= 0.1;

            //}

        }

        private void ZoomIn()

        {

            zoomAndPanControl.ContentScale += 0.1;

            //if (zoomAndPanControl2 != null)

            //{

            //    zoomAndPanControl2.ContentScale += 0.1;

            //}

        }

        #endregion

        private void init()

        {

            foreach (var item in ViewerDataModel.Instance.MarkupControls)

            {

                ControlList.Clear();

                listBox.Items.Clear();

                selected_item.Clear();

                (item as IMarkupCommonData).IsSelected = false;

            }

        }

        private HitTestResultBehavior MyCallback(HitTestResult result)

        {

            //this.cursor = Cursors.UpArrow;

            var element = result.VisualHit;

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

                element = VisualTreeHelper.GetParent(element);

            if (element == null)

            {

                return HitTestResultBehavior.Stop;

            }

            else

            {

                if (element is CommentUserInfo)

                {

                    if (!hitList.Contains(element))

                    {

                        hitList.Add((CommentUserInfo)element);

                    }

                    else

                    {

                        return HitTestResultBehavior.Stop;

                    }

                    //IntersectionDetail intersectionDetail =

                    //((GeometryHitTestResult)result).IntersectionDetail;

                    //switch (intersectionDetail)

                    //{

                    //    case IntersectionDetail.FullyContains:

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

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

                    //        return HitTestResultBehavior.Continue;

                    //    case IntersectionDetail.Intersects:

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

                    //        return HitTestResultBehavior.Continue;

                    //    case IntersectionDetail.FullyInside:

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

                    //        return HitTestResultBehavior.Continue;

                    //    default:

                    //        return HitTestResultBehavior.Stop;

                    //}

                }

            }

            return HitTestResultBehavior.Continue;

        }

        public void ReleaseSelectPath()

        {

            if (SelectionPath == null)

            {

                SelectionPath = new Path();

                SelectionPath.Name = "";

            }

            if (SelectionPath.Name != "")

            {

                SelectionPath.Name = "None";

            }

            SelectionPath.Opacity = 0.01;

            SelectionPath.RenderTransform = null;

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

        }

        #region 컨트롤 초기화 

        public void Control_Init(object control)

        {

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

            {

                (control as IPath).LineSize = L_Size;

                L_Size = 0;

            }

            switch (control.GetType().Name)

            {

                case "RectangleControl":

                    {

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

                    }

                    break;

                case "CircleControl":

                    {

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

                    }

                    break;

                case "TriControl":

                    {

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

                    }

                    break;

                case "RectCloudControl":

                    {

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

                    }

                    break;

                case "CloudControl":

                    {

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

                    }

                    break;

                case "PolygonControl":

                    {

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

                    }

                    break;

                case "ArcControl":

                    {

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

                    }

                    break;

                case "ArrowArcControl":

                    {

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

                    }

                    break;

                case "LineControl":

                    {

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

                    }

                    break;

                case "ArrowControl_Multi":

                    {

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

                    }

                    break;

                case "TextControl":

                    {

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

                    }

                    break;

                case "ArrowTextControl":

                    {

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

                    }

                    break;

                case "InsideWhiteControl":

                    {

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

                    }

                    break;

                case "OverlapWhiteControl":

                    {

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

                    }

                    break;

                case "ClipWhiteControl":

                    {

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

                    }

                    break;

                case "CoordinateControl":

                    {

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

                    }

                    break;

            }

        }

        #endregion

        public void firstCondition_MouseLeave(object sender, MouseEventArgs e)

        {

            //Control_Init(e.Source);

        }

        private Window _dragdropWindow = null;

        [DllImport("user32.dll")]

        [return: MarshalAs(UnmanagedType.Bool)]

        internal static extern bool GetCursorPos(ref Win32Point pt);

        [StructLayout(LayoutKind.Sequential)]

        internal struct Win32Point

        {

            public Int32 X;

            public Int32 Y;

        };

        public string symbol_id = null;

        public long symbol_group_id;

        public int symbol_SelectedIndex;

        public ImageSource symbol_img;

        public string symbol_Data = null;

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

        {

            if (this._dragdropWindow != null)

            {

                this._dragdropWindow.Close();

                this._dragdropWindow = null;

            }

            symbol_id = id;

            symbol_group_id = group_id;

            symbol_SelectedIndex = SelectedIndex;

            symbol_Data = Data_;

            symbol_img = img;

            CreateDragDropWindow2(img);

        }

        private void CreateDragDropWindow2(ImageSource image)

        {

            this._dragdropWindow = new Window();

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

            _dragdropWindow.WindowStyle = WindowStyle.None;

            _dragdropWindow.AllowsTransparency = true;           

            _dragdropWindow.AllowDrop = false;

            _dragdropWindow.Background = null;

            _dragdropWindow.IsHitTestVisible = false;

            _dragdropWindow.SizeToContent = SizeToContent.WidthAndHeight;

            _dragdropWindow.Topmost = true;

            _dragdropWindow.ShowInTaskbar = false;

            Rectangle r = new Rectangle();

            r.Width = image.Width;

            r.Height = image.Height;

            r.Opacity = 0.5;            

            r.Fill = new ImageBrush(image);

            this._dragdropWindow.Content = r;

            Win32Point w32Mouse = new Win32Point();

            GetCursorPos(ref w32Mouse);

            //w32Mouse.X = getCurrentPoint.X;

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

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

            this._dragdropWindow.Show();

        }

        private void zoomAndPanControl_MouseMove(object sender, MouseEventArgs e)

        {

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

            {

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

                Point currentPos = e.GetPosition(rect);

                floatingTip.HorizontalOffset = currentPos.X + 20;

                floatingTip.VerticalOffset = currentPos.Y;

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

                //tool.Content = "ToolTip";

                //panel.ToolTip = tool;

            }

            if (mouseHandlingMode != MouseHandlingMode.Drawing)

            {

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

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

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

                //if (firstCondition != null)

                //{

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

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

                //    {

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

                //        return;

                //    }

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

                //    {

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

                //        return;

                //    }

                //    if (L_Size == 0)

                //    {

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

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

                //    }

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

                //    {

                //        case "RectangleControl":

                //            {

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

                //            }

                //            break;

                //        case "CircleControl":

                //            {

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

                //            }

                //            break;

                //        case "TriControl":

                //            {

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

                //            }

                //            break;

                //        case "RectCloudControl":

                //            {

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

                //            }

                //            break;

                //        case "CloudControl":

                //            {

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

                //            }

                //            break;

                //        case "PolygonControl":

                //            {

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

                //            }

                //            break;

                //        case "ArcControl":

                //            {

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

                //            }

                //            break;

                //        case "LineControl":

                //            {

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

                //            }

                //            break;

                //        case "ArrowControl_Multi":

                //            {

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

                //            }

                //            break;

                //        default:

                //            {

                //            }

                //            break;

                //    }

                //} 

                #endregion

            }

            getCurrentPoint = e.GetPosition(drawingRotateCanvas);

            #region 주석

            //if (mouseButtonDown == MouseButton.Middle)

            //{

            //    SetCursor();

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

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

            //    Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

            //    zoomAndPanControl.ContentOffsetX -= dragOffset.X;

            //    zoomAndPanControl.ContentOffsetY -= dragOffset.Y;

            //    //SetCursor();

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

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

            //    //Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

            //    //zoomAndPanControl.ContentOffsetX += 1;

            //    //zoomAndPanControl.ContentOffsetY += 1;

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

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

            //}

            #endregion

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

            {

                SetCursor();

                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);

                Vector dragOffset = currentCanvasZoomPanningMouseMovePoint - canvasZoommovingMouseDownPoint;

                zoomAndPanControl.ContentOffsetX -= dragOffset.X;

                zoomAndPanControl.ContentOffsetY -= dragOffset.Y;

                if (Sync.IsChecked)

                {

                    ViewerDataModel.Instance.Sync_ContentOffsetX = zoomAndPanControl.ContentOffsetX;

                    ViewerDataModel.Instance.Sync_ContentOffsetY = zoomAndPanControl.ContentOffsetY;

                }

            }

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

            {

                Point currentCanvasDrawingMouseMovePoint = e.GetPosition(drawingRotateCanvas);

                Point currentCanvasZoomPanningMouseMovePoint = e.GetPosition(zoomAndPanCanvas);