From 9d1660270272180cd71147d6ddd53d1382643d2e Mon Sep 17 00:00:00 2001
From: wenxiangchao <wenxiangchao@ihengxin.com.cn>
Date: 星期一, 02 十一月 2026 18:00:14 +0800
Subject: [PATCH] merge: 并入远程 Initial commit 作为历史根节点

---
 HMI.Base/PluginLoader.cs |  234 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 234 insertions(+), 0 deletions(-)

diff --git a/HMI.Base/PluginLoader.cs b/HMI.Base/PluginLoader.cs
new file mode 100644
index 0000000..81e1f84
--- /dev/null
+++ b/HMI.Base/PluginLoader.cs
@@ -0,0 +1,234 @@
+锘縰sing HMI.Core.Api;
+using HMI.Core.Entity;
+using HMI.Core.Util;
+using log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using System.Windows;
+using System.Windows.Threading;
+
+namespace HMI.Base
+{
+    public class PluginLoader
+    {
+        private static ILog log = LogManager.GetLogger("PluginLoader");
+        private static string PluginFolder = PathHelper.PluginFolder();
+
+        public SqliteHelper sqliteHelper;
+        public List<PluginInfo> Menus { get; private set; }
+        public List<PluginInfo> Plugins { get; private set; }
+        public static PluginLoader Instance { get; private set; }
+
+        public event EventHandler<LoadMsg> LoadMessageAppend;
+
+        private PluginLoader()
+        {
+            sqliteHelper = new SqliteHelper(PathHelper.DatabasePath);
+        }
+
+        public static void Reset()
+        {
+            if (Instance != null)
+            {
+                Instance = null;
+            }
+            GC.Collect();
+        }
+
+        public static PluginLoader GetLoader()
+        {
+            if (Instance == null)
+            {
+                Instance = new PluginLoader();
+            }
+            return Instance;
+        }
+
+        private IPluginContainer pluginContainer;
+
+        public void LoadMenuAndPlugin(IPluginContainer container, Dispatcher dispatcher)
+        {
+            pluginContainer = container;
+            if (Menus == null)
+            {
+                Plugins = new List<PluginInfo>();
+                Menus = LoadTreeMenu(dispatcher);
+                sqliteHelper.Close();
+                LoadMessageAppend?.Invoke(this, new LoadMsg { Type = LoadMsgType.FINISHED });
+            }
+            pluginContainer.DoCloseEvent += PluginContainer_DoCloseEvent;
+        }
+
+        private void PluginContainer_DoCloseEvent(object sender, EventArgs e)
+        {
+            Reset();
+        }
+
+        private void LoadChildrenMenu()
+        {
+            foreach (var menu in Plugins)
+            {
+                CountdownEvent c = new CountdownEvent(1);
+                Thread.Sleep(50);
+                Application.Current.Dispatcher.Invoke(new Action(() =>
+                {
+                    try
+                    {
+                        var start = DateTime.Now;
+                        log.Info(this.lang("App.IsLoadingMenu", menu.Name));
+                        LoadMessageAppend?.Invoke(this,
+                            new LoadMsg
+                            {
+                                Type = LoadMsgType.LOADING,
+                                Message = this.lang("App.IsLoadingMenu", menu.Name)
+                            }
+                        );
+
+                        if (!string.IsNullOrEmpty(menu.DllPath))
+                        {
+                            string dllPath = Path.Combine(PluginFolder, menu.DllPath);
+                            Assembly ass = Assembly.LoadFrom(dllPath);
+                            var tss = ass.GetTypes();
+                            Type ClassType = ass.GetType(menu.ClassName);
+                            object Instance = Activator.CreateInstance(ClassType);
+                            menu.Content = Instance;
+                            if (Instance is IPlugin plugin)
+                            {
+                            }
+                            else
+                            {
+                                plugin = new PluginPackage(Instance);
+                            }
+                            plugin.SetLogger(LogManager.GetLogger(menu.Code));
+                            string configFolder = Path.Combine(PathHelper.ConfigFolder, menu.Code);
+                            if (!Directory.Exists(configFolder))
+                            {
+                                Directory.CreateDirectory(configFolder);
+                            }
+                            plugin.SetBaseFolder(configFolder);
+                            plugin.InitFinish();
+                            pluginContainer.OnCloseEvent += plugin.OnClose;
+                            pluginContainer.DoCloseEvent += plugin.DoClose;
+                            Type SettingType = ass.GetType($"{menu.ClassName}_Setting");
+                            if (SettingType != null)
+                            {
+                                object SettingInstance = Activator.CreateInstance(SettingType);
+                                if (SettingInstance is IFolderOwner fo)
+                                {
+                                    fo.SetBaseFolder(configFolder);
+                                }
+                                menu.SettingControl = SettingInstance;
+                            }
+                        }
+                        log.Info($"{this.lang("App.MenuLoadSuccess", menu.Name)} Cost: {(DateTime.Now - start).TotalMilliseconds}ms");
+                        LoadMessageAppend?.Invoke(this,
+                            new LoadMsg
+                            {
+                                Type = LoadMsgType.LOADING,
+                                Result = true,
+                                Message = this.lang("App.MenuLoadSuccess", menu.Name),
+                            });
+                    }
+                    catch (Exception ex)
+                    {
+                        log.Error($"Load Plugin [{menu.Name}] Failed.", ex);
+                        LoadMessageAppend?.Invoke(this, new LoadMsg
+                        {
+                            Type = LoadMsgType.LOADING,
+                            Result = false,
+                            Message = this.lang("App.MenuLoadFailed", menu.Name, ex.Message, ex.StackTrace)
+                        });
+                    }
+                    finally
+                    {
+                        c.Signal();
+                    }
+                }));
+                c.Wait();
+            }
+        }
+
+        private PluginInfo ConvertPermission2PluginInfo(PermissionData data)
+        {
+            if (data.Type == "鏉冮檺") return null;
+            PluginInfo info = new PluginInfo
+            {
+                Code = data.Code,
+                Name = data.Name,
+                Type = data.Type,
+                ParentCode = data.ParentCode,
+                DllPath = data.DllPath,
+                ClassName = data.ClassName,
+                IconFont = data.IconFont
+                //Icon = new BitmapImage(new Uri(Path.Combine(PathHelper.IconFolder, dr["iconPath"].ToString())))
+            };
+            if (data.Children != null && data.Children.Count > 0)
+            {
+                foreach (var child in data.Children)
+                {
+                    var childInfo = ConvertPermission2PluginInfo(child);
+                    if (childInfo != null) info.Children.Add(childInfo);
+                }
+            }
+            return info;
+        }
+
+        public List<PluginInfo> LoadTreeMenu(Dispatcher dispatcher)
+        {
+            List<PluginInfo> menus = new List<PluginInfo>();
+            Dictionary<string, PluginInfo> cache = new Dictionary<string, PluginInfo>();
+            try
+            {
+                List<PermissionData> allPermissions = UserInfo.User?.AllPermissions;
+                if (allPermissions != null)
+                {
+                    Application.Current.Dispatcher.Invoke(new Action(() =>
+                    {
+                        log.Info(this.lang("App.MenuCount", allPermissions.Count));
+                        LoadMessageAppend?.Invoke(this,
+                          new LoadMsg
+                          {
+                              Type = LoadMsgType.INIT,
+                              NumData = allPermissions.Count,
+                              Message = this.lang("App.MenuCount", allPermissions.Count),
+                          });
+
+                        foreach (PermissionData data in allPermissions)
+                        {
+                            if (data.Type == "Permission") continue;
+                            var menu = new PluginInfo
+                            {
+                                Code = data.Code,
+                                Name = data.Name,
+                                Type = data.Type,
+                                ParentCode = data.ParentCode,
+                                DllPath = data.DllPath,
+                                ClassName = data.ClassName,
+                                IconFont = data.IconFont
+                            };
+                            cache[menu.Code] = menu;
+                            if (!cache.ContainsKey(menu.ParentCode))
+                            {
+                                menus.Add(menu);
+                            }
+                            else
+                            {
+                                cache[menu.ParentCode].Children.Add(menu);
+                            }
+                            Plugins.Add(menu);
+                        }
+                    }));
+                    LoadChildrenMenu();
+                }
+            }
+            catch (Exception ex)
+            {
+                //LoadMessageAppend?.Invoke(this, ex.Message);
+            }
+            return menus;
+        }
+    }
+}

--
Gitblit v1.9.1