SANAS/SmartCoalApplication/Program.cs

using Resources;
using SmartCoalApplication.Base;
using SmartCoalApplication.Base.AutoMeasure;
using SmartCoalApplication.Base.CommTool;
using SmartCoalApplication.Base.Enum;
using SmartCoalApplication.Base.MeasureModel;
using SmartCoalApplication.Base.SettingModel;
using SmartCoalApplication.Core;
using SmartCoalApplication.Core.DbOpreate;
using SmartCoalApplication.Core.DbOpreate.DbBll;
using SmartCoalApplication.Core.DbOpreate.DbModel;
using SmartCoalApplication.ParameterSet;
using SmartCoalApplication.SystemLayer;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.Entity.Core.Mapping;
using System.Data.Entity.Core.Metadata.Edm;
using System.Data.Entity.Infrastructure;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using SenseShield;
using SmartCoalApplication.Base.FunctionModel;

namespace SmartCoalApplication
{
    internal sealed class Program
    {
        public static Program instance;

        public SplashForm splashForm = null;
        /// <summary>
        /// 图像处理参数
        /// </summary>
        public ImageMenu imageMenuModel;
        /// <summary>
        /// 相机是否合法
        /// </summary>
        public static bool cameraSNLegal = false;
        /// <summary>
        /// 启动时传进来的参数，需要进行解析
        /// 在自定义快捷方式的时候会用到
        /// 读取不同的配置路径的配置信息
        /// </summary>
        private string[] args;
        /// <summary>
        /// 主窗体
        /// </summary>
        private MainForm mainForm;
        /// <summary>
        /// 设置信息所在的文件夹
        /// </summary>
        public string SettingPrefix = "Default";
        /// <summary>
        /// 系统配置
        /// </summary>
        public ConfigModel configModel;

        /// <summary>
        /// 系统配置
        /// </summary>
        public FileNameRule fileNameRule;

        /// <summary>
        /// 快捷键配置
        /// </summary>
        public HotkeyModel hotkeyModel;
        /// <summary>
        /// 工具栏
        /// </summary>
        public ToolbarModel toolbarModel;
        /// <summary>
        /// 快捷栏
        /// </summary>
        public ShortcutbarModel shortcutbarModel;
        /// <summary>
        /// 测量样式信息
        /// </summary>
        public MeasureStyleModel measureStyleModel;

        /// <summary>
        /// 测量样式信息
        /// </summary>
        public MeasureAreaModel measureAreaModel;
        /// <summary>
        /// 换算完的标尺信息，包含所有系统内得单位
        /// </summary>
        public Dictionary<MeasurementUnit, double> rules = new Dictionary<MeasurementUnit, double>();
        /// <summary>
        /// 系统内选定的单位
        /// </summary>
        public MeasurementUnit measurementUnit;
        /// <summary>
        /// 当前系统标尺
        /// </summary>
        public mic_rulers ruleDB;
        /// <summary>
        /// 标尺集合
        /// </summary>
        public List<mic_rulers> mic_rulersAll;
        /// <summary>
        /// 单位对应的枚举数字
        /// </summary>
        public Dictionary<string, int> companyEnume;
        /// <summary>
        /// 是否开启加密锁验证
        /// </summary>
        public static/*const*/ bool useSenseShield = false;// true;//
        /// <summary>
        /// 将value为FALSE的菜单隐藏显示，key为要隐藏的menuID
        /// </summary>
        public static Dictionary<uint, bool> shieldValue = new Dictionary<uint, bool>();

        public int step_length = 1;

        /// <summary>
        /// 是否压缩
        /// </summary>
        public bool isCompression = true;

        /// <summary>
        /// 
        /// </summary>
        public int decimalPlaces = 2;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="args"></param>
        private Program(string[] args)
        {
            Application.SetCompatibleTextRenderingDefault(false);
            Application.EnableVisualStyles();

            //先单独获取App基础配置
            configModel = XmlSerializeHelper.DESerializer<ConfigModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Config.xml", FileMode.Open));
            PdnResources.Initialize(configModel);

            this.splashForm = new SplashForm("");
            var width = Screen.PrimaryScreen.WorkingArea.Width;
            var height = Screen.PrimaryScreen.WorkingArea.Height;
            this.splashForm.Location = new System.Drawing.Point(width / 2 - 300, height / 2 - 200);
            this.splashForm.TopMost = true;
            this.splashForm.Show();
            this.splashForm.Update();

            this.args = args;

            Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            config.ConnectionStrings.ConnectionStrings["DBEntities"].ConnectionString = "Data Source=" + Application.StartupPath + @"\microscope.db3";
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection("connectionStrings");

            //用于EF暖机操作，以避免第一次度数据库过慢
            using (var dbcontext = new DBEntities())
            {
                var objectContext = ((IObjectContextAdapter)dbcontext).ObjectContext;
                var mappingCollection = (StorageMappingItemCollection)objectContext.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace);
                mappingCollection.GenerateViews(new List<EdmSchemaError>());
            }
        }

        /// <summary>
        /// 启动一个实例
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="requireAdmin">是否需要管理员权限</param>
        /// <param name="args">传递进来的参数</param>
        public static void StartNewInstance(IWin32Window parent, bool requireAdmin, string[] args)
        {
            StringBuilder allArgsSB = new StringBuilder();

            foreach (string arg in args)
            {
                allArgsSB.Append(' ');

                if (arg.IndexOf(' ') != -1)
                {
                    allArgsSB.Append('"');
                }

                allArgsSB.Append(arg);

                if (arg.IndexOf(' ') != -1)
                {
                    allArgsSB.Append('"');
                }
            }

            string allArgs;

            if (allArgsSB.Length > 0)
            {
                allArgs = allArgsSB.ToString(1, allArgsSB.Length - 1);
            }
            else
            {
                allArgs = null;
            }

            /*Shell.Execute(
                parent,
                Application.ExecutablePath,
                allArgs,
                requireAdmin ? ExecutePrivilege.RequireAdmin : ExecutePrivilege.AsInvokerOrAsManifest,
                ExecuteWaitType.ReturnImmediately);*/
        }

        /// <summary>
        /// 检查需要的文件是否存在
        /// </summary>
        /// <returns>
        /// 返回true则说明缺少东西
        /// </returns>
        private bool CheckForImportantFiles()
        {
            string[] requiredFiles =
                new string[]
                {
                    "PaintDotNet.Base.dll",
                    "PaintDotNet.Core.dll",
                    "PaintDotNet.Data.dll",
                    "PaintDotNet.Resources.dll",
                    "PaintDotNet.Strings.3.ZH-CN.resources",
                    "PaintDotNet.SystemLayer.dll"
                };

            string dirName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            List<string> missingFiles = null;

            foreach (string requiredFile in requiredFiles)
            {
                bool missing;

                try
                {
                    string pathName = Path.Combine(dirName, requiredFile);
                    FileInfo fileInfo = new FileInfo(pathName);
                    missing = !fileInfo.Exists;
                }

                catch (Exception)
                {
                    missing = true;
                }

                if (missing)
                {
                    if (missingFiles == null)
                    {
                        missingFiles = new List<string>();
                    }

                    missingFiles.Add(requiredFile);
                }
            }

            if (missingFiles == null)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public void Start()
        {
           
            /*if (CheckForImportantFiles())
            {
                Startup.StartNewInstance(null, true, args);
                return;
            }*/
            StartPart2();
        }

        /// <summary>
        /// 设置语言、地区等
        /// </summary>
        private void StartPart2()
        {
            string locale = Settings.CurrentUser.GetString(SettingNames.LanguageName, null);

            if (locale == null)
            {
                locale = Settings.SystemWide.GetString(SettingNames.LanguageName, null);
            }

            if (locale != null)
            {
                try
                {
                    CultureInfo ci = new CultureInfo(locale, true);
                    Thread.CurrentThread.CurrentUICulture = ci;
                }

                catch (Exception)
                {
                    // Don't want bad culture name to crash us
                }
            }

            // Parse command-line arguments
            if (this.args.Length == 1)
            {
                //Updates.UpdatesOptionsDialog.ShowUpdateOptionsDialog(null, false);
            }
            else
            {
                this.mainForm = new MainForm();
                Application.Run(this.mainForm);

                try
                {
                    this.mainForm.Dispose();
                }

                catch (Exception)
                {
                }

                this.mainForm = null;
            }
        }


        /// <summary>
        /// 程序主入口
        /// </summary>
        [STAThread]
        public static int Main(string[] args)
        {
            if (useSenseShield)
            {
                shieldValue.Clear();
                try
                {
                    //1.生成目录下需要有4个运行库，分别在x64和x86下，每个里面两个
                    //2.在C#项目里引用SlmRuntimeCsharp.dll
                    //3.插入加密狗，执行代码测试

                    //uint[] moduleIds = new uint[] {1, 100000,2,100013, 100066,5,100134, 230,231,232,233,1310,500,501};
                    uint[] moduleIds = DogDecrypting.decryptingModules(5 /*, moduleIds*/);//第一个参数固定为4
                                                                                          //this.label2.Text = string.Format("加密狗内许可模块号：{0}{1}", Environment.NewLine, string.Join(",", moduleIds));
                    foreach (uint menuId in moduleIds)
                        if (!shieldValue.ContainsKey(menuId))
                            shieldValue.Add(menuId, true);
                        else
                            shieldValue[menuId] = true;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message, "错误：", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return 0;
                }
            }
            //这是要求管理员权限的版本
            /*//当前用户是管理员的时候，直接启动应用程序
            //如果不是管理员，则使用启动对象启动程序，以确保使用管理员身份运行
            //获得当前登录的Windows用户标示
            System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent();
            //创建Windows用户主题
            Application.EnableVisualStyles();

            System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity);
            //判断当前登录用户是否为管理员
            if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator))
            {
                //如果是管理员，则直接运行
                //Application.EnableVisualStyles();
                //Application.Run(new Form1());

                instance = new Startup(args);
                instance.ModifySettingPrefix(args);
                instance.SystemReset();
                instance.InitSetting();
                instance.Start();

                // 为了测试用
                if (System.IO.File.Exists(Application.StartupPath + @"\1.txt"))
                    useSenseShield = true;

                if (useSenseShield)
                {
                    shieldValue.Clear();
                    try
                    {
                        //1.生成目录下需要有4个运行库，分别在x64和x86下，每个里面两个
                        //2.在C#项目里引用SlmRuntimeCsharp.dll
                        //3.插入加密狗，执行代码测试
                        uint[] moduleIds = DogDecrypting.decryptingModules(4*//*, moduleIds*//*);//第一个参数固定为4
                                                                                             //this.label2.Text = string.Format("加密狗内许可模块号：{0}{1}", Environment.NewLine, string.Join(",", moduleIds));

                        foreach (uint menuId in moduleIds)
                            if (!shieldValue.ContainsKey(menuId))
                                shieldValue.Add(menuId, true);
                            else
                                shieldValue[menuId] = true;
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.Message, "错误：", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return 0;
                    }
                }

                instance = new Startup(args);
                instance.ModifySettingPrefix(args);
                instance.SystemReset();
                instance.InitSetting();
                instance.Start();
            }
            else
            {
                //创建启动对象
                System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
                //设置运行文件
                startInfo.FileName = System.Windows.Forms.Application.ExecutablePath;
                //设置启动参数
                //startInfo.Arguments = String.Join(" ", Args);
                //设置启动动作,确保以管理员身份运行
                startInfo.Verb = "runas";
                try
                {
                    //如果不是管理员，则启动UAC
                    System.Diagnostics.Process.Start(startInfo);
                    //退出
                    System.Windows.Forms.Application.Exit();
                }
                catch
                {
                }
            }*/

            instance = new Program(args);
            instance.ModifySettingPrefix(args);
            instance.SystemReset();

            instance.isCompression = instance.configModel.isCompression;
            instance.decimalPlaces = instance.configModel.decimalPlacesNum;

            instance.InitSetting();
            instance.Start();
            return 0;
        }
        private void createData() {

            string filePath = Application.StartupPath + "\\Config\\Default\\basicTreeData.xml";
            MeasureMaintenanceTreeData measureMaintenanceTreeData = XmlSerializeHelper.DESerializer<MeasureMaintenanceTreeData>(FileOperationHelper.ReadStringFromFile(filePath, FileMode.Open));

            var id = 10;

            for (int i = 1; i <= measureMaintenanceTreeData.MeasureMaintenanceTreeDataList.Count; i++) 
            {
                switch (i) {
                    case 1:
                        string[] qianmangkongErjiInfor = {"初件淺盲孔" };
                        string[] celiangxianText = {"最大值","最小值","平均值", "上基材銅","下基材銅","上面銅+基材銅","下面銅+基材銅","上面銅","下面銅","左孔銅",
                    "右孔銅","上孔徑","下孔徑","孔底","孔底咬蝕量" };
                        for (int k = 0; k < qianmangkongErjiInfor.Length; k++) {

                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = qianmangkongErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);

                            id++;
                            for (int m = 0; m < celiangxianText.Length; m++) {
                                MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                pdata.FormulaParameterName = celiangxianText[m];
                                pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                pdata.FormulaParametersId = id.ToString();
                                data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);

                                id++;
                            }
                        }

                        break;
                    case 2:

                        string[] shenmangkongErjiInfor = { "深盲孔單層", "深盲孔雙層" };
                        string[] shenmangkongCeliangxianText1 = { "最大值", "最小值", "平均值", "上基材銅","下基材銅","上面銅+基材銅","下面銅+基材銅","上面銅","下面銅","左孔銅",
                    "右孔銅","上孔徑","下孔徑","孔底","孔底咬蝕量","孔深","左膠厚","右膠厚","左膠内縮","右膠内縮" };
                        string[] shenmangkongCeliangxianText2 = {"最大值", "最小值", "平均值", "上層上基材銅","上層下基材銅","上層上面銅+基材銅","上層下面銅+基材銅","上層上面銅","上層下面銅","上層左孔銅",
                    "上層右孔銅","上層上孔徑","上層下孔徑","上層孔底","上層孔底咬蝕量","上層孔深","上層左膠厚","上層右膠厚","上層左膠内縮","上層右膠内縮" ,"下層上基材銅","下層下基材銅","下層上面銅+基材銅"
                    ,"下層下面銅+基材銅","下層上面銅","下層下面銅","下層左孔銅",
                    "下層右孔銅","下層上孔徑","下層下孔徑","下層孔底","下層孔底咬蝕量","下層孔深","下層左膠厚","下層右膠厚","下層左膠内縮","下層右膠内縮" };
                        for (int k = 0; k < shenmangkongErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = shenmangkongErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k) {
                                case 0:
                                    for (int m = 0; m < shenmangkongCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = shenmangkongCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < shenmangkongCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = shenmangkongCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;

                            }
                        }

                        break;
                    case 3:
                        string[] sicengbanErjiInfor = { "四層板左","四層板右","四層板孔徑" };
                        string[] sicengbanCeliangxianText1 = { "最大值", "最小值", "平均值", "上基材銅", "下基材銅", "上面銅+基材銅", "下面銅+基材銅", "上面銅", "下面銅", "上粗糙度", "下粗糙度", "上孔銅", "中孔銅", "下孔銅" };
                        string[] sicengbanCeliangxianText2 = { "最大值", "最小值", "平均值", "上孔徑", "下孔徑" };
                        for (int k = 0; k < sicengbanErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = sicengbanErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < sicengbanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = sicengbanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < sicengbanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = sicengbanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 2:
                                    for (int m = 0; m < sicengbanCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = sicengbanCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                            break;
                    case 4:
                        string[] sancengbanErjiInfor = { "三層板左", "三層板右","三層板全" };
                        string[] sancengbanCeliangxianText1 = { "最大值", "最小值", "平均值", "上基材銅", "下基材銅", "上面銅+基材銅", "下面銅+基材銅", "上面銅", "下面銅", "粗糙度", "上孔銅", "下孔銅" };
                        string[] sancengbanCeliangxianText2 = { "最大值", "最小值", "平均值", "左側上基材銅", "左側下基材銅", "左側上面銅+基材銅", "左側下面銅+基材銅", "左側上面銅", "左側下面銅", "左側粗糙度", "左側上孔銅", "左側下孔銅",
                    "右側上基材銅", "右側下基材銅", "右側上面銅+基材銅", "右側下面銅+基材銅", "右側上面銅", "右側下面銅", "右側粗糙度", "右側上孔銅", "右側下孔銅","上孔徑","下孔徑"};
                        for (int k = 0; k < sancengbanErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = sancengbanErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < sancengbanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = sancengbanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < sancengbanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = sancengbanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 2:
                                    for (int m = 0; m < sancengbanCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = sancengbanCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                        break;
                    case 5:
                        string[] liangcengbanErjiInfor = { "兩層板左", "兩層板右","兩層板全" };
                        string[] liangcengbanCeliangxianText1 = { "最大值", "最小值", "平均值", "上基材銅", "下基材銅", "上面銅+基材銅", "下面銅+基材銅", "上面銅", "下面銅", "孔銅" };
                        string[] liangcengbanCeliangxianText2 = { "最大值", "最小值", "平均值", "左側上基材銅", "左側下基材銅", "左側上面銅+基材銅", "左側下面銅+基材銅", "左側上面銅", "左側下面銅", "左側孔銅",
                    "右側上基材銅", "右側下基材銅", "右側上面銅+基材銅", "右側下面銅+基材銅", "右側上面銅", "右側下面銅", "右側孔銅","上孔徑","下孔徑"};
                        for (int k = 0; k < liangcengbanErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = liangcengbanErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < liangcengbanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = liangcengbanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < liangcengbanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = liangcengbanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 2:
                                    for (int m = 0; m < liangcengbanCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = liangcengbanCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                        break;
                    case 6:
                        string[] shikeyinziErjiInfor = { "蝕刻因子單層", "蝕刻因子雙層" };
                        string[] shikeyinziCeliangxianText1 = { "最大值", "最小值", "平均值", "上幅", "下幅", "銅厚" };
                        string[] shikeyinziCeliangxianText2 = { "最大值", "最小值", "平均值", "上幅", "下幅", "銅厚", "縂厚" };
                        for (int k = 0; k < shikeyinziErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = shikeyinziErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < shikeyinziCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = shikeyinziCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < shikeyinziCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = shikeyinziCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                        break;
                    case 7:
                        string[] fanghanErjiInfor = { "meikaikou", "沒開口", "youkaikou", "有開口", "shuangcengtong", "雙層銅" };
                        string[] fanghanCeliangxianText1 = { "最大值", "最小值", "平均值", "銅厚", "防焊厚度", "PI上防焊厚度", "安全距離", "offset", "undercut" };
                        string[] fanghanCeliangxianText2 = { "最大值", "最小值", "平均值", "銅厚", "防焊厚度", "LPI厚度", "安全距離", "offset", "undercut", "防焊開口" };
                        string[] fanghanCeliangxianText3 = { "最大值", "最小值", "平均值", "銅厚", "綫上防焊", "LPI厚度", "安全距離", "offset", "undercut" };
                        for (int k = 0; k < fanghanErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = fanghanErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < fanghanCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = fanghanCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < fanghanCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = fanghanCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 2:
                                    for (int m = 0; m < fanghanCeliangxianText3.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = fanghanCeliangxianText3[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                        break;
                    case 8:
                        string[] gaoduchaErjiInfor = { "左側", "右側", "全" };
                        string[] gaoduchaCeliangxianText1 = { "最大值", "最小值", "平均值", "B", "B*" };
                        string[] gaoduchaCeliangxianText2 = { "最大值", "最小值", "平均值", "PAD銅厚1", "PI上防焊1", "PAD銅厚2", "PI上防焊2" };
                        for (int k = 0; k < gaoduchaErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = gaoduchaErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < gaoduchaCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = gaoduchaCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 1:
                                    for (int m = 0; m < gaoduchaCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = gaoduchaCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                                case 2:
                                    for (int m = 0; m < gaoduchaCeliangxianText2.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = gaoduchaCeliangxianText2[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                        break;
                    case 9:
                        string[] diegouErjiInfor = { "曡構" };
                        string[] diegouCeliangxianText1 = { "最大值", "最小值", "平均值", "單層厚", "縂厚" };
                        for (int k = 0; k < diegouErjiInfor.Length; k++)
                        {
                            MeasureMaintenanceTreeSpecificData data = new MeasureMaintenanceTreeSpecificData();
                            data.MeasureMaintenanceTreeSpecificDataId = id.ToString();
                            data.MeasureMaintenanceTreeSpecificDataParentId = measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificDataId;
                            data.MeasureMaintenanceTreeSpecificLevel = 2;
                            data.MeasureMaintenanceTreeSpecificName = diegouErjiInfor[k];
                            data.MeasureMaintenanceTreeSpecificSonDataList = new List<MeasureMaintenanceTreeSpecificData>();
                            data.MeasureMaintenanceTreeSpecificFormulaDataList = new List<MeasureMaintenanceFormulaParameters>();
                            measureMaintenanceTreeData.MeasureMaintenanceTreeDataList[i - 1].MeasureMaintenanceTreeSpecificSonDataList.Add(data);
                            id++;

                            switch (k)
                            {
                                case 0:
                                    for (int m = 0; m < diegouCeliangxianText1.Length; m++)
                                    {
                                        MeasureMaintenanceFormulaParameters pdata = new MeasureMaintenanceFormulaParameters();
                                        pdata.FormulaParameterName = diegouCeliangxianText1[m];
                                        pdata.FormulaParameterParentId = data.MeasureMaintenanceTreeSpecificDataId;
                                        pdata.FormulaParametersId = id.ToString();
                                        data.MeasureMaintenanceTreeSpecificFormulaDataList.Add(pdata);
                                        id++;
                                    }
                                    break;
                            }
                        }
                        break;
                }
            }

            string stageModelXml = XmlSerializeHelper.XmlSerialize<MeasureMaintenanceTreeData>(measureMaintenanceTreeData);
            FileOperationHelper.WriteStringToFile(stageModelXml, filePath, FileMode.Create);
        }

        /// <summary>
        /// 获取menuId对应的菜单是否显示
        /// </summary>
        /// <param name="menuId"></param>
        /// <returns></returns>
        public static bool getMenuIdVisible(int menuId)
        {
            if (shieldValue.ContainsKey((uint)menuId))
                return shieldValue[(uint)menuId];
            if (!useSenseShield)
                return true;

            return false;
        }

        /// <summary>
        /// 初始化配置信息
        /// </summary>
        private void InitSetting()
        {
            //设置->常规设置->用户信息
            //userInfo = XmlSerializeHelper.DESerializer<UserInfoModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\UserInfo.xml", FileMode.Open));
            //设置->网格设置
            //gridModel = XmlSerializeHelper.DESerializer<GridModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Grid.xml", FileMode.Open));
            //工具->自定义界面-快捷键配置
            hotkeyModel = XmlSerializeHelper.DESerializer<HotkeyModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Hotkey.xml", FileMode.Open));
            ////工具->工作流程
            //workFlowModel = XmlSerializeHelper.DESerializer<WorkFlowModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\WorkFlow.xml", FileMode.Open));
            //工具->自定义界面-快捷栏
            shortcutbarModel = XmlSerializeHelper.DESerializer<ShortcutbarModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Shortcutbar.xml", FileMode.Open));
            //工具->自定义界面-工具栏
            toolbarModel = XmlSerializeHelper.DESerializer<ToolbarModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Toolbar.xml", FileMode.Open));
            //// 设置-常规设置-辅助线样式信息
            //guideStyleModel = XmlSerializeHelper.DESerializer<GuideStyleModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\SetUp\\" + "GuideStyle.xml", FileMode.Open)); ;
            //// 工字线配置
            //workTypeStyleModel = XmlSerializeHelper.DESerializer<WorkTypeStyleModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\WorkType\\" + configModel.WorkType, FileMode.Open));
            ////标尺样式配置
            //rulerModel = XmlSerializeHelper.DESerializer<RulerModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Ruler.xml", FileMode.Open));
            ////电动偏光配置
            //motorizedLightModel = XmlSerializeHelper.DESerializer<MotorizedLightModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\MotorizedLightModel.xml", FileMode.Open));
            ////电压配置
            //voltageModel = XmlSerializeHelper.DESerializer<VoltageModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\VoltageModel.xml", FileMode.Open));
            //imageMenuModel = XmlSerializeHelper.DESerializer<ImageMenu>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\ParameterSaving\\ParameterSaving.xml", FileMode.Open));
            //测量样式配置
            measureStyleModel = XmlSerializeHelper.DESerializer<MeasureStyleModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Measure\\" + configModel.MeasurementStyle, FileMode.Open));
            //测量区域配置
            measureAreaModel = XmlSerializeHelper.DESerializer<MeasureAreaModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\MeasureArea\\" + configModel.MeasurementArea, FileMode.Open));

            string filePath = Application.StartupPath + "\\Config\\" + Program.instance.SettingPrefix + "\\FileNameRule.xml";

            if (!System.IO.File.Exists(filePath))
            {
                fileNameRule = new FileNameRule();
            }
            else
            {
                fileNameRule = XmlSerializeHelper.DESerializer<FileNameRule>(FileOperationHelper.ReadStringFromFile(filePath, FileMode.Open));
            }

            foreach (var item in fileNameRule.NameRuleList) 
            {
                if (item.isContinue) 
                {
                    continue;
                }
                item.NowNumber = 1;
            }

            //初始化提取，DB中保存的的标尺
            mic_rulersAll = mic_rulers_BLL.FindAll();
            //初始化标尺信息
            InitRulerInfo();
            //初始化App内的单位
            InitUnitInfo();
            //初始化单位对应的枚举数字
            CompanyEnumeration();
        }

        /// <summary>
        /// 初始化系统选择的单位的信息
        /// 单位对应的枚举数字
        /// </summary>
        public void CompanyEnumeration()
        {
            companyEnume = new Dictionary<string, int>();
            companyEnume.Add(PdnResources.GetString("MeasurementUnit.Inch"), 1);//英寸
            companyEnume.Add(PdnResources.GetString("Menu.cm.text"), 2);//厘米
            companyEnume.Add(PdnResources.GetString("Menu.Mm.text"), 3);//毫米
            companyEnume.Add(PdnResources.GetString("Menu.Micron.text"), 4);//微米
            companyEnume.Add(PdnResources.GetString("Menu.nanometer.text"), 5);//纳米
            companyEnume.Add(PdnResources.GetString("Menu.Pixel.text"), 6);//像素
        }

        /// <summary>
        /// 初始化系统选择的单位的信息
        /// 如果初始安装没有设置过，则默认微米
        /// </summary>
        public void InitUnitInfo()
        {
            if (configModel != null && configModel.Unit > 0)
            {
                measurementUnit = (MeasurementUnit)Enum.Parse(typeof(MeasurementUnit), configModel.Unit.ToString());
            }
            else
            {
                measurementUnit = MeasurementUnit.Micron;
            }
        }

        /// <summary>
        /// 初始化标尺信息，从数据库中读取
        /// 然后根据标尺的单位，换算出所有单位的数据
        /// </summary>
        public void InitRulerInfo()
        {
            rules.Clear();
            if (configModel != null)
            {
                for (int i = 0; i < Program.instance.mic_rulersAll.Count; i++)
                {
                    if (Program.instance.mic_rulersAll[i].id == configModel.RulerId)
                    {
                        ruleDB = Program.instance.mic_rulersAll[i];
                        break;
                    }
                }
                //ruleDB = mic_rulers_BLL.FindDefault(configModel.RulerId);
                if (ruleDB != null)
                {
                    //计算单位长度 比如0.05英寸/像素； 100纳米/像素；
                    double unitLength = (double)(ruleDB.physical_length / (decimal)ruleDB.pixel_length);
                    switch (ruleDB.ruler_units)
                    {
                        case (int)MeasurementUnit.Inch://英寸
                            rules.Add(MeasurementUnit.Inch, unitLength);                    //英寸
                            rules.Add(MeasurementUnit.Centimeter, 2.54 * unitLength);       //厘米
                            rules.Add(MeasurementUnit.Millimeter, 25.4 * unitLength);       //毫米
                            rules.Add(MeasurementUnit.Micron, 25400 * unitLength);          //微米
                            rules.Add(MeasurementUnit.Nano, 25400000 * unitLength);         //纳米
                            break;
                        case (int)MeasurementUnit.Centimeter://厘米
                            rules.Add(MeasurementUnit.Inch, 0.3937008 * unitLength);        //英寸
                            rules.Add(MeasurementUnit.Centimeter, unitLength);              //厘米
                            rules.Add(MeasurementUnit.Millimeter, 10 * unitLength);         //毫米
                            rules.Add(MeasurementUnit.Micron, 10000 * unitLength);          //微米
                            rules.Add(MeasurementUnit.Nano, 10000000 * unitLength);         //纳米
                            break;
                        case (int)MeasurementUnit.Millimeter://毫米
                            rules.Add(MeasurementUnit.Inch, 0.0393701 * unitLength);        //英寸
                            rules.Add(MeasurementUnit.Centimeter, 0.1 * unitLength);        //厘米
                            rules.Add(MeasurementUnit.Millimeter, unitLength);              //毫米
                            rules.Add(MeasurementUnit.Micron, 1000 * unitLength);           //微米
                            rules.Add(MeasurementUnit.Nano, 1000000 * unitLength);          //纳米
                            break;
                        case (int)MeasurementUnit.Micron://微米
                            rules.Add(MeasurementUnit.Inch, 0.00003937007874 * unitLength);        //英寸
                            rules.Add(MeasurementUnit.Centimeter, 0.0001 * unitLength);     //厘米
                            rules.Add(MeasurementUnit.Millimeter, 0.001 * unitLength);      //毫米
                            rules.Add(MeasurementUnit.Micron, unitLength);                  //微米
                            rules.Add(MeasurementUnit.Nano, 1000 * unitLength);             //纳米
                            break;
                        case (int)MeasurementUnit.Nano://纳米
                            rules.Add(MeasurementUnit.Inch, 3.9370e-8 * unitLength);        //英寸
                            rules.Add(MeasurementUnit.Centimeter, 1e-7 * unitLength);       //厘米
                            rules.Add(MeasurementUnit.Millimeter, 1e-6 * unitLength);       //毫米
                            rules.Add(MeasurementUnit.Micron, 0.001 * unitLength);          //微米
                            rules.Add(MeasurementUnit.Nano, unitLength);                    //纳米
                            break;
                        default:
                            ruleDB = null;
                            break;
                    }
                }
            }

            if (ruleDB == null)
            {
                //如果没有标尺的时候，默认1微米/像素
                rules.Add(MeasurementUnit.Inch, 0.0000394);     //英寸
                rules.Add(MeasurementUnit.Centimeter, 0.0001);  //厘米
                rules.Add(MeasurementUnit.Millimeter, 0.001);   //毫米
                rules.Add(MeasurementUnit.Micron, 1);           //微米
                rules.Add(MeasurementUnit.Nano, 1000);          //纳米
            }
            //设置文档标尺
            Document.defaultDpi = 1 / rules[MeasurementUnit.Inch];
        }

        /// <summary>
        /// 判断是否根据快捷方式参数修改界面
        /// </summary>
        /// <param name="argsArr"></param>
        /// <returns></returns>
        private bool ModifySettingPrefix(string[] argsArr)
        {
            if (argsArr.Count() == 2 && (0 == string.Compare(argsArr[0], "/personalConfig", true)))
            {
                string configName = argsArr[1].Replace("/", "");
                if (Directory.Exists(Application.StartupPath + "\\Config\\" + configName + "\\"))
                {
                    this.SettingPrefix = configName;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 系统复位
        /// </summary>
        /// <returns></returns>
        private void SystemReset()
        {
            //先单独获取App基础配置
            configModel = XmlSerializeHelper.DESerializer<ConfigModel>(FileOperationHelper.ReadStringFromFile(Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Config.xml", FileMode.Open));        

            //需要复位
            //if (configModel.LabelInformationReset == 1 || configModel.MeasurementInformationReset == 1 || configModel.LogReset == 1 ||
            //    configModel.ShortcutBarReset == 1 || configModel.ToolbarReset == 1 || configModel.HotKeyReset == 1)
            //{
            //    try
            //    {
            //        //标注初始化
            //        if (configModel.LabelInformationReset == 1)
            //        {
            //            string originalFilePath = Application.StartupPath + "\\Config\\Original\\Label\\Default.xml";
            //            string destFilePath = Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Label\\Default.xml";
            //            System.IO.File.Copy(originalFilePath, destFilePath, true);
            //            configModel.LabelInformationReset = 0;
            //        }
            //        //测量初始化
            //        if (configModel.MeasurementInformationReset == 1)
            //        {
            //            string originalFilePath = Application.StartupPath + "\\Config\\Original\\Measure\\Default.xml";
            //            string destFilePath = Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Measure\\Default.xml";
            //            System.IO.File.Copy(originalFilePath, destFilePath, true);
            //            configModel.MeasurementInformationReset = 0;
            //        }
            //        //log初始化
            //        if (configModel.LogReset == 1)
            //        {
            //            //未处理
            //            configModel.LogReset = 0;
            //        }
            //        //快捷栏初始化
            //        if (configModel.ShortcutBarReset == 1)
            //        {
            //            string originalFilePath = Application.StartupPath + "\\Config\\Original\\Shortcutbar.xml";
            //            string destFilePath = Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Shortcutbar.xml";
            //            System.IO.File.Copy(originalFilePath, destFilePath, true);
            //            configModel.ShortcutBarReset = 0;
            //        }
            //        //工具栏初始化
            //        if (configModel.ToolbarReset == 1)
            //        {
            //            string originalFilePath = Application.StartupPath + "\\Config\\Original\\Toolbar.xml";
            //            string destFilePath = Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Toolbar.xml";
            //            System.IO.File.Copy(originalFilePath, destFilePath, true);
            //            configModel.ToolbarReset = 0;
            //        }
            //        //快捷键初始化
            //        if (configModel.HotKeyReset == 1)
            //        {
            //            string originalFilePath = Application.StartupPath + "\\Config\\Original\\Hotkey.xml";
            //            string destFilePath = Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Hotkey.xml";
            //            System.IO.File.Copy(originalFilePath, destFilePath, true);
            //            configModel.HotKeyReset = 0;
            //        }

            //        string configModelXml = XmlSerializeHelper.XmlSerialize<ConfigModel>(configModel);
            //        FileOperationHelper.WriteStringToFile(configModelXml, Application.StartupPath + "\\Config\\" + SettingPrefix + "\\Config.xml", FileMode.Create);

            //    }
            //    catch (Exception)
            //    {
            //        MessageBox.Show(PdnResources.GetString("Menu.Systemresetfailure.text"));
            //    }
            //}
        }
    }
}