OTS/OTSIncAMeasureApp/1-OTSMeasure/Measure/ParamData/OTSDefaultParam.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using OTSDataType;
using OTSMeasureApp._0_OTSModel.OTSDataType;
using static OTSDataType.otsdataconst;

namespace OTSModelSharp
{
   public  class COTSDefaultParam : ISlo
    {
        protected static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        // soft pack id
        private otsdataconst.OTS_SysType_ID systemTypeId;
        public otsdataconst.RunMode m_runmode;

        // SEM stage data
        CSEMStageData m_pStageDataParam;

        // general parameter
        COTSCommonParam m_CommonParam;

        // image scan parameter
        COTSImgScanPrm m_pImageScanParam;
        CSpecialGrayRangeParam m_pSpecialGrayRangeParam;
        // image process parameter
        COTSImageProcParam m_pImageProcParam;

        // X-Ray parameter
        COTSXRayParam m_pXRayParam;

        CBrightnessContrastRegulateParam m_pBrightnessContrastRegulateParam;    

        // file pathname
        protected string m_strPathName;

        const int SCREEN_WIDTH_MAG100 = 1142;

        const long STAGE_DATA_X_AXIS_START = -100000;

        const long STAGE_DATA_X_AXIS_END = 100000;

        //stage data y start
        const long STAGE_DATA_Y_AXIS_START = -100000;

        //stage data y end
        const long STAGE_DATA_Y_AXIS_END = 100000;
   

        const String STR_MEASURE_PREFERENCE_FILE_NAME = "OTSProgMgrParam.pmf";

        // sample name
        const String SAMPLE_NAME = "Sample";

        // measure switch
        const bool MEASURE_SWITCH = true;

        const String STR_COFIGPATH = "Config";

        const String STR_PROG_DATA = "ProData";

        const String STR_SYSTEM_DATA = "SysData";

        public OTS_SysType_ID SystemTypeId { get => systemTypeId; set => systemTypeId = value; }
        public CSpecialGrayRangeParam SpecialGrayRangeParam { get => m_pSpecialGrayRangeParam; set => m_pSpecialGrayRangeParam = value; }
        internal CBrightnessContrastRegulateParam BrightnessContrastRegulationParam { get => m_pBrightnessContrastRegulateParam; set => m_pBrightnessContrastRegulateParam = value; }

        public COTSDefaultParam()
        {
            Init();
        }
        //样品台文件（读取样品台数据等)                            
        private CStageHolderParam stageHolderParam = null;

        public COTSImgScanPrm GetImageScanParam() { return m_pImageScanParam; }

        public COTSImageProcParam GetImageProcParam() { return m_pImageProcParam; }
        public COTSXRayParam GetXRayParam() { return m_pXRayParam; }

        public CSEMStageData GetStageDataParam() { return m_pStageDataParam; }
        public COTSCommonParam GetCommonParam() { return m_CommonParam; }


        



        public void SetCommonParam(COTSCommonParam a_cOTSGeneralParam) { m_CommonParam=a_cOTSGeneralParam; }

        public void SetImageScanParam(COTSImgScanPrm a_cOTSImgScanPrm) { m_pImageScanParam= a_cOTSImgScanPrm; }

        public void SetImageProcParam(COTSImageProcParam a_cOTSImageProcParam) { m_pImageProcParam=a_cOTSImageProcParam; }
        public void SetXRayParam(COTSXRayParam a_cOTSXRayParam) { m_pXRayParam=a_cOTSXRayParam; }

        public void SetStageDataParam(CSEMStageData a_cSEMStageData) { m_pStageDataParam=a_cSEMStageData; }


        public CStageHolderParam GetStageHolderParam()
        {
            return stageHolderParam;
        }

        public void SetStageHolderParam(CStageHolderParam value)
        {
            stageHolderParam = value;
        }

        public bool LoadInfoFromProgMgrFile()
        {

            // get software pack measure preference file pathname
            string strProgMgrParamFileName = GetOTSMeasurePrefFileName();
   
            // program manager param file exists?
            if (File.Exists(strProgMgrParamFileName))
            {
                // tried to load it
                if (!Load(strProgMgrParamFileName))
                {
                    // failed to load the license info file
                    logger.Info("LoadLicenseInfoFile: failed to load license info file. pathname:"+strProgMgrParamFileName+".");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadLicenseInfoFile: failed to load license info file. pathname: %s"), strProgMgrParamFilePathName);
                    return false;
                }
            }
            LoadStageParamFile();
            return true;
        }

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

            return true;

        }

        public string GetSysTypeName()
        {
            return systemTypeId.ToString();
        }
        public OTS_SysType_ID GetSysType()
        {
            return systemTypeId;
        }

        public RunMode GetRunMode()
        {
            return m_runmode;
        }

        public static string GetMsrParamFileFolderName()
        {

            return ".\\Config\\SysData\\";
        }

        public static string GetPartSTDLibFolderName()
        {
            return ".\\Config\\SysData\\";
        }

        // get software pack preference file path name
        public String GetOTSMeasurePrefFileName()
        {
            // get software package system data pathname
            String strOTSPackSysDataPathName = GetOTSSysDataPathName();


            String strOTSPackProgMgrPathName = strOTSPackSysDataPathName + STR_MEASURE_PREFERENCE_FILE_NAME;

            // return software package license file pathname 
            return strOTSPackProgMgrPathName;
        }

        // get software pack system data path
        private  String GetOTSSysDataPathName()//deprecated,since we have build one new solution for the particle system.
        {

            // get common data pathname string
            String strCommonDataPathName = GetOSCommonDataPathName();
      

            // software package system data pathname
         
            String strOTSSysDataPathName = strCommonDataPathName + STR_COFIGPATH + "\\" + STR_SYSTEM_DATA + "\\";

            // return software package system data path
            return strOTSSysDataPathName;
        }


        // get system common data folder pathname
        // return "" if failed
       private String GetOSCommonDataPathName()
        {

            return ".\\";
        }


        // safe parameters into program preference file
        public bool SaveInfoToProgMgrFile()
        {

            // get software pack measure preference file pathname
            string strProgMgrParamFileFullName = GetOTSMeasurePrefFileName();
          // save parameters into program preference file
            if (!Save(strProgMgrParamFileFullName))
            {
                // failed to save program preference file, return FALSE
                logger.Info("SaveInfoToProgMgrFile: failed to save program preference file.");  //LogErrorTrace(__FILE__, __LINE__, _T("SaveInfoToProgMgrFile: failed to save program preference file."));
                return false;
            }
            // ok, return TRUE
            return true;
        }

    


        // NOTE: be sure a_strPathName is a valid file pathname
        private bool Load(string a_strPathName)
        {
            // file pathname
            m_strPathName = a_strPathName;

            m_pStageDataParam = new CSEMStageData();

            m_CommonParam = new COTSCommonParam();
            // image scan parameter
            m_pImageScanParam = new COTSImgScanPrm();

            // image process parameter
            m_pImageProcParam = new COTSImageProcParam();

            // X-Ray parameter
            m_pXRayParam = new COTSXRayParam();

            m_pSpecialGrayRangeParam=new CSpecialGrayRangeParam();
            m_pBrightnessContrastRegulateParam = new CBrightnessContrastRegulateParam();    
            XmlDocument doc = new XmlDocument();
            //载入xml文件
            doc.Load(a_strPathName); 

            XmlNode root = doc.SelectSingleNode("XMLData");
            Serialize(false, doc, root);

            
            return true;
        }
        // save program manager file 
        private bool Save(string a_strPathName)
        {
            //ASSERT(m_pStageData);
            //Debug.Assert(m_pParam);
            XmlDocument doc = new XmlDocument();
            doc.Load(a_strPathName);
            doc.RemoveAll();
            //添加xml文件头申明
            XmlDeclaration xmldecl = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
            doc.AppendChild(xmldecl);
            XmlElement rootNode = doc.CreateElement("XMLData");
            doc.AppendChild(rootNode);

            Serialize(true, doc, rootNode);
            try
            {
                doc.Save(a_strPathName);
            }
            catch
            {
                return false;
            }
            // file pathname
            m_strPathName = a_strPathName;
            // ok, return TRUE
            return true;
        }
        // serialization
        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
           
            xString xSysType = new xString();

            xString xRunMode = new xString();
            Slo slo = new Slo();
          
            slo.Register("SysType", xSysType);
            slo.Register("RunMode", xRunMode);
            slo.Register("StageData", m_pStageDataParam);
            slo.Register("GenParam", m_CommonParam);
            slo.Register("ImageScanParam", m_pImageScanParam);
            slo.Register("SpecialGrayParam", m_pSpecialGrayRangeParam);
            slo.Register("BrightnessContrastRegulateParam", m_pBrightnessContrastRegulateParam);
            slo.Register("ImageProcParam", m_pImageProcParam);
            slo.Register("XrayParam", m_pXRayParam);
            if (isStoring)
            {
                xSysType.AssignValue(systemTypeId.ToString());
                xRunMode.AssignValue(m_runmode.ToString());
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);

                switch (xSysType.value())
                {
                    case "IncA":
                        this.systemTypeId = OTS_SysType_ID.IncA;
                        break;
                    case "TCCleannessA":
                        this.systemTypeId = OTS_SysType_ID.TCCleannessA;
                        break;
                    case "BatteryCleannessA":
                        this.systemTypeId = OTS_SysType_ID.BatteryCleannessA;
                        break;
                    default:
                        break;                                
                }
                switch (xRunMode.value())
                {
                    case "ProfessionalMode":
                        this.m_runmode = otsdataconst.RunMode.ProfessionalMode;
                        break;
                    case "PlainMode":
                        this.m_runmode = RunMode.PlainMode;
                        break;
                    default:
                        break;
                }


            }
        }


        protected void Init()
        {
            m_strPathName = "";
        }

        // duplication
        protected void Duplicate(COTSDefaultParam a_oSource)
        {
            // initialization
            Init();

            // copy data over
            m_strPathName = a_oSource.m_strPathName;
            m_CommonParam = new COTSCommonParam(a_oSource.m_CommonParam);
        }
    }
}