OTS/OTSIncAReportApp/1-UI/frmReportApp.cs


using OTS.WinFormsUI.Docking;
using OTSCommon.DBOperate.Model;
using OTSIncAReportApp._1_UI;
using OTSIncAReportApp.OTSRibbon;
using OTSIncAReportApp.OTSRstMgrFunction;
using OTSIncAReportApp.OTSSampleReportInfo;
using OTSIncAReportGraph.OTSIncAReportGraphFuncation;
using OTSIncAReprotCharts;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using OTSCommon;
using NLog.Fluent;

namespace OTSIncAReportApp
{
    public struct PostLogMsg
    {
        public int logLevel;//1 trace 2 debug 3info 4 warn 5 error 6 fatal
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = (int)2000)]
        public char[] logMessage;
    };
    /// <summary>
    /// 报告主窗体类
    /// </summary>
    public partial class frmReportApp : Form
    {
        #region 共享窗体对象--------------------------------------------------------------------------------------
        public frmMeasureRstMgr m_RstWindow = null;                             //测量结果，树控件窗体，属性Grid窗体
        public frmReportConditionChoose m_conditionChoose = null;                           //属性Grid窗体
        public frmSampleImage m_SImageWindow = null;                            //BSE窗体
        public frmTables m_TablesWindowandChart = null;                                //统计分析窗体
        public frmTables m_ParticlesListWindow = null;                         //颗粒列表窗体
        public frmTables m_OverviewWindow = null;                                //结果概况窗体
        public FormStandardLibraryInformation m_StandardLibrary = null;         //标准库窗体
        public frmReportSysConfig m_ReportSysConfigForm;                        //配置参数窗体

        #endregion //-----------------------------------------------------------------------------------------------

        #region 报告类结构相关------------------------------------------------------------------------------------
        NLog.Logger log;

        private PostLogMsg m_LogMsg;
        public const int MsgID = 0x0464;
        public const int LogMsgID = 0x0465;

        public OutputNlog m_OutputNlog;                                                     //日志类对象
        public ResultDataMgr m_rstDataMgr = null;                                              //DataMgrFun 对象， 此类是和调用C++ DataMGR交互数据
        public OTSRibbonFun m_RibbonFun = null;                                             //报告菜单相关操作类
  

        //当前工作结果
        public static RectangleF selectedRegion = new RectangleF();
        public RptConfigFile m_RptConfigFile;
        public string MoreSource = "";

        public string savePathName = "FIELD_FILES_REMEASURE";        //二次采集图像目录名
        Hashtable table;                                                                                            //国际化表

        string[] m_str_resultfilepaths;
        #endregion //-----------------------------------------------------------------------------------------------

        #region EChart相关变量------------------------------------------------------------------------------------
        //定义浏览器
        //public CefSharp.WinForms.ChromiumWebBrowser browser;
        //public CefSharp.WinForms.ChromiumWebBrowser browsermore;//多测量结果对比时使用

        public bool more = false;
        public bool trans = false;

        //定义浏览器
        //public CefSharp.WinForms.ChromiumWebBrowser browser_trio;
        //public CefSharp.WinForms.ChromiumWebBrowser browser_triomore;//多测量结果对比时使用

        public class JsEvent
        {
            public string MessageText { set; get; }
            public void ShowTest()
            {
                MessageBox.Show(MessageText);
            }
        }

        public JsEvent js = new JsEvent();
        public string m_reportname;
        public string data;
        public string dataCombin;
        public string type;
        public bool timerKG;

        #endregion //------------------------------------------------------------------------------------------------

        #region 各功能模块窗体 -----------------------------------------------------------------------------------
        /// <summary>
        /// 颗粒分布图
        /// </summary>
        public OTSIncAReportGraph.Controls.Control_DrawDistrbutionImageAndBSE im_Control_DrawDistrbutionImageAndBSE = null;

        /// <summary>
        /// 颗粒排序图
        /// </summary>
        public OTSIncAReportGraph.Controls.Control_DrawDistrbutionSortImage im_Control_DrawDistrbutionSortImage = null;

        /// <summary>
        /// 颗粒列表_分页
        /// </summary>
        public OTSIncAReportGrids.ParticlesGridDevidePage im_ParticlesGridDevidePage = null;



        /// <summary>
        /// 颗粒成份分布表
        /// </summary>
        public OTSIncAReportGrids.CompositionDistributionGrid im_CompositionDistributionGrid = null;

        /// <summary>
        /// 平均元素含量表
        /// </summary>
        public OTSIncAReportGrids.ElementCompositionAvgGrid im_ElementCompositionAvgGrid = null;

        /// <summary>
        /// 颗粒尺寸表
        /// </summary>
        public OTSIncAReportGrids.ParticlesSizeGrid im_ParticlesSizeGrid = null;

        /// <summary>
        /// 测量结果概况
        /// </summary>
        public OTSIncAReportGrids.ResultGrid im_ResultGrid = null;

        /// <summary>
        /// 颗粒成份图EChart
        /// </summary>
        public Control_ECharts.DEVChart_ParticlesComposition im_EChart_ParticlesComposition = null;

        /// <summary>
        /// 三元相图EChart
        /// </summary>
        public Control_ECharts.DEVChart_Trianglediagram im_EChart_Trianglediagram = null;
        /// <summary>
        /// 国标信息表方法一
        /// </summary>
        public OTSIncAReportGB.ChineseStandardABCDDS im_ChineseStandardABCDDS = null;

        /// <summary>
        /// 国标信息表方法二
        /// </summary>
        public OTSIncAReportGB.NationalStandardMethodTwo im_NationalStandardMethodTwo = null;
        /// <summary>
        /// 美标
        /// </summary>
        public OTSIncAReportGB.ASTMStandardABCDDS im_ASTMStandardABCDDS = null;
        /// <summary>
        /// 德标
        /// </summary>
        public OTSIncAReportGB.DINStandardABCDDS im_DINStandardABCDDS = null;
        /// <summary>
        /// yb/t 6156-2023
        /// </summary>
        public OTSIncAReportGB.YB6156ABCD im_YB6156ABCD = null;
        public List<Particle> GetSelectedParticles()
        {
            List<Particle> Particles = new List<Particle>();
            int tabIndex = (int)(m_conditionChoose.tabIndex);
            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:
                    foreach (var field in im_Control_DrawDistrbutionImageAndBSE.m_list_allDfield)
                    {
                        foreach (var dp in field.List_DParticle)
                        {
                            if (dp.IsSelect)
                            {
                                Particle particle = new Particle();
                                particle.FieldId = ((OTSIncAReportGraph.DisplayParticle)dp).FieldId;
                                particle.ParticleId = ((OTSIncAReportGraph.DisplayParticle)dp).ParticleId;
                                Particles.Add(particle);
                            }
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    Particles = im_ParticlesGridDevidePage.GetParticleslist_select();
                    break;
                default:
                    break;
            }


            return Particles;
        }
        #endregion //--------------------------------------------------------------------------------------------
        #region 拖拽提示面板相关字段
        private Panel dropHintPanel;
        private PictureBox dropIconBox;
        private Label dropHintLabel;
        private Label dropSubLabel;
        #endregion
        #region 窗体初始化及构造函数

        /// <summary>
        /// 窗体构造函数
        /// </summary>
        public frmReportApp()
        {
            m_OutputNlog = new OutputNlog();
            m_OutputNlog.Visible = true;
            log = NLog.LogManager.GetCurrentClassLogger();

               

            InitializeComponent();
           
            //初始化Ribbon类，操作Ribbon按钮的可用或者不可用
            m_RibbonFun = new OTSRibbonFun(this);
            //和DataMgr进行数据交互类
            m_rstDataMgr = new ResultDataMgr();
            //配置文件管理窗体
            m_ReportSysConfigForm = new frmReportSysConfig(this);
            //属性窗口
            m_conditionChoose = new frmReportConditionChoose(this);
            //树窗口
            m_RstWindow = new frmMeasureRstMgr(this);
            //分布图，排列图窗体
            m_SImageWindow = new frmSampleImage(this);
            //grid表格窗体
            m_TablesWindowandChart = new frmTables(this);
            m_ParticlesListWindow=new frmTables(this);
            m_OverviewWindow = new frmTables(this);
            //标准库窗体
            m_StandardLibrary = new FormStandardLibraryInformation (this);
            m_StandardLibrary = new FormStandardLibraryInformation(this);
            m_StandardLibrary.Visible = true;
            SetTag();
            #region 国际化语言
            Language lan = new Language(this);
            table = lan.GetNameTable(this.Name);
            #endregion
            // 初始化拖拽功能
            InitializeDragDropFeatures();
        }


        /// <summary>
        /// 为生成后没有Name的控件添加标签，为了国际化语言设置时可以找到这个控件
        /// </summary>
        protected void SetTag()
        {
            ribbonPanel3.Tag = "ribbonPanel3";
            ribbonPanel2.Tag = "ribbonPanel2";
            rbSelTool.Tag = "rbSelTool";
            rbChoiceTools.Tag = "rbChoiceTools";
            ribbonPanelOthers.Tag = "ribbonPanelOthers";
            ribbonTab1.Tag = "ribbonTab1";
            rbMenu.Tag = "rbMenu";

            dpbOpen.Tag = "dpbOpen";
            ribbonOrbMenuItem_Extremum.Tag = "ribbonOrbMenuItem_Extremum";
            dpbExport.Tag = "dpbExport";
            dpbTemplateEditing.Tag = "dpbTemplateEditing";
            ribbonOrbOptionButton1.Tag = "ribbonOrbOptionButton1";
            ribbonOrbMenuItem_InclusionsTraceability.Tag = "ribbonOrbMenuItem_InclusionsTraceability";
            ribbonOrbMenuItem_purity.Tag = "ribbonOrbMenuItem_purity";
            rbClose.Tag = "rbClose";
            rbChoiceParticle.Tag = "rbChoiceParticle";
            //dpbTemplateEditing.Tag = "dpbTemplateEditing";

        }

        /// <summary>
        /// 窗体构造函数,可接收多个测量结果文件
        /// </summary>
        public frmReportApp(string[] str_resultfilepaths)
        {
            
            m_OutputNlog = new OutputNlog();
            m_OutputNlog.Visible = true;
            Environment.CurrentDirectory = Path.GetDirectoryName(Application.ExecutablePath);


            log = NLog.LogManager.GetCurrentClassLogger();

            m_str_resultfilepaths = str_resultfilepaths;
            
            InitializeComponent();
          
            //初始化Ribbon类，操作Ribbon按钮的可用或者不可用
            m_RibbonFun = new OTSRibbonFun(this);
            //和DataMgr进行数据交互类
            m_rstDataMgr = new ResultDataMgr();//必须放在new frmReportSysConfig(this)前
            //配置文件管理窗体
            m_ReportSysConfigForm = new frmReportSysConfig(this);
            //属性窗口
            m_conditionChoose = new frmReportConditionChoose(this);
            //树窗口
            m_RstWindow = new frmMeasureRstMgr(this);
          

            //分布图，排列图窗体
            m_SImageWindow = new frmSampleImage(this);
            //grid表格窗体
            m_TablesWindowandChart = new frmTables(this);
            m_ParticlesListWindow=new frmTables(this);
            m_OverviewWindow =new frmTables(this);
            //标准库窗体
            m_StandardLibrary = new FormStandardLibraryInformation(this);
            m_StandardLibrary = new FormStandardLibraryInformation(this);
            m_StandardLibrary.Visible = true;
            SetTag();
            #region 国际化语言
            Language lan = new Language(this);
            table = lan.GetNameTable(this.Name);
            #endregion
            // 初始化拖拽功能
            InitializeDragDropFeatures();
        }



        /// <summary>
        /// 报告主窗体加载事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OTSReportApp_Load(object sender, EventArgs e)
        {
            log = NLog.LogManager.GetCurrentClassLogger();

            //------------- initialize the HMI of the main form.
            //if (Cef.IsInitialized == false)
            //{
            //    var lib = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"CefSharp\libcef.dll");
            //    var browser = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"CefSharp\CefSharp.BrowserSubprocess.exe");
            //    var locales = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"CefSharp\locales\");
            //    var res = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"CefSharp\");

            //    var libraryLoader = new CefLibraryHandle(lib);
            //    var isValid = !libraryLoader.IsInvalid;
            //    if (isValid)
            //    {
            //        //InitializeCef();
            //        var settings = new CefSettings
            //        {
            //            BrowserSubprocessPath = browser,
            //            LocalesDirPath = locales,
            //            ResourcesDirPath = res
                     
            //        };
            //        settings.Locale = "zh-CN";
            //        settings.CefCommandLineArgs.Add("disable-gpu", "1");
            //        Cef.Initialize(settings);
                    

            //    }


            //}

            //加载配置文件
          
            m_rstDataMgr.m_RptConfigFile.LoadDataFromFile();
            //设置菜单按钮，都为true状态
            m_RibbonFun.SetAllRibbonButnStatu(false);
            //激活标准库窗体
            this.m_StandardLibrary.Activate();
            //创建，树窗口，属性grid窗口，分布图，grid,chart窗体等。
            CreateNewWorkspaceWindow();

            this.m_OverviewWindow.Activate();

            
            //----------------end the initialization

            if (m_str_resultfilepaths != null)
            {
                string path = m_str_resultfilepaths[0].Replace("^", " ");
                if (Path.GetExtension(path) == ".rst")
                {
                    //构造函数直接接收传入的测量结果文件，并加载
                    for (int i = 0; i < m_str_resultfilepaths.Length; i++)
                    {
                        this.m_RstWindow.AddSampleResult(m_str_resultfilepaths[i].Replace("^", " "));
                    }
                }
                else if (Path.GetExtension(path) == ".prj")
                {
                    this.Cursor = Cursors.WaitCursor;
                    string strFilePath = System.IO.Path.GetDirectoryName(path);

                    System.IO.DirectoryInfo folder = new System.IO.DirectoryInfo(strFilePath);

                    foreach (System.IO.DirectoryInfo directory in folder.GetDirectories())
                    {
                        foreach (System.IO.FileInfo file in directory.GetFiles("*.rst"))
                        {
                            this.m_RstWindow.AddSampleResult(file.FullName);
                            this.m_StandardLibrary.DataRefresh();
                        }
                    }
                    this.Cursor = Cursors.Default;
                }
            }

            if (Language.ReadDefaultLanguage() == "EN")
            {
                rbHelp.Enabled = false;
            }
            else
            {
                rbHelp.Enabled = true;
            }
            m_RptConfigFile =RptConfigFile.GetRptConfig();         //报表程序的配置文件
            this.Text = "ReportApp(" + m_rstDataMgr.m_RptConfigFile.Systype.ToString() + ")";
        }

        #endregion

        #region Ribbon菜单按钮及菜单相关按按钮事件

        /// <summary>
        /// 新建按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ribTitleNewFile_Click(object sender, EventArgs e)
        {
            InitReportProState();
        }

        /// <summary>
        /// 初始伦报告加载
        /// </summary>
        public void InitReportProState()
        {
            //清除树窗体
            m_RstWindow.treeView1.Nodes.Clear();

            //清除属性Grid
            m_conditionChoose.m_sourceGrid = new OTSSourceGrid(m_conditionChoose);

            m_rstDataMgr.ResultFilesList.Clear();

            //清除各模块报表文件
            //m_ChartsWindow.Controls.Clear();
            m_TablesWindowandChart.Controls.Clear();
            m_ParticlesListWindow.Controls.Clear();
            m_OverviewWindow.Controls.Clear();
            m_SImageWindow.Controls.Clear();

            //再重新初始化下拉菜单和ribbon菜单中的按钮状态
            m_RibbonFun.SetAllRibbonButnStatu(false);
            im_Control_DrawDistrbutionImageAndBSE = null;
            im_Control_DrawDistrbutionSortImage = null;
            im_ParticlesGridDevidePage = null;
            im_CompositionDistributionGrid = null;
            im_ElementCompositionAvgGrid = null;
            im_ParticlesSizeGrid = null;
            im_ResultGrid = null;
        }


        /// <summary>
        /// 程序管理按钮点击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void RibbonOrbOptionButton1_Click(object sender, EventArgs e)
        {
            //程序管理
            m_ReportSysConfigForm.ShowDialog();
        }

        /// <summary>
        /// 打开报告项目文件按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbOpen_Click(object sender, EventArgs e)
        {
            
            string path = "";
            OpenFileDialog fileDialog = new OpenFileDialog();
            fileDialog.Filter = "text File|*.rst";
            fileDialog.RestoreDirectory = true; 
            if (fileDialog.ShowDialog() == DialogResult.OK)
            {
               
                path = System.IO.Path.GetFullPath(fileDialog.FileName);
                log.Info("begin to load the result!");
                Cursor = Cursors.WaitCursor;
                this.m_RstWindow.AddSampleResult(path);
                Cursor = Cursors.Default;
                this.m_StandardLibrary.DataRefresh();
            }
        }

        /// <summary>
        /// 全图匹配按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbAllImage_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);
           
            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:
                    int imgDisType=m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == 0)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.FullGraphMatch();
                            im_Control_DrawDistrbutionImageAndBSE.Invalidate();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            //排列图
                            im_Control_DrawDistrbutionSortImage.FullGraphMatch();
                            im_Control_DrawDistrbutionSortImage.Invalidate();
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 帧图边框按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbFrame_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);

            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:
                    int imgDisType = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == 0)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.ShowGridLine();
                            im_Control_DrawDistrbutionImageAndBSE.Invalidate();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 标尺按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbStaff_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);

            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:
                    int imgDisType = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == 0)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.ShowRulerControl();
                            im_Control_DrawDistrbutionImageAndBSE.Invalidate();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            im_Control_DrawDistrbutionSortImage.ShowRulerControl();
                            im_Control_DrawDistrbutionSortImage.Invalidate();
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 恢复按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbRenew_Click(object sender, EventArgs e)
        {
            rbRenewFun(false, 0, 0);
        }

        public void rbRenewFun(bool isReview, int FieldId, int ParticleId)
        {
            int tabIndex = (int)m_conditionChoose.tabIndex;
            int DisType = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:
                    if (DisType == (int)IMAGE_DISPLAY_TYPE.DISTRIBUTION)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.ShowRulerControl(false);
                            im_Control_DrawDistrbutionImageAndBSE.ShowGridLine(false);
                            im_Control_DrawDistrbutionImageAndBSE.Invalidate();

                            m_SImageWindow.Controls.Clear();
                            im_Control_DrawDistrbutionImageAndBSE = new OTSIncAReportGraph.Controls.Control_DrawDistrbutionImageAndBSE(this);
                            im_Control_DrawDistrbutionImageAndBSE.isReView = isReview;
                            im_Control_DrawDistrbutionImageAndBSE.reViewFieldId = FieldId;
                            im_Control_DrawDistrbutionImageAndBSE.reViewParticleId = ParticleId;
                            im_Control_DrawDistrbutionImageAndBSE.Dock = DockStyle.Fill;
                            m_SImageWindow.Controls.Add(im_Control_DrawDistrbutionImageAndBSE);
                            m_SImageWindow.Activate();
                            im_Control_DrawDistrbutionImageAndBSE.ShowSourceName = "";
                            im_Control_DrawDistrbutionImageAndBSE.DrawDistrbutionImageAndBSE_ByQuery(m_conditionChoose.m_conditionData);
                            im_Control_DrawDistrbutionImageAndBSE.SetSelectParticle(GetSelectedParticles());

                            ConditionItem imgType = m_conditionChoose.m_CurrentConditions[OTS_REPORT_PROP_GRID_ITEMS.IMAGE_TYPE];
                            //切换分布图显示方式
                            DISTRIBUTION_IMAGE_SHOW_MODE t = (DISTRIBUTION_IMAGE_SHOW_MODE)imgType.itemVal;
                            im_Control_DrawDistrbutionImageAndBSE.SetShowMode(t);

                            //并删除排列图
                            im_Control_DrawDistrbutionSortImage = null;
                        }
                    }
                    if (DisType == (int)IMAGE_DISPLAY_TYPE.IMAGE_GRID)
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            //排序图
                            im_Control_DrawDistrbutionSortImage.ShowRulerControl(false);
                            im_Control_DrawDistrbutionSortImage.Invalidate();

                            m_SImageWindow.Controls.Clear();
                            im_Control_DrawDistrbutionSortImage = new OTSIncAReportGraph.Controls.Control_DrawDistrbutionSortImage(this);
                            im_Control_DrawDistrbutionSortImage.Dock = DockStyle.Fill;
                            m_SImageWindow.Controls.Add(im_Control_DrawDistrbutionSortImage);
                            m_SImageWindow.Activate();
                            im_Control_DrawDistrbutionSortImage.ShowSourceName = "";
                            im_Control_DrawDistrbutionSortImage.GetDistrbutionSortimage_ByQuery(m_conditionChoose.m_CurrentConditions);
                            im_Control_DrawDistrbutionSortImage.SetSelectParticle(GetSelectedParticles());
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 反选操作按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbReverseSelection_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);

            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:

                    int imgDisType = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == 0)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.ReverseSelection();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            im_Control_DrawDistrbutionSortImage.ReverSeSelection();
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 圆形工具按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbCircular_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);

            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:

                    IMAGE_DISPLAY_TYPE imgDisType = (IMAGE_DISPLAY_TYPE)m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == IMAGE_DISPLAY_TYPE.DISTRIBUTION)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.MultiSelect_Ellipse();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            im_Control_DrawDistrbutionSortImage.MultiSelect_Ellipse();
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 矩形工具按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbRectangle_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);

            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:
                    int imgDisType = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == 0)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.MultiSelect_Rectangle();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            im_Control_DrawDistrbutionSortImage.MultiSelect_Rectangle();
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 取消多边形选择工具按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbCancel_Click(object sender, EventArgs e)
        {
            int tabIndex = (int)(m_conditionChoose.tabIndex);
            switch (tabIndex)
            {
                case (int)DisplayPicutureType.AnalyzeImg:

                    int imgDisType = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTS_REPORT_PROP_GRID_ITEMS.IMAGE_DISPLAY_TYPE);
                    if (imgDisType == 0)
                    {
                        if (im_Control_DrawDistrbutionImageAndBSE != null)
                        {
                            //分布图
                            im_Control_DrawDistrbutionImageAndBSE.DeselectAllParticle();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            im_Control_DrawDistrbutionSortImage.DeselectAllParticle();
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeSheetandChart:
                    break;
                default:
                    break;
            }
        }
        static OTSImageDisHelp ReportFun;

        public RptConfigFile RptConfigFile { get => m_RptConfigFile; set => m_RptConfigFile = value; }

        /// <summary>
        /// 二次采集按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbReMeasure_Click(object sender, EventArgs e)
        {

            if (ReportFun == null)
            {
                //resultFile = m_rstDataMgr.CurResultFile;
                ReportFun = new OTSImageDisHelp(m_rstDataMgr.CurResultFile);
            }

            //二次测量参数页面
            frmReMeasure frmReMeasure = new frmReMeasure(ReportFun, this);
            frmReMeasure.ShowDialog();
        }

        #endregion


        #region 自定义封装相关方法
        /// <summary>
        /// 新建一个工作区域
        /// </summary>
        public void CreateNewWorkspaceWindow()
        {
            //创建测量数据窗口
            CreateCOverviewWindow();
            //创建测量数据窗口
            CreateCTablesWindow();
            //创建图表窗口
            CreateCSheetandChartWindow();
            //Show BSE图窗口
            CreateSampleWindow();

            //StandardLibraryWindow();

            m_OutputNlog.Show(DockWindowPanel, OTS.WinFormsUI.Docking.DockState.DockRight);
            m_OutputNlog.Visible = true;
            m_StandardLibrary.Show(DockWindowPanel, DockState.DockLeft);
            m_RstWindow.Show(DockWindowPanel, OTS.WinFormsUI.Docking.DockState.DockLeft);
            m_conditionChoose.Show(DockWindowPanel);
           
            DockWindowPanel.DockLeftPortion = 300;
            DockWindowPanel.DockRightPortion = 351;
        }

        /// <summary>
        /// 创建新的窗体
        /// </summary>
        /// <param name="WorkWindow"></param>
        /// <param name="iType"></param>
        /// <returns></returns>
        private OTS.WinFormsUI.Docking.DockContent CreateNewDocument(OTS.WinFormsUI.Docking.DockContent WorkWindow, DisplayPicutureType iType)
        {
            string text = "";



            if (iType == DisplayPicutureType.AnalyzeImg)
            {
                text = table["analysisdiagram"].ToString(); ;
            }
            else if (iType == DisplayPicutureType.AnalyzeDataTable)
            {
                text = table["analysisdatasheet"].ToString();
            }
            else if (iType == DisplayPicutureType.AnalyzeSheetandChart)
            {
                text = table["analysisdatasheetandchart"].ToString();
            }
            else if (iType == DisplayPicutureType.OverviewTable)
            {
                text = table["overviewtable"].ToString();
            }
            else
            {
                text = "标准库信息";
            }
           

            WorkWindow.Text = text;
            return WorkWindow;

        }

        /// <summary>
        /// 创建样品BSE图窗口
        /// </summary>
        public void CreateSampleWindow()
        {
            if (null == m_SImageWindow)
            {
                m_SImageWindow = new frmSampleImage(this);
            }
            m_SImageWindow = (frmSampleImage)CreateNewDocument(m_SImageWindow, DisplayPicutureType.AnalyzeImg);
            if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            {
                m_SImageWindow.MdiParent = this;
                m_SImageWindow.Show();
            }
            else
            {
                m_SImageWindow.Show(DockWindowPanel);
            }
        }
        private void StandardLibraryWindow()
        {
            if (null == m_StandardLibrary)
            {
                m_StandardLibrary = new FormStandardLibraryInformation(this);
            }

            m_StandardLibrary = (FormStandardLibraryInformation)CreateNewDocument(m_StandardLibrary, DisplayPicutureType.AnalyzeStandardLibrary);

            if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            {
                m_StandardLibrary.MdiParent = this;
                m_StandardLibrary.Show();
            }
            else
            {
                m_StandardLibrary.Show(DockWindowPanel);
            }
            //m_StandardLibrary.Text = "标准库数据";
            //if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            //{
            //    m_StandardLibrary.MdiParent = this;
            //    m_StandardLibrary.Show();
            //}
            //else
            //{
            //    m_StandardLibrary.Show(DockWindowPanel);
            //}
        }


        /// <summary>
        /// 创建Grid表格窗体
        /// </summary>
        private void CreateCSheetandChartWindow()
        {
            if (null == m_TablesWindowandChart)
            {
                m_TablesWindowandChart = new frmTables(this);
            }

            m_TablesWindowandChart = (frmTables)CreateNewDocument(m_TablesWindowandChart, DisplayPicutureType.AnalyzeSheetandChart);

            if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            {
                m_TablesWindowandChart.MdiParent = this;
                m_TablesWindowandChart.Show();
            }
            else
            {
                m_TablesWindowandChart.Show(DockWindowPanel);
            }
        }
        /// <summary>
        /// 创建Grid表格窗体
        /// </summary>
        private void CreateCTablesWindow()
        {
            if (null == m_ParticlesListWindow)
            {
                m_ParticlesListWindow = new frmTables(this);
            }

            m_ParticlesListWindow = (frmTables)CreateNewDocument(m_ParticlesListWindow, DisplayPicutureType.AnalyzeDataTable);

            if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            {
                m_ParticlesListWindow.MdiParent = this;
                m_ParticlesListWindow.Show();
            }
            else
            {
                m_ParticlesListWindow.Show(DockWindowPanel);
            }

        }
        ///// <summary>
        ///// 创建chart图表窗体
        ///// </summary>
        //private void CreateChartsWindow()
        //{
        //    if (null == m_ChartsWindow)
        //    {
        //        m_ChartsWindow = new frmCharts(this);
        //    }

        //    m_ChartsWindow = (frmCharts)CreateNewDocument(m_ChartsWindow, DisplayPicutureType.AnalyzeSheetandChart);

        //    if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
        //    {
        //        m_ChartsWindow.MdiParent = this;
        //        m_ChartsWindow.Show();
        //    }
        //    else
        //    {
        //        m_ChartsWindow.Show(DockWindowPanel);
        //    }
        //}


        /// <summary>
        /// 创建结果概况窗体
        /// </summary>
        private void CreateCOverviewWindow()
        {
            if (null == m_OverviewWindow)
            {
                m_OverviewWindow = new frmTables(this);
            }

            m_OverviewWindow = (frmTables)CreateNewDocument(m_OverviewWindow, DisplayPicutureType.OverviewTable);

            if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            {
                m_OverviewWindow.MdiParent = this;
                m_OverviewWindow.Show();
            }
            else
            {
                m_OverviewWindow.Show(DockWindowPanel);
            }

        }

        /// <summary>
        /// 新建样品时提示保存样品信息Messagebox 
        /// </summary>
        /// <returns></returns>
        public int ShowSaveInfoMsgBox()
        {
            //是否保存修改信息,保存样品信息提示
            int iRev = (int)MessageBox.Show("Save modification information", "Tips", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning);
            if (iRev == (int)DialogResult.Yes)
            {
                return (int)MessageBoxRev.DIALOG_YES;
            }
            else if (iRev == (int)DialogResult.No)
            {
                return (int)MessageBoxRev.DIALOG_NO;
            }
            else
            {
                return (int)MessageBoxRev.DIALOG_CANCEL;
            }
        }

        #endregion

        #region 系统菜单相关功能
        private void ribbonOrbMenuItem4_Click(object sender, EventArgs e)
        {
            MemoryManagementClass.FlushMemory();
            //系统菜单，输出
            OTSReport_Export oe = new OTSReport_Export(this,true);
            oe.ShowDialog();
            oe.Dispose();
            oe = null;
            MemoryManagementClass.FlushMemory();
        }


        private void frmReportApp_FormClosed(object sender, FormClosedEventArgs e)
        {
            //string strDBpathGB =m_DataMgrFun. resultFilesList[0].FilePath + "\\" + "ReportGBDB.db"; 
            //File.Delete(strDBpathGB);


            //Process.GetCurrentProcess().Kill();
            //this.Hide();//打开EChar图后，回收浏览器资源暂卡，为达到操作流畅性，先隐藏窗体再回收资源
           
            //this.Invoke(new Action(() =>
            //{
            //    if (Cef.IsInitialized)
            //        Cef.Shutdown();
            //}));

            
        }


        #endregion

        private void dpbOpen_Click(object sender, EventArgs e)
        {
            OpenProFile();
        }

        /// <summary>
        /// 打开报告项目工程文件，封装方法
        /// </summary>
        /// <returns></returns>
        private bool OpenProFile()
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Measure Project Files((*.prj)|*.prj";
            openFileDialog.ValidateNames = true;
            openFileDialog.CheckPathExists = true;
            openFileDialog.CheckFileExists = true;
            openFileDialog.Multiselect = false;
            CHistoryPrj historyPrj = new CHistoryPrj();
            historyPrj.loadHistoryPath();
            string strLatestPrjFolder = historyPrj.GetLatestPrjFolder();
            openFileDialog.InitialDirectory = strLatestPrjFolder;
            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.Cursor = Cursors.WaitCursor;
                string strFilePath = System.IO.Path.GetDirectoryName(openFileDialog.FileName);

                System.IO.DirectoryInfo folder = new System.IO.DirectoryInfo(strFilePath);

                foreach (System.IO.DirectoryInfo directory in folder.GetDirectories())
                {
                    foreach (System.IO.FileInfo file in directory.GetFiles("*.rst"))
                    {
                        this.m_RstWindow.AddSampleResult(file.FullName);
                        this.m_StandardLibrary.DataRefresh();
                    }
                }
                this.Cursor = Cursors.Default;
                return true;
            }

            else return false;
        }

        private void frmReportApp_FormClosing(object sender, FormClosingEventArgs e)
        {
            
        }

        private void ribbonOrbMenuItem_Extremum_Click(object sender, EventArgs e)
        {
            try
            {
                System.Diagnostics.Process p = System.Diagnostics.Process.Start(".\\OTSExtremum.exe");
                p.WaitForExit();
            }
            catch (Exception ex)
            {
                log.Error("OTSExtremum:" + ex.ToString());
            }
        }
        protected override void DefWndProc(ref Message m)
        {
            switch (m.Msg)
            {
                
                case LogMsgID:
                    m_LogMsg = new PostLogMsg();

                    m_LogMsg = (PostLogMsg)Marshal.PtrToStructure(m.LParam, typeof(PostLogMsg));
                    var log = NLog.LogManager.GetCurrentClassLogger();
                    string s = GetString(m_LogMsg.logMessage);
                    switch (m_LogMsg.logLevel)
                    {
                        case 1:
                            log.Trace(s);
                            break;
                        case 2:
                            log.Debug(s);
                            break;
                        case 3:
                            log.Info(s);
                            break;
                        case 4:
                            log.Warn(s);
                            break;
                        case 5:
                            log.Error(s);
                            break;
                        case 6:
                            log.Fatal(s);
                            break;
                    }

                    break;
                default:
                    base.DefWndProc(ref m);
                    break;
            }
        }
        private string GetString(char[] csStr)
        {
            int ilen = csStr.Length;
            string csName = new string(csStr);                //MSTMsg.STMSampleStu.cSName
            csName.IndexOf('\0');
            csName = csName.Substring(0, csName.IndexOf('\0'));
            return csName;
        }

     

        private void Backup_Click(object sender, EventArgs e)
        {

            //OTSImageDisHelp m_ReportFun = null;
            //public OTSImageDisHelp ReportFun { get => m_ReportFun; set => m_ReportFun = value; }

            //var ReportFun = new OTSImageDisHelp(m_rstDataMgr.CurResultFile);

            if (BackupDatabase())
            {
                MessageBox.Show("Backup succeeded");
            }
            else
            {
                MessageBox.Show("Backup failed");
            }
        }

        private bool BackupDatabase()
        {
            //创建备份数据库文件夹
            string sourcePath = m_rstDataMgr.CurResultFile.FilePath + "\\FIELD_FILES\\Inclusion.db";//源文件路径
            string sourceName = "Inclusion.db";//源文件名称
            string folderPath = m_rstDataMgr.CurResultFile.FilePath + "\\FIELD_FILES\\Backups";//目标文件夹
            string Fields = "";
            for (int i = 1; i < 201; i++)
            {
                if (System.IO.Directory.Exists(folderPath + i.ToString()))
                {
                    Fields = folderPath + i.ToString();
                    continue;
                }
                else
                {
                    System.IO.Directory.CreateDirectory(folderPath + i.ToString());
                    Fields = folderPath + i.ToString();
                    break;
                }
            }
            if (Fields == "")
            {
                return false;
            }
            //复制数据库文件
            string targetPath = Path.Combine(Fields, sourceName);
            FileInfo file = new FileInfo(sourcePath);
            if (file.Exists)
            {
                file.CopyTo(targetPath, true);
            }

            return true;
        }

        private void ribbonOrbMenuItem_InclusionsTraceability_Click(object sender, EventArgs e)
        {
            string sou = m_conditionChoose.m_CurrentConditions[OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE].itemDisplayVal.ToString();
            if(sou.Contains("+"))
            {
                MessageBox.Show("This function does not support multiple samples!");
                return;
            }
            int index = m_conditionChoose.m_conditionData.GetComboDownListIndexByItemName(OTSSampleReportInfo.OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE);
            try
            {
                System.Diagnostics.Process p = System.Diagnostics.Process.Start(".\\OTSInclusionsTraceability.exe", "\""+ m_rstDataMgr.ResultFilesList[index].FilePath+ "\"");
                p.WaitForExit();
            }
            catch (Exception ex)
            {
                log.Error("InclusionsTraceability :" + ex.ToString());
            }
        }

        private void rbClose_Click(object sender, EventArgs e)
        {
           m_RstWindow. RemoveSample();
            //m_StandardLibrary.DataDeletion();
        }

        private void ribbonOrbMenuItem_purity_Click(object sender, EventArgs e)
        {
            string sou = m_conditionChoose.m_CurrentConditions[OTS_REPORT_PROP_GRID_ITEMS.DATA_SOURCE].itemDisplayVal.ToString();
            if (sou.Contains("+"))
            {
                MessageBox.Show("This function does not support multiple samples!");
                return;
            }
            try
            {
                _1_UI.GBCalculate.Purity purity = new _1_UI.GBCalculate.Purity(this);
                purity.Show();
            }
            catch (Exception ex)
            {
                log.Error("purity:" + ex.ToString());
                MessageBox.Show("purity启动失败！");
            }
        }

        private void dpbTemplateEditing_Click(object sender, EventArgs e)
        {
            MemoryManagementClass.FlushMemory();
            //系统菜单，输出
            OTSReport_Export oe = new OTSReport_Export(this, false);
            oe.ShowDialog();
            oe.Dispose();
            oe = null;
            MemoryManagementClass.FlushMemory();
        }

        private void toolTip1_Popup(object sender, PopupEventArgs e)
        {

        }

        private void DockWindowPanel_ActiveContentChanged(object sender, EventArgs e)
        {

        }

        private void rbOpenprj_Click(object sender, EventArgs e)
        {
            OpenProFile();
        }











        
        private void frmReportApp_DragDrop(object sender, DragEventArgs e)
        {
            // 隐藏拖拽提示面板
            HideDropHintPanel();
            try
            {
                if (e.Data.GetDataPresent(DataFormats.FileDrop))
                {
                    string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
                    // 过滤出有效的文件
                    var validFiles = files.Where(f =>
                        Path.GetExtension(f)?.ToLower() == ".prj" ||
                        Path.GetExtension(f)?.ToLower() == ".rst").ToList();

                    if (!validFiles.Any())
                    {
                        MessageBox.Show("未找到有效的 .prj 或 .rst 文件", "提示",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }
                    this.Cursor = Cursors.WaitCursor;
                    try
                    {
                        ProcessDroppedFiles(validFiles);
                    }
                    finally
                    {
                        this.Cursor = Cursors.Default;
                    }
                }
            }
            catch (Exception ex)
            {
                this.Cursor = Cursors.Default;
                log.Error(ex, $"处理拖拽文件时发生错误: {ex.Message}");
                MessageBox.Show($"处理文件时发生错误: {ex.Message}", "错误",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void frmReportApp_DragEnter(object sender, DragEventArgs e)
        {
            try
            {
                // 检查拖放的数据是否包含文件
                if (e.Data.GetDataPresent(DataFormats.FileDrop))
                {
                    // 获取拖放的文件
                    string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
                    // 检查是否有有效的.prj文件
                    bool hasValidFile = files.Any(f =>
                        !string.IsNullOrEmpty(Path.GetExtension(f)) &&
                        (Path.GetExtension(f).ToLower() == ".prj"|| Path.GetExtension(f).ToLower() == ".rst"));
                    if (hasValidFile)
                    {
                        // 显示拖拽提示面板
                        ShowDropHintPanel();
                        // 显示复制光标
                        e.Effect = DragDropEffects.Copy;
                        return;
                    }
                }
            }
            catch (Exception ex)
            {
                log?.Warn($"DragEnter处理异常: {ex.Message}");
            }
            // 隐藏拖拽提示面板并设置无效文件类型
            HideDropHintPanel();
            e.Effect = DragDropEffects.None;
        }
        /// <summary>
        /// 初始化拖拽提示面板
        /// </summary>
        private void InitializeDropHintPanel()
        {
            // 创建主面板
            dropHintPanel = new Panel();
            dropHintPanel.Name = "dropHintPanel";
            dropHintPanel.BackColor = Color.FromArgb(200, Color.RoyalBlue);
            dropHintPanel.Dock = DockStyle.Fill;
            dropHintPanel.Visible = false;
            dropHintPanel.BorderStyle = BorderStyle.None;
            // 创建主提示文本
            dropHintLabel = new Label();
            dropHintLabel.Text = "拖拽 .prj 或 .rst文件到此处打开项目";
            dropHintLabel.AutoSize = false;
            dropHintLabel.TextAlign = ContentAlignment.MiddleCenter;
            dropHintLabel.Font = new Font(this.Font.FontFamily, 18, FontStyle.Bold);
            dropHintLabel.ForeColor = Color.White;
            dropHintLabel.Dock = DockStyle.Fill;
            dropHintLabel.BackColor = Color.Transparent;













            // 创建辅助说明文本
            dropSubLabel = new Label();
            dropSubLabel.Text = "松开鼠标按键即可打开项目";
            dropSubLabel.AutoSize = false;
            dropSubLabel.TextAlign = ContentAlignment.MiddleCenter;
            dropSubLabel.Font = new Font(this.Font.FontFamily, 12, FontStyle.Regular);
            dropSubLabel.ForeColor = Color.LightGray;
            dropSubLabel.Dock = DockStyle.Bottom;
            dropSubLabel.Height = 30;
            dropSubLabel.BackColor = Color.Transparent;

            // 组装控件
            dropHintPanel.Controls.Add(dropIconBox);
            dropHintPanel.Controls.Add(dropHintLabel);
            dropHintPanel.Controls.Add(dropSubLabel);

            // 将面板添加到窗体中并置于顶层
            this.Controls.Add(dropHintPanel);
            dropHintPanel.BringToFront();
        }

        /// <summary>
        /// 显示拖拽提示面板
        /// </summary>
        private void ShowDropHintPanel()
        {
            if (dropHintPanel == null) return;

            dropHintPanel.Visible = true;
            dropHintPanel.BringToFront();
        }

        /// <summary>
        /// 隐藏拖拽提示面板
        /// </summary>
        private void HideDropHintPanel()
        {
            if (dropHintPanel == null) return;

            dropHintPanel.Visible = false;
        }
        /// <summary>
        /// 初始化拖拽功能
        /// </summary>
        private void InitializeDragDropFeatures()
        {
            this.AllowDrop = true;
            InitializeDropHintPanel();
        }






        private void frmReportApp_DragOver(object sender, DragEventArgs e)
        {
            if (dropHintPanel != null && dropHintPanel.Visible)
            {
                e.Effect = DragDropEffects.Copy;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void frmReportApp_DragLeave(object sender, EventArgs e)
        {
            HideDropHintPanel();
        }
        private void ProcessDroppedFiles(List<string> files)
        {
            bool processed = false;

            foreach (string filePath in files)
            {
                try
                {
                    string extension = Path.GetExtension(filePath).ToLower();

                    if (extension == ".prj")
                    {
                        ProcessProjectFile(filePath);
                        processed = true;
                        break; // 只处理第一个项目文件
                    }
                    else if (extension == ".rst")
                    {
                        log.Info($"开始加载结果文件: {filePath}");
                        this.m_RstWindow.AddSampleResult(filePath);
                        this.m_StandardLibrary.DataRefresh();
                        processed = true;
                    }
                }
                catch (Exception ex)
                {
                    log.Error(ex, $"处理文件 {filePath} 时发生错误: {ex.Message}");
                    MessageBox.Show($"处理文件 {filePath} 时发生错误: {ex.Message}", "错误",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }

            if (!processed && files.Any())
            {
                MessageBox.Show("未能成功处理任何文件", "提示",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void ProcessProjectFile(string projectFilePath)
        {
            try
            {
                string directoryPath = Path.GetDirectoryName(projectFilePath);
                DirectoryInfo folder = new DirectoryInfo(directoryPath);

                int loadedCount = 0;
                foreach (System.IO.DirectoryInfo directory in folder.GetDirectories())
                {
                    foreach (System.IO.FileInfo file in directory.GetFiles("*.rst"))
                    {
                        this.m_RstWindow.AddSampleResult(file.FullName);
                        loadedCount++;
                    }
                }

                if (loadedCount > 0)
                {
                    this.m_StandardLibrary.DataRefresh();
                    log.Info($"从项目文件加载了 {loadedCount} 个结果文件");
                }
                else
                {
                    log.Warn("项目文件夹中未找到 .rst 文件");
                    MessageBox.Show("项目文件夹中未找到 .rst 文件", "提示",
                        MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"处理项目文件时出错: {ex.Message}", ex);
            }
        }
    }
}