PDFOffice_Windows_exe/PDF Office/ViewModels/PropertyPanel/AnnotPanel/LinkAnnotPropertyViewModel.cs

using ComPDFKit.PDFDocument;
using ComPDFKit.PDFPage;
using ComPDFKitViewer.AnnotEvent;
using ComPDFKitViewer.PdfViewer;
using PDF_Office.Model;
using PDF_Office.ViewModels.Tools;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using System.Windows;
using System.Windows.Media.Imaging;
using Prism.Commands;
using PDF_Office.Helper;
using Microsoft.Office.Interop.Word;
using static Dropbox.Api.Files.FileCategory;
using PDF_Office.Views.PropertyPanel.AnnotPanel;
using System.Windows.Controls;
using PDF_Office.CustomControl;

namespace PDF_Office.ViewModels.PropertyPanel.AnnotPanel
{
    internal class LinkAnnotPropertyViewModel : BindableBase, INavigationAware
    {
        public AnnotAttribEvent AnnotAttribEvent { get; set; }
        private int totalPage = 0;
        private AnnotPropertyPanel PropertyPanel;
        private AnnotArgsType annotType;

        private LinkAnnotArgs _annotArgs;

        public LinkAnnotArgs AnnotArgs
        {
            get
            {
                return _annotArgs;
            }
            set
            {
                if (_annotArgs != null)
                {
                    _annotArgs.LinkDrawFinished -= _annotArgs_LinkDrawFinished;
                }
                _annotArgs = value;

                if (_annotArgs != null)
                {
                    _annotArgs.LinkDrawFinished += _annotArgs_LinkDrawFinished;
                }
            }
        }

        public AnnotArgsType AnnotType
        {
            get { return annotType; }
            set
            {
                SetProperty(ref annotType, value);
            }
        }

        private string pageNumTextContent = "Enter target page";

        public string PageNumTextContent
        {
            get
            {
                return pageNumTextContent;
            }
            set
            {
                SetProperty(ref pageNumTextContent, value);
            }
        }

        private WriteableBitmap previewImage;

        public WriteableBitmap PreviewImage
        {
            get { return previewImage; }
            set
            {
                SetProperty(ref previewImage, value);
            }
        }

        private Visibility imagePreviewVisibility = Visibility.Collapsed;

        public Visibility ImagePreviewVisibility
        {
            get { return imagePreviewVisibility; }
            set
            {
                SetProperty(ref imagePreviewVisibility, value);
            }
        }

        private Visibility btnGOorBackVisibility = Visibility.Collapsed;

        public Visibility BtnGOorBackVisibility
        {
            get { return btnGOorBackVisibility; }
            set
            {
                SetProperty(ref btnGOorBackVisibility, value);
            }
        }

        private Visibility errorNumTipsVisibility = Visibility.Collapsed;

        public Visibility ErrorNumTipsVisibility
        {
            get { return errorNumTipsVisibility; }
            set
            {
                SetProperty(ref errorNumTipsVisibility, value);
            }
        }

        private Visibility errorRangeTipsVisibility = Visibility.Collapsed;

        public Visibility ErrorRangeTipsVisibility
        {
            get { return errorRangeTipsVisibility; }
            set
            {
                SetProperty(ref errorRangeTipsVisibility, value);
            }
        }

        private CPDFViewer pdfViewer;
        private CPDFDocument document;
        private LinkAnnotProperty linkAnnot;
        public DelegateCommand<object> LoadedCommand { get; set; }
        public DelegateCommand<object> PageNumTextChangedCommand { get; set; }
        public DelegateCommand<object> ToggleButtonTabCommand { get; set; }

        public LinkAnnotPropertyViewModel()
        {
            LoadedCommand = new DelegateCommand<object>(Loaded);
            PageNumTextChangedCommand = new DelegateCommand<object>(PageNumTextChanged);
            ToggleButtonTabCommand = new DelegateCommand<object>(ToggleButtonTabSelected);
        }

        private void ToggleButtonTabSelected(object obj)
        {
            if (obj is object[] array)
            {
            }
        }

        private void PageNumTextChanged(object obj)
        {
            if (obj is TextChangedEventArgs textChangedEventArgs)
            {
                if (textChangedEventArgs.Source is TextBoxWithTip textBox)
                {
                    int pageNum = -1;
                    if (CheckPageNumVaild(out pageNum, textBox))
                    {
                        if (AnnotArgs != null)
                        {
                            AnnotArgs.DestIndex = pageNum - 1;
                            SetImagePreview();
                        }
                    }
                }
            }
        }

        private bool CheckPageNumVaild(out int pageNum, TextBoxWithTip textBox)
        {
            pageNum = -1;
            ErrorNumTipsVisibility = Visibility.Collapsed;
            ErrorRangeTipsVisibility = Visibility.Collapsed;
            BtnGOorBackVisibility = Visibility.Collapsed;
            if (string.IsNullOrEmpty(textBox.Text))
            {
                return false;
            }
            if (textBox.Text.Trim() != string.Empty)
            {
                if (!int.TryParse(textBox.Text.Trim(), out pageNum))
                {
                    //ErrorNumTipsVisibility = Visibility.Visible;
                    //ErrorRangeTipsVisibility = Visibility.Collapsed;
                    textBox.IsError = true;
                    textBox.ShowTip = Visibility.Visible;
                    textBox.TipText = " Page number error.";
                    return false;
                }
            }
            if (pageNum < 1 || pageNum > totalPage)
            {
                //ErrorNumTipsVisibility = Visibility.Collapsed;
                //ErrorRangeTipsVisibility = Visibility.Visible;
                textBox.IsError = true;
                textBox.ShowTip = Visibility.Visible;
                textBox.TipText = "  Page number out of range.";
                return false;
            }
            else
            {
                textBox.IsError = false;
                textBox.ShowTip = Visibility.Collapsed;
            }
            BtnGOorBackVisibility = Visibility.Visible;
            return true;
        }

        private void SetImagePreview()
        {
            ImagePreviewVisibility = Visibility.Visible;
            BtnGOorBackVisibility = Visibility.Visible;

            int dpiHeight = (int)linkAnnot.ImagePreview.Height;
            int dpiWidth = (int)linkAnnot.ImagePreview.Width;
            if (dpiHeight <= 0 || dpiWidth <= 0)
            {
                return;
            }

            int pageIndex = AnnotArgs.DestIndex;
            Rect MediaRect = GetPageRect(document, pageIndex, CPDFDisplayBox.MediaBox);

            System.Windows.Size pageSize = GetPageSize(document, pageIndex);
            double scale = Math.Min(dpiWidth / MediaRect.Width, dpiHeight / MediaRect.Height);
            scale = Math.Min(scale, 1);

            int cropWidth = (int)(scale * pageSize.Width);
            int cropHeight = (int)(scale * pageSize.Height);

            byte[] imageDatas = RenderPDFPageToArray(document, pageIndex, new Rect(0, 0, cropWidth, cropHeight), scale, true, true);

            WriteableBitmap WirteBitmap = new WriteableBitmap(cropWidth, cropHeight, 96, 96, PixelFormats.Bgra32, null);
            WirteBitmap.WritePixels(new Int32Rect(0, 0, cropWidth, cropHeight), imageDatas, WirteBitmap.BackBufferStride, 0);

            PreviewImage = WirteBitmap;
        }

        private void _annotArgs_LinkDrawFinished(object sender, bool e)
        {
            linkAnnot.SetTextBoxEnableOrNot(e, totalPage);
            //AnnotArgs = (LinkAnnotArgs)PropertyPanel.annot;
        }

        private void Loaded(object obj)
        {
            if (obj is CompositeCommandParameter composite)
            {
                if (composite.Parameter is LinkAnnotProperty linkAnnotProperty)
                {
                    linkAnnot = linkAnnotProperty;
                }
            }
        }

        public bool IsNavigationTarget(NavigationContext navigationContext)

        {
            return true;
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            navigationContext.Parameters.TryGetValue<AnnotPropertyPanel>(ParameterNames.PropertyPanelContentViewModel, out PropertyPanel);
            navigationContext.Parameters.TryGetValue<CPDFViewer>(ParameterNames.PDFViewer, out pdfViewer);

            if (PropertyPanel != null && pdfViewer != null)
            {
                AnnotAttribEvent = PropertyPanel.AnnotEvent;
                AnnotType = PropertyPanel.annot.EventType;

                document = pdfViewer.Document;
                totalPage = pdfViewer.Document.PageCount;
                if (linkAnnot != null)
                {
                    if (pdfViewer != null && pdfViewer.ToolManager != null && pdfViewer.ToolManager.CurrentAnnotArgs?.EventType == AnnotArgsType.AnnotLink)
                    {
                        if (AnnotAttribEvent.IsAnnotCreateReset)
                        {
                            AnnotArgs = pdfViewer.ToolManager.CurrentAnnotArgs as LinkAnnotArgs;
                        }
                    }
                    linkAnnot.SetTextBoxEnableOrNot(!AnnotAttribEvent.IsAnnotCreateReset, totalPage);
                }
                else
                {
                    AnnotArgs = (LinkAnnotArgs)PropertyPanel.annot;
                }
            }
        }

        public byte[] RenderPDFPageToArray(CPDFDocument document, int pageIndex, Rect renderRect, double currentZoom, bool renderAnnot = false, bool renderForm = false)
        {
            if (renderRect.Width <= 0 || renderRect.Height <= 0 || document == null)
            {
                return null;
            }
            try
            {
                byte[] bmpData = new byte[(int)renderRect.Width * (int)renderRect.Height * 4];
                currentZoom = currentZoom * 96 / 72;
                int flag = 0;
                if (renderAnnot)
                {
                    flag = 1;
                }
                uint bgColor = 0xFFFFFFFF;
                CPDFPage page = document.PageAtIndex(pageIndex);
                if (page.IsValid())
                {
                    page.RenderPageBitmapWithMatrix((float)currentZoom, renderRect, bgColor, bmpData, flag, renderForm);
                }
                return bmpData;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        private Rect GetPageRect(CPDFDocument document, int pageIndex, CPDFDisplayBox displayBox)
        {
            CPDFPage currentPage = document.PageAtIndex(pageIndex);
            Rect boundBox = currentPage.GetBoundsForBox(displayBox);

            Rect boundRect = new Rect((int)(boundBox.Left / 72.0 * 96.0), (int)(boundBox.Top / 72.0 * 96.0),
            (int)(boundBox.Width / 72.0 * 96.0), (int)(boundBox.Height / 72.0 * 96.0));

            return boundRect;
        }

        private System.Windows.Size GetPageSize(CPDFDocument document, int pageIndex)
        {
            System.Windows.Size pageSize = document.GetPageSize(pageIndex);
            pageSize.Width = pageSize.Width / 72.0 * 96;
            pageSize.Height = pageSize.Height / 72.0 * 96;

            return pageSize;
        }
    }
}