프로젝트

일반

사용자정보

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

markus / KCOM / Controls / PrintControl.xaml.cs @ 89971d17

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

1
using System;
2
using System.Collections.Generic;
3
using System.Linq;
4
using System.Windows;
5
using System.Windows.Controls;
6
using System.Windows.Media;
7
using Telerik.Windows.Controls;
8
using System.Collections.ObjectModel;
9
using System.Drawing.Printing;
10
using System.Windows.Media.Imaging;
11
using KCOMDataModel.DataModel;
12
using Microsoft.Win32;
13
using System.IO;
14
using System.Timers;
15
//using IKCOM.Common;
16
using KCOM.Event;
17
using iTextSharp;
18
using iTextSharp.text;
19
//using Leadtools.Windows.Controls;
20
using IKCOM;
21
using iTextSharp.text.pdf;
22
using Microsoft.Office.Core;
23
using System.Net;
24
using Image = System.Windows.Controls.Image;
25

    
26
namespace KCOM.Control
27
{
28
    public class DefinedPages
29
    {
30
        public DOCINFO DocumentInfo { get; set; }
31

    
32
        public int PagesCount { get; set; }
33
        public string vpSlip { get; set; }
34
        public string vpTitle { get; set; }
35
        public string fileUrl { get; set; }
36
        public ImageBrush Back_Image { get; set; }
37

    
38
        public double CurrentValue { get; set; }
39

    
40
        string _DefinedPagesStrings;
41
        /// <summary>
42
        /// 사용자 정의 페이지를 입력시 오류를 방지하기 위해 적용
43
        /// </summary>
44
        public string DefinedPagesStrings
45
        {
46
            get { return _DefinedPagesStrings; }
47
            set
48
            {
49
                if (string.IsNullOrWhiteSpace(value)) return;
50

    
51
                var _definedPages = value.Replace('-', ',').Split(',');
52
                List<char> _NotEx = new List<char>();
53

    
54
                foreach (var item in _definedPages)
55
                {
56
                    bool _isNum = true;
57

    
58
                    foreach (var chr in item)
59
                    {
60
                        if (!char.IsNumber(chr))
61
                        {
62
                            _NotEx.Add(chr);
63
                            _isNum = false;
64
                        }
65
                    }
66

    
67
                    if (_isNum)
68
                    {
69
                        if (Convert.ToInt32(item) > PagesCount)
70
                            throw new Exception(string.Format("Max Page Number is '{0}'!!.", PagesCount));
71
                    }
72
                }
73

    
74
                if (_NotEx.Count() > 0)
75
                {
76
                    string _notString = "";
77
                    _NotEx.ForEach(s => _notString += s.ToString());
78
                    throw new Exception(string.Format("'{0}' Can not be added.", _notString));
79
                }
80

    
81

    
82
                try
83
                {
84

    
85
                    string _notString2 = "";
86
                    _NotEx.ForEach(s => _notString2 += s.ToString());
87
                    _DefinedPagesStrings = value;
88
                }
89
                catch (Exception)
90
                {
91
                    throw new Exception(string.Format("Can not be added."));
92
                }
93

    
94
            }
95
        }
96
    }
97

    
98
    /// <summary>
99
    /// Interaction logic for Print.xaml
100
    /// </summary>
101
    public partial class PrintControl : UserControl
102
    {
103
        #region Data
104

    
105
        string ProjectNo = null; //프로젝트 넘버
106
        string _DefaultTileUri = null; //기본 타일 경로
107
        int _StartPageNo; //시작페이지 
108
        DOCINFO _DocInfo; //문서 정보
109
        //DocInfo _DocInfo; //문서 정보
110
        bool currentPagePrint = false; //현재 페이지 수
111
        int PageCount { get; set; } //총 페이지수 
112
        DefinedPages _definePages = null; //인쇄 설정 범위 지정
113
        public bool IsPrint { get; set; }
114

    
115
        PrintDocument printDocument = new PrintDocument(); //프린터도큐먼트 생성
116

    
117
        //LayerControl LayerControl = null; // 레이어 컨트롤
118
        ObservableCollection<IKCOM.MarkupInfoItem> _markupInfo = new ObservableCollection<IKCOM.MarkupInfoItem>(); //마크업 정보
119
        List<MarkupPageItem> _PageMarkupList = new List<MarkupPageItem>();
120
        List<SetColorMarkupItem> _LoadMakupList = new List<SetColorMarkupItem>();
121
        List<int> _lstPrintPageNo = new List<int>();
122

    
123
        System.Windows.Threading.DispatcherTimer tm = new System.Windows.Threading.DispatcherTimer();
124
        bool _initializeComponentFinished; //이벤트
125
        bool _IsDagSlider = false; //드래그 상태인가
126
        List<DisplayColorInfo> colorList = new List<DisplayColorInfo>();
127
        DefinedPages DocumentInfo { get; set; } //문서정보 정의        
128
        //PdfSharp.Pdf.PdfDocument document { get; set; } // pdfsharp 인데 아직 왜 넣었는지 모름 
129
        delegate void PrintEventHandler(); //프린트 핸들러
130
        SaveFileDialog SaveDig = new SaveFileDialog(); //파일 세이브 다이얼로그
131
        //SaveFileDialog SaveFile { get; set; } //저장할 때 사용
132

    
133
        //RasterImageViewer _viewer; //이미지 뷰어
134
        //System.Windows.Controls.Image backimg; //백그라운드 이미지
135
        System.Drawing.Image Printimg; //프린트 이미지
136
        System.Drawing.Image p_img; //프린트 이미지
137
        iTextSharp.text.Image Export_img;
138
        Dictionary<int, System.Drawing.Image> Printimg_List; //프린트 이미지
139

    
140
        //RasterCodecs codecs;
141
        int currentPage;
142
        public string PrintName;
143
        public string Type;
144

    
145
        public System.Timers.Timer timm = new System.Timers.Timer();
146

    
147

    
148
        #endregion
149

    
150
        #region Static Property Defines
151
        public static readonly DependencyProperty CurrentPageNoProperty =
152
                   DependencyProperty.Register("CurrentPageNo", typeof(int), typeof(PrintControl),
153
                   new PropertyMetadata(new PropertyChangedCallback(CurrentPageNoPropertyChanged)));
154
        #endregion
155

    
156
        #region Property
157
        public int CurrentPageNo
158
        {
159
            get { return (int)GetValue(CurrentPageNoProperty); }
160
            set { SetValue(CurrentPageNoProperty, value); }
161
        }
162
        #endregion
163

    
164
        #region PropertyChangeMethod
165
        private static void CurrentPageNoPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
166
        {
167
            var printPage = (PrintControl)d;
168
            var newValue = (int)e.NewValue;
169

    
170
            printPage.sliderPages.Value = newValue;
171
            printPage.SetLoadMakupList(newValue);
172

    
173
        }
174
        #endregion
175

    
176
        #region 생성자
177

    
178
        public PrintControl(string TileSourceUri, string ProjectNo, DOCINFO DocInfo, List<IKCOM.MarkupInfoItem> markupInfo, int CurrentPageNo, string slip, string title, string fileurl, bool isPrint)
179
        {
180
            InitializeComponent();
181

    
182
            this.IsEnabled = true;
183

    
184
            //Layer Control을 통째로 가져와야 하는건가
185
            this._DocInfo = DocInfo;
186
            this._DefaultTileUri = TileSourceUri;
187
            this.ProjectNo = ProjectNo;
188
            this._StartPageNo = CurrentPageNo;
189

    
190
            markupInfo.ForEach(info => this._markupInfo.Add(info));
191

    
192
            foreach (var info in _markupInfo)
193
            {
194
                if (info.Consolidate == 1)
195
                {
196
                    info.UserName = "Consolidation";
197
                }
198
                info.MarkupList.ForEach(makup =>
199
                {
200
                    var _pageMarkup = _PageMarkupList.Where(item => item.PageNumber == makup.PageNumber);
201
                    var _SetMarkupItem = new SetColorMarkupItem { markupID = makup.ID, DisplayColor = info.DisplayColor };
202

    
203
                    if (_pageMarkup.Count() > 0)
204
                        _pageMarkup.First().DisplayColorItems.Add(_SetMarkupItem);
205
                    else
206
                        _PageMarkupList.Add(new MarkupPageItem
207
                        {
208
                            PageNumber = makup.PageNumber,
209
                            DisplayColorItems = new List<SetColorMarkupItem> { _SetMarkupItem }
210
                        });
211
                });
212

    
213
                colorList.Add(new DisplayColorInfo
214
                {
215
                    UserID = info.UserID,
216
                    DisplayColor = info.DisplayColor,
217
                    Department = info.Depatment,
218
                    UserName = info.UserName,
219
                });
220
            }
221

    
222
            gridViewMarkup.ItemsSource = this._markupInfo;
223
            SetLoadMakupList(this._StartPageNo);
224
            if (_LoadMakupList.Count() == 0)
225
                chkOnlyMarkup.IsChecked = false;
226

    
227
            this.CurrentPageNo = _StartPageNo;
228

    
229
            _definePages = new DefinedPages { DefinedPagesStrings = "", DocumentInfo = this._DocInfo
230
                            , PagesCount = Convert.ToInt32(this._DocInfo.PAGE_COUNT), vpSlip = slip, vpTitle = title, fileUrl = fileurl };
231

    
232
            DocumentInfo = _definePages;
233
            this.DataContext = _definePages;
234

    
235
            CheckCommentPages();
236

    
237
            //초기화면 Comment Check된 상태로 보여주기
238
            foreach (var item in _markupInfo)
239
            {
240
                gridViewMarkup.SelectedItems.Add(item);
241
            }
242

    
243
            PageChangeAsync(Common.ViewerDataModel.Instance.NewCancellationToken(), _StartPageNo).ConfigureAwait(true);
244

    
245
            sliderPages.Maximum = Convert.ToDouble(this._DocInfo.PAGE_COUNT);
246
            this.stPageNo.Maximum = Convert.ToDouble(this._DocInfo.PAGE_COUNT);
247
            this.edPageNo.Maximum = Convert.ToDouble(this._DocInfo.PAGE_COUNT);
248
            this.IsPrint = isPrint;
249

    
250
            if (!IsPrint)
251
            {
252
                GetPrint(false);
253
                btnWholeExport.Visibility = Visibility.Visible;
254
                btnWholePrint.Visibility = Visibility.Collapsed;
255
                Selected_Print.Header = "Export Type";
256
            }
257
            else
258
            {
259
                //PrintList 가져오기
260
                GetPrint(true);
261
                btnWholePrint.Visibility = Visibility.Visible;
262
                btnWholeExport.Visibility = Visibility.Collapsed;
263
            }
264

    
265
            _initializeComponentFinished = true;
266

    
267
            //timm.Interval = 10;
268
            //timm.Elapsed += new System.Timers.ElapsedEventHandler(_Timer_Elapsed);
269
            //timm.Enabled = true;
270
        }
271

    
272
        #endregion
273

    
274
        #region Control Event
275
        private async void sliderPages_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
276
        {
277
            if (_initializeComponentFinished)
278
            {
279
                if (!_IsDagSlider)
280
                {
281
                    this.CurrentPageNo = (int)this.sliderPages.Value;
282

    
283
                    await PageChangeAsync(Common.ViewerDataModel.Instance.NewCancellationToken(), this.CurrentPageNo);
284
                    //await App.PageStorage.GetPageUriAsync(this.CurrentPageNo);
285
                
286
                    if (_ButtonName == "Current")
287
                    {
288
                        stPageNo.Value = CurrentPageNo;
289
                        edPageNo.Value = CurrentPageNo;
290
                    }
291

    
292
                    //CheckCommentPages();
293
                }
294
            }
295
        }
296

    
297
        private async void sliderPages_DragCompleted(object sender, RadDragCompletedEventArgs e)
298
        {
299
            _IsDagSlider = false;
300
            this.CurrentPageNo = (int)this.sliderPages.Value;
301
            if (_initializeComponentFinished)
302
            {
303
               
304
            }
305
        }
306

    
307
        private void sliderPages_DragStarted(object sender, RadDragStartedEventArgs e)
308
        {
309
            _IsDagSlider = true;
310
        }
311

    
312
        private void chkOnlyMarkup_Checked(object sender, RoutedEventArgs e)
313
        {
314
            if (_initializeComponentFinished)      //GridRangePages
315
            {
316
                CheckCommentPages();
317
            }
318
        }
319
        string _ButtonName;
320
        private void PageSelect_Checked(object sender, RoutedEventArgs e)
321
        {
322
            if (!_initializeComponentFinished) return;
323

    
324
            _ButtonName = (sender as RadRadioButton).Tag.ToString();
325
            CommentPageList.ItemsSource = null;
326

    
327
            switch (_ButtonName)
328
            {
329
                case "Current":
330
                    stPageNo.Value = CurrentPageNo;
331
                    edPageNo.Value = CurrentPageNo;
332

    
333
                    GridCurrentPage.Visibility = Visibility.Visible;
334
                    GridDefinePages.Visibility = Visibility.Collapsed;
335
                    GridRangePages.Visibility = Visibility.Collapsed;
336
                    GridAllPages.Visibility = Visibility.Collapsed;
337

    
338
                    break;
339
                case "RangePrint":
340
                    GridCurrentPage.Visibility = Visibility.Collapsed;
341
                    GridDefinePages.Visibility = Visibility.Visible;
342
                    GridRangePages.Visibility = Visibility.Collapsed;
343
                    GridAllPages.Visibility = Visibility.Collapsed;
344
                    break;
345
                case "UserDefined":
346
                    GridCurrentPage.Visibility = Visibility.Collapsed;
347
                    GridDefinePages.Visibility = Visibility.Collapsed;
348
                    GridRangePages.Visibility = Visibility.Visible;
349
                    GridAllPages.Visibility = Visibility.Collapsed;
350
                    break;
351
                case "AllPrint":
352
                    stPageNo.Value = 1;
353
                    edPageNo.Value = Convert.ToDouble(_DocInfo.PAGE_COUNT);
354
                    GridCurrentPage.Visibility = Visibility.Collapsed;
355
                    GridDefinePages.Visibility = Visibility.Collapsed;
356
                    GridRangePages.Visibility = Visibility.Collapsed;
357
                    GridAllPages.Visibility = Visibility.Visible;
358
                    break;
359
            }
360

    
361
            CheckCommentPages();
362
        }
363

    
364
        private void PageNo_ValueChanged(object sender, RadRangeBaseValueChangedEventArgs e)
365
        {
366
            if (_initializeComponentFinished)      //GridRangePages
367
            {
368
                if (stPageNo.Value > edPageNo.Value)
369
                {
370
                    if (sender.Equals(stPageNo))
371
                        edPageNo.Value = stPageNo.Value;
372
                    else
373
                        stPageNo.Value = edPageNo.Value;
374
                }
375

    
376
                //뷰어잠시제외(강인구)
377
                //this.LayoutRoot.Dispatcher.BeginInvoke(delegate()
378
                //{
379
                CheckCommentPages();
380
                //});
381
            }
382
        }
383

    
384
        private void txtDefinedPages_TextChanged(object sender, TextChangedEventArgs e)
385
        {
386
            CheckCommentPages();
387
        }
388

    
389
        private void btnClearDefinedPages_Click(object sender, RoutedEventArgs e)
390
        {
391
            txtDefinedPages.Text = "";
392
        }
393

    
394
        private void CommentPageList_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
395
        {
396
            if (_initializeComponentFinished)
397
                if (CommentPageList.SelectedItem != null)
398
                    this.CurrentPageNo = (CommentPageList.SelectedItem as MarkupPageItem).PageNumber;
399
        }
400

    
401
        private async void gridViewMarkup_SelectionChanged(object sender, SelectionChangeEventArgs e)
402
        {
403
            if (_initializeComponentFinished)
404
            {
405
                await PageChangeAsync(Common.ViewerDataModel.Instance.NewCancellationToken(),this.CurrentPageNo);
406
            }
407
        }
408

    
409
        #endregion
410

    
411
        public async System.Threading.Tasks.Task<bool> PageChangeAsync(System.Threading.CancellationToken cts, int PageNo, bool Flag = false)
412
        {
413
            System.Diagnostics.Debug.WriteLine("PageChangeAsync " + PageNo);
414
            bool result = false;
415
            //Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate
416
            //{
417
            try
418
            {
419
                Load load = new Load();
420

    
421
                _definePages.Back_Image = new ImageBrush();
422
                //var defaultBitmapImage = new BitmapImage(new Uri(_DefaultTileUri + PageNo + ".png"));
423

    
424
                var pages = _definePages.DocumentInfo.DOCPAGE.Where(x => x.PAGE_NUMBER == PageNo);
425

    
426
                if(pages.Count() > 0)
427
                {
428
                    var currentPage = pages.First();
429

    
430
                    //var buffer = await new WebClient().DownloadDataTaskAsync(_DefaultTileUri + PageNo + ".png");
431

    
432
                    //var bitmap = new BitmapImage();
433
                    //using (var stream = new MemoryStream(buffer))
434
                    //{
435
                    //bitmap.BeginInit();
436
                    //bitmap.CacheOption = BitmapCacheOption.OnLoad;
437
                    //bitmap.StreamSource = stream;
438
                    //bitmap.EndInit();
439

    
440
                        
441
                    var uri = await App.PageStorage.GetPageUriAsync(cts, currentPage.PAGE_NUMBER);
442
                    //Image bitmap = new Image();
443
                    //bitmap.Stretch = Stretch.Fill;
444
                    //bitmap.Source = bitmapframe;
445
                    //bitmap.Width = Convert.ToDouble(currentPage.PAGE_WIDTH);
446
                    //bitmap.Height = Convert.ToDouble(currentPage.PAGE_HEIGHT);
447

    
448
                    if (uri.Scheme == Uri.UriSchemeFile)
449
                    {
450
                        var cloneUri = new Uri(System.IO.Path.Combine(System.IO.Path.GetTempPath(),System.IO.Path.GetRandomFileName()),UriKind.Absolute);
451
                        File.Copy(uri.LocalPath, cloneUri.LocalPath);
452

    
453
                        uri = cloneUri;
454
                    }
455

    
456
                    printCanvas.Children.Clear();
457
                    printCanvas.Width = Convert.ToDouble(currentPage.PAGE_WIDTH);
458
                    printCanvas.Height = Convert.ToDouble(currentPage.PAGE_HEIGHT);
459
                 
460
                    printCanvas.Background = new ImageBrush{ ImageSource = new BitmapImage(uri)};
461

    
462
                    //printCanvas.RenderTransformOrigin = new Point(0.5, 0.5);
463
                    //printCanvas.RenderTransform = new RotateTransform(currentPage.PAGE_ANGLE);
464
                    //ImageBrush background = new ImageBrush(bitmap);
465
                    //printCanvas.Background = background;
466
                    //printCanvas.Background = new SolidColorBrush(Colors.Transparent);
467

    
468

    
469
                    foreach (var info in gridViewMarkup.SelectedItems.Cast<IKCOM.MarkupInfoItem>())
470
                    {
471
                        load.User_Id = info.UserID;
472
                        load.document_id = _DocInfo.DOCUMENT_ID;
473
                        load.Page_No = PageNo;
474
                        load.DisplayColor = info.DisplayColor;
475
                        load.Markupinfoid = info.MarkupInfoID;
476
                        var IsLoad = await load.Markup_LoadAsync(printCanvas, 0);
477
                    }
478
                    //await Dispatcher.InvokeAsync(() => {
479
                    //    printCanvas.UpdateLayout();
480
                    //});
481

    
482
                    if (Flag)
483
                        {
484
                        //MemoryStream ms = new MemoryStream();
485
                        //BmpBitmapEncoder bbe = new BmpBitmapEncoder();
486
                        //bbe.Frames.Add(BitmapFrame.Create(new Uri(_DefaultTileUri + PageNo + ".png")));
487
                        //bbe.Save(ms);
488

    
489
                        //System.Drawing.Image.FromFile()
490
                        //Printimg = System.Drawing.Image.FromStream(stream);
491
                        //await System.Threading.Tasks.Task.Run(() =>
492
                        //{
493
                           await Dispatcher.InvokeAsync(() =>
494
                            {
495
                                Export export = new Export();
496
                                p_img = export.Exporting(PrintView, printCanvas.Width, printCanvas.Height);
497
                                Printimg_List.Add(Printimg_List.Count() + 1, p_img);
498
                            },System.Windows.Threading.DispatcherPriority.SystemIdle);
499
                        //});
500
                    }
501

    
502
                        result = true;
503
                    //}
504
                } 
505
            }
506
            catch (Exception ex)
507
            {
508
                //Logger.sendResLog("PrintControl.PageChanged", ex.Message, 0);
509
            }
510

    
511
            return result;
512
            //}));
513
        }
514

    
515

    
516
        public static MemoryStream ByteBufferFromImage(BitmapImage imageSource)
517
        {
518
            var ms = new MemoryStream();
519
            var pngEncoder = new PngBitmapEncoder();
520
            pngEncoder.Frames.Add(BitmapFrame.Create(imageSource));
521
            pngEncoder.Save(ms);
522

    
523
            return ms;
524
        }
525
        //Print 버튼 클릭 이벤트
526
        #region Method - 명령
527
        async void PrintMethod(object sender, RoutedEventArgs e)
528
        {
529
            try
530
            {
531
                var token = Common.ViewerDataModel.Instance.NewCancellationToken();
532

    
533
                if (this.printIndy.IsBusy == true)
534
                    return;
535

    
536
                (this.Parent as RadWindow).CanClose = false;
537

    
538
                await this.Dispatcher.InvokeAsync(() => { 
539
                        this.printIndy.IsBusy = true;
540
                        printIndy.BusyContent = "Printing. . .";
541
                });
542

    
543

    
544
                _lstPrintPageNo = PrintPageCreate();
545

    
546
                if (_lstPrintPageNo.Count == 0)
547
                {
548
                    RadWindow.Alert(new DialogParameters
549
                    {
550
                        Owner = Application.Current.MainWindow,
551
                        Theme = new VisualStudio2013Theme(),
552
                        Header = "Info",
553
                        Content = "Not specified the page."
554
                    });
555
                    sliderPages.Value = 1;
556
                    this.printIndy.IsBusy = false;
557
                    return;
558
                }
559

    
560
                int cnt = 0;
561

    
562
                Printimg_List = new Dictionary<int, System.Drawing.Image>();
563

    
564
                foreach (int PageNo in _lstPrintPageNo)
565
                {
566
                    cnt++;
567
                    sliderPages.Value = PageNo;
568
                    await PageChangeAsync(token,PageNo, true);
569
                    await System.Threading.Tasks.Task.Delay(300);
570
                    //PageChanged(cnt, true);
571
                }
572
                PrintName = cbPrint.SelectedItem.ToString();
573

    
574
                await this.Dispatcher.InvokeAsync(() => {
575
                    if (cnt == _lstPrintPageNo.Count)
576
                    {
577
                        Printing();
578
                    }
579
                });
580
            }
581
            catch (Exception ex)
582
            {
583
                //Logger.sendResLog("PrintMethod", ex.Message, 0);
584
            }
585
            finally
586
            {
587
                (this.Parent as RadWindow).CanClose = true;
588
            }
589

    
590
        }
591

    
592
        //Export 버튼 클릭 이벤트
593
        async void ExportMethod(object sender, RoutedEventArgs e)
594
        {
595
            try
596
            {
597
                if (this.printIndy.IsBusy == true)
598
                    return;
599

    
600
                var token = Common.ViewerDataModel.Instance.NewCancellationToken();
601

    
602
                (this.Parent as RadWindow).CanClose = false;
603

    
604
                this.printIndy.IsBusy = true;
605
                printIndy.BusyContent = "Exporting. . .";
606

    
607
                Export export = new Export();
608
                _lstPrintPageNo = PrintPageCreate();
609

    
610
                if (_lstPrintPageNo.Count == 0)
611
                {
612
                    sliderPages.Value = 1;
613
                    this.printIndy.IsBusy = false;
614
                    RadWindow.Alert(new DialogParameters
615
                    {
616
                        Owner = Application.Current.MainWindow,
617
                        Theme = new VisualStudio2013Theme(),
618
                        Header = "Info",
619
                        Content = "Not specified the page.",
620
                    });
621
                    return;
622
                }
623

    
624
                //FileDialogFilter filterImage = new FileDialogFilter("Image Files", "*.jpg", "*.png");
625

    
626
                switch (cbPrint.SelectedIndex)
627
                {
628
                    case (0):
629
                        {
630
                            SaveDig.Filter = "PDF file format|*.pdf";
631
                            break;
632
                        }
633
                    case (1):
634
                        {
635
                            SaveDig.Filter = "Image Files (*.jpg, *.Jpeg)|*.jpg;*.Jpeg|Image Files (*.png)|*.png";
636
                            break;
637
                        }
638
                }
639

    
640
                SaveDig.Title = "Save an PDF File";
641
                if(SaveDig.ShowDialog().Value)
642
                {
643
                    Printimg_List = new Dictionary<int, System.Drawing.Image>();
644

    
645
                    foreach (int PageNo in _lstPrintPageNo)
646
                    {
647
                        await Dispatcher.InvokeAsync(() =>
648
                        {
649
                            sliderPages.Value = PageNo;
650
                        });
651

    
652

    
653
                        await PageChangeAsync(token, PageNo, true);
654

    
655
                        System.Diagnostics.Debug.WriteLine("Export Page : " + PageNo);
656
                    }
657

    
658
                    //using (FileStream fs = new FileStream(@"D:\Temp\Text.pdf", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None))
659

    
660
                    if (SaveDig.FileName != "")
661
                    {
662
                        switch (cbPrint.SelectedIndex)
663
                        {
664
                            case (0):
665
                                {
666
                                    using (FileStream fs = new FileStream(SaveDig.FileName, FileMode.Create, FileAccess.Write, FileShare.None))
667
                                    {
668
                                        using (Document doc = new Document())
669
                                        {
670
                                            using (PdfWriter writer = PdfWriter.GetInstance(doc, fs))
671
                                            {
672
                                                doc.Open();
673
                                                
674
                                                float height = doc.PageSize.Height;
675
                                                float width = doc.PageSize.Width;
676

    
677
                                                foreach (var item in Printimg_List)
678
                                                {
679
                                                    Export_img = iTextSharp.text.Image.GetInstance(item.Value, System.Drawing.Imaging.ImageFormat.Png);
680

    
681
                                                    if (Export_img.Width > Export_img.Height)
682
                                                    {
683
                                                        doc.SetPageSize(new Rectangle(height, width));
684
                                                        Export_img.ScaleToFit(height, width);
685
                                                    }
686
                                                    else
687
                                                    {
688
                                                        doc.SetPageSize(new Rectangle(width, height));
689
                                                        Export_img.ScaleToFit(width, height);
690
                                                    }
691

    
692
                                                    Export_img.SetAbsolutePosition(0, 0);
693

    
694
                                                    doc.NewPage();
695
                                                    doc.Add(Export_img);
696

    
697
                                                    await System.Threading.Tasks.Task.Delay(100);
698

    
699
                                                }
700
                                                doc.Close();
701
                                            }
702
                                        }
703
                                    }
704
                                    break;
705
                                }
706
                            case (1):
707
                                {
708
                                    foreach (var item in Printimg_List)
709
                                    {
710
                                        switch (SaveDig.FilterIndex)
711
                                        {
712
                                            case (1):
713
                                                {
714
                                                    //(item.Value as System.Drawing.Image).Save(SaveDig.FileName + item.Key, System.Drawing.Imaging.ImageFormat.Jpeg);
715
                                                    (item.Value as System.Drawing.Image).Save(SaveDig.FileName.Replace(".jpg", "_" + item.Key.ToString()) + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
716
                                                }
717
                                                break;
718
                                            case (2):
719
                                                {
720
                                                    //(item.Value as System.Drawing.Image).Save(SaveDig.FileName, System.Drawing.Imaging.ImageFormat.Png);
721
                                                    (item.Value as System.Drawing.Image).Save(SaveDig.FileName.Replace(".png", "_" + item.Key.ToString()) + ".png", System.Drawing.Imaging.ImageFormat.Png);
722
                                                }
723
                                                break;
724
                                        }
725
                                    }
726
                                    break;
727
                                }
728
                        }
729
                    }
730
                    else
731
                    {
732
                        sliderPages.Value = 1;
733
                        this.printIndy.IsBusy = false;
734
                        return;
735
                    }
736

    
737
                    await this.Dispatcher.InvokeAsync(() =>
738
                    {
739
                        sliderPages.Value = 1;
740
                        printIndy.IsBusy = false;
741
                    });
742

    
743
                    await PageChangeAsync(token,_StartPageNo);
744

    
745
                    (Application.Current.MainWindow as MainWindow).dzMainMenu.DialogMessage_Alert("Success", "Alert");
746
                }else
747
                {
748
                    Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate
749
                    {
750
                        sliderPages.Value = 1;
751
                        printIndy.IsBusy = false;
752
                    }));
753

    
754
                    (Application.Current.MainWindow as MainWindow).dzMainMenu.DialogMessage_Alert("Cancel", "Alert");
755
                }                
756
            }
757
            catch (Exception ex)
758
            {
759
                sliderPages.Value = 1;
760
                printIndy.IsBusy = false;
761

    
762
                //Logger.sendResLog("Export Method", ex.Message, 0);
763
                //(Application.Current.MainWindow as MainWindow).dzMainMenu.DialogMessage_Alert("Alert", "관리자 확인이 필요합니다. 다시 시도해 주세요.\n"+ex.Message);
764
            }
765
            finally
766
            {
767
                (this.Parent as RadWindow).CanClose = true;
768
            }
769

    
770

    
771
        }
772
        #endregion
773

    
774
        #region Method - 처리
775
        void CheckCommentPages()
776
        {
777
            List<MarkupPageItem> _pages = new List<MarkupPageItem>();
778
            DoubleCollection _Ticks = new DoubleCollection();
779

    
780

    
781
            if (GridCurrentPage.Visibility == System.Windows.Visibility.Visible)
782
            {
783

    
784
                _pages = (from commPage in this._PageMarkupList
785
                          where commPage.PageNumber == CurrentPageNo
786
                          orderby commPage.PageNumber
787
                          select commPage).ToList();
788
            }
789
            else if (GridRangePages.Visibility == System.Windows.Visibility.Visible)
790
            {
791
                stPageNo.Value = stPageNo.Value == null ? 1 : stPageNo.Value;
792
                edPageNo.Value = edPageNo.Value == null ? 1 : edPageNo.Value;
793

    
794
                int _stPage = (int)stPageNo.Value;
795
                int _edPage = (int)edPageNo.Value;
796

    
797
                _pages = (from commPage in this._PageMarkupList
798
                          where commPage.PageNumber >= _stPage && commPage.PageNumber <= _edPage
799
                          orderby commPage.PageNumber
800
                          select commPage).ToList();
801
            }
802
            else if (GridDefinePages.Visibility == System.Windows.Visibility.Visible)
803
            {
804
                stPageNo.Value = stPageNo.Value == null ? 1 : stPageNo.Value;
805
                edPageNo.Value = edPageNo.Value == null ? 1 : edPageNo.Value;
806

    
807
                int _stPage = (int)stPageNo.Value;
808
                int _edPage = (int)edPageNo.Value;
809

    
810
                //Using DeepView.Common.RangeParser
811
                var lst = RangeParser.Parse(txtDefinedPages.Text, _stPage, _definePages.PagesCount);
812
                _pages = (from commPage in this._PageMarkupList
813
                          from compareData in lst
814
                          where commPage.PageNumber == compareData
815
                          orderby commPage.PageNumber
816
                          select commPage).ToList();
817
            }
818
            else
819
            {
820
                _pages = (from commPage in this._PageMarkupList
821
                          orderby commPage.PageNumber
822
                          select commPage).ToList();
823
            }
824
            CommentPageList.ItemsSource = _pages.ToList();
825
        }
826

    
827
        void SetLoadMakupList(int PageNo)
828
        {
829
            _LoadMakupList.Clear();
830
            var _markupList = _PageMarkupList.Where(page => page.PageNumber == PageNo);
831

    
832
            if (_markupList.Count() > 0)
833
                _LoadMakupList = _markupList.First().DisplayColorItems.ToList();
834
        }
835

    
836
        #region 프린트 리스트 가져오기
837
        public void GetPrint(bool flag)
838
        {
839
            if (flag)
840
            {
841
                foreach (string printer in PrinterSettings.InstalledPrinters)
842
                {
843
                    this.cbPrint.Items.Add(printer);
844
                }
845
                printDocument = new PrintDocument();
846
                this.cbPrint.SelectedItem = printDocument.PrinterSettings.PrinterName;
847
            }
848
            else
849
            {
850
                this.cbPrint.Items.Add("PDF");
851
                this.cbPrint.Items.Add("IMAGE");
852

    
853
                this.cbPrint.SelectedItem = "PDF";
854
            }
855
        }
856
        #endregion
857

    
858
        #region 프린트 실행
859
        public async void Printing()
860
        {
861
            var token = Common.ViewerDataModel.Instance.NewCancellationToken();
862

    
863
            await PageChangeAsync(token,1);
864

    
865
            if (PrinterSettings.InstalledPrinters != null && PrinterSettings.InstalledPrinters.Count > 0)
866
            {
867
                printDocument = new PrintDocument();
868
                printDocument.OriginAtMargins = true;
869
                printDocument.BeginPrint += new System.Drawing.Printing.PrintEventHandler(printDocument_BeginPrint);
870
                printDocument.PrintPage += new System.Drawing.Printing.PrintPageEventHandler(printDocument_PrintPage);
871
                printDocument.EndPrint += new System.Drawing.Printing.PrintEventHandler(printDocument_EndPrint);
872
            }
873
            else
874
                printDocument = null;
875

    
876
            #region 인쇄 미리보기 테스트
877
            using (System.Windows.Forms.PrintPreviewDialog dlg = new System.Windows.Forms.PrintPreviewDialog())
878
            {
879
                printDocument.PrinterSettings.MinimumPage = 1;
880
                printDocument.PrinterSettings.MaximumPage = _lstPrintPageNo.Count();
881
                printDocument.PrinterSettings.FromPage = 1;
882
                printDocument.PrinterSettings.ToPage = _lstPrintPageNo.Count();
883
                printDocument.DefaultPageSettings.Margins = new Margins(0, 0, 0, 0);
884
                printDocument.PrinterSettings.PrinterName = PrintName;
885
                dlg.Document = printDocument;
886
                dlg.WindowState = System.Windows.Forms.FormWindowState.Maximized;
887
                dlg.ShowDialog();
888
            }
889
            #endregion
890

    
891
            #region 인쇄
892
            //printDocument.PrinterSettings.MinimumPage = 1;
893
            //printDocument.PrinterSettings.MaximumPage = _lstPrintPageNo.Count();
894
            //printDocument.PrinterSettings.FromPage = 1;
895
            //printDocument.PrinterSettings.ToPage = _lstPrintPageNo.Count();
896

    
897
            //printDocument.DefaultPageSettings.Margins = new Margins(0, 0, 0, 0);
898
            //printDocument.PrinterSettings.PrinterName = PrintName;
899

    
900
            //printDocument.Print();
901
            #endregion
902
        }
903

    
904
        private void printDocument_BeginPrint(object sender, PrintEventArgs e)
905
        {
906
            //Printimg_List = new Dictionary<int, System.Drawing.Image>();
907
            // This demo only loads one page at a time, so no need to re-set the print page number
908
            PrintDocument document = sender as PrintDocument;
909
            currentPage = document.PrinterSettings.FromPage;
910
        }
911

    
912
        private void printDocument_PrintPage(object sender, PrintPageEventArgs e)
913
        {
914
            //e.Graphics.DrawImage(Printimg_List.Where(info => info.Key == currentPage).FirstOrDefault().Value, 0, 0);
915

    
916
            Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate
917
            {
918
                p_img = Printimg_List.Where(data => data.Key == currentPage).FirstOrDefault().Value;
919

    
920
                if (p_img.Width > p_img.Height)
921
                {
922
                    p_img.RotateFlip(System.Drawing.RotateFlipType.Rotate90FlipNone);
923
                }
924

    
925
                //iTextSharp.text.Image pic = iTextSharp.text.Image.GetInstance(p_img, System.Drawing.Imaging.ImageFormat.Jpeg);
926
                System.Drawing.Image pic = p_img;
927
                System.Drawing.Rectangle m = e.MarginBounds;
928

    
929
                //if ((double)pic.Width / (double)pic.Height > (double)m.Width / (double)m.Height) // image is wider
930
                //{
931
                //    m.Height = 1135;//(int)((double)pic.Height / (double)pic.Width * (double)m.Width) - 16;
932
                //}
933
                //else
934
                //{
935
                //    m.Width = 793;//(int)((double)pic.Width / (double)pic.Height * (double)m.Height) - 16;
936
                //}
937
                m.Width = (int)e.PageSettings.PrintableArea.Width;
938
                m.Height = (int)e.PageSettings.PrintableArea.Height;
939
                m.X = (int)e.PageSettings.HardMarginX;
940
                m.Y = (int)e.PageSettings.HardMarginY;
941

    
942
                e.Graphics.DrawImage(pic, m);
943
                //e.Graphics.DrawImage(p_img, e.MarginBounds);
944
                //e.Graphics.DrawImage(p_img, 0, 0);
945
            }));
946

    
947
            //다음 페이지
948
            currentPage++;
949

    
950
            ////인쇄를 계속 할지 말지 확인
951
            if (currentPage <= printDocument.PrinterSettings.ToPage)
952
                e.HasMorePages = true;
953
            else
954
                e.HasMorePages = false;
955

    
956
        }
957

    
958
        private void printDocument_EndPrint(object sender, PrintEventArgs e)
959
        {
960
            Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate
961
            {
962
                sliderPages.Value = 1;
963
                printIndy.IsBusy = false;
964
            }));
965
        }
966
        #endregion
967

    
968
        #region Selected Pages Check
969
        List<int> PrintPageCreate()
970
        {
971
            List<int> Result = new List<int>();
972

    
973
            if (GridCurrentPage.Visibility == System.Windows.Visibility.Visible || currentPagePrint)
974
            {
975
                Result.Add(CurrentPageNo);
976
            }
977
            else if (GridRangePages.Visibility == System.Windows.Visibility.Visible)
978
            {
979
                for (int i = Convert.ToInt32(stPageNo.Value); i <= Convert.ToInt32(edPageNo.Value); i++)
980
                {
981
                    Result.Add(i);
982
                }
983
            }
984
            else if (GridDefinePages.Visibility == System.Windows.Visibility.Visible)
985
            {
986
                int _stPage = (int)stPageNo.Value;
987
                int _edPage = (int)edPageNo.Value;
988

    
989
                var lst = RangeParser.Parse(txtDefinedPages.Text, _stPage, _definePages.PagesCount);
990
                Result.AddRange(lst);
991
            }
992
            else
993
            {
994
                for (int i = 1; i <= _definePages.PagesCount; i++)
995
                {
996
                    Result.Add(i);
997
                }
998
            }
999
            if (currentPagePrint)
1000
            {
1001
                return Result;
1002
            }
1003

    
1004
            if (chkOnlyMarkup.IsChecked.Value)
1005
            {
1006
                var _result = from result in Result
1007
                              where _PageMarkupList.Where(page => page.PageNumber == result).Count() > 0
1008
                              select result;
1009
                Result = _result.ToList();
1010
            }
1011
            return Result;
1012
        }
1013
        #endregion
1014

    
1015
        #endregion
1016
    }
1017
}
클립보드 이미지 추가 (최대 크기: 500 MB)