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

using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using PDF_Office.CustomControl.CompositeControl;
using PDF_Office.Model;
using PDF_Office.Model.PropertyPanel.AnnotPanel;
using PDF_Office.ViewModels.Tools;
using PDFSettings;
using Prism.Commands;
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.Controls;
using System.Windows.Media;

namespace PDF_Office.ViewModels.PropertyPanel.AnnotPanel
{
    public class FreetextAnnotPropertyViewModel : FontBoard, INavigationAware
    {
        private bool isSelectedEmpty;
        public bool IsSelectedEmpty
        {
            get { return isSelectedEmpty; }
            set { SetProperty(ref isSelectedEmpty, value); }
        }

        private double fillOpacity = 1;
        public double FillOpacity
        {
            get { return fillOpacity; }
            set
            {
                SetProperty(ref fillOpacity, value);
            }
        }

        private Brush _currentFillColor = new SolidColorBrush(Colors.Transparent);
        public Brush CurrentFillColor
        {
            get { return _currentFillColor; }
            set
            {
                SetProperty(ref _currentFillColor, value);
            }
        }

        private Brush fillColor = new SolidColorBrush(Colors.Transparent);
        public Brush FillColor
        {
            get { return fillColor; }
            set
            {
                SetProperty(ref fillColor, value);
                if (IsCanSave)
                {
                    AnnotEvent?.UpdateAttrib(AnnotAttrib.FillColor, (fillColor as SolidColorBrush).Color);
                    AnnotEvent?.UpdateAnnot();
                }
                else
                {
                    CurrentFillColor = fillColor;
                }
               
            }
        }

        private bool _isMultiSelected = false;
        public bool IsMultiSelected
        {
            get { return _isMultiSelected; }
            set => SetProperty(ref _isMultiSelected, value);
        }

        public DelegateCommand<object> SelectedFillOpacityCommand { get; set; }
        public DelegateCommand<object> SelectedFontStyleCommand { get; set; }
        public DelegateCommand<object> SelectedColorCommand { get; set; }
        public DelegateCommand<object> SelectedFillColorCommand { get; set; }
        public DelegateCommand<object> FontFamilyChangedCommand { get; set; }

        public DelegateCommand<object> FontSizeChangedCommand { get; set; }
        public DelegateCommand<object> TextAlignCheckedCommand { get; set; }
        public DelegateCommand<object> LineModeCheckedCommand { get; set; }
        public DelegateCommand<object> SelectedOpacityValueCommand { get; set; }

        public DelegateCommand CustomFontStyleCommand { get; set; }

        public DelegateCommand ReDefineFontStyleCommand { get; set; }
        public DelegateCommand RestoreDefaultStyleCommand { get; set; }

        public event EventHandler<object> LoadPropertyHandler;

        public FreetextAnnotPropertyViewModel()
        {
            SelectedFillOpacityCommand = new DelegateCommand<object>(SelectedFillOpacity);
            SelectedFontStyleCommand = new DelegateCommand<object>(SelectedFontStyle);
            SelectedColorCommand = new DelegateCommand<object>(SelectedColor_Command);
            SelectedFillColorCommand = new DelegateCommand<object>(SelectedFillColor_Command);
            FontFamilyChangedCommand = new DelegateCommand<object>(FontFamilyChanged_Command);
            FontSizeChangedCommand = new DelegateCommand<object>(FontSizeChanged_Command);
            TextAlignCheckedCommand = new DelegateCommand<object>(TextAlignChecked);
            LineModeCheckedCommand = new DelegateCommand<object>(LineMode_Checked);
            SelectedOpacityValueCommand = new DelegateCommand<object>(SelectedOpacityValue);

            CustomFontStyleCommand = new DelegateCommand(CustomFontStyle);
            ReDefineFontStyleCommand = new DelegateCommand(ReDefineFontStyle);
            RestoreDefaultStyleCommand = new DelegateCommand(RestoreDefaultStyle);
            InitVariable();
        }

        private void InitVariable()
        {
            InitFontStyles();
            InitFontFamilyComboBox();
            InitFontStyleComboBox();
        }

        private void InitFontFamilyComboBox()
        {
            FontFamilyItems = TextFont.GetFamily();
        }

        private void InitFontStyleComboBox()
        {
            FontStyleItems = TextFont.GetFontStyle();
        }

        private void InitFontStyles()
        {
            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 TextAlignChecked(object obj)
        {
            if ((string)obj != null /*&& TextEditEvent != null*/)
            {
                switch ((string)obj)
                {
                    case "AlignLeft":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Left);
                        break;

                    case "AlignCenter":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Center);
                        break;

                    case "AlignRight":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Right);
                        break;

                    case "Align":
                        break;
                }

                AnnotEvent?.UpdateAnnot();
            }
        }
        private void LineMode_Checked(object obj)
        {
            if(obj != null)
            {
                var tag = ((string)obj);
                switch (tag)
                {
                    case "Dashed":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.LineStyle, DashStyles.Dash);
                        break;

                    case "Solid":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.LineStyle, DashStyles.Solid);
                        break;

                }
                AnnotEvent?.UpdateAnnot();
            }
        }
        
        private void SelectedFontStyle(object obj)
        {
            if (obj != null && (PresetFontItem)obj != null)
            {
                var item = (PresetFontItem)obj;

                AnnotEvent?.UpdateAttrib(AnnotAttrib.FontSize, item.mFontSize);

                AnnotEvent?.UpdateAnnot();

            }
        }

        private void SelectedFillOpacity(object obj)
        {
            if (obj != null)
            {
                FillOpacity = (double)obj;
                SelectColor.Opacity = FillOpacity;

                AnnotEvent?.UpdateAttrib(AnnotAttrib.Transparency, FillOpacity);
                AnnotEvent?.UpdateAnnot();
            }
        }

        private void SelectedOpacityValue(object obj)
        {
            if (obj != null)
            {
                FillOpacity = (double)obj;
                SelectColor.Opacity = FillOpacity;

                AnnotEvent?.UpdateAttrib(AnnotAttrib.Transparency, FillOpacity);
                AnnotEvent?.UpdateAnnot();
            }
        }
        
        private void FontSizeChanged_Command(object obj)
        {
            if (obj != null)
            {
                var item = (ComboBoxItem)obj;
                var content = (string)item.Content;
                if (content != null)
                {
                    var intData = int.Parse(content);
                    AnnotEvent?.UpdateAttrib(AnnotAttrib.FontSize, intData);
                   
                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        private void FontFamilyChanged_Command(object obj)
        {

        }

        private void SelectedFillColor_Command(object obj)
        {
            if (obj != null)
            {
                var colorValue = (Color)obj;
                if (colorValue != null)
                {

                    FillColor = new SolidColorBrush(colorValue);
                    FillColor.Opacity = FillOpacity;

                    Dictionary<AnnotArgsType, object> changeData = new Dictionary<AnnotArgsType, object>();
                    changeData[AnnotArgsType.AnnotFreehand] = obj;
                    PropertyPanel.DataChangedInvoke(this, changeData);
                }
            }
        }

        private void SelectedColor_Command(object obj)
        {
            if (obj != null)
            {
                var colorValue = (Color)obj;
                if (colorValue != null)
                {

                    SelectColor = new SolidColorBrush(colorValue);
                    SelectColor.Opacity = FillOpacity;
                    
                    Dictionary<AnnotArgsType, object> changeData = new Dictionary<AnnotArgsType, object>();
                    changeData[AnnotArgsType.AnnotFreehand] = obj;
                    PropertyPanel.DataChangedInvoke(this, changeData);
                }
            }
        }

        private void CustomFontStyle()
        {
            if (CurrentPresetFont != null)
            {
                ContextMenu menu;
                if (CurrentPresetFont.ValueStr == "custom")
                {
                    menu = SelectAnnotContextMenu(false);
                }
                else
                {
                    menu = SelectAnnotContextMenu(true);
                }

                if (menu != null)
                {
                    menu.IsOpen = true;
                }
            }

        }

        private ContextMenu SelectAnnotContextMenu(bool isEnable)
        {
            var popMenu = App.Current.FindResource("CustomFontStyleFlyoutMenu") as ContextMenu;
            if (popMenu != null && popMenu.Items.Count == 2)
            {
                //用所选部分重新定义
                MenuItem menuItem = popMenu.Items[0] as MenuItem;
                menuItem.IsEnabled = isEnable;
                menuItem.Command = ReDefineFontStyleCommand;
                //恢复默认预设样式
                menuItem = popMenu.Items[1] as MenuItem;
                menuItem.IsEnabled = isEnable;
                menuItem.Command = RestoreDefaultStyleCommand;
            }
            return popMenu;
        }

        public List<PresetFontItem> FontStyleList = new List<PresetFontItem>();
        private void ReDefineFontStyle()
        {
            var item = FontStyleList.FirstOrDefault(temp => temp.mTag == CurrentPresetFont.ValueStr);

            if (CurrentFontFamily.ValueStr == "Bold")
            {
                item.mFontStyle = FontStyles.Normal;
                item.mFontWeight = FontWeights.Bold;
            }
            else if (CurrentFontFamily.ValueStr == "Regular")
            {
                item.mFontStyle = FontStyles.Normal;
                item.mFontWeight = FontWeights.Normal;
            }
            else
            {
                item.mFontStyle = FontStyles.Italic;
                item.mFontWeight = FontWeights.Bold;
            }

            item.mFontSize = (int)CurrentFontSize.Value;
        }

        private void RestoreDefaultStyle()
        {
            var item = FontStyleList.FirstOrDefault(temp => temp.mTag == CurrentPresetFont.ValueStr);
        }

        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            IsCanSave = false;
            ChangedValue -= FontMode_ChangedValue;
            IsMultiSelected = false;
        }

        public AnnotAttribEvent AnnotEvent { get; set; }
        private FreeTextAnnotArgs Annot;
        private AnnotPropertyPanel PropertyPanel;
        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            navigationContext.Parameters.TryGetValue<AnnotPropertyPanel>(ParameterNames.PropertyPanelContentViewModel, out PropertyPanel);
            if (PropertyPanel != null)
            {
                AnnotEvent = PropertyPanel.AnnotEvent;
                Annot = PropertyPanel.annot as FreeTextAnnotArgs;
                LoadPropertyHandler?.Invoke(this, Annot);
                ChangedValue -= FontMode_ChangedValue;
                ChangedValue += FontMode_ChangedValue;
                if (PropertyPanel.annotlists != null && PropertyPanel.annotlists.Count > 1)
                {
                    IsMultiSelected = true;
                }
                else
                {
                    IsMultiSelected = false;
                }

                if(IsMultiSelected)
                {

                }
                else
                {
                    GetAnnotProperty();
                }

                IsCanSave = true;
            }
        }

        private void GetAnnotProperty()
        {
            SelectColor = new SolidColorBrush(Annot.FontColor);
            FillColor = new SolidColorBrush(Annot.BgColor);

            GetCurrentFontSize((int)Annot.FontSize);
            GetCurrentFontFamily(Annot.FontFamily.ToString(), Annot.FontFamily.ToString());
            GetFontWeights_Style(Annot.FontStyle, Annot.FontWeight);
        }

        private void FontMode_ChangedValue(object sender, FontSetModeType e)
        {
            if (sender != null)
            {
                switch (e)
                {
                    case FontSetModeType.PresetFontStyes:
                        if (PresetFontList != null && sender is string == true)
                        {
                            var item = PresetFontList.FirstOrDefault(temp => temp.mTag == (string)sender);
                            if (item != null && Annot != null)
                            {

                            }
                        }
                        break;
                    case FontSetModeType.FontFamilys:
                        if (sender is string == true && IsCanSave)
                        {
                            AnnotEvent.UpdateAttrib(AnnotAttrib.FontFamily, new FontFamily((string)sender));
                            AnnotEvent.UpdateAnnot();
                        }

                        break;
                    case FontSetModeType.FontSizes:
                        if (sender is double == true && (double)sender > 0 && Annot.FontSize > 0)
                        {
                            AnnotEvent.UpdateAttrib(AnnotAttrib.FontSize, (double)sender);
                            AnnotEvent.UpdateAnnot();
                        }

                        break;
                    case FontSetModeType.FontWeight_Style:
                        UpdateFontWeight_Style();
                        AnnotEvent.UpdateAttrib(AnnotAttrib.FontWeight, FontWeightItem);
                        AnnotEvent.UpdateAttrib(AnnotAttrib.FontStyle, FontStyleItem);
                        AnnotEvent.UpdateAnnot();
                        break;
                    case FontSetModeType.FontColor:
                        if (sender is Color == true)
                        {
                            AnnotEvent.UpdateAttrib(AnnotAttrib.FontColor, (SelectColor as SolidColorBrush).Color );
                            AnnotEvent.UpdateAnnot();
                        }

                        break;

                    case FontSetModeType.TextAlignment:
                        break;
                }
            }
        }
    }
}