WPF Print Engine: Part I

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing.Printing;
using System.Linq;
using System.Printing;
using System.Printing.Interop;
using System.Runtime.InteropServices;
using System.Timers;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Shapes;
using System.Windows.Threading;
using Microsoft.Practices.Composite.Presentation.Commands;
using Microsoft.Practices.Unity;
using SUT.PrintEngine.Controls.ProgressDialog;
using SUT.PrintEngine.Controls.WaitScreen;
using SUT.PrintEngine.Extensions;
using SUT.PrintEngine.Utils;
using SUT.PrintEngine.Views;
using Application = System.Windows.Application;
using HorizontalAlignment = System.Windows.HorizontalAlignment;
using Orientation = System.Windows.Controls.Orientation;

namespace SUT.PrintEngine.ViewModels
{
    public abstract class APrintControlViewModel : AViewModel, IViewModel
    {
        protected DocumentPaginator Paginator;
        protected IUnityContainer UnityContainer { get; set; }
        protected IWaitScreenViewModel WaitScreen { get; set; }
        protected IProgressDialogViewModel ProgressDialog { get; set; }
        public ICommand ChangePaperCommand { get; set; }
        protected bool ScaleCanceling;

        public double OldScale { get; set; }

        [DllImport("winspool.Drv", EntryPoint = "DocumentPropertiesW", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        static extern int DocumentProperties(IntPtr hwnd, IntPtr hPrinter, [MarshalAs(UnmanagedType.LPWStr)] string pDeviceName, IntPtr pDevModeOutput, IntPtr pDevModeInput, int fMode);


        #region Dependency Properties
        public static readonly DependencyProperty IsPotraitProperty = DependencyProperty.Register(
            "IsPotrait",
            typeof(bool),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(false, new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty IsLandscapeProperty = DependencyProperty.Register(
            "IsLandscape",
            typeof(bool),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(false, new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty IsAdvancedPrintingOptionOpenProperty = DependencyProperty.Register(
            "IsAdvancedPrintingOptionOpen",
            typeof(bool),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(false, new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty IsMarkPageNumbersProperty = DependencyProperty.Register(
            "IsMarkPageNumbers",
            typeof(bool),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty PageOrientationProperty = DependencyProperty.Register(
            "PageOrientation",
            typeof(PageOrientation),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(PageOrientation.Portrait, new PropertyChangedCallback(OnDependencyPropertyChanged)));
        public static readonly DependencyProperty PageOrientationStringProperty = DependencyProperty.Register(
            "PageOrientationString",
            typeof(string),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));
        public static readonly DependencyProperty ApproaxNumberOfPagesProperty = DependencyProperty.Register(
            "ApproaxNumberOfPages",
            typeof(Int32),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty PrintCopyCountProperty = DependencyProperty.Register(
            "PrintCopyCount",
            typeof(int),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(1, new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty PaperSizesProperty = DependencyProperty.Register(
            "PaperSizes",
            typeof(IList<PaperSize>),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty CurrentPaperProperty = DependencyProperty.Register(
            "CurrentPaper",
            typeof(PaperSize),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty DefaultPaperSizeProperty = DependencyProperty.Register(
            "DefaultPaperSize",
            typeof(PaperSize),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty CurrentPrinterNameProperty = DependencyProperty.Register(
            "CurrentPrinterName",
            typeof(string),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty CurrentPrinterProperty = DependencyProperty.Register(
            "CurrentPrinter",
            typeof(PrintQueue),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty PrintersProperty = DependencyProperty.Register(
            "Printers",
            typeof(PrintQueueCollection),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty PagesAcrossProperty = DependencyProperty.Register(
            "PagesAcross",
            typeof(Int32),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));

        public static readonly DependencyProperty NumberOfPagesProperty = DependencyProperty.Register(
            "NumberOfPages",
            typeof(Int32),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(new PropertyChangedCallback(OnDependencyPropertyChanged)));
        public static readonly DependencyProperty IsPrintingOptionsOpenProperty = DependencyProperty.Register(
            "IsPrintingOptionsOpen",
            typeof(bool),
            typeof(APrintControlViewModel));
        public static readonly DependencyProperty IsCancelPrintingOptionsEnabledProperty = DependencyProperty.Register(
            "IsCancelPrintingOptionsEnabled",
            typeof(bool),
            typeof(APrintControlViewModel));
        public static readonly DependencyProperty IsSetPrintingOptionsEnabledProperty = DependencyProperty.Register(
            "IsSetPrintingOptionsEnabled",
            typeof(bool),
            typeof(APrintControlViewModel));
        public static readonly DependencyProperty CanScaleProperty = DependencyProperty.Register(
            "CanScale",
            typeof(bool),
            typeof(APrintControlViewModel),
            new FrameworkPropertyMetadata(true));
        public static readonly DependencyProperty PrinterErrorVisibilityProperty = DependencyProperty.Register(
            "PrinterErrorVisibility",
            typeof(Visibility),
            typeof(APrintControlViewModel));
        public Visibility PrinterErrorVisibility
        {
            get
            {
                return (Visibility)GetValue(PrinterErrorVisibilityProperty);
            }
            set
            {
                SetValue(PrinterErrorVisibilityProperty, value);
            }
        }
        public bool CanScale
        {
            get
            {
                return (bool) GetValue(CanScaleProperty);
            }
            set
            {
                SetValue(CanScaleProperty, value);
            }
        }
        public bool IsPotrait
        {
            get
            {
                return (bool)GetValue(IsPotraitProperty);
            }
            set
            {
                SetValue(IsPotraitProperty, value);
            }
        }
        public bool IsLandscape
        {
            get
            {
                return (bool)GetValue(IsLandscapeProperty);
            }
            set
            {
                SetValue(IsLandscapeProperty, value);
            }
        }
        public bool IsAdvancedPrintingOptionOpen
        {
            get
            {
                return (bool)GetValue(IsAdvancedPrintingOptionOpenProperty);
            }
            set
            {
                SetValue(IsAdvancedPrintingOptionOpenProperty, value);
            }
        }
        public bool IsMarkPageNumbers
        {
            get
            {
                return (bool)GetValue(IsMarkPageNumbersProperty);
            }
            set
            {
                SetValue(IsMarkPageNumbersProperty, value);
            }
        }
        public bool IsPrintingOptionsOpen
        {
            get
            {
                return (bool)GetValue(IsPrintingOptionsOpenProperty);
            }
            set
            {
                SetValue(IsPrintingOptionsOpenProperty, value);
            }
        }
        public bool IsCancelPrintingOptionsEnabled
        {
            get
            {
                return (bool)GetValue(IsCancelPrintingOptionsEnabledProperty);
            }
            set
            {
                SetValue(IsCancelPrintingOptionsEnabledProperty, value);
            }
        }
        public bool IsSetPrintingOptionsEnabled
        {
            get
            {
                return (bool)GetValue(IsSetPrintingOptionsEnabledProperty);
            }
            set
            {
                SetValue(IsSetPrintingOptionsEnabledProperty, value);
            }
        }
        public string PageOrientationString
        {
            get
            {
                return (string)GetValue(PageOrientationStringProperty);
            }
            set
            {
                SetValue(PageOrientationStringProperty, value);
            }
        }
        public PageOrientation PageOrientation
        {
            get
            {
                return (PageOrientation)GetValue(PageOrientationProperty);
            }
            set
            {
                SetValue(PageOrientationProperty, value);
                PageOrientationString = PageOrientation.ToString();
            }
        }

        public int ApproaxNumberOfPages
        {
            get
            {
                return (int)GetValue(ApproaxNumberOfPagesProperty);
            }
            set
            {
                SetValue(ApproaxNumberOfPagesProperty, value);
            }
        }

        public int PrintCopyCount
        {
            get
            {
                return (int)GetValue(PrintCopyCountProperty);
            }
            set
            {
                SetValue(PrintCopyCountProperty, value);
            }
        }

        public IList<PaperSize> PaperSizes
        {
            get
            {
                return (IList<PaperSize>)GetValue(PaperSizesProperty);
            }
            set
            {
                SetValue(PaperSizesProperty, value);
            }
        }

        public PaperSize CurrentPaper
        {
            get
            {
                return (PaperSize)GetValue(CurrentPaperProperty);
            }
            set
            {
                SetValue(CurrentPaperProperty, value);
            }
        }

        public PaperSize DefaultPaperSize
        {
            get
            {
                return (PaperSize)GetValue(DefaultPaperSizeProperty);
            }
            set
            {
                SetValue(DefaultPaperSizeProperty, value);
            }
        }

        public string CurrentPrinterName
        {
            get
            {
                return GetValue(CurrentPrinterNameProperty).ToString();
            }
            set
            {
                SetValue(CurrentPrinterNameProperty, value);
            }
        }

        public PrintQueue CurrentPrinter
        {
            get
            {
                return (PrintQueue)GetValue(CurrentPrinterProperty);
            }
            set
            {
                SetValue(CurrentPrinterProperty, value);
            }
        }

        public PrintQueueCollection Printers
        {
            get
            {
                return (PrintQueueCollection)GetValue(PrintersProperty);
            }
            set
            {
                SetValue(PrintersProperty, value);
            }
        }

        public int PagesAcross
        {
            get
            {
                return (int)GetValue(PagesAcrossProperty);
            }
            set
            {
                SetValue(PagesAcrossProperty, value);
            }
        }

        public int NumberOfPages
        {
            get
            {
                return (int)GetValue(NumberOfPagesProperty);
            }
            set
            {
                SetValue(NumberOfPagesProperty, value);
            }
        }
        #endregion

        #region Member Variables
        public int MaxCopies;
        private bool IsMarkPageNumbersChanged;
        private bool IsPageOrientationChanged;
        private bool IsPrintCopyCountChanged;
        private bool IsCurrentPaperChanged;
        private bool IsCurrentPrinterChanged;
        private bool IsCurrentPrinterNameChanged;

        #endregion

        private static void OnDependencyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var presenter = ((APrintControlViewModel)d);
            if (!presenter._settingOptions)
            {
                switch (e.Property.Name)
                {
                    case "IsMarkPageNumbers":
                        presenter.PrintOptionsSetterIsEnable(true);
                        if (e.OldValue != null && !presenter.IsMarkPageNumbersChanged)
                        {
                            presenter.IsMarkPageNumbersChanged = true;
                            presenter._oldPrintingOptions.IsMarkPageNumbers = (bool)e.OldValue;
                        }
                        presenter._newPrintingOptions.IsMarkPageNumbers = (bool)e.NewValue;
                        break;
                    case "PageOrientation":
                        presenter.PrintOptionsSetterIsEnable(true);
                        if (e.OldValue != null && !presenter.IsPageOrientationChanged)
                        {
                            presenter.IsPageOrientationChanged = true;
                            presenter._oldPrintingOptions.PageOrientation = (PageOrientation)e.OldValue;
                        }
                        presenter._newPrintingOptions.PageOrientation = (PageOrientation)e.NewValue;
                        break;
                    case "CurrentPaper":
                        presenter.PrintOptionsSetterIsEnable(true);
                        if (e.OldValue != null && !presenter.IsCurrentPaperChanged)
                        {
                            presenter.IsCurrentPaperChanged = true;
                            presenter._oldPrintingOptions.CurrentPaper = (PaperSize)e.OldValue;
                        }
                        presenter._newPrintingOptions.CurrentPaper = (PaperSize)e.NewValue;
                        break;
                    case "PrintCopyCount":
                        presenter.PrintOptionsSetterIsEnable(true);
                        if (e.OldValue != null && !presenter.IsPrintCopyCountChanged)
                        {
                            presenter.IsPrintCopyCountChanged = true;
                            presenter._oldPrintingOptions.PrintCopyCount = (int)e.OldValue;
                        }
                        presenter._newPrintingOptions.PrintCopyCount = (int)e.NewValue;
                        break;
                    case "CurrentPrinter":
                        if (e.NewValue != null)
                        {
                            presenter.PrintOptionsSetterIsEnable(true);
                            try
                            {
                                if (e.OldValue != null && !presenter.IsCurrentPrinterChanged)
                                {
                                    presenter.IsCurrentPrinterChanged = true;
                                    presenter._oldPrintingOptions.CurrentPrinter = (PrintQueue)e.OldValue;
                                }
                                presenter.FetchSetting();
                                presenter._newPrintingOptions.CurrentPrinter = (PrintQueue)e.NewValue;
                                presenter.SetPrintError(false);
                            }
                            catch (Exception)
                            {
                                presenter.SetPrintError(true);
                            }

                        }
                        break;
                    case "CurrentPrinterName":
                        presenter.PrintOptionsSetterIsEnable(true);
                        if (e.OldValue != null && !presenter.IsCurrentPrinterNameChanged)
                        {
                            presenter.IsCurrentPrinterNameChanged = true;
                            presenter._oldPrintingOptions.CurrentPrinterName = (string)e.OldValue;
                        }
                        presenter._newPrintingOptions.CurrentPrinterName = (string)e.NewValue;
                        break;

                }
            }
            else
            {
                if (e.Property.Name == "CurrentPrinter")
                {
                    var currentPrinter = e.NewValue as PrintQueue;
                    if (currentPrinter != null)
                    {
                        try
                        {
                            presenter.FetchSetting();
                            presenter.SetPrintError(false);
                        }
                        catch (Exception)
                        {
                            presenter.SetPrintError(true);
                        }
                    }
                }
            }
        }

        private void SetPrintError(bool isError)
        {
            if (isError)
            {
                PrinterErrorVisibility = Visibility.Visible;
                ((PrintControlView)View).EnablePrintingOptionsSet(false);
                ((PrintControlView)View).PrintingOptionsWaitCurtainVisibility(false);
            }
            else
            {
                PrinterErrorVisibility = Visibility.Hidden;
                ((PrintControlView)View).EnablePrintingOptionsSet(true);
            }

        }

        public virtual void HandlePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
        }
        #region Class Members

        public PrintQueue LocalPrinter;
        public Window FullScreenPrintWindow;
        private PrintingOptions _oldPrintingOptions;
        private PrintingOptions _newPrintingOptions;
        private bool _settingOptions;
        public bool Loading;
        public bool ReloadingPreview;
        public ICommand PrintDocumentCommand { get; set; }
        public ICommand PrintSetupCommand { get; set; }
        public ICommand CancelPrintCommand { get; set; }
        public ICommand PageOrientationCommand { get; set; }
        public ICommand SetPrintingOptionsCommand { get; set; }
        public ICommand CancelPrintingOptionsCommand { get; set; }
        public ICommand MarkPageNumbersCommand { get; set; }
        public ICommand AllPagesCommand { get; set; }
        public ICommand ActualPageSizeCommand { get; set; }
        #endregion

        protected APrintControlViewModel(PrintControlView view, IUnityContainer unityContainer)
            : base(view)
        {
            PrintControlView = view;
            PrintControlView.Loaded += PrintControlViewLoaded;
            _oldPrintingOptions = new PrintingOptions();
            _newPrintingOptions = new PrintingOptions();
            UnityContainer = unityContainer;
            WaitScreen = UnityContainer.Resolve<IWaitScreenViewModel>();
            PrintUtility = unityContainer.Resolve<PrintUtility>();
            CancelPrintCommand = new DelegateCommand<object>(ExecuteCancelPrint);
            PrintDocumentCommand = new DelegateCommand<object>(ExecutePrint);
            PageOrientationCommand = new DelegateCommand<object>(ExecutePageOrientation);
            SetPrintingOptionsCommand = new DelegateCommand<object>(ExecuteSetPrintingOptions);
            CancelPrintingOptionsCommand = new DelegateCommand<object>( ExecuteCancelPrintingOptions);
            MarkPageNumbersCommand = new DelegateCommand<object>(ExecuteMarkPageNumbers);
            AllPagesCommand = new DelegateCommand<object>(ExecuteAllPages);
            ActualPageSizeCommand = new DelegateCommand<object>(ExecuteActualPageSizeCommand);
            ChangePaperCommand = new DelegateCommand<object>(ExecuteChangePaper);

        }

        private void ExecuteChangePaper(object obj)
        {
            try
            {
                var ptc = new PrintTicketConverter(CurrentPrinter.FullName, CurrentPrinter.ClientPrintSchemaVersion);
                var mainWindowPtr = new WindowInteropHelper(FullScreenPrintWindow).Handle;
                var myDevMode = ptc.ConvertPrintTicketToDevMode(CurrentPrinter.UserPrintTicket, BaseDevModeType.UserDefault);
                var pinnedDevMode = GCHandle.Alloc(myDevMode, GCHandleType.Pinned);
                var pDevMode = pinnedDevMode.AddrOfPinnedObject();
                var result = DocumentProperties(mainWindowPtr, IntPtr.Zero, CurrentPrinter.FullName, pDevMode, pDevMode, 14);
                if (result == 1)
                {
                    CurrentPrinter.UserPrintTicket = ptc.ConvertDevModeToPrintTicket(myDevMode);
                    pinnedDevMode.Free();
                    PrintCopyCount = CurrentPrinter.UserPrintTicket.CopyCount.Value;
                    SetPageOrientation(CurrentPrinter.UserPrintTicket.PageOrientation);
                    SetCurrentPaper(CurrentPrinter.UserPrintTicket.PageMediaSize);
                    ExecuteSetPrintingOptions(null);
                }
            }
            catch (Exception)
            {

            }
        }

        public void ExecutePageOrientation(object parameter)
        {
            PageOrientation = parameter.ToString() == "Portrait" ? PageOrientation.Portrait : PageOrientation.Landscape;
        }

        protected virtual void ExecuteActualPageSizeCommand(object obj)
        {
            ShowAllPages = false;
            ReloadPreview();
        }

        public abstract void ReloadPreview();

        public virtual void InitializeProperties()
        {
            try
            {
                Printers = PrintUtility.GetPrinters();
                SetLocalPrinter();
                var defaultPrintQueue = PrintUtility.GetDefaultPrintQueue(string.Empty);
                IsMarkPageNumbers = true;
                var defaultPrinterFullName = defaultPrintQueue.FullName;
                var defaultExists = false;
                foreach (var printer in Printers)
                {
                    if (printer.Name == defaultPrintQueue.Name)
                    {
                        defaultExists = true;
                        break;
                    }
                }
                if (!defaultExists)
                {
                    Printers.Add(defaultPrintQueue);
                    var temp = Printers;
                    Printers = null;
                    Printers = temp;
                }
                CurrentPrinterName = defaultPrinterFullName;
                CurrentPrinter = Printers.First(e => e.FullName == defaultPrinterFullName);
                PrintOptionsSetterIsEnable(false);
                SetPrintError(false);
                var userPrintTicket = PrintUtility.GetUserPrintTicket(CurrentPrinter.FullName);
                if(userPrintTicket != null)
                    CurrentPrinter.UserPrintTicket = userPrintTicket;
                SetCurrentPaper(CurrentPrinter.UserPrintTicket.PageMediaSize);
                SetPageOrientation(CurrentPrinter.UserPrintTicket.PageOrientation);
                ExecuteSetPrintingOptions(false);
            }
            catch (Exception ex)
            {
                SetPrintError(true);
            }

        }

        private void SetLocalPrinter()
        {
            foreach (var printer in Printers)
            {
                if (printer.HostingPrintServer.Name.Contains(SystemInformation.ComputerName))
                {
                    LocalPrinter = printer;
                    break;
                }
            }
        }

        #region Command Execution
        public virtual void ExecuteAllPages(object parameter)
        {
            ShowAllPages = true;
            ReloadPreview();
        }

        private void SetPageOrientation(PageOrientation? pageOrientation)
        {
            if (pageOrientation == PageOrientation.Portrait && PageOrientation != PageOrientation.Portrait)
            {
                PageOrientation = PageOrientation.Portrait;
            }
            if (pageOrientation == PageOrientation.Landscape && PageOrientation != PageOrientation.Landscape)
            {
                PageOrientation = PageOrientation.Landscape;
            }
        }

        private void SetCurrentPaper(PageMediaSize pageMediaSize)
        {
            var widthInInch = Math.Round(pageMediaSize.Width.Value / 96 * 100);
            var heightInInch = Math.Round(pageMediaSize.Height.Value / 96 * 100);
            var paperSize = PaperSizes.FirstOrDefault(p => p.Width == widthInInch && p.Height == heightInInch);
            if (paperSize != null)
                CurrentPaper = PaperSizes[PaperSizes.IndexOf(paperSize)];
        }

        public void ExecuteSetPrintingOptions(object parameter)
        {
            _settingOptions = true;
            if (IsPrintCopyCountChanged)
            {
                PrintCopyCount = _newPrintingOptions.PrintCopyCount;
                CurrentPrinter.UserPrintTicket.CopyCount = PrintCopyCount;
            }
            if (IsMarkPageNumbersChanged)
            {
                IsMarkPageNumbers = _newPrintingOptions.IsMarkPageNumbers;
            }

            if (IsPageOrientationChanged)
            {
                PageOrientation = _newPrintingOptions.PageOrientation;
                if (PageOrientation == PageOrientation.Portrait)
                {
                    ((PrintControlView)View).Portrait.IsChecked = true;
                }
                else
                {
                    ((PrintControlView)View).Landscape.IsChecked = true;
                }
                SetupPrintOrientation(PageOrientation);
            }
            if (IsCurrentPaperChanged)
            {
                CurrentPaper = _newPrintingOptions.CurrentPaper;
            }

            PrintUtility.SaveUserPrintTicket(CurrentPrinter);

            ResetPrintingOptions();
            ReloadPreview();
        }

        public void ExecuteCancelPrintingOptions(object parameter)
        {
            _settingOptions = true;
            if (IsPrintCopyCountChanged)
                PrintCopyCount = _oldPrintingOptions.PrintCopyCount;
            if (IsMarkPageNumbersChanged)
                IsMarkPageNumbers = _oldPrintingOptions.IsMarkPageNumbers;
            if (IsPageOrientationChanged)
            {
                PageOrientation = _oldPrintingOptions.PageOrientation;
                if (PageOrientation == PageOrientation.Portrait)
                    ((PrintControlView)View).Portrait.IsChecked = true;
                else
                    ((PrintControlView)View).Landscape.IsChecked = true;
            }
            if (IsCurrentPrinterChanged)
            {
                PaperSizes = _oldPrintingOptions.PaperSizes;
                CurrentPrinter = _oldPrintingOptions.CurrentPrinter;
                CurrentPrinterName = _oldPrintingOptions.CurrentPrinterName;
                CurrentPaper = _oldPrintingOptions.CurrentPaper;
            }
            ResetPrintingOptions();
            _settingOptions = false;
        }

        public void ResetPrintingOptions()
        {
            _settingOptions = true;
            IsSetPrintingOptionsEnabled = false;
            IsCancelPrintingOptionsEnabled = false;
            IsAdvancedPrintingOptionOpen = false;
            _oldPrintingOptions = new PrintingOptions();
            _newPrintingOptions = new PrintingOptions();
            IsMarkPageNumbersChanged = false;
            IsPageOrientationChanged = false;
            IsPrintCopyCountChanged = false;
            IsCurrentPaperChanged = false;
            IsCurrentPrinterChanged = false;
            IsCurrentPrinterNameChanged = false;
            _settingOptions = false;
            PrintOptionsSetterIsEnable(false);
            ((PrintControlView)View).EnablePrintingOptionsSet(true);
        }

        private void PrintOptionsSetterIsEnable(bool isEnabled)
        {
            ((PrintControlView)View).SetButton.Visibility = Visibility.Visible;
            ((PrintControlView)View).SetButton.IsEnabled = isEnabled;
            ((PrintControlView)View).CancelSetButton.IsEnabled = isEnabled;
        }

        public virtual void ExecuteMarkPageNumbers(object parameter)
        {
            ReloadPreview();
        }

        public void ExecuteCancelPrint(object parameter)
        {
            if (FullScreenPrintWindow != null)
                FullScreenPrintWindow.Close();
        }

        #region Exec Print

        public virtual void ExecutePrint(object parameter)
        {
            try
            {
                var printDialog = new System.Windows.Controls.PrintDialog();
                printDialog.PrintQueue = CurrentPrinter;
                printDialog.PrintTicket = CurrentPrinter.UserPrintTicket;
                ShowProgressDialog();
                printDialog.PrintDocument(Paginator, "");
            }
            catch (Exception)
            {
            }
            finally
            {
                ProgressDialog.Hide();
            }

        }

        private void SetupPrintOrientation(PageOrientation orientation)
        {
            if (orientation == PageOrientation.Portrait)
            {
                CurrentPrinter.UserPrintTicket.PageOrientation = PageOrientation.Portrait;
            }
            else
            {
                CurrentPrinter.UserPrintTicket.PageOrientation = PageOrientation.Landscape;
            }
        }

        public void ShowProgressDialog()
        {
            ProgressDialog = UnityContainer.Resolve<IProgressDialogViewModel>();
            var cancelAsyncPrintCommand = new DelegateCommand<object>(ExecuteCancelAsyncPrint);
            ProgressDialog.CancelCommand = cancelAsyncPrintCommand;
            ProgressDialog.MaxProgressValue = ApproaxNumberOfPages;
            ProgressDialog.CurrentProgressValue = 0;
            ProgressDialog.Message = GetStatusMessage();
            ProgressDialog.DialogTitle = "Printing...";
            ProgressDialog.CancelButtonCaption = "Cancel";
            SetProgressDialogCancelButtonVisibility();
            ProgressDialog.Show();
        }

        public virtual void SetProgressDialogCancelButtonVisibility()
        {
            ProgressDialog.CancelButtonVisibility = CurrentPrinter.IsXpsDevice ? Visibility.Visible : Visibility.Hidden;
        }

        public virtual void ExecuteCancelAsyncPrint(object obj)
        {
            try
            {
                ProgressDialog.Hide();
            }
            catch
            {
            }
        }

        public string GetStatusMessage()
        {
            return string.Format("Printing pages {0} / {1}", ProgressDialog.CurrentProgressValue, ProgressDialog.MaxProgressValue);
        }

        #endregion

        #endregion

        #region Show View

        public void CreatePrintPreviewWindow()
        {
            FullScreenPrintWindow = new Window();
            FullScreenPrintWindow.Activated += FullScreenPrintWindowActivated;
            FullScreenPrintWindow.Closing += FullScreenPrintWindowClosing;
            FullScreenPrintWindow.Title = "Print Preview";
            FullScreenPrintWindow.MinWidth = 600;
            FullScreenPrintWindow.MinHeight = 600;
            FullScreenPrintWindow.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            FullScreenPrintWindow.ShowInTaskbar = false;
            FullScreenPrintWindow.WindowStyle = WindowStyle.SingleBorderWindow;
            FullScreenPrintWindow.WindowState = WindowState.Maximized;
            FullScreenPrintWindow.Owner = Application.Current.MainWindow;
            FullScreenPrintWindow.Content = View;
            ApplicationExtention.MainWindow = FullScreenPrintWindow;
        }

        public virtual void FullScreenPrintWindowClosing(object sender, CancelEventArgs e)
        {
            if (!ReloadingPreview)
            {
                IsAdvancedPrintingOptionOpen = false;
            }
        }

        private void FullScreenPrintWindowActivated(object sender, EventArgs e)
        {
            if (Loading)
            {
                ApplicationExtention.MainWindow = FullScreenPrintWindow;
            }
        }

        private void LoadDocument()
        {
            ////TempFileLogger.Log("Starting Load Document");
            _settingOptions = true;
            ReloadPreview();
            Loading = false;
            IsSetPrintingOptionsEnabled = false;
            IsCancelPrintingOptionsEnabled = false;
            _settingOptions = false;
            ////TempFileLogger.Log("End Load Document");

        }
        #endregion

        #region updating pane visibility
        private Dispatcher _dispatcher;
        private const bool IsShown = false;
        private System.Timers.Timer _hideTimer;
        public void ShowPrintOptionCurtain()
        {
            if (_dispatcher == null)
            {
                _dispatcher = Application.Current.Dispatcher;
                _hideTimer = new System.Timers.Timer();
                _hideTimer.Elapsed += HideTimerElapsed;
                _hideTimer.Interval = 300;
                _hideTimer.Enabled = false;
            }
            if (_dispatcher != null)
            {
                _dispatcher.BeginInvoke(DispatcherPriority.Send, new Action(ShowUpdatingPaneHandler));
                Block();
            }
        }

        private static void Block()
        {
            if (Application.Current == null)
                return;
            while (true)
            {
                ApplicationExtention.DoEvents(Application.Current);
                System.Threading.Thread.Sleep(5);
                break;
            }
        }

        private void ShowUpdatingPaneHandler()
        {
            try
            {
                if (IsShown)
                {
                    _hideTimer.Stop();
                    return;
                }
                ((IPrintControlView)View).PrintingOptionsWaitCurtainVisibility(true);
            }
            catch
            {
            }
        }

        public void HidePrintOptionCurtain()
        {
            _hideTimer.Start();
        }
        void HideTimerElapsed(object sender, ElapsedEventArgs e)
        {
            _hideTimer.Stop();
            if (_dispatcher != null)
                _dispatcher.BeginInvoke(DispatcherPriority.Send, new Action(HideUpdatingPaneHandler));
        }

        private void HideUpdatingPaneHandler()
        {
            ((IPrintControlView)View).PrintingOptionsWaitCurtainVisibility(false);
        }
        #endregion

        #region Asynchronous Printer Data

        public IDocumentPaginatorSource PaginatorSource;
        public double Pageaccrosswith;
        protected PrintControlView PrintControlView;
        protected bool ShowAllPages = true;
        private readonly PrinterPreferences _printerPreferences;
        protected PrintUtility PrintUtility;

        public void FetchSetting()
        {
            ShowPrintOptionCurtain();
            CurrentPrinterName = CurrentPrinter.FullName;
            PaperSizes = PrintUtility.GetPaperSizes(CurrentPrinterName);
            var userPrintTicket = PrintUtility.GetUserPrintTicket(CurrentPrinter.FullName);
            if (userPrintTicket != null)
                CurrentPrinter.UserPrintTicket = userPrintTicket;
            SetCurrentPaper(CurrentPrinter.UserPrintTicket.PageMediaSize);
            SetPageOrientation(CurrentPrinter.UserPrintTicket.PageOrientation);
            PrintCopyCount = CurrentPrinter.UserPrintTicket.CopyCount !=null? CurrentPrinter.UserPrintTicket.CopyCount.Value:PrintCopyCount;
            ExecuteSetPrintingOptions(null);
            HidePrintOptionCurtain();
        }

        #endregion

        protected void PrintControlViewLoaded(object sender, RoutedEventArgs e)
        {
            PrintControlView.SetPrintingOptionsWaitCurtainVisibility(Visibility.Collapsed);
            InitializeProperties();
            ResetPrintingOptions();
            LoadDocument();
        }

        protected void DisplayPagePreviewsAll(DocumentPaginator paginator)
        {
            double scale;
            var rowCount = GetRowCount(paginator);
            var container = ((IPrintControlView)View).GetPagePreviewContainer();
            container.Children.Clear();
            for (var i = 0; i < rowCount; i++)
            {

                container.Children.Add(new StackPanel
                                           {
                                               Orientation = Orientation.Horizontal,
                                               HorizontalAlignment = HorizontalAlignment.Stretch,
                                               VerticalAlignment = System.Windows.VerticalAlignment.Center
                                           });
                Application.Current.DoEvents();
            }

            var totalWidth = PagesAcross * (paginator.PageSize.Width + 40);
            var totalHeight = rowCount * (paginator.PageSize.Height + 40);
            if (totalWidth > totalHeight)
            {
                scale = ((ScrollViewer)((Border)container.Parent).Parent).ActualWidth / totalWidth;
            }
            else
            {
                scale = ((ScrollViewer)((Border)container.Parent).Parent).ActualHeight / totalHeight;
            }

            scale = ShowAllPages ? scale : 1;

            for (var i = 0; i < paginator.PageCount; i++)
            {
                Application.Current.DoEvents();
                var pageElement = GetPageUiElement(i, paginator, scale);
                pageElement.HorizontalAlignment = HorizontalAlignment.Center;
                pageElement.VerticalAlignment = System.Windows.VerticalAlignment.Center;
                var rowIndex = i / PagesAcross;
                InsertPageToPreviewContainer(rowIndex, pageElement, container);

            }
        }

        private static void InsertPageToPreviewContainer(int rowIndex, Border pageElement, StackPanel container)
        {
            ((StackPanel)container.Children[rowIndex]).Children.Add(pageElement);
        }

        private int GetRowCount(DocumentPaginator paginator)
        {
            return (int)(Math.Ceiling((double)paginator.PageCount / PagesAcross));
        }

        private Border GetPageUiElement(int i, DocumentPaginator paginator, double scale)
        {
            var source = paginator.GetPage(i);
            var border = new Border() { Background = Brushes.White };
            border.Margin = new Thickness(10 * scale);
            border.BorderBrush = Brushes.DarkGray;
            border.BorderThickness = new Thickness(1);
            //var margin = PrintUtility.GetPageMargin(CurrentPrinterName);
            var margin = new Thickness();
            var rectangle = new Rectangle();
            rectangle.Width = ((source.Size.Width * 0.96 - (margin.Left + margin.Right)) * scale);
            rectangle.Height = ((source.Size.Height * 0.96 - (margin.Top + margin.Bottom)) * scale);
            rectangle.Margin = new Thickness(margin.Left * scale, margin.Top * scale, margin.Right * scale, margin.Bottom * scale);
            rectangle.Fill = Brushes.White;
            var vb = new VisualBrush(source.Visual);
            vb.Opacity = 1;
            vb.Stretch = Stretch.Uniform;
            rectangle.Fill = vb;
            border.Child = rectangle;
            return border;
        }

        public void PrintControlLoaded()
        {
            LoadDocument();
        }
    }
}