프로젝트

일반

사용자정보

통계
| 브랜치(Branch): | 개정판:

markus / KCOM / Controls / Sample.xaml.cs @ 1137be84

이력 | 보기 | 이력해설 | 다운로드 (47.1 KB)

1
using IKCOM;
2
using KCOM.Common;
3
using KCOMDataModel.DataModel;
4
using MarkupToPDF.Common;
5
using MarkupToPDF.Controls.Parsing;
6
using System;
7
using System.Collections.Generic;
8
using System.Collections.ObjectModel;
9
using System.ComponentModel;
10
using System.Diagnostics;
11
using System.Linq;
12
using System.Windows;
13
using System.Windows.Controls;
14
using System.Windows.Input;
15
using System.Windows.Media;
16
using Telerik.Windows.Controls;
17
using static MarkupToPDF.Controls.Parsing.MarkupParser;
18

    
19
namespace KCOM.Controls
20
{
21
    /// <summary>
22
    /// Interaction logic for PageNavigator.xaml
23
    /// </summary>
24
    public partial class Sample : UserControl, INotifyPropertyChanged
25
    {
26
        public List<FAVORITE_DOC> _FavoriteSet { get; set; }
27
        public event PropertyChangedEventHandler PropertyChanged;
28
        public Sample()
29
        {             
30
            App.splashString(ISplashMessage.SAMPLE);
31
            this.Loaded += Sample_Loaded;
32
        }
33

    
34
        private void Sample_Loaded(object sender, RoutedEventArgs e)
35
        {
36
            if(!_Initialize)
37
            {
38
                InitializeComponent();
39
                _Initialize = true;
40
                this.lstSelectComment.SelectionChanged += new System.Windows.Controls.SelectionChangedEventHandler(lstSelectComment_SelectionChanged);
41
                this.ImgListbox.SelectionChanged += new SelectionChangedEventHandler(ImgListbox_SelectionChanged);                
42
            }            
43
        }
44

    
45
        public ObservableCollection<ThumbnailItem> _thumbnailItems;
46
        private List<DOCPAGE> _PageList = null;
47
        private string _DefaultUri = null;
48
        public ThumbnailItem CurrentPage = null;
49
        public int PageCount = 0;
50
        private bool _Initialize;
51
        public event EventHandler<PageChangeEventArgs> PageChanged;
52
        public event EventHandler<PageChangeEventArgs> PageChanging;
53
        List<UsersCommentPagesMember> _UsersCommentPagesList = new List<UsersCommentPagesMember>();
54
        public class PageChangeEventArgs : EventArgs
55
        {
56
            public DOCPAGE CurrentPage { get; set; }
57
            public string PageUri { get; set; }
58
            public int PageNumber { get; set; }
59
        }
60
        private bool _IsFitOn { get; set; }
61
        public bool IsFitOn
62
        {
63
            get
64
            {
65
                return _IsFitOn;
66
            }
67
            set
68
            {
69
                _IsFitOn = value;
70
                RaisePropertyChanged("IsFitOn");
71
            }
72
        }
73

    
74
        public void RaisePropertyChanged(string propName)
75
        {
76
            if (PropertyChanged != null)
77
                PropertyChanged(this, new PropertyChangedEventArgs(propName));
78
        }
79

    
80
        public void SetPageNavi(List<DOCPAGE> PageList, string DefaultUri)
81
        {
82
            Logger.sendCheckLog("SetPageNavi", 1);
83
            this._PageList = PageList;
84
            this._DefaultUri = DefaultUri;
85
            ThumbnailSet();
86
            this.PageCount = PageList.Count();
87
            //ThumbNmailSet();
88
            rdoAllPages.Checked += new RoutedEventHandler(rdoCommented_Checked);
89
            rdoFavoritePages.Checked += new RoutedEventHandler(rdoFavoritePages_Checked);
90
            expCommentPages.PreviewCollapsed += new Telerik.Windows.RadRoutedEventHandler(expCommentPages_PreviewCollapsed);
91
            expCommentPages.PreviewExpanded += new Telerik.Windows.RadRoutedEventHandler(expCommentPages_PreviewExpanded);
92
        }
93

    
94
        void rdoCommented_Checked(object sender, RoutedEventArgs e)
95
        {
96
            Logger.sendCheckLog("rdoCommented_Checked", 1);
97
            if (rdoAllPages.IsChecked == true) expCommentPages.IsExpanded = false;
98
            SetCommentPages();
99
        }
100

    
101
        void rdoFavoritePages_Checked(object sender, RoutedEventArgs e)
102
        {
103
            Logger.sendCheckLog("rdoFavoritePages_Checked", 1);
104
            if (rdoFavoritePages.IsChecked == true)
105
                expCommentPages.IsExpanded = false;
106

    
107
            _FavoriteSet = _FavoriteSet == null ? new List<FAVORITE_DOC>() : _FavoriteSet;
108
            if (_FavoriteSet.Count > 0)
109
            {
110
                SetCommentPages_Favorite(); //수정    
111
            }
112
            else
113
            {
114
                rdoAllPages.IsChecked = true;
115
                rdoFavoritePages.IsChecked = false;
116
            }
117
        }
118

    
119
        private void SetCommentPages_Favorite()
120
        {
121
            ThumbnailSet();            
122
            SetCommentPages();
123
        }
124

    
125
        void expCommentPages_PreviewCollapsed(object sender, Telerik.Windows.RadRoutedEventArgs e)
126
        {
127
            //txtThumbCount.Visibility = Visibility.Collapsed;            
128
        }
129

    
130
        void expCommentPages_PreviewExpanded(object sender, Telerik.Windows.RadRoutedEventArgs e)
131
        {
132
            Logger.sendCheckLog("expCommentPages_PreviewExpanded", 1);
133
            rdoAllPages.IsChecked = false;
134
            rdoFavoritePages.IsChecked = false;
135
            //txtThumbCount.Visibility = Visibility.Visible;
136
            SetCommentPages();
137
        }
138

    
139
        /// <summary>
140
        /// called when image list box's selection is changed
141
        /// </summary>
142
        /// <param name="sender"></param>
143
        /// <param name="e"></param>
144
        private void ImgListbox_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
145
        {            
146
            if (ImgListbox.SelectedItem != null)
147
            {
148
                int _CurrentPageNo = -1;
149
                if (this.CurrentPage != null)
150
                {
151
                    this.ParentOfType<MainWindow>().dzTopMenu._SaveEvent(null, null);   /// save controls
152
                    _CurrentPageNo = this.CurrentPage.PageNumber;
153
                }
154

    
155
                this.CurrentPage = ImgListbox.SelectedItem as ThumbnailItem;
156
                int iPageNo = this.CurrentPage.PageNumber;
157
                if(_CurrentPageNo != iPageNo)
158
                {
159
                    PageChanging(this, new PageChangeEventArgs
160
                    {
161
                        CurrentPage = this._PageList.Where(p => p.PAGE_NUMBER == iPageNo).First(),
162
                        PageNumber = iPageNo,
163
                        PageUri = null
164
                    });
165
                }
166
            }
167

    
168
            //var border = VisualTreeHelper.GetChild(ImgListbox, 0);
169
            //if (border != null)
170
            //{
171
            //    IEnumerable<ScrollViewer> scrollViewer = border.ChildrenOfType<ScrollViewer>();
172

    
173
            //}
174
            //ScrollViewer scrollViewer = (sender as RadListBox) as ScrollViewer;
175

    
176
            
177
            //System.Diagnostics.Debug.WriteLine("page:"+ImgListbox.SelectedIndex);
178
        }
179

    
180
        public bool GotoPageFlag = false;
181

    
182
        /// <summary>
183
        /// 해당 썸네일로 이동
184
        /// </summary>
185
        /// <param name="_pageNumber">이동할 페이지 번호</param>
186
        public void GotoPage(int _pageNumber)
187
        {
188
            try
189
            {
190
                var _page = _thumbnailItems.Where(item => item.PageNumber == _pageNumber);
191
                if (_page.Count() > 0)
192
                {
193
                    ThumbnailItem thumbnailitem = _page.First();
194
                    if (PageChanging != null)
195
                    {
196
                        var _itemIndex = this._thumbnailItems.IndexOf(thumbnailitem);
197
                        ImgListbox.SelectedItem = thumbnailitem;
198
                        //ImgListbox.Items.MoveCurrentTo(thumbnailitem);
199
                        //if (_itemIndex < _thumbnailItems.Count() - 1)
200
                        //    ImgListbox.ScrollIntoView(_itemIndex);
201
                        //else
202
                        //    ImgListbox.ScrollIntoView(this._thumbnailItems.Count() - 1);
203
                    }
204
                }
205
            }
206
            catch(Exception ex)
207
            {
208
                Logger.sendResLog("GotoPage", ex.Message, 0);
209
            }
210
        }
211

    
212
        /// <summary>
213
        /// 주어진 페이지로 변경한다
214
        /// </summary>
215
        /// <param name="iPageNo">변경할 페이지 번호</param>
216
        public void ChangePage(int iPageNo)
217
        {
218
            var thumbitem = this._thumbnailItems.Where(item => item.PageNumber == iPageNo).FirstOrDefault();
219
            if ((PageChanged != null) && (thumbitem != null))
220
            {
221
                var uri = thumbitem.PageUri.ToString();
222
                    //_DefaultUri.Replace("{PageNo}", thumbitem.PageNumber.ToString());
223

    
224
                var _DocPages = _PageList.Where(p => p.PAGE_NUMBER == thumbitem.PageNumber).FirstOrDefault();
225
                if (_DocPages != null)
226
                {
227
                    PageChanged(this, new PageChangeEventArgs
228
                    {
229
                        CurrentPage = _DocPages,
230
                        PageUri = uri,
231
                        PageNumber = thumbitem.PageNumber
232
                    });
233
                    //ImgListbox.SelectedItem = thumbitem;                    
234
                    //ImgListbox.Items.MoveCurrentTo(thumbitem);
235
                    
236
                    this.CurrentPage = thumbitem;
237
                }
238
                else
239
                {
240
                    //System.Diagnostics.Debug.WriteLine("페이지 정보가 없습니다");
241
                }
242
            }
243
        }
244

    
245
        public void GotoPageTALK(int _pageNumber, int _angle)
246
        {
247
            int _PageNo = -1;
248

    
249
            if (int.TryParse(_pageNumber.ToString(), out _PageNo))
250
            {
251
                var _page = _thumbnailItems.Where(item => item.PageNumber == _PageNo);
252
                if (_page.Count() > 0)
253
                {
254
                    ThumbnailItem _item = _page.First();
255
                    setPageChangeTALK(_item, _angle);
256
                    this.ImgListbox.SelectedIndex = _pageNumber - 1;
257
                    //this.ImgListbox.ScrollIntoView(_pageNumber - 1);
258
                }
259
            }
260
        }
261

    
262
        public void setPageChangeTALK(ThumbnailItem thumbnailItem, int _angle)
263
        {
264
            if (thumbnailItem != null)
265
            {
266
                if (PageChanging != null)
267
                {
268
                    ///this.CurrentPage = _NextPage;
269
                    ///_NextPage = thumbnailItem;
270
                    PageChanging(this, new PageChangeEventArgs
271
                    {
272
                        CurrentPage = _PageList.Where(p => p.PAGE_NUMBER == thumbnailItem.PageNumber).First(),
273
                        PageNumber = Convert.ToInt32(thumbnailItem.PageNumber),
274
                        PageUri = null
275
                    });
276

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

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

    
281
                    if (rotationNum > 0) // 1, 2, 3
282
                    {
283
                        for (int i = 0; i < rotationNum; i++)
284
                        {
285
                            drawingPannelRotate(true);
286
                        }
287
                    }
288
                    else if (rotationNum < 0)// -1, -2, -3
289
                    {
290
                        for (int i = 0; i < -rotationNum; i++)
291
                        {
292
                            drawingPannelRotate(false);
293
                        }
294
                    }
295
                }
296
            }
297
        }
298

    
299
        public void drawingPannelRotate(bool Flag)
300
        {
301
            var instanceMain = this.ParentOfType<MainWindow>();
302

    
303
            if (Flag)
304
            {
305
                if (instanceMain.dzMainMenu.rotate.Angle == 270)
306
                {
307
                    instanceMain.dzMainMenu.rotate.Angle = 0;
308
                }
309
                else
310
                {
311
                    instanceMain.dzMainMenu.rotate.Angle += 90;
312
                }
313
            }
314
            else
315
            {
316
                if (instanceMain.dzMainMenu.rotate.Angle == 0)
317
                {
318
                    instanceMain.dzMainMenu.rotate.Angle = 270;
319
                }
320
                else
321
                {
322
                    instanceMain.dzMainMenu.rotate.Angle -= 90;
323
                }
324
            }
325

    
326
            if (instanceMain.dzMainMenu.zoomAndPanCanvas.Width == ViewerDataModel.Instance.ContentWidth)
327
            {
328
                double emptySize = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;
329
                instanceMain.dzMainMenu.zoomAndPanCanvas.Width = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;
330
                instanceMain.dzMainMenu.zoomAndPanCanvas.Height = emptySize;
331
            }
332

    
333
            if (instanceMain.dzMainMenu.rotate.Angle == 0)
334
            {
335
                instanceMain.dzMainMenu.translate.X = 0;
336
                instanceMain.dzMainMenu.translate.Y = 0;
337
            }
338
            else if (instanceMain.dzMainMenu.rotate.Angle == 90)
339
            {
340
                instanceMain.dzMainMenu.translate.X = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;
341
                instanceMain.dzMainMenu.translate.Y = 0;
342
            }
343
            else if (instanceMain.dzMainMenu.rotate.Angle == 180)
344
            {
345
                instanceMain.dzMainMenu.translate.X = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;
346
                instanceMain.dzMainMenu.translate.Y = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;
347
            }
348
            else
349
            {
350
                instanceMain.dzMainMenu.translate.X = 0;
351
                instanceMain.dzMainMenu.translate.Y = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;
352
            }
353

    
354
            instanceMain.dzMainMenu.zoomAndPanControl.RotationAngle = instanceMain.dzMainMenu.rotate.Angle;
355
            ViewerDataModel.Instance.ContentWidth = instanceMain.dzMainMenu.zoomAndPanCanvas.Width;
356
            ViewerDataModel.Instance.ContentHeight = instanceMain.dzMainMenu.zoomAndPanCanvas.Height;
357
            ViewerDataModel.Instance.AngleOffsetX = instanceMain.dzMainMenu.translate.X;
358
            ViewerDataModel.Instance.AngleOffsetY = instanceMain.dzMainMenu.translate.Y;
359
            ViewerDataModel.Instance.Angle = instanceMain.dzMainMenu.rotate.Angle;
360

    
361
            instanceMain.dzMainMenu.pageNavigator._thumbnailItems.Where(info => info.PageNumber == instanceMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber).ToList().ForEach(data =>
362
            {
363
                data.Angle = int.Parse(instanceMain.dzMainMenu.rotate.Angle.ToString());
364

    
365
                instanceMain.dzMainMenu.pageNavigator.ImgListbox.ItemsSource = instanceMain.dzMainMenu.pageNavigator._thumbnailItems;
366
                var instance = instanceMain.dzMainMenu.CurrentDoc.docInfo.DOCPAGE.Where(p => p.PAGE_NUMBER == instanceMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber).FirstOrDefault();
367
                instance.PAGE_ANGLE = int.Parse(instanceMain.dzMainMenu.rotate.Angle.ToString());
368

    
369
                var rotationdoc = ViewerDataModel.Instance.RotationDocs.Where(d => d.ID == instance.ID).FirstOrDefault();
370
                if (rotationdoc != null)
371
                {
372
                    rotationdoc.PAGE_ANGLE = instance.PAGE_ANGLE;
373
                }
374
                else
375
                {
376
                    ViewerDataModel.Instance.RotationDocs.Add(instance);
377
                }
378
                instanceMain.dzMainMenu.pageNavigator.GotoPage(data.PageNumber);
379
            });
380
        }
381

    
382
        void lstSelectComment_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
383
        {
384
            SetCommentPages();
385
        }
386
        
387
        void user_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
388
        {
389
            SetCommentPages();
390
            //System.Diagnostics.Debug.WriteLine(e.PropertyName);
391
        }
392

    
393
        public void SetCommentPages()
394
        {
395
            ThumbnailSet();
396
            SetCommentList(_UsersCommentPagesList.ToList());
397
        }
398

    
399
        public void SetCommentList(List<UsersCommentPagesMember> UsersCommentPagesList)
400
        {
401
            Logger.sendCheckLog("SetCommentList", 1);
402
            Logger.sendCheckLog("SetCommentList_기존 Comment 색상 제거", 1);
403
            #region 기존 색상 제거 작업
404
            foreach (var item in this._thumbnailItems)
405
            {
406
                item.DisplayColorItems.Clear();
407
            }
408
            #endregion
409

    
410
            Logger.sendCheckLog("SetCommentList_delItem select 및 remove", 1);
411
            List<UsersCommentPagesMember> _delItem = new List<UsersCommentPagesMember>();
412

    
413
            _UsersCommentPagesList.ToList().ForEach(item =>
414
            {
415
                var _comm = UsersCommentPagesList.Where(a => a.MarkupInfoID == item.MarkupInfoID);
416

    
417
                if (_comm.Count() == 0)
418
                {
419
                    _delItem.Add(item);
420
                }
421
            });
422

    
423
            _delItem.ForEach(f => _UsersCommentPagesList.Remove(f));
424

    
425
            Logger.sendCheckLog("SetCommentList_UsersCommentPagesMember_PropertyChanged", 1);
426
            List<SetColorMarkupItem> setColorMarkupItems = new List<SetColorMarkupItem>();
427

    
428
            UsersCommentPagesList.ForEach(user =>
429
            {
430
                user.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(user_PropertyChanged);
431
                user.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(user_PropertyChanged);
432

    
433
                var _commLst = _UsersCommentPagesList.Where(o => o.MarkupInfoID == user.MarkupInfoID);
434

    
435
                if (_commLst.Count() == 0)
436
                {
437
                    _UsersCommentPagesList.Add(user);
438
                }
439
                else
440
                {
441
                    if (_commLst.First().PageNumber != user.PageNumber)
442
                        _commLst.First().PageNumber = user.PageNumber;
443
                }
444

    
445
                user.PageNumber.ForEach(page =>
446
                {
447
                    var _items = this._thumbnailItems.Where(item => item.PageNumber == page);
448

    
449
                    if (_items.Count() > 0)
450
                    {
451
                        setColorMarkupItems.Add(new SetColorMarkupItem { DisplayColor = user.SetColor, markupID = user.MarkupInfoID, Page = page });
452
                        
453
                    }
454
                        
455
                });
456
            });
457

    
458
            foreach (var item in this._thumbnailItems)
459
            {
460
                item.DisplayColorItems = setColorMarkupItems.Where(color => color.Page == item.PageNumber).ToList();
461
            }
462
            
463
            Logger.sendCheckLog("SetCommentList_SelectComment.ItemsSource 설정", 1);
464
            var data = _UsersCommentPagesList.OrderByDescending(p => p.isConSolidation == Convert.ToInt32(true)).ToList();
465
            if (data.Count() != 0)
466
            {
467
                if (Convert.ToBoolean(data.First().isConSolidation))
468
                {
469
                    data.Where(p => p.isConSolidation == Convert.ToInt32(true)).FirstOrDefault().UserName = "Consolidated";
470
                    data.Where(p => p.isConSolidation == Convert.ToInt32(true)).FirstOrDefault().Depart = "";
471
                    this.lstSelectComment.ItemsSource = data;
472
                }
473
                else
474
                {
475
                    this.lstSelectComment.ItemsSource = _UsersCommentPagesList;  //섬네일   
476
                }
477
            }
478
            else
479
            {
480
                this.lstSelectComment.ItemsSource = _UsersCommentPagesList;  //섬네일   
481
            }
482
            
483
            Logger.sendCheckLog("SetComme6ntList_ImgListbox 설정", 1);
484

    
485

    
486
            //var template = this.ImgListbox.ItemTemplate;
487
            //this.ImgListbox.ItemTemplate = null;
488
            //this.ImgListbox.ItemTemplate = template;
489

    
490
        }
491

    
492
        private void ThumbnailSet()
493
        {
494
            Logger.sendCheckLog("ThumbnailSet", 1);
495
            if (!_Initialize) return;
496

    
497
            this._thumbnailItems = new ObservableCollection<ThumbnailItem>();
498
            List<int> _selectComment = new List<int>();
499
            if (this.lstSelectComment.ItemsSource != null)
500
            {
501
                var _pages = from commentPage in this.lstSelectComment.ItemsSource.Cast<UsersCommentPagesMember>()
502
                             where commentPage.IsSelected == true
503
                             select commentPage.PageNumber;
504

    
505
                foreach (var item in _pages)
506
                {
507
                    item.ForEach(pp => _selectComment.Add(pp));
508
                }
509

    
510
                _selectComment.Distinct();
511
            }
512

    
513
            var uri = _DefaultUri.Replace("{0}/{1}_{2}", "8/0_0");
514
            this._PageList = this._PageList.OrderBy(data => data.PAGE_NUMBER).ToList();
515
            //this._PageList.ForEach(page =>
516
            ViewerDataModel.Instance.Document_Info.OrderBy(data => data.PAGE_NUMBER).ToList().ForEach(page =>
517
            {
518
                var _pageNo = page.PAGE_NUMBER;
519
                bool _addFlag = false;
520

    
521
                if (rdoFavoritePages.IsChecked == false)
522
                {
523
                    if (_selectComment.Count() > 0)
524
                    {
525
                        if ((rdoAllPages.IsChecked == true)
526
                            || (expCommentPages.IsExpanded == true && _selectComment.Where(s => s == _pageNo).Count() > 0))
527
                        {
528
                            _addFlag = true;
529
                        }
530
                    }
531
                    else
532
                    {
533
                        //if (App.ViewInfo.IsCustomPage)
534
                        //{
535
                        //    //_addFlag = false;
536

    
537
                        //    //App.ViewInfo.IsCustomPage = false;
538
                        //    //this.rdoAllPages.Visibility = System.Windows.Visibility.Collapsed;
539
                        //    //this.lstSelectComment.Visibility = System.Windows.Visibility.Collapsed;
540
                        //    this.rdoAllPages.IsChecked = false;
541
                        //    this.rdoFavoritePages.IsChecked = true;
542
                        //    //SetCommentPages();                        
543
                        //}
544
                        //else
545
                        //{
546
                        _addFlag = true;
547
                        //}
548
                    }
549
                }
550

    
551

    
552
                if (_addFlag)
553
                {
554
                    this._thumbnailItems.Add(new ThumbnailItem
555
                    {
556
                        ImageUri = new Uri(uri.Replace("{PageNo}", _pageNo.ToString())),
557
                        PageUri = new Uri(uri.Replace("{PageNo}", _pageNo.ToString()).Replace("jpg","png")),
558
                        PageNumber = _pageNo,
559
                        Angle = page.PAGE_ANGLE,
560
                    });
561
                }
562
                else
563
                {
564
                    if ((rdoFavoritePages.IsChecked == true) && _FavoriteSet.Where(data => data.PAGE_NO == _pageNo).FirstOrDefault() != null)
565
                    {
566
                        this._thumbnailItems.Add(new ThumbnailItem
567
                        {
568
                            ImageUri = new Uri(uri.Replace("{PageNo}", _pageNo.ToString())),
569
                            PageNumber = _pageNo,
570
                            Angle = page.PAGE_ANGLE,
571
                        });
572
                    }
573
                }
574

    
575

    
576

    
577
                //this._thumbnailItems.Add(new ThumbnailItem
578
                //{
579
                //    ImageUri = new Uri(uri.Replace("{PageNo}", _pageNo.ToString())),
580

    
581
                //    //ImageUri = new Uri(@"http://www.honeyhead.net/Pages/000000/111111/11111111/1.cmp"),
582

    
583
                //    //ImageUri = new Uri(@"https://image.freepik.com/free-vector/abstract-logo-in-flame-shape_1043-44.jpg"),
584
                //    //DisplayColorItems = pageColor,
585
                //    PageNumber = Convert.ToInt32(_pageNo),
586
                //    Angle = Convert.ToInt32(page.PAGE_ANGLE),
587
                //});
588
            });
589

    
590
            //txtTotPageNo.Text = this._PageList.Count().ToString();
591

    
592
            //txtThumbCount.Text = String.Format("Count : {0}", (this._thumbnailItems.Count).ToString());
593

    
594
            if (ImgListbox.ItemsSource == null)
595
            {
596
                ImgListbox.ItemsSource = this._thumbnailItems;
597

    
598
                this._thumbnailItems.ToList().ForEach(data =>
599
                {
600
                    data.Width = ImgListbox.ActualWidth;
601
                    data.Height = ImgListbox.ActualHeight;
602
                });
603

    
604
                if (ImgListbox.Items.Count > 0)
605
                {
606
                    //int StartPageIdx = Convert.ToInt32(App.ViewInfo.StartPage) - 1;
607
                    int StartPageIdx = 1;
608
                    //if (App.ViewInfo.IsCustomPage)
609
                    //{
610
                    //    ImgListbox.SelectedItem = ImgListbox.Items.Where(data => (data as ThumbnailItem).PageNumber == Convert.ToInt32(App.ViewInfo.StartPage)).FirstOrDefault();
611
                    //}
612
                    //else
613
                    //{
614

    
615
                    if (StartPageIdx <= 0 || StartPageIdx > ImgListbox.Items.Count || StartPageIdx == 1)
616
                    {
617
                        ImgListbox.SelectedItem = ImgListbox.Items[0];
618
                    }
619
                    else
620
                    {
621
                        ImgListbox.SelectedItem = ImgListbox.Items[StartPageIdx];
622
                    }
623
                    //}
624
                }
625
            }
626
            else
627
            {
628
                ImgListbox.UpdateLayout();
629
                ImgListbox.ItemsSource = this._thumbnailItems;
630
            }
631
        }
632

    
633
        private void Border_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
634
        {
635
            if (e.ClickCount >= 2)
636
            {
637
                var selectItem = MarkupList.SelectedItem as IKCOM.MarkupItem;
638
                GotoPage(selectItem.PageNumber);
639
                var result = MarkupParser.GetBaseControl(selectItem.Data);
640
                Rect rect = new Rect(new Point(result.StartPoint.X - 100, result.StartPoint.Y - 100), new Point(result.EndPoint.X + 100, result.EndPoint.Y + 100));
641
                this.ParentOfType<KCOM.Views.MainMenu>().zoomAndPanControl.ZoomTo(rect);
642
                //bool isGO = false;
643

    
644
                //var imageViewer = this.ParentOfType<KCOM.Views.MainMenu>().imageViewer;
645
                //imageViewer.SizeMode = Leadtools.Windows.Controls.SizeMode.Fit;
646
                //imageViewer.InteractiveMode = Leadtools.Windows.Controls.InteractiveMode.UserRectangle;
647
                //imageViewer.InteractiveUserRectangle += (sen, ea) =>
648
                //{
649
                //    System.Diagnostics.Debug.WriteLine(ea.Bounds);
650
                //    if (ea.Status == Leadtools.Windows.Controls.InteractiveModeStatus.End)
651
                //    {
652
                //        this.ParentOfType<KCOM.Views.MainMenu>().zoomAndPanControl.ZoomTo(ea.Bounds);                        
653
                //    }
654

    
655
                //};
656
                //imageViewer.SizeMode = Leadtools.Windows.Controls.SizeMode.Normal;
657

    
658
                //GotoPage(MarkupList.SelectedItem as MarkupList)
659
            }
660
        }
661

    
662
        private void commentUser_SelectionChanged(object sender, SelectionChangedEventArgs e)
663
        {
664
            MarkupList.ItemsSource = null;
665
            tbSearch.Text = string.Empty;
666

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

    
669
            if (commentType.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue)).ToList(); }
670

    
671
            if (commentUser.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.UserName == ((IKCOM.MarkupInfoItem)commentUser.SelectedValue).UserName).ToList(); }
672

    
673
            if (commentPage.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue)).ToList(); }
674

    
675
            MarkupList.ItemsSource = TempMarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
676
        }
677

    
678
        public class MarkupInfoItemSmall
679
        {
680
            public string Id { get; set; }
681
            public string UserName { get; set; }
682
            public string UserID { get; set; }
683
            public int PageNumber { get; set; }
684
            public string Data { get; set; }
685
            public int Data_Type { get; set; }
686
        }
687

    
688
        private List<MarkupInfoItemSmall> _MarkupInfoSmallList { get; set; }
689
        public List<MarkupInfoItemSmall> MarkupInfoSmallList
690
        {
691
            get
692
            {
693
                if (_MarkupInfoSmallList == null)
694
                {
695
                    _MarkupInfoSmallList = new List<MarkupInfoItemSmall>();
696
                }
697
                return _MarkupInfoSmallList;
698
            }
699
            set
700
            {
701

    
702
                _MarkupInfoSmallList = value;
703
                RaisePropertyChanged("MarkupInfoSmallList");
704
            }
705
        }
706

    
707
        /// <summary>
708
        /// goto page and select item selected by user
709
        /// </summary>
710
        /// <param name="sender"></param>
711
        /// <param name="e"></param>
712
        private void RadButton_Click(object sender, RoutedEventArgs e)
713
        {
714
            var clickButtonItem = sender as RadButton;
715
            if (clickButtonItem != null && clickButtonItem.CommandParameter != null)
716
            {
717
                try
718
                {
719
                    Rect rect = new Rect();
720
                    Point s_point = new Point();
721
                    Point e_point = new Point();
722

    
723
                    MarkupInfoItemSmall gaza = clickButtonItem.CommandParameter as MarkupInfoItemSmall;
724
                    GotoPage(Convert.ToInt32(gaza.PageNumber));
725

    
726
                    var data = MarkupToPDF.Serialize.Core.JsonSerializerHelper.UnCompressString(gaza.Data.ToString()); //언패킹작업
727
                    switch (Enum.Parse(typeof(MarkupToPDF.Controls.Common.ControlType), gaza.Data_Type.ToString()))
728
                    {
729
                        case MarkupToPDF.Controls.Common.ControlType.TextControl:
730
                            {
731
                                MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);
732
                                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));
733
                            }
734
                            break;
735
                        case MarkupToPDF.Controls.Common.ControlType.TextBorder:
736
                            {
737
                                MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);
738
                                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));
739
                            }
740
                            break;
741
                        case MarkupToPDF.Controls.Common.ControlType.TextCloud:
742
                            {
743
                                MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);
744
                                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));
745
                            }
746
                            break;
747
                        case MarkupToPDF.Controls.Common.ControlType.PolygonControl:
748
                            {
749
                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);
750

    
751
                                foreach (Point A in instance.PointSet)
752
                                {
753
                                    if (s_point == new Point())
754
                                    {
755
                                        s_point = A;
756
                                        e_point = A;
757
                                    }
758
                                    s_point.X = Math.Min(s_point.X, A.X);
759
                                    s_point.Y = Math.Min(s_point.Y, A.Y);
760
                                    e_point.X = Math.Max(e_point.X, A.X);
761
                                    e_point.Y = Math.Max(e_point.Y, A.Y);
762
                                }
763
                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));
764
                            }
765
                            break;
766
                        case MarkupToPDF.Controls.Common.ControlType.PolygonCloud:
767
                            {
768
                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);
769

    
770
                                foreach (Point A in instance.PointSet)
771
                                {
772
                                    if (s_point == new Point())
773
                                    {
774
                                        s_point = A;
775
                                        e_point = A;
776
                                    }
777
                                    s_point.X = Math.Min(s_point.X, A.X);
778
                                    s_point.Y = Math.Min(s_point.Y, A.Y);
779
                                    e_point.X = Math.Max(e_point.X, A.X);
780
                                    e_point.Y = Math.Max(e_point.Y, A.Y);
781
                                }
782
                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));
783
                            }
784
                            break;
785
                        case MarkupToPDF.Controls.Common.ControlType.ChainLine:
786
                            {
787
                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);
788

    
789
                                foreach (Point A in instance.PointSet)
790
                                {
791
                                    if (s_point == new Point())
792
                                    {
793
                                        s_point = A;
794
                                        e_point = A;
795
                                    }
796
                                    s_point.X = Math.Min(s_point.X, A.X);
797
                                    s_point.Y = Math.Min(s_point.Y, A.Y);
798
                                    e_point.X = Math.Max(e_point.X, A.X);
799
                                    e_point.Y = Math.Max(e_point.Y, A.Y);
800
                                }
801
                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));
802
                            }
803
                            break;
804
                        case MarkupToPDF.Controls.Common.ControlType.Ink:
805
                            {
806
                                MarkupToPDF.Serialize.S_Control.S_BaseControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);
807

    
808
                                foreach (Point A in instance.PointSet)
809
                                {
810
                                    if (s_point == new Point())
811
                                    {
812
                                        s_point = A;
813
                                        e_point = A;
814
                                    }
815
                                    s_point.X = Math.Min(s_point.X, A.X);
816
                                    s_point.Y = Math.Min(s_point.Y, A.Y);
817
                                    e_point.X = Math.Max(e_point.X, A.X);
818
                                    e_point.Y = Math.Max(e_point.Y, A.Y);
819
                                }
820
                                rect = new Rect(new Point(s_point.X - 100, s_point.Y - 100), new Point(e_point.X + 100, e_point.Y + 100));
821
                            }
822
                            break;
823
                        default:
824
                            MarkupToPDF.Serialize.S_Control.S_BaseControl item = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_BaseControl>(data);
825
                            rect = new Rect(new Point(item.StartPoint.X - 100, item.StartPoint.Y - 100), new Point(item.EndPoint.X + 100, item.EndPoint.Y + 100));
826
                            break;
827
                    }
828

    
829
                    SelectionSet.Instance.SelectItemByRect(rect, this.ParentOfType<KCOM.Views.MainMenu>());
830
                    this.ParentOfType<KCOM.Views.MainMenu>().zoomAndPanControl.ZoomTo(rect);
831
                }
832
                catch (Exception ex)
833
                {
834
                    this.ParentOfType<KCOM.Views.MainMenu>().DialogMessage_Alert(ex.Message, "Error");
835
                }
836
            }
837
        }
838

    
839
        private void MarkupList_Loaded(object sender, RoutedEventArgs e)
840
        {
841
            if (MarkupInfoSmallList.Count == 0)
842
            {
843
                ViewerDataModel.Instance._markupInfoList.ToList().ForEach(d =>
844
                {
845
                    if (d.MarkupList != null)
846
                    {
847
                        d.MarkupList.ForEach(b =>
848
                        {
849
                            MarkupInfoSmallList.Add(new MarkupInfoItemSmall
850
                            {
851
                                Id = b.ID,
852
                                Data = b.Data,
853
                                Data_Type = b.Data_Type,
854
                                PageNumber = b.PageNumber,
855
                                UserID = d.UserID,
856
                                UserName = d.UserName,
857
                            });
858
                        });
859
                    }
860
                });
861
                MarkupList.ItemsSource = null;
862
                MarkupList.ItemsSource = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
863

    
864
                commentPage.ItemsSource = MarkupInfoSmallList.Select(d => d.PageNumber).Distinct().OrderBy(d => d).ToList();
865
                commentType.ItemsSource = MarkupInfoSmallList.Select(d => d.Data_Type).Distinct().OrderBy(d => d).ToList();
866
            }
867
        }
868

    
869
        public void MarkupListUpdate(MarkupReturn res, Event_Type eventType, string CommentID, MarkupInfoItem item)
870
        {
871
            if (MarkupInfoSmallList.Count == 0)
872
            {
873
                ViewerDataModel.Instance._markupInfoList.ToList().ForEach(d =>
874
                {
875
                    if (d.MarkupList != null)
876
                    {
877
                        d.MarkupList.ForEach(b =>
878
                        {
879
                            MarkupInfoSmallList.Add(new MarkupInfoItemSmall
880
                            {
881
                                Id = b.ID,
882
                                Data = b.Data,
883
                                Data_Type = b.Data_Type,
884
                                PageNumber = b.PageNumber,
885
                                UserID = d.UserID,
886
                                UserName = d.UserName,
887
                            });
888
                        });
889
                    }
890
                });
891
                MarkupList.ItemsSource = null;
892
                MarkupList.ItemsSource = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
893
                commentPage.ItemsSource = MarkupInfoSmallList.Select(d => d.PageNumber).Distinct().OrderBy(d => d).ToList();
894
                commentType.ItemsSource = MarkupInfoSmallList.Select(d => d.Data_Type).Distinct().OrderBy(d => d).ToList();
895
            }
896

    
897
            switch (eventType)
898
            {
899
                case Event_Type.Create:
900
                    MarkupInfoSmallList.Add(new MarkupInfoItemSmall
901
                    {
902
                        Id = res.CommentID,
903
                        Data = res.ConvertData,
904
                        Data_Type = res.DATA_TYPE,
905
                        PageNumber = CurrentPage.PageNumber,
906
                        UserID = App.ViewInfo.UserID,
907
                        UserName = App.UserName,
908
                    });
909
                    break;
910
                case Event_Type.Delete:
911
                    if(CommentID == null) //user information list delete btn
912
                    {
913
                        foreach (var delItem in item.MarkupList)
914
                        {
915
                            MarkupInfoSmallList.RemoveAll(p => p.Id == delItem.ID);
916
                        }
917
                    }
918
                    else //delete, cut, 
919
                    {
920
                        MarkupInfoSmallList.RemoveAll(p => p.Id.Equals(CommentID));
921
                    }                    
922
                    break;
923
                case Event_Type.Thumb://이동 회전
924
                    MarkupInfoSmallList.RemoveAll(p => p.Id.Equals(res.CommentID));
925
                    MarkupInfoSmallList.Add(new MarkupInfoItemSmall
926
                    {
927
                        Id = res.CommentID,
928
                        Data = res.ConvertData,
929
                        Data_Type = res.DATA_TYPE,
930
                        PageNumber = CurrentPage.PageNumber,
931
                        UserID = App.ViewInfo.UserID,
932
                        UserName = App.UserName,
933
                    });
934
                    break;
935
                default:
936
                    break;
937
            }
938

    
939
            List<MarkupInfoItemSmall> TempMarkupInfoSmallList = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
940
            if (commentType.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue)).ToList(); }
941

    
942
            if (commentUser.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.UserName == ((IKCOM.MarkupInfoItem)commentUser.SelectedValue).UserName).ToList();                 }            
943

    
944
            if (commentPage.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue)).ToList(); }
945

    
946
            MarkupList.ItemsSource = TempMarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();            
947
           
948
            commentType.ItemsSource = MarkupInfoSmallList.Select(d => d.Data_Type).Distinct().OrderBy(d => d).ToList();
949
            commentPage.ItemsSource = MarkupInfoSmallList.Select(d => d.PageNumber).Distinct().OrderBy(d => d).ToList();            
950
        }
951

    
952
        private void commentType_SelectionChanged(object sender, SelectionChangedEventArgs e)
953
        {
954
            MarkupList.ItemsSource = null;
955
            tbSearch.Text = string.Empty;
956
            List<MarkupInfoItemSmall> TempMarkupInfoSmallList = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
957
            if (commentType.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue)).ToList(); }
958

    
959
            if (commentUser.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.UserName == ((IKCOM.MarkupInfoItem)commentUser.SelectedValue).UserName).ToList(); }
960

    
961
            if (commentPage.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue)).ToList(); }
962

    
963
            MarkupList.ItemsSource = TempMarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
964
        }
965

    
966
        private void commentPage_SelectionChanged(object sender, SelectionChangedEventArgs e)
967
        {
968
            MarkupList.ItemsSource = null;
969
            tbSearch.Text = string.Empty;
970

    
971
            List<MarkupInfoItemSmall> TempMarkupInfoSmallList = MarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
972
            if (commentType.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.Data_Type == Convert.ToInt32(commentType.SelectedValue)).ToList(); }
973

    
974
            if (commentUser.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.UserName == ((IKCOM.MarkupInfoItem)commentUser.SelectedValue).UserName).ToList(); }
975

    
976
            if (commentPage.SelectedValue != null) { TempMarkupInfoSmallList = TempMarkupInfoSmallList.Where(d => d.PageNumber == Convert.ToInt32(commentPage.SelectedValue)).ToList(); }
977

    
978
            MarkupList.ItemsSource = TempMarkupInfoSmallList.OrderBy(d => d.PageNumber).ToList();
979
        }
980

    
981
        private void btnPanorama_Click(object sender, RoutedEventArgs e)
982
        {
983
            ViewerDataModel.Instance.SystemMain.dzTopMenu.PanoramaShow();
984
        }
985

    
986
        private void btnSearch_Click(object sender, RoutedEventArgs e)
987
        {
988
            string search_str = tbSearch.Text;
989
            var sel_type = commentType.SelectedItem;
990
            var sel_user = commentUser.SelectedItem;
991
            var sel_page = commentPage.SelectedItem;
992
            List<MarkupInfoItemSmall> small_list = new List<MarkupInfoItemSmall>();
993
            List<MarkupInfoItemSmall> list = MarkupInfoSmallList;
994
            if (sel_page != null)
995
            {
996
                list = list.Where(d => d.PageNumber == Convert.ToInt32(sel_page)).ToList();
997
            }
998
            if (sel_type != null)
999
            {
1000
                list = list.Where(d => d.Data_Type == Convert.ToInt32(sel_type)).ToList();
1001
            }
1002
            if (sel_user != null)
1003
            {
1004
                list = list.Where(d => d.UserID == (sel_user as MarkupInfoItem).UserID).ToList();
1005
            }
1006
            foreach (var item in list)
1007
            {
1008
                var data = MarkupToPDF.Serialize.Core.JsonSerializerHelper.UnCompressString(item.Data.ToString());
1009

    
1010
                switch (Enum.Parse(typeof(MarkupToPDF.Controls.Common.ControlType), item.Data_Type.ToString()))
1011
                {
1012
                    case MarkupToPDF.Controls.Common.ControlType.TextControl:
1013
                    case MarkupToPDF.Controls.Common.ControlType.TextBorder:
1014
                    case MarkupToPDF.Controls.Common.ControlType.TextCloud:
1015
                        {
1016
                            MarkupToPDF.Serialize.S_Control.S_TextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_TextControl>(data);
1017
                            if (instance.Text.Contains(search_str))
1018
                            {
1019
                                small_list.Add(item);
1020
                            }
1021
                        }
1022
                        break;
1023
                    case MarkupToPDF.Controls.Common.ControlType.ArrowTextBorderControl:
1024
                    case MarkupToPDF.Controls.Common.ControlType.ArrowTextCloudControl:
1025
                    case MarkupToPDF.Controls.Common.ControlType.ArrowTextControl:
1026
                    case MarkupToPDF.Controls.Common.ControlType.ArrowTransTextBorderControl:
1027
                    case MarkupToPDF.Controls.Common.ControlType.ArrowTransTextCloudControl:
1028
                    case MarkupToPDF.Controls.Common.ControlType.ArrowTransTextControl:
1029
                        {
1030
                            MarkupToPDF.Serialize.S_Control.S_ArrowTextControl instance = MarkupToPDF.Serialize.Core.JsonSerializerHelper.JsonDeserialize<MarkupToPDF.Serialize.S_Control.S_ArrowTextControl>(data);
1031
                            if (instance.ArrowText.Contains(search_str))
1032
                            {
1033
                                small_list.Add(item);
1034
                            }
1035
                        }
1036
                        break;
1037
                }
1038
            }
1039

    
1040
            MarkupList.ItemsSource = null;
1041
            MarkupList.ItemsSource = small_list.OrderBy(d => d.PageNumber).ToList();
1042
            tbSearch.Text = string.Empty;
1043
        }
1044
    }
1045
}