kmpdfkit_demo/Demo/Examples/Compdfkit_Tools/Edit/PDFImageEdit/PDFImageEditControl/PDFImageEditControl.xaml.cs

using ComPDFKit.Import;
using ComPDFKit.PDFDocument;
using ComPDFKit.PDFPage;
using ComPDFKit.PDFPage.Edit;
using ComPDFKit.Tool;
using ComPDFKit.Tool.UndoManger;
using ComPDFKit.Viewer.Helper;
using ComPDFKitViewer;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace Compdfkit_Tools.Edit
{
    public partial class PDFImageEditControl : UserControl
    {
        public CPDFViewerTool ToolView { get; set; }
        public ImageEditParam EditEvent { get; set; }
        //public List<PDFEditEvent> EditMultiEvents { get; set; }

        public PDFImageEditControl()
        {
            InitializeComponent();
            Loaded += PDFImageEditControl_Loaded;
            Unloaded += PDFImageEditControl_Unloaded;
        }

        private void PDFImageEditControl_Unloaded(object sender, RoutedEventArgs e)
        {
            RotateUI.RotationChanged -= RotateUI_RotationChanged;
            FlipUI.FlipChanged -= FlipUI_FlipChanged;
        }

        public void InitWithPDFViewer(CPDFViewerTool newPDFView)
        {
            ToolView = newPDFView;
            RotateUI.RotationChanged -= RotateUI_RotationChanged;
            FlipUI.FlipChanged -= FlipUI_FlipChanged;
            RotateUI.RotationChanged += RotateUI_RotationChanged;
            FlipUI.FlipChanged += FlipUI_FlipChanged;
        }
        
        public void SetRotationText(float rotation)
        {
            RotationTxb.Text = rotation.ToString(CultureInfo.CurrentCulture);
        }

        public void SetPDFImageEditData(ImageEditParam newEvent)
        {
            if (newEvent.EditIndex < 0)
            {
                EditEvent = null;
            }
            else
            {
                EditEvent = newEvent;
            }
            if (newEvent != null && newEvent.EditType == CPDFEditType.EditImage)
            {
                SetImageTransparency(newEvent.Transparency);
            }
            
            if(RotationTxb!=null && newEvent!=null && newEvent.EditType == CPDFEditType.EditImage)
            {
                //RotationTxb.Text = newEvent.CurrentRotated.ToString(CultureInfo.CurrentCulture);
            }
            
            EditEvent = newEvent;
            SetImageThumb();
        }

        //public void SetPDFImageMultiEditData(List<PDFEditEvent> editEvents)
        //{
        //    EditEvent = null;
        //    EditMultiEvents = null;

        //    if (ImageThumbBorder != null)
        //    {
        //        ImageThumbBorder.Visibility = Visibility.Collapsed;
        //    }

        //    if(ImageReplaceBtn != null)
        //    {
        //        ImageReplaceBtn.Visibility = Visibility.Collapsed;
        //    }

        //    if(ImageClipBtn!=null)
        //    {
        //        ImageClipBtn.Visibility = Visibility.Collapsed;
        //    }

        //    if (ImageThumbUI != null)
        //    {
        //        ImageThumbUI.Source = null;
        //    }

           
        //    if (editEvents != null && editEvents.Count > 0)
        //    {
        //        PDFEditEvent editEvent = editEvents[0];
        //        if (editEvent != null && editEvent.EditType == CPDFEditType.EditImage)
        //        {
        //            SetImageTransparency(editEvent.Transparency);
        //        }
        //    }

        //    EditMultiEvents = editEvents;
        //}

        private void PDFImageEditControl_Loaded(object sender, RoutedEventArgs e)
        {

        }

        private void FlipUI_FlipChanged(object sender, bool e)
        {
            GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);
            if (imageArea != null)
            {
                Rect oldRect = DataConversionForWPF.CRectConversionForRect(imageArea.GetFrame());
                bool result = false;
                if (e)
                {
                    result = imageArea.VerticalMirror();
                }
                else
                {
                    result = imageArea.HorizontalMirror();
                }
                if (result)
                {
                    PDFEditHistory editHistory = new PDFEditHistory();
                    editHistory.EditPage = editPage;
                    if (pdfPage != null)
                    {
                        editHistory.PageIndex = pdfPage.PageIndex;
                    }

                    ToolView.GetCPDFViewer()?.UndoManager.AddHistory(editHistory);
                    ToolView.UpdateRender(oldRect, imageArea);
                    editPage.EndEdit();
                }

                SetImageThumb();
            }

            //if (EditMultiEvents != null)
            //{
            //    foreach (PDFEditEvent editEvent in EditMultiEvents)
            //    {
            //        if (e)
            //        {
            //            editEvent.VerticalMirror = true;
            //        }
            //        else
            //        {
            //            editEvent.HorizontalMirror = true;
            //        }
            //    }
            //    PDFEditEvent.UpdatePDFEditList(EditMultiEvents);
            //}
        }

        private void RotateUI_RotationChanged(object sender, double e)
        {
            GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);
            if (imageArea != null)
            {
                Rect oldRect = DataConversionForWPF.CRectConversionForRect(imageArea.GetFrame());
                if (imageArea.Rotate((int)e))
                {
                    PDFEditHistory editHistory = new PDFEditHistory();
                    editHistory.EditPage = editPage;
                    if (pdfPage != null)
                    {
                        editHistory.PageIndex = pdfPage.PageIndex;
                    }

                    ToolView.GetCPDFViewer()?.UndoManager.AddHistory(editHistory);
                    SetImageThumb();
                    ToolView.UpdateRender(oldRect, imageArea);
                    editPage.EndEdit();
                    RotationTxb.Text = imageArea.GetRotation().ToString();
                }
            }

            //if (EditMultiEvents != null)
            //{
            //    foreach (PDFEditEvent editEvent in EditMultiEvents)
            //    {
            //        editEvent.Rotate = (int)e;
            //    }
            //    PDFEditEvent.UpdatePDFEditList(EditMultiEvents);
            //}
        }

        private void Slider_DragStarted(object sender, DragStartedEventArgs e)
        {
            Slider slider = sender as Slider;
            if (slider != null)
            {
                slider.Tag = "false";
            }
        }

        private void SliderOpacity_DragCompleted(object sender, DragCompletedEventArgs e)
        {
            Slider slider = sender as Slider;
            if (slider != null)
            {
                slider.Tag = "true";
            }
            GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);
            if (imageArea != null)
            {
                Rect oldRect = DataConversionForWPF.CRectConversionForRect(imageArea.GetFrame());
                if (imageArea.SetImageTransparency((byte)(ImasgeOpacitySlider.Value * 255)))
                {
                    PDFEditHistory editHistory = new PDFEditHistory();
                    editHistory.EditPage = editPage;
                    if (pdfPage != null)
                    {
                        editHistory.PageIndex = pdfPage.PageIndex;
                    }

                    ToolView.GetCPDFViewer()?.UndoManager.AddHistory(editHistory);
                    SetImageThumb();
                    ToolView.UpdateRender(oldRect, imageArea);
                    editPage.EndEdit();
                }
            }

            //if (EditMultiEvents != null)
            //{
            //    foreach (PDFEditEvent editEvent in EditMultiEvents)
            //    {
            //        editEvent.Transparency = (int)(ImasgeOpacitySlider.Value * 255);
            //    }
            //    PDFEditEvent.UpdatePDFEditList(EditMultiEvents);
            //}
        }

        private void SliderOpacity_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            Slider slider = sender as Slider;
            if (OpacityTextBox != null)
            {
                OpacityTextBox.Text = string.Format("{0}%", (int)(ImasgeOpacitySlider.Value * 100));
            }

            if (slider != null && slider.Tag != null && slider.Tag.ToString() == "false")
            {
                return;
            }
            GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);
            if (imageArea != null)
            {
                Rect oldRect = DataConversionForWPF.CRectConversionForRect(imageArea.GetFrame());
                if (imageArea.SetImageTransparency((byte)(ImasgeOpacitySlider.Value * 255)))
                {
                    PDFEditHistory editHistory = new PDFEditHistory();
                    editHistory.EditPage = editPage;
                    if (pdfPage != null)
                    {
                        editHistory.PageIndex = pdfPage.PageIndex;
                    }

                    ToolView.GetCPDFViewer()?.UndoManager.AddHistory(editHistory);
                    SetImageThumb();
                    ToolView.UpdateRender(oldRect, imageArea);
                    editPage.EndEdit();
                }
            }
        }

        private void ImageReplaceBtn_Click(object sender, RoutedEventArgs e)
        {
            //if(EditMultiEvents!=null && EditMultiEvents.Count>1)
            //{
            //    return;
            //}

            if (EditEvent != null)
            {
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Filter = "Image Files(*.jpg;*.jpeg;*.png;*.bmp)|*.jpg;*.jpeg;*.png;*.bmp;";
                if (openFileDialog.ShowDialog() == true)
                {
                    GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);
                    if (imageArea != null)
                    {
                        int imageWidth = 0;
                        int imageHeight = 0;
                        byte[] imageData = null;
                        
                        BitmapFrame frame = null;
                        BitmapDecoder decoder = BitmapDecoder.Create(new Uri(openFileDialog.FileName), BitmapCreateOptions.None, BitmapCacheOption.Default);
                        if (decoder.Frames.Count > 0)
                        {
                            frame = decoder.Frames[0];
                        }
                        if (frame != null)
                        {
                            imageData = new byte[frame.PixelWidth * frame.PixelHeight * 4];
                            if (frame.Format != PixelFormats.Bgra32)
                            {
                                FormatConvertedBitmap covert = new FormatConvertedBitmap(frame, PixelFormats.Bgra32, frame.Palette, 0);
                                covert.CopyPixels(imageData, frame.PixelWidth * 4, 0);
                            }
                            else
                            {
                                frame.CopyPixels(imageData, frame.PixelWidth * 4, 0);
                            }
                            imageWidth = frame.PixelWidth;
                            imageHeight = frame.PixelHeight;
                        }
                        Rect oldRect = DataConversionForWPF.CRectConversionForRect(imageArea.GetFrame());
                        CRect imageRect = imageArea.GetClipRect();
                        if (imageArea.ReplaceImageArea(imageRect, imageData, imageWidth, imageHeight))
                        {
                            PDFEditHistory editHistory = new PDFEditHistory();
                            editHistory.EditPage = editPage;
                            if (pdfPage != null)
                            {
                                editHistory.PageIndex = pdfPage.PageIndex;
                            }

                            ToolView.GetCPDFViewer()?.UndoManager.AddHistory(editHistory);
                            SetImageThumb();
                            ToolView.UpdateRender(oldRect, imageArea);
                            editPage.EndEdit();
                        }
                    }
                }
            }
        }

        private void ImageExportBtn_Click(object sender, RoutedEventArgs e)
        {
            if (ToolView != null)
            {
                //需要选中图片对象
                // Dictionary<int, List<Bitmap>> imageDict = PDFView.GetSelectedImages();
                Dictionary<int, List<Bitmap>> imageDict = new Dictionary<int, List<Bitmap>>();
                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)
                        {

                        }
                    }
                }
            }
        }

        private void ImageClipBtn_Click(object sender, RoutedEventArgs e)
        {
            //if(EditMultiEvents!=null && EditMultiEvents.Count>1)
            //{
            //    return;
            //}

            //if (EditEvent != null)
            //{
            //    EditEvent.ClipImage = true;
            //    EditEvent.UpdatePDFEditByEventArgs();
            //}
        }

        private void OpacityComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ComboBoxItem selectItem = OpacityComboBox.SelectedItem as ComboBoxItem;
            if (selectItem != null && selectItem.Content != null)
            {
                if (double.TryParse(selectItem.Content.ToString().TrimEnd('%'), out double newOpacity))
                {
                    OpacityTextBox.Text = selectItem.Content.ToString();
                    ImasgeOpacitySlider.Value = newOpacity / 100.0;
                }
            }
        }

        public void SetImageThumb()
        {
            if (EditEvent != null)
            {
                try
                {
                    GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);

                    string path = Path.GetTempPath();
                    string uuid = Guid.NewGuid().ToString("N");
                    string imagePath = Path.Combine(path, uuid + ".tmp");
                    imageArea.ExtractImage(imagePath);

                    Bitmap bitmapImage = new Bitmap(imagePath);
                    MemoryStream memoryStream = new MemoryStream();

                    bitmapImage.Save(memoryStream, bitmapImage.RawFormat);
                    BitmapImage imageShow = new BitmapImage();
                    imageShow.BeginInit();
                    imageShow.StreamSource = memoryStream;
                    imageShow.EndInit();
                    ImageThumbUI.Source = imageShow;
                }
                catch (Exception ex)
                {

                }
            }
        }

        public void SetImageTransparency(double transparency)
        {
            ImasgeOpacitySlider.Value = transparency / 255D;
            OpacityTextBox.Text = string.Format("{0}%", (int)(Math.Round(ImasgeOpacitySlider.Value * 100)));
        }

        private void GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage)
        {
            imageArea = null;
            editPage = null;
            pdfPage = null;
            if (ToolView == null || EditEvent == null)
            {
                return;
            }

            try
            {
                CPDFViewer pdfViewer = ToolView.GetCPDFViewer();
                CPDFDocument pdfDoc = pdfViewer.GetDocument();
                pdfPage = pdfDoc.PageAtIndex(EditEvent.PageIndex);
                editPage = pdfPage.GetEditPage();
                List<CPDFEditArea> editAreas = editPage.GetEditAreaList();
                if (editAreas != null && editAreas.Count > EditEvent.EditIndex)
                {
                    imageArea = editAreas[EditEvent.EditIndex] as CPDFEditImageArea;
                }
            }
            catch (Exception ex)
            {

            }
        }
        
        private void SetAbsRotation(double absRotation)
        {
            GetImageArea(out CPDFEditImageArea imageArea, out CPDFPage pdfPage, out CPDFEditPage editPage);
            if (imageArea != null)
            {
                int rotation = (int)absRotation - imageArea.GetRotation();
                Rect oldRect = DataConversionForWPF.CRectConversionForRect(imageArea.GetFrame());
                if (imageArea.Rotate(rotation))
                {
                    PDFEditHistory editHistory = new PDFEditHistory();
                    editHistory.EditPage = editPage;
                    if (pdfPage != null)
                    {
                        editHistory.PageIndex = pdfPage.PageIndex;
                    }

                    ToolView.GetCPDFViewer()?.UndoManager.AddHistory(editHistory);
                    SetImageThumb();
                    ToolView.UpdateRender(oldRect, imageArea);
                    editPage.EndEdit();
                }
            }
        }
        
        private void RotationTxb_LostFocus(object sender, RoutedEventArgs e)
        {
            if(!double.TryParse(RotationTxb.Text, out double rotation))
            {
                return;
            }
            SetAbsRotation(rotation);
        }

        private void RotationTxb_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                RotationTxb_LostFocus(null, null);
            }
        }

    }
}