kmpdfkit_demo/Demo/Examples/Compdfkit_Tools/DigitalSignature/DigitalSignatureControl/DigitalSignatureControl.xaml.cs

using Compdfkit_Tools.PDFControl;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using System;
using System.ComponentModel;
using System.Dynamic;
using System.IO;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using Compdfkit_Tools.Helper;
using ComPDFKit.DigitalSign;
using ComPDFKit.PDFAnnotation.Form;
using ComPDFKitViewer;

namespace Compdfkit_Tools.PDFControl
{
    public partial class DigitalSignatureControl : UserControl, INotifyPropertyChanged
    {
        private bool isFirstLoad = true;
        public PDFViewControl PDFViewControl = new PDFViewControl();
        private SignatureStatusBarControl signatureStatusBarControl;
        private PanelState panelState = PanelState.GetInstance();
        private CPDFDisplaySettingsControl displaySettingsControl = null;
        private double[] zoomLevelList = { 1f, 8f, 12f, 25, 33f, 50, 66f, 75, 100, 125, 150, 200, 300, 400, 600, 800, 1000 };
        public event EventHandler<bool> OnCanSaveChanged;
        private CPDFSignatureWidget currentSignatureWidget;
        public event EventHandler<string> AfterFillSignature;

        public event EventHandler SignatureStatusChanged;
        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged([CallerMemberName] string name = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }

        public bool CanUndo
        {
            get
            {
                if (PDFViewControl != null && PDFViewControl.PDFView != null)
                {
                    return PDFViewControl.PDFView.UndoManager.CanUndo;
                }
                return false;
            }
        }

        public bool CanRedo
        {
            get
            {
                if (PDFViewControl != null && PDFViewControl.PDFView != null)
                {
                    return PDFViewControl.PDFView.UndoManager.CanRedo;
                }

                return false;
            }
        }

        private bool CanSave
        {
            get
            {
                if (PDFViewControl != null && PDFViewControl.PDFView != null)
                {
                    return PDFViewControl.PDFView.UndoManager.CanSave;
                }

                return false;
            }
        }
        public DigitalSignatureControl()
        {
            InitializeComponent();
            DataContext = this;
            string trustedFolder = AppDomain.CurrentDomain.BaseDirectory + @"\TrustedFolder\";
            if (!Directory.Exists(trustedFolder))
            {
                Directory.CreateDirectory(trustedFolder);
            }
            CPDFSignature.SignCertTrustedFolder = trustedFolder;
        }

        public void ClearViewerControl()
        {
            PDFGrid.Child = null;
            BotaContainer.Child = null;
            PropertyContainer.Child = null;
            displaySettingsControl = null;
            SignatureStatusBorder.Child = null;
            DigitalSignatureBarControl.ClearAllToolState();
        }

        public void InitWithPDFViewer(CPDFViewer pdfViewer)
        {
            PDFViewControl.PDFView = pdfViewer;
            PDFGrid.Child = PDFViewControl;
            FloatPageTool.InitWithPDFViewer(pdfViewer);
            InitialControl();
            DigitalSignatureBarControl.DigitalSignatureActionChanged -= DigitalSignatureBarControl_DigitalSignatureActionChanged;
            DigitalSignatureBarControl.DigitalSignatureActionChanged += DigitalSignatureBarControl_DigitalSignatureActionChanged;

            PDFViewControl.PDFView.WidgetClickHandler -= PDFView_WidgetClickHandler;
            PDFViewControl.PDFView.WidgetClickHandler += PDFView_WidgetClickHandler;
            PDFViewControl.PDFView.UndoManager.PropertyChanged -= UndoManager_PropertyChanged;
            PDFViewControl.PDFView.UndoManager.PropertyChanged += UndoManager_PropertyChanged;
            panelState.PropertyChanged -= PanelState_PropertyChanged;
            panelState.PropertyChanged += PanelState_PropertyChanged;
        }
 
        private void PDFView_WidgetClickHandler(object sender, WidgetArgs e)
        {
            var signatureWidget = (e as WidgetSignArgs).Sign;
            CPDFSignature sig = signatureWidget.GetSignature();
            if (signatureWidget.IsSigned() && sig.SignerList.Count > 0)
            {
                ViewSignatureEvent(sender, sig);
            }
            else
            {
                Window parentWindow = Window.GetWindow((DependencyObject)sender);
                AddCertificationDialog addCertificationControl = new AddCertificationDialog
                {
                    Owner = parentWindow
                };
                currentSignatureWidget = signatureWidget;
                addCertificationControl.FillSignatureEvent -= AddCertificationControl_FillSignatureEvent;
                addCertificationControl.FillSignatureEvent += AddCertificationControl_FillSignatureEvent;
                addCertificationControl.ShowDialog(); 
            }
        }

        private void AddCertificationControl_FillSignatureEvent(object sender, CertificateAccess e)
        {
            FillDigitalSignatureDialog fillDigitalSignatureDialog = new FillDigitalSignatureDialog
            {
                FilePath = e.filePath,
                Password = e.password,
                SignatureWidget = currentSignatureWidget,
                Document = PDFViewControl.PDFView.Document,
                Owner = Window.GetWindow(this)
            };
            fillDigitalSignatureDialog.AfterFillSignature += FillDigitalSignatureDialog_AfterFillSignature; ;
            fillDigitalSignatureDialog.ShowDialog();
        }

        private void FillDigitalSignatureDialog_AfterFillSignature(object sender, string e)
        {
            AfterFillSignature?.Invoke(this, e);
        }

        private void DigitalSignatureBarControl_DigitalSignatureActionChanged(object sender, Common.CPDFDigitalSignatureBarControl.DigitalSignatureAction e)
        {
            if (e == Common.CPDFDigitalSignatureBarControl.DigitalSignatureAction.AddSignatureField)
            {
                CreateSign();
            }
            else if (e == Common.CPDFDigitalSignatureBarControl.DigitalSignatureAction.Signing)
            {
                PDFViewControl.PDFView.SetMouseMode(MouseModes.Viewer);
            }
            else if (e == Common.CPDFDigitalSignatureBarControl.DigitalSignatureAction.VerifySignature)
            {
                ToggleButton button = sender as ToggleButton;
                button.IsChecked = false;
                SignatureStatusChanged?.Invoke(this, null);
            }
        }

        private string GetTime()
        {
            DateTime dateTime = DateTime.Now;
            return " " + dateTime.ToString("yyyy-MM-dd HH:mm:ss.fff");
        }

        private void CreateSign()
        {
            PDFViewControl.PDFView.SetMouseMode(MouseModes.FormEditTool);
            WidgetSignArgs signArgs = new WidgetSignArgs
            {
                LineWidth = 1,
                LineColor = Colors.Black,
                FieldName = "Signature" + GetTime()
            };
            PDFViewControl.PDFView.SetToolParam(signArgs);
        }

        private void InitialControl()
        {
            PDFViewControl.PDFView?.SetMouseMode(MouseModes.Viewer);
            //PDFViewControl.PDFView?.Load();
            PDFViewControl.PDFView?.SetShowLink(true);
            PDFGrid.Child = PDFViewControl;
            PDFViewControl.PDFView.SetFormFieldHighlight(true);
        }

        private void PanelState_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(PanelState.IsLeftPanelExpand))
            {
                ExpandLeftPanel(panelState.IsLeftPanelExpand);
            }
            else if (e.PropertyName == nameof(PanelState.RightPanel))
            {
                if (panelState.RightPanel == PanelState.RightPanelState.ViewSettings)
                {
                    ExpandRightPropertyPanel(displaySettingsControl, Visibility.Visible);
                }
                else
                {
                    ExpandRightPropertyPanel(null, Visibility.Collapsed);

                }
            }
        }

        public void ExpandLeftPanel(bool isExpand)
        {
            BotaContainer.Visibility = isExpand ? Visibility.Visible : Visibility.Collapsed;
            Splitter.Visibility = isExpand ? Visibility.Visible : Visibility.Collapsed;
            if (isExpand)
            {
                BodyGrid.ColumnDefinitions[0].Width = new GridLength(320);
                BodyGrid.ColumnDefinitions[1].Width = new GridLength(15);
            }
            else
            {
                BodyGrid.ColumnDefinitions[0].Width = new GridLength(0);
                BodyGrid.ColumnDefinitions[1].Width = new GridLength(0);
            }
        }

        public void ExpandRightPropertyPanel(UIElement propertytPanel, Visibility visible)
        {
            PropertyContainer.Width = 260;
            PropertyContainer.Child = propertytPanel;
            PropertyContainer.Visibility = visible;
        }

        public void SetBOTAContainer(CPDFBOTABarControl botaControl)
        {
            BotaContainer.Child = botaControl;
        }

        public void ViewCertificateEvent(object sender, CPDFSignature e)
        {
            Window parentWindow = Window.GetWindow((DependencyObject)sender);
            ViewCertificateDialog dialog = new ViewCertificateDialog()
            {
                Owner = parentWindow
            };
            dialog.InitCertificateList(e);
            dialog.CertificateInfoControl.TrustCertificateEvent += (o, args) =>
            {
                SignatureStatusChanged?.Invoke(this, null);
            };
            
            VerifyDigitalSignatureControl verifyControl = parentWindow as VerifyDigitalSignatureControl;
            if (verifyControl != null)
            {
                dialog.CertificateInfoControl.TrustCertificateEvent += (o, args) =>
                {
                    verifyControl.InitWithSignature(e);
                };
            }
            dialog.ShowDialog();
        }

        public void SetDisplaySettingsControl(CPDFDisplaySettingsControl displaySettingsControl)
        {
            this.displaySettingsControl = displaySettingsControl;
        }

        public void SetSignatureStatusBarControl(SignatureStatusBarControl signatureStatusBarControl)
        {
            this.signatureStatusBarControl = signatureStatusBarControl;
            SignatureStatusBorder.Child = this.signatureStatusBarControl;
            if (signatureStatusBarControl.Status != SignatureStatus.None)
            {
                SignatureStatusBorder.Visibility = Visibility.Visible;
            }
            else
            {
                SignatureStatusBorder.Visibility = Visibility.Collapsed;
            }
        }

        /// <summary>
        /// Undo Redo Event Noitfy
        /// </summary>
        private void UndoManager_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            OnPropertyChanged(e.PropertyName);
            if (e.PropertyName == "CanSave")
            {
                OnCanSaveChanged?.Invoke(this, CanSave);
            }
        }

        private void CommandBinding_Executed_Undo(object sender, ExecutedRoutedEventArgs e)
        {
            if (PDFViewControl != null && PDFViewControl.PDFView != null && CanUndo)
            {
                PDFViewControl.PDFView.UndoManager?.Undo();
            }
        }

        private void CommandBinding_Executed_Redo(object sender, ExecutedRoutedEventArgs e)
        {
            if (PDFViewControl != null && PDFViewControl.PDFView != null && CanUndo)
            {
                PDFViewControl.PDFView.UndoManager?.Redo();
            }
        }

        private void UndoButton_Click(object sender, RoutedEventArgs e)
        {
            if (PDFViewControl != null && PDFViewControl.PDFView != null && CanUndo)
            {
                PDFViewControl.PDFView.UndoManager?.Undo();
            }
        }

        private void RedoButton_Click(object sender, RoutedEventArgs e)
        {
            if (PDFViewControl != null && PDFViewControl.PDFView != null && CanRedo)
            {
                PDFViewControl.PDFView.UndoManager?.Redo();
            }
        }

        public void ViewSignatureEvent(object sender, CPDFSignature e)
        {
            Window parentWindow = Window.GetWindow((DependencyObject)sender);
            VerifyDigitalSignatureControl dialog = new VerifyDigitalSignatureControl()
            {
                Owner = parentWindow
            };
            dialog.ViewCertificateEvent -= ViewCertificateEvent;
            dialog.ViewCertificateEvent += ViewCertificateEvent;
            dialog.InitWithSignature(e);
            dialog.ShowDialog();
        }
        
        private void PDFView_AnnotCommandHandler(object sender, AnnotCommandArgs e)
        {
            if (e != null && e.CommandType == CommandType.Context)
            {
                if (e.CommandTarget == TargetType.WidgetView)
                {
                    e.Handle = true;
                    e.PopupMenu = new ContextMenu();
                    var sign = e.Sign.GetSignature();
                    if (!e.Sign.IsSigned())
                    {
                        e.PopupMenu.Items.Add(new MenuItem()
                            { Header = "Copy", Command = ApplicationCommands.Copy, CommandTarget = (UIElement)sender });
                        e.PopupMenu.Items.Add(new MenuItem()
                            { Header = "Cut", Command = ApplicationCommands.Cut, CommandTarget = (UIElement)sender });
                        e.PopupMenu.Items.Add(new MenuItem()
                            { Header = "Delete", Command = ApplicationCommands.Delete, CommandTarget = (UIElement)sender });
                    }
                    else
                    {
                        MenuItem DeleteMenu = new MenuItem()
                            { Header = "Delete" };
                        DeleteMenu.Click += (o, args) =>
                        {
                            var widget = sign.GetSignatureWidget(PDFViewControl.PDFView.Document);
                            int index = e.Sign.Page.PageIndex;
                            PDFViewControl.PDFView.Document.RemoveSignature(sign, true);
                            SignatureStatusChanged?.Invoke(this, null);
                            
                            bool res = widget.ResetForm();
                        };
                        e.PopupMenu.Items.Add(DeleteMenu);
                    }
                }
                else
                {
                    e.Handle = true;
                    e.PopupMenu = new ContextMenu();

                    e.PopupMenu.Items.Add(new MenuItem()
                        { Header = "Paste", Command = ApplicationCommands.Paste, CommandTarget = (UIElement)sender });
                    e.PopupMenu.Items.Add(new Separator());

                    MenuItem fitWidthMenu = new MenuItem();
                    fitWidthMenu.Header = "Automatically Resize";
                    fitWidthMenu.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ChangeFitMode(FitMode.FitWidth);
                        }
                    };

                    e.PopupMenu.Items.Add(fitWidthMenu);

                    MenuItem fitSizeMenu = new MenuItem();
                    fitSizeMenu.Header = "Actual Size";
                    fitSizeMenu.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ChangeFitMode(FitMode.FitSize);
                        }
                    };

                    e.PopupMenu.Items.Add(fitSizeMenu);

                    MenuItem zoomInMenu = new MenuItem();
                    zoomInMenu.Header = "Zoom In";
                    zoomInMenu.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            double newZoom = CommandHelper.CheckZoomLevel(zoomLevelList,
                                PDFViewControl.PDFView.ZoomFactor + 0.01, true);
                            PDFViewControl.PDFView?.Zoom(newZoom);
                        }
                    };

                    e.PopupMenu.Items.Add(zoomInMenu);

                    MenuItem zoomOutMenu = new MenuItem();
                    zoomOutMenu.Header = "Zoom Out";
                    zoomOutMenu.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            double newZoom = CommandHelper.CheckZoomLevel(zoomLevelList,
                                PDFViewControl.PDFView.ZoomFactor - 0.01, false);
                            PDFViewControl.PDFView?.Zoom(newZoom);
                        }
                    };

                    e.PopupMenu.Items.Add(zoomOutMenu);
                    e.PopupMenu.Items.Add(new Separator());

                    MenuItem singleView = new MenuItem();
                    singleView.Header = "Single Page";
                    singleView.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ChangeViewMode(ViewMode.Single);
                        }
                    };

                    e.PopupMenu.Items.Add(singleView);

                    MenuItem singleContinuousView = new MenuItem();
                    singleContinuousView.Header = "Single Page Continuous";
                    singleContinuousView.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ChangeViewMode(ViewMode.SingleContinuous);
                        }
                    };

                    e.PopupMenu.Items.Add(singleContinuousView);

                    MenuItem doubleView = new MenuItem();
                    doubleView.Header = "Two Pages";
                    doubleView.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ChangeViewMode(ViewMode.Double);
                        }
                    };

                    e.PopupMenu.Items.Add(doubleView);

                    MenuItem doubleContinuousView = new MenuItem();
                    doubleContinuousView.Header = "Two Pages Continuous";
                    doubleContinuousView.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ChangeViewMode(ViewMode.DoubleContinuous);
                        }
                    };
                    e.PopupMenu.Items.Add(doubleContinuousView);

                    MenuItem resetFormMenu = new MenuItem();
                    resetFormMenu.Header = "Reset Forms";
                    resetFormMenu.Click += (o, p) =>
                    {
                        if (PDFViewControl != null)
                        {
                            PDFViewControl.PDFView?.ResetForm(null);
                        }
                    };
                    e.PopupMenu.Items.Add(new Separator());
                    e.PopupMenu.Items.Add(resetFormMenu);
                }
            }
            else
            {
                e.DoCommand();
            }
        }

        private void CopyImage_Click(object sender, RoutedEventArgs e)
        {
            CommandHelper.CopyImage_Click(PDFViewControl.PDFView.GetSelectedImages());
        }

        private void ExtraImage_Click(object sender, RoutedEventArgs e)
        {
            CommandHelper.ExtraImage_Click(PDFViewControl.PDFView.GetSelectedImages());
        }
        
        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            PDFViewControl.PDFView.AnnotCommandHandler -= PDFView_AnnotCommandHandler;
            PDFViewControl.PDFView.AnnotCommandHandler += PDFView_AnnotCommandHandler;
        }
         
        private void UserControl_Unloaded(object sender, RoutedEventArgs e)
        {
            PDFViewControl.PDFView.AnnotCommandHandler -= PDFView_AnnotCommandHandler;
        }
        
    }
}