MARKUS

using IIpc;

using IKCOM;

using KCOM.Common;

using KCOMDataModel.DataModel;

using MarkupToPDF.Common;

using MarkupToPDF.Controls.Parsing;

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.ComponentModel;

using System.Diagnostics;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Input;

using System.Windows.Media;

using Telerik.Windows.Controls;

using static MarkupToPDF.Controls.Parsing.MarkupParser;

namespace KCOM.Controls

{

    /// <summary>

    /// Interaction logic for PageNavigator.xaml

    /// </summary>

    public partial class Sample : UserControl, INotifyPropertyChanged

    {

        public List<FAVORITE_DOC> _FavoriteSet { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;

        public DelegateCommand SelectCommentCommand { get; private set; }

        public Sample()

        {

            InitializeComponent();

            if (App.IsDesignMode)

            {

                return;

            }

            App.splashString(ISplashMessage.SAMPLE);

            this.SizeChanged += Sample_SizeChanged1;

            this.Loaded += Sample_Loaded;

            this.Unloaded += Sample_Unloaded;

        }

        private void Sample_SizeChanged1(object sender, SizeChangedEventArgs e)

        {

            if(e.PreviousSize.Width != e.NewSize.Width)

            {

                ImgListbox.ApplyTemplate();

            }

        }

        private void Sample_Unloaded(object sender, RoutedEventArgs e)

        {

        }

        private void Sample_Loaded(object sender, RoutedEventArgs e)

        {

            if(!_Initialize)

            {

                _Initialize = true;

                SelectCommentCommand = new DelegateCommand(SetCommentPages);

                this.SizeChanged += Sample_SizeChanged;

                this.lstSelectComment.SelectionChanged += new System.Windows.Controls.SelectionChangedEventHandler(lstSelectComment_SelectionChanged);

                this.ImgListbox.SelectionChanged += new SelectionChangedEventHandler(ImgListbox_SelectionChanged);

                this.ImgListbox.PreviewKeyUp += ImgListbox_PreviewKeyUp;

            }            

        }

        private void Sample_SizeChanged(object sender, SizeChangedEventArgs e)

        {

            if (e.WidthChanged)

            {

                ImgListbox.ApplyTemplate();

            }

        }

        public static readonly DependencyProperty FilteredThumbnailProperty =  DependencyProperty.Register("FilteredThumbnail", typeof(CollectionViewSource),typeof(Sample)

                                                                            ,new PropertyMetadata(null,new PropertyChangedCallback(FilteredThumbnailPropertyChanged)));

        private static void FilteredThumbnailPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            var owner = d as Sample;

            if(owner != null)

            {

                owner.ImgListbox.ApplyTemplate();

            }

        }

        public CollectionViewSource FilteredThumbnail

        {

            get { return (CollectionViewSource)GetValue(FilteredThumbnailProperty); }

            set { SetValue(FilteredThumbnailProperty, value); }

        }

        public static readonly DependencyProperty CurrentPageProperty 

            = DependencyProperty.Register("CurrentPage", typeof(ThumbnailItem), typeof(Sample),new PropertyMetadata(null,CurrentPageChnaged));

        private static void CurrentPageChnaged(DependencyObject d, DependencyPropertyChangedEventArgs e)

        {

            //var owner = d as Sample;

            //if (owner?.UsersCommentPagesList != null)

            //{

            //    owner.SetCommentPages();

            //}

        }

        public ThumbnailItem CurrentPage

        {

            get { return (ThumbnailItem)GetValue(CurrentPageProperty); }

            set { SetValue(CurrentPageProperty, value); }

        }

        public ObservableCollection<ThumbnailItem> _thumbnailItems;

        private List<DOCPAGE> _PageList = null;

        private string _DefaultUri = null;

        public int PageCount = 0;

        private bool _Initialize;

        public event EventHandler<EventArgs> ThumbInitialized;

        public event EventHandler<PageChangeEventArgs> PageChanged;

        public event EventHandler<PageChangeEventArgs> PageChanging;

        private ObservableCollection<UsersCommentPagesMember> _UsersCommentPagesList;

        public ObservableCollection<UsersCommentPagesMember> UsersCommentPagesList

        {

            get {

                if(_UsersCommentPagesList == null)

                {

                    _UsersCommentPagesList = new ObservableCollection<UsersCommentPagesMember>();

                }

                return _UsersCommentPagesList; }

            set { _UsersCommentPagesList = value; }

        }

        public class PageChangeEventArgs : EventArgs

        {

            public DOCPAGE CurrentPage { get; set; }

            public string PageUri { get; set; }

            public int PageNumber { get; set; }

        }

        private bool _IsFitOn { get; set; }

        public bool IsFitOn

        {

            get

            {

                return _IsFitOn;

            }

            set

            {

                _IsFitOn = value;

                RaisePropertyChanged("IsFitOn");

            }

        }

        public void RaisePropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public async Task SetPageNaviAsync(List<DOCPAGE> PageList, string DefaultUri)

        {

            App.splashString(ISplashMessage.SAMPLE);

            //rdoAllPages.Checked += new RoutedEventHandler(rdoCommented_Checked);

            //rdoFavoritePages.Checked += new RoutedEventHandler(rdoFavoritePages_Checked);

            this._PageList = PageList;

            this._DefaultUri = DefaultUri;

            string tempStoragePath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "MARKUS", System.IO.Path.GetRandomFileName());

            //ThumbnailSetAsync();

            await this.Dispatcher.InvokeAsync(()=> ThumbnailSetAsync());

            this.PageCount = PageList.Count();

            string endpoint = Common.Commons.shortGuid() + "Thumbnail";

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

            wcfServer.IpcThumbnailReceived += WcfServer_IpcThumbnailReceived;

            wcfServer.Start();

            DownloadProcess.ThumbnailDownloader(endpoint,ViewerDataModel.Instance.IsAdmin, this._DefaultUri, tempStoragePath, "jpg", this.PageCount);

            DownloadProcess.ProcessMonitor(ViewerDataModel.Instance.IsAdmin, tempStoragePath, App.PageStorage.LocalStorage,Common.ViewerDataModel.Instance.OriginalTempFile);

            App.splashScreen.Close();

        }

        private void WcfServer_IpcThumbnailReceived(object sender, IpcThumbnailEventArgs e)

        {

            var items = _thumbnailItems.Where(x => x.PageNumber == e.PageNo);

            if (items.Count() > 0)

            {

                //Dispatcher.BeginInvoke((Action)delegate ()

                //{

                items.First().ImageUri = new Uri(e.Path, UriKind.Absolute);

                System.Diagnostics.Debug.WriteLine($"no:{e.PageNo} {e.Path}");

                if(e.IsLast)

                {

                    (sender as IIpc.IIpcServer).IpcThumbnailReceived -= WcfServer_IpcThumbnailReceived;

                    //(sender as IIpc.IIpcServer).Stop();

                }

                //if (e.PageNo > 2 && ImgListbox.Items.Count > 0)

                //{

                //    ImgListbox.IsScrollIntoViewEnabled = true;

                //    //ImgListbox.BringIntoView();

                //    ImgListbox.ScrollIntoView(0);

                //}

                //});

            }

        }

        void rdoCommented_Checked(object sender, RoutedEventArgs e)

        {

            Logger.sendCheckLog("rdoCommented_Checked", 1);

            SetCommentPages();

        }

        void rdoFavoritePages_Checked(object sender, RoutedEventArgs e)

        {

            Logger.sendCheckLog("rdoFavoritePages_Checked", 1);

            //if (rdoFavoritePages.IsChecked == true)

            //    expCommentPages.IsExpanded = false;

            //_FavoriteSet = _FavoriteSet == null ? new List<FAVORITE_DOC>() : _FavoriteSet;

            //if (_FavoriteSet.Count > 0)

            //{

            //    SetCommentPages(); //수정    

            //}

            //else

            //{

            //    rdoAllPages.IsChecked = true;

            //    rdoFavoritePages.IsChecked = false;

            //}

        }

        private async void ShowPageChange(object sender, RoutedEventArgs e)

        {

            //if (rdoAllPages.IsChecked == true) expCommentPages.IsExpanded = false;

            if (IsInitialized)

            {

                //ThumbnailSetAsync();

                await this.Dispatcher.InvokeAsync(() => ThumbnailSetAsync());

            }

        }

        void expCommentPages_PreviewCollapsed(object sender, Telerik.Windows.RadRoutedEventArgs e)

        {

            //txtThumbCount.Visibility = Visibility.Collapsed;            

        }

        void expCommentPages_PreviewExpanded(object sender, Telerik.Windows.RadRoutedEventArgs e)

        {

            Logger.sendCheckLog("expCommentPages_PreviewExpanded", 1);

            rdoAllPages.IsChecked = false;

            rdoFavoritePages.IsChecked = false;

            //txtThumbCount.Visibility = Visibility.Visible;

            SetCommentPages();

        }

        private void ImgListbox_PreviewKeyUp(object sender, KeyEventArgs e)

        {

            if (ImgListbox.SelectedItem != null && (e.Key == Key.Up || e.Key == Key.Down))

            {

                System.Diagnostics.Debug.WriteLine("ImgListbox_PreviewKeyUp");

                PageChange(ImgListbox.SelectedItem as KCOM.Common.ThumbnailItem);

            }

        }

        /// <summary>

        /// called when image list box's selection is changed

        /// </summary>

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

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

        private void ImgListbox_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)

        {

            if (!Keyboard.IsKeyDown(Key.Down) && !Keyboard.IsKeyDown(Key.Up))

            {

                if (ImgListbox.SelectedItem != null)

                {

                    PageChange(ImgListbox.SelectedItem as KCOM.Common.ThumbnailItem);

                }

            }

        }

        private void PageChange(KCOM.Common.ThumbnailItem selectItem)

        { 

                var number = selectItem.PageNumber;

                if (ViewerDataModel.Instance.SyncPageNumber != number)

                {

                    ViewerDataModel.Instance.SystemMain.dzTopMenu._SaveEvent(null, null);   /// save controls

                    this.CurrentPage = ImgListbox.SelectedItem as KCOM.Common.ThumbnailItem;

                    PageChanging(this, new PageChangeEventArgs

                    {

                        CurrentPage = this._PageList.Where(p => p.PAGE_NUMBER == number).First(),

                        PageNumber = number,

                        PageUri = null

                    });

                }

        }

        public bool GotoPageFlag = false;

        /// <summary>

        /// 해당 썸네일로 이동

        /// </summary>

        /// <param name="_pageNumber">이동할 페이지 번호</param>

        public void GotoPage(int _pageNumber)

        {

            try

            {

                //System.Threading.Tasks.Task.Factory.StartNew(() => { 

                    var _page = _thumbnailItems.Where(item => item.PageNumber == _pageNumber);

                    if (_page.Count() > 0)

                    {

                        ThumbnailItem thumbnailitem = _page.First();

                        if (PageChanging != null)

                        {

                            ImgListbox.Dispatcher.InvokeAsync(() => {  

                                var _itemIndex = this._thumbnailItems.IndexOf(thumbnailitem);

                                ImgListbox.SelectedItem = thumbnailitem;

                                if (navigationTab.SelectedIndex != 0)

                                {

                                    PageChange(thumbnailitem);

                                }

                            });

                            //ImgListbox.Items.MoveCurrentTo(thumbnailitem);

                            //if (_itemIndex < _thumbnailItems.Count() - 1)

                            //    ImgListbox.ScrollIntoView(_itemIndex);

                            //else

                            //    ImgListbox.ScrollIntoView(this._thumbnailItems.Count() - 1);

                        }

                    }

                //}).ConfigureAwait(false);

            }

            catch(Exception ex)

            {

                //Logger.sendResLog("GotoPage", ex.Message, 0);

            }

        }

        /// <summary>

        /// 주어진 페이지로 변경한다

        /// </summary>

        /// <param name="iPageNo">변경할 페이지 번호</param>

        public void ChangePage(int iPageNo)

        {

            var thumbitem = this._thumbnailItems.Where(item => item.PageNumber == iPageNo).FirstOrDefault();

            if ((PageChanged != null) && (thumbitem != null))

            {

                var uri = thumbitem.PageUri.ToString();

                    //_DefaultUri.Replace("{PageNo}", thumbitem.PageNumber.ToString());

                var _DocPages = _PageList.Where(p => p.PAGE_NUMBER == thumbitem.PageNumber).FirstOrDefault();

                if (_DocPages != null)

                {

                    PageChanged(this, new PageChangeEventArgs

                    {

                        CurrentPage = _DocPages,

                        PageUri = uri,

                        PageNumber = thumbitem.PageNumber

                    });

                    //ImgListbox.SelectedItem = thumbitem;                    

                    //ImgListbox.Items.MoveCurrentTo(thumbitem);

                    this.CurrentPage = thumbitem;

                }

                else

                {

                    //System.Diagnostics.Debug.WriteLine("페이지 정보가 없습니다");

                }

            }

        }

        public void GotoPageTALK(int _pageNumber, int _angle)

        {

            int _PageNo = -1;

            if (int.TryParse(_pageNumber.ToString(), out _PageNo))

            {

                var _page = _thumbnailItems.Where(item => item.PageNumber == _PageNo);

                if (_page.Count() > 0)

                {

                    ThumbnailItem _item = _page.First();

                    setPageChangeTALK(_item, _angle);

                    this.ImgListbox.SelectedIndex = _pageNumber - 1;

                    //this.ImgListbox.ScrollIntoView(_pageNumber - 1);

                }

            }

        }

        public void setPageChangeTALK(ThumbnailItem thumbnailItem, int _angle)

        {

            if (thumbnailItem != null)

            {

                if (PageChanging != null)

                {

                    ///this.CurrentPage = _NextPage;

                    ///_NextPage = thumbnailItem;

                    PageChanging(this, new PageChangeEventArgs

                    {

                        CurrentPage = _PageList.Where(p => p.PAGE_NUMBER == thumbnailItem.PageNumber).First(),

                        PageNumber = Convert.ToInt32(thumbnailItem.PageNumber),

                        PageUri = null

                    });

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

                    var rotationNum = (_angle - instanceMain.dzMainMenu.rotate.Angle) / 90;

                    if (rotationNum > 0) // 1, 2, 3

                    {

                        for (int i = 0; i < rotationNum; i++)

                        {

                            drawingPannelRotate(true);

                        }

                    }

                    else if (rotationNum < 0)// -1, -2, -3

                    {

                        for (int i = 0; i < -rotationNum; i++)

                        {

                            drawingPannelRotate(false);

                        }

                    }

                }

            }

        }

        public void drawingPannelRotate(bool Flag)

        {

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

            if (Flag)

            {

                if (instanceMain.dzMainMenu.rotate.Angle == 270)

                {

                    instanceMain.dzMainMenu.rotate.Angle = 0;

                }

                else

                {

                    instanceMain.dzMainMenu.rotate.Angle += 90;

                }

            }

            else

            {

                if (instanceMain.dzMainMenu.rotate.Angle == 0)

                {

                    instanceMain.dzMainMenu.rotate.Angle = 270;

                }

                else

                {

                    instanceMain.dzMainMenu.rotate.Angle -= 90;

                }

            }

            if (instanceMain.dzMainMenu.zoomAndPanCanvas.Width == ViewerDataModel.Instance.ContentWidth)

            {

                double emptySize = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;

                instanceMain.dzMainMenu.zoomAndPanCanvas.Width = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;

                instanceMain.dzMainMenu.zoomAndPanCanvas.Height = emptySize;

            }

            if (instanceMain.dzMainMenu.rotate.Angle == 0)

            {

                instanceMain.dzMainMenu.translate.X = 0;

                instanceMain.dzMainMenu.translate.Y = 0;

            }

            else if (instanceMain.dzMainMenu.rotate.Angle == 90)

            {

                instanceMain.dzMainMenu.translate.X = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;

                instanceMain.dzMainMenu.translate.Y = 0;

            }

            else if (instanceMain.dzMainMenu.rotate.Angle == 180)

            {

                instanceMain.dzMainMenu.translate.X = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;

                instanceMain.dzMainMenu.translate.Y = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;

            }

            else

            {

                instanceMain.dzMainMenu.translate.X = 0;

                instanceMain.dzMainMenu.translate.Y = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;

            }

            instanceMain.dzMainMenu.zoomAndPanControl.RotationAngle = instanceMain.dzMainMenu.rotate.Angle;

            ViewerDataModel.Instance.ContentWidth = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;

            ViewerDataModel.Instance.ContentHeight = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;

            ViewerDataModel.Instance.AngleOffsetX = instanceMain.dzMainMenu.translate.X;

            ViewerDataModel.Instance.AngleOffsetY = instanceMain.dzMainMenu.translate.Y;

            ViewerDataModel.Instance.MarkupAngle = instanceMain.dzMainMenu.rotate.Angle;

            instanceMain.dzMainMenu.pageNavigator._thumbnailItems.Where(info => info.PageNumber == instanceMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber).ToList().ForEach(data =>

            {

                data.Angle = int.Parse(instanceMain.dzMainMenu.rotate.Angle.ToString());

                //instanceMain.dzMainMenu.pageNavigator.ImgListbox.ItemsSource = instanceMain.dzMainMenu.pageNavigator._thumbnailItems;

                var instance = instanceMain.dzMainMenu.CurrentDoc.docInfo.DOCPAGE.Where(p => p.PAGE_NUMBER == instanceMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber).FirstOrDefault();

                instance.PAGE_ANGLE = int.Parse(instanceMain.dzMainMenu.rotate.Angle.ToString());

                var rotationdoc = ViewerDataModel.Instance.RotationDocs.Where(d => d.ID == instance.ID).FirstOrDefault();

                if (rotationdoc != null)

                {

                    rotationdoc.PAGE_ANGLE = instance.PAGE_ANGLE;

                }

                else

                {

                    ViewerDataModel.Instance.RotationDocs.Add(instance);

                }

                instanceMain.dzMainMenu.pageNavigator.GotoPage(data.PageNumber);

            });

        }

        void lstSelectComment_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)

        {

            SetCommentPages();

        }

        public async void SetCommentPages(object obj = null)

        {

            //ThumbnailSetAsync();

            await this.Dispatcher.InvokeAsync(() => ThumbnailSetAsync());

        }

        public void SetCommentList(List<UsersCommentPagesMember> UsersCommentPagesList,CancellationToken? cts)

        {

            Logger.sendCheckLog("SetCommentList", 1);

            Logger.sendCheckLog("SetCommentList_기존 Comment 색상 제거", 1);

            #region 기존 색상 제거 작업

            foreach (var item in this._thumbnailItems)

            {

                if (item.DisplayColorItems != null)

                {

                    item.DisplayColorItems.Clear();

                }

            }

            #endregion

            Logger.sendCheckLog("SetCommentList_delItem select 및 remove", 1);

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

            this.UsersCommentPagesList.ToList().ForEach(item =>

            {

                var _comm = UsersCommentPagesList.Where(a => a.MarkupInfoID == item.MarkupInfoID);

                if (_comm.Count() == 0)

                {

                    _delItem.Add(item);

                }

                if (cts != null)

                {

                    if (cts.Value.IsCancellationRequested)

                        return;

                }

            });

            _delItem.ForEach(f => this.UsersCommentPagesList.Remove(f));

            Logger.sendCheckLog("SetCommentList_UsersCommentPagesMember_PropertyChanged", 1);

            List<SetColorMarkupItem> setColorMarkupItems = new List<SetColorMarkupItem>();

            UsersCommentPagesList.ForEach(user =>

            {

                //user.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(user_PropertyChanged);

                //user.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(user_PropertyChanged);

                var _commLst = this.UsersCommentPagesList.Where(o => o.MarkupInfoID == user.MarkupInfoID);

                if (_commLst.Count() == 0)

                {

                    this.UsersCommentPagesList.Add(user);

                }

                else

                {

                    if (_commLst.First().PageNumber != user.PageNumber)

                        _commLst.First().PageNumber = user.PageNumber;

                }

                user.PageNumber.ForEach(page =>

                {

                    var _items = this._thumbnailItems.Where(item => item.PageNumber == page);

                    if (_items.Count() > 0)

                    {

                        setColorMarkupItems.Add(new SetColorMarkupItem { DisplayColor = user.SetColor, markupID = user.MarkupInfoID, Page = page });

                    }

                    if (cts != null)

                    {

                        if (cts.Value.IsCancellationRequested)

                            return;

                    }

                });

            });

            foreach (var item in this._thumbnailItems)

            {

                item.DisplayColorItems = setColorMarkupItems.Where(color => color.Page == item.PageNumber).ToList();

            }

            Logger.sendCheckLog("SetCommentList_SelectComment.ItemsSource 설정", 1);

            var data = UsersCommentPagesList.OrderByDescending(p => p.isConSolidation == Convert.ToInt32(true)).ToList();

            if (data.Count() != 0)

            {

                if (Convert.ToBoolean(data.First().isConSolidation))

                {

                    data.Where(p => p.isConSolidation == Convert.ToInt32(true)).FirstOrDefault().UserName = "Consolidated";

                    data.Where(p => p.isConSolidation == Convert.ToInt32(true)).FirstOrDefault().Depart = "";

                    this.lstSelectComment.ItemsSource = data;

                }

            }

            this.lstSelectComment.ItemsSource = this.UsersCommentPagesList;  //섬네일   

            Logger.sendCheckLog("SetComme6ntList_ImgListbox 설정", 1);

            //var template = this.ImgListbox.ItemTemplate;

            //this.ImgListbox.ItemTemplate = null;

            //this.ImgListbox.ItemTemplate = template;

        }

        List<int> FilterPages = null;

        private void ThumbnailSetAsync()

        {

            Logger.sendCheckLog("ThumbnailSet", 1);

            if (FilteredThumbnail == null)

            {

                var uri = _DefaultUri.Replace("{0}/{1}_{2}", "8/0_0");

                var pageList = ViewerDataModel.Instance.Document_Info;

                var items = from page in pageList

                            let pageLink = uri.Replace("{PageNo}", page.PAGE_NUMBER.ToString())

                            select new ThumbnailItem

                            {

                                //ImageUri = new Uri(pageLink),

                                PageUri = new Uri(pageLink.Replace("jpg", "png")),

                                PageNumber = page.PAGE_NUMBER,

                                Angle = page.PAGE_ANGLE

                            };

                _thumbnailItems = new ObservableCollection<ThumbnailItem>(items);

                FilteredThumbnail = new CollectionViewSource();

                FilteredThumbnail.SortDescriptions.Add(new SortDescription { Direction = ListSortDirection.Ascending, PropertyName = "PageNumber" });

                FilteredThumbnail.Source = _thumbnailItems;

                FilteredThumbnail.View.CurrentChanging += (snd, evt) =>

                  {

                      System.Diagnostics.Debug.WriteLine("ect");

                  };

                FilterPages = _thumbnailItems.Select(x=>x.PageNumber).ToList();

                FilteredThumbnail.Filter += (snd, evt) =>

                {

                    if (FilterPages?.Count() > 0 && evt.Item != null)

                    {

                        evt.Accepted = FilterPages.Contains((evt.Item as ThumbnailItem).PageNumber);

                    }

                    else

                    {

                        evt.Accepted = false;

                    }

                };

            }

            FilterPages.Clear();

            if (rdoAllPages.IsChecked == true)

            {

                FilterPages = _thumbnailItems.Select(x=>x.PageNumber).ToList();

            }

            else if (rdoFavoritePages.IsChecked == true)

            {

                if (_FavoriteSet != null)

                {

                    FilterPages = (from thumb in _thumbnailItems

                                where _FavoriteSet.Where(data => data.PAGE_NO == thumb.PageNumber).FirstOrDefault() != null

                                select thumb.PageNumber).ToList();

                }

            }

            else if (rdoCommentPages.IsChecked == true)

            {

                if (this.lstSelectComment.ItemsSource != null)

                {

                    var commentPages = (from commentPage in this.UsersCommentPagesList

                                        where commentPage.IsSelected == true

                                        select commentPage.PageNumber).SelectMany(x => x).Distinct();

                    if (commentPages?.Count() > 0)

                    {

                        FilterPages = (from thumb in _thumbnailItems

                                       where commentPages.Where(s => s == thumb.PageNumber).Count() > 0

                                       select thumb.PageNumber).ToList();

                    }

                }

            }

            if (FilterPages != null)

            {

                if(FilteredThumbnail == null)

                {

                    System.Diagnostics.Debug.WriteLine("filter null");

                }

                if (FilteredThumbnail.View == null)

                {

                    System.Diagnostics.Debug.WriteLine("filter null");

                }

                FilteredThumbnail.View.Refresh();

                if (FilterPages.Count() > 0)

                {

                    if (_thumbnailItems.Count() > 0)

                    {

                        ImgListbox.SelectedItem = _thumbnailItems[0];

                    }

                    //SetCommentList(UsersCommentPagesList.ToList());

                }

                else

                {

                    ImgListbox.SelectedItem = null;

                }

                if (ThumbInitialized != null)

                {

                    ThumbInitialized(this, new EventArgs());

                    ThumbInitialized = null;

                }

            }

        }

        private async void Border_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

        {

            if (e.ClickCount >= 2)

            {

                var selectItem = MarkupList.SelectedItem as IKCOM.MarkupItem;

                GotoPage(selectItem.PageNumber);

                var result = await MarkupParser.GetBaseControlAsync(selectItem.Data, ViewerDataModel.Instance.NewMarkupCancelToken());

                Rect rect = new Rect(new Point(result.StartPoint.X - 100, result.StartPoint.Y - 100), new Point(result.EndPoint.X + 100, result.EndPoint.Y + 100));

                this.ParentOfType<KCOM.Views.MainMenu>().zoomAndPanControl.ZoomTo(rect);

                //bool isGO = false;

                //var imageViewer = this.ParentOfType<KCOM.Views.MainMenu>().imageViewer;

                //imageViewer.SizeMode = Leadtools.Windows.Controls.SizeMode.Fit;

                //imageViewer.InteractiveMode = Leadtools.Windows.Controls.InteractiveMode.UserRectangle;

                //imageViewer.InteractiveUserRectangle += (sen, ea) =>

                //{

                //    System.Diagnostics.Debug.WriteLine(ea.Bounds);

                //    if (ea.Status == Leadtools.Windows.Controls.InteractiveModeStatus.End)

                //    {

                //        this.ParentOfType<KCOM.Views.MainMenu>().zoomAndPanControl.ZoomTo(ea.Bounds);                        

                //    }

                //};

                //imageViewer.SizeMode = Leadtools.Windows.Controls.SizeMode.Normal;

                //GotoPage(MarkupList.SelectedItem as MarkupList)

            }

        }

        public class MarkupInfoItemSmall

        {

            public string Id { get; set; }

            public string UserName { get; set; }

            public string UserID { get; set; }

            public int PageNumber { get; set; }

            public string Data { get; set; }

            public int Data_Type { get; set; }

            public bool IsConsolidate { get; set; }

        }

        private List<MarkupInfoItemSmall> _MarkupInfoSmallList { get; set; }

        public List<MarkupInfoItemSmall> MarkupInfoSmallList

        {

            get

            {

                if (_MarkupInfoSmallList == null)

                {

                    _MarkupInfoSmallList = new List<MarkupInfoItemSmall>();

                }

                return _MarkupInfoSmallList;

            }

            set

            {

                _MarkupInfoSmallList = value;

                RaisePropertyChanged("MarkupInfoSmallList");

            }

        }

        /// <summary>

        /// goto page and select item selected by user

        /// </summary>

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

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

        private async void RadButton_Click_OLD(object sender, RoutedEventArgs e)

        {

            var clickButtonItem = sender as RadButton;

            if (clickButtonItem != null && clickButtonItem.CommandParameter != null)

            {

                try

                {

                    Rect rect = new Rect();

                    Point s_point = new Point();

                    Point e_point = new Point();

                    MarkupInfoItemSmall gaza = clickButtonItem.CommandParameter as MarkupInfoItemSmall;

                    GotoPage(Convert.ToInt32(gaza.PageNumber));

                    var data = await MarkupToPDF.Serialize.Core.JsonSerializerHelper.UnCompressStringAsync(gaza.Data.ToString(),ViewerDataModel.Instance.NewMarkupCancelToken()); //언패킹작업

                    switch (Enum.Parse(typeof(MarkupToPDF.Controls.Common.ControlType), gaza.Data_Type.ToString()))

                    {

                        case MarkupToPDF.Controls.Common.ControlType.TextControl:

                            {

                                MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);

                                rect = new Rect(new Point(instance.StartPoint.X - 100, instance.StartPoint.Y - 100), new Point(instance.StartPoint.X + instance.BoxW + 100, instance.StartPoint.Y + instance.BoxW + 100));

                            }

                            break;

                        case MarkupToPDF.Controls.Common.ControlType.TextBorder:

                            {

                                MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);

                                rect = new Rect(new Point(instance.StartPoint.X - 100, instance.StartPoint.Y - 100), new Point(instance.StartPoint.X + instance.BoxW + 100, instance.StartPoint.Y + instance.BoxW + 100));

                            }

                            break;

                        case MarkupToPDF.Controls.Common.ControlType.TextCloud:

                            {

                                MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);

                                rect = new Rect(new Point(instance.StartPoint.X - 100, instance.StartPoint.Y - 100), new Point(instance.StartPoint.X + instance.BoxW + 100, instance.StartPoint.Y + instance.BoxW + 100));

                            }

                            break;

                        case MarkupToPDF.Controls.Common.ControlType.PolygonControl:

                            {

                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);

                                foreach (Point A in instance.PointSet)

                                {

                                    if (s_point == new Point())

                                    {

                                        s_point = A;

                                        e_point = A;

                                    }

                                    s_point.X = Math.Min(s_point.X, A.X);

                                    s_point.Y = Math.Min(s_point.Y, A.Y);

                                    e_point.X = Math.Max(e_point.X, A.X);

                                    e_point.Y = Math.Max(e_point.Y, A.Y);

                                }

                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));

                            }

                            break;

                        case MarkupToPDF.Controls.Common.ControlType.PolygonCloud:

                            {

                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);

                                foreach (Point A in instance.PointSet)

                                {

                                    if (s_point == new Point())

                                    {

                                        s_point = A;

                                        e_point = A;

                                    }

                                    s_point.X = Math.Min(s_point.X, A.X);

                                    s_point.Y = Math.Min(s_point.Y, A.Y);

                                    e_point.X = Math.Max(e_point.X, A.X);

                                    e_point.Y = Math.Max(e_point.Y, A.Y);

                                }

                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));

                            }

                            break;

                        case MarkupToPDF.Controls.Common.ControlType.ChainLine:

                            {

                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);

                                foreach (Point A in instance.PointSet)

                                {

                                    if (s_point == new Point())

                                    {

                                        s_point = A;

                                        e_point = A;

                                    }

                                    s_point.X = Math.Min(s_point.X, A.X);

                                    s_point.Y = Math.Min(s_point.Y, A.Y);

                                    e_point.X = Math.Max(e_point.X, A.X);

                                    e_point.Y = Math.Max(e_point.Y, A.Y);

                                }

                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));

                            }

                            break;

                        case MarkupToPDF.Controls.Common.ControlType.Ink:

                            {

                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);

                                foreach (Point A in instance.PointSet)

                                {

                                    if (s_point == new Point())

                                    {

                                        s_point = A;

                                        e_point = A;

                                    }

                                    s_point.X = Math.Min(s_point.X, A.X);

                                    s_point.Y = Math.Min(s_point.Y, A.Y);

                                    e_point.X = Math.Max(e_point.X, A.X);

                                    e_point.Y = Math.Max(e_point.Y, A.Y);

                                }

                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));

                            }

                            break;

                        default:

                            MarkupToPDF.Serialize.S_Control.S_BaseControl item = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);

                            rect = new Rect(new Point(item.StartPoint.X - 100, item.StartPoint.Y - 100), new Point(item.EndPoint.X + 100, item.EndPoint.Y + 100));

                            break;

                    }

                    SelectionSet.Instance.SelectItemByRect(rect, this.ParentOfType<KCOM.Views.MainMenu>());

                    this.ParentOfType<KCOM.Views.MainMenu>().zoomAndPanControl.ZoomTo(rect);

                }

                catch (Exception ex)

                {

                    this.ParentOfType<KCOM.Views.MainMenu>().DialogMessage_Alert(ex.Message, "Error");

                }

            }

        }

        private void btGotoMarkup_Click(object sender, RoutedEventArgs e)

        {

            var clickButtonItem = sender as RadButton;

            if (clickButtonItem != null && clickButtonItem.CommandParameter != null)

            {

                try

                {

                    MarkupInfoItemSmall gaza = clickButtonItem.CommandParameter as MarkupInfoItemSmall;

                    MarkupList.SelectedItem = gaza;

                    MarkupHelper.GotoMarkup(new[] { gaza.Id });

                }

                catch (Exception ex)

                {

                    this.ParentOfType<KCOM.Views.MainMenu>().DialogMessage_Alert(ex.Message, "Error");

                }

            }

        }

        ///// <summary>

        ///// 선택된 마크업의 ID리스트를 받아 해당 페이지로 이동 후 GotoSelectedMarkup 호출

        ///// </summary>

        ///// <param name="CommentIdList"></param>

        //private void GotoMarkup(IEnumerable<string> CommentIdList)

        //{

        //    var instance = Common.ViewerDataModel.Instance;

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

        //    var commentList = instance._markupInfoList.Where(x => x.MarkupList != null).SelectMany(x => x.MarkupList).Where(f => f.ID == CommentIdList.First());

        //    if (commentList.Count() > 0)

        //    {

        //        //하단 그리드의 markup list에서 commentid가 포함된 markupinfo를 선택되게 한다.

        //        #region markup list grid select items

        //        var infoItem = instance._markupInfoList.Where(x => x.MarkupList != null).Where(f => f.MarkupList.Count(y => y == commentList.First()) > 0);

        //        if (infoItem.Count() > 0)

        //        {

        //            var gridMarkup = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.gridViewMarkup;

        //            gridMarkup.SelectedItems.Clear();

        //            gridMarkup.SelectedItems.Add(infoItem.First());

        //        }

        //        #endregion

        //        var pageNavigator = instance.SystemMain.dzMainMenu.pageNavigator;

        //        if (pageNavigator.CurrentPage.PageNumber == commentList.First().PageNumber)

        //        {

        //            GotoSelectedMarkup(CommentIdList);

        //        }

        //        else

        //        {

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

        //            handler = (snd, evt) =>

        //            {

        //                GotoSelectedMarkup(CommentIdList);

        //                pageNavigator.PageChanged -= handler;

        //            };

        //            pageNavigator.PageChanged += handler;

        //            pageNavigator.GotoPage(commentList.First().PageNumber);

        //        }

        //    }

        //}

        ///// <summary>

        ///// 페이지 이동 후 마크업을 선택하고 Zoom을 한다.

        ///// 마크업이 페이지보다 크면 Zoom을 하지 않음.

        ///// </summary>

        ///// <param name="CommentIdList"></param>

        //private void GotoSelectedMarkup(IEnumerable<string> CommentIdList)

        //{

        //    var instance = Common.ViewerDataModel.Instance;

        //    var selectOrderComments = instance.MarkupControls.Where(x => CommentIdList.Count(y => y == x.CommentID) > 0).ToList();

        //    var commentUserInfo = instance.MarkupControls_USER.Where(x => CommentIdList.Count(y => y == x.CommentID) > 0).ToList();

        //    if (commentUserInfo.Count() > 0 || selectOrderComments.Count() > 0)

        //    {

        //        commentUserInfo.ForEach(x => x.IsSelected = true);

        //        commentUserInfo.AddRange(selectOrderComments);

        //        if (commentUserInfo?.Count() > 0)

        //        {

        //            var main = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu;

        //            try

        //            {

        //                if(Common.ViewerDataModel.Instance.Angle != 0)

        //                {

        //                    for (int i = 0; i < (Common.ViewerDataModel.Instance.Angle / 90); i++)

        //                    {

        //                        Common.ViewerDataModel.Instance.SystemMain.dzTopMenu.drawingPannelRotate(true);

        //                    } 

        //                    //Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.rotate.Angle = 0;

        //                    //Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.translate.X = 0;

        //                    //Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.translate.Y = 0;

        //                }

        //                Rect rect = commentUserInfo.First().ItemRect;

        //                foreach (var UserInfo in commentUserInfo)

        //                {

        //                    rect = Rect.Union(rect, UserInfo.ItemRect);

        //                }

        //                SelectionSet.Instance.SelectItemByRect(rect, main);

        //                var center = new Vector(Common.ViewerDataModel.Instance.ImageViewWidth / 2, Common.ViewerDataModel.Instance.ImageViewHeight / 2);

        //                //var matrix = MatrixHelper.Rotation(Common.ViewerDataModel.Instance.Angle);

        //                //rect.Transform(matrix);

        //                double scaleX = Common.ViewerDataModel.Instance.ImageViewWidth / rect.Width;

        //                double scaleY = Common.ViewerDataModel.Instance.ImageViewHeight / rect.Height;

        //                double newScale = main.zoomAndPanControl.ContentScale * Math.Min(scaleX, scaleY);

        //                double positionX = 0;

        //                double positionY = 0;

        //                if (Common.ViewerDataModel.Instance.Angle == 90)

        //                {

        //                    positionX = Common.ViewerDataModel.Instance.ImageViewHeight + rect.X;

        //                    positionY = Common.ViewerDataModel.Instance.ImageViewWidth + rect.Y;

        //                }

        //                main.zoomAndPanControl.ContentScale = newScale;

        //                main.zoomAndPanControl.ContentOffsetX = positionX;

        //                main.zoomAndPanControl.ContentOffsetY = positionY;

        //                var pageSize = new Size(main.pageNavigator.CurrentPage.Width, main.pageNavigator.CurrentPage.Height);

        //                double pageAngle = Common.ViewerDataModel.Instance.Angle;

        //                if (pageAngle == 90)

        //                {

        //                    pageAngle = 270;

        //                }

        //                else

        //                {

        //                    pageAngle = 90;

        //                }

        //                if ((rect.Size.Width + rect.Size.Height) > (pageSize.Width + pageSize.Height))

        //                {

        //                    var matrix = MatrixHelper.Rotation(Common.ViewerDataModel.Instance.Angle);

        //                    rect.Transform(matrix);

        //                    main.zoomAndPanControl.ZoomTo(rect);

        //                }

        //                else

        //                {

        //                    rect.Inflate(rect.Width * 3, rect.Height * 3);

        //                    var matrix = MatrixHelper.Rotation(Common.ViewerDataModel.Instance.Angle);

        //                    rect.Transform(matrix);

        //                    main.zoomAndPanControl.ZoomTo(rect);

        //                }

        //            }

        //            catch (Exception ex)

        //            {

        //                main.DialogMessage_Alert(ex.Message, "Error");

        //            }

        //        }

        //    }

        //}

        private void MarkupList_Loaded(object sender, RoutedEventArgs e)

        {

            LoadMakupList();

        }

        public void LoadMakupList()

        { 

            if (MarkupInfoSmallList.Count == 0)

            {

                ViewerDataModel.Instance._markupInfoList.ToList().ForEach(d =>

                {

                    if (d.MarkupList != null)

                    {

                        d.MarkupList.ForEach(b =>

                        {

                            bool isConsolidate = false;

                            if(d.Consolidate == 1 && d.AvoidConsolidate == 0)

                            {

                                isConsolidate = true;

                            }

                            System.Diagnostics.Debug.WriteLine($"UserID : {d.UserID} Consolidate : {d.Consolidate}  AvoidConsolidate : {d.AvoidConsolidate}");

                            MarkupInfoSmallList.Add(new MarkupInfoItemSmall

                            {

                                Id = b.ID,

                                Data = b.Data,

                                Data_Type = b.Data_Type,

                                PageNumber = b.PageNumber,

                                UserID = d.UserID,

                                UserName = d.UserName,

                                IsConsolidate = isConsolidate

                            });

                        });

                    }

                });

                MarkupList.ItemsSource = null;

                MarkupList.ItemsSource = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();

                FilterUpdate();

            }

        }

        public void MarkupListUpdate(MarkupReturn res, Event_Type eventType, string CommentID, MarkupInfoItem item)

        {

            if (MarkupInfoSmallList.Count == 0)

            {

                ViewerDataModel.Instance._markupInfoList.ToList().ForEach(d =>

                {

                    if (d.MarkupList != null)

                    {

                        d.MarkupList.ForEach(b =>

                        {

                            MarkupInfoSmallList.Add(new MarkupInfoItemSmall

                            {

                                Id = b.ID,

                                Data = b.Data,

                                Data_Type = b.Data_Type,

                                PageNumber = b.PageNumber,

                                UserID = d.UserID,

                                UserName = d.UserName,

                            });

                        });

                    }

                });

                MarkupList.ItemsSource = null;

                MarkupList.ItemsSource = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();

            }

            switch (eventType)

            {

                case Event_Type.Create:

                    MarkupInfoSmallList.Add(new MarkupInfoItemSmall

                    {

                        Id = res.CommentID,

                        Data = res.ConvertData,

                        Data_Type = res.DATA_TYPE,

                        PageNumber = CurrentPage.PageNumber,

                        UserID = App.ViewInfo.UserID,

                        UserName = App.UserName,

                    });

                    break;

                case Event_Type.Delete:

                    if(CommentID == null) //user information list delete btn

                    {

                        foreach (var delItem in item.MarkupList)

                        {

                            MarkupInfoSmallList.RemoveAll(p => p.Id == delItem.ID);

                        }

                    }

                    else //delete, cut, 

                    {

                        MarkupInfoSmallList.RemoveAll(p => p.Id.Equals(CommentID));

                    }                    

                    break;

                case Event_Type.Thumb://이동 회전

                    MarkupInfoSmallList.RemoveAll(p => p.Id.Equals(res.CommentID));

                    MarkupInfoSmallList.Add(new MarkupInfoItemSmall

                    {

                        Id = res.CommentID,

                        Data = res.ConvertData,

                        Data_Type = res.DATA_TYPE,

                        PageNumber = CurrentPage.PageNumber,

                        UserID = App.ViewInfo.UserID,

                        UserName = App.UserName,

                    });

                    break;

                default:

                    break;

            }

            List<MarkupInfoItemSmall> TempMarkupInfoSmallList = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();

            bool IsConsolidation = false;

            string UserId = null;

            if (commentUser.SelectedValue != null)

            {

                if (((KCOM.Common.UsersCommentPagesMember)commentUser.SelectedValue).UserName != "Consolidated")

                {

                    UserId = ((KCOM.Common.UsersCommentPagesMember)commentUser.SelectedValue).UserName;

                }

                else

                {

                    IsConsolidation = true;

                }

            }

            var filterItems = TempMarkupInfoSmallList.WhereIf(commentType.SelectedValue != null, d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue))

                                 .WhereIf(UserId != null, d => d.UserName == ((KCOM.Common.UsersCommentPagesMember)commentUser.SelectedValue).ToString())

                                 .WhereIf(commentPage.SelectedValue != null, d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue));

            MarkupList.ItemsSource = TempMarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();

            FilterUpdate();

        }

        private void FilterUpdate(string selectUser = null)

        {

            //var items = MarkupList.ItemsSource as List<MarkupInfoItemSmall>;

            //commentType.ItemsSource = items.Select(d => d.Data_Type).Distinct().OrderBy(d => d).ToList();

            //commentPage.ItemsSource = items.Select(d => d.PageNumber).Distinct().OrderBy(d => d).ToList();

            var items = MarkupList.ItemsSource as List<MarkupInfoItemSmall>;

            var filterUsers = MarkupInfoSmallList.WhereIf(commentType.SelectedValue != null, d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue))

                                   .WhereIf(commentPage.SelectedValue != null, d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue));

            var filterTypes = MarkupInfoSmallList.WhereIf(selectUser != null, d => d.UserName == selectUser)

                                .WhereIf(commentPage.SelectedValue != null, d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue));

            var filterPages = MarkupInfoSmallList.WhereIf(commentType.SelectedValue != null, d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue))

                              .WhereIf(selectUser != null, d => d.UserName == selectUser);

            commentUser.ItemsSource = filterUsers.Select(d => d.UserName).Distinct().OrderBy(d => d).ToList();

            commentType.ItemsSource = filterTypes.Select(d => d.Data_Type).Distinct().OrderBy(d => d).ToList();

            commentPage.ItemsSource = filterPages.Select(d => d.PageNumber).Distinct().OrderBy(d => d).ToList();

        }

        private void commentFilter_SelectionChanged(object sender, SelectionChangedEventArgs e)

        {

            MarkupList.ItemsSource = null;

            txtSearch.Text = string.Empty;

            List<MarkupInfoItemSmall> TempMarkupInfoSmallList = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();

            bool IsConsolidation = false;

            string userName = null;

            if (commentUser.SelectedValue != null)

            {

                if(commentUser.SelectedValue?.ToString() != "Consolidated")

                {

                    userName = commentUser.SelectedValue.ToString();

                }

                else

                {

                    IsConsolidation = true;

                }

            }

            var filterItems = TempMarkupInfoSmallList.WhereIf(commentType.SelectedValue != null, d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue))

                                   .WhereIf(userName != null, d => d.UserName == userName)

                                   .WhereIf(IsConsolidation,d=>d.IsConsolidate == IsConsolidation)

                                   .WhereIf(commentPage.SelectedValue != null, d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue));

            MarkupList.ItemsSource = filterItems.OrderBy(d => d.PageNumber).ToList();

            FilterUpdate();

        }

        private void btnPanorama_Click(object sender, RoutedEventArgs e)

        {

            ViewerDataModel.Instance.SystemMain.dzTopMenu.PanoramaShow();

        }

        private async void btnSearch_Click(object sender, RoutedEventArgs e)

        {

            string search_str = txtSearch.Text;

            if(string.IsNullOrWhiteSpace(search_str))

            {

                return;

            }

            var sel_type = commentType.SelectedItem;

            var sel_user = commentUser.SelectedItem;

            var sel_page = commentPage.SelectedItem;

            List<MarkupInfoItemSmall> small_list = new List<MarkupInfoItemSmall>();

            List<MarkupInfoItemSmall> list = MarkupInfoSmallList;

            if (sel_page != null)

            {

                list = list.Where(d => d.PageNumber == Convert.ToInt32(sel_page)).ToList();

            }

            if (sel_type != null)

            {

                list = list.Where(d => d.Data_Type == Convert.ToInt32(sel_type)).ToList();

            }

            if (sel_user != null)

            {

                list = list.Where(d => d.UserID == (sel_user as MarkupInfoItem).UserID).ToList();

            }

            foreach (var item in list)

            {

                var data = await MarkupToPDF.Serialize.Core.JsonSerializerHelper.UnCompressStringAsync(item.Data.ToString(), ViewerDataModel.Instance.NewMarkupCancelToken());

                switch (Enum.Parse(typeof(MarkupToPDF.Controls.Common.ControlType), item.Data_Type.ToString()))

                {

                    case MarkupToPDF.Controls.Common.ControlType.TextControl:

                    case MarkupToPDF.Controls.Common.ControlType.TextBorder:

                    case MarkupToPDF.Controls.Common.ControlType.TextCloud:

                        {

                            MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);

                            if (!string.IsNullOrWhiteSpace(instance.Text))

                            {

                                if (instance.Text.ToLower().Contains(search_str.ToLower()))

                                {

                                    small_list.Add(item);

                                }

                            }

                        }

                        break;

                    case MarkupToPDF.Controls.Common.ControlType.ArrowTextBorderControl:

                    case MarkupToPDF.Controls.Common.ControlType.ArrowTextCloudControl:

                    case MarkupToPDF.Controls.Common.ControlType.ArrowTextControl:

                    case MarkupToPDF.Controls.Common.ControlType.ArrowTransTextBorderControl:

                    case MarkupToPDF.Controls.Common.ControlType.ArrowTransTextCloudControl:

                    case MarkupToPDF.Controls.Common.ControlType.ArrowTransTextControl:

                        {

                            MarkupToPDF.Serialize.S_Control.S_ArrowTextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_ArrowTextControl>(data);

                            if (!string.IsNullOrWhiteSpace(instance.ArrowText))

                            {

                                if (instance.ArrowText.Contains(search_str))

                                {

                                    small_list.Add(item);

                                }

                            }

                        }

                        break;

                }

            }

            MarkupList.ItemsSource = null;

            MarkupList.ItemsSource = small_list.OrderBy(d => d.PageNumber).ToList();

        }

        private void TxtSearch_KeyDown(object sender, KeyEventArgs e)

        {

            if(e.Key == Key.Enter || e.Key == Key.Return)

            {

                btnSearch_Click(sender, new RoutedEventArgs());

            }

        }

    }

}