PDFOffice_Windows_exe/PDF Office/ViewModels/Tools/AnnotToolContentViewModel.Function.cs

using ComPDFKit.PDFAnnotation;
using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using Microsoft.Win32;
using PDF_Office.CustomControl;
using PDF_Office.Helper;
using PDF_Office.Properties;
using PDFSettings;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;

namespace PDF_Office.ViewModels.Tools
{
    public sealed partial class AnnotToolContentViewModel : BindableBase, INavigationAware
    {
        #region 初始化
        private void BindingEvent()
        {
            propertyPanel.DataChanged += AnnotPropertyPanel_DataChanged;
            propertyPanel.DefaultStored += AnnotProperty_DefaultStored;
        }

        private void InitDefaultValue()
        {

            InitAnnotHighlight();
            InitAnnotUnderline();
            InitAnnotSquiggly();
            InitAnnotStrikeout();
        }

        private void InitAnnotHighlight()
        {
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotHighlight);
            if (annotProperty == null)
            {
                annotProperty = new DefaultAnnotProperty();
                annotProperty.AnnotToolType = AnnotArgsType.AnnotHighlight;
                annotProperty.BackgroundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.ForgoundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.Opacity = 0.5;
                SettingHelper.SetAnnotDefaultProperty(annotProperty);
            }
            else
            {
                HighLightColor = new SolidColorBrush(annotProperty.BackgroundColor);
                HighLightOpacity = annotProperty.Opacity;
            }
        }


        private void InitAnnotUnderline()
        {
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotUnderline);
            if (annotProperty == null)
            {
                annotProperty = new DefaultAnnotProperty();
                annotProperty.AnnotToolType = AnnotArgsType.AnnotUnderline;
                annotProperty.BackgroundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.ForgoundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.Opacity = 0.5;
                SettingHelper.SetAnnotDefaultProperty(annotProperty);
            }
            else
            {
                UnderLineColor = new SolidColorBrush(annotProperty.BackgroundColor);
                UnderLineOpacity = annotProperty.Opacity;
            }
        }

        private void InitAnnotSquiggly()
        {
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotSquiggly);
            if (annotProperty == null)
            {
                annotProperty = new DefaultAnnotProperty();
                annotProperty.AnnotToolType = AnnotArgsType.AnnotSquiggly;
                annotProperty.BackgroundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.ForgoundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.Opacity = 0.5;
                SettingHelper.SetAnnotDefaultProperty(annotProperty);
            }
            else
            {
                SquigglyColor = new SolidColorBrush(annotProperty.BackgroundColor);
                SquigglyOpacity = annotProperty.Opacity;
            }
        }

        private void InitAnnotStrikeout()
        {
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotStrikeout);
            if (annotProperty == null)
            {
                annotProperty = new DefaultAnnotProperty();
                annotProperty.AnnotToolType = AnnotArgsType.AnnotStrikeout;
                annotProperty.BackgroundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.ForgoundColor = Color.FromRgb(0xFF, 0xBB, 0x00);
                annotProperty.Opacity = 0.5;
                SettingHelper.SetAnnotDefaultProperty(annotProperty);
            }
            else
            {
                StrikeoutColor = new SolidColorBrush(annotProperty.BackgroundColor);
                StrikeoutOpacity = annotProperty.Opacity;
            }
        }

        #endregion


        #region 注释工具

        /// <summary>
        /// 高亮注释
        /// </summary>
        /// <returns></returns>
        private AnnotHandlerEventArgs GetHighLight()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            TextHighlightAnnotArgs highlightArgs = new TextHighlightAnnotArgs();
            highlightArgs.Color = Color.FromRgb(0xFF, 0xBB, 0x00);
            highlightArgs.Transparency = 0.5;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotHighlight);
            if (annotProperty != null)
            {
                highlightArgs.Color = annotProperty.ForgoundColor;
                highlightArgs.Transparency = annotProperty.Opacity;
                highlightArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = highlightArgs.Color;
            annotAttribsList[AnnotAttrib.Transparency] = highlightArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = string.Empty;

            AddToPropertyPanel(highlightArgs, "HighLight", "TextAnnotProperty");
            return highlightArgs;
        }

        private AnnotHandlerEventArgs GetUnderLine()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            TextUnderlineAnnotArgs underlineArgs = new TextUnderlineAnnotArgs();
            underlineArgs.Color = Color.FromRgb(0x12, 0xFD, 0xFF);
            underlineArgs.Transparency = 1;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotUnderline);
            if (annotProperty != null)
            {
                underlineArgs.Color = annotProperty.ForgoundColor;
                underlineArgs.Transparency = annotProperty.Opacity;
                underlineArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = underlineArgs.Color;
            annotAttribsList[AnnotAttrib.Transparency] = underlineArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = string.Empty;
          
            AddToPropertyPanel(underlineArgs, "UnderLine", "TextAnnotProperty");
            return underlineArgs;
        }

        private AnnotHandlerEventArgs GetSquiggly()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            TextSquigglyAnnotArgs squigglyArgs = new TextSquigglyAnnotArgs();
            squigglyArgs.Color = Color.FromRgb(0xFF, 0x87, 0x16);
            squigglyArgs.Transparency = 1;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotSquiggly);
            if (annotProperty != null)
            {
                squigglyArgs.Color = annotProperty.ForgoundColor;
                squigglyArgs.Transparency = annotProperty.Opacity;
                squigglyArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = squigglyArgs.Color;
            annotAttribsList[AnnotAttrib.Transparency] = squigglyArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = string.Empty;

            AddToPropertyPanel(squigglyArgs, "Squiggly", "TextAnnotProperty");
            return squigglyArgs;
        }

        private AnnotHandlerEventArgs GetStrikeout()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            TextStrikeoutAnnotArgs strikeoutArgs = new TextStrikeoutAnnotArgs();
            strikeoutArgs.Color = Color.FromRgb(0xFF, 0x3B, 0x30);
            strikeoutArgs.Transparency = 1;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotStrikeout);
            if (annotProperty != null)
            {
                strikeoutArgs.Color = annotProperty.ForgoundColor;
                strikeoutArgs.Transparency = annotProperty.Opacity;
                strikeoutArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = strikeoutArgs.Color;
            annotAttribsList[AnnotAttrib.Transparency] = strikeoutArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = string.Empty;

            AddToPropertyPanel(strikeoutArgs, "Strikeout", "TextAnnotProperty");
            return strikeoutArgs;
        }

        private AnnotHandlerEventArgs GetFreehand()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            FreehandAnnotArgs freehandArgs = new FreehandAnnotArgs();
            freehandArgs.InkColor = Color.FromRgb(0x38, 0xE0, 0x2E);
            freehandArgs.Transparency = 1;
            freehandArgs.LineWidth = 1;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotFreehand);
            if (annotProperty != null)
            {
                freehandArgs.InkColor = annotProperty.ForgoundColor;
                freehandArgs.Transparency = annotProperty.Opacity;
                freehandArgs.LineWidth = annotProperty.Thickness;
                freehandArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = freehandArgs.InkColor;
            annotAttribsList[AnnotAttrib.Transparency] = freehandArgs.Transparency;
            annotAttribsList[AnnotAttrib.Thickness] = freehandArgs.LineWidth;
            annotAttribsList[AnnotAttrib.NoteText] = freehandArgs.Content;

            AddToPropertyPanel(freehandArgs, "Freehand", "FreehandAnnotProperty");
            return freehandArgs;
        }

        private AnnotHandlerEventArgs GetFreetext()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            FreeTextAnnotArgs freetextArgs = new FreeTextAnnotArgs();
            freetextArgs.Align = TextAlignment.Left;
            freetextArgs.BgColor = Colors.Transparent;
            freetextArgs.FontFamily = new FontFamily(Settings.Default.AppProperties.Annotate.TextFontFamaily);
            freetextArgs.FontColor = Colors.Black;
            freetextArgs.FontSize = 14;
            freetextArgs.Transparency = 1;
            freetextArgs.LineColor = Colors.Black;
            freetextArgs.LineWidth = 0;
            freetextArgs.TextContent = string.Empty;

            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotFreeText);
            if (annotProperty != null)
            {
                freetextArgs.Align = annotProperty.TextAlign;
                freetextArgs.BgColor = annotProperty.BackgroundColor;
                freetextArgs.FontFamily = new FontFamily(annotProperty.FontFamily);
                freetextArgs.FontColor = annotProperty.ForgoundColor;
                freetextArgs.FontSize = annotProperty.FontSize;
                freetextArgs.Transparency = annotProperty.Opacity;
                freetextArgs.LineColor = annotProperty.BorderColor;
                freetextArgs.LineWidth = annotProperty.Thickness;
                freetextArgs.TextContent = annotProperty.NoteText;
                freetextArgs.FontWeight = annotProperty.FontWeight;
                freetextArgs.FontStyle = annotProperty.FontStyle;
            }
            int align = Settings.Default.AppProperties.Annotate.TextAlign;
            TextAlignment textAlignment;
            if (align == 0)
                textAlignment = TextAlignment.Left;
            else if (align == 1)
                textAlignment = TextAlignment.Center;
            else
                textAlignment = TextAlignment.Right;
            annotAttribsList[AnnotAttrib.Color] = freetextArgs.LineColor;
            annotAttribsList[AnnotAttrib.FillColor] = freetextArgs.BgColor;
            annotAttribsList[AnnotAttrib.Thickness] = freetextArgs.LineWidth;
            annotAttribsList[AnnotAttrib.Transparency] = freetextArgs.Transparency;
            annotAttribsList[AnnotAttrib.FontColor] = freetextArgs.FontColor;
            annotAttribsList[AnnotAttrib.FontSize] = freetextArgs.FontSize;
            annotAttribsList[AnnotAttrib.FontFamily] = freetextArgs.FontFamily;
            annotAttribsList[AnnotAttrib.FontStyle] = freetextArgs.FontStyle;
            annotAttribsList[AnnotAttrib.FontWeight] = freetextArgs.FontWeight;
            annotAttribsList[AnnotAttrib.TextAlign] = textAlignment;
            annotAttribsList[AnnotAttrib.NoteText] = freetextArgs.TextContent;

            AddToPropertyPanel(freetextArgs, "Freetext", "FreetextAnnotProperty");
            return freetextArgs;
        }

        private AnnotHandlerEventArgs GetStickyNote()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            StickyAnnotArgs stickyAnnotArgs = new StickyAnnotArgs();
            stickyAnnotArgs.Color = Color.FromRgb(0xFF, 0x81, 0x33);
            stickyAnnotArgs.StickyNote = string.Empty;
            stickyAnnotArgs.Transparency = 1;

            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotSticky);
            if (annotProperty != null)
            {
                stickyAnnotArgs.Color = annotProperty.ForgoundColor;
                stickyAnnotArgs.StickyNote = annotProperty.NoteText;
                stickyAnnotArgs.Transparency = annotProperty.Opacity;
            }

            annotAttribsList[AnnotAttrib.Color] = stickyAnnotArgs.Color;
            annotAttribsList[AnnotAttrib.Transparency] = stickyAnnotArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = stickyAnnotArgs.StickyNote;

            AddToPropertyPanel(stickyAnnotArgs, "StickyNote", "FreetextAnnotProperty");
            return stickyAnnotArgs;
        }

        private AnnotHandlerEventArgs GetRect()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            SquareAnnotArgs squareArgs = new SquareAnnotArgs();
            squareArgs.LineColor = Colors.Red;
            squareArgs.BgColor = Colors.Transparent;
            squareArgs.LineWidth = 1;
            squareArgs.Transparency = 1;
            squareArgs.LineDash = DashStyles.Solid;
            squareArgs.Content = string.Empty;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotSquare);
            if (annotProperty != null)
            {
                squareArgs.LineColor = annotProperty.BorderColor;
                squareArgs.BgColor = annotProperty.BackgroundColor;
                if (annotProperty.DashArray == null || annotProperty.DashArray.Count == 0)
                {
                    squareArgs.LineDash = DashStyles.Solid;
                }
                else
                {
                    DashStyle dash = new DashStyle();
                    foreach (var offset in annotProperty.DashArray)
                    {
                        dash.Dashes.Add(offset);
                    }
                    squareArgs.LineDash = dash;
                }
                squareArgs.LineWidth = annotProperty.Thickness;
                squareArgs.Transparency = annotProperty.Opacity;
                squareArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = squareArgs.LineColor;
            annotAttribsList[AnnotAttrib.FillColor] = squareArgs.BgColor;
            annotAttribsList[AnnotAttrib.LineStyle] = squareArgs.LineDash;
            annotAttribsList[AnnotAttrib.Thickness] = squareArgs.LineWidth;
            annotAttribsList[AnnotAttrib.Transparency] = squareArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = squareArgs.Content;

            AddToPropertyPanel(squareArgs, "Rect", "SharpsAnnotProperty");
            return squareArgs;
        }

        private AnnotHandlerEventArgs GetCircle()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            CircleAnnotArgs circleAnnotArgs = new CircleAnnotArgs();
            circleAnnotArgs.LineColor = Colors.Red;
            circleAnnotArgs.BgColor = Colors.Transparent;
            circleAnnotArgs.LineWidth = 1;
            circleAnnotArgs.Transparency = 1;
            circleAnnotArgs.LineDash = DashStyles.Solid;
            circleAnnotArgs.Content = string.Empty;
            DefaultAnnotProperty annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotCircle);
            if (annotProperty != null)
            {
                circleAnnotArgs.LineColor = annotProperty.BorderColor;
                circleAnnotArgs.BgColor = annotProperty.BackgroundColor;
                if (annotProperty.DashArray == null || annotProperty.DashArray.Count == 0)
                {
                    circleAnnotArgs.LineDash = DashStyles.Solid;
                }
                else
                {
                    DashStyle dash = new DashStyle();
                    foreach (var offset in annotProperty.DashArray)
                    {
                        dash.Dashes.Add(offset);
                    }
                    circleAnnotArgs.LineDash = dash;
                }
                circleAnnotArgs.LineWidth = annotProperty.Thickness;
                circleAnnotArgs.Transparency = annotProperty.Opacity;
                circleAnnotArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = circleAnnotArgs.LineColor;
            annotAttribsList[AnnotAttrib.FillColor] = circleAnnotArgs.BgColor;
            annotAttribsList[AnnotAttrib.LineStyle] = circleAnnotArgs.LineDash;
            annotAttribsList[AnnotAttrib.Thickness] = circleAnnotArgs.LineWidth;
            annotAttribsList[AnnotAttrib.Transparency] = circleAnnotArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = circleAnnotArgs.Content;

            AddToPropertyPanel(circleAnnotArgs, "Circle", "SharpsAnnotProperty");
            return circleAnnotArgs;
        }

        private AnnotHandlerEventArgs GetArrowLine(string TagStr)
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            LineAnnotArgs lineArgs = new LineAnnotArgs();
            lineArgs.LineColor = Colors.Red;
            lineArgs.HeadLineType = C_LINE_TYPE.LINETYPE_NONE;
            if (TagStr == "Line")
            {
                lineArgs.TailLineType = C_LINE_TYPE.LINETYPE_NONE;
            }
            else
            {
                lineArgs.TailLineType = C_LINE_TYPE.LINETYPE_ARROW;
            }
            lineArgs.LineDash = DashStyles.Solid;
            lineArgs.LineWidth = 1;
            lineArgs.Transparency = 1;
            lineArgs.Content = string.Empty;

            DefaultAnnotProperty annotProperty = null;
            if (TagStr == "Line")
            {
                annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotLine, "Line");
                if (annotProperty != null)
                {
                    annotProperty.HeadLineType = C_LINE_TYPE.LINETYPE_NONE;
                    annotProperty.TailLineType = C_LINE_TYPE.LINETYPE_NONE;
                }
            }
            else
            {
                annotProperty = SettingHelper.GetAnnotDefaultProperty(AnnotArgsType.AnnotLine, "Arrow");
            }

            if (annotProperty != null)
            {
                lineArgs.LineColor = annotProperty.BorderColor;
                lineArgs.HeadLineType = annotProperty.HeadLineType;
                lineArgs.TailLineType = annotProperty.TailLineType;

                DashStyle dash = new DashStyle();
                foreach (var offset in annotProperty.DashArray)
                {
                    dash.Dashes.Add(offset);
                }
                lineArgs.LineDash = dash;
                lineArgs.LineWidth = annotProperty.Thickness;
                lineArgs.Transparency = annotProperty.Opacity;
                lineArgs.Content = annotProperty.NoteText;
            }
            annotAttribsList[AnnotAttrib.Color] = lineArgs.LineColor;
            annotAttribsList[AnnotAttrib.LineStart] = lineArgs.HeadLineType;
            annotAttribsList[AnnotAttrib.LineEnd] = lineArgs.TailLineType;
            annotAttribsList[AnnotAttrib.LineStyle] = lineArgs.LineDash;
            annotAttribsList[AnnotAttrib.Thickness] = lineArgs.LineWidth;
            annotAttribsList[AnnotAttrib.Transparency] = lineArgs.Transparency;
            annotAttribsList[AnnotAttrib.NoteText] = lineArgs.Content;

            AddToPropertyPanel(lineArgs, TagStr, "SharpsAnnotProperty");
            return lineArgs;
        }

        private AnnotHandlerEventArgs GetStamp()
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            StampAnnotArgs stampAnnotArgs = new StampAnnotArgs();
            stampAnnotArgs.Opacity = 1;
            stampAnnotArgs.StampText = "APPROVED";
            stampAnnotArgs.Type = StampType.STANDARD_STAMP;

            annotAttribsList[AnnotAttrib.Transparency] = stampAnnotArgs.Opacity;

            AddToPropertyPanel(stampAnnotArgs, null, "StampAnnotProperty");
            return stampAnnotArgs;
        }

        private AnnotHandlerEventArgs GetImage(CustomIconToggleBtn annotBtn)
        {
            Dictionary<AnnotAttrib, object> annotAttribsList = new Dictionary<AnnotAttrib, object>();
            annotBtn.IsChecked = false;
            StampAnnotArgs stampArgs = new StampAnnotArgs();
            stampArgs.Opacity = 1;
            stampArgs.Type = StampType.IMAGE_STAMP;
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Image Files(*.jpg;*.jpeg;*.png;*.bmp)|*.jpg;*.jpeg;*.png;*.bmp;";
            if (openFileDialog.ShowDialog() == true)
            {
                stampArgs.ImagePath = openFileDialog.FileName;

              
            }

            AddToPropertyPanel(stampArgs, null, "ImageAnnotProperty");
            return stampArgs;
        }


        private void AddToPropertyPanel(AnnotHandlerEventArgs annot, string toolTag, string viewContent)
        {
            if (string.IsNullOrEmpty(toolTag) == false)
            {
                if (!ToolExpandDict.ContainsKey(toolTag))
                {
                    ToolExpandDict[toolTag] = true;
                }
            }

            if (annot != null)
                propertyPanel.annot = annot;

            if (string.IsNullOrEmpty(viewContent) == false)
            {
                viewContentViewModel.SelectedPrpoertyPanel(viewContent, propertyPanel);
            }

        }


        #endregion
    }
}