HYTOS

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 Microsoft.Win32;

using System.IO;

using System.Threading;

using SPPID.Modeling;

using SPPID.Model;

using SPPID.Utill;

using SPPID.DB;

using Microsoft.VisualBasic;

using Newtonsoft.Json;

using DevExpress.XtraEditors.Repository;

using DevExpress.XtraEditors.Controls;

using DevExpress.XtraEditors;

namespace SPPIDConverter_AutoModeling

{

    public partial class MainControl2 : UserControl

    {

        const string _Ready = "Ready";

        const string _LoadFail = "Can't Load";

        const string _NeedMapping = "Need Mapping";

        const string _NeedUnit = "Select Unit";

        const string _NeedTemplate = "Select Template";

        const string _Error = "Error";

        const string _EndProcess = "End Process";

        const string _Processing = "Processing";

        Thread autoModelingThread;

        Dictionary<string, Document> dicDocument = new Dictionary<string, Document>();

        private Dictionary<string, string> symbolMapping = new Dictionary<string, string>();

        private Dictionary<string, string> attributeMapping = new Dictionary<string, string>();

        List<string> needSymbolMapping = new List<string>();

        List<string> needAttributeMapping = new List<string>();

        private DataTable dUnit = new DataTable();

        private string TemplatePath;

        private string SymbolPath;

        DataTable converterDT = new DataTable();

        DataTable symbolDT = new DataTable();

        DataTable attributeDT = new DataTable();

        DataTable symbolPathDT = new DataTable();

        RepositoryItemComboBox templateComboBox;

        RepositoryItemComboBox attributeComboBox;

        public MainControl2()

        {

            InitializeComponent();

            if (InitPath())

            {

                InitDBSettingPage();

                if (SPPIDUtill.LoadDB())

                {

                    InitGridControl();

                    InitDBInformation();

                }

                else

                    MessageBox.Show("Please Check DB Setting", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

            }

            else

            {

            }

        }

        private void InitGridControl()

        {

            #region Converter Page

            gridViewConverter.OptionsSelection.MultiSelect = true;

            gridViewConverter.OptionsSelection.MultiSelectMode = DevExpress.XtraGrid.Views.Grid.GridMultiSelectMode.CheckBoxRowSelect;

            DataColumn col = converterDT.Columns.Add("colDrawingFileName");

            col.Caption = "Drawing File Name";

            col = converterDT.Columns.Add("colUnit");

            col.Caption = "Unit";

            col = converterDT.Columns.Add("colTemplate");

            col.Caption = "Template";

            col = converterDT.Columns.Add("colDrawingNumber");

            col.Caption = "Drawing Number";

            col = converterDT.Columns.Add("colDrawingName");

            col.Caption = "Drawing Name";

            col = converterDT.Columns.Add("colStatus");

            col.Caption = "Status";

            col = converterDT.Columns.Add("colUID");

            gridControlConverter.DataSource = converterDT;

            templateComboBox = new RepositoryItemComboBox();

            templateComboBox.TextEditStyle = TextEditStyles.DisableTextEditor;

            gridControlConverter.RepositoryItems.Add(templateComboBox);

            gridViewConverter.Columns["colTemplate"].ColumnEdit = templateComboBox;

            RepositoryItemButtonEdit unitButton = new RepositoryItemButtonEdit();

            unitButton.ButtonClick += UnitButton_ButtonClick;

            unitButton.TextEditStyle = DevExpress.XtraEditors.Controls.TextEditStyles.DisableTextEditor;

            gridControlConverter.RepositoryItems.Add(unitButton);

            gridViewConverter.Columns["colUnit"].ColumnEdit = unitButton;

            gridViewConverter.Columns["colDrawingFileName"].OptionsColumn.AllowEdit = false;

            gridViewConverter.Columns["colUnit"].OptionsColumn.ReadOnly = true;

            gridViewConverter.Columns["colStatus"].OptionsColumn.AllowEdit = false;

            gridViewConverter.Columns["colUID"].Visible = false;

            gridViewConverter.BestFitColumns();

            #endregion

            #region Mapping Page

            col = symbolDT.Columns.Add("colItemName");

            col.Caption = "Item Name";

            col = symbolDT.Columns.Add("colSPPIDName");

            col.Caption = "SPPID Name";

            gridControlSymbol.DataSource = symbolDT;

            RepositoryItemButtonEdit symbolButton = new RepositoryItemButtonEdit();

            symbolButton.ButtonClick += SymbolButton_ButtonClick;

            symbolButton.TextEditStyle = TextEditStyles.DisableTextEditor;

            gridControlSymbol.RepositoryItems.Add(symbolButton);

            gridViewSymbol.Columns["colSPPIDName"].ColumnEdit = symbolButton;

            gridViewSymbol.Columns["colItemName"].OptionsColumn.AllowEdit = false;

            col = attributeDT.Columns.Add("colAttribute");

            col.Caption = "Attribute Name";

            col = attributeDT.Columns.Add("colSPPIDAttribute");

            col.Caption = "SPPID Attribute Name";

            gridControlAttribute.DataSource = attributeDT;

            attributeComboBox = new RepositoryItemComboBox();

            attributeComboBox.TextEditStyle = TextEditStyles.DisableTextEditor;

            gridControlAttribute.RepositoryItems.Add(attributeComboBox);

            gridViewAttribute.Columns["colSPPIDAttribute"].ColumnEdit = attributeComboBox;

            gridViewAttribute.Columns["colAttribute"].OptionsColumn.AllowEdit = false;

            #endregion

        }

        private bool InitPath()

        {

            try

            {

                RegistryKey key = Registry.LocalMachine;

                RegistryKey software = key.OpenSubKey("SOFTWARE");

                RegistryKey DOFTECH = software.OpenSubKey("DOFTECH");

                if (DOFTECH != null)

                {

                    RegistryKey ID2 = DOFTECH.OpenSubKey("ID2");

                    if (ID2 != null)

                    {

                        SPPIDUtill.defaultPath = ID2.GetValue("Path").ToString();

                        Log.logPath = SPPIDUtill.defaultPath + @"Converter\SPPID Converter.log";

                        SPPIDUtill.mappingFilePath = SPPIDUtill.defaultPath + @"Converter\mapping.xml";

                        SPPIDUtill.dbFilePath = SPPIDUtill.defaultPath + @"Converter\DB.config";

                        return true;

                    }

                }

            }

            catch (Exception ex)

            {

            }

            return false;

        }

        public void InitDBInformation()

        {

            try

            {

                DBInformation dbInfo = DBInformation.GetInstance();

                if (dbInfo.Status)

                {

                    tbDBType.Text = dbInfo.DBType;

                    tbServiceName.Text = dbInfo.Service;

                    tbSiteName.Text = dbInfo.Site;

                    tbServerIP.Text = dbInfo.ServerIP;

                    tbPort.Text = dbInfo.Port;

                    tbDBUser.Text = dbInfo.DBUser;

                    tbDBPassword.Text = dbInfo.DBPassword;

                    comboBoxPlantList.Properties.Items.AddRange(dbInfo.PlantList);

                    comboBoxPlantList.SelectedIndex = dbInfo.PlantList.FindIndex(x => x == dbInfo.Plant);

                }

                // Unit DataTable

                dUnit = DB.GetUnitTree();

                // Template List

                TemplatePath = DB.GetPlantPID_T_OPTIONSETTING_Value("PID Template Path");

                if (!string.IsNullOrEmpty(TemplatePath))

                {

                    templateComboBox.Items.Clear();

                    templateComboBox.Items.AddRange(Directory.GetFiles(TemplatePath, "*.pid").ToList().Select(filePath => Path.GetFileName(filePath)).ToList());

                }

                // Symbol Path

                SymbolPath = DB.GetPlantPID_T_OPTIONSETTING_Value("Catalog Explorer root path");

                SetPathDataTable();

                // Load Mapping

                SPPIDUtill.LoadMapping(symbolMapping, attributeMapping);

                foreach (var item in symbolMapping)

                    symbolDT.Rows.Add(item.Key, item.Value);

                gridViewSymbol.BestFitColumns();

                // Attribute

                attributeComboBox.Items.Clear();

                attributeComboBox.Items.AddRange(DB.GetSPPIDAttribute());

                // Load Attribute

                foreach (var item in attributeMapping)

                    attributeDT.Rows.Add(new object[] { item.Key, item.Value });

            }

            catch (Exception ex)

            {

            }

        }

        private void SetPathDataTable()

        {

            symbolPathDT = new DataTable();

            symbolPathDT.Columns.Add("ID");

            symbolPathDT.Columns.Add("Parent");

            symbolPathDT.Columns.Add("Name");

            symbolPathDT.Columns.Add("FullPath");

            DirectoryInfo info = new DirectoryInfo(SymbolPath);

            symbolPathDT.Rows.Add(new object[] { "0", "-1", info.Name });

            loop(info, "0");

        }

        private void loop(DirectoryInfo parentInfo, string parentUID)

        {

            DirectoryInfo[] infos = parentInfo.GetDirectories();

            foreach (DirectoryInfo info in infos)

            {

                string uid = Guid.NewGuid().ToString();

                symbolPathDT.Rows.Add(new object[] { uid, parentUID, info.Name });

                loop(info, uid);

                FileInfo[] files = info.GetFiles("*.sym");

                foreach (FileInfo fileInfo in files)

                {

                    symbolPathDT.Rows.Add(new object[] { Guid.NewGuid().ToString(), uid, fileInfo.Name, fileInfo.FullName.Replace(SymbolPath, "") });

                }

            }

        }

        public void InitDBSettingPage()

        {

            comboBoxPlantList.Properties.TextEditStyle = DevExpress.XtraEditors.Controls.TextEditStyles.DisableTextEditor;

            textBoxFittingSymbolPath.Properties.TextEditStyle = DevExpress.XtraEditors.Controls.TextEditStyles.DisableTextEditor;

        }

        private void tabControl_SelectedPageChanged(object sender, DevExpress.XtraTab.TabPageChangedEventArgs e)

        {

            if (e.Page.Name == "pageItemMapping")

            {

                gridViewSymbol.BeginUpdate();

                gridViewAttribute.BeginUpdate();

                symbolDT.Rows.Clear();

                attributeDT.Rows.Clear();

                foreach (var item in symbolMapping)

                {

                    if (item.Key == "FittingSymbolPath")

                    {

                        textBoxFittingSymbolPath.EditValue = item.Value;

                    }

                    else

                    {

                        symbolDT.Rows.Add(item.Key, item.Value);

                    }

                }

                foreach (var item in attributeMapping)

                {

                    if (item.Key == "LargeSize")

                    {

                        if (radioGroupReducer.Properties.Items[0].Tag.ToString() == item.Value)

                            radioGroupReducer.SelectedIndex = 0;

                        else

                            radioGroupReducer.SelectedIndex = 1;

                    }

                    else if (item.Key != "SmallSize")

                    {

                        attributeDT.Rows.Add(new object[] { item.Key, item.Value });

                    }

                }

                needSymbolMapping = needSymbolMapping.Distinct().ToList();

                foreach (string item in needSymbolMapping)

                {

                    if (!symbolMapping.ContainsKey(item))

                        symbolDT.Rows.Add(item, "");

                }

                needAttributeMapping = needAttributeMapping.Distinct().ToList();

                foreach (string item in needAttributeMapping)

                {

                    if (!attributeMapping.ContainsKey(item))

                        attributeDT.Rows.Add(item, "");

                }

                gridViewSymbol.EndUpdate();

                gridViewAttribute.EndUpdate();

            }

        }

        #region Converter Page

        private void RefreshGridViewDrawingList()

        {

            if (gridControlConverter.InvokeRequired)

            {

                gridControlConverter.BeginInvoke(new Action(() => gridControlConverter.Refresh()));

                Thread.Sleep(1);

            }

            else

            {

                gridControlConverter.Refresh();

            }

        }

        private void btnLoadFiles_Click(object sender, EventArgs e)

        {

            OpenFileDialog dia = new OpenFileDialog();

            dia.Multiselect = true;

            dia.Filter = "Xml Files(*.xml)|*.xml";

            if (dia.ShowDialog() == DialogResult.OK)

            {

                foreach (string fileName in dia.FileNames)

                {

                    try

                    {

                        DataRow row = converterDT.NewRow();

                        Document document = Document.Load(fileName, symbolMapping, attributeMapping);

                        if (document == null)

                        {

                            row[""] = fileName;

                            row["colDrawingFileName"] = fileName;

                            row["colStatus"] = _LoadFail;

                        }

                        else

                        {

                            row["colDrawingFileName"] = document.DWGNAME;

                            row["colDrawingNumber"] = document.DWGNAME;

                            row["colDrawingName"] = document.DWGNAME;

                        }

                        string sUID = Guid.NewGuid().ToString();

                        row["colUID"] = sUID;

                        dicDocument.Add(sUID, document);

                        converterDT.Rows.Add(row);

                        gridViewConverter.BestFitColumns();

                    }

                    catch (Exception ex)

                    {

                    }

                }

            }

        }

        private void btnRun_Click(object sender, EventArgs e)

        {

            if (!CheckDB())

            {

                MessageBox.Show("Please Check DB Setting", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                return;

            }

            if (gridViewConverter.SelectedRowsCount > 0)

            {

                if (DialogResult.OK == MessageBox.Show("SPPID Converter를 실행하시겠습니까?", "Question", MessageBoxButtons.OKCancel, MessageBoxIcon.Question))

                {

                    try

                    {

                        ProgressForm.stop = false;

                        foreach (int rowHandle in gridViewConverter.GetSelectedRows())

                        {

                            try

                            {

                                string sStatus = gridViewConverter.GetRowCellDisplayText(rowHandle, "colStatus");

                                if (sStatus == _Ready && !ProgressForm.stop)

                                {

                                    gridViewConverter.SetRowCellValue(rowHandle, "colStatus", _Processing);

                                    RefreshGridViewDrawingList();

                                    string sUnit = gridViewConverter.GetRowCellDisplayText(rowHandle, "colUnit");

                                    string sTemplate = TemplatePath + @"\" + gridViewConverter.GetRowCellDisplayText(rowHandle, "colTemplate");

                                    string sDrawingNumber = gridViewConverter.GetRowCellDisplayText(rowHandle, "colDrawingNumber");

                                    string sDrawingName = gridViewConverter.GetRowCellDisplayText(rowHandle, "colDrawingName");

                                    //

                                    dynamic application = Interaction.GetObject("", "PIDAutomation.Application");

                                    dynamic newDrawing = application.Drawings.Add(sUnit, sTemplate, sDrawingNumber, sDrawingName);

                                    application.ActiveWindow.Fit();

                                    Thread.Sleep(100);

                                    application.ActiveWindow.Zoom = 2000;

                                    Thread.Sleep(100);

                                    //

                                    Document document = dicDocument[gridViewConverter.GetRowCellDisplayText(rowHandle, "colUID")];

                                    autoModelingThread = new Thread(Func =>

                                    {

                                        try

                                        {

                                            Thread.Sleep(500);

                                            ProgressForm.UpdateDocument(document.DWGNAME);

                                            AutoModeling auto = new AutoModeling(document);

                                            auto.Run();

                                            ProgressForm.End();

                                        }

                                        catch (Exception ex)

                                        {

                                            Log.WriteLine(ex);

                                        }

                                    });

                                    ProgressForm.Start(autoModelingThread);

                                    gridViewConverter.SetRowCellValue(rowHandle, "colStatus", _EndProcess);

                                    RefreshGridViewDrawingList();

                                    application.ActiveWindow.Fit();

                                    Thread.Sleep(100);

                                    newDrawing.CloseDrawing(true);

                                    Thread.Sleep(100);

                                }

                            }

                            catch (Exception ex)

                            {

                                gridViewConverter.SetRowCellValue(rowHandle, "colStatus", _Error);

                            }

                        }

                    }

                    catch (Exception ex)

                    {

                        MessageBox.Show(ex.Message);

                    }

                }

            }

            else

            {

                MessageBox.Show("도면을 선택해주세요!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

            }

        }

        private void UnitButton_ButtonClick(object sender, ButtonPressedEventArgs e)

        {

            UnitForm unitForm = new UnitForm(dUnit);

            if (unitForm.ShowDialog() == DialogResult.OK)

            {

                ButtonEdit button = sender as ButtonEdit;

                button.EditValue = unitForm.SelectedUnit;

                gridViewConverter.CloseEditor();

                gridViewConverter.UpdateCurrentRow();

                gridViewConverter.BestFitColumns();

            }

        }

        private void gridViewConverter_CellValueChanged(object sender, DevExpress.XtraGrid.Views.Base.CellValueChangedEventArgs e)

        {

            if (e.Column.FieldName == "colUnit" || e.Column.FieldName == "colTemplate")

            {

                CheckStatus(e.RowHandle);

            }

        }

        private void CheckStatus(int rowHandle)

        {

            bool result = true;

            string sUnit = gridViewConverter.GetRowCellDisplayText(rowHandle, "colUnit");

            string sTemplate = gridViewConverter.GetRowCellDisplayText(rowHandle, "colTemplate");

            string sUID = gridViewConverter.GetRowCellDisplayText(rowHandle, "colUID");

            Document document = dicDocument[sUID];

            if (!document.ReMapping(needSymbolMapping, needAttributeMapping))

            {

                needSymbolMapping = needSymbolMapping.Distinct().ToList();

                needAttributeMapping = needAttributeMapping.Distinct().ToList();

                result = false;

            }

            if (string.IsNullOrEmpty(sUnit) || string.IsNullOrEmpty(sTemplate))

                result = false;

            if (result)

                gridViewConverter.SetRowCellValue(rowHandle, "colStatus", "Ready");

            else

                gridViewConverter.SetRowCellValue(rowHandle, "colStatus", "");

        }

        #endregion

        #region DB Setting Page

        private void LoadPlantiniFile_Click(object sender, EventArgs e)

        {

            try

            {

                OpenFileDialog dialog = new OpenFileDialog();

                dialog.Multiselect = false;

                dialog.Filter = "ini File(*.ini)|*.ini";

                if (dialog.ShowDialog() == DialogResult.OK)

                {

                    string sDBTYPE = string.Empty;

                    string sSERVICENAME = string.Empty;

                    string sUID = string.Empty;

                    string[] texts = File.ReadAllLines(dialog.FileName);

                    bool find = false;

                    for (int i = 0; i < texts.Length; i++)

                    {

                        string text = texts[i];

                        if (text.Trim() == "[SITESCHEMA]")

                            find = true;

                        if (find)

                        {

                            if (text.StartsWith("DBTYPE=") && string.IsNullOrEmpty(sDBTYPE))

                                sDBTYPE = text.Remove(0, "DBTYPE=".Length);

                            else if (text.StartsWith("DBSERVER=") && string.IsNullOrEmpty(sSERVICENAME))

                                sSERVICENAME = text.Remove(0, "DBSERVER=".Length);

                            else if (text.StartsWith("UID=") && string.IsNullOrEmpty(sUID))

                                sUID = text.Remove(0, "UID=".Length);

                        }

                    }

                    if (string.IsNullOrEmpty(sDBTYPE) || string.IsNullOrEmpty(sSERVICENAME) || string.IsNullOrEmpty(sUID))

                        MessageBox.Show("Unavailable ini file.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                    else

                    {

                        tbDBType.Text = sDBTYPE;

                        tbServiceName.Text = sSERVICENAME;

                        tbSiteName.Text = sUID;

                    }

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show("Unavailable ini file.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

            }

        }

        private void btnDBTest_Click(object sender, EventArgs e)

        {

            try

            {

                SetDBInformation();

                comboBoxPlantList.Properties.Items.Clear();

                comboBoxPlantList.SelectedIndex = -1;

                List<string> plantList = DB.GetPlantList();

                if (plantList.Count > 0)

                {

                    comboBoxPlantList.Properties.Items.AddRange(plantList);

                    comboBoxPlantList.SelectedIndex = 0;

                    MessageBox.Show("Success.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);

                }

            }

            catch (Exception ex)

            {

            }

        }

        private void SetDBInformation()

        {

            DBInformation dbInfo = DBInformation.GetInstance();

            dbInfo.Status = false;

            dbInfo.DBType = tbDBType.Text;

            dbInfo.Service = tbServiceName.Text;

            dbInfo.Site = tbSiteName.Text;

            dbInfo.ServerIP = tbServerIP.Text;

            dbInfo.Port = tbPort.Text;

            dbInfo.DBUser = tbDBUser.Text;

            dbInfo.DBPassword = tbDBPassword.Text;

        }

        private bool CheckDB()

        {

            bool result = false;

            List<string> plantList = DB.GetPlantList();

            string selectedPlant = comboBoxPlantList.Properties.Items[comboBoxPlantList.SelectedIndex].ToString();

            if (plantList.Contains(selectedPlant))

                result = true;

            return result;

        }

        private void btnSave_Click(object sender, EventArgs e)

        {

            try

            {

                if (comboBoxPlantList.SelectedIndex == -1)

                {

                    MessageBox.Show("Plant를 선택해주세요.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                    return;

                }

                DBInformation dbInfo = DBInformation.GetInstance();

                SetDBInformation();

                List<string> plantList = DB.GetPlantList();

                string selectedPlant = comboBoxPlantList.Properties.Items[comboBoxPlantList.SelectedIndex].ToString();

                if (plantList.Contains(selectedPlant) && DB.SetPlantDBSetting())

                {

                    dbInfo.Plant = selectedPlant;

                    dbInfo.PlantList = plantList;

                    dbInfo.Status = true;

                    string sJson = JsonConvert.SerializeObject(dbInfo);

                    SPPIDUtill.SaveDB(sJson);

                    MessageBox.Show("DB 정보를 저장하였습니다.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);

                }

                else

                {

                    MessageBox.Show("저장에 실패하였습니다.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show("저장에 실패하였습니다.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);

            }

        }

        #endregion

        #region Mapping Page

        private void SymbolButton_ButtonClick(object sender, ButtonPressedEventArgs e)

        {

            SymbolPathForm symbolPathForm = new SymbolPathForm(symbolPathDT);

            if (symbolPathForm.ShowDialog() == DialogResult.OK)

            {

                ButtonEdit button = sender as ButtonEdit;

                button.EditValue = symbolPathForm.FullPath;

                gridViewSymbol.CloseEditor();

                gridViewSymbol.UpdateCurrentRow();

                gridViewSymbol.BestFitColumns();

            }

        }

        private void btnMappingSave_Click(object sender, EventArgs e)

        {

            symbolMapping.Clear();

            foreach (DataRow row in symbolDT.Rows)

            {

                if (row["colItemName"] != null && row["colSPPIDName"] != null)

                {

                    string key = row["colItemName"].ToString();

                    string value = row["colSPPIDName"].ToString();

                    if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))

                    {

                        if (symbolMapping.ContainsKey(key))

                            symbolMapping[key] = value;

                        else

                            symbolMapping.Add(key, value);

                    }

                }

            }

            attributeMapping.Clear();

            foreach (DataRow row in attributeDT.Rows)

            {

                if (row["colAttribute"] != null && row["colSPPIDAttribute"] != null)

                {

                    string key = row["colAttribute"].ToString();

                    string value = row["colSPPIDAttribute"].ToString();

                    if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))

                    {

                        if (attributeMapping.ContainsKey(key))

                            attributeMapping[key] = value;

                        else

                            attributeMapping.Add(key, value);

                    }

                }

            }

            // Custom

            if (radioGroupReducer.SelectedIndex == 0)

            {

                attributeMapping.Add("LargeSize", radioGroupReducer.Properties.Items[0].Tag.ToString());

                attributeMapping.Add("SmallSize", radioGroupReducer.Properties.Items[1].Tag.ToString());

            }

            else

            {

                attributeMapping.Add("LargeSize", radioGroupReducer.Properties.Items[1].Tag.ToString());

                attributeMapping.Add("SmallSize", radioGroupReducer.Properties.Items[0].Tag.ToString());

            }

            symbolMapping.Add("FittingSymbolPath", textBoxFittingSymbolPath.EditValue.ToString());

            SPPIDUtill.SaveMapping(symbolMapping, attributeMapping);

            for (int i = 0; i < converterDT.Rows.Count; i++)

            {

                CheckStatus(gridViewConverter.GetRowHandle(i));

            }

            MessageBox.Show("Save success!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);

        }

        private void textBoxSymbolPath_ButtonClick(object sender, ButtonPressedEventArgs e)

        {

            SymbolPathForm symbolPathForm = new SymbolPathForm(symbolPathDT);

            if (symbolPathForm.ShowDialog() == DialogResult.OK)

            {

                ButtonEdit button = sender as ButtonEdit;

                button.EditValue = symbolPathForm.FullPath;

            }

        }

        #endregion

    }

}