kmpdfkit_demo/Demo/Examples/Compdfkit_Tools/Security/Watermark/AddWatermark/WatermarkDialog.xaml.cs

using ComPDFKit.PDFWatermark;
using Compdfkit_Tools.Common;
using Compdfkit_Tools.Helper;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using static Compdfkit_Tools.PDFControl.PageRangeDialog;

namespace Compdfkit_Tools.PDFControl
{
    /// <summary>
    /// Interaction logic for WatermarkDialog.xaml
    /// </summary>
    public partial class WatermarkDialog : Window, INotifyPropertyChanged
    {
        private bool _canChangeRange = false;
        public bool CanChangeRange
        {
            get => _canChangeRange;
            set => UpdateProper(ref _canChangeRange, value);
        }

        private C_Watermark_Type _watermarkType = C_Watermark_Type.WATERMARK_TYPE_TEXT;
        public C_Watermark_Type WatermarkType
        {
            get => _watermarkType;
            set
            {
                if (UpdateProper(ref _watermarkType, value))
                {
                    watermarkData.Type = _watermarkType;
                }
            }
        }

        private string _watermarkText = "Watermark";
        public string WatermarkText
        {
            get => _watermarkText;
            set
            {
                if (UpdateProper(ref _watermarkText, value))
                {
                    watermarkData.Text = _watermarkText;
                }
            }
        }

        private byte[] _brush = new byte[] { 255, 0, 0 };
        public byte[] Brush
        {
            get => _brush;
            set
            {
                if (UpdateProper(ref _brush, value))
                {
                    watermarkData.Color = _brush;
                }
            }
        }
        private int _selectedTag = 4;
        public int SelectedTag
        {
            get => _selectedTag;
            set
            {
                if (UpdateProper(ref _selectedTag, value))
                {
                    Vertalign = (C_Watermark_Vertalign)(SelectedTag / 3);
                    Horizalign = (C_Watermark_Horizalign)(SelectedTag % 3);
                }
            }
        }

        private C_Watermark_Horizalign _horizalign = C_Watermark_Horizalign.WATERMARK_HORIZALIGN_CENTER;
        public C_Watermark_Horizalign Horizalign
        {
            get => _horizalign;
            set
            {
                if (UpdateProper(ref _horizalign, value))
                {
                    watermarkData.Horizalign = _horizalign;
                }
            }
        }

        private C_Watermark_Vertalign _vertalign = C_Watermark_Vertalign.WATERMARK_VERTALIGN_CENTER;
        public C_Watermark_Vertalign Vertalign
        {
            get => _vertalign;
            set
            {
                if (UpdateProper(ref _vertalign, value))
                {
                    watermarkData.Vertalign = _vertalign;
                }
            }
        }

        private string _imagePath = "";
        public string ImagePath
        {
            get => _imagePath;
            set
            {
                if (UpdateProper(ref _imagePath, value))
                {
                    watermarkData.ImagePath = _imagePath;
                }
            }
        }

        private string _imageScale = "100";
        public string ImageScale
        {
            get => _imageScale;
            set
            {
                if (string.IsNullOrEmpty(value))
                {
                    return;
                }
                if (int.Parse(value) > ScaleNumericControl.Maxium)
                {
                    value = ScaleNumericControl.Maxium.ToString();
                }
                if (int.Parse(value) < ScaleNumericControl.Minimum)
                {
                    value = ScaleNumericControl.Minimum.ToString();
                }
                if (UpdateProper(ref _imageScale, value))
                {
                    watermarkData.ImageScale = int.Parse(_imageScale);
                }
            }
        }

        private WatermarkData watermarkData = new();

        private string _fontName = "Helvetica";
        public string FontName
        {
            get => _fontName;
            set
            {
                if (UpdateProper(ref _fontName, value))
                {
                    watermarkData.FontName = _fontName;
                }
            }
        }

        private string _textSize = "48";
        public string TextSize
        {
            get => _textSize;
            set
            {
                if (UpdateProper(ref _textSize, value))
                {
                    watermarkData.FontSize = float.Parse(_textSize);
                }
            }
        }

        private bool _isFront = true;
        public bool IsFront
        {
            get => _isFront;
            set
            {
                if (UpdateProper(ref _isFront, value))
                {
                    watermarkData.IsFront = _isFront;
                }
            }
        }

        private bool _isFullScreen;
        public bool IsFullScreen
        {
            get => _isFullScreen;
            set
            {
                if (UpdateProper(ref _isFullScreen, value))
                {
                    watermarkData.IsFullScreen = _isFullScreen;
                }
            }
        }

        private int _rotation;
        public int Rotation
        {
            get => _rotation;
            set
            {
                if (UpdateProper(ref _rotation, value))
                {
                    watermarkData.Rotation = _rotation;
                }
            }
        }

        private byte _opacityValue = 255;
        public byte OpacityValue
        {
            get => _opacityValue;
            set
            {
                if (UpdateProper(ref _opacityValue, value))
                {
                    watermarkData.Opacity = _opacityValue;
                }
            }
        }

        private float _verticalSpacing;
        public float VerticalSpacing
        {
            get => _verticalSpacing;
            set
            {
                if (UpdateProper(ref _verticalSpacing, value))
                {
                    watermarkData.VerticalSpacing = _verticalSpacing;
                }
            }
        }

        private float _horizontalSpacing;
        public float HorizontalSpacing
        {
            get => _horizontalSpacing;
            set
            {
                if (UpdateProper(ref _horizontalSpacing, value))
                {
                    watermarkData.HorizontalSpacing = _horizontalSpacing;
                }
            }
        }

        private float _vertOffset;
        public float VertOffset
        {
            get => _vertOffset;
            set
            {
                if (UpdateProper(ref _vertOffset, value))
                {
                    watermarkData.VertOffset = _vertOffset;
                }
            }
        }

        private float _horizOffset;
        public float HorizOffset
        {
            get => _horizOffset;
            set
            {
                if (UpdateProper<float>(ref _horizOffset, value))
                {
                    watermarkData.HorizOffset = _horizOffset;
                }
            }
        }
        public delegate void WindowClosedEventHandler(object sender, WatermarkData watermarkData); 
        public event WindowClosedEventHandler WindowClosed;
        private WeakReference weakReference;

        public WatermarkDialog()
        {
            DataContext = this;
            InitializeComponent();
        }

        public bool InitWithFileInfo(FileInfoWithRange fileInfo)
        {
            if (fileInfo == null)
            {
                return false;
            }
            InitPreviewControl(fileInfo);
            return true;
        }

        private void InitPreviewControl(FileInfoWithRange fileInfo)
        {
            PreviewControl.Document = fileInfo.Document;
            PreviewControl.MarkedPageList = fileInfo.PageRangeList;
            PreviewControl.PageRangeList = CommonHelper.GetDefaultPageList(PreviewControl.Document);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        protected bool UpdateProper<T>(ref T properValue,
            T newValue,
            [CallerMemberName] string properName = "")
        {
            if (object.Equals(properValue, newValue))
                return false;

            properValue = newValue;
            OnPropertyChanged(properName);
            return true;
        }

        private void FontFamilyCbx_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var item = sender as ComboBox;
            if (item != null)
            {
                FontName = (item.SelectedItem as ComboBoxItem).Tag.ToString();
            }
        }

        private void FontSizeCbx_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var item = sender as ComboBox;
            if (item != null)
            {
                TextSize = (item.SelectedItem as ComboBoxItem).Tag.ToString();
            }
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            ColorPickerControl.SetIsChecked(1);
            InitWatermarkData(in watermarkData);
            PreviewControl.WatermarkData = watermarkData;
            watermarkData.ValueChanged += 
                (sender, e) => PreviewControl.WatermarkData = watermarkData;
            weakReference = new WeakReference(this);
        }

        private void InitWatermarkData(in WatermarkData watermarkData)
        {
            watermarkData.Type = WatermarkType;
            watermarkData.Text = WatermarkText;
            watermarkData.FontName = FontName;
            watermarkData.FontSize = float.Parse(TextSize);
            watermarkData.Color = Brush;
            watermarkData.ImagePath = ImagePath;
            watermarkData.ImageScale = int.Parse(ImageScale);
            watermarkData.Rotation = Rotation;
            watermarkData.Opacity = OpacityValue;
            watermarkData.Vertalign = Vertalign;
            watermarkData.Horizalign = Horizalign;
            watermarkData.VertOffset = VertOffset;
            watermarkData.Horizalign = Horizalign;
            watermarkData.IsFront = IsFront;
            watermarkData.IsFullScreen = IsFullScreen;
            watermarkData.VerticalSpacing = VerticalSpacing;
            watermarkData.HorizontalSpacing = HorizontalSpacing;

        }


        private void ImagePathBtn_Click(object sender, RoutedEventArgs e)
        {
            string filePath = CommonHelper.GetExistedPathOrEmpty("image (*.jpg;*.jpeg;*.png;)|*.jpg;*.jpeg;*.png;");
            if (!string.IsNullOrEmpty(filePath))
            {
                ImagePath = filePath;
            }
        }

        private void CPDFOpacityControl_OpacityChanged(object sender, EventArgs e)
        {
            var opacityControl = sender as CPDFOpacityControl;
            if (opacityControl != null)
            {
                OpacityValue = (byte)(opacityControl.OpacityValue / 100.0 * 255.0);
            }
        }

        private void LocationChk_Checked(object sender, RoutedEventArgs e)
        {
            var locationChk = sender as CheckBox;
            if (locationChk != null)
            {
                if (locationChk.Name == "LocationChk")
                {
                    IsFront = true;
                }
                else
                {
                    IsFront = false;
                }
            }
        }

        private void ColorPickerControl_ColorChanged(object sender, EventArgs e)
        {
            var colorPicker = sender as ColorPickerControl;
            if (colorPicker != null)
            {
                Brush = CommonHelper.ConvertBrushToByteArray(colorPicker.Brush);
            }
        }

        private void TypeRdo_Checked(object sender, RoutedEventArgs e)
        {
            var rdo = sender as RadioButton;
            if (rdo != null)
            {
                if (rdo.Name == "TextRdo")
                {
                    WatermarkType = C_Watermark_Type.WATERMARK_TYPE_TEXT;
                }
                else if (rdo.Name == "ImageRdo")
                {
                    WatermarkType = C_Watermark_Type.WATERMARK_TYPE_IMG;
                }
                else
                {
                    watermarkData.Type = C_Watermark_Type.WATERMARK_TYPE_UNKNOWN;
                }
            }
        }

        private void CPDFRotationControl_RotationChanged(object sender, EventArgs e)
        {
            var rotationControl = sender as CPDFRotationControl;
            if (rotationControl != null)
            {
                Rotation = int.Parse(rotationControl.RotationText);
            }
        }

        private void CPDFTileControl_HorizontalSpacingChanged(object sender, EventArgs e)
        {
            var tileControl = sender as CPDFTileControl;
            if (tileControl != null)
            {
                HorizontalSpacing = float.Parse(tileControl.HorizontalSpacingValue);
            }
        }

        private void CPDFTileControl_VerticalSpacingChanged(object sender, EventArgs e)
        {
            var tileControl = sender as CPDFTileControl;
            if (tileControl != null)
            {
                VerticalSpacing = float.Parse(tileControl.VerticalSpacingValue);
            }
        }

        private void CPDFTileControl_FullScreenChanged(object sender, EventArgs e)
        {
            var tileControl = sender as CPDFTileControl;
            if (tileControl != null)
            {
                IsFullScreen = tileControl.IsFullScreen;
            }
        }

        private void CPDFLocationControl_HorizOffsetChanged(object sender, EventArgs e)
        {
            var locationControl = sender as CPDFLocationControl;
            if (locationControl != null)
            {
                HorizOffset = float.Parse(locationControl.HorizOffsetValue);
            }
        }

        private void CPDFLocationControl_VertOffsetChanged(object sender, EventArgs e)
        {
            var locationControl = sender as CPDFLocationControl;
            if (locationControl != null)
            {
                VertOffset = float.Parse(locationControl.VertOffsetValue);
            }
        }

        private void ConfirmBtn_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
            WindowClosed?.Invoke(weakReference.Target,  watermarkData);
        }

        private void CancelBtn_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
            WindowClosed?.Invoke(weakReference.Target, null);
        }

        protected override void OnClosed(EventArgs e)
        {
            PreviewControl.DeleteDisplayWatermark();
            base.OnClosed(e);
        }
    }
}