PDFOffice_Windows_exe/PDF Office/Model/AnnotPanel/FontBoard.cs

using ComPDFKit.PDFAnnotation;
using ComPDFKitViewer.AnnotEvent;
using PDF_Master.CustomControl.CompositeControl;
using PDF_Master.Model.PropertyPanel.AnnotPanel;
using PDFSettings;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;

namespace PDF_Master.Model.AnnotPanel
{
    //属性触发事件的标识
    public enum FontSetModeType
    {
        PresetFontStyes,
        FontFamilys,
        FontSizes,
        FontWeight_Style,
        FontColor,
        TextAlignment
    }

    /// <summary>
    ///  编辑-文本 设置字体大小、字体内容排版、字体颜色、字体样式、字重
    /// </summary>
    public class FontBoard : BindableBase
    {
        #region 变量

        protected event EventHandler<FontSetModeType> ChangedValue;

        protected bool IsCanSave = false;

        private List<ComboDataItem> _fontFamilyItems;

        public List<ComboDataItem> FontFamilyItems
        {
            get { return _fontFamilyItems; }
            set
            {
                SetProperty(ref _fontFamilyItems, value);
            }
        }

        public List<ComboDataItem> FontStyleItems { get; protected set; }
        public List<ComboDataItem> FontSizeItems { get; protected set; }
        public List<ComboDataItem> PresetFontItems { get; protected set; }

        public List<PresetFontItem> PresetFontList = new List<PresetFontItem>();

        #endregion 变量

        #region 初始化下拉框或列表默认的数据

        protected void InitBaseVariable()
        {
            InitBase_PresetFontStyles();
            InitBase_FontFamilys();
            InitBase_FontStyles();
            InitBase_FontSize();
        }

        //预设字体大小
        private void InitBase_FontSize()
        {
            FontSizeItems = TextFont.GetFontSize();
        }

        //预设字体样式
        private void InitBase_PresetFontStyles()
        {
            PresetFontItems = new List<ComboDataItem>();
            PresetFontList = TextFont.GetCachePresetEditFontList();

            foreach (var item in PresetFontList)
            {
                ComboDataItem itemData = new ComboDataItem(item.mTag, item.mTagContent);
                PresetFontItems.Add(itemData);
            }
        }

        //字体
        public void InitBase_FontFamilys()
        {
            FontFamilyItems = TextFont.GetFamilyEdit();
        }

        //字重
        private void InitBase_FontStyles()
        {
            FontStyleItems = TextFont.GetFontStyle();
        }

        #endregion 初始化下拉框或列表默认的数据

        #region 属性

        //文字内容对齐
        private string _strtextAlign;

        public string StrTextAlign
        {
            get { return _strtextAlign; }
            set { SetProperty(ref _strtextAlign, value); }
        }

        /// <summary>
        /// 预设样式
        /// </summary>

        private int presetFontSelectedIndex;

        public int PresetFontSelectedIndex
        {
            get { return presetFontSelectedIndex; }
            set
            {
                SetProperty(ref presetFontSelectedIndex, value);
            }
        }

        private ComboDataItem _currentPresetFont = new ComboDataItem("Custom", "Custom");

        public ComboDataItem CurrentPresetFont
        {
            get { return _currentPresetFont; }
            set
            {
                bool isChange = IsEqualStrComboData(_currentPresetFont, value);
                SetProperty(ref _currentPresetFont, value);
                if (isChange)
                {
                    ChangedValue?.Invoke(_currentPresetFont.ValueStr, FontSetModeType.PresetFontStyes);
                }
                SetProperty(ref _currentPresetFont, value);
                switch (value.ValueStr.ToString())
                {
                    case "Custom":
                        PresetFontSelectedIndex = 0;
                        break;

                    case "H1":
                        PresetFontSelectedIndex = 1;
                        break;

                    case "H2":
                        PresetFontSelectedIndex = 2;
                        break;

                    case "H3":
                        PresetFontSelectedIndex = 3;
                        break;

                    case "B1":
                        PresetFontSelectedIndex = 4;
                        break;

                    case "B2":
                        PresetFontSelectedIndex = 5;
                        break;

                    case "B3":
                        PresetFontSelectedIndex = 6;
                        break;

                    default:
                        PresetFontSelectedIndex = 0;
                        break;
                }
            }
        }

        #region 字体样式

        //下拉框列表
        private ComboDataItem _currentFontFamily = new ComboDataItem("Arial", "Arial");

        public ComboDataItem CurrentFontFamily
        {
            get { return _currentFontFamily; }
            set
            {
                bool isChange = IsEqualStrComboData(_currentFontFamily, value);
                SetProperty(ref _currentFontFamily, value);
                if (isChange)
                {
                    string str = _currentFontFamily.Content;
                    if (_currentFontFamily.Content == "Times New Roman")
                    {
                        str = "Times-Roman";
                    }
                    ChangedValue?.Invoke(str, FontSetModeType.FontFamilys);
                }
                SetProperty(ref _currentFontFamily, value);
                if (value.Content != null)
                {
                    int index = FontFamilyItems.FindIndex(item => item.Content == value.Content);
                    FontFamilySelectedIndex = index;
                    Trace.WriteLine(index);
                }
                else
                {
                    FontFamilySelectedIndex = 0;
                }
            }
        }

        private int fontFamilySelectedIndex = -1;

        public int FontFamilySelectedIndex
        {
            get { return fontFamilySelectedIndex; }
            set
            {
                SetProperty(ref fontFamilySelectedIndex, value);
            }
        }

        #endregion 字体样式

        #region 字体大小

        private int fontSizeSelectedIndex;

        public int FontSizeSelectedIndex
        {
            get { return fontSizeSelectedIndex; }
            set
            {
                SetProperty(ref fontSizeSelectedIndex, value);
            }
        }

        //下拉框列表：字体大小
        private ComboDataItem _currentFontSize = new ComboDataItem(6);

        public ComboDataItem CurrentFontSize
        {
            get { return _currentFontSize; }
            set
            {
                bool isChange = IsEqualComboData(_currentFontSize, value);
                SetProperty(ref _currentFontSize, value);
                if (isChange && value.Value > 0)
                {
                    ChangedValue?.Invoke(_currentFontSize.Value, FontSetModeType.FontSizes);
                }
                SetProperty(ref _currentFontSize, value);
                switch (value.Value)
                {
                    case 8:
                        FontSizeSelectedIndex = 0;
                        break;

                    case 9:
                        FontSizeSelectedIndex = 1;
                        break;

                    case 10:
                        FontSizeSelectedIndex = 2;
                        break;

                    case 11:
                        FontSizeSelectedIndex = 3;
                        break;

                    case 12:
                        FontSizeSelectedIndex = 4;
                        break;

                    case 14:
                        FontSizeSelectedIndex = 5;
                        break;

                    case 16:
                        FontSizeSelectedIndex = 6;
                        break;

                    case 18:
                        FontSizeSelectedIndex = 7;
                        break;

                    case 20:
                        FontSizeSelectedIndex = 8;
                        break;

                    case 22:
                        FontSizeSelectedIndex = 9;
                        break;

                    case 24:
                        FontSizeSelectedIndex = 10;
                        break;

                    case 26:
                        FontSizeSelectedIndex = 11;
                        break;

                    case 28:
                        FontSizeSelectedIndex = 12;
                        break;

                    case 36:
                        FontSizeSelectedIndex = 13;
                        break;

                    case 48:
                        FontSizeSelectedIndex = 14;
                        break;

                    case 72:
                        FontSizeSelectedIndex = 15;
                        break;

                    default:
                        //FontSizeSelectedIndex = 0;
                        //FontSizeSelectedIndex = -1;
                        break;
                }
            }
        }

        #endregion 字体大小

        //FontStyle & FontWeight

        private FontStyle _fontStyle;

        public FontStyle FontStyleItem
        {
            get { return _fontStyle; }
            set { SetProperty(ref _fontStyle, value); }
        }

        private FontWeight _fontWeight;

        public FontWeight FontWeightItem
        {
            get { return _fontWeight; }
            set { SetProperty(ref _fontWeight, value); }
        }

        private int fontStyleSelectedIndex = 0;

        public int FontStyleSelectedIndex
        {
            get { return fontStyleSelectedIndex; }
            set
            {
                SetProperty(ref fontStyleSelectedIndex, value);
            }
        }

        private ComboDataItem _currrentFontWeightStyle = new ComboDataItem("Regular", "Regular");

        public ComboDataItem CurrrentFontWeightStyle
        {
            get { return _currrentFontWeightStyle; }

            set
            {
                bool isChange = IsEqualStrComboData(_currrentFontWeightStyle, value);
                SetProperty(ref _currrentFontWeightStyle, value);
                if (isChange)
                {
                    ChangedValue?.Invoke(_currrentFontWeightStyle, FontSetModeType.FontWeight_Style);
                }
                SetProperty(ref _currrentFontWeightStyle, value);
                switch (value.Content.ToString())
                {
                    case "Regular":
                        FontStyleSelectedIndex = 0;
                        break;

                    case "Bold":
                        FontStyleSelectedIndex = 1;
                        break;

                    case "Italic":
                        FontStyleSelectedIndex = 2;
                        break;

                    case "Bold Italic":
                        FontStyleSelectedIndex = 3;
                        break;
                }
            }
        }

        protected void UpdateFontWeight_Style()
        {
            switch (CurrrentFontWeightStyle.ValueStr)
            {
                case "Regular":
                    FontStyleItem = FontStyles.Normal;
                    FontWeightItem = FontWeights.Normal;
                    break;

                case "Bold":
                    FontStyleItem = FontStyles.Normal;
                    FontWeightItem = FontWeights.Bold;
                    break;

                case "Italic":
                    FontStyleItem = FontStyles.Italic;
                    FontWeightItem = FontWeights.Normal;
                    break;

                case "Bold Italic":
                    FontStyleItem = FontStyles.Italic;
                    FontWeightItem = FontWeights.Bold;
                    break;
            }
        }

        private C_TEXT_ALIGNMENT _textAlignment;

        public C_TEXT_ALIGNMENT TextAlignmentItem
        {
            get { return _textAlignment; }
            set { SetProperty(ref _textAlignment, value); }
        }

        //颜色
        private Brush selectColor = new SolidColorBrush(Colors.Black);

        public Brush SelectColor
        {
            get { return selectColor; }
            set
            {
                SetProperty(ref selectColor, value);
                if (IsCanSave)
                {
                    ChangedValue?.Invoke((selectColor as SolidColorBrush).Color, FontSetModeType.FontColor);
                }
                else
                {
                    CurrentFontColor = selectColor;
                }
            }
        }

        private Brush _currentFontColor = new SolidColorBrush(Colors.Transparent);

        public Brush CurrentFontColor
        {
            get { return _currentFontColor; }
            set
            {
                SetProperty(ref _currentFontColor, value);
            }
        }

        private bool IsEqualComboData(ComboDataItem oldValue, ComboDataItem newValue)
        {
            if (newValue == null || IsCanSave == false)
                return false;

            if (oldValue != null && newValue != null)
            {
                if (oldValue.Value != newValue.Value)
                    return true;
            }
            return false;
        }

        private bool IsEqualStrComboData(ComboDataItem oldValue, ComboDataItem newValue)
        {
            if (newValue == null || string.IsNullOrEmpty(newValue.ValueStr) == true || IsCanSave == false)
                return false;

            if (oldValue != null && newValue != null)
            {
                if (oldValue.ValueStr != newValue.ValueStr)
                    return true;
            }
            return false;
        }

        #endregion 属性

        #region 列表选中赋值

        public void GetFontWeights_Style(FontStyle fontStyle, FontWeight fontWeights)
        {
            string strValue = "";
            string strContent = "";
            if (fontStyle == FontStyles.Normal)
            {
                if (fontWeights == FontWeights.Normal)
                {
                    strValue = "Regular";
                    strContent = "Regular";
                }
                else
                {
                    strValue = "Bold";
                    strContent = "Bold";
                }
            }
            else
            {
                if (fontWeights == FontWeights.Normal)
                {
                    strValue = "Italic";
                    strContent = "Italic";
                }
                else
                {
                    strValue = "Bold Italic";
                    strContent = "Bold Italic";
                }
            }

            CurrrentFontWeightStyle = new ComboDataItem(strValue, strContent);
            UpdateFontWeight_Style();
        }

        protected void GetCurrentFontSize(int size)
        {
            CurrentFontSize = new ComboDataItem(size);
        }

        protected void GetCurrentFontFamily(string fontFamily, string uiStr)
        {
            //SDK捕获到的字体会是Times-Roman
            if (fontFamily == "Times-Roman")
            {
                uiStr = "Times New Roman";
            }
            //WPF的UI字体不包含Helvetica

            if (fontFamily == "Helvetica")
            {
                fontFamily = "Arial";
                uiStr = "Arial";
            }
            CurrentFontFamily = new ComboDataItem(fontFamily, uiStr);
        }

        #endregion 列表选中赋值
    }
}