kmpdfkit_demo/Demo/Examples/ContentEditor/MainWindow.xaml.cs

using ComPDFKit.PDFDocument;
using ComPDFKit.PDFPage;
using Compdfkit_Tools.Edit;
using Compdfkit_Tools.Helper;
using Compdfkit_Tools.PDFControl;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
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.Imaging;

namespace ContentEditor
{
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        #region Property

        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;
            }
        }

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

        /// <summary>
        /// The last PDF edit object
        /// </summary>
        private PDFEditEvent lastPDFEditEvent = null;

        private PDFViewControl passwordViewer;

        private PDFViewControl pdfViewControl;

        private PDFImageEditControl imageEditControl = new PDFImageEditControl();

        private PDFTextEditControl textEditControl = new PDFTextEditControl();

        private Border empytPanel = new Border();

        private UIElement prevPanel = null;

        private double[] zoomLevelList = { 1f, 8f, 12f, 25, 33f, 50, 66f, 75, 100, 125, 150, 200, 300, 400, 600, 800, 1000 };

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        public MainWindow()
        {
            InitializeComponent();
            Loaded += MainWindow_Loaded;
            DataContext = this;
        }

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            TextBlock emptyBlock = new TextBlock();
            emptyBlock.HorizontalAlignment = HorizontalAlignment.Center;
            emptyBlock.VerticalAlignment = VerticalAlignment.Center;
            empytPanel.Child = emptyBlock;
            empytPanel.Width = 260;

            BotaSideTool.AddBOTAContent(BOTATools.Thumbnail | BOTATools.Outline | BOTATools.Bookmark | BOTATools.Search);
            LoadDefaultDocument();
        }

        #region Load document

        private void LoadDocument()
        {
            pdfViewControl.PDFView?.Load();
            PDFGrid.Child = pdfViewControl;
            pdfViewControl.PDFView.InfoChanged -= PdfViewer_InfoChanged;
            pdfViewControl.PDFView.InfoChanged += PdfViewer_InfoChanged;
            PasswordUI.Closed -= PasswordUI_Closed;
            PasswordUI.Canceled -= PasswordUI_Canceled;
            PasswordUI.Confirmed -= PasswordUI_Confirmed;
            PasswordUI.Closed += PasswordUI_Closed;
            PasswordUI.Canceled += PasswordUI_Canceled;
            PasswordUI.Confirmed += PasswordUI_Confirmed;

            pdfViewControl.PDFView.PDFEditActiveHandler -= PDFView_PDFEditActiveHandler;
            pdfViewControl.PDFView.PDFEditActiveHandler += PDFView_PDFEditActiveHandler;
            pdfViewControl.PDFView.UndoManager.PropertyChanged -= UndoManager_PropertyChanged;
            pdfViewControl.PDFView.UndoManager.PropertyChanged += UndoManager_PropertyChanged;
            pdfViewControl.PDFView.PDFEditCommandHandler -= PDFView_PDFEditCommandHandler;
            pdfViewControl.PDFView.PDFEditCommandHandler += PDFView_PDFEditCommandHandler;
            pdfViewControl.PDFView.AnnotCommandHandler -= PDFView_AnnotCommandHandler;
            pdfViewControl.PDFView.AnnotCommandHandler += PDFView_AnnotCommandHandler;
            pdfViewControl.PDFView.SetFormFieldHighlight(true);

            pdfViewControl.PDFView.ChangeFitMode(FitMode.FitWidth);
            CPDFSaclingControl.InitWithPDFViewer(pdfViewControl.PDFView);
            CPDFSaclingControl.SetZoomTextBoxText(string.Format("{0}", (int)(pdfViewControl.PDFView.ZoomFactor * 100)));

            FloatPageTool.InitWithPDFViewer(pdfViewControl.PDFView);
            BotaSideTool.InitWithPDFViewer(pdfViewControl.PDFView);
            BotaSideTool.SelectBotaTool(BOTATools.Thumbnail);
            ViewSettingBtn.IsChecked = false;
            PropertyContainer.Child = null;
            PropertyContainer.Visibility = Visibility.Collapsed;

            SetEditMode();
        }

        private void LoadDefaultDocument()
        {
            string defaultFilePath = "PDF32000_2008.pdf";
            pdfViewControl = new PDFViewControl();
            pdfViewControl.PDFView.InitDocument(defaultFilePath);
            LoadDocument();
        }


        #endregion 

        #region Password

        private void PasswordUI_Confirmed(object sender, string e)
        {
            if (passwordViewer != null && passwordViewer.PDFView != null && passwordViewer.PDFView.Document != null)
            {
                passwordViewer.PDFView.Document.UnlockWithPassword(e);
                if (passwordViewer.PDFView.Document.IsLocked == false)
                {
                    PasswordUI.SetShowError("", Visibility.Collapsed);
                    PasswordUI.ClearPassword();
                    PasswordUI.Visibility = Visibility.Collapsed;
                    PopupBorder.Visibility = Visibility.Collapsed;
                    pdfViewControl = passwordViewer;
                    LoadDocument();
                }
                else
                {
                    PasswordUI.SetShowError("Wrong Password", Visibility.Visible);
                }
            }
        }

        private void PasswordUI_Canceled(object sender, EventArgs e)
        {
            PopupBorder.Visibility = Visibility.Collapsed;
            PasswordUI.Visibility = Visibility.Collapsed;
        }

        private void PasswordUI_Closed(object sender, EventArgs e)
        {
            PopupBorder.Visibility = Visibility.Collapsed;
            PasswordUI.Visibility = Visibility.Collapsed;
        }

        #endregion
           
        #region Expand and collapse Panel

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

        #endregion

        #region Context menu
         
        private void PDFView_AnnotCommandHandler(object sender, AnnotCommandArgs e)
        {
            if (e != null && e.CommandType == CommandType.Context)
            {
                if (e.PressOnSelectedText)
                {
                    e.Handle = true;
                    e.PopupMenu = new ContextMenu();
                    e.PopupMenu.Items.Add(new MenuItem() { Header = "Copy", Command = ApplicationCommands.Copy, CommandTarget = (UIElement)sender });
                }
                else if (e.CommandTarget == TargetType.ImageSelection)
                {
                    if (pdfViewControl != null && pdfViewControl.PDFView != null && pdfViewControl.PDFView.GetSelectImageCount() > 0)
                    {
                        e.Handle = true;
                        e.PopupMenu = new ContextMenu();

                        MenuItem imageCopyMenu = new MenuItem();
                        imageCopyMenu = new MenuItem();
                        imageCopyMenu.Header = "Copy Images";
                        WeakEventManager<MenuItem, RoutedEventArgs>.AddHandler(imageCopyMenu, "Click", CopyImage_Click);
                        imageCopyMenu.CommandParameter = e;
                        e.PopupMenu.Items.Add(imageCopyMenu);

                        MenuItem imageExtraMenu = new MenuItem();
                        imageExtraMenu = new MenuItem();
                        imageExtraMenu.Header = "Extract Images";
                        WeakEventManager<MenuItem, RoutedEventArgs>.AddHandler(imageExtraMenu, "Click", ExtraImage_Click);
                        imageExtraMenu.CommandParameter = e;
                        e.PopupMenu.Items.Add(imageExtraMenu);
                    }
                }
                else
                {
                    e.Handle = true;
                    e.PopupMenu = new ContextMenu();

                    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 = CheckZoomLevel(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 = CheckZoomLevel(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);
                }
            }

            if (e != null && e.CommandType == CommandType.Copy)
            {
                e.DoCommand();
            }
        }

        private void CopyImage_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                Dictionary<int, List<Bitmap>> imageDict = pdfViewControl.PDFView?.GetSelectedImages();

                if (imageDict != null && imageDict.Count > 0)
                {
                    foreach (int pageIndex in imageDict.Keys)
                    {
                        List<Bitmap> imageList = imageDict[pageIndex];
                        foreach (Bitmap image in imageList)
                        {
                            MemoryStream ms = new MemoryStream();
                            image.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
                            BitmapImage imageData = new BitmapImage();
                            imageData.BeginInit();
                            imageData.StreamSource = ms;
                            imageData.CacheOption = BitmapCacheOption.OnLoad;
                            imageData.EndInit();
                            imageData.Freeze();
                            Clipboard.SetImage(imageData);
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {

            }
        }

        private void ExtraImage_Click(object sender, RoutedEventArgs e)
        {
            System.Windows.Forms.FolderBrowserDialog folderDialog = new System.Windows.Forms.FolderBrowserDialog();
            if (folderDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                string choosePath = folderDialog.SelectedPath;
                string openPath = choosePath;
                try
                {
                    Dictionary<int, List<Bitmap>> imageDict = pdfViewControl.PDFView?.GetSelectedImages();

                    if (imageDict != null && imageDict.Count > 0)
                    {
                        foreach (int pageIndex in imageDict.Keys)
                        {
                            List<Bitmap> imageList = imageDict[pageIndex];
                            foreach (Bitmap image in imageList)
                            {
                                string savePath = Path.Combine(choosePath, Guid.NewGuid() + ".jpg");
                                image.Save(savePath, System.Drawing.Imaging.ImageFormat.Jpeg);
                                openPath = savePath;
                            }
                        }
                    }
                    Process.Start("explorer", "/select,\"" + openPath + "\"");
                }
                catch (Exception ex)
                {

                }
            }
        }
        private void PDFEditImageContextMenu(object sender, PDFEditCommand editCommand)
        {
            editCommand.PopupMenu = new ContextMenu();

            if (ApplicationCommands.Copy.CanExecute(null, (UIElement)sender) && lastPDFEditEvent != null)
            {
                MenuItem rotateLeftMenu = new MenuItem();
                rotateLeftMenu.Header = "Rotate Left";
                rotateLeftMenu.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        lastPDFEditEvent.Rotate = -90;
                        lastPDFEditEvent.UpdatePDFEditByEventArgs();
                        imageEditControl?.SetImageThumb();
                    }
                };
                editCommand.PopupMenu.Items.Add(rotateLeftMenu);

                MenuItem rotateRightMenu = new MenuItem();
                rotateRightMenu.Header = "Rotate Right";
                rotateRightMenu.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        lastPDFEditEvent.Rotate = 90;
                        lastPDFEditEvent.UpdatePDFEditByEventArgs();
                        imageEditControl?.SetImageThumb();
                    }
                };
                editCommand.PopupMenu.Items.Add(rotateRightMenu);

                MenuItem replaceMenu = new MenuItem();
                replaceMenu.Header = "Replace";
                replaceMenu.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        OpenFileDialog openFileDialog = new OpenFileDialog();
                        openFileDialog.Filter = "Image Files(*.jpg;*.jpeg;*.png;*.bmp)|*.jpg;*.jpeg;*.png;*.bmp;";
                        if (openFileDialog.ShowDialog() == true)
                        {
                            lastPDFEditEvent.ReplaceImagePath = openFileDialog.FileName;
                            lastPDFEditEvent.UpdatePDFEditByEventArgs();
                            pdfViewControl.PDFView?.ClearSelectPDFEdit();
                        }
                    }
                };
                editCommand.PopupMenu.Items.Add(replaceMenu);

                MenuItem exportMenu = new MenuItem();
                exportMenu.Header = "Export";
                exportMenu.Click += (o, p) =>
                {
                    if (pdfViewControl != null && pdfViewControl.PDFView != null)
                    {
                        Dictionary<int, List<Bitmap>> imageDict = pdfViewControl.PDFView.GetSelectedImages();
                        if (imageDict != null && imageDict.Count > 0)
                        {
                            System.Windows.Forms.FolderBrowserDialog folderBrowser = new System.Windows.Forms.FolderBrowserDialog();
                            if (folderBrowser.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                            {
                                string choosePath = folderBrowser.SelectedPath;
                                string openPath = choosePath;
                                try
                                {
                                    foreach (int pageIndex in imageDict.Keys)
                                    {
                                        List<Bitmap> imageList = imageDict[pageIndex];
                                        foreach (Bitmap image in imageList)
                                        {
                                            string savePath = System.IO.Path.Combine(choosePath, Guid.NewGuid() + ".jpg");
                                            image.Save(savePath, System.Drawing.Imaging.ImageFormat.Jpeg);
                                            openPath = savePath;
                                        }
                                    }
                                    Process.Start("explorer", "/select,\"" + openPath + "\"");
                                }
                                catch (Exception ex)
                                {

                                }
                            }
                        }
                    }
                };
                editCommand.PopupMenu.Items.Add(exportMenu);

                MenuItem opacityMenu = new MenuItem();
                opacityMenu.Header = "Opacity";
                editCommand.PopupMenu.Items.Add(opacityMenu);

                AppendOpacityMenu(opacityMenu);

                MenuItem horizonMirror = new MenuItem();
                horizonMirror.Header = "Flip horizontal";
                horizonMirror.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        lastPDFEditEvent.HorizontalMirror = true;
                        lastPDFEditEvent.UpdatePDFEditByEventArgs();
                        imageEditControl?.SetImageThumb();
                    }
                };
                editCommand.PopupMenu.Items.Add(horizonMirror);

                MenuItem verticalMirror = new MenuItem();
                verticalMirror.Header = "Flip vertical";
                verticalMirror.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        lastPDFEditEvent.VerticalMirror = true;
                        lastPDFEditEvent.UpdatePDFEditByEventArgs();
                        imageEditControl?.SetImageThumb();
                    }
                };
                editCommand.PopupMenu.Items.Add(verticalMirror);

                MenuItem cropMenu = new MenuItem();
                cropMenu.Header = "Crop";
                cropMenu.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        lastPDFEditEvent.ClipImage = true;
                        lastPDFEditEvent.UpdatePDFEditByEventArgs();
                    }
                };
                editCommand.PopupMenu.Items.Add(cropMenu);

                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Copy", Command = ApplicationCommands.Copy, CommandTarget = (UIElement)sender });
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Cut", Command = ApplicationCommands.Cut, CommandTarget = (UIElement)sender });
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Delete", Command = ApplicationCommands.Delete, CommandTarget = (UIElement)sender });
            }
            else
            {
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Paste", Command = ApplicationCommands.Paste, CommandTarget = (UIElement)sender });
            }
        }

        private void AppendOpacityMenu(MenuItem parentMenu)
        {
            List<int> opacityList = new List<int>()
            {
                25,50,75,100
            };

            foreach (int opacity in opacityList)
            {
                MenuItem opacityMenu = new MenuItem();
                opacityMenu.Header = string.Format("{0}%", opacity);
                opacityMenu.Click += (o, p) =>
                {
                    if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
                    {
                        lastPDFEditEvent.Transparency = (int)(opacity * 255 / 100D);
                        lastPDFEditEvent.UpdatePDFEditByEventArgs();
                        imageEditControl?.SetImageTransparency(lastPDFEditEvent.Transparency);
                        imageEditControl?.SetImageThumb();
                    }
                };
                parentMenu.Items.Add(opacityMenu);
            }
        }
         
        private void PDFEditTextContextMenu(object sender, PDFEditCommand editCommand)
        {
            editCommand.PopupMenu = new ContextMenu();
            if (lastPDFEditEvent != null)
            {
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Copy", Command = ApplicationCommands.Copy, CommandTarget = (UIElement)sender });
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Cut", Command = ApplicationCommands.Cut, CommandTarget = (UIElement)sender });
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Delete", Command = ApplicationCommands.Delete, CommandTarget = (UIElement)sender });
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Paste", Command = ApplicationCommands.Paste, CommandTarget = (UIElement)sender });
            }
            else
            {
                editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Paste", Command = ApplicationCommands.Paste, CommandTarget = (UIElement)sender });
                if (editCommand.TextAreaCopied)
                {
                    editCommand.PopupMenu.Items.Add(new MenuItem() { Header = "Paste And Match Style", Command = CustomCommands.PasteMatchStyle, CommandTarget = (UIElement)sender });
                }
            }
        }

        #endregion

        #region UI

        /// <summary>
        /// Check the zoom factor
        /// </summary>
        private double CheckZoomLevel(double zoom, bool IsGrowth)
        {
            double standardZoom = 100;
            if (zoom <= 0.01)
            {
                return 0.01;
            }
            if (zoom >= 10)
            {
                return 10;
            }

            zoom *= 100;
            for (int i = 0; i < zoomLevelList.Length - 1; i++)
            {
                if (zoom > zoomLevelList[i] && zoom <= zoomLevelList[i + 1] && IsGrowth)
                {
                    standardZoom = zoomLevelList[i + 1];
                    break;
                }
                if (zoom >= zoomLevelList[i] && zoom < zoomLevelList[i + 1] && !IsGrowth)
                {
                    standardZoom = zoomLevelList[i];
                    break;
                }
            }
            return standardZoom / 100;
        }

        private void PageView_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            UIElement pageView = sender as UIElement;
            if (pageView != null)
            {
                pageView.MouseLeftButtonUp -= PageView_MouseLeftButtonUp;
            }
            SetImageEditProperty();
        }
        private void RightPanelBtn_Click(object sender, RoutedEventArgs e)
        {
            ViewSettingBtn.IsChecked = false;
            ToggleButton toggleButton = sender as ToggleButton;
            if (toggleButton != null)
            {
                if (toggleButton.IsChecked == true)
                {
                    if (PropertyContainer.Child is CPDFDisplaySettingsControl)
                    {
                        PropertyContainer.Child = prevPanel;
                    }

                    if (PropertyContainer.Child == null)
                    {
                        PropertyContainer.Child = empytPanel;
                    }
                    PropertyContainer.Visibility = Visibility.Visible;
                }
                else
                {
                    PropertyContainer.Visibility = Visibility.Collapsed;
                }
            }
        }

        private void ToolExpand_Click(object sender, RoutedEventArgs e)
        {
            ToggleButton expandBtn = sender as ToggleButton;
            if (expandBtn != null)
            {
                bool isExpand = expandBtn.IsChecked == true;
                ExpandLeftPanel(isExpand);
            }
        }

        private void ExpandSearchBtn_Click(object sender, RoutedEventArgs e)
        {
            ToolExpandBtn.IsChecked = true;
            ExpandLeftPanel(true);
            BotaSideTool.SelectBotaTool(BOTATools.Search);
        }


        private void ViewSettingBtn_Click(object sender, RoutedEventArgs e)
        {
            RightPanelBtn.IsChecked = false;
            ToggleButton toggleButton = sender as ToggleButton;
            if (toggleButton != null)
            {
                if (toggleButton.IsChecked == true)
                {
                    CPDFDisplaySettingsControl displayPanel = new CPDFDisplaySettingsControl();
                    displayPanel.SetSplitContainerVisibility(Visibility.Collapsed);
                    displayPanel.InitWithPDFViewer(pdfViewControl.PDFView);
                    prevPanel = PropertyContainer.Child;
                    PropertyContainer.Child = displayPanel;
                    PropertyContainer.Visibility = Visibility.Visible;
                }
                else
                {
                    PropertyContainer.Child = null;
                    PropertyContainer.Visibility = Visibility.Collapsed;
                }
            }
        }

        private void NextPageBorder_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            pdfViewControl.PDFView?.GoToPage(pdfViewControl.PDFView.CurrentIndex + 1);
        }

        private void PrevPageBorder_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            pdfViewControl.PDFView?.GoToPage(pdfViewControl.PDFView.CurrentIndex - 1);
        }

        private void PageInfoBtn_Click(object sender, RoutedEventArgs e)
        {
            PasswordUI.Visibility = Visibility.Collapsed;
            FileInfoUI.Visibility = Visibility.Visible;
            FileInfoControl.InitWithPDFViewer(pdfViewControl.PDFView);
            PopupBorder.Visibility = Visibility.Visible;
        }

        private void FileInfoCloseBtn_Click(object sender, RoutedEventArgs e)
        {
            PopupBorder.Visibility = Visibility.Collapsed;
        }

        private void OpenFile_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string filePath = CommonHelper.GetFilePathOrEmpty();
                if (!string.IsNullOrEmpty(filePath) && pdfViewControl != null)
                {
                    if (pdfViewControl.PDFView != null && pdfViewControl.PDFView.Document != null)
                    {
                        string oldFilePath = pdfViewControl.PDFView.Document.FilePath;
                        if (oldFilePath.ToLower() == filePath.ToLower())
                        {
                            return;
                        }
                    }

                    passwordViewer = new PDFViewControl();
                    passwordViewer.PDFView.InitDocument(filePath);
                    if (passwordViewer.PDFView.Document == null)
                    {
                        MessageBox.Show("Open File Failed");
                        return;
                    }

                    if (passwordViewer.PDFView.Document.IsLocked)
                    {
                        PasswordUI.SetShowText(System.IO.Path.GetFileName(filePath) + " password encrypted.");
                        PasswordUI.ClearPassword();
                        PopupBorder.Visibility = Visibility.Visible;
                        PasswordUI.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        pdfViewControl = passwordViewer;
                        LoadDocument();
                    }
                }
            }
            catch (Exception ex)
            {

            }
        }

        private void SaveFileBtn_Click(object sender, RoutedEventArgs e)
        {
            SaveFile();
        }

        private void PDFTextEditButton_Click(object sender, RoutedEventArgs e)
        {
            ToggleButton senderBtn = sender as ToggleButton;
            if (senderBtn != null && pdfViewControl != null)
            {
                ClearPDFEditState(senderBtn);
                RightPanelBtn.IsChecked = false;
                if (PropertyContainer.Child != null)
                {
                    PropertyContainer.Child = empytPanel;
                }

                if (senderBtn.IsChecked == true)
                {
                    pdfViewControl.PDFView?.SetMouseMode(MouseModes.Viewer);
                    pdfViewControl.PDFView?.SetPDFEditType(CPDFEditType.EditText);
                    pdfViewControl.PDFView?.SetPDFEditCreateType(CPDFEditType.EditText);
                    pdfViewControl.PDFView?.SetMouseMode(MouseModes.PDFEdit);
                    pdfViewControl.PDFView?.ReloadDocument();
                }
                else
                {
                    pdfViewControl.PDFView?.SetPDFEditCreateType(CPDFEditType.None);
                    pdfViewControl.PDFView?.SetPDFEditType(CPDFEditType.EditImage | CPDFEditType.EditText);
                    pdfViewControl.PDFView?.SetMouseMode(MouseModes.PDFEdit);
                    pdfViewControl.PDFView?.ReloadDocument();
                }
            }
        }

        private void PDFImageEditButton_Click(object sender, RoutedEventArgs e)
        {
            ToggleButton senderBtn = sender as ToggleButton;
            if (senderBtn != null && pdfViewControl != null)
            {
                ClearPDFEditState(senderBtn);
                senderBtn.IsChecked = false;

                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Filter = "Image Files(*.jpg;*.jpeg;*.png;*.bmp)|*.jpg;*.jpeg;*.png;*.bmp;";
                if (openFileDialog.ShowDialog() == true)
                {
                    pdfViewControl.PDFView?.ClearSelectPDFEdit();
                    pdfViewControl.PDFView?.SetPDFEditType(CPDFEditType.EditImage | CPDFEditType.EditText);
                    pdfViewControl.PDFView?.SetMouseMode(MouseModes.PDFEdit);
                    pdfViewControl.PDFView?.ReloadDocument();

                    RightPanelBtn.IsChecked = false;
                    if (PropertyContainer.Child != null)
                    {
                        PropertyContainer.Child = empytPanel;
                    }
                    PropertyContainer.Visibility = Visibility.Collapsed;
                    pdfViewControl.PDFView?.SetPDFEditCreateType(CPDFEditType.EditImage);
                    pdfViewControl.PDFView?.AddPDFEditImage(openFileDialog.FileName);
                }
            }
        }

        private void ClearPDFEditState(ToggleButton ignoreBtn = null)
        {
            List<ToggleButton> clearBtnList = new List<ToggleButton>()
            {
                PDFTextEditButton,
                PDFImageEditButton
            };

            foreach (ToggleButton item in clearBtnList)
            {
                if (ignoreBtn == item)
                {
                    continue;
                }
                item.IsChecked = false;
            }
        }

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

        private void RedoBtn_Click(object sender, RoutedEventArgs e)
        {
            if (pdfViewControl != null && pdfViewControl.PDFView != null)
            {
                pdfViewControl.PDFView.UndoManager?.Redo();
            }
        }
        #endregion

        #region Property changed
         
        protected void OnPropertyChanged([CallerMemberName] string name = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
        }

        private void UndoManager_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            OnPropertyChanged(e.PropertyName);
        }

        #endregion

        #region Event handle
         
        private void PDFView_PDFEditCommandHandler(object sender, PDFEditCommand e)
        {
            if (e == null)
            {
                return;
            }

            if (e.EditType == CPDFEditType.EditText)
            {
                e.Handle = true;
                PDFEditTextContextMenu(sender, e);
            }

            if (e.EditType == CPDFEditType.EditImage)
            {
                e.Handle = true;
                PDFEditImageContextMenu(sender, e);
            }
        }

        private void PDFView_PDFEditActiveHandler(object sender, PDFEditEvent e)
        {
            PDFEditEvent tempEvent = lastPDFEditEvent;
            lastPDFEditEvent = e;
            ViewSettingBtn.IsChecked = false;
            if (e == null)
            {
                PropertyContainer.Child = null;
                RightPanelBtn.IsChecked = false;
                PropertyContainer.Visibility = Visibility.Collapsed;
                return;
            }

            if (Mouse.RightButton == MouseButtonState.Pressed && PropertyContainer.Visibility != Visibility.Visible)
            {
                return;
            }

            if (e.EditType == CPDFEditType.EditText)
            {
                if (textEditControl == null)
                {
                    textEditControl = new PDFTextEditControl();
                }
                textEditControl.SetPDFTextEditData(e);
                PropertyContainer.Child = textEditControl;
                PropertyContainer.Visibility = Visibility.Visible;
                RightPanelBtn.IsChecked = true;
                return;
            }

            if (e.EditType == CPDFEditType.EditImage && pdfViewControl != null)
            {
                UIElement pageView = sender as UIElement;
                if (pageView != null)
                {
                    pageView.MouseLeftButtonUp -= PageView_MouseLeftButtonUp;
                    pageView.MouseLeftButtonUp += PageView_MouseLeftButtonUp;
                }
                if (Mouse.RightButton == MouseButtonState.Pressed)
                {
                    SetImageEditProperty();
                }
                return;
            }
        }

        #endregion 

        #region Save file

        private void SaveFile()
        {
            if (pdfViewControl != null && pdfViewControl.PDFView != null && pdfViewControl.PDFView.Document != null)
            {
                CPDFDocument pdfDoc = pdfViewControl.PDFView.Document;
                if (pdfDoc.WriteToLoadedPath())
                {
                    return;
                }

                SaveFileDialog saveDialog = new SaveFileDialog();
                saveDialog.Filter = "(*.pdf)|*.pdf";
                saveDialog.DefaultExt = ".pdf";
                saveDialog.OverwritePrompt = true;

                if (saveDialog.ShowDialog() == true)
                {
                    pdfDoc.WriteToFilePath(saveDialog.FileName);
                }
            }
        }

        #endregion

        #region Selected changed

        private void PdfViewer_InfoChanged(object sender, KeyValuePair<string, object> e)
        {
            if (e.Key == "Zoom")
            {
                CPDFSaclingControl.SetZoomTextBoxText(string.Format("{0}", (int)((double)e.Value * 100)));
            }
        }

        private void SetImageEditProperty()
        {
            if (lastPDFEditEvent != null && lastPDFEditEvent.EditType == CPDFEditType.EditImage)
            {
                if (imageEditControl == null)
                {
                    imageEditControl = new PDFImageEditControl();
                }
                imageEditControl.InitWithPDFViewer(pdfViewControl.PDFView);
                imageEditControl.SetPDFImageEditData(lastPDFEditEvent);
                PropertyContainer.Child = imageEditControl;
                PropertyContainer.Visibility = Visibility.Visible;
                RightPanelBtn.IsChecked = true;
            }
        }

        private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            SetEditMode();
        }

        private void SetEditMode()
        {
            ClearPDFEditState(null);

            if (pdfViewControl != null && ViewComboBox != null)
            {
                if (ViewComboBox.SelectedIndex == 0)
                {
                    PDFEditTool.Visibility = Visibility.Collapsed;
                    pdfViewControl.PDFView?.SetShowLink(true);
                    pdfViewControl.PDFView?.SetPDFEditType(CPDFEditType.None);
                    pdfViewControl.PDFView?.SetMouseMode(MouseModes.Viewer);
                    pdfViewControl.PDFView?.ReloadDocument();
                    if (PropertyContainer != null)
                    {
                        PropertyContainer.Child = null;
                    }
                    return;
                }

                if (ViewComboBox.SelectedIndex == 1)
                {
                    PDFEditTool.Visibility = Visibility.Visible;
                    pdfViewControl.PDFView?.SetShowLink(false);
                    pdfViewControl.PDFView?.SetPDFEditType(CPDFEditType.EditText | CPDFEditType.EditImage);
                    pdfViewControl.PDFView?.SetPDFEditCreateType(CPDFEditType.None);
                    pdfViewControl.PDFView?.SetMouseMode(MouseModes.PDFEdit);
                    pdfViewControl.PDFView?.ReloadDocument();
                }
            }
        }

        #endregion 

        #region Close window

        protected override void OnClosing(CancelEventArgs e)
        {
            if (pdfViewControl.PDFView.UndoManager.CanSave)
            {
                MessageBoxResult result = MessageBox.Show("Do you want to save your changes before closing the application？", "Message", MessageBoxButton.YesNoCancel);
                if (result == MessageBoxResult.Yes)
                {
                    SaveFile();
                }
                else if (result == MessageBoxResult.No)
                {

                }
                else
                {
                    e.Cancel = true;
                }
            }
        }

        #endregion 
    }
}