OTS/OTSIncAReportApp/1-UI/GBCalculate/NationalStandardMethodTwo.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using OTSCLRINTERFACE;
using System.Collections;
using OTSCommon;

namespace OTSIncAReportGB
{
    public partial class NationalStandardMethodTwo : UserControl
    {
        #region 全局变量
        //设置数据表
        public DataTable m_dt_A = new DataTable();
        public DataTable m_dt_B = new DataTable();
        public DataTable m_dt_C = new DataTable();
        public DataTable m_dt_D = new DataTable();
        public DataTable m_dt_sulfide = new DataTable();
        public DataTable m_dt_DS = new DataTable();

        //底层相关,项目操作管理类
        CReportMgrClr m_ReportMgrClr = null;


        //获取从框架得到的底层计算结果,国标表A
        List<CGridDataClr> m_list_cgriddataclr_A = null;

        //获取从框架得到的底层计算结果,国标表B
        List<CGridDataClr> m_list_cgriddataclr_B = null;

        //获取从框架得到的底层计算结果,国标表C
        List<CGridDataClr> m_list_cgriddataclr_C = null;

        //获取从框架得到的底层计算结果,国标表D
        List<CGridDataClr> m_list_cgriddataclr_D = null;

        //获取从框架得到的底层计算结果,国标表D硫化物表
        List<CGridDataClr> m_list_cgriddataclr_sulfide = null;

        //获取从框架得到的底层计算结果,国标表DS
        List<CGridDataClr> m_list_cgriddataclr_DS = null;

        //定义一个组List
        List<CGridDataClr> m_list_ALLTwo = null;

        //接收底层数据
        public List<CGridDataClr> DataAll;
        //一个数据源包含几个列数的记录数
        private int m_oneresult_columnscount_A = 3;
        private int m_oneresult_columnscount_B = 3;
        private int m_oneresult_columnscount_C = 3;
        private int m_oneresult_columnscount_D = 3;
        private int m_oneresult_columnscount_sulfide = 3;
        private int m_oneresult_columnscount_DS = 3;


        string str_result = "";
        #endregion

        #region 自定义方法

        private void SetDataGridViewStyleAll()
        {
            //用户不能调整标题的高度
            Gview_gzA.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //用户不能调整 行高
            Gview_gzA.AllowUserToResizeRows = false;

            //改变行的高度;
            //Gview_gz.RowTemplate.Height = 20;

            //点击选择整行
            Gview_gzA.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

            //居中显示
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleCenter;
            Gview_gzA.DefaultCellStyle = dataGridViewCellStyle1;
            Gview_gzA.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;

            //再次重覆禁用拖动表头高度，居然有效果了
            Gview_gzA.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //设置grid可以复制
            Gview_gzA.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;

        }

        /// <summary>
        /// 设置DataGridView样式,B类表
        /// </summary>
        private void SetDataGridViewStyleB()
        {
            //用户不能调整标题的高度
            Gview_gzB.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //用户不能调整 行高
            Gview_gzB.AllowUserToResizeRows = false;

            //改变行的高度;
            //Gview_gz.RowTemplate.Height = 20;

            //点击选择整行
            Gview_gzB.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

            //居中显示
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleCenter;
            Gview_gzB.DefaultCellStyle = dataGridViewCellStyle1;
            Gview_gzB.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;

            //再次重覆禁用拖动表头高度，居然有效果了
            Gview_gzB.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //设置grid可以复制
            Gview_gzB.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;

            //设置每列的宽度
            Gview_gzB.Columns[0].Width = 40;//第一列序号的宽度设置一下吧，要不太丑

            //设置序号列不排序
            Gview_gzB.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;

            //设置序号列不可以设置宽度
            Gview_gzB.Columns[0].Resizable = DataGridViewTriState.False;

        }

        /// <summary>
        /// 设置DataGridView样式,C类表
        /// </summary>
        private void SetDataGridViewStyleC()
        {
            //用户不能调整标题的高度
            Gview_gzC.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //用户不能调整 行高
            Gview_gzC.AllowUserToResizeRows = false;

            //改变行的高度;
            //Gview_gz.RowTemplate.Height = 20;

            //点击选择整行
            Gview_gzC.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

            //居中显示
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleCenter;
            Gview_gzC.DefaultCellStyle = dataGridViewCellStyle1;
            Gview_gzC.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;

            //再次重覆禁用拖动表头高度，居然有效果了
            Gview_gzC.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //设置grid可以复制
            Gview_gzC.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;

            //设置每列的宽度
            Gview_gzC.Columns[0].Width = 40;//第一列序号的宽度设置一下吧，要不太丑

            //设置序号列不排序
            Gview_gzC.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;

            //设置序号列不可以设置宽度
            Gview_gzC.Columns[0].Resizable = DataGridViewTriState.False;

        }

        /// <summary>
        /// 设置DataGridView样式,D类表
        /// </summary>
        private void SetDataGridViewStyleD()
        {
            //用户不能调整标题的高度
            Gview_gzD.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //用户不能调整 行高
            Gview_gzD.AllowUserToResizeRows = false;

            //改变行的高度;
            //Gview_gz.RowTemplate.Height = 20;

            //点击选择整行
            Gview_gzD.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

            //居中显示
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleCenter;
            Gview_gzD.DefaultCellStyle = dataGridViewCellStyle1;
            Gview_gzD.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;

            //再次重覆禁用拖动表头高度，居然有效果了
            Gview_gzD.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //设置grid可以复制
            Gview_gzD.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;

            //设置每列的宽度
            Gview_gzD.Columns[0].Width = 40;//第一列序号的宽度设置一下吧，要不太丑

            //设置序号列不排序
            Gview_gzD.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;

            //设置序号列不可以设置宽度
            Gview_gzD.Columns[0].Resizable = DataGridViewTriState.False;

        }

        /// <summary>
        /// 设置DataGridView样式,DS类表
        /// </summary>
        private void SetDataGridViewStyleDS()
        {
            //用户不能调整标题的高度
            Gview_gzDS.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //用户不能调整 行高
            Gview_gzDS.AllowUserToResizeRows = false;

            //改变行的高度;
            //Gview_gz.RowTemplate.Height = 20;

            //点击选择整行
            Gview_gzDS.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

            //居中显示
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleCenter;
            Gview_gzDS.DefaultCellStyle = dataGridViewCellStyle1;
            Gview_gzDS.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;

            //再次重覆禁用拖动表头高度，居然有效果了
            Gview_gzDS.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

            //设置grid可以复制
            Gview_gzDS.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;

            //设置每列的宽度
            Gview_gzDS.Columns[0].Width = 40;//第一列序号的宽度设置一下吧，要不太丑

            //设置序号列不排序
            Gview_gzDS.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;

            //设置序号列不可以设置宽度
            Gview_gzDS.Columns[0].Resizable = DataGridViewTriState.False;

        }


        #endregion

        #region 窗体加载及初始化
        public NationalStandardMethodTwo()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 国标报表，构造函数，接收A,B,C,D,DS五种结果，并进行显示
        /// </summary>
        /// <param name="in_sec"></param>
        /// <param name="in_Cotsreportprojfilemgrclr"></param>       
        /// <param name="in_list_CGridDataClrAll"></param>   //all  代表A、B、C、D、DS按顺序得表
        public string ColumnName;
        public string RowName;
        #region 国际化语言
        Language lan;
        Hashtable table;
        #endregion
        public NationalStandardMethodTwo(CReportMgrClr in_Cotsreportprojfilemgrclr, List<CGridDataClr> in_list_CGridDataClrAll)
        {

            DataAll = in_list_CGridDataClrAll;

            //获取报告项目类对象
            m_ReportMgrClr = in_Cotsreportprojfilemgrclr;

            m_list_cgriddataclr_A = in_list_CGridDataClrAll.GetRange(0, 1);
            m_list_cgriddataclr_B = in_list_CGridDataClrAll.GetRange(1, 1);
            m_list_cgriddataclr_C = in_list_CGridDataClrAll.GetRange(2, 1);
            m_list_cgriddataclr_D = in_list_CGridDataClrAll.GetRange(3, 1);
            m_list_cgriddataclr_sulfide = in_list_CGridDataClrAll.GetRange(4, 1);
            m_list_cgriddataclr_DS = in_list_CGridDataClrAll.GetRange(5, 1);

            m_list_ALLTwo = in_list_CGridDataClrAll;


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

            log_1.Text = "";
            log_2.Text = "";
            log_3.Text = "";
            log_4.Text = "";
            log_5.Text = "";
            //log_6.Text = "";
            log_1_1.Text = "";
            log_2_1.Text = "";
            log_3_1.Text = "";
            log_4_1.Text = "";
            log_5_1.Text = "";
            //log_6_1.Text = "";
        }

        private void NationalStandardMethodTwo_Load(object sender, EventArgs e)
        {

            //从底层结果类对象中，分解出数据保存到datatable中

            if (m_list_ALLTwo.Count > 7)
            {
                int SouseData = (m_ReportMgrClr.GetSmplMsrResultMgrs().Count) * 7;
                for (int g = 0; g < m_ReportMgrClr.GetSmplMsrResultMgrs().Count; g++)
                {
                    for (int i = 0; i < 6; i++)
                    {
                        DataTable dt = new DataTable();
                        DataColumn cc = new DataColumn();
                        int q = g * 7 + i;
                        dt = ChineseStandardABCD_GetDataTable_Total(DataAll.GetRange(q, 1), out m_oneresult_columnscount_A);
                        DataGridView aa = new DataGridView();
                        int start = 68;
                        int end = 0;
                        end = 150 * q;
                        aa.Location = new Point(start, end);
                        aa.Width = panel1.Width;
                        aa.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
                        aa.BackgroundColor = Color.White;
                        panel1.Controls.Add(aa);
                        aa.DataSource = dt;
                        aa.Name = i.ToString();

                        Label bb = new Label();
                        int startLabel = 0;
                        int endLabel = 0;
                        endLabel = 150 * q;
                        bb.Location = new Point(startLabel, endLabel);
                        bb.Width = 75;
                        for (int t = 0; t < SouseData; t++)
                        {
                            if (i == t * 6)
                            {
                                bb.Text = table["label1"].ToString();
                                break;
                            }
                            if (i == t * 6 + 1)
                            {
                                bb.Text = table["label2"].ToString();
                            }
                            if (i == t * 6 + 2)
                            {
                                bb.Text = table["label3"].ToString();
                            }
                            if (i == t * 6 + 3)
                            {
                                bb.Text = table["label4"].ToString();
                            }
                            if (i == t * 6 + 4)
                            {
                                bb.Text = table["label5"].ToString();
                            }
                            if (i == t * 6 + 5)
                            {
                                bb.Text = table["label6"].ToString();
                            }

                        }
                        bb.Font = new Font(bb.Font.Name, 12, FontStyle.Bold | FontStyle.Underline);
                        panel1.Controls.Add(bb);

                    }
                }


                Gview_gzA.Visible = false;
                Gview_gzB.Visible = false;
                Gview_gzC.Visible = false;
                Gview_gzD.Visible = false;
                sulfide.Visible = false;
                Gview_gzDS.Visible = false;
                label1.Visible = false;
                label2.Visible = false;
                label3.Visible = false;
                label4.Visible = false;
                label5.Visible = false;
                label6.Visible = false;
                Invalidate();
            }
            else
            {
                m_dt_A = ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_A, out m_oneresult_columnscount_A);
                m_dt_B = ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_B, out m_oneresult_columnscount_B);
                m_dt_C = ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_C, out m_oneresult_columnscount_C);
                m_dt_D = ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_D, out m_oneresult_columnscount_D);
                m_dt_sulfide = ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_sulfide, out m_oneresult_columnscount_sulfide);
                m_dt_DS = ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_DS, out m_oneresult_columnscount_DS);

                DataView dv = m_dt_DS.DefaultView;
                dv.Sort = "Grade desc";
                DataTable dt_DS_data = dv.ToTable();

                Gview_gzA.DataSource = m_dt_A;
                for (int i = 0; i < 13; i++)
                {
                    Gview_gzA.Columns[i].Width = 68;
                }
                Gview_gzB.DataSource = m_dt_B;
                for (int i = 0; i < 13; i++)
                {
                    Gview_gzB.Columns[i].Width = 68;
                }
                Gview_gzC.DataSource = m_dt_C;
                for (int i = 0; i < 13; i++)
                {
                    Gview_gzC.Columns[i].Width = 68;
                }
                Gview_gzD.DataSource = m_dt_D;
                for (int i = 0; i < 13; i++)
                {
                    Gview_gzD.Columns[i].Width = 68;
                }
                sulfide.DataSource = m_dt_sulfide;
                for (int i = 0; i < 13; i++)
                {
                    sulfide.Columns[i].Width = 68;
                }
             
                Gview_gzDS.DataSource = dt_DS_data;

                Gview_gzA.Width = panel1.Width;
                Gview_gzB.Width = panel1.Width;
                Gview_gzC.Width = panel1.Width;
                Gview_gzD.Width = panel1.Width;
                sulfide.Width = panel1.Width;
                Gview_gzDS.Width = panel1.Width;



                int it = 0;
                if(DetermineWhetherImprovementIsNeeded("A类", m_dt_A))
                {
                    str_result = str_result + "夹杂物评级达到2.0：表明钢中的MnS或硫化物夹杂物控制不够理想。" +
                        "针对这一问题，我们建议您在相关工艺上进行优化和改进。";
                    LabelAssignment(it);
                    it++;
                    str_result = "";
                }
                if(DetermineWhetherImprovementIsNeeded("B类", m_dt_B))
                {
                    str_result = str_result + "夹杂物评级达到2.0：表明钢中的铝酸盐或其他不变形氧化物夹杂物控制不够理想。" +
                        "针对这一问题，我们建议您在相关工艺上进行优化和改进。";
                    LabelAssignment(it);
                    it++;
                    str_result = "";
                }
                if(DetermineWhetherImprovementIsNeeded("C类", m_dt_C))
                {
                    str_result = str_result + "夹杂物评级达到2.0：表明钢中的硅酸盐过其他可变性氧化物夹杂物控制不够理想。" +
                        "针对这一问题，我们建议您在相关工艺上进行优化和改进。";
                    LabelAssignment(it);
                    it++;
                    str_result = "";
                }
                if (DetermineWhetherImprovementIsNeeded("D类", m_dt_D))
                {
                    str_result = str_result + "夹杂物评级达到2.0：表明钢中的单颗粒球状氧化物夹杂物控制不够理想。" +
                        "针对这一问题，我们建议您在相关工艺上进行优化和改进。";
                    LabelAssignment(it);
                    it++;
                    str_result = "";
                }
                if (DetermineWhetherImprovementIsNeeded("D硫化物类", m_dt_sulfide))
                {
                    str_result = str_result + "夹杂物评级达到2.0：表明钢中的球状硫化物夹杂物控制不够理想。" +
                        "针对这一问题，我们建议您在相关工艺上进行优化和改进。";
                    LabelAssignment(it);
                    it++;
                    str_result = "";
                }
              

            }

            Invalidate();

        }
        private void LabelAssignment(int it)
        {
            if (it == 0)
            {
                log_1.Text = str_result;
                log_1_1.Text = "为了获取更具体的改进措施，您可以随时联系我们公司的软件售后服务团队，" +
             "我们的炼钢工艺专家将为您提供专业的建议和支持。";
            }
            else if (it == 1)
            {
                log_2.Text = str_result;
                log_2_1.Text = "为了获取更具体的改进措施，您可以随时联系我们公司的软件售后服务团队，" +
            "我们的炼钢工艺专家将为您提供专业的建议和支持。";
            }
            else if (it == 2)
            {
                log_3.Text = str_result;
                log_3_1.Text = "为了获取更具体的改进措施，您可以随时联系我们公司的软件售后服务团队，" +
            "我们的炼钢工艺专家将为您提供专业的建议和支持。";
            }
            else if (it == 3)
            {
                log_4.Text = str_result;
                log_4_1.Text = "为了获取更具体的改进措施，您可以随时联系我们公司的软件售后服务团队，" +
            "我们的炼钢工艺专家将为您提供专业的建议和支持。";
            }
            else if (it == 4)
            {
                log_5.Text = str_result;
                log_5_1.Text = "为了获取更具体的改进措施，您可以随时联系我们公司的软件售后服务团队，" +
            "我们的炼钢工艺专家将为您提供专业的建议和支持。";
            }
        }
        private bool DetermineWhetherImprovementIsNeeded(string str, DataTable data)
        {

            string Thin = ""; string Thick = ""; string OverSize = "";
            for (int i = 6; i < data.Columns.Count; i++)
            {
                if (Convert.ToInt32(data.Rows[0][i]) > 0)
                {
                    Thin = "细系";
                }
                if (Convert.ToInt32(data.Rows[1][i]) > 0)
                {
                    Thick = "粗系";
                }
                if (Convert.ToInt32(data.Rows[2][i]) > 0)
                {
                    OverSize = "超尺寸";
                }
            }

            if (Thin != "" || Thick != "" || OverSize != "")
            {
                str_result = str + "的" + Thin + Thick + OverSize;
                return true;

            }
            return false;
        }
        #endregion

        #region 相关事件
        /// <summary>
        /// 复制选择区域,A
        /// </summary>
        public void CopySelected_A()
        {
            //复制选择区域
            object oo = Gview_gzA.GetClipboardContent();
            Clipboard.SetDataObject(Gview_gzA.GetClipboardContent());
        }

        /// <summary>
        /// 复制选择区域,B
        /// </summary>
        public void CopySelected_B()
        {
            //复制选择区域
            object oo = Gview_gzB.GetClipboardContent();
            Clipboard.SetDataObject(Gview_gzA.GetClipboardContent());
        }

        /// <summary>
        /// 复制选择区域,C
        /// </summary>
        public void CopySelected_C()
        {
            //复制选择区域
            object oo = Gview_gzC.GetClipboardContent();
            Clipboard.SetDataObject(Gview_gzA.GetClipboardContent());
        }

        /// <summary>
        /// 复制选择区域,D
        /// </summary>
        public void CopySelected_D()
        {
            //复制选择区域
            object oo = Gview_gzD.GetClipboardContent();
            Clipboard.SetDataObject(Gview_gzA.GetClipboardContent());
        }

        /// <summary>
        /// 复制选择区域,DS
        /// </summary>
        public void CopySelected_DS()
        {
            //复制选择区域
            object oo = Gview_gzDS.GetClipboardContent();
            Clipboard.SetDataObject(Gview_gzA.GetClipboardContent());
        }

        /// <summary>
        /// 复制所有,A
        /// </summary>
        public void CopyAll_A()
        {
            Gview_gzA.SelectAll();
            Clipboard.SetDataObject(Gview_gzA.GetClipboardContent());
        }

        /// <summary>
        /// 复制所有,B
        /// </summary>
        public void CopyAll_B()
        {
            Gview_gzB.SelectAll();
            Clipboard.SetDataObject(Gview_gzB.GetClipboardContent());
        }

        /// <summary>
        /// 复制所有,C
        /// </summary>
        public void CopyAll_C()
        {
            Gview_gzC.SelectAll();
            Clipboard.SetDataObject(Gview_gzC.GetClipboardContent());
        }

        /// <summary>
        /// 复制所有,D
        /// </summary>
        public void CopyAll_D()
        {
            Gview_gzD.SelectAll();
            Clipboard.SetDataObject(Gview_gzD.GetClipboardContent());
        }

        /// <summary>
        /// 复制所有,DS
        /// </summary>
        public void CopyAll_DS()
        {
            Gview_gzDS.SelectAll();
            Clipboard.SetDataObject(Gview_gzDS.GetClipboardContent());
        }

        private void Gview_gzA_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            //排序中
            if (this.Gview_gzA.Rows[e.RowIndex1].Tag != null && this.Gview_gzA.Rows[e.RowIndex1].Tag.ToString() == "统计行")
            {
                //ROW1>ROW2  
                e.SortResult = 1;
                if (this.Gview_gzA.SortOrder == SortOrder.Descending)
                    e.SortResult = -1;
                e.Handled = true;
                return;
            }

            if (this.Gview_gzA.Rows[e.RowIndex2].Tag != null && this.Gview_gzA.Rows[e.RowIndex2].Tag.ToString() == "统计行")
            {
                //ROW1<ROW2  
                e.SortResult = -1;
                if (this.Gview_gzA.SortOrder == SortOrder.Descending)
                    e.SortResult = 1;
                e.Handled = true;
                return;
            }
        }

        private void Gview_gzA_Sorted(object sender, EventArgs e)
        {
            //排序完成，重新设置序号
            for (int i = 0; i < Gview_gzA.Rows.Count; i++)
            {
                if (Gview_gzA.Rows[i].Tag != null && this.Gview_gzA.Rows[i].Tag.ToString() == "统计行")
                { }
                else
                {
                    Gview_gzA.Rows[i].Cells[0].Value = i.ToString();
                }
            }
        }

        private void Gview_gzB_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            //排序中
            if (this.Gview_gzB.Rows[e.RowIndex1].Tag != null && this.Gview_gzB.Rows[e.RowIndex1].Tag.ToString() == "统计行")
            {
                //ROW1>ROW2  
                e.SortResult = 1;
                if (this.Gview_gzB.SortOrder == SortOrder.Descending)
                    e.SortResult = -1;
                e.Handled = true;
                return;
            }

            if (this.Gview_gzB.Rows[e.RowIndex2].Tag != null && this.Gview_gzB.Rows[e.RowIndex2].Tag.ToString() == "统计行")
            {
                //ROW1<ROW2  
                e.SortResult = -1;
                if (this.Gview_gzB.SortOrder == SortOrder.Descending)
                    e.SortResult = 1;
                e.Handled = true;
                return;
            }
        }

        private void Gview_gzB_Sorted(object sender, EventArgs e)
        {
            //排序完成，重新设置序号
            for (int i = 0; i < Gview_gzB.Rows.Count; i++)
            {
                if (Gview_gzB.Rows[i].Tag != null && this.Gview_gzB.Rows[i].Tag.ToString() == "统计行")
                { }
                else
                {
                    Gview_gzB.Rows[i].Cells[0].Value = i.ToString();
                }
            }
        }

        private void Gview_gzC_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            //排序中
            if (this.Gview_gzC.Rows[e.RowIndex1].Tag != null && this.Gview_gzC.Rows[e.RowIndex1].Tag.ToString() == "统计行")
            {
                //ROW1>ROW2  
                e.SortResult = 1;
                if (this.Gview_gzC.SortOrder == SortOrder.Descending)
                    e.SortResult = -1;
                e.Handled = true;
                return;
            }

            if (this.Gview_gzC.Rows[e.RowIndex2].Tag != null && this.Gview_gzC.Rows[e.RowIndex2].Tag.ToString() == "统计行")
            {
                //ROW1<ROW2  
                e.SortResult = -1;
                if (this.Gview_gzC.SortOrder == SortOrder.Descending)
                    e.SortResult = 1;
                e.Handled = true;
                return;
            }
        }

        private void Gview_gzC_Sorted(object sender, EventArgs e)
        {
            //排序完成，重新设置序号
            for (int i = 0; i < Gview_gzC.Rows.Count; i++)
            {
                if (Gview_gzC.Rows[i].Tag != null && this.Gview_gzC.Rows[i].Tag.ToString() == "统计行")
                { }
                else
                {
                    Gview_gzC.Rows[i].Cells[0].Value = i.ToString();
                }
            }
        }

        private void Gview_gzD_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            //排序中
            if (this.Gview_gzD.Rows[e.RowIndex1].Tag != null && this.Gview_gzD.Rows[e.RowIndex1].Tag.ToString() == "统计行")
            {
                //ROW1>ROW2  
                e.SortResult = 1;
                if (this.Gview_gzD.SortOrder == SortOrder.Descending)
                    e.SortResult = -1;
                e.Handled = true;
                return;
            }

            if (this.Gview_gzD.Rows[e.RowIndex2].Tag != null && this.Gview_gzD.Rows[e.RowIndex2].Tag.ToString() == "统计行")
            {
                //ROW1<ROW2  
                e.SortResult = -1;
                if (this.Gview_gzD.SortOrder == SortOrder.Descending)
                    e.SortResult = 1;
                e.Handled = true;
                return;
            }
        }

        private void Gview_gzD_Sorted(object sender, EventArgs e)
        {
            //排序完成，重新设置序号
            for (int i = 0; i < Gview_gzD.Rows.Count; i++)
            {
                if (Gview_gzD.Rows[i].Tag != null && this.Gview_gzD.Rows[i].Tag.ToString() == "统计行")
                { }
                else
                {
                    Gview_gzD.Rows[i].Cells[0].Value = i.ToString();
                }
            }
        }

        private void Gview_gzDS_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            //排序中
            if (this.Gview_gzDS.Rows[e.RowIndex1].Tag != null && this.Gview_gzDS.Rows[e.RowIndex1].Tag.ToString() == "统计行")
            {
                //ROW1>ROW2  
                e.SortResult = 1;
                if (this.Gview_gzDS.SortOrder == SortOrder.Descending)
                    e.SortResult = -1;
                e.Handled = true;
                return;
            }

            if (this.Gview_gzDS.Rows[e.RowIndex2].Tag != null && this.Gview_gzDS.Rows[e.RowIndex2].Tag.ToString() == "统计行")
            {
                //ROW1<ROW2  
                e.SortResult = -1;
                if (this.Gview_gzDS.SortOrder == SortOrder.Descending)
                    e.SortResult = 1;
                e.Handled = true;
                return;
            }
        }

        private void Gview_gzDS_Sorted(object sender, EventArgs e)
        {
            //排序完成，重新设置序号
            for (int i = 0; i < Gview_gzDS.Rows.Count; i++)
            {
                if (Gview_gzDS.Rows[i].Tag != null && this.Gview_gzDS.Rows[i].Tag.ToString() == "统计行")
                { }
                else
                {
                    Gview_gzDS.Rows[i].Cells[0].Value = i.ToString();
                }
            }
        }

        private void ToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            //A,复制整个表
            CopyAll_A();
        }

        private void ToolStripMenuItem2_Click(object sender, EventArgs e)
        {
            //A,复制选择区域
            CopySelected_A();
        }

        private void toolStripMenuItem4_Click(object sender, EventArgs e)
        {
            //B，复制整个表
            CopyAll_B();
        }

        private void toolStripMenuItem5_Click(object sender, EventArgs e)
        {
            //B,复制选择区域
            CopySelected_B();
        }

        private void toolStripMenuItem7_Click(object sender, EventArgs e)
        {
            //C，复制整个表
            CopyAll_C();
        }

        private void toolStripMenuItem8_Click(object sender, EventArgs e)
        {
            //C,复制选择区域
            CopySelected_C();
        }

        private void toolStripMenuItem10_Click(object sender, EventArgs e)
        {
            //D，复制整个表
            CopyAll_D();
        }

        private void toolStripMenuItem11_Click(object sender, EventArgs e)
        {
            //D,复制选择区域
            CopySelected_D();
        }

        private void toolStripMenuItem13_Click(object sender, EventArgs e)
        {
            //DS，复制整个表
            CopyAll_DS();
        }

        private void toolStripMenuItem14_Click(object sender, EventArgs e)
        {
            //DS,复制选择区域
            CopySelected_DS();
        }
        #endregion

        #region 获取向导出模块提供的DataTable和GridView对象
        /// <summary>
        /// 获取到该模块输出后形成的DataTable,和GridView
        /// </summary>
        /// <param name="out_dt"></param>
        /// <param name="out_dg"></param>
        public void GetDataTableAndGridView(out DataTable out_dtA, out DataTable out_dtB, out DataTable out_dtC, out DataTable out_dtD, out DataTable out_dt_sulfide, out DataTable out_dtDS,
        out DataGridView out_dgA, out DataGridView out_dgB, out DataGridView out_dgC, out DataGridView out_dgD, out DataGridView out_dgsulfide, out DataGridView out_dgDS)
        {

            //从panel中找出前5个datagridview,然后进行输出
            foreach (Control ctl in this.panel1.Controls)
            {
                if (ctl.Name == "0")
                {
                    this.Gview_gzA = (DataGridView)ctl;
                }
                if (ctl.Name == "1")
                {
                    this.Gview_gzB = (DataGridView)ctl;
                }
                if (ctl.Name == "2")
                {
                    this.Gview_gzC = (DataGridView)ctl;
                }
                if (ctl.Name == "3")
                {
                    this.Gview_gzD = (DataGridView)ctl;
                }
                if (ctl.Name == "4")
                {
                    this.sulfide = (DataGridView)ctl;
                }
                if (ctl.Name == "5")
                {
                    this.Gview_gzDS = (DataGridView)ctl;
                }
            }

            out_dtA = m_dt_A;
            out_dgA = this.Gview_gzA;

            out_dtB = m_dt_B;
            out_dgB = this.Gview_gzB;

            out_dtC = m_dt_C;
            out_dgC = this.Gview_gzC;

            out_dtD = m_dt_D;
            out_dgD = this.Gview_gzD;

            out_dt_sulfide = m_dt_sulfide;
            out_dgsulfide = this.sulfide;

            out_dtDS = m_dt_DS;
            out_dgDS = this.Gview_gzDS;
        }
        #endregion



        #region clr加载数据部分
        public DataTable ChineseStandardABCD_GetDataTable_Total(List<CGridDataClr> in_list_cgriddataclr, out int oneresult_columncount)
        {
            oneresult_columncount = 1;//一个数据源的跨度，计算出一个数据源包含几个列
            //创建一个临时表
            DataTable ret_dt = new DataTable();

            //判断传入的数据对象是否为空
            if (in_list_cgriddataclr == null)
            {
                string str1 = "传入分解表格数据的CGridDataClr对象为空！";
                str1 = table["str1"].ToString();
                //log.Error("(OTSIncAReportGridsFun.ChineseStandardABCD_GetDataTable_Total)" + str1);
                return ret_dt;
            }

            #region 根据返回的结构创建DataTable的结构---------------------------------------------
            for (int i = 0; i < in_list_cgriddataclr.Count(); i++)
            {
                //分解结果内容
                List<CGridColumnClr> list_cgridcolumnclrs = new List<CGridColumnClr>();
                list_cgridcolumnclrs = in_list_cgriddataclr[i].GetGridColumnList();    //获取各列

                //单个数据源包含几个列的跨度
                if (oneresult_columncount < list_cgridcolumnclrs.Count())
                    oneresult_columncount = list_cgridcolumnclrs.Count();

                if (in_list_cgriddataclr.Count > 1)
                {
                    //创建DT的列,多个数据源，为每个字段带上索引号
                    foreach (CGridColumnClr ls_cgridcolumnclr in list_cgridcolumnclrs)
                    {
                        string ls_fl_strName = ls_cgridcolumnclr.GetName();

                        //通过获取到的列，创建表的列
                        ret_dt.Columns.Add(ls_fl_strName + "(" + (i + 1).ToString() + ")");
                    }
                }
                else
                {
                    //创建DT的列,单个数据源，不带索引号
                    foreach (CGridColumnClr ls_cgridcolumnclr in list_cgridcolumnclrs)
                    {
                        string ls_fl_strName = ls_cgridcolumnclr.GetName();

                        //通过获取到的列，创建表的列
                        ret_dt.Columns.Add(ls_fl_strName);
                    }
                }
            }
            #endregion

            #region 再创建表的行------------------------------------------------------------------
            //取最大的rowlistcount,要不然，不知道这底层返回的数据居然还有2,2,3这样的行数据
            int maxrownumber = 0;
            for (int i = 0; i < in_list_cgriddataclr.Count(); i++)
            {
                //分解结果内容
                List<CGridColumnClr> list_cgridcolumnclrs = new List<CGridColumnClr>();
                list_cgridcolumnclrs = in_list_cgriddataclr[i].GetGridColumnList();    //获取各列

                //创建DT的行
                if (list_cgridcolumnclrs != null)
                {
                    foreach (CGridColumnClr ls_cgridcolumnclr in list_cgridcolumnclrs)
                    {
                        if (maxrownumber < ls_cgridcolumnclr.GetRowList().Count())
                        {
                            maxrownumber = ls_cgridcolumnclr.GetRowList().Count();
                        }
                    }
                }
            }
            for (int k = 0; k < maxrownumber; k++)
            {
                DataRow dr = ret_dt.NewRow();
                ret_dt.Rows.Add(dr);
            }
            #endregion

            #region //再次重新分解，先分解列，然后将获取到的各行各列的数据，填充到相应的位置上---
            for (int i = 0; i < in_list_cgriddataclr.Count(); i++)
            {
                //分解结果内容
                List<CGridColumnClr> list_cgridcolumnclrs = new List<CGridColumnClr>();
                list_cgridcolumnclrs = in_list_cgriddataclr[i].GetGridColumnList();    //获取各列
                                                                                       //再次重新分解，先分解列，然后将获取到的
                for (int k = 0; k < list_cgridcolumnclrs.Count(); k++)
                {
                    string ls_fl_strName = list_cgridcolumnclrs[k].GetName();
                    List<CGridRowClr> ls_list_cgridrowclr = new List<CGridRowClr>();
                    ls_list_cgridrowclr = list_cgridcolumnclrs[k].GetRowList();

                    for (int j = 0; j < ls_list_cgridrowclr.Count(); j++)
                    {
                        //先判断该行该单元格的数据类型
                        string str_value = "";//因为显示只需要对字符串进行操作就可以了，所以将底层获取到的数据，除了颗粒类型外的都转成string

                        switch (ls_list_cgridrowclr[j].GetDataType())
                        {
                            case 0:
                                //string
                                str_value = ls_list_cgridrowclr[j].GetStringValue();
                                ret_dt.Rows[j][k + i * oneresult_columncount] = str_value;
                                break;
                            case 1:
                                //该元素含量表没有需要显示的颗粒图像
                                //ret_dt.Rows[j][k+i*oneresult_columncount] = GetBitmapByParticleList(ls_list_cgridrowclr[k].GetParticle());
                                break;
                            case 2:
                                //int
                                str_value = ls_list_cgridrowclr[j].GetIntValue().ToString();
                                ret_dt.Rows[j][k + i * oneresult_columncount] = str_value;
                                break;
                            case 3:
                                //float
                                str_value = ls_list_cgridrowclr[j].GetDoubleValue().ToString("0.00");
                                ret_dt.Rows[j][k + i * oneresult_columncount] = str_value;
                                break;
                            default:
                                str_value = "";
                                ret_dt.Rows[j][k + i * oneresult_columncount] = str_value;
                                break;
                        }
                    }
                }
            }
            #endregion

            return ret_dt;
        }
        #endregion
        #region 读取加载clr中的国标数据信息
        public List<DataTable> ChineseStandardABCD_GetDataTable()
        {
            List<DataTable> dataTables = new List<DataTable>();
            dataTables.Add(ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_A, out m_oneresult_columnscount_A));
            dataTables.Add( ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_B, out m_oneresult_columnscount_B));
            dataTables.Add( ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_C, out m_oneresult_columnscount_C));
            dataTables.Add( ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_D, out m_oneresult_columnscount_D));
            dataTables.Add( ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_sulfide, out m_oneresult_columnscount_sulfide));
            dataTables.Add( ChineseStandardABCD_GetDataTable_Total(m_list_cgriddataclr_DS, out m_oneresult_columnscount_DS));
            return dataTables;
        }
        #endregion

    }
}