OTS/OTSIncAReportApp/1-UI/OTSTemplateDesigner/OTSReport_Export.cs

using OTSIncAReportApp.Controls;
using OTSIncAReportApp.DataOperation.DataAccess;
using OTSCommon.Model;
using OTSIncAReportApp.OTSSampleReportInfo;
using OTSIncAReportApp.OTSTemplateDesigner;
using OTSIncAReportApp.SysMgrTools;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SQLite;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using OTSIncAReportApp._1_UI.OTSTemplateDesigner;
using DevExpress.XtraReports.UI;
using OTSIncAReportApp.ReportTemplate;

namespace OTSIncAReportApp
{
    public partial class OTSReport_Export : Form
    {
        
        #region 全局变量
        public string m_thread_flag = "无";                             //线程操作的标识
        public string m_str_tmpbitmappath = "d:\\1.bmp";                //存放临时图片 的路径名和文件名
        public string m_str_tmpbitmappath2 = "d:\\2.bmp";
        public string m_str_tmpdocxpath = "d:\\1.doc";
        public string m_strDBpath = "";                                 //报表模板数据库文件
        public string m_strDBpathGB = "";                               //报告国标导出
        public string m_strDBpath_ParticleList = "";                    //报表模板，颗粒列表数据库文件
        public int m_SelectedIndex = 0;
        System.Collections.Hashtable table;
        public frmReportApp m_ReportApp = null;                         //报告项目总进程对象
        public string m_export_type = "Excel";                          //导出文件的格式类型Excel,Word,Pdf

        Export_ReportTemplate m_export_reporttemplate;
        public string strPath = "./Config/ReportTemplate/ReportTemplateConfig.xml"; //报告模板设置文件的路径
       
        public string strPath2;
        public XmlOperateUtil xmlutil;
        public XmlOperateUtil xmlutil2;
        public c_TemplateClass m_mbszclass = null;
        OTS_DEVReport DEVReport;
        
        GBReport GB_Report;
        /*public bool ReportExporting = false;*///判断报告是不在是在导出的过程中

        #endregion

        #region 条件参数变量
        /// <summary>
        /// 选择的数据类型
        /// </summary>
        public string SJLX { get; set; }

        /// <summary>
        /// 尺寸计算方法
        /// </summary>
        public string CCJSFF { get; set; }

        /// <summary>
        /// 粒级表
        /// </summary>
        public string LJB { get; set; }

        /// <summary>
        /// 三元相图模板
        /// </summary>
        public string SYXTMB { get; set; }

        #endregion

       
        #region 模板设置类
        /// <summary>
        /// 模板设置类
        /// </summary>
        public class c_TemplateClass
        {
            public DZ M_DZ { get; set; }

            #region 属性
            /// <summary>
            /// 首页
            /// </summary>
            public SY M_SY { get; set; }

            /// <summary>
            /// 页眉页脚
            /// </summary>
            public YMYJ M_YMYJ { get; set; }

            /// <summary>
            /// 颗粒分析结果
            /// </summary>
            public KLFXJG M_KLFXJG { get; set; }

            /// <summary>
            /// 元素分析结果
            /// </summary>
            public YSFXJG M_YSFXJG { get; set; }

            /// <summary>
            /// 三元相图
            /// </summary>
            public SYXT M_SYXT { get; set; }

            /// <summary>
            /// 颗粒列表信息
            /// </summary>
            public KLLBXX M_KLLBXX { get; set; }

            /// <summary>
            /// 夹杂物占比
            /// </summary>
            public JZWZB M_JZWZB { get; set; }
            #endregion

            #region 构造函数
            public c_TemplateClass()
            {
                M_SY = new SY();
                M_YMYJ = new YMYJ();
                M_KLFXJG = new KLFXJG();
                M_YSFXJG = new YSFXJG();
                M_YSFXJG.list_str_tb_yscf_ysxx = new List<string>();
                M_YSFXJG.list_str_tb_ysfx_xsys = new List<string>();
                M_SYXT = new SYXT();
                M_SYXT.list_lbv_syxt_mblb = new List<string>();
                M_SYXT.list_lbv_syxt_mblb_index = new List<int>();
                M_KLLBXX = new KLLBXX();
                M_JZWZB = new JZWZB();
                M_KLLBXX.list_str_tb_lllb_sxys = new List<string>();
                M_KLLBXX.list_str_kllb_qcys = new List<string>();
                M_KLLBXX.list_str_kllb_DeleteClass = new List<string>();
                M_DZ = new DZ();
            }
            #endregion

            public class DZ
            {
                public string route { get; set; }
            }

            #region 首页部份
            public class SY
            {
                /// <summary>
                /// 主标题
                /// </summary>
                public string str_tb_ZBT { get; set; }

                /// <summary>
                /// 副标题
                /// </summary>
                public string str_tb_FBT { get; set; }

                /// <summary>
                /// 样品编号
                /// </summary>
                public string str_tb_YPBH { get; set; }

                /// <summary>
                /// 参考标准
                /// </summary>
                public string str_tb_CKBZ { get; set; }

                /// <summary>
                /// 是否显示样品说明
                /// </summary>
                public bool b_ck_ypsm { get; set; }

                /// <summary>
                /// 是否显示结果概况
                /// </summary>
                public bool b_ck_jggk { get; set; }
                /// <summary>
                /// 报告备注
                /// </summary>
                public string str_bz { get; set; }
                /// <summary>
                /// 选择颗粒导出范围_内容
                /// </summary>
                public string str_xzkl { get; set; }
                /// <summary>
                /// 选择颗粒导出范围，索引
                /// </summary>
                public int int_xzkl { get; set; }
            }
            #endregion

            #region 页眉页脚部份
            public class YMYJ
            {
                /// <summary>
                /// 页眉文本
                /// </summary>
                public string str_tb_ymwb { get; set; }

                /// <summary>
                /// 客户号
                /// </summary>
                public string str_tb_KHH { get; set; }

                /// <summary>
                /// 是否显示页码
                /// </summary>
                public bool b_ck_ym { get; set; }

                /// <summary>
                /// 页脚文本
                /// </summary>
                public string str_tb_yjwb { get; set; }
            }
            #endregion

            #region 颗粒分析结果部份
            public class KLFXJG
            {
                /// <summary>
                /// 大分类是否显示
                /// </summary>
                public bool b_ck_klcc_dfl { get; set; }
                /// <summary>
                /// 小分类是否显示
                /// </summary>
                public bool b_ck_klcc_xfl { get; set; }

                /// <summary>
                /// 是否显示颗粒尺寸分析结果表
                /// </summary>
                public bool b_ck_klcc_xsmk { get; set; }
                /// <summary>
                /// 是否显示颗粒尺寸 堆叠图
                /// </summary>
                public bool b_ck_klcc_xsddt { get; set; }

                /// <summary>
                ///颗粒尺寸分析结果表 计算方式文本
                /// </summary>
                public string str_cb_klcc_jsfs { get; set; }

                /// <summary>
                ///颗粒尺寸分析结果表 计算方式索引
                /// </summary>
                public int index_cb_klcc_jsfs { get; set; }

                /// <summary>
                ///颗粒尺寸分析结果表 粒级表文本
                /// </summary>
                public string str_cb_klcc_ljb { get; set; }

                /// <summary>
                ///颗粒尺寸分析结果表 粒级表索引
                /// </summary>
                public int index_cb_klcc_ljb { get; set; }

                /// <summary>
                ///颗粒尺寸分析结果表 颗粒选择范围文本
                /// </summary>
                public string str_cb_klcc_klfw { get; set; }

                /// <summary>
                ///颗粒尺寸分析结果表 颗粒选择范围索引
                /// </summary>
                public int index_cb_klcc_klfw { get; set; }

                /// <summary>
                /// 夹杂物分类图 是否显示该模块
                /// </summary>
                public bool b_cb_jzwfl_xsmk { get; set; }

                /// <summary>
                ///夹杂物分类图 显示图形选择文本
                /// </summary>
                public string str_cb_jzwfl_xstx { get; set; }

                /// <summary>
                ///夹杂物分类图 显示图形 选择索引
                /// </summary>
                public int index_cb_jzwfl_xstx { get; set; }

                /// <summary>
                ///夹杂物分类图 计算方式 选择文本
                /// </summary>
                public string str_cb_jzwfl_jsfs { get; set; }

                /// <summary>
                ///夹杂物分类图 计算方式 选择索引
                /// </summary>
                public int index_cb_jzwfl_jsfs { get; set; }

                /// <summary>
                ///夹杂物分类图 粒级表 选择文本
                /// </summary>
                public string str_cb_jzwfl_ljb { get; set; }

                /// <summary>
                ///夹杂物分类图 粒级表 选择索引
                /// </summary>
                public int index_cb_jzwfl_ljb { get; set; }

                /// <summary>
                ///夹杂物分类图 颗粒范围 选择文本
                /// </summary>
                public string str_cb_jzwfl_klfw { get; set; }

                /// <summary>
                ///夹杂物分类图 颗粒范围 选择索引
                /// </summary>
                public int index_cb_jzwfl_klfw { get; set; }
            }

            #endregion

            #region 元素分析结果部份
            public class YSFXJG
            {
                /// <summary>
                /// 元素分析表 是否显示该模块
                /// </summary>
                public bool b_ck_ysfx_xsmk { get; set; }

                /// <summary>
                /// 元素分析表 计算方式  选择文本
                /// </summary>
                public string str_cb_yxfx_jsfs { get; set; }

                /// <summary>
                /// 元素分析表 计算方式  选择索引
                /// </summary>
                public int index_cb_yxfx_jsfs { get; set; }

                /// <summary>
                /// 元素分析表 颗粒范围 选择文本
                /// </summary>
                public string str_cb_ysfx_klfw { get; set; }

                /// <summary>
                /// 元素分析表 颗粒范围 选择索引
                /// </summary>
                public int index_cb_ysfx_klfw { get; set; }

                /// <summary>
                /// 元素分析表 显示元素显示文本
                /// </summary>
                public string str_tb_ysfx_xsys { get; set; }

                /// <summary>
                /// 元素分析表 显示元素拆分元素列表
                /// </summary>
                public List<string> list_str_tb_ysfx_xsys { get; set; }

                /// <summary>
                /// 元素成份图 是否显示该模块
                /// </summary>
                public bool b_ck_yscf_xsmk { get; set; }

                /// <summary>
                /// 元素成份图 显示图形 文本
                /// </summary>
                public string str_cb_yscf_xstx { get; set; }

                /// <summary>
                /// 元素成份图 显示图形 索引
                /// </summary>
                public int index_cb_yscf_xstx { get; set; }

                /// <summary>
                /// 元素成份图 计算方式 文本
                /// </summary>
                public string str_cb_yscf_jsfs { get; set; }

                /// <summary>
                /// 元素成份图 计算方式 索引
                /// </summary>
                public int index_cb_yscf_jsfs { get; set; }

                /// <summary>
                /// 元素成份图 颗粒范围 文本
                /// </summary>
                public string str_cb_yscf_klfw { get; set; }

                /// <summary>
                /// 元素成份图 颗粒范围 索引
                /// </summary>
                public int index_cb_yscf_klfw { get; set; }

                /// <summary>
                /// 元素成份图 元素信息
                /// </summary>
                public string str_tb_yscf_ysxx { get; set; }

                /// <summary>
                /// 元素成份图 元素信息列表拆分字符列表
                /// </summary>
                public List<string> list_str_tb_yscf_ysxx { get; set; }

            }
            #endregion

            #region 三元相图部份
            public class SYXT
            {
                /// <summary>
                /// 三元相图 是否显示该模块
                /// </summary>
                public bool b_ck_syxt_xsmk { get; set; }

                /// <summary>
                /// 计算方式 文本
                /// </summary>
                public string str_cb_syxt_jsfs { get; set; }

                /// <summary>
                /// 计算方式 索引
                /// </summary>
                public int index_cb_syxt_jsfs { get; set; }

                /// <summary>
                /// 颗粒范围 文本
                /// </summary>
                public string str_cb_syxt_klfw { get; set; }

                /// <summary>
                /// 颗粒范围 索引
                /// </summary>
                public int index_cb_syxt_klfw { get; set; }

                /// <summary>
                /// 粒级表信息 文本
                /// </summary>
                public string str_cb_syxt_ljb { get; set; }

                /// <summary>
                /// 粒级表信息 索引
                /// </summary>
                public int index_cb_syxt_ljb { get; set; }

                /// <summary>
                /// 每行显示数量 文本
                /// </summary>
                public string str_cb_syxt_mhxssl { get; set; }

                /// <summary>
                /// 每行显示数量 索引
                /// </summary>
                public int index_cb_syxt_mhxssl { get; set; }

                /// <summary>
                /// 三元相图模板集合列表
                /// </summary>
                public List<string> list_lbv_syxt_mblb { get; set; }

                /// <summary>
                /// 三元相图模板索引集合列表
                /// </summary>
                public List<int> list_lbv_syxt_mblb_index { get; set; }
            }
            #endregion

            #region 颗粒列表信息部份
            public class KLLBXX
            {
                /// <summary>
                /// 颗粒列表 是否显示该模块
                /// </summary>
                public bool b_ck_kllb_xsmk { get; set; }

                /// <summary>
                /// 颗粒列表 是否显示附加帧图模块
                /// </summary>
                public bool b_ck_kllb_fjzt { get; set; }

                /// <summary>
                /// 颗粒列表 计算方式 文本
                /// </summary>
                public string str_cb_kllb_jsfs { get; set; }

                /// <summary>
                /// 颗粒列表 计算方式 索引
                /// </summary>
                public int index_cb_kllb_jsfs { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒范围 文本
                /// </summary>
                public string str_cb_kllb_klfw { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒范围 索引
                /// </summary>
                public int index_cb_kllb_klfw { get; set; }

                /// <summary>
                /// 颗粒列表 数量上限
                /// </summary>
                public int int_tb_kllb_ylsx { get; set; }

                /// <summary>
                /// 颗粒列表 显示元素
                /// </summary>
                public string str_tb_kllb_sxys { get; set; }

                /// <summary>
                /// 颗粒列表 显示元素拆分元素列表
                /// </summary>
                public List<string> list_str_tb_lllb_sxys { get; set; }

                /// <summary>
                /// 颗粒列表 是否显示原始图像
                /// </summary>
                public bool b_ck_kllb_ystx { get; set; }

                /// <summary>
                /// 颗粒列表 是否显示放大图像
                /// </summary>
                public bool b_ck_kllb_fdtx { get; set; }

                /// <summary>
                /// 颗粒列表 是否显示能谱信息
                /// </summary>
                public bool b_ck_kllb_npxx { get; set; }


                
                
                /// <summary>
                /// 颗粒列表 颗粒排序表行中第一个可选字段 文本
                /// </summary>
                public string str_cb_kllb_sort_p1 { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒排序表行中第一个可选字段 索引
                /// </summary>
                public int index_cb_kllb_sort_p1 { get; set; }
                /// <summary>
                /// 颗粒列表 颗粒排序表行中第二个可选字段 文本
                /// </summary>
                public string str_cb_kllb_sort_p2 { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒排序表行中第二个可选字段 索引
                /// </summary>
                public int index_cb_kllb_sort_p2 { get; set; }
                /// <summary>
                /// 颗粒列表 颗粒排序表行中第三个可选字段 文本
                /// </summary>
                public string str_cb_kllb_sort_p3 { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒排序表行中第三个可选字段 索引
                /// </summary>
                public int index_cb_kllb_sort_p3 { get; set; }
                /// <summary>
                /// 颗粒列表 颗粒帧图表行中第一个可选字段 文本
                /// </summary>
                public string str_cb_kllb_chartSort_p1 { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒帧图表行中第一个可选字段 索引
                /// </summary>
                public int index_cb_kllb_chartSort_p1 { get; set; }
                /// <summary>
                /// 颗粒列表 颗粒帧图表行中第二个可选字段 文本
                /// </summary>
                public string str_cb_kllb_chartSort_p2 { get; set; }

                /// <summary>
                /// 颗粒列表 颗粒帧图表行中第二个可选字段 索引
                /// </summary>
                public int index_cb_kllb_chartSort_p2 { get; set; }
                /// <summary>
                /// 颗粒列表去除不要的颗粒
                /// </summary>
                public string str_kllb_qcys { get; set; }
                /// <summary>
                /// 颗粒列表去除不要的颗粒
                /// </summary>
                public List<string> list_str_kllb_qcys { get; set; }

                /// <summary>
                /// 颗粒列表去除不要的物质分类
                /// </summary>
                public string str_kllb_DeleteClass { get; set; }
                /// <summary>
                /// 颗粒列表去除不要的物质分类
                /// </summary>
                public List<string> list_str_kllb_DeleteClass { get; set; }

                /// <summary>
                /// 显示颗粒数量
                /// </summary>
                public int list_int_kllb_number { get; set; }
            }
            #endregion
            #region 夹杂物占比
            public class JZWZB
            {
                /// <summary>
                /// 夹杂物占比表
                /// </summary>
                public bool b_ck_surface { get; set; }
                /// <summary>
                /// 夹杂物占比图
                /// </summary>
                public bool b_ck_chart { get; set; }
            }

            #endregion
        }
        #endregion

        #region 窗体加载及构造函数
        public OTSReport_Export(frmReportApp ReportApp)
        {
            InitializeComponent();
            m_ReportApp = ReportApp;
            m_export_reporttemplate = new Export_ReportTemplate(this);

            //初始化xml类
            xmlutil = new XmlOperateUtil(strPath);

            m_mbszclass = new c_TemplateClass();

            //读取配置文件中的模板
            LoadMBSZClass();

            LoadRouteclass();

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

        }
        ///<summary>
        ///从配置文件中读取报告模板信息
        /// </summary>
        private void LoadRouteclass()
        {
            if (m_mbszclass.M_DZ.route == null)
            {
                strPath2 = strPath;
                m_mbszclass.M_DZ.route = strPath;
            }
            else
            if (m_mbszclass.M_DZ.route == "")
            {
                strPath2 = strPath;
                m_mbszclass.M_DZ.route = strPath;
            }
            else
            {
                strPath2 = m_mbszclass.M_DZ.route;
            }

            xmlutil2 = new XmlOperateUtil(strPath2);
            //首页
            m_mbszclass.M_SY.str_tb_ZBT = xmlutil2.Read("M_SY", "str_tb_ZBT");
            m_mbszclass.M_SY.str_tb_FBT = xmlutil2.Read("M_SY", "str_tb_FBT");
            m_mbszclass.M_SY.str_tb_YPBH = xmlutil2.Read("M_SY", "str_tb_YPBH");
            m_mbszclass.M_SY.str_tb_CKBZ = xmlutil2.Read("M_SY", "str_tb_CKBZ");
            m_mbszclass.M_SY.str_bz = xmlutil2.Read("M_SY", "str_bz");
            m_mbszclass.M_SY.b_ck_ypsm = Convert.ToBoolean(xmlutil2.Read("M_SY", "b_ck_ypsm"));
            m_mbszclass.M_SY.b_ck_jggk = Convert.ToBoolean(xmlutil2.Read("M_SY", "b_ck_jggk"));
            m_mbszclass.M_SY.str_xzkl= xmlutil2.Read("M_SY", "str_xzkl");
            m_mbszclass.M_SY.int_xzkl = Convert.ToInt32(xmlutil2.Read("M_SY", "int_xzkl"));
            //页眉页脚
            m_mbszclass.M_YMYJ.str_tb_ymwb = xmlutil2.Read("M_YMYJ", "str_tb_ymwb");
            m_mbszclass.M_YMYJ.str_tb_KHH = xmlutil2.Read("M_YMYJ", "str_tb_KHH");
            m_mbszclass.M_YMYJ.b_ck_ym = Convert.ToBoolean(xmlutil2.Read("M_YMYJ", "b_ck_ym"));
            m_mbszclass.M_YMYJ.str_tb_yjwb = xmlutil2.Read("M_YMYJ", "str_tb_yjwb");

            //颗粒分析结果
            m_mbszclass.M_KLFXJG.b_ck_klcc_xsmk = Convert.ToBoolean(xmlutil2.Read("M_KLFXJG", "b_ck_klcc_xsmk"));//是否显示模块
            m_mbszclass.M_KLFXJG.b_ck_klcc_xsddt = Convert.ToBoolean(xmlutil2.Read("M_KLFXJG", "b_ck_klcc_xsddt"));
            m_mbszclass.M_KLFXJG.index_cb_klcc_jsfs = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_klcc_jsfs"));//计算方式
            m_mbszclass.M_KLFXJG.str_cb_klcc_jsfs = Convert.ToString(xmlutil2.Read("M_KLFXJG", "str_cb_klcc_jsfs"));//计算方式
            m_mbszclass.M_KLFXJG.index_cb_klcc_ljb = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_klcc_ljb"));//粒级表
            m_mbszclass.M_KLFXJG.index_cb_klcc_klfw = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_klcc_klfw"));//颗粒范围
            m_mbszclass.M_KLFXJG.b_cb_jzwfl_xsmk = Convert.ToBoolean(xmlutil2.Read("M_KLFXJG", "b_cb_jzwfl_xsmk"));//是否显示该模块
            m_mbszclass.M_KLFXJG.index_cb_jzwfl_xstx = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_jzwfl_xstx"));//选择图像
            m_mbszclass.M_KLFXJG.index_cb_jzwfl_jsfs = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_jzwfl_jsfs"));//计算方式
            m_mbszclass.M_KLFXJG.index_cb_jzwfl_ljb = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_jzwfl_ljb"));//粒级表
            m_mbszclass.M_KLFXJG.index_cb_jzwfl_klfw = Convert.ToInt32(xmlutil2.Read("M_KLFXJG", "index_cb_jzwfl_klfw"));//颗粒范围


            m_mbszclass.M_KLFXJG.b_ck_klcc_dfl = Convert.ToBoolean(xmlutil2.Read("M_KLFXJG", "b_ck_klcc_dfl"));//大分类是否显示
            m_mbszclass.M_KLFXJG.b_ck_klcc_xfl = Convert.ToBoolean(xmlutil2.Read("M_KLFXJG", "b_ck_klcc_xfl"));//小分类是否显示



            //元素分析结果
            m_mbszclass.M_YSFXJG.b_ck_ysfx_xsmk = Convert.ToBoolean(xmlutil2.Read("M_YSFXJG", "b_ck_ysfx_xsmk"));    //是否显示模块
            m_mbszclass.M_YSFXJG.index_cb_yxfx_jsfs = Convert.ToInt32(xmlutil2.Read("M_YSFXJG", "index_cb_yxfx_jsfs"));    //计算方式
            m_mbszclass.M_YSFXJG.index_cb_ysfx_klfw = Convert.ToInt32(xmlutil2.Read("M_YSFXJG", "index_cb_ysfx_klfw"));    //颗粒范围
            m_mbszclass.M_YSFXJG.str_tb_ysfx_xsys = xmlutil2.Read("M_YSFXJG", "str_tb_ysfx_xsys");        //显示元素

            m_mbszclass.M_YSFXJG.list_str_tb_ysfx_xsys.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有元素列表
            {
                string str = xmlutil2.Read("M_YSFXJG", "list_str_tb_ysfx_xsys", "YS" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_YSFXJG.list_str_tb_ysfx_xsys.Add(str);
                }
            }

            m_mbszclass.M_YSFXJG.b_ck_yscf_xsmk = Convert.ToBoolean(xmlutil2.Read("M_YSFXJG", "b_ck_yscf_xsmk"));    //是否显示模块
            m_mbszclass.M_YSFXJG.index_cb_yscf_xstx = Convert.ToInt32(xmlutil2.Read("M_YSFXJG", "index_cb_yscf_xstx"));    //显示图形
            m_mbszclass.M_YSFXJG.index_cb_yscf_jsfs = Convert.ToInt32(xmlutil2.Read("M_YSFXJG", "index_cb_yscf_jsfs"));    //计算方式
            m_mbszclass.M_YSFXJG.index_cb_yscf_klfw = Convert.ToInt32(xmlutil2.Read("M_YSFXJG", "index_cb_yscf_klfw"));    //颗粒范围
            m_mbszclass.M_YSFXJG.str_tb_yscf_ysxx = xmlutil2.Read("M_YSFXJG", "str_tb_yscf_ysxx");    //显示元素

            m_mbszclass.M_YSFXJG.list_str_tb_yscf_ysxx.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有元素列表
            {
                string str = xmlutil2.Read("M_YSFXJG", "list_str_tb_yscf_ysxx", "YS" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_YSFXJG.list_str_tb_yscf_ysxx.Add(str);
                }
            }

            //三元相图
            m_mbszclass.M_SYXT.b_ck_syxt_xsmk = Convert.ToBoolean(xmlutil2.Read("M_SYXT", "b_ck_syxt_xsmk"));    //是否显示模块
            m_mbszclass.M_SYXT.index_cb_syxt_jsfs = Convert.ToInt32(xmlutil2.Read("M_SYXT", "index_cb_syxt_jsfs"));    //计算方式
            m_mbszclass.M_SYXT.index_cb_syxt_klfw = Convert.ToInt32(xmlutil2.Read("M_SYXT", "index_cb_syxt_klfw"));    //颗粒范围
            m_mbszclass.M_SYXT.str_cb_syxt_mhxssl = xmlutil2.Read("M_SYXT", "str_cb_syxt_mhxssl");    //每行显示数量

            m_mbszclass.M_SYXT.list_lbv_syxt_mblb.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有模板列表
            {
                string str = xmlutil2.Read("M_SYXT", "list_lbv_syxt_mblb", "MB" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_SYXT.list_lbv_syxt_mblb.Add(str);
                }
            }
            m_mbszclass.M_SYXT.list_lbv_syxt_mblb_index.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有模板列表 索引
            {
                string str = xmlutil2.Read("M_SYXT", "list_lbv_syxt_mblb_index", "MBIndex" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_SYXT.list_lbv_syxt_mblb_index.Add(Convert.ToInt32(str));
                }
            }
            //颗粒列表信息
            m_mbszclass.M_KLLBXX.b_ck_kllb_xsmk = Convert.ToBoolean(xmlutil2.Read("M_KLLBXX", "b_ck_kllb_xsmk"));    //是否显示模块
            m_mbszclass.M_KLLBXX.b_ck_kllb_fjzt = Convert.ToBoolean(xmlutil2.Read("M_KLLBXX", "b_ck_kllb_fjzt"));    //是否显示帧图模块
            m_mbszclass.M_KLLBXX.index_cb_kllb_jsfs = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_jsfs"));    //计算方式
            m_mbszclass.M_KLLBXX.index_cb_kllb_klfw = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_klfw"));    //颗粒范围
            m_mbszclass.M_KLLBXX.int_tb_kllb_ylsx = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "int_tb_kllb_ylsx"));    //数量上限
            m_mbszclass.M_KLLBXX.str_tb_kllb_sxys = xmlutil2.Read("M_KLLBXX", "str_tb_kllb_sxys");    //显示元素

            m_mbszclass.M_KLLBXX.list_str_tb_lllb_sxys.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有元素列表
            {
                string str = xmlutil2.Read("M_KLLBXX", "list_str_tb_lllb_sxys", "YS" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_KLLBXX.list_str_tb_lllb_sxys.Add(str);
                }
            }
            m_mbszclass.M_KLLBXX.b_ck_kllb_ystx = Convert.ToBoolean(xmlutil2.Read("M_KLLBXX", "b_ck_kllb_ystx"));    //原始图像
            m_mbszclass.M_KLLBXX.b_ck_kllb_fdtx = Convert.ToBoolean(xmlutil2.Read("M_KLLBXX", "b_ck_kllb_fdtx"));    //放大图像
            m_mbszclass.M_KLLBXX.b_ck_kllb_npxx = Convert.ToBoolean(xmlutil2.Read("M_KLLBXX", "b_ck_kllb_npxx"));    //能谱图像

           
            m_mbszclass.M_KLLBXX.str_cb_kllb_sort_p1 = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_cb_kllb_sort_p1"));//颗粒列表列中第一个可选参数
            m_mbszclass.M_KLLBXX.index_cb_kllb_sort_p1 = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_sort_p1"));
            m_mbszclass.M_KLLBXX.str_cb_kllb_sort_p2 = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_cb_kllb_sort_p2"));//颗粒列表中第二个可选参数
            m_mbszclass.M_KLLBXX.index_cb_kllb_sort_p2 = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_sort_p2"));
            m_mbszclass.M_KLLBXX.str_cb_kllb_sort_p3 = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_cb_kllb_sort_p3"));//颗粒列表中第三个可选参数
            m_mbszclass.M_KLLBXX.index_cb_kllb_sort_p3 = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_sort_p3"));
            m_mbszclass.M_KLLBXX.str_cb_kllb_chartSort_p1 = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_cb_kllb_chartSort_p1"));//帧图表列中第一个可选参数
            m_mbszclass.M_KLLBXX.index_cb_kllb_chartSort_p1 = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_chartSort_p1"));
            m_mbszclass.M_KLLBXX.str_cb_kllb_chartSort_p2 = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_cb_kllb_chartSort_p2"));//帧图表列中第二个可选参数
            m_mbszclass.M_KLLBXX.index_cb_kllb_chartSort_p2 = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_chartSort_p2"));
            //m_mbszclass.M_KLLBXX.str_cb_kllb_chartSort_p3 = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_cb_kllb_chartSort_p3"));//帧图表列中第三个可选参数
            //m_mbszclass.M_KLLBXX.index_cb_kllb_chartSort_p3 = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "index_cb_kllb_chartSort_p3"));

            m_mbszclass.M_KLLBXX.str_kllb_qcys = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_kllb_qcys"));
            m_mbszclass.M_KLLBXX.list_str_kllb_qcys.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有元素列表
            {
                string str = xmlutil2.Read("M_KLLBXX", "list_str_kllb_qcys", "YS" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_KLLBXX.list_str_kllb_qcys.Add(str);
                }
            }
            m_mbszclass.M_KLLBXX.str_kllb_DeleteClass = Convert.ToString(xmlutil2.Read("M_KLLBXX", "str_kllb_DeleteClass"));
            m_mbszclass.M_KLLBXX.list_str_kllb_DeleteClass.Clear();
            for (int i = 0; i < 100; i++)                              //取得所有元素列表
            {
                string str = xmlutil2.Read("M_KLLBXX", "list_str_kllb_DeleteClass", "YS" + i.ToString());
                if (str == null)
                {
                    break;
                }
                else
                {
                    m_mbszclass.M_KLLBXX.list_str_kllb_DeleteClass.Add(str);
                }
            }


            //夹杂物占比
            m_mbszclass.M_JZWZB.b_ck_surface = Convert.ToBoolean(xmlutil2.Read("M_JZWZB", "b_ck_surface"));//夹杂物占比表
            m_mbszclass.M_JZWZB.b_ck_chart= Convert.ToBoolean(xmlutil2.Read("M_JZWZB", "b_ck_chart"));//夹杂物占比图

            m_mbszclass.M_KLLBXX.list_int_kllb_number = Convert.ToInt32(xmlutil2.Read("M_KLLBXX", "list_int_kllb_number"));//保存显示颗粒数量
        }
        /// <summary>
        /// 从配置文件中读取报告模板路径
        /// </summary>
        private void LoadMBSZClass()
        {

            //文件路径
            m_mbszclass.M_DZ.route = xmlutil.Read("M_address", "Path");
            if (m_mbszclass.M_DZ.route == "")
            {
                tb_mblj.Text = strPath;
                m_mbszclass.M_DZ.route = strPath;
            }
            else
            if (File.Exists(m_mbszclass.M_DZ.route))
            {
                tb_mblj.Text = m_mbszclass.M_DZ.route;
            }
            else
            {
                tb_mblj.Text = strPath;
                m_mbszclass.M_DZ.route = strPath;
            }
        }

        /// <summary>
        /// 将报告模板信息保存到配置文件中
        /// </summary>
        private void SaveMBSClass()
        {
            //文件路径
            xmlutil.Write(m_mbszclass.M_DZ.route.ToString(), "M_address", "Path");
        }

        /// <summary>
        /// 传入，3个层级的xml结点标识，进行删除结点
        /// </summary>
        /// <param name="strnode_mk"></param>
        /// <param name="strnode_kj"></param>
        /// <param name="strnode_xh"></param>
        private void RemoveMBSZClassNode(string strnode_mk, string strnode_kj, string strnode_xh, int int_start)
        {
            for (int i = int_start; i < 1000; i++)
            {
                string strxh = i.ToString();
                if (null != xmlutil.Read(strnode_mk, strnode_kj, strnode_xh + strxh))
                {
                    //删除该节点
                    xmlutil.RemoveNode(strnode_mk, strnode_kj, strnode_xh + strxh);
                }
                else
                {
                    break;
                }
            }
        }
 
     

        /// <summary>
        /// 加载报告模板选择项，数据源选项
        /// </summary>
        private void BindComboBox()
        {
            //加载数据源
            for (int i = 0; i < m_ReportApp.m_rstDataMgr.ResultFilesList.Count; i++)
            {
                cbo_sjy.Items.Add(m_ReportApp.m_rstDataMgr.ResultFilesList[i].anotherFileName);
            }

            if (cbo_sjy.Items.Count > 0)
                cbo_sjy.SelectedIndex = 0;

        }

        private void OTSReport_Export_Load(object sender, EventArgs e)
        {
           
            //先获取D盘，如果没有，则再获取C盘
            string str_drivename = GetSecondDriveName();
            if (str_drivename == "")
                str_drivename = GetFirstDriveName();
            //初始化临时文件位置
            m_str_tmpbitmappath = str_drivename + "1.bmp";
            m_str_tmpbitmappath2 = str_drivename + "2.bmp";
            m_str_tmpdocxpath = str_drivename + "1.doc";
            //窗体加载时，初始化Combobox
            BindComboBox();
            //设置界面线程
            backgroundWorker2.WorkerReportsProgress = true;
            backgroundWorker2.WorkerSupportsCancellation = true;

            //确定报表进程db数据库的路径
            string strdbname = "ReportTemplateDB.db";
            m_strDBpath = m_ReportApp.m_rstDataMgr.ResultFilesList[cbo_sjy.SelectedIndex].FilePath;
            m_strDBpathGB = m_ReportApp.m_rstDataMgr.ResultFilesList[cbo_sjy.SelectedIndex].FilePath;
            m_strDBpath = m_strDBpath + "\\" + strdbname;
            m_strDBpathGB = m_strDBpathGB + "\\" + "ReportGBDB.db";

            string strdbparticlelistname = "ReportTemplateDBParticleList.db";
            m_strDBpath_ParticleList = m_ReportApp.m_rstDataMgr.ResultFilesList[cbo_sjy.SelectedIndex].FilePath;
            m_strDBpath_ParticleList = m_strDBpath_ParticleList + "\\" + strdbparticlelistname;

           
        }
        #endregion

        #region 自定义方法
        /// <summary>
        /// 传入完整的路径及文件名，和需要的扩展名，返回文件加上需要的扩展名
        /// </summary>
        /// <param name="in_str"></param>
        /// <param name="in_extename"></param>
        /// <returns></returns>
        public string GetFileExteName(string in_str, string in_extename)
        {
            string ret_str = in_str.Substring(0, in_str.IndexOf('.'));
            ret_str = ret_str + in_extename;
            return ret_str;
        }

        /// <summary>
        /// 获取第一个磁盘盘符的名称
        /// </summary>
        /// <returns></returns>
        public string GetFirstDriveName()
        {
            System.IO.DriveInfo[] ls_driveinfo = System.IO.DriveInfo.GetDrives();
            if (ls_driveinfo.Count() > 0)
                return ls_driveinfo[0].Name;

            return "";
        }

        /// <summary>
        /// 获取第二个磁盘盘符的名称,因为有时c盘不会给予读写的权限，所以要用到这个
        /// </summary>
        /// <returns></returns>
        private string GetSecondDriveName()
        {
            System.IO.DriveInfo[] ls_driveinfo = System.IO.DriveInfo.GetDrives();
            if (ls_driveinfo.Count() > 1)
                return ls_driveinfo[1].Name;

            return "";
        }

        /// <summary>
        /// 将文本追加到RictBox的尾部上
        /// </summary>
        public void WriteRictBox(string in_str)
        {
            //追加到rictbox尾部
            richTextBox1.AppendText("[" + DateTime.Now.Hour.ToString() + ":"
                + DateTime.Now.Minute.ToString() + ":"
                + DateTime.Now.Second.ToString() + "]"
                + in_str + Environment.NewLine);
            richTextBox1.SelectionColor = GetRandomColor30(30);
            richTextBox1.ScrollToCaret();
        }

        /// <summary>
        /// 重载输出文本，带有可以指定颜色
        /// </summary>
        /// <param name="in_str"></param>
        /// <param name="in_c"></param>
        public void WriteRictBox(string in_str, Color in_c)
        {
            //追加到rictbox尾部
            richTextBox1.AppendText("[" + DateTime.Now.Hour.ToString() + ":"
                + DateTime.Now.Minute.ToString() + ":"
                + DateTime.Now.Second.ToString() + "]"
                + in_str + Environment.NewLine);
            richTextBox1.SelectionColor = in_c;
            richTextBox1.ScrollToCaret();
        }
        /// <summary>
        /// 根据传入的颜色，及传入Size的大小，返回一个该色的bitmap对象
        /// </summary>
        /// <param name="in_c"></param>
        /// <returns></returns>
        public Bitmap GetBitmapByColor(Color in_c, Size in_z)
        {
            Bitmap bmp = new Bitmap(in_z.Width, in_z.Height); //这里给104是为了左边和右边空出2个像素，剩余的100就是百分比的值
            Graphics g = Graphics.FromImage(bmp);
            g.Clear(Color.White);
            SolidBrush drawBrush = new SolidBrush(Color.Black);
            g.FillRectangle(new SolidBrush(in_c), 0, 0, in_z.Width, in_z.Height);

            return bmp;
        }

        /// <summary>
        /// [颜色：16进制转成RGB]
        /// </summary>
        /// <param name="strColor">设置16进制颜色 [返回RGB]</param>
        /// <returns></returns>
        public System.Drawing.Color colorHx16toRGB(string strHxColor)
        {
            try
            {
                if (strHxColor.Length == 0)
                {//如果为空
                    return System.Drawing.Color.FromArgb(0, 0, 0);//设为黑色
                }
                else
                {//转换颜色
                    if (strHxColor.IndexOf('#') > -1)
                    {
                        //如果颜色格式是 #0000FF 格式的
                        return System.Drawing.Color.FromArgb(System.Int32.Parse(strHxColor.Substring(1, 2), System.Globalization.NumberStyles.AllowHexSpecifier), System.Int32.Parse(strHxColor.Substring(3, 2), System.Globalization.NumberStyles.AllowHexSpecifier), System.Int32.Parse(strHxColor.Substring(5, 2), System.Globalization.NumberStyles.AllowHexSpecifier));
                    }
                    else
                    {
                        //如果颜色格式是 0000FF 格式的
                        return System.Drawing.Color.FromArgb(System.Int32.Parse(strHxColor.Substring(0, 2), System.Globalization.NumberStyles.AllowHexSpecifier), System.Int32.Parse(strHxColor.Substring(2, 2), System.Globalization.NumberStyles.AllowHexSpecifier), System.Int32.Parse(strHxColor.Substring(4, 2), System.Globalization.NumberStyles.AllowHexSpecifier));
                    }
                }
            }
            catch
            {//设为黑色
                return System.Drawing.Color.FromArgb(0, 0, 0);
            }
        }


        /// <summary>
        /// [颜色：RGB转成16进制]专为输出Excel表头格式而定制，其它地方不要使用该方法,或修改返回加#号，例#000000FF
        /// </summary>
        /// <param name="R">红 int</param>
        /// <param name="G">绿 int</param>
        /// <param name="B">蓝 int</param>
        /// <returns></returns>
        public string colorRGBtoHx16ForExcel(Color color)
        {
            if (color.IsEmpty)
                return "000000";
            return String.Format("{0:X2}{1:X2}{2:X2}", color.R, color.G, color.B);
        }

        /// <summary>
        /// 将RGB颜色转成整数
        /// </summary>
        /// <param name="color"></param>
        /// <returns></returns>
        public int ParseRGB(Color color)
        {
            return (int)(((int)color.B << 16) | (ushort)(((ushort)color.G << 8) | color.R));
        }

        /// <summary>
        /// 从指定的几种颜色中进行随机颜色,传入30个颜色的范围，越大颜色越多
        /// </summary>
        /// <returns></returns>
        public Color GetRandomColor30(int i_randomrange)
        {
            Random r = new Random();
            int n = r.Next(0, i_randomrange);

            Color ret_color;
            switch (n)
            {
                case 1:
                    ret_color = Color.Aqua;
                    break;
                case 2:
                    ret_color = Color.Black;
                    break;
                case 3:
                    ret_color = Color.Blue;
                    break;
                case 4:
                    ret_color = Color.BlueViolet;
                    break;
                case 5:
                    ret_color = Color.Brown;
                    break;
                case 6:
                    ret_color = Color.BurlyWood;
                    break;
                case 7:
                    ret_color = Color.CadetBlue;
                    break;
                case 8:
                    ret_color = Color.CadetBlue;
                    break;
                case 9:
                    ret_color = Color.CornflowerBlue;
                    break;
                case 10:
                    ret_color = Color.DarkBlue;
                    break;
                case 11:
                    ret_color = Color.Gray;
                    break;
                case 12:
                    ret_color = Color.Indigo;
                    break;
                case 13:
                    ret_color = Color.LightSlateGray;
                    break;
                case 14:
                    ret_color = Color.Magenta;
                    break;
                case 15:
                    ret_color = Color.Maroon;
                    break;
                case 16:
                    ret_color = Color.MediumBlue;
                    break;
                case 17:
                    ret_color = Color.MediumOrchid;
                    break;
                case 18:
                    ret_color = Color.MidnightBlue;
                    break;
                case 19:
                    ret_color = Color.Navy;
                    break;
                case 20:
                    ret_color = Color.Olive;
                    break;
                case 21:
                    ret_color = Color.PaleVioletRed;
                    break;
                case 22:
                    ret_color = Color.Peru;
                    break;
                case 23:
                    ret_color = Color.Purple;
                    break;
                case 24:
                    ret_color = Color.Red;
                    break;
                case 25:
                    ret_color = Color.RosyBrown;
                    break;
                case 26:
                    ret_color = Color.RoyalBlue;
                    break;
                case 27:
                    ret_color = Color.SaddleBrown;
                    break;
                case 28:
                    ret_color = Color.SeaGreen;
                    break;
                case 29:
                    ret_color = Color.Teal;
                    break;
                case 30:
                    ret_color = Color.Tomato;
                    break;
                case 31:
                    ret_color = Color.YellowGreen;
                    break;

                default:
                    ret_color = Color.Black;
                    break;
            }

            return ret_color;
        }


        /// <summary>
        /// 打开报表模板进程
        /// </summary>
        private void OpenOTSINcAreportTemplateAPP()
        {
            ReportPrintTool tool = new ReportPrintTool(DEVReport);
            tool.ShowPreview();
        }


        /// <summary>
        /// 打开报表模板进程,颗粒列表
        /// </summary>
        public void OpenOTSINcAreportTemplateAPP_ParticleList(string arg4)
        {
            //----------------------------------
            //共传4个参数
            //参数1:是需要打开db数据库的路径
            //参数2:是打开报表模板xml文件的路径
            //参数3:是要执行查看报表的类型，输出主报表，还是输出颗粒列表
            //参数4:打开主报表时是是指定夹杂物的数量，打开颗粒列表时，是颗粒列表显示的范围如，0-50,50-100
            //参数5:是要执行查看报表的类型，输出主报表时，指定读取的标记帧图图像范围，如0-50,50-100,输出颗粒列表时无用
            //----------------------------------
            ProcessStartInfo process = new ProcessStartInfo();
            process.FileName = "ReportTemplateExe\\OTSIncAReportTemplate.exe";//打开app的路径
            string arg1 = m_strDBpath_ParticleList.Replace(" ", "^");//参数1，是需要打开db数据库的路径
            string arg2 = tb_mblj.Text.Trim().Replace(" ", "^");//参数2，是模板文件的路径
            string arg3 = "ParticleListReport";//颗粒列表
            //string arg4 = "";//夹杂物数量,从多少到多少
            string arg5 = "0";//在打开颗粒列表时，传的标记帧图图像数量参数暂不用
            process.Arguments = string.Format("{0} {1} {2} {3} {4}", arg1, arg2, arg3, arg4, arg5);  //多个参数用空格隔开
            process.WindowStyle = ProcessWindowStyle.Normal;
            Process.Start(process);
        }
        #endregion

        #region 窗体控件事件
        private void OTSReport_Export_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (backgroundWorker2.IsBusy == true)
            {
                //导出线程正在工作中，不让退出该界面
                MessageBox.Show(table["messagebox1"].ToString(), table["messagebox2"].ToString(), MessageBoxButtons.OK, MessageBoxIcon.Information);
                //然后取消关闭窗体的事件
                e.Cancel = true;
            }
        }

      

        private void btn_preview_Click(object sender, EventArgs e)
        {
            
            DEVReport = new OTS_DEVReport(this, m_mbszclass);
            //DEVReport.Dispose();

          
            m_ReportApp.m_rstDataMgr.setSelectedIndex(cbo_sjy.SelectedIndex);
            
            //重新导出报表数据
            m_ReportApp.m_ChartsWindow.Activate();

            WriteRictBox(table["rictbox1"].ToString());
            progressBar1.Value = 0;

            //预览
            if (backgroundWorker2.IsBusy != true)
            {
                // 启动异步操作
                backgroundWorker2.RunWorkerAsync();
            }

        }

        private void button3_Click(object sender, EventArgs e)
        {
            if (File.Exists(tb_lj.Text.Trim()))
            {
                //打开刚才导出的文件
                System.Diagnostics.Process.Start(tb_lj.Text.Trim());
            }
            else
            {
                WriteRictBox(table["rictbox2"].ToString() + tb_lj.Text.Trim() + table["rictbox3"].ToString());
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //退出
            this.Close();
        }

        private void btn_openfilepath_Click(object sender, EventArgs e)
        {
            LoadControlsToXml();
            SaveMBSClass();

        }



        private void btn_selectPath_Click(object sender, EventArgs e)
        {
            //选择保存文件路径对话框
            SaveFileDialog saveFileDialog1 = new SaveFileDialog();

            //获取默认操作的数据源名，用来当做保存的文件名
            saveFileDialog1.FileName = m_ReportApp.m_rstDataMgr.GetSampleName();

            saveFileDialog1.Filter = "Excel (*.xls)|*.xls|Word (*.doc)|*.doc|PDF (*.pdf)|*.pdf";
            saveFileDialog1.FilterIndex = 1;
            saveFileDialog1.RestoreDirectory = true;

            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                if (saveFileDialog1.FilterIndex == 1)
                {
                    //选择输出Excel
                    m_export_type = "Excel";
                }
                if (saveFileDialog1.FilterIndex == 2)
                {
                    //选择输出Word
                    m_export_type = "Word";
                }
                if (saveFileDialog1.FilterIndex == 3)
                {
                    //选择输出PDF
                    m_export_type = "PDF";
                }

                tb_lj.Text = saveFileDialog1.FileName;
            }
        }

        //调用编辑模板窗体
        private void btn_TempDes_Click(object sender, EventArgs e)
        {
            //预览设置
            OTSReport_TemplateDesignerRM OtsTemDRM = new OTSReport_TemplateDesignerRM(this);
            if (OtsTemDRM.ShowDialog() == DialogResult.Yes)
            {
                //如果用户点击确定，则将m_mbszclass,模板设置类的内容存到文件中。
                // m_mbszclass.M_DZ.route = tb_mblj.Text;
                m_mbszclass.M_DZ.route = tb_mblj.Text;
                SaveMBSClass();
            }
        }

        #endregion
       

        #region 导出工作线程部份
        private void backgroundWorker2_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;

            //主任务的实现
            #region //获取模板设置的导出的内容-------------------------------------------------

            //获取报告模板设置内容
            worker.ReportProgress(0, table["rictbox4"].ToString());//已获取模板中设置内容为:
            System.Threading.Thread.Sleep(1);
            //更新进度
            worker.ReportProgress(5);
            #endregion //设置模板导出内容结束--------------------------------------------------------


            int processvalue = 12;//各功能模块从进度条为15时开始依次调用

            #region //依次循环调用各功能模块-------------------------------------------------------------
            int i_zz = 0;//增值
            i_zz = 80 / 9;

            //首先将测量结果信息表导出,在表头------------------------------------------------
            worker.ReportProgress(0, table["result_information_ing"].ToString());//加载测量结果信息表模块中....
            worker.ReportProgress(0, table["load_result_information"].ToString());//加载:测量结果信息表
            //更新进度条
            processvalue = processvalue + 1;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_result_information_completed"].ToString());//加载测量结果信息表模块完成
                                                                                               //-------------------------------------------------------------------------


            //调用,颗粒尺寸分析表------------------------------------------------
            worker.ReportProgress(0, table["dimensional_analysis_table_ing"].ToString());//加载颗粒尺寸分析表模块中....
            worker.ReportProgress(0, table["loading_dimension_analysis_table"].ToString());//加载:颗粒尺寸分析表
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_dimension_analysis_table_completed"].ToString());//加载颗粒尺寸分析表模块完成



            //调用,元素分析表---------------------------------------------
            worker.ReportProgress(0, table["element_analysis_table_ing"].ToString());//加载元素分析表模块中....
            worker.ReportProgress(0, table["load_element_analysis_table"].ToString());//加载:元素分析表
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_element_analysis_table_completed"].ToString());//加载元素分析表模块完成



            //调用,夹杂物面积比表---------------------------------------------
            worker.ReportProgress(0, table["inca_area_ratio_table_ing"].ToString());//加载夹杂物面积比表模块中....
            worker.ReportProgress(0, table["load_inca_area_ratio_table"].ToString());//加载:夹杂物面积比表
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_inca_area_ratio_table_completed"].ToString());//加载夹杂物面积比表模块完成


            //调用,夹杂物面积比图---------------------------------------------
            worker.ReportProgress(0, table["inca_area_ratio_diagram_ing"].ToString());//加载夹杂物面积比图模块中....
            worker.ReportProgress(0, table["load_inca_area_ratio_diagram"].ToString());//加载:夹杂物面积比图
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_inca_area_ratio_diagram_completed"].ToString());//加载夹杂物面积比图模块完成


            //System.Threading.Thread.Sleep(2000);
            //调用,三元相图----------------------------------------------
            worker.ReportProgress(0, table["ternary_graph_ing"].ToString());//加载三元相图模块中....
            worker.ReportProgress(0, table["load_ternary_graph"].ToString());//加载:三元相图
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_ternary_graph_completed"].ToString());//加载三元相图模块完成


            //调用输出，颗粒列表----------------------------------------
            worker.ReportProgress(0, table["particle_list_ing"].ToString());//加载颗粒列表模块中....
            worker.ReportProgress(0, table["load_particle_list"].ToString());//加载:颗粒列表
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_particle_list_completed"].ToString());//加载颗粒列表模块完成



            //调用输出，颗粒列表帧图----------------------------------------
            worker.ReportProgress(0, table["particle_list_frame_diagram_ing"].ToString());//加载颗粒列表帧图模块中....
            worker.ReportProgress(0, table["load_particle_list_frame_diagram"].ToString());//加载:颗粒列表帧图
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["loading_particle_list_frame_diagram_completed"].ToString());//加载颗粒列表帧图模块完成


            //生成，模板临时数据库文件----------------------------------------------
            worker.ReportProgress(0, table["rictbox35"].ToString());//生成模板临时数据库文件....
            worker.ReportProgress(0, table["rictbox36"].ToString());//加载:生成模板临时数据库文件
            //更新进度条
            processvalue = processvalue + i_zz;
            worker.ReportProgress(processvalue);
            lock (m_thread_flag)
                m_thread_flag = table["rictbox7"].ToString();//等待
            while (m_thread_flag == table["rictbox7"].ToString())//等待
            {
                System.Threading.Thread.Sleep(500);
            }
            worker.ReportProgress(0, table["rictbox37"].ToString());//模板临时数据库文件完成

            #endregion 依将循环调用各功能模块结束-------------------------------------------------------
        }
        private string AnalyticGraphics(int a_Indexes)
        {
            if (a_Indexes == 0)
                return "pie";//饼图
            else if (a_Indexes == 1)
                return "radius";//圈图
            else if (a_Indexes == 2)
                return "bar";//柱状图
            else if (a_Indexes == 3)
                return "line";//线状图
            else return "stack";//堆叠图
        }

        private void backgroundWorker2_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            string strNill = table["rictbox40"].ToString();
            BackgroundWorker worker = sender as BackgroundWorker;
          
            //更新进度条的进度
            if (e.UserState != null)
            {
                string ls_str = (string)e.UserState;
                WriteRictBox((string)e.UserState);

                string s = AnalyticGraphics(m_mbszclass.M_KLFXJG.index_cb_jzwfl_xstx);
                if (ls_str.IndexOf(table["rictbox12"].ToString()) > -1)//加载:
                {
                    if (ls_str.IndexOf(table["result_information"].ToString()) > -1)//测量结果信息表
                    {
                        DEVReport.International_language(dev_internationalLanguage());
                        DEVReport.setResultGrid();
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }
                    if (ls_str.IndexOf(table["dimensional_analysis_table"].ToString()) > -1)//颗粒尺寸分析表
                    {

                        if (m_mbszclass.M_KLFXJG.b_ck_klcc_xsmk)
                        {
                            //DEVReport.setParticleSizeTable(true, false);
                            DEVReport.setParticleSizeTable(m_mbszclass.M_KLFXJG.b_ck_klcc_dfl, m_mbszclass.M_KLFXJG.b_ck_klcc_xfl, m_mbszclass.M_KLFXJG.b_ck_klcc_xsddt);
                        }
                            //DEVReport.setParticleSizeTable(true,false);
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }

                    if (ls_str.IndexOf(table["element_analysis_table"].ToString()) > -1)//元素分析表
                    {
                        if (m_mbszclass.M_YSFXJG.b_ck_ysfx_xsmk)
                            DEVReport.setElementAvgGrid();
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }

                    if (ls_str.IndexOf(table["inca_area_ratio_table"].ToString()) > -1)//夹杂物面积比表
                    {
                        if (m_mbszclass.M_JZWZB.b_ck_surface)
                            DEVReport.setINCAtable();
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }

                    if (ls_str.IndexOf(table["inca_area_ratio_diagram"].ToString()) > -1)//夹杂物面积比图
                    {
                        if (m_mbszclass.M_JZWZB.b_ck_chart)
                        {
                            DEVReport.set_incaPIC_classify();
                            DEVReport.set_incaPIC_subdivision();
                        }
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }
                    if (ls_str.IndexOf(table["ternary_graph"].ToString()) > -1)//三元图
                    {
                        if (m_mbszclass.M_SYXT.b_ck_syxt_xsmk)
                            DEVReport.InsertReportTemplateChart_Trianglediagram();
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }

                    if (ls_str.IndexOf(table["particle_list"].ToString()) > -1)//颗粒列表
                    {
                        if (m_mbszclass.M_KLLBXX.b_ck_kllb_xsmk)
                            DEVReport.set_kllb_data();
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }

                    if (ls_str.IndexOf(table["particle_list_frame_diagram"].ToString()) > -1)//颗粒帧图列表
                    {
                        if (m_mbszclass.M_KLLBXX.b_ck_kllb_fjzt)
                            DEVReport.set_kllb_data_frame();
                        
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }
                    if (ls_str.IndexOf(table["rictbox38"].ToString()) > -1)//生成模板临时数据库文件
                    {
                        //DEVReport.International_language(dev_internationalLanguage());
                        lock (m_thread_flag)
                            m_thread_flag = strNill;
                    }
                }
            }
            else
            {
                progressBar1.Value = e.ProgressPercentage;
                WriteRictBox(table["rictbox39"].ToString() + e.ProgressPercentage.ToString() + "%");
            }
        }

        private void backgroundWorker2_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            WriteRictBox(table["rictbox41"].ToString() + m_export_reporttemplate.m_list_dt.Count.ToString() + table["rictbox42"].ToString(), Color.Red);

            //处理结束后,再将button的状态更新回去
            progressBar1.Value = 100;
            WriteRictBox("-----------------"+ table["rictbox43"].ToString() + "--------------------", Color.Red);
            MemoryManagementClass.FlushMemory();



            //导出完成，打开报表
            OpenOTSINcAreportTemplateAPP();
            m_ReportApp.m_conditionChoose.ShowsTheDefaultPic();

            this.Close();
        }
        #endregion

        #region 读取文件
        private void LoadControlsToXml()
        {
            string path = string.Empty;

            OpenFileDialog Load = new OpenFileDialog();
            Load.Filter = "XML File|*.xml";
            Load.InitialDirectory = @System.Windows.Forms.Application.StartupPath + "\\Config\\ProData";
            if (Load.ShowDialog() == DialogResult.OK)
                path = Load.FileName;//赋值目录
            if (path != string.Empty)
            {
                tb_mblj.Text = path;
                m_mbszclass.M_DZ.route = path;
                OTSIncAReportApp.Controls.XmlOperateUtil xmlutil = new OTSIncAReportApp.Controls.XmlOperateUtil(path);
                //首页
                m_mbszclass.M_SY.str_tb_ZBT = xmlutil.Read("M_SY", "str_tb_ZBT");
                m_mbszclass.M_SY.str_tb_FBT = xmlutil.Read("M_SY", "str_tb_FBT");
                m_mbszclass.M_SY.str_tb_YPBH = xmlutil.Read("M_SY", "str_tb_YPBH");
                m_mbszclass.M_SY.str_tb_CKBZ = xmlutil.Read("M_SY", "str_tb_CKBZ");
                m_mbszclass.M_SY.str_bz = xmlutil.Read("M_SY", "str_bz");
                m_mbszclass.M_SY.b_ck_ypsm = Convert.ToBoolean(xmlutil.Read("M_SY", "b_ck_ypsm"));
                m_mbszclass.M_SY.b_ck_jggk = Convert.ToBoolean(xmlutil.Read("M_SY", "b_ck_jggk"));

                m_mbszclass.M_SY.str_xzkl = xmlutil.Read("M_SY", "str_xzkl");
                m_mbszclass.M_SY.int_xzkl = Convert.ToInt32(xmlutil.Read("M_SY", "int_xzkl"));
                //页眉页脚
                m_mbszclass.M_YMYJ.str_tb_ymwb = xmlutil.Read("M_YMYJ", "str_tb_ymwb");
                m_mbszclass.M_YMYJ.str_tb_KHH = xmlutil.Read("M_YMYJ", "str_tb_KHH");
                m_mbszclass.M_YMYJ.b_ck_ym = Convert.ToBoolean(xmlutil.Read("M_YMYJ", "b_ck_ym"));
                m_mbszclass.M_YMYJ.str_tb_yjwb = xmlutil.Read("M_YMYJ", "str_tb_yjwb");
                //颗粒分析结果
                m_mbszclass.M_KLFXJG.b_ck_klcc_xsmk = Convert.ToBoolean(xmlutil.Read("M_KLFXJG", "b_ck_klcc_xsmk"));//是否显示模块
                m_mbszclass.M_KLFXJG.b_ck_klcc_xsddt = Convert.ToBoolean(xmlutil.Read("M_KLFXJG", "b_ck_klcc_xsddt"));
                m_mbszclass.M_KLFXJG.index_cb_klcc_jsfs = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_klcc_jsfs"));//计算方式
                m_mbszclass.M_KLFXJG.index_cb_klcc_ljb = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_klcc_ljb"));//粒级表
                m_mbszclass.M_KLFXJG.index_cb_klcc_klfw = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_klcc_klfw"));//颗粒范围
                m_mbszclass.M_KLFXJG.b_cb_jzwfl_xsmk = Convert.ToBoolean(xmlutil.Read("M_KLFXJG", "b_cb_jzwfl_xsmk"));//是否显示该模块
                m_mbszclass.M_KLFXJG.index_cb_jzwfl_xstx = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_jzwfl_xstx"));//选择图像
                m_mbszclass.M_KLFXJG.index_cb_jzwfl_jsfs = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_jzwfl_jsfs"));//计算方式
                m_mbszclass.M_KLFXJG.index_cb_jzwfl_ljb = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_jzwfl_ljb"));//粒级表
                m_mbszclass.M_KLFXJG.index_cb_jzwfl_klfw = Convert.ToInt32(xmlutil.Read("M_KLFXJG", "index_cb_jzwfl_klfw"));//颗粒范围
                //元素分析结果
                m_mbszclass.M_YSFXJG.b_ck_ysfx_xsmk = Convert.ToBoolean(xmlutil.Read("M_YSFXJG", "b_ck_ysfx_xsmk"));    //是否显示模块
                m_mbszclass.M_YSFXJG.index_cb_yxfx_jsfs = Convert.ToInt32(xmlutil.Read("M_YSFXJG", "index_cb_yxfx_jsfs"));    //计算方式
                m_mbszclass.M_YSFXJG.index_cb_ysfx_klfw = Convert.ToInt32(xmlutil.Read("M_YSFXJG", "index_cb_ysfx_klfw"));    //颗粒范围
                m_mbszclass.M_YSFXJG.str_tb_ysfx_xsys = xmlutil.Read("M_YSFXJG", "str_tb_ysfx_xsys");        //显示元素
                m_mbszclass.M_YSFXJG.list_str_tb_ysfx_xsys.Clear();
                for (int i = 0; i < 100; i++)                              //取得所有元素列表
                {
                    string str = xmlutil.Read("M_YSFXJG", "list_str_tb_ysfx_xsys", "YS" + i.ToString());
                    if (str == null)
                    {
                        break;
                    }
                    else
                    {
                        m_mbszclass.M_YSFXJG.list_str_tb_ysfx_xsys.Add(str);
                    }
                }
                m_mbszclass.M_YSFXJG.b_ck_yscf_xsmk = Convert.ToBoolean(xmlutil.Read("M_YSFXJG", "b_ck_yscf_xsmk"));    //是否显示模块
                m_mbszclass.M_YSFXJG.index_cb_yscf_xstx = Convert.ToInt32(xmlutil.Read("M_YSFXJG", "index_cb_yscf_xstx"));    //显示图形
                m_mbszclass.M_YSFXJG.index_cb_yscf_jsfs = Convert.ToInt32(xmlutil.Read("M_YSFXJG", "index_cb_yscf_jsfs"));    //计算方式
                m_mbszclass.M_YSFXJG.index_cb_yscf_klfw = Convert.ToInt32(xmlutil.Read("M_YSFXJG", "index_cb_yscf_klfw"));    //颗粒范围
                m_mbszclass.M_YSFXJG.str_tb_yscf_ysxx = xmlutil.Read("M_YSFXJG", "str_tb_yscf_ysxx");    //显示元素
                m_mbszclass.M_YSFXJG.list_str_tb_yscf_ysxx.Clear();
                for (int i = 0; i < 100; i++)                              //取得所有元素列表
                {
                    string str = xmlutil.Read("M_YSFXJG", "list_str_tb_yscf_ysxx", "YS" + i.ToString());
                    if (str == null)
                    {
                        break;
                    }
                    else
                    {
                        m_mbszclass.M_YSFXJG.list_str_tb_yscf_ysxx.Add(str);
                    }
                }
                //三元相图
                m_mbszclass.M_SYXT.b_ck_syxt_xsmk = Convert.ToBoolean(xmlutil.Read("M_SYXT", "b_ck_syxt_xsmk"));    //是否显示模块
                m_mbszclass.M_SYXT.index_cb_syxt_jsfs = Convert.ToInt32(xmlutil.Read("M_SYXT", "index_cb_syxt_jsfs"));    //计算方式
                m_mbszclass.M_SYXT.index_cb_syxt_klfw = Convert.ToInt32(xmlutil.Read("M_SYXT", "index_cb_syxt_klfw"));    //颗粒范围
                m_mbszclass.M_SYXT.str_cb_syxt_mhxssl = xmlutil.Read("M_SYXT", "str_cb_syxt_mhxssl");    //每行显示数量
                m_mbszclass.M_SYXT.list_lbv_syxt_mblb.Clear();
                for (int i = 0; i < 100; i++)                              //取得所有模板列表
                {
                    string str = xmlutil.Read("M_SYXT", "list_lbv_syxt_mblb", "MB" + i.ToString());
                    if (str == null)
                    {
                        break;
                    }
                    else
                    {
                        m_mbszclass.M_SYXT.list_lbv_syxt_mblb.Add(str);
                    }
                }
                m_mbszclass.M_SYXT.list_lbv_syxt_mblb_index.Clear();
                for (int i = 0; i < 100; i++)                              //取得所有模板列表 索引
                {
                    string str = xmlutil.Read("M_SYXT", "list_lbv_syxt_mblb_index", "MBIndex" + i.ToString());
                    if (str == null)
                    {
                        break;
                    }
                    else
                    {
                        m_mbszclass.M_SYXT.list_lbv_syxt_mblb_index.Add(Convert.ToInt32(str));
                    }
                }
                //颗粒列表信息
                m_mbszclass.M_KLLBXX.b_ck_kllb_xsmk = Convert.ToBoolean(xmlutil.Read("M_KLLBXX", "b_ck_kllb_xsmk"));    //是否显示模块
                m_mbszclass.M_KLLBXX.index_cb_kllb_jsfs = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_jsfs"));    //计算方式
                m_mbszclass.M_KLLBXX.index_cb_kllb_klfw = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_klfw"));    //颗粒范围
                m_mbszclass.M_KLLBXX.int_tb_kllb_ylsx = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "int_tb_kllb_ylsx"));    //数量上限
                m_mbszclass.M_KLLBXX.str_tb_kllb_sxys = xmlutil.Read("M_KLLBXX", "str_tb_kllb_sxys");    //显示元素
                m_mbszclass.M_KLLBXX.list_str_tb_lllb_sxys.Clear();
                for (int i = 0; i < 100; i++)                              //取得所有元素列表
                {
                    string str = xmlutil.Read("M_KLLBXX", "list_str_tb_lllb_sxys", "YS" + i.ToString());
                    if (str == null)
                    {
                        break;
                    }
                    else
                    {
                        m_mbszclass.M_KLLBXX.list_str_tb_lllb_sxys.Add(str);
                    }
                }
                m_mbszclass.M_KLLBXX.b_ck_kllb_ystx = Convert.ToBoolean(xmlutil.Read("M_KLLBXX", "b_ck_kllb_ystx"));    //原始图像
                m_mbszclass.M_KLLBXX.b_ck_kllb_fdtx = Convert.ToBoolean(xmlutil.Read("M_KLLBXX", "b_ck_kllb_fdtx"));    //放大图像
                m_mbszclass.M_KLLBXX.b_ck_kllb_npxx = Convert.ToBoolean(xmlutil.Read("M_KLLBXX", "b_ck_kllb_npxx"));    //能谱图像

              
               
                m_mbszclass.M_KLLBXX.str_cb_kllb_sort_p1 = Convert.ToString(xmlutil.Read("M_KLLBXX", "str_cb_kllb_sort_p1"));//颗粒列表列中第一个可选参数
                m_mbszclass.M_KLLBXX.index_cb_kllb_sort_p1 = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_sort_p1"));
                m_mbszclass.M_KLLBXX.str_cb_kllb_sort_p2 = Convert.ToString(xmlutil.Read("M_KLLBXX", "str_cb_kllb_sort_p2"));//颗粒列表中第二个可选参数
                m_mbszclass.M_KLLBXX.index_cb_kllb_sort_p2 = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_sort_p2"));
                m_mbszclass.M_KLLBXX.str_cb_kllb_sort_p3 = Convert.ToString(xmlutil.Read("M_KLLBXX", "str_cb_kllb_sort_p3"));//颗粒列表中第三个可选参数
                m_mbszclass.M_KLLBXX.index_cb_kllb_sort_p3 = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_sort_p3"));
                m_mbszclass.M_KLLBXX.str_cb_kllb_chartSort_p1 = Convert.ToString(xmlutil.Read("M_KLLBXX", "str_cb_kllb_chartSort_p1"));//帧图表列中第一个可选参数
                m_mbszclass.M_KLLBXX.index_cb_kllb_chartSort_p1 = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_chartSort_p1"));
                m_mbszclass.M_KLLBXX.str_cb_kllb_chartSort_p2 = Convert.ToString(xmlutil.Read("M_KLLBXX", "str_cb_kllb_chartSort_p2"));//帧图表列中第二个可选参数
                m_mbszclass.M_KLLBXX.index_cb_kllb_chartSort_p2 = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_chartSort_p2"));
                //m_mbszclass.M_KLLBXX.str_cb_kllb_chartSort_p3 = Convert.ToString(xmlutil.Read("M_KLLBXX", "str_cb_kllb_chartSort_p3"));//帧图表列中第三个可选参数
                //m_mbszclass.M_KLLBXX.index_cb_kllb_chartSort_p3 = Convert.ToInt32(xmlutil.Read("M_KLLBXX", "index_cb_kllb_chartSort_p3"));
                m_mbszclass.M_KLLBXX.list_int_kllb_number= Convert.ToInt32(xmlutil.Read("M_KLLBXX", "list_int_kllb_number"));//保存显示颗粒数量
            }
        }

        #endregion

        private void button7_Click(object sender, EventArgs e)
        {

            OTSReport_criterion criterion = new OTSReport_criterion(m_export_reporttemplate, GB_Report,this);
            criterion.Sample_order = cbo_sjy.SelectedIndex;
            criterion.Language_dt = dev_internationalLanguage();
            criterion.ShowDialog();

        }

      
       
        private void OTSReport_Export_FormClosed(object sender, FormClosedEventArgs e)
        {
           
        }

        private void button1_Click(object sender, EventArgs e)
        {
            DEVReport = new OTS_DEVReport(this, m_mbszclass);
            //DEVReport.Dispose();
            //DEVReport = new OTS_DEVReport(this);

            DEVReport.setResultGrid();
            DEVReport.setParticleSizeTable(true,true,true);
            DEVReport.setElementAvgGrid();
            DEVReport.setINCAtable();
            DEVReport.set_incaPIC_classify();
            DEVReport.set_incaPIC_subdivision();

            DEVReport.InsertReportTemplateChart_Trianglediagram();
            DEVReport.set_kllb_data();


            DEVReport.set_kllb_data_frame();
            DEVReport.International_language(dev_internationalLanguage());


            ReportPrintTool tool = new ReportPrintTool(DEVReport);
            tool.ShowPreview();

          
        }

          /// <summary>
        /// 从数据库中读取语言配置信息
        /// </summary>
        /// <returns></returns>
        private DataTable dev_internationalLanguage()
        {
            string Language = "ZH";
            OTSCommon.SqLiteHelper sh = new OTSCommon.SqLiteHelper("data source='" + System.IO.Directory.GetCurrentDirectory() + "\\Config\\ReportTemplate\\language.db'");
            DataTable dt_stl = sh.ExecuteQuery("select * from "+ Language);
            return dt_stl;
        }

        private void button2_Click_1(object sender, EventArgs e)
        {
       
        }
    }
    
}