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.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
    }

    //设置字体大小、字体内容排版、字体颜色、字体样式、字重
    public class FontBoard : BindableBase
    {
        #region 变量

        protected event EventHandler<FontSetModeType> ChangedValue;

        protected bool IsCanSave = false;
        public List<ComboDataItem> FontFamilyItems { get; protected set; }
        public List<ComboDataItem> FontStyleItems { 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();
        }

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

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

        //字体
        private void InitBase_FontFamilys()
        {
            FontFamilyItems = TextFont.GetFamily();
        }

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

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

        #region 属性

        private ComboDataItem _currentPresetFont;

        public ComboDataItem CurrentPresetFont
        {
            get { return _currentPresetFont; }
            set
            {
                bool isChange = IsEqualStrComboData(_currentPresetFont, value);
                SetProperty(ref _currentPresetFont, value);
                if (isChange)
                {
                    ChangedValue?.Invoke(_currentPresetFont.ValueStr, FontSetModeType.PresetFontStyes);
                }
            }
        }

        #region 字体样式

        //下拉框列表
        private ComboDataItem _currentFontFamily;

        public ComboDataItem CurrentFontFamily
        {
            get { return _currentFontFamily; }
            set
            {
                bool isChange = IsEqualStrComboData(_currentFontFamily, value);
                SetProperty(ref _currentFontFamily, value);
                if (isChange)
                {
                    ChangedValue?.Invoke(_currentFontFamily.ValueStr, FontSetModeType.FontFamilys);
                }
            }
        }

        #endregion 字体样式

        #region 字体大小

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

        public ComboDataItem CurrentFontSize
        {
            get { return _currentFontSize; }
            set
            {
                bool isChange = IsEqualComboData(_currentFontSize, value);

                if (isChange && value.Value > 0)
                    SetProperty(ref _currentFontSize, value);

                if (isChange && value.Value > 0)
                {
                    ChangedValue?.Invoke(_currentFontSize.Value, FontSetModeType.FontSizes);
                }
            }
        }

        #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 ComboDataItem _currrentFontWeightStyle;

        public ComboDataItem CurrrentFontWeightStyle
        {
            get { return _currrentFontWeightStyle; }
            set
            {
                bool isChange = IsEqualStrComboData(_currrentFontWeightStyle, value);
                SetProperty(ref _currrentFontWeightStyle, value);
                if (isChange)
                {
                    ChangedValue?.Invoke(_currrentFontWeightStyle, FontSetModeType.FontWeight_Style);
                }
            }
        }

        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 列表选中赋值

        protected void GetFontWeights_Style(FontStyle fontStyle, FontWeight fontWeights)
        {
            string strValue = "";
            string strContent = "";
            if (fontStyle == FontStyles.Normal)
            {
                if (fontWeights == FontWeights.Normal)
                {
                    strValue = "Regular";
                    strContent = "常规";
                }
                else
                {
                    strValue = "Bold";
                    strContent = "粗体";
                }
            }
            else
            {
                if (fontWeights == FontWeights.Normal)
                {
                    strValue = "Italic";
                    strContent = "斜体";
                }
                else
                {
                    strValue = "Bold Italic";
                    strContent = "粗斜体";
                }
            }

            CurrrentFontWeightStyle = new ComboDataItem(strValue, strContent);
        }

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

        protected void GetCurrentFontFamily(string fontFamily, string uiStr)
        {
            CurrentFontFamily = new ComboDataItem(fontFamily, uiStr);
        }

        #endregion 列表选中赋值
    }

    //设置字体大小、字体内容排版、字体颜色、字体样式、字重
    public class FontBoardVm : BindableBase
    {
        #region 变量

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

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

        public FontBoardVm(bool isInitdata)
        {
            if (isInitdata)
                InitBaseVariable();
        }

        #endregion 变量

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

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

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

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

        //字体
        private void InitBase_FontFamilys()
        {
            FontFamilyItems = TextFont.GetFamily();
        }

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

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

        #region 属性

        /// <summary>
        /// 预设样式
        /// </summary>
        private ComboDataItem _currentPresetFont = new ComboDataItem("Custom", "Custom");

        public ComboDataItem CurrentPresetFont
        {
            get { return _currentPresetFont; }
            set
            {
                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;
                }
            }
        }

        private int presetFontSelectedIndex;

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

        #region 字体样式

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

        public ComboDataItem CurrentFontFamily
        {
            get { return _currentFontFamily; }
            set
            {
                SetProperty(ref _currentFontFamily, value);
                switch (value.Content.ToString())
                {
                    case "Courier New":
                        FontFamilySelectedIndex = 0;
                        break;

                    case "Helvetica":
                    case "Arial":
                        FontFamilySelectedIndex = 1;
                        break;

                    case "Times New Roman":
                        FontFamilySelectedIndex = 2;
                        break;
                }
            }
        }

        private int fontFamilySelectedIndex;

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

        #endregion 字体样式

        #region 字体大小

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

        public ComboDataItem CurrentFontSize
        {
            get { return _currentFontSize; }
            set => SetProperty(ref _currentFontSize, value);
        }

        #endregion 字体大小

        //FontStyle & FontWeight

        private FontStyle _fontStyleItem;

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

        private FontWeight _fontWeight;

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

        private int fontStyleSelectedIndex;

        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
            {
                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;
                }
            }
        }

        public 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 string _strtextAlign;

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

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

        public Brush FontColor
        {
            get { return _fontColor; }
            set { SetProperty(ref _fontColor, value); CurrentFontColor = _fontColor; }
        }

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

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

        //外部UI引用，判断是否选中左对齐、居中对齐、右对齐，或都不选中
        public string strAglinState { get; private set; }

        //VM赋值
        public void SetStrAglinState(string str)
        {
            strAglinState = str;
        }

        #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);
        }

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

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

        public void GetCurrentPresetFont(string presetFont, string uiStr)
        {
            CurrentPresetFont = new ComboDataItem(presetFont, uiStr);
        }

        internal bool GetCurrentPresetFont(FreeTextAnnotArgs annot)
        {
            bool isExist = false;
            //List<PresetFontItem> presetFontItems = TextFont.GetCachePresetFontList();
            foreach (var item in PresetFontList)
            {
                if (annot.FontSize == item.mFontSize && annot.FontWeight == item.mFontWeight
                    && (annot.FontFamily.Source == item.mFontFamily.Source || annot.FontFamily.Source == "Arial" && item.mFontFamily.Source == "Helvetica")
                    )
                {
                    if (item.mTag != "Custom")
                    {
                        CurrentPresetFont = new ComboDataItem(item.mTag, item.mTagContent);
                        isExist = true;
                    }

                    break;
                }
            }
            return isExist;
        }

        #endregion 列表选中赋值
    }
}