using OTSModelSharp;
using OTSDataType;
using NSOTSController;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.IO;

using OTSModelSharp.ResourceManage;
using static OTSModelSharp.ResourceManage.ResourceID;
using static OTSModelSharp.ResourceManage.ResourceData;
using static OTSDataType.otsdataconst;
using System.Windows.Forms;

namespace OTSMeasureApp
{

    public enum OTS_SOFT_PACKAGE_ID
    {
        OTSIncA = 0,             //夹杂物分析
        OTSPartA = 1,            //颗粒度分析
    };

    //文件保存返回的结果，DataMgr返回
    public enum OTS_SAVE_FILE_REV
    {
        SaveFile_Success = 0,
        SaveFile_Cancel = 1,
        SaveFile_Failed = 2,
        SaveFile_NoNedd = 3      //文件不需要保存
    }

 

    //设置线程状态
    public enum MSR_THREAD_RunSTATUS
    {
        RUNMEASURE = 1,         //开始测量
        RUNSampleHoleImage = 2  //运行获取样品孔照片
    };
    enum SAMPLE_FAULT_WARN_CODE
    {
        INVALID = -1,
        MIN = 0,
        SEM_DATA_ERROR = 0,
        AREA_OUTSIDE_HOLE = 1,
        RESOLUTION_LOW = 2,
        FINISHED = 3,
        NO_ERROR_WARNING = 4,
        FILE_NOT_SAVED = 5,
        MAX = 5
    };
    enum SAMPLE_CHECK_RESULT_TYPE
    {
        INVALID = -1,
        MIN = 0,
        SWITCH_ON = 0,
        FINISHED = 1,
        SETTING_ERROR = 2,
        SETTING_WARNING = 3,
        MEASURABLE = 4,
        NO_ERROR_WARNING = 5,
        MAX = 5
    };
    public class COTSMeasureParam 
    {
        OTSIncAMeasureAppForm m_MeasureAppFrom = null;


        /// <summary></summary>
        /// <remarks>创建</remarks>
        public COTSMsrPrjResultData m_ResultData;



        //参数文件
        public COTSDefaultParam m_DefaultParam = null;
        //样品台文件（读取样品台数据等)                            
        public CStageParam m_StageParam = null;
  
        //测量样品链表
        List<COTSSample> m_MeasureSampleList = new List<COTSSample>();

        NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();

        public COTSMeasureParam(OTSIncAMeasureAppForm MeasureApp)
        {
            m_MeasureAppFrom = MeasureApp;
           
            m_ResultData = new COTSMsrPrjResultData();


        }

      



        //检查参数文件是否存在
        public bool LoadParamFile()
        {
            //加载样品参数文件:   \Config\SysData\OTSProgMgrParam.pmf
            m_DefaultParam = new COTSDefaultParam();
            m_DefaultParam.LoadInfoFromProgMgrFile();
            if (null == m_DefaultParam)
            {
                return false;
            }


            return true;
        }

        //检查参数样品台文件是否存在
        public bool LoadStageParamFile()
        {
            m_StageParam = new CStageParam();
            // 加载样品台文件；  \Config\SysData\OTSStage.stg
            if (!m_StageParam.Load(true, false))
            {
                return false;
            }

            return true;
        }



        //获取系统文件是否存在和有效
      
        public bool InitResultData(bool bNewFileFlag = true)
        {
            //打开文件，则文件中保存有样品台信息，不需要使用系统样品名信息
            if (bNewFileFlag)
            {

                //设置样品台参数
                CStage Stage = m_StageParam.GetWorkingStage();
                if (null == Stage)
                {
                    return false;
                }
                m_ResultData.SetStage(Stage);
                

                // 设置 SEM stage data
                CSEMStageData SEMData = m_DefaultParam.GetStageDataParam();
                if (null == SEMData)
                {
                    return false;
                }
                m_ResultData.SetSEMStageData(SEMData);
            }

            //设置 general parameter
            COTSGeneralParam GenParam = m_DefaultParam.GetGenParam();
            if (null == GenParam)
            {
                return false;
            }
            m_ResultData.SetGenParam(GenParam);



            if (m_ResultData.GetPathName()=="")
            {
                m_ResultData.SetPathName("Untitled");             
            }

            m_ResultData.m_nPackId = m_DefaultParam.m_nPackId;


            return true;
        }

       

        //新建样品工作文件 0:报错 1：正常 2：取消
        public int CreateNewFile()
        {
            if (m_ResultData.IsModified())    // 文件被修改
            {
                int iRev = m_MeasureAppFrom.ShowSaveInfoMsgBox();
                if ((int)MessageBoxRev.DIALOG_YES == iRev)
                {
                    if (!m_ResultData.Save())
                    {

                        return 0;
                    }
                }
                else if((int)MessageBoxRev.DIALOG_CANCEL == iRev)
                {
                    return 2;
                }
            }

            //新建新的工作文件
            //重新生成一个工作文件对象
            COTSMsrPrjResultData ProjDataMgr = new COTSMsrPrjResultData();
            m_ResultData.SetPathName("Untitled");
          

            m_ResultData = ProjDataMgr;
            this.LoadStageParamFile();
           
            if (!this.InitResultData())
            {
                return 0;
            }

            return 1;
        }




 

        //将样品台坐标转换为Sem 坐标
        public Point ChangeOTSToSemCoord(Point POTSCoord)
        {
            System.Drawing.Point VSemCoord = new System.Drawing.Point();
            m_DefaultParam.GetStageDataParam().ConverOTSToSEMPoint(POTSCoord, ref VSemCoord);
            return (Point)VSemCoord;
        }

        //将Sem 坐标转换为样品台坐标
        public Point ConverSEMToOTSPoint(Point PSEMCoord)
        {
            System.Drawing.Point VOTSCoord = new System.Drawing.Point();
            m_DefaultParam.GetStageDataParam().ConverSEMToOTSPoint(PSEMCoord, ref VOTSCoord);
            return (Point)VOTSCoord;
        }

        //添加样品
        //string sSHoleName:  样品孔名,当在样品孔上点击右键添加样品时，sSHoleName=样品孔名。当MEASUREAPP和TREEVIEW添加样品时，sSHoleName=""
        //返回新的工作样品名称
        public OTSSamplePropertyInfo AddNewSampleMeasure(string a_strHoleName = "")
        {

            COTSSample NewSample = new COTSSample();
            SetSampleDefaultPara(ref NewSample, a_strHoleName);
            //NewSample.
            //添加样品
            m_ResultData.AddSample(NewSample);

          
            // 获取样品的属性值
            OTSSamplePropertyInfo MeasureInfo = new OTSSamplePropertyInfo();
            if (!GetWorkSamplePerameter(NewSample, ref MeasureInfo))
            {
                return null;
            }      

            return MeasureInfo;
        }
        protected COTSSample SetSampleDefaultPara(ref COTSSample pSample, String a_strHoleName)
        {
            // get new sample name
            String strNewSampleName = GetNewSampleName();

            // make sure the new sample name is not an empty string
            strNewSampleName.Trim();


            // get a suitable sample hole for the new sample
            CHole pHole = SelectASmpleHole(a_strHoleName);

            // check the sample hole
            if (pHole == null)
            {
                // failed to get sample hole for the new sample

                return null;
            }
            // measurement area 	
            CDomain pMsrArea = CalculateDefaultArea(pHole);
            // measure data parameters containing particle analysis std, image scan parameter, image process parameter and x-ray parameter 
            CSampleParam poMsrParams = new CSampleParam();
            poMsrParams.m_nPackId = m_DefaultParam.m_nPackId;
            poMsrParams.m_runmode = m_DefaultParam.m_runmode;
            var m_pParam = m_DefaultParam.GetGenParam();
            MEMBRANE_TYPE a_nVal = (MEMBRANE_TYPE)m_pParam.GetMembraneType();
            poMsrParams.SetImageScanParam(m_DefaultParam.GetImageScanParam ());
            poMsrParams.SetImageProcessParam(m_DefaultParam.GetImageProcParam()); 
            poMsrParams.SetXRayParam(m_DefaultParam.GetXRayParam());
            String sSTDName = m_pParam.GetSTDSelect();
            poMsrParams.SetSTDName(sSTDName);
            poMsrParams.SetSteelTechnology((STEEL_TECHNOLOGY)m_pParam.GetSteelTechnology());
            // set sample parameters
            pSample.SetName(strNewSampleName);
            pSample.SetSampleHoleName(pHole.GetName());
            pSample.SetSwitch(m_pParam.GetMeasurementSwitch());
            pSample.SetSysSTDSwitch(m_pParam.GetSysSTD());
            pSample.SetMsrArea(pMsrArea);
            pSample.SetMembraneType(a_nVal);
            pSample.SetMsrParams(poMsrParams);
            CSEMDataMsr semData = new CSEMDataMsr();
            var m_pSEMStageData = m_DefaultParam.GetStageDataParam();
            semData.SetScanFieldSize100(m_pSEMStageData.GetScanFieldSize100());
            pSample.SetSEMDataMsr(semData);

            return pSample;
        }
        public String GetNewSampleName()
        {
            // new sample name
            String strNewSmplName = "";

            // safety check
            var m_pParam = m_DefaultParam.GetGenParam();
            if (m_pParam == null)
            {
                // shouldn't happen, invalid general parameter pointer.

                return strNewSmplName;
            }

            // new sample name base
            String strNewSmplNameBase = m_pParam.GetSampleName() + @"{0}";
            int nIndex = 1;

            do
            {
                // new sample name is new sample name base + number string
                strNewSmplName = string.Format(strNewSmplNameBase, nIndex);
                ++nIndex;
            }
            // make sure that the new sample name is not same with any sample in the samples list
            while (SameNameInList(strNewSmplName));

            // new sample name
            return strNewSmplName;
        }
        public bool SameNameInList(String a_strSampleName, int a_nExclude = -1)
        {
            // make sure the input sample name is not empty
            a_strSampleName.Trim();
            if (a_strSampleName == "")
            {
                // shouldn't happen, input name is an empty string

                return false;
            }

            // go through sample list
            int nIndex = 0;
            var m_listSamples = m_ResultData.GetSampleList();
            foreach (var pSample in m_listSamples)
            {
                // return TRUE if this is not an exclude sample and its name is same with input
                String strSampleName = pSample.GetName();
                if (nIndex != a_nExclude && strSampleName.CompareTo(a_strSampleName) == 0)
                {
                    // find a same name sample
                    return true;
                }

                ++nIndex;
            }

            // no, same name sample in the same list, return FALSE
            return false;
        }
        // select a suitable sample hole for a new sample
        public CHole SelectASmpleHole(String a_strHoleName /*= _T("")*/)
        {

            // get holes list of the stage
            var m_pStage = m_StageParam.GetWorkingStage();
            List<CHole> listHoles = m_pStage.GetHoleList();
            //返回样品孔对象
            CHole cReHole = new CHole();
            // make sure the holes list is not empty
            if (listHoles.Count == 0)
            {
                // shouldn't happen, stage have no hole.

                return null;
            }

            // check the input hole name
            a_strHoleName.Trim();
            if (a_strHoleName != "")
            {
                // try to find matched hole
                bool IsChanged = false;
                int holeIndex = -1;
                for (int itr = 0; itr < listHoles.Count; itr++)
                {
                    if (listHoles[itr].GetName() == a_strHoleName)
                    {
                        cReHole = listHoles[itr];
                        //listHoles.RemoveAt(itr);
                        IsChanged = true;
                        holeIndex = itr;
                        break;
                    }
                }

                if (IsChanged)
                {
                    return cReHole;
                }
            }

            // can't find a matched hole, then pick the first empty hole
            //没有按照孔进行添加，则与样品列表进行判断
            // go through the holes list
            foreach (var pHole in listHoles)
            {
                // has this hole any sample in it?
                String strHoleName = pHole.GetName();
                bool IsChanged = false;
                var m_listSamples = m_ResultData.GetSampleList();
                foreach (COTSSample sampleItem in m_listSamples)
                {
                    if (strHoleName == sampleItem.GetSampleHoleName())
                    {
                        //listHoles.RemoveAt(itr);
                        IsChanged = true;
                    }
                }
                if (!IsChanged)
                {
                    return pHole;
                }
            }

            // no empty hole, then the first hole will be the one
            return listHoles[0];
        }
        public CDomain CalculateDefaultArea(CHole a_pHole)
        {
            Rectangle rectHole = a_pHole.GetDomainRect();
            System.Drawing.Point ptCenter = new System.Drawing.Point((rectHole.Left + rectHole.Right) / 2, (rectHole.Top + rectHole.Bottom) / 2);
            var m_pParam = m_DefaultParam.GetGenParam();
            DOMAIN_SHAPE nShape = m_pParam.GetShape();

            double dArea = m_pParam.GetArea() * 1000000;

            System.Drawing.Point ptLeftTop = new System.Drawing.Point();
            System.Drawing.Size ptSize = new System.Drawing.Size();

            int nEdge = 0;
            int nRadius = 0;

            switch ((int)nShape)
            {
                case (int)DOMAIN_SHAPE.RECTANGLE:
                    nEdge = (int)Math.Sqrt(dArea) / 2;
                    ptLeftTop.X = ptCenter.X - nEdge;
                    ptLeftTop.Y = ptCenter.Y - nEdge;
                    ptSize.Width = ptCenter.X + nEdge - ptLeftTop.X;
                    ptSize.Height = ptCenter.Y + nEdge - ptLeftTop.Y;
                    break;
                case (int)DOMAIN_SHAPE.ROUND:
                    nRadius = (int)Math.Sqrt(dArea / 3.1415926);
                    ptLeftTop.X = ptCenter.X - nRadius;
                    ptLeftTop.Y = ptCenter.Y - nRadius;
                    ptSize.Width = ptCenter.X + nRadius - ptLeftTop.X;
                    ptSize.Height = ptCenter.Y + nRadius - ptLeftTop.Y;
                    break;
            }

            Rectangle MsrRect = new Rectangle(ptLeftTop, ptSize);
            CDomain pMsrArea = new CDomain(nShape, MsrRect);

            // return measurement area
            return pMsrArea;
        }
        //设置工作样品的属性值
        public bool SetSampleParamVal(OTS_SAMPLE_PROP_GRID_ITEMS ItemId, OTS_ITEM_TYPES ValType, object objVal)
        {

            COTSSample WSample = m_ResultData.GetWorkingSample();

            bool bSetFalg = false;
            //判断样品名是否有效
            if (ItemId == OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME)
            {
                if (!m_ResultData.IsValidSampleName((string)objVal))
                {
                    bSetFalg = false;
                    return false;
                }
            }
            bSetFalg = WSample.SetParamVal(ItemId, ValType, objVal);

            if (bSetFalg)
            {
                m_ResultData.SetModify(true);
            }
            return bSetFalg;
        }

        //获取工作样品名称
        public string GetWorkSampleName()
        {

            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return "";
            }
            string sWorkSampleName = WSample.GetName();
            if ("" == sWorkSampleName)
            {
                return "";
            }

            return sWorkSampleName;
        }

        //设置工作样品
        //string sNewWorkSampleName:  新工作样品
        public bool SetWorkSample(string sNewWorkSampleName)
        {
            if ("" == sNewWorkSampleName)
            {
                return false;
            }

            if (!m_ResultData.SetWorkingSampleByName(sNewWorkSampleName))
            {
                return false;
            }
            return true;
        }

        //获取工作样品
        // 返回工作样品对象
        public COTSSample GetWorkSample()
        {

            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {

            }
            return WSample;

        }

        //删除工作样品
        //string sWorkSampleName : 删除工作样品名称
        public bool DeleteWorkSample(string sWorkSampleName)
        {
            return m_ResultData.DeleteSampleByName(sWorkSampleName);
        }

        // 获取样品总数
        //返回样品总数
        public int GetSampleCount()
        {
            return m_ResultData.GetSampleList().Count();
        }

        //改变工作样品名称
        //String sWSampleNewName
        public bool ChangeWorkSampleName(String sWSampleNewName)
        {
            if (!m_ResultData.IsValidSampleName(sWSampleNewName))
            {
                return false;
            }
            COTSSample WorkSample = m_ResultData.GetWorkingSample();
            if (null == WorkSample)
            {
                return false;
            }

            WorkSample.SetName(sWSampleNewName);
            m_ResultData.SetModify(true);
            return true;

        }

        //移动工作样品到其他样品孔，样品孔名称和测量区域都要改变,重新设置工作样品参数
        //SampleMeasurePara SMeasurePara:
        public SampleMeasurePara SetWorkSampleHoleNameAndMeasureArea(SampleMeasurePara SMeasurePara)
        {
            SampleMeasurePara SMPara = new SampleMeasurePara();
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return SMPara;
            }

            CDomain Domain = new CDomain();
            Domain.SetShape((otsdataconst.DOMAIN_SHAPE)SMeasurePara.iShape);
            Domain.SetRectDomain(SMeasurePara.MeasureRect);
            if (SMeasurePara.DrawPolygonPointRegionF != null)
            {
                List<Point> PolygonPoint = new List<Point>();
                foreach (var item in SMeasurePara.DrawPolygonPointRegionF)
                {
                    PolygonPoint.Add(new Point((int)item.X, (int)item.Y));
                }
                Domain.SetPolygonPoint(PolygonPoint);
            }
            WSample.SetSampleHoleName(SMeasurePara.sHoleName);
            WSample.SetMsrArea(Domain);

            //获取样品的测量区域信息 
            SMPara.sSampleName = WSample.GetName();    //获取样品名称
            SMPara.iShape = (int)WSample.GetMsrArea().GetShape();  // 获取测量区域形状
            SMPara.sHoleName = WSample.GetSampleHoleName(); //获取样品孔名称
            SMPara.MeasureRect = (Rectangle)WSample.GetMsrArea().GetRectDomain();  //样品测量区域

            //改变测量区域后重新设置样品修改状态
            //m_ResultData.SetModify(true);
            //string pathName = m_ProjDataMgr.GetPathName();
            //if (pathName != "" && pathName != "Untitled")
            //{
            //    m_ProjDataMgr.Save();
            //}
            return SMPara;

        }




        //设置测量区域的形状 （通过RIBBON 上的画圆，画矩形 设置)
        //int iShape:  测量区域形状 0： 圆形； 1 ：矩形
        public void SetMeasureAreaShape(int iShape)
        {
            //  SampleMeasurePara SMPara = new SampleMeasurePara();
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return;
            }

            CDomain Domain = new CDomain();
            Domain.SetShape((otsdataconst.DOMAIN_SHAPE)iShape);
        }


        //修改了ITEMID后，重新更新GROUPID和ITEMID
        public void UpdateGroupValAndItemVal(OTS_SAMPLE_PROP_GRID_ITEMS ItemID)
        {
            OTS_SAMPLE_PROP_GRID_ITEM_GROUPS GroupID = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.INVALID;
            OTS_SAMPLE_PROP_GRID_ITEMS iItemID = OTS_SAMPLE_PROP_GRID_ITEMS.INVALID;
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return;
            }
            if (!WSample.GetRelatedPropItemGrp((OTS_SAMPLE_PROP_GRID_ITEMS)ItemID, ref GroupID))
            {
                bool bFlag = WSample.GetRelatedPropItem(ItemID, ref iItemID);
            }

        }

  

        //设置样品参数锁
        //bool ParaLockFlag : 样品参数锁
        public bool SetWorkSampleParamLock(bool ParaLockFlag)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }
            WSample.SetParamLock(ParaLockFlag);
            m_ResultData.SetModify(true);
            return true;
        }

        //获取工作样品锁
        //ref bool ParamLockFlag : 获取的工作样品参数锁
        public bool GetWSampleParaLock(ref bool ParamLockFlag)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }
            ParamLockFlag = WSample.GetParamLock();
            return true;
        }

        //获取工作样品测量锁
        public bool GetWSampleParaLock(ref OTSSamplePropertyInfo SMInfo)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }

            if (!GetWorkSamplePerameter(WSample, ref SMInfo))
            {

                return false;
            }
            return true;
        }

        //重新设置样品在样品列表中的位置（当拖动TREEVIEW的样品顺序后执行 ）
        public bool SortSamplePosition(List<string> SNameList)
        {
            if (!m_ResultData.ResetSamplesListOrder(SNameList))
            {
                return false;
            }

            List<COTSSample> SampleList = new List<COTSSample>();
            SampleList = m_ResultData.GetSampleList();

            return true;
        }

      
        public bool CheckSampleParam(bool bCheckFlag)
        {
            m_MeasureSampleList.Clear();
            List<COTSSample> MSampleList = new List<COTSSample>();

            if (!CheckMeasureParam(m_ResultData, ref MSampleList, bCheckFlag))
            {
                return false;
            }
            if (MSampleList.Count > 0)
            {
                m_MeasureSampleList = MSampleList;
                return true;
            }
            return false;
        }
        public bool CheckMeasureParam(COTSMsrPrjResultData a_pProjMgrFile, ref List<COTSSample> a_listMeasuableSamples, bool a_bCheckSetting)
        {


            // go through the sample list to check setting parameters 
            int nSwitchSmplNo = 0;
            int nCompletedSmplNo = 0;
            int nErrorSmplNo = 0;
            int nWarningSmplNo = 0;
            List<String> listSamplMessages = new List<string>();
            List<COTSSample> listSamples = a_pProjMgrFile.GetSampleList();
            List<COTSSample> listMeasurableSamples = new List<COTSSample>();
            List<COTSSample> listWithWarningMeasurableSamples = new List<COTSSample>();
            foreach (var pSample in listSamples)
            {
                // is the sample switch on
                if (pSample.GetSwitch())
                {
                    ++nSwitchSmplNo;
                    String strSmplMessage;
                    strSmplMessage = pSample.GetName() + ":" + "\r\n";

                    // is this a measurement completed sample
                    if (IsMeasureCompletedSmpl(pSample))
                    {   // measurement completed sample
                        ++nCompletedSmplNo;
                        string str2 = GetSampleErrorWarnString(SAMPLE_FAULT_WARN_CODE.FINISHED);
                        strSmplMessage += str2;
                        strSmplMessage += "\r\n";
                    }
                    else
                    {
                        // errors
                        List<SAMPLE_FAULT_WARN_CODE> a_listErrorCodes = new List<SAMPLE_FAULT_WARN_CODE>();
                        GetSampleErrorCodes(a_pProjMgrFile, pSample, ref a_listErrorCodes);
                        if (a_listErrorCodes.Count != 0)
                        {
                            // has error, this is not a measurable sample
                            ++nErrorSmplNo;
                            foreach (var nErrorCode in a_listErrorCodes)
                            {
                                String str3 = GetSampleErrorWarnString(nErrorCode);
                                strSmplMessage += str3;
                                strSmplMessage += "\r\n";
                            }
                        }
                        else
                        {
                            // no error, this is a measurable sample
                            listMeasurableSamples.Add(pSample);
                        }

                        // warnings
                        List<SAMPLE_FAULT_WARN_CODE> a_listWarningCodes = new List<SAMPLE_FAULT_WARN_CODE>();
                        GetSampleWarningCodes(a_pProjMgrFile, pSample, ref a_listWarningCodes);
                        if (a_listWarningCodes.Count != 0)
                        {
                            ++nWarningSmplNo;
                            foreach (var nWarningCode in a_listWarningCodes)
                            {
                                String str3 = GetSampleErrorWarnString(nWarningCode);
                                strSmplMessage += str3;
                                strSmplMessage += "\r\n";
                            }

                            // has no error?
                            if (a_listErrorCodes.Count == 0)
                            {
                                // this is a measurable sample but with setting warnings
                                listWithWarningMeasurableSamples.Add(pSample);
                            }
                        }

                        // no error and warning
                        if (a_listErrorCodes.Count == 0 && a_listWarningCodes.Count == 0)
                        {
                            String str3 = GetSampleErrorWarnString(SAMPLE_FAULT_WARN_CODE.NO_ERROR_WARNING);
                            strSmplMessage += str3;
                            strSmplMessage += "\r\n";
                        }
                    }

                    // add 
                    listSamplMessages.Add(strSmplMessage);
                }
            }

            // dlg message string
            String strDlgMessage = "";
            String str;
            String str1;
            str1 = GetResourceByKey(GrpOtherParam, IDS_SAMPLE_CHECK_RESULT + (int)SAMPLE_CHECK_RESULT_TYPE.SWITCH_ON);
            str1 = str1.Replace("%d", "{0}");
            str = string.Format(str1, nSwitchSmplNo);
            strDlgMessage += str;
            strDlgMessage += "\r\n";

            // add more string if there switch on sample
            if (nSwitchSmplNo > 0)
            {
                // completed sample number (optional)
                if (nCompletedSmplNo > 0)
                {
                    str1 = GetResourceByKey(GrpOtherParam, IDS_SAMPLE_CHECK_RESULT + (int)SAMPLE_CHECK_RESULT_TYPE.FINISHED);
                    str1 = str1.Replace("%d", "{0}");
                    str = string.Format(str1, nCompletedSmplNo);
                    strDlgMessage += str;
                    strDlgMessage += "\r\n";
                }

                // any unmeasured switch on samples?
                if (nSwitchSmplNo > nCompletedSmplNo)
                {
                    // with setting error sample number
                    str1 = GetResourceByKey(GrpOtherParam, IDS_SAMPLE_CHECK_RESULT + (int)SAMPLE_CHECK_RESULT_TYPE.SETTING_ERROR);
                    str1 = str1.Replace("%d", "{0}");
                    str = string.Format(str1, nErrorSmplNo);
                    strDlgMessage += str;
                    strDlgMessage += "\r\n";

                    // with setting warning sample number
                    str1 = GetResourceByKey(GrpOtherParam, IDS_SAMPLE_CHECK_RESULT + (int)SAMPLE_CHECK_RESULT_TYPE.SETTING_WARNING);
                    str1 = str1.Replace("%d", "{0}");
                    str = string.Format(str1, nWarningSmplNo);
                    strDlgMessage += str;
                    strDlgMessage += "\r\n";

                }
            }

            // add an empty line strDlgMessage
            strDlgMessage += "\r\n";

            // add sample messages
            foreach (var strSmplMessage in listSamplMessages)
            {
                strDlgMessage += strSmplMessage;
                strDlgMessage += "\r\n";
            }

            // do we need to show dialog box?
            if (nSwitchSmplNo == 0)
            {
                return false;
            }

            // measure button clicked?
            if (a_bCheckSetting)
            {
                // there are measurable samples but no setting warnings samples
                if (listMeasurableSamples.Count > 0 && listWithWarningMeasurableSamples.Count == 0)
                {
                    // set output measurable samples list
                    foreach (var pSample in listMeasurableSamples)
                    {
                        a_listMeasuableSamples.Add(pSample);
                    }
                    return true;
                }

            }
            //when there is sample setting error, and setting with no error and no warning samples, the dlg will not be show.??

            //show the result dlg
            DIALOG_CHECK_PARAM_RESULT dlg = new DIALOG_CHECK_PARAM_RESULT();
            int nTatolMeasuableSmplNo = listMeasurableSamples.Count;
            int nWithWarningMeasuableSmplNo = listWithWarningMeasurableSamples.Count;

            // set the dlg parameters
            dlg.SetCheckOnlyFlag(a_bCheckSetting);
            dlg.SetMessageBase(strDlgMessage);
            dlg.SetTatolMeasuableSmplNo(nTatolMeasuableSmplNo);
            dlg.SetWithWarningMeasuableSmplNo(nWithWarningMeasuableSmplNo);

            //no error not show dlg
            if (nTatolMeasuableSmplNo == nSwitchSmplNo - nCompletedSmplNo && listMeasurableSamples.Count != 0)
            {
                foreach (var pSample in listMeasurableSamples)
                {
                    var itr = listWithWarningMeasurableSamples.Find(s => { return s.GetName() == pSample.GetName(); });


                    if (itr == null)
                    {
                        a_listMeasuableSamples.Add(pSample);
                    }
                }

                if (a_listMeasuableSamples.Count == listMeasurableSamples.Count)
                {
                    return true;
                }

            }


            //show dlg
            DialogResult dResult = dlg.ShowDialog();
            if (!(dResult == System.Windows.Forms.DialogResult.OK))
            {
                // do something here
                return false;
            }
            else
            {
                //if warnDo, back the listMeasuableSample
                if (dlg.GetWarnDo())
                {
                    foreach (var pSample in listMeasurableSamples)
                    {
                        a_listMeasuableSamples.Add(pSample);
                    }
                }
                else // back with no warn sample
                {
                    foreach (var pSample in listMeasurableSamples)
                    {
                        var itr = listWithWarningMeasurableSamples.Find(e => { return e.GetName() == pSample.GetName(); });
                        if (itr == null)
                        {
                            a_listMeasuableSamples.Add(pSample);
                        }
                    }
                }
            }



            return true;
        }
        bool IsMeasureCompletedSmpl(COTSSample a_pSample)
        {
            // safety check

            if (a_pSample.GetMsrStatus().GetStatus() != OTSDataType.OTS_MSR_SAMPLE_STATUS.SUCCESSED)
            {

                return false;
            }
            return true;
        }
        string GetSampleErrorWarnString(SAMPLE_FAULT_WARN_CODE a_nSampleFaultWarn)
        {

            // check input
            if (a_nSampleFaultWarn < SAMPLE_FAULT_WARN_CODE.MIN && a_nSampleFaultWarn > SAMPLE_FAULT_WARN_CODE.MAX)
            {
                return "";
            }
            // error/waring string
            string strErrorWarn;
            strErrorWarn = GetResourceByKey(GrpOtherParam, IDS_ERROR_WARNING + (int)a_nSampleFaultWarn);
            return strErrorWarn;
        }
        // get error codes list of a sample
        void GetSampleErrorCodes(COTSMsrPrjResultData a_pProjMgrFile, COTSSample a_pSample, ref List<SAMPLE_FAULT_WARN_CODE> a_listErrorCodes)
        {

            const string UNTITLED_FILE_NAME = "Untitled";

            // file has not been saved
            String strPathName = a_pProjMgrFile.GetPathName();

            // is this a file no saved?
            strPathName.Trim();
            if (strPathName == UNTITLED_FILE_NAME || strPathName == "")
            {
           
                a_listErrorCodes.Add(SAMPLE_FAULT_WARN_CODE.FILE_NOT_SAVED);
            }


        }

        // get warning codes list of a sample
        void GetSampleWarningCodes(COTSMsrPrjResultData a_pProjMgrFile, COTSSample a_pSample, ref List<SAMPLE_FAULT_WARN_CODE> a_listWarningCodes)
        {

            // get the work stage
            CStage pStage = a_pProjMgrFile.GetStage();

            //get hole
            String sHoleName = a_pSample.GetSampleHoleName();

            //look for the hole Domain
            CHole pSampleHole = pStage.GetHoleByName(sHoleName);
            if (pSampleHole == null)
            {

                return;
            }
            if (a_pSample.GetSEMDataMsr() != null)
            {
                // compute pixel size
                double dPixleSize = a_pSample.CalculatePixelSize();

                // get min size
                COTSImageProcParam pImageProcParam = a_pSample.GetMsrParams().GetImageProcessParam();
                double dMinSize = pImageProcParam.GetIncAreaRange().GetStart();

                // if pixel size bigger than 1/2 of the min size, current magnification can't see clear of the object
                if (dPixleSize >= dMinSize * 0.5)
                {
                    // resolution low
                    a_listWarningCodes.Add(SAMPLE_FAULT_WARN_CODE.RESOLUTION_LOW);
                }
            }
            if(a_pSample.GetSEMDataMsr().GetTotalFields()==0
               && a_pSample.GetSEMDataMsr().GetScanFieldSize() == 0
               && a_pSample.GetSEMDataMsr().GetWorkingDistance() == 0)
            {
                // SEM_DATA_ERROR 
                a_listWarningCodes.Add(SAMPLE_FAULT_WARN_CODE.SEM_DATA_ERROR);
            }
        }

        //获取测量参数文件名称
        //int iNamePos:  文件名在链表中的位置
        //List<string> MParamFileNameList：  测量参数文件链表
        public bool GetMeasureParamFileName(ref int iNamePos, ref List<string> MParamFileNameList)
        {
            if (!m_ResultData.GetParamFileList(ref iNamePos, ref MParamFileNameList))
            {
                return false;
            }
            return true;
        }
        //设置测量文件名称
        //int iNamePos:  文件名在链表中的位置
        public bool SetMeasrueParamFileName(int iNamePos)
        {
            if (!m_ResultData.ChangeParamFromList(iNamePos))
            {
                return false;
            }
            return true;
        }

        //获取STD 标准库文件名称
        //int iNamePos:  文件名在链表中的位置
        //List<string> STDFileNameList：  STD文件链表
        public bool GetSTDFileName(ref int iNamePos, ref List<string> STDFileNameList)
        {
            if (!m_ResultData.GetSTDFileList(ref iNamePos, ref STDFileNameList))
            {
                return false;
            }
            return true;
        }
        //设置STD 标准库文件名称
        public bool SetSTDFileName(int iNamePos)
        {
            if (!m_ResultData.ChangeSTDFromList(iNamePos))
            {
                return false;
            }
            return true;
        }

        ///保存工作样品的测量参数文件     
        public bool SaveWorkMeasureFile()
        {
            CSampleParamMgr SMeasureParamData = new CSampleParamMgr();
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }
            if (!SMeasureParamData.SetMsrParamFile(WSample.GetMsrParams()))
            {
                return false;
            }
            // file open dialog
            CSampleParamMgr cSampleParamMgr = new CSampleParamMgr();
            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.FileName = WSample.GetName() +"_Config"+ cSampleParamMgr.MESUREMENT_PARAM_FILE_EXT;
            saveFileDialog.Filter = cSampleParamMgr.MESUREMENT_PARAM_FILE_FILTER;
            if (saveFileDialog.ShowDialog() != DialogResult.OK)
            {
                return false;

            }
            // get file pathname
            string strPathName = saveFileDialog.FileName;
            SMeasureParamData.Save(strPathName);
            return true;
        }




        //打开工作样品的测量参数文件     
        public bool LoadWorkMeasureFile()
        {
            CSampleParamMgr SMeasureParamData = new CSampleParamMgr();
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = SMeasureParamData.MESUREMENT_PARAM_FILE_FILTER;
            if (openFileDialog.ShowDialog() != DialogResult.OK)
            {
                return false;

            }
            // get file pathname
            string strPathName = openFileDialog.FileName;
            if (!SMeasureParamData.Load(strPathName, true))
            {
                return false;
            }

            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }

            WSample.SetMsrParams(SMeasureParamData.GetMsrParams());

            //更新样品GRID值测量文件名
            OTSSamplePropertyInfo SMInfo = new OTSSamplePropertyInfo();
            if (!this.GetWorkSamplePerameter(WSample, ref SMInfo))
            {
                return false;
            }
            m_MeasureAppFrom.m_SPropertyWindows.DisplaySampleMeasureInfo(SMInfo);
            return true;
        }



        //判断是否允许修改样品名
        public bool CheckSampleNameIsValid(string sNewName)
        {
            return m_ResultData.IsValidSampleName(sNewName);
        }

        //设置电镜参数
        //int iScanFieldSize: Field扫描参数
        //int iWDistance： 电镜工作距离
        //double dMagni： 放大倍数
        public void SetWorkingSampleSEMData(double iWDistance, double dMagni)
        {
            try
            {
                m_ResultData.GetWorkingSample().GetSEMDataMsr().SetWorkingDistance(iWDistance);
                m_ResultData.GetWorkingSample().GetSEMDataMsr().SetMagnification(dMagni);
            }
            catch (Exception)
            {
            }
        }

        //获取电镜参数
        //int iScanFieldSize: Field扫描参数
        //int iWDistance： 电镜工作距离
        //double dMagni： 放大倍数
        public void GetWorkingSampleSEMData(ref double iWDistance, ref double dMagni)
        {
            iWDistance = m_ResultData.GetWorkingSample().GetSEMDataMsr().GetWorkingDistance();
            dMagni = m_ResultData.GetWorkingSample().GetSEMDataMsr().GetMagnification();
        }

        //获取工作样品的测量区域
        //int iShape :测量区域形状
        //Rectangle Srect: 测量区域大小
        public bool GetWSampleMrsArea(ref int iShape, ref Rectangle Srect)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }

            CDomain pMsrArea = new CDomain();
            pMsrArea = WSample.GetMsrArea();
            if (null == pMsrArea)
            {
                return false;
            }

            iShape = (int)pMsrArea.GetShape();

            ValueType ValType = new Rectangle();
            ValType = pMsrArea.GetRectDomain();
            Srect = (Rectangle)ValType;
            return true;
        }




        //检查Samplelist中的sample的checkbox状态
        //当Samplelist中的链表有sample 的checkbox状态是选中状态，则返回TRUE. 说明可以测量
        public bool GetSampleCheckBoxStatus()
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }
            List<COTSSample> SampleList = new List<COTSSample>();
            SampleList = m_ResultData.GetSampleList();
            int iCount = SampleList.Count();
            if (0 == iCount)
            {
                return false;
            }

            for (int i = 0; i < iCount; i++)
            {
                if (SampleList[i].GetSwitch())
                {
                    return true;
                }
            }

            return false;
        }

        //获取BSE图像数据
        public bool GetBSEImageSize(ref int iHeight, ref int iWidth)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }

            if (!WSample.GetBSESize(out iHeight, out iWidth))
            {
                return false;
            }
            return true;
        }



       

        //获取图像尺寸
        public string GetBSEImageSize()
        {
            try
            {
                COTSSample WSample = m_ResultData.GetWorkingSample();
                if (null == WSample)
                {
                    return "";
                }

                OTSSamplePropertyInfo SMInfo = new OTSSamplePropertyInfo();
                if (!GetWorkSamplePerameter(WSample, ref SMInfo))
                {
                    return "";
                }
                int iCount = SMInfo.SampleDataList.Count();
                for (int i = 0; i < iCount; i++)
                {
                    if (OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION == SMInfo.SampleDataList[i].iSampleId)
                    {

                        String val = (String)SMInfo.SampleDataList[i].SampleVal;

                        return val;
                    }
                }
                return "";
            }
            catch (Exception)
            {
                return "";
            }
        }

        //获取放大倍数和工作距离
        public bool GetMagAndDistance(ref double SemMag, ref double dDistance)
        {
          
                COTSSample WSample = m_ResultData.GetWorkingSample();
                if (null == WSample)
                {
                    return false;
                }
            //GetWorkingSampleSEMData(ref SemMag, ref dDistance);
            GetWorkingSampleSEMData(ref dDistance, ref SemMag);
            return true;
           
        }

        public bool GetWorkSamplePerameter(COTSSample Sample, ref OTSSamplePropertyInfo SMeasureInfo)
        {
            //设置工作样品属性项
            if (Sample.GetMsrParams().m_nPackId == OTS_SysType_ID.CleanlinessA)
            {
                Sample.SetPropItemGrpsForCleanlinessSys();
            }
            else
            {
                Sample.SetPropItemGrpsForIncA();
            }
          
            bool MeasurementStatus = false;
           

            //样品的标题名 (Treeview的根节点名)           
            SMeasureInfo.sSampleSoluName = m_ResultData.GetFileName();

            // Treeview 的样品信息  
            SMeasureInfo.TSampleParam.sSampleTitleName = m_ResultData.GetFileName();

            //获得 样品属性值

           

            SMeasureInfo.bSwitch = Sample.GetSwitch();// (bool)jo.GetValue("bSwitch");
            SMeasureInfo.TSampleParam.bParamLock = Sample.GetParamLock();// (bool)jo.GetValue("ParamLock");

            //获取样品的测量区域信息 
            //获取样品名称
          
            SMeasureInfo.SMeasurePara.sSampleName = Sample.GetName();// (String)SMeasurePara.GetValue("sNewSampleName");
            // 获取测量区域形状
            SMeasureInfo.SMeasurePara.iShape = (int)Sample.GetMsrArea().GetShape();// (int)SMeasurePara.GetValue("iShape");
            //获取样品孔名称
            SMeasureInfo.SMeasurePara.sHoleName = Sample.GetSampleHoleName();// (String)SMeasurePara.GetValue("sHoleName");
                                                                             //样品测量区域
                                                                             // JObject rec = (JObject)SMeasurePara.GetValue("MeasureRect");
            Rectangle rec = Sample.GetMsrArea().GetDomainRect();
            SMeasureInfo.SMeasurePara.MeasureRect = new Rectangle((int)rec.X, (int)rec.Y, (int)rec.Width, (int)rec.Height);

         
            SMeasureInfo.TSampleParam.sWorkSampleName = Sample.GetName();// (String)TSampleParam.GetValue("sWorkSampleName");
            SMeasureInfo.TSampleParam.bSwitch = Sample.GetSwitch();// (bool)TSampleParam.GetValue("bSwitch");

            List<CPropItemGrp> ja = Sample.GetPropItemGrps();// (JArray)jo.GetValue("ItemGrp");

            for (int i = 0; i < ja.Count; i++)
            {
                //获取GROUP ID和Grid的显示组的标题名
                var grp = ja[i];
                int grpId = (int)grp.GetGroupId();
                String sTitle = (String)grp.GetName();

                //获取样品属性ID和值

                var SDataArr = grp.GetItemsList();
                if (SDataArr.Count == 0)
                    continue;

                SampleDataGroup smlgrp = new SampleDataGroup();
                smlgrp.GroupId = (OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)grpId;
                smlgrp.sTitle = sTitle;
                for (int j = 0; j < SDataArr.Count; j++)
                {
                    var SDataObj = SDataArr[j];
                    SampleData SData = new SampleData();
                    int smplid = (int)SDataObj.GetSmplItemId();
                    SData.iSampleId = (OTS_SAMPLE_PROP_GRID_ITEMS)smplid;
                    if (SData.iSampleId == OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE)
                    {
                        bool b = (bool)SDataObj.IsReadOnly();
                    }
                    SData.sSCaptionName = (String)SDataObj.GetName();
                    //------------------------------修改--------------------------

                    if ((String)SDataObj.GetName() == "样品名")
                    {
                        for (int a = 0; a < ja.Count; a++)
                        {
                            var grpa = ja[a];
                            var SDataArra = grpa.GetItemsList();
                            for (int b = 0; b < SDataArra.Count; b++)
                            {
                                var SDataObb = SDataArra[b];
                                if ((String)SDataObb.GetName() == "测量状态")
                                {
                                    if ((String)Sample.GetItemValueStr((OTS_SAMPLE_PROP_GRID_ITEMS)SDataObb.GetSmplItemId()) == "未测量")
                                    {
                                        MeasurementStatus = false;
                                    }
                                    else
                                    {
                                        MeasurementStatus = true;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        MeasurementStatus = false;
                    }
                    if (MeasurementStatus)
                    {
                        SData.bReadOnly = MeasurementStatus;
                    }
                    else
                    {
                        SData.bReadOnly = (bool)SDataObj.IsReadOnly();// OTS_ITEM_TYPES
                    }

                    //---------------------------------------------------------------

                    int type = (int)SDataObj.GetTypeId();
                    SData.iSampleValType = (OTS_ITEM_TYPES)type;
                    SData.sDescriptionInfo = (String)SDataObj.GetDescription();
                
                    OTS_SAMPLE_PROP_GRID_ITEMS ItemId = SDataObj.GetSmplItemId();
                    SData.SampleVal = (String)Sample.GetItemValueStr(ItemId);
                    List<string> downStrList = new List<string>();
                    if (type == (int)OTS_ITEM_TYPES.COMBO)
                    {
                        Sample.GetPropComboStrings(SDataObj.GetSmplItemId(), downStrList);
                    }
                    else if (type == (int)OTS_ITEM_TYPES.FILE_LIST)
                    {
                        //the sample object dosen't know anything about the fileList infomation so it has to delay this duty here.
                        int iPos = -1;
                        List<string> sFileNameList = new List<string>();
                        if (OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_PARAM_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)smplid)
                        {
                            if (!this.GetMeasureParamFileName(ref iPos, ref sFileNameList))
                            {
                                return false;
                            }
                            foreach (var f in sFileNameList)
                            {
                                downStrList.Add(f);
                            }

                        }

                        if (OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)smplid)
                        {
                            if (!this.GetSTDFileName(ref iPos, ref sFileNameList))
                            {
                                return false;
                            }
                            foreach (var f in sFileNameList)
                            {
                                downStrList.Add(f);
                            }

                        }

                    }

                    if (downStrList.Count > 0)
                    {
                        for (int k = 0; k < downStrList.Count; k++)
                        {
                            SData.comboDownList.Add((String)downStrList[k]);
                        }
                    }
                    smlgrp.SampleDataList.Add(SData);

                }
                SMeasureInfo.AddASampleDataGrp(smlgrp);
            }

            return true;
        }




        //保存测量样品的
        public bool SaveMeasureSampleInfo()
        {

            if (!m_ResultData.Save())
            {
                return false;
            }
            return true;
        }

        //获取测量Sample的开始时间
        public bool GetMsrSampleStartTime(ref DateTime MsrFieldStartTime)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }
            MsrFieldStartTime = (DateTime)WSample.GetMsrStatus().GetStartTime();
            return true;
        }

        //获取测量已用时间
        public bool GetMsrSampleUsedTime(ref TimeSpan TUsedTime)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }
            TUsedTime = (TimeSpan)WSample.GetMsrStatus().GetUsedTime();
            return true;
        }



        // 获取测量样品中之前已经测量完成Field帧图，（上一次未测量完成继续测试）
        public bool GetBeforeCompleteField(ref string MsrSampleName, ref List<Point> FieldList)
        {
            COTSSample WSample = m_ResultData.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }

            MsrSampleName = WSample.GetName();
            FieldList = WSample.GetMsrStatus().GetCompletedFieldsCenter();
            return true;
        }


 

        /// <summary>
        /// 通过样品孔信息 返回默认测量区域大小
        /// </summary>
        /// <param name="cHoleClr"></param>
        /// <returns></returns>
        public Rectangle CalculateMsrArea(string cHoleName)
        {
            CHole cHoleClr = null;
            foreach (CHole item in m_ResultData.GetStage().GetHoleList())
            {
                if (item.GetName() == cHoleName)
                {
                    cHoleClr = item;
                }
            }
            CDomain CDomain = m_ResultData.CalculateMsrArea(cHoleClr);
            return (Rectangle)CDomain.GetRectDomain();
        }

        /// <summary>
        /// 获取已完成测量的结果文件路径
        /// </summary>
        /// <param name="mrFilePathList">返回测量结果文件路径</param>
        /// <returns></returns>
        public bool GetCompletedMeasureFileName(ref List<string> mrFilePathList)
        {
            //测量文件路径
            string proFilePath = m_ResultData.GetPathName();
            //样品列表
            List<COTSSample> sampleList = m_ResultData.GetSampleList();
            //获取样品数量
            int sampleCount = sampleList.Count;
            string mrSuffix = ".rst";
            int existsCount = 0;
            //获取测量文件路径
            if (proFilePath.Equals("Untitled"))
            {
                return false;
            }
            string mrFolderPath = string.Empty;
            try
            {
                mrFolderPath = proFilePath.Substring(0, proFilePath.LastIndexOf("\\"));
            }
            catch (Exception)
            {
                mrFolderPath = string.Empty;
            }
            for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)
            {
                int CompleteFieldsCount = sampleList[sampleIndex].GetMsrStatus().GetCompletedFields();
                //如果样品已测量成功后再加载至报告程序中
                if (CompleteFieldsCount > 0)
                {
                    string sampleName = sampleList[sampleIndex].GetName();
                    string mrFilePath = mrFolderPath + "\\" + sampleName + "\\" + sampleName + mrSuffix;
                    //判断文件是否存在
                    if (File.Exists(mrFilePath))
                    {
                        if (mrFilePathList != null)
                        {
                            mrFilePathList.Add(mrFilePath);
                        }
                        existsCount++;
                    }
                }
            }
            if (existsCount > 0)
            {
                return true;
            }
            return false;
        }


        /// <summary>
        /// 获取工作样品的测量状态
        /// </summary>
        /// <param name="workingSampleName"></param>
        /// <returns></returns>
        public bool GetWorkSampleMeasureStatus()
        {
            bool reuslt = false;
            COTSSample COTSSample = m_ResultData.GetWorkingSample();
            int sampleStatus = COTSSample.GetMsrStatus().GetCompletedFields();
            if (sampleStatus > 0)
            {
                reuslt = true;
            }
            return reuslt;

        }
      
    }

   



}