using log4net; 
 | 
using PdmSwPlugin.Commmon.Util.UI; 
 | 
using PdmSwPlugin.Common.Util; 
 | 
using PdmSwPlugin.Common.Util.Http; 
 | 
using PdmSwPlugin.PropertySetting.Interface; 
 | 
using SolidWorks.Interop.sldworks; 
 | 
using SolidWorks.Interop.swconst; 
 | 
using System; 
 | 
using System.Collections.Generic; 
 | 
using System.ComponentModel; 
 | 
using System.Net.Http; 
 | 
using System.Runtime.CompilerServices; 
 | 
using System.Threading.Tasks; 
 | 
using System.Windows; 
 | 
using System.Windows.Controls; 
 | 
using PdmSwPlugin.Common.Interface; 
 | 
using PdmSwPlugin.Common; 
 | 
using PdmSwPlugin.PropertySetting.Entity; 
 | 
using PdmSwPlugin.PropertySetting.Panel; 
 | 
using System.Windows.Threading; 
 | 
using PdmSwPlugin.Common.Setting; 
 | 
using System.IO; 
 | 
using System.Runtime.InteropServices; 
 | 
  
 | 
namespace PdmSwPlugin.PropertySetting 
 | 
{ 
 | 
  
 | 
    /// <summary> 
 | 
    /// CommonSettingControl.xaml 的交互逻辑 
 | 
    /// </summary> 
 | 
    [PdmSwPlugin(Title = "属性设置")] 
 | 
    public partial class SettingControl : UserControl, ISwAppSetter, INotifyPropertyChanged 
 | 
        , IActiveDocChangeHandler, ITabControlSelectionChangeHandler 
 | 
    { 
 | 
        private static ILog Logger = LogManager.GetLogger("PropertySetting"); 
 | 
  
 | 
        #region 不能公用的东西,真有你的啊C# 
 | 
        public event PropertyChangedEventHandler PropertyChanged; 
 | 
        public void RaisePropertyChanged(string name) 
 | 
        { 
 | 
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name)); 
 | 
        } 
 | 
        public void RaiseAndSetIfChanged<T>(ref T old, T @new, [CallerMemberName] string propertyName = null) 
 | 
        { 
 | 
            old = @new; 
 | 
            if (propertyName != null) 
 | 
            { 
 | 
                RaisePropertyChanged(propertyName); 
 | 
            } 
 | 
        } 
 | 
        #endregion 
 | 
  
 | 
        public readonly Dictionary<string, UserControl> controlCache = new Dictionary<string, UserControl>(); 
 | 
  
 | 
        #region 属性 
 | 
        public SldWorks SwApp { get; private set; } 
 | 
        /// <summary> 
 | 
        /// 激活的文档 
 | 
        /// </summary> 
 | 
        public ModelDoc2 activeDoc { set; get; } 
 | 
        /// <summary> 
 | 
        /// 上次读取的文档 
 | 
        /// </summary> 
 | 
        public ModelDoc2 LastReadDoc { get; set; } 
 | 
        /// <summary> 
 | 
        /// 当前读取的文档 
 | 
        /// </summary> 
 | 
        public ModelDoc2 ReadDoc { get; set; } 
 | 
        /// <summary> 
 | 
        /// 当前读取的组件 
 | 
        /// </summary> 
 | 
        public Component2 ReadComponent { get; set; } 
 | 
  
 | 
        private HttpClient Client { get; set; } 
 | 
  
 | 
        Dictionary<string, JgjType> settings; 
 | 
        #endregion 
 | 
  
 | 
        #region UI绑定 
 | 
        private string _readDocPath; 
 | 
        public string ReadDocPath 
 | 
        { 
 | 
            get => _readDocPath; 
 | 
            set => RaiseAndSetIfChanged(ref _readDocPath, value); 
 | 
        } 
 | 
        #endregion 
 | 
        private HttpClientCreator clientCreator { get; set; } 
 | 
  
 | 
        private UserControl ActiveOpter { get; set; } 
 | 
  
 | 
        public SettingControl() 
 | 
        { 
 | 
            clientCreator = new HttpClientCreator(new HttpConfig(PluginSetting.Instance.BaseAddress)); 
 | 
            InitializeComponent(); 
 | 
            DataContext = this; 
 | 
        } 
 | 
  
 | 
        public SettingControl(SldWorks SwApp) : this() 
 | 
        { 
 | 
            this.SwApp = SwApp; 
 | 
        } 
 | 
  
 | 
        public void InitPropertyData() 
 | 
        { 
 | 
            if (Client == null) 
 | 
            { 
 | 
                Client = clientCreator.GetClient(); 
 | 
            } 
 | 
            DefaultPanel defaultPanel = new DefaultPanel(); 
 | 
            controlCache.Add("default", defaultPanel); 
 | 
  
 | 
            JgjPartPanel jgjPart = new JgjPartPanel(); 
 | 
            controlCache.Add("jgjPart", jgjPart); 
 | 
  
 | 
            JgjModulePanel jgjModule = new JgjModulePanel(); 
 | 
            controlCache.Add("jgjModule", jgjModule); 
 | 
  
 | 
            var stPart = new StandardPartPanel(); 
 | 
            controlCache.Add("standardPart", stPart); 
 | 
  
 | 
            var stModule = new StandardModulePanel(); 
 | 
            controlCache.Add("standardModule", stModule); 
 | 
            LoadComboxItemSource(); 
 | 
            Refresh_Click(null, null); 
 | 
        } 
 | 
  
 | 
        private void Jgj_SinglePropertyChanged(object sender, string name, object value) 
 | 
        { 
 | 
            // CustomPropertyUtil.SetCustomProperties(ReadDoc, name, (string)value); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 从服务器加载各种选项 
 | 
        /// </summary> 
 | 
        private void LoadComboxItemSource() 
 | 
        { 
 | 
            try 
 | 
            { 
 | 
                Result<Dictionary<string, JgjType>> res = Client.GetSyncAction<Dictionary<string, JgjType>>("design/rule/openApi/test"); 
 | 
                Dictionary<string, JgjType> datas = res.HandleResult(); 
 | 
                settings = datas; 
 | 
                foreach (var key in controlCache.Keys) 
 | 
                { 
 | 
                    (controlCache[key] as IPropertyOpt).SetSettings(settings); 
 | 
                } 
 | 
            } 
 | 
            catch (Exception ex) 
 | 
            { 
 | 
                Logger.Error("Request Jgj properties failed.", ex); 
 | 
                this.Error($"请求加工件属性失败!{ex.Message}"); 
 | 
            } 
 | 
        } 
 | 
  
 | 
        private void UpdateActiveDoc() 
 | 
        { 
 | 
            if (activeDoc != null) 
 | 
            { 
 | 
                DetachDocNotify(activeDoc); 
 | 
            } 
 | 
  
 | 
            activeDoc = SwApp.ActiveDoc; 
 | 
            if (activeDoc != null) 
 | 
            { 
 | 
                AttachDocNotify(activeDoc); 
 | 
                int docType = activeDoc.GetType(); 
 | 
                if (docType == (int)swDocumentTypes_e.swDocASSEMBLY) 
 | 
                { 
 | 
                    activeDoc.ClearSelection2(true); 
 | 
                } 
 | 
            } 
 | 
            UpdateUI(activeDoc); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 附加一些插件范围内的事件 
 | 
        /// </summary> 
 | 
        /// <param name="doc"></param> 
 | 
        private void AttachDocNotify(ModelDoc2 doc) 
 | 
        { 
 | 
            int docType = doc.GetType(); 
 | 
            if (docType == (int)swDocumentTypes_e.swDocASSEMBLY) 
 | 
            { 
 | 
                AssemblyDoc ass = doc as AssemblyDoc; 
 | 
                ass.UserSelectionPostNotify += Ass_UserSelectionPostNotify; 
 | 
                ass.DestroyNotify2 += ActiveDocDestroyNotify2; 
 | 
            } 
 | 
            else if (docType == (int)swDocumentTypes_e.swDocPART) 
 | 
            { 
 | 
                PartDoc part = doc as PartDoc; 
 | 
                part.DestroyNotify2 += ActiveDocDestroyNotify2; 
 | 
            } 
 | 
            else if (docType == (int)swDocumentTypes_e.swDocDRAWING) 
 | 
            { 
 | 
                DrawingDoc draw = doc as DrawingDoc; 
 | 
                draw.DestroyNotify2 += ActiveDocDestroyNotify2; 
 | 
            } 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 移除插件范围内的一些事件 
 | 
        /// </summary> 
 | 
        /// <param name="doc"></param> 
 | 
        private void DetachDocNotify(ModelDoc2 doc) 
 | 
        { 
 | 
            try 
 | 
            { 
 | 
                int docType = doc.GetType(); 
 | 
                if (docType == (int)swDocumentTypes_e.swDocASSEMBLY) 
 | 
                { 
 | 
                    AssemblyDoc ass = doc as AssemblyDoc; 
 | 
                    ass.UserSelectionPostNotify -= Ass_UserSelectionPostNotify; 
 | 
                    ass.DestroyNotify2 -= ActiveDocDestroyNotify2; 
 | 
                } 
 | 
                else if (docType == (int)swDocumentTypes_e.swDocPART) 
 | 
                { 
 | 
                    PartDoc part = doc as PartDoc; 
 | 
                    part.DestroyNotify2 -= ActiveDocDestroyNotify2; 
 | 
                } 
 | 
                else if (docType == (int)swDocumentTypes_e.swDocDRAWING) 
 | 
                { 
 | 
                    DrawingDoc draw = doc as DrawingDoc; 
 | 
                    draw.DestroyNotify2 -= ActiveDocDestroyNotify2; 
 | 
                } 
 | 
            } 
 | 
            catch (COMException e) 
 | 
            { 
 | 
                // 如果sw把不是装配体/零件体/工程图的文档关了,有时会报这个问题,留个日志不报错了 
 | 
                Logger.Warn("COMObject detach event failed.", e); 
 | 
                activeDoc = null; 
 | 
            } 
 | 
        } 
 | 
  
 | 
        private int ActiveDocDestroyNotify2(int DestroyType) 
 | 
        { 
 | 
            if (activeDoc == null) 
 | 
            { 
 | 
                return 0; 
 | 
            } 
 | 
            DetachDocNotify(activeDoc); 
 | 
            activeDoc = null; 
 | 
            ReadComponent = null; 
 | 
            UpdateUI(null); 
 | 
            return 0; 
 | 
        } 
 | 
  
 | 
        public void UpdateUI(ModelDoc2 doc) 
 | 
        { 
 | 
            AlertSaveWindow(); 
 | 
            LastReadDoc = ReadDoc; 
 | 
            ReadDoc = doc; 
 | 
            Dispatcher.Invoke(() => 
 | 
            { 
 | 
                SwitchVisiable(); 
 | 
                // LoadDocProperties(); 
 | 
            }); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 判断是否需要弹窗提示保存 
 | 
        /// </summary> 
 | 
        public void AlertSaveWindow() 
 | 
        { 
 | 
            IPropertyOpt opt = ActiveOpter as IPropertyOpt; 
 | 
            if (opt != null && opt.GetDocChanged()) 
 | 
            { 
 | 
                // 历史文档直接重置 
 | 
                string fullName = Path.GetFileName(ReadDocPath); 
 | 
                if (NameUtil.IsHistoryDoc(fullName)) 
 | 
                { 
 | 
                    opt.ResetProperty(out string errMsg); 
 | 
                    return; 
 | 
                } 
 | 
  
 | 
                string Message = $"{fullName}属性发生变更,是否保存?"; 
 | 
                if (SwApp.SendMsgToUser2(Message, (int)swMessageBoxIcon_e.swMbWarning 
 | 
                   , (int)swMessageBoxBtn_e.swMbYesNo) == (int)swMessageBoxResult_e.swMbHitYes) 
 | 
                { 
 | 
                    SaveDoc(true); 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    opt.ResetProperty(out string errMsg); 
 | 
                } 
 | 
            } 
 | 
        } 
 | 
  
 | 
        private int Ass_UserSelectionPostNotify() 
 | 
        { 
 | 
            var swSelMgr = (SelectionMgr)activeDoc.SelectionManager; 
 | 
            var i = swSelMgr.GetSelectedObjectCount2(-1); 
 | 
            if (i > 0) 
 | 
            { 
 | 
                try 
 | 
                { 
 | 
                    Component2 component = swSelMgr.GetSelectedObjectsComponent4(1, -1); 
 | 
                    ModelDoc2 doc = activeDoc; 
 | 
                    ReadComponent = null; 
 | 
                    if (component != null) 
 | 
                    { 
 | 
                        doc = component.IGetModelDoc(); 
 | 
                        ReadComponent = component; 
 | 
                    } 
 | 
                    UpdateUI(doc); 
 | 
                } 
 | 
                catch (Exception ex) 
 | 
                { 
 | 
                    Logger.Error("Ass Change Component Error.", ex); 
 | 
                    this.Error($"刷新属性失败!{ex.Message}"); 
 | 
                } 
 | 
            } 
 | 
            return 1; 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 根据激活的文档类型,变更属性可视 
 | 
        /// </summary> 
 | 
        private void SwitchVisiable() 
 | 
        { 
 | 
            HashSet<string> skipName = new HashSet<string> { 
 | 
                NameConstant.materialCode 
 | 
            }; 
 | 
  
 | 
            IPropertyOpt last = ActiveOpter as IPropertyOpt; 
 | 
            string contentKey = "default"; 
 | 
            int? docType = ReadDoc?.GetType(); 
 | 
            UserControl control; 
 | 
            IPropertyOpt newOne; 
 | 
            Dictionary<string, string> properties; 
 | 
            if (docType == (int)swDocumentTypes_e.swDocDRAWING) 
 | 
            { 
 | 
                ReadDocPath = ReadDoc.GetPathName(); 
 | 
                contentKey = "default"; 
 | 
                control = controlCache[contentKey]; 
 | 
                newOne = control as IPropertyOpt; 
 | 
                newOne.SetProperties(null, "当前不支持工程图", true, out _); 
 | 
            } 
 | 
            else if (docType == (int)swDocumentTypes_e.swDocPART) 
 | 
            { 
 | 
                ReadDocPath = ReadDoc.GetPathName(); 
 | 
                properties = CustomPropertyUtil.GetCustomProperties2(ReadDoc, true, null, skipName); 
 | 
                string fileType = properties.Get(NameConstant.docType); 
 | 
                /*if (fileType == "加工件" || fileType == "模组") 
 | 
                { 
 | 
                    contentKey = "jgjPart"; 
 | 
                }*/ 
 | 
                if (BomIniterHolder.Instance.IsJgj(ReadDoc)) 
 | 
                { 
 | 
                    contentKey = "jgjPart"; 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    contentKey = "standardPart"; 
 | 
                } 
 | 
                control = controlCache[contentKey]; 
 | 
                newOne = control as IPropertyOpt; 
 | 
                newOne.SetProperties(ReadDoc, properties, true, out _); 
 | 
            } 
 | 
            else if (docType == (int)swDocumentTypes_e.swDocASSEMBLY) 
 | 
            { 
 | 
                ReadDocPath = ReadDoc.GetPathName(); 
 | 
                if (ReadDoc.IsOpenedViewOnly()) 
 | 
                { 
 | 
                    contentKey = "default"; 
 | 
                    control = controlCache[contentKey]; 
 | 
                    newOne = control as IPropertyOpt; 
 | 
                    newOne.SetProperties(null, "当前处于只读模式", true, out _); 
 | 
                } 
 | 
                else if (ReadDoc.IsOpenedReadOnly()) 
 | 
                { 
 | 
                    contentKey = "default"; 
 | 
                    control = controlCache[contentKey]; 
 | 
                    newOne = control as IPropertyOpt; 
 | 
                    newOne.SetProperties(null, "当前处于只读模式", true, out _); 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    // !Equals(LastReadDoc, ReadDoc) 
 | 
                    properties = CustomPropertyUtil.GetCustomProperties2(ReadDoc, true, null, skipName); 
 | 
                    string fileType = properties.Get(NameConstant.docType); 
 | 
                    /*if (fileType == "加工件" || fileType == "模组") 
 | 
                    { 
 | 
                        contentKey = "jgjPart"; 
 | 
                    }*/ 
 | 
                    if (BomIniterHolder.Instance.IsJgj(ReadDoc)) 
 | 
                    { 
 | 
                        contentKey = "jgjModule"; 
 | 
                    } 
 | 
                    else 
 | 
                    { 
 | 
                        contentKey = "standardModule"; 
 | 
                    } 
 | 
                    control = controlCache[contentKey]; 
 | 
                    newOne = control as IPropertyOpt; 
 | 
                    newOne.SetProperties(ReadDoc, properties, true, out _); 
 | 
                } 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                contentKey = "default"; 
 | 
                control = controlCache[contentKey]; 
 | 
                newOne = control as IPropertyOpt; 
 | 
  
 | 
                string PathName = ReadComponent?.GetPathName(); 
 | 
                if (PathName == null) 
 | 
                { 
 | 
                    ReadDocPath = ""; 
 | 
                    newOne.SetProperties(ReadDoc, "请打开一个文档", true, out _); 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    ReadDocPath = PathName; 
 | 
                    string name = Path.GetFileNameWithoutExtension(PathName); 
 | 
                    newOne.SetProperties(ReadDoc, $"【{name}】未找到文档,请检查是否被压缩或轻量化", true, out _); 
 | 
                } 
 | 
            } 
 | 
            if (last != null) 
 | 
            { 
 | 
                last.UpdateProperty -= Jgj_SinglePropertyChanged; 
 | 
                last = null; 
 | 
            } 
 | 
            ActiveOpter = control; 
 | 
            contentPanel.Children.Clear(); 
 | 
            newOne.UpdateProperty += Jgj_SinglePropertyChanged; 
 | 
            contentPanel.Children.Add(control); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 根据激活的文档类型,变更属性可视 
 | 
        /// </summary> 
 | 
        private void SwitchVisiable2() 
 | 
        { 
 | 
            HashSet<string> skipName = new HashSet<string> { 
 | 
                NameConstant.materialCode 
 | 
            }; 
 | 
  
 | 
            IPropertyOpt last = ActiveOpter as IPropertyOpt; 
 | 
            string contentKey = "default"; 
 | 
            int? docType = ReadDoc?.GetType(); 
 | 
            UserControl control; 
 | 
            IPropertyOpt newOne; 
 | 
            Dictionary<string, string> properties; 
 | 
            if (docType == (int)swDocumentTypes_e.swDocDRAWING) 
 | 
            { 
 | 
                ReadDocPath = ReadDoc.GetPathName(); 
 | 
  
 | 
                control = new DefaultPanel(); 
 | 
                newOne = control as IPropertyOpt; 
 | 
                newOne.SetSettings(settings); 
 | 
                newOne.SetProperties(null, "当前不支持工程图", true, out _); 
 | 
            } 
 | 
            else if (docType == (int)swDocumentTypes_e.swDocPART) 
 | 
            { 
 | 
                ReadDocPath = ReadDoc.GetPathName(); 
 | 
                properties = CustomPropertyUtil.GetCustomProperties2(ReadDoc, true, null, skipName); 
 | 
                string fileType = properties.Get(NameConstant.docType); 
 | 
                /*if (fileType == "加工件" || fileType == "模组") 
 | 
                { 
 | 
                    contentKey = "jgjPart"; 
 | 
                }*/ 
 | 
                if (BomIniterHolder.Instance.IsJgj(ReadDoc)) 
 | 
                { 
 | 
                    control = new JgjPartPanel(); 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    control = new StandardPartPanel(); 
 | 
                } 
 | 
                newOne = control as IPropertyOpt; 
 | 
                newOne.SetSettings(settings); 
 | 
                newOne.SetProperties(ReadDoc, properties, true, out _); 
 | 
            } 
 | 
            else if (docType == (int)swDocumentTypes_e.swDocASSEMBLY) 
 | 
            { 
 | 
                ReadDocPath = ReadDoc.GetPathName(); 
 | 
                // !Equals(LastReadDoc, ReadDoc) 
 | 
                properties = CustomPropertyUtil.GetCustomProperties2(ReadDoc, true, null, skipName); 
 | 
                string fileType = properties.Get(NameConstant.docType); 
 | 
                /*if (fileType == "加工件" || fileType == "模组") 
 | 
                { 
 | 
                    contentKey = "jgjPart"; 
 | 
                }*/ 
 | 
                if (BomIniterHolder.Instance.IsJgj(ReadDoc)) 
 | 
                { 
 | 
                    control = new JgjModulePanel(); 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    control = new StandardModulePanel(); 
 | 
                } 
 | 
                newOne = control as IPropertyOpt; 
 | 
                newOne.SetSettings(settings); 
 | 
                newOne.SetProperties(ReadDoc, properties, true, out _); 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                control = new DefaultPanel(); 
 | 
                newOne = control as IPropertyOpt; 
 | 
  
 | 
                string PathName = ReadComponent?.GetPathName(); 
 | 
                if (PathName == null) 
 | 
                { 
 | 
                    ReadDocPath = ""; 
 | 
                    newOne.SetSettings(settings); 
 | 
                    newOne.SetProperties(ReadDoc, "请打开一个文档", true, out _); 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    ReadDocPath = PathName; 
 | 
                    string name = Path.GetFileNameWithoutExtension(PathName); 
 | 
                    newOne.SetSettings(settings); 
 | 
                    newOne.SetProperties(ReadDoc, $"【{name}】未找到文档,请检查是否被压缩或轻量化", true, out _); 
 | 
                } 
 | 
            } 
 | 
            if (last != null) 
 | 
            { 
 | 
                last.UpdateProperty -= Jgj_SinglePropertyChanged; 
 | 
                last = null; 
 | 
            } 
 | 
            ActiveOpter = control; 
 | 
            contentPanel.Children.Clear(); 
 | 
            newOne.UpdateProperty += Jgj_SinglePropertyChanged; 
 | 
            contentPanel.Children.Add(control); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 从激活的文档中读取参数 
 | 
        /// </summary> 
 | 
        private void LoadDocProperties() 
 | 
        { 
 | 
            IPropertyOpt opt = ActiveOpter as IPropertyOpt; 
 | 
            string ErrMsg = null; 
 | 
            if (ReadDoc == null) 
 | 
            { 
 | 
                string PathName = ReadComponent?.GetPathName(); 
 | 
                if (PathName == null) 
 | 
                { 
 | 
                    ReadDocPath = ""; 
 | 
                    opt.SetProperties(ReadDoc, "请打开一个文档", true, out ErrMsg); 
 | 
                    return; 
 | 
                } 
 | 
                ReadDocPath = PathName; 
 | 
                string name = Path.GetFileNameWithoutExtension(PathName); 
 | 
                opt.SetProperties(ReadDoc, $"【{name}】未找到文档,请检查是否被压缩或轻量化", true, out ErrMsg); 
 | 
                return; 
 | 
            } 
 | 
            int docType = ReadDoc.GetType(); 
 | 
            ReadDocPath = ReadDoc.GetPathName(); 
 | 
            if (docType == (int)swDocumentTypes_e.swDocDRAWING) 
 | 
            { 
 | 
                opt.SetProperties(null, "当前不支持工程图", true, out ErrMsg); 
 | 
                return; 
 | 
            } 
 | 
            HashSet<string> skipName = new HashSet<string> { 
 | 
                NameConstant.materialCode 
 | 
            }; 
 | 
            Dictionary<string, string> properties = CustomPropertyUtil.GetCustomProperties2(ReadDoc, true, null, skipName); 
 | 
            opt.SetProperties(ReadDoc, properties, !Equals(LastReadDoc, ReadDoc), out ErrMsg); 
 | 
        } 
 | 
  
 | 
        private void ClearDocProperties() 
 | 
        { 
 | 
            IPropertyOpt opt = ActiveOpter as IPropertyOpt; 
 | 
            opt.ClearAllProperties(out string ErrMsg); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 将属性设置进文档,注意,并没有保存 
 | 
        /// </summary> 
 | 
        /// <param name="doc">文档</param> 
 | 
        private void SetDocProperty(ModelDoc2 doc, Dictionary<string, string> props) 
 | 
        { 
 | 
            CustomPropertyUtil.SetCustomProperties(doc, props); 
 | 
        } 
 | 
  
 | 
        public void SetSwApp(SldWorks SwApp) 
 | 
        { 
 | 
            this.SwApp = SwApp; 
 | 
        } 
 | 
  
 | 
  
 | 
        private void SaveDoc(bool qiaoqiaode) 
 | 
        { 
 | 
  
 | 
            int errors = 0, warnings = 0; 
 | 
  
 | 
            if ((ActiveOpter as IPropertyOpt).SaveDoc(ref errors, ref warnings)) 
 | 
            { 
 | 
                // if (!qiaoqiaode) this.Info("保存成功"); 
 | 
            } 
 | 
        } 
 | 
  
 | 
        private void SaveButton_Click(object sender, RoutedEventArgs e) 
 | 
        { 
 | 
            if (ReadDoc == null) 
 | 
            { 
 | 
                return; 
 | 
            } 
 | 
            SaveDoc(false); 
 | 
        } 
 | 
  
 | 
        public void RefreshData() 
 | 
        { 
 | 
            MaskAdorner.ShowMask(content, "属性加载中,请稍候..."); 
 | 
            Task.Run(() => 
 | 
            { 
 | 
                try 
 | 
                { 
 | 
                    UpdateActiveDoc(); 
 | 
                } 
 | 
                catch (COMException come) 
 | 
                { 
 | 
                    // 频繁关闭会抛出这个异常,不管了 
 | 
                    Logger.Warn("Read property COMObject failed.", come); 
 | 
                } 
 | 
                catch (Exception ex) 
 | 
                { 
 | 
                    Logger.Error($"读取参数异常,文件:[{ReadDocPath}]!", ex); 
 | 
                    this.Error($"读取参数异常:{ex.Message}"); 
 | 
                } 
 | 
                finally 
 | 
                { 
 | 
                    MaskAdorner.HideMask(content); 
 | 
                } 
 | 
            }); 
 | 
        } 
 | 
  
 | 
        private void Refresh_Click(object sender, RoutedEventArgs e) 
 | 
        { 
 | 
            RefreshData(); 
 | 
        } 
 | 
  
 | 
        private void LoadComboBox_Click(object sender, RoutedEventArgs e) 
 | 
        { 
 | 
            MaskAdorner.ShowMask(content, "加载MES设置,请稍候..."); 
 | 
            Task.Run(() => 
 | 
            { 
 | 
                try 
 | 
                { 
 | 
                    LoadComboxItemSource(); 
 | 
                } 
 | 
                finally 
 | 
                { 
 | 
                    MaskAdorner.HideMask(content); 
 | 
                } 
 | 
            }); 
 | 
        } 
 | 
  
 | 
        private void PropertySettingControl_Initialized(object sender, EventArgs e) 
 | 
        { 
 | 
            InitPropertyData(); 
 | 
        } 
 | 
  
 | 
        /// <summary> 
 | 
        /// 激活的文档变更触发 
 | 
        /// </summary> 
 | 
        /// <param name="lastDoc"></param> 
 | 
        /// <param name="doc"></param> 
 | 
        /// <param name="comp"></param> 
 | 
        public void OnSwActiveDocChange(ModelDoc2 lastDoc, ModelDoc2 doc, Component2 comp) 
 | 
        { 
 | 
            // CurrentChanged(); 
 | 
            RefreshData(); 
 | 
        } 
 | 
  
 | 
        public void OnSwActiveDocSaved(ModelDoc2 doc, Component2 comp) 
 | 
        { 
 | 
            // 读取文件,设置参数 
 | 
            // LoadDocProperties(); 
 | 
        } 
 | 
  
 | 
        public void OnCustomPropertyChange(string propName, string Configuration, string oldValue, string NewValue, int valueType) 
 | 
        { 
 | 
            if (oldValue == NewValue) 
 | 
            { 
 | 
                return; 
 | 
            } 
 | 
            IPropertyOpt opt = ActiveOpter as IPropertyOpt; 
 | 
            opt.UpdateSingleProperty(propName, NewValue); 
 | 
        } 
 | 
  
 | 
        public void OnDocDestroy(ModelDoc2 doc) 
 | 
        { 
 | 
  
 | 
        } 
 | 
  
 | 
        public void AfterDocDestroy() 
 | 
        { 
 | 
  
 | 
        } 
 | 
  
 | 
        public void OnTabControlSelectionChange(object sender, SelectionChangedEventArgs e) 
 | 
        { 
 | 
            if (e.RemovedItems == null) 
 | 
            { 
 | 
                return; 
 | 
            } 
 | 
  
 | 
            foreach (object obj in e.RemovedItems) 
 | 
            { 
 | 
                if (obj is TabItem item) 
 | 
                { 
 | 
                    if (item.Content == this) 
 | 
                    { 
 | 
                        AlertSaveWindow(); 
 | 
                        break; 
 | 
                    } 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    return; 
 | 
                } 
 | 
            } 
 | 
        } 
 | 
  
 | 
        public void DisabledHandler() 
 | 
        { 
 | 
             
 | 
        } 
 | 
    } 
 | 
} 
 |