using CefSharp;
using CefSharp.WinForms;
using OTS.WinFormsUI.Docking;
using OTSCommon.Model;
using OTSIncAReportApp.OTSDataMgrFunction;
using OTSIncAReportApp.OTSRibbon;
using OTSIncAReportApp.OTSSampleReportInfo;
using OTSIncAReportApp.SysMgrTools;
using OTSIncAReportGraph;
using OTSIncAReportGraph.OTSIncAReportGraphFuncation;
using OTSIncAReprotCharts;

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows.Forms;

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 frmCharts m_ChartsWindow = null;                                //图表窗体
        public frmTables m_TablesWindow = 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.EChart_ParticlesComposition im_EChart_ParticlesComposition = null;

        /// <summary>
        /// 三元相图EChart
        /// </summary>
        public Control_ECharts.EChart_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;
        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 窗体初始化及构造函数

        /// <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(this);
            //配置文件管理窗体
            m_ReportSysConfigForm = new frmReportSysConfig(this);
            //属性窗口
            m_conditionChoose = new frmReportConditionChoose(this);
            //树窗口
            m_RstWindow = new frmMeasureRstMgr(this);
            //分布图，排列图窗体
            m_SImageWindow = new frmSampleImage(this);
            //chart图表窗体
            m_ChartsWindow = new frmCharts(this);
            //grid表格窗体
            m_TablesWindow = new frmTables(this);



            SetTag();

            #region 国际化语言
            Language lan = new Language(this);
            table = lan.GetNameTable(this.Name);
            
            #endregion
        }
        /// <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;
            log = NLog.LogManager.GetCurrentClassLogger();

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

            //分布图，排列图窗体
            m_SImageWindow = new frmSampleImage(this);
            //chart图表窗体
            m_ChartsWindow = new frmCharts(this);
            //grid表格窗体
            m_TablesWindow = new frmTables(this);
            

           
            SetTag();
            #region 国际化语言
            Language lan = new Language(this);
            table = lan.GetNameTable(this.Name);
            #endregion
        }



        /// <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);

            //创建，树窗口，属性grid窗口，分布图，grid,chart窗体等。
            CreateNewWorkspaceWindow();

            //激活测量结果窗体
            this.m_RstWindow.Activate();
            //激活表图窗体
            this.m_TablesWindow.Activate();
            //----------------end the initialization

            if (m_str_resultfilepaths != null)
            {
                //构造函数直接接收传入的测量结果文件，并加载
                for (int i = 0; i < m_str_resultfilepaths.Length; i++)
                {
                    this.m_RstWindow.AddSampleResult(m_str_resultfilepaths[i].Replace("^", " "));
                }
            }

            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_TablesWindow.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;
            }
        }

        /// <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)
                        {
                            //排列图
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeDataChart:
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 宽度匹配按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void rbWidthImage_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.WidthMatch();
                            im_Control_DrawDistrbutionImageAndBSE.Invalidate();
                        }
                    }
                    else
                    {
                        if (im_Control_DrawDistrbutionSortImage != null)
                        {
                            //排列图
                        }
                    }
                    break;
                case (int)DisplayPicutureType.AnalyzeDataTable:
                    break;
                case (int)DisplayPicutureType.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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.AnalyzeDataChart:
                    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()
        {
            //创建测量数据窗口
            CreateCTablesWindow();
            //Show BSE图窗口
            CreateSampleWindow();
            //创建图表窗口
            CreateChartsWindow();

            m_OutputNlog.Show(DockWindowPanel, OTS.WinFormsUI.Docking.DockState.DockRight);
            m_OutputNlog.Visible = true;
            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.AnalyzeDataChart)
            {
                text = table["analysisdatachart"].ToString();
            }

            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);
            }
        }

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

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

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

        }

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

            m_ChartsWindow = (frmCharts)CreateNewDocument(m_ChartsWindow, DisplayPicutureType.AnalyzeDataChart);

            if (DockWindowPanel.DocumentStyle == DocumentStyle.SystemMdi)
            {
                m_ChartsWindow.MdiParent = this;
                m_ChartsWindow.Show();
            }
            else
            {
                m_ChartsWindow.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;
            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                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);
                    }
                }
                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());
            }
        }

        private void rbHelp_Click(object sender, EventArgs e)
        {
            Help help = new Help();
            help.ShowDialog();
        }
        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();
        }

        private void rbClose_DoubleClick(object sender, EventArgs e)
        {

        }

        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)
        {

        }
    }
}