HYTOS

                                    bool leaderLine = false;

                                    SymbolMapping symbolMapping = document.SymbolMappings.Find(x => x.UID == item.DBUID);

                                    if (symbolMapping != null)

                                        leaderLine = symbolMapping.LEADERLINE;

                                    LMLabelPersist _LMLabelPresist = _placement.PIDPlaceLabel(item.SPPID.MAPPINGNAME, ref points, Rotation: 0, LabeledItem: _TargetItem.AsLMRepresentation(), IsLeaderVisible: leaderLine);

                                    //Leader 선 센터로

                        LEADERLINE = DBNull.Value.Equals(row["LEADERLINE"]) ? false : (bool)row["LEADERLINE"]

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Globalization;

using System.Data.SQLite;

using System.Data;

namespace Converter.BaseModel

{

    public class Project_DB

    {

        const string SPPID_DB_INFO_TABLE = "T_SPPID_CONNECTION_INFO";

        const string SPPID_SYMBOL_MAPPING_TABLE = "T_SPPID_SYMBOL_MAPPING";

        const string SPPID_ATTRIBUTE_MAPPING_TABLE = "T_SPPID_ATTRIBUTE_MAPPING";

        const string SPPID_ETC_SETTING_TABLE = "T_SPPID_ETC_SETTING_TABLE";

        const string SPPID_LABEL_INFO_TABLE = "T_SPPID_LABEL_INFO";

        const string LineProperties_TABLE = "LineProperties";

        const string LineTypes_TABLE = "LineTypes";

        const string SymbolType_TABLE = "SymbolType";

        const string SymbolAttribute_TABLE = "SymbolAttribute";

        const string Symbol_TABLE = "Symbol";

        public static bool ConnTestAndCreateTable()

        {

            bool result = false;

            Project_Info projectInfo = Project_Info.GetInstance();

            SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, @"Data Source = {0}", projectInfo.DBFilePath));

            try

            {

                connection.Open();

                if (connection.State == ConnectionState.Open)

                {

                    CreateTable(connection);

                    result = true;

                }

                connection.Close();

            }

            catch (Exception ex)

            {

            }

            finally

            {

                connection.Dispose();

            }

            return result;

        }

        public static bool SaveSPPID_DB_INFO(string jsonString)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("DELETE FROM {0}", SPPID_DB_INFO_TABLE);

                        cmd.ExecuteNonQuery();

                        cmd.CommandText = string.Format("INSERT INTO {0} VALUES (@jsonString)", SPPID_DB_INFO_TABLE);

                        cmd.Parameters.AddWithValue("@jsonString", jsonString);

                        cmd.ExecuteNonQuery();

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

        public static DataTable SelectSPPID_DB_INFO()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("SELECT * FROM {0}", SPPID_DB_INFO_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        public static bool SaveETCSetting(string jsonString)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("DELETE FROM {0}", SPPID_ETC_SETTING_TABLE);

                        cmd.ExecuteNonQuery();

                        cmd.CommandText = string.Format("INSERT INTO {0} VALUES (@jsonString)", SPPID_ETC_SETTING_TABLE);

                        cmd.Parameters.AddWithValue("@jsonString", jsonString);

                        cmd.ExecuteNonQuery();

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

        public static DataTable SelectETCSetting()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format("SELECT * FROM {0}", SPPID_ETC_SETTING_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        private static void CreateTable(SQLiteConnection connection)

        {

            using (SQLiteCommand cmd = connection.CreateCommand())

            {

                cmd.CommandText = "SELECT NAME FROM sqlite_master WHERE type='table'";

                using (SQLiteDataReader dr = cmd.ExecuteReader())

                using (DataTable dt = new DataTable())

                {

                    dt.Load(dr);

                    if (dt.Select(string.Format("NAME = '{0}'", SPPID_DB_INFO_TABLE)).Length == 0)

                    {

                        cmd.CommandText = string.Format("CREATE TABLE {0} (JsonString TEXT)", SPPID_DB_INFO_TABLE);

                        cmd.ExecuteNonQuery();

                    }

                    if (dt.Select(string.Format("NAME = '{0}'", SPPID_ETC_SETTING_TABLE)).Length == 0)

                    {

                        cmd.CommandText = string.Format("CREATE TABLE {0} (JsonString TEXT)", SPPID_ETC_SETTING_TABLE);

                        cmd.ExecuteNonQuery();

                    }

                    if (dt.Select(string.Format("NAME = '{0}'", SPPID_SYMBOL_MAPPING_TABLE)).Length == 0)

                    {

                        cmd.CommandText = string.Format("CREATE TABLE {0} (UID TEXT PRIMARY KEY, NAME TEXT, SPPID_SYMBOL_PATH TEXT, LEADERLINE BOOLEAN)", SPPID_SYMBOL_MAPPING_TABLE);

                        cmd.ExecuteNonQuery();

                    }

                    if (dt.Select(string.Format("NAME = '{0}'", SPPID_ATTRIBUTE_MAPPING_TABLE)).Length == 0)

                    {

                        cmd.CommandText = string.Format("CREATE TABLE {0} (UID TEXT PRIMARY KEY, SPPID_ATTRIBUTE TEXT)", SPPID_ATTRIBUTE_MAPPING_TABLE);

                        cmd.ExecuteNonQuery();

                    }

                    if (dt.Select(string.Format("NAME = '{0}'", SPPID_LABEL_INFO_TABLE)).Length == 0)

                    {

                        cmd.CommandText = string.Format("CREATE TABLE {0} (UID TEXT PRIMARY KEY, LOCATION INT DEFAULT 0, LEADERLINE BOOLEAN)", SPPID_LABEL_INFO_TABLE);

                        cmd.ExecuteNonQuery();

                    }

                }

                #region Check Column 업데이트시 예비용

                cmd.CommandText = string.Format("SELECT * FROM {0}", SPPID_SYMBOL_MAPPING_TABLE);

                using (SQLiteDataReader dr = cmd.ExecuteReader())

                using (DataTable dt = new DataTable())

                {

                    dt.Load(dr);

                    if (!dt.Columns.Contains("LEADERLINE"))

                    {

                        cmd.CommandText = string.Format("ALTER TABLE {0} ADD COLUMN LEADERLINE BOOLEAN", SPPID_SYMBOL_MAPPING_TABLE);

                        cmd.ExecuteNonQuery();

                    }

                }

                #endregion

            }

        }

        public static DataTable SelectProjectSymbol()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format(@"

                            SELECT s.UID, s.Name, st.Type, sp.SPPID_SYMBOL_PATH, sp.LEADERLINE FROM {1} as st, {0} as s 

                                LEFT OUTER JOIN {2} as sp 

                                    ON s.UID = SP.UID 

                            WHERE s.SymbolType_UID = st.UID 

                            ORDER BY st.TYPE ASC;", Symbol_TABLE, SymbolType_TABLE, SPPID_SYMBOL_MAPPING_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                        DataTable dtClone = dt.Clone();

                        dtClone.Columns["UID"].DataType = typeof(string);

                        foreach (DataRow row in dt.Rows)

                        {

                            dtClone.ImportRow(row);

                        }

                        dt.Dispose();

                        dt = dtClone;

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        public static DataTable SelectProjectChildSymbol()

        {

            DataTable result = new DataTable();

            result.Columns.Add("UID");

            result.Columns.Add("Name");

            result.Columns.Add("Type");

            result.Columns.Add("SPPID_SYMBOL_PATH");

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            using (DataTable dt = new DataTable())

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format(@"

                            SELECT AdditionalSymbol FROM Symbol");

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

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

                        foreach (DataRow row in dt.Rows)

                        {

                            if (!string.IsNullOrEmpty((string)row["AdditionalSymbol"]))

                            {

                                string[] array = row["AdditionalSymbol"].ToString().Split(new char[] { '/' });

                                foreach (var childString in array)

                                {

                                    childList.Add(childString.Split(new char[] { ',' })[2]);

                                }

                            }

                        }

                        dt.Clear();

                        cmd.Reset();

                        cmd.CommandText = string.Format(@"

                            SELECT * FROM {0}", SPPID_SYMBOL_MAPPING_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                        childList = childList.Distinct().ToList();

                        foreach (var child in childList)

                        {

                            string mappingPath = string.Empty;

                            DataRow[] rows = dt.Select(string.Format("UID = '{0}'", child));

                            if (rows.Length == 1)

                                mappingPath = !DBNull.Value.Equals(rows[0]["SPPID_SYMBOL_PATH"]) ? (string)rows[0]["SPPID_SYMBOL_PATH"] : null;

                            DataRow newRow = result.NewRow();

                            newRow["UID"] = child;

                            newRow["Name"] = child;

                            newRow["Type"] = "Child Symbol";

                            newRow["SPPID_SYMBOL_PATH"] = mappingPath;

                            result.Rows.Add(newRow);

                        }

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return result;

        }

        public static DataTable SelectProjectLine()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format(@"

                            SELECT l.UID, l.Name, sp.SPPID_SYMBOL_PATH FROM {0} as l 

                                LEFT OUTER JOIN {1} as sp 

                                    ON l.UID = SP.UID ;", LineTypes_TABLE, SPPID_SYMBOL_MAPPING_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        public static DataTable SelectProjectLineProperties()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format(@"

                            SELECT lp.UID, lp.DisplayName, sp.SPPID_SYMBOL_PATH, spa.SPPID_ATTRIBUTE

                            FROM {0} as lp 

                                 LEFT OUTER JOIN {1} as sp 

                                      ON lp.UID = sp.UID

                                 LEFT OUTER JOIN {2} as spa 

                                      ON lp.UID = spa.UID;", LineProperties_TABLE, SPPID_SYMBOL_MAPPING_TABLE, SPPID_ATTRIBUTE_MAPPING_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        public static DataTable SelectProjectAttribute()

        {

            DataTable dt = new DataTable();

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteCommand cmd = connection.CreateCommand())

                    {

                        cmd.CommandText = string.Format(@"

                            SELECT sa.UID, sa.DisplayAttribute, st.TYPE, spa.SPPID_ATTRIBUTE, sp.SPPID_SYMBOL_PATH, spl.LOCATION, spl.LEADERLINE 

                            FROM {1} as sa, {0} as st 

                                 LEFT OUTER JOIN {2} as sp 

                                      ON sa.UID = SP.UID 

                                LEFT OUTER JOIN {3} as spa 

                                     ON sa.UID = spa.UID

                                LEFT OUTER JOIN {4} as spl 

                                     ON sa.UID = spl.UID

                            WHERE sa.SymbolType_UID = st.UID;", SymbolType_TABLE, SymbolAttribute_TABLE, SPPID_SYMBOL_MAPPING_TABLE, SPPID_ATTRIBUTE_MAPPING_TABLE, SPPID_LABEL_INFO_TABLE);

                        using (SQLiteDataReader dr = cmd.ExecuteReader())

                            dt.Load(dr);

                    }

                    connection.Close();

                }

                catch (Exception ex)

                {

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return dt;

        }

        public static bool InsertSymbolMapping(List<Tuple<string, string, string, bool>> datas)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteTransaction transaction = connection.BeginTransaction())

                    {

                        try

                        {

                            using (SQLiteCommand cmd = connection.CreateCommand())

                            {

                                foreach (var item in datas)

                                {

                                    cmd.Parameters.Clear();

                                    cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (UID, NAME, SPPID_SYMBOL_PATH, LEADERLINE) VALUES (@UID, @NAME, @SPPID_SYMBOL_PATH, @LEADERLINE)", SPPID_SYMBOL_MAPPING_TABLE);

                                    cmd.Parameters.AddWithValue("@UID", item.Item1);

                                    cmd.Parameters.AddWithValue("@NAME", item.Item2);

                                    cmd.Parameters.AddWithValue("@SPPID_SYMBOL_PATH", item.Item3);

                                    cmd.Parameters.AddWithValue("@LEADERLINE", item.Item4);

                                    cmd.ExecuteNonQuery();

                                }

                            }

                            transaction.Commit();

                            connection.Close();

                        }

                        catch (Exception ex)

                        {

                            transaction.Rollback();

                        }

                        finally

                        {

                            transaction.Dispose();

                        }

                    }

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

        public static bool InsertAttributeMapping(List<Tuple<string, string>> datas)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteTransaction transaction = connection.BeginTransaction())

                    {

                        try

                        {

                            using (SQLiteCommand cmd = connection.CreateCommand())

                            {

                                foreach (var item in datas)

                                {

                                    cmd.Parameters.Clear();

                                    cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (UID, SPPID_ATTRIBUTE) VALUES (@UID, @SPPID_ATTRIBUTE)", SPPID_ATTRIBUTE_MAPPING_TABLE);

                                    cmd.Parameters.AddWithValue("@UID", item.Item1);

                                    cmd.Parameters.AddWithValue("@SPPID_ATTRIBUTE", item.Item2);

                                    cmd.ExecuteNonQuery();

                                }

                            }

                            transaction.Commit();

                            connection.Close();

                        }

                        catch (Exception ex)

                        {

                            transaction.Rollback();

                        }

                        finally

                        {

                            transaction.Dispose();

                        }

                    }

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

        public static bool InsertLabelInfoMapping(List<Tuple<string, int, bool>> datas)

        {

            Project_Info projectInfo = Project_Info.GetInstance();

            using (SQLiteConnection connection = new SQLiteConnection(string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", projectInfo.DBFilePath)))

            {

                try

                {

                    connection.Open();

                    using (SQLiteTransaction transaction = connection.BeginTransaction())

                    {

                        try

                        {

                            using (SQLiteCommand cmd = connection.CreateCommand())

                            {

                                foreach (var item in datas)

                                {

                                    cmd.Parameters.Clear();

                                    cmd.CommandText = string.Format("INSERT OR REPLACE INTO {0} (UID, LOCATION, LEADERLINE) VALUES (@UID, @LOCATION, @LEADERLINE)", SPPID_LABEL_INFO_TABLE);

                                    cmd.Parameters.AddWithValue("@UID", item.Item1);

                                    cmd.Parameters.AddWithValue("@LOCATION", item.Item2);

                                    cmd.Parameters.AddWithValue("@LEADERLINE", item.Item3);

                                    cmd.ExecuteNonQuery();

                                }

                            }

                            transaction.Commit();

                            connection.Close();

                        }

                        catch (Exception ex)

                        {

                            transaction.Rollback();

                        }

                        finally

                        {

                            transaction.Dispose();

                        }

                    }

                }

                catch (Exception ex)

                {

                    return false;

                }

                finally

                {

                    connection.Dispose();

                }

            }

            return true;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.IO;

namespace Converter.BaseModel

{

    public class Project_Info

    {

        private static Project_Info projectInfo;

        private string _DefaultPath;

        private string _Name;

        private bool _Enable;

        private string _DBFilePath;

        private string _TempDirPath;

        private string _ImageDirPath;

        private string _SvgImageDirPath;

        private string _SPPID_ImageDirPath;

        public string DefaultPath {

            get { return _DefaultPath; }

            set {

                _DefaultPath = value;

                _Name = Path.GetFileName(value);

                _DBFilePath = value + @"\db\ITI_PID.db";

                _TempDirPath = value + @"\Temp\";

                _ImageDirPath = value + @"\image\";

                _SvgImageDirPath = value + @"\svg\";

                _SPPID_ImageDirPath = value + @"\SPPID_Image";

                Directory.CreateDirectory(_SPPID_ImageDirPath);

            }

        }

        public string Name

        {

            get { return _Name; }

        }

        public string DBFilePath

        {

            get { return _DBFilePath; }

        }

        public string TempDirPath

        {

            get { return _TempDirPath; }

        }

        public string ImageDirPath

        {

            get { return _ImageDirPath; }

        }

        public string SvgImageDirPath

        {

            get { return _SvgImageDirPath; }

        }

        public string SPPID_ImageDirPath

        {

            get { return _SPPID_ImageDirPath; }

        }

        public bool Enable { get => _Enable; set => _Enable = value; }

        public static Project_Info GetInstance()

        {

            if (projectInfo == null)

                projectInfo = new Project_Info();

            return projectInfo;

        }

    }

}

            this.GroupLineNumber = new DevExpress.XtraLayout.LayoutControlGroup();

            this.layoutControlGroup8 = new DevExpress.XtraLayout.LayoutControlGroup();

            this.layoutControlItem13 = new DevExpress.XtraLayout.LayoutControlItem();

            this.layoutControlItem3 = new DevExpress.XtraLayout.LayoutControlItem();

            this.layoutControlItem18 = new DevExpress.XtraLayout.LayoutControlItem();

            ((System.ComponentModel.ISupportInitialize)(this.GroupLineNumber)).BeginInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlGroup8)).BeginInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlItem13)).BeginInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlItem3)).BeginInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlItem18)).BeginInit();

            // GroupLineNumber

            // 

            this.GroupLineNumber.Items.AddRange(new DevExpress.XtraLayout.BaseLayoutItem[] {

            this.layoutControlGroup8});

            this.GroupLineNumber.Location = new System.Drawing.Point(0, 0);

            this.GroupLineNumber.Name = "GroupLineNumber";

            this.GroupLineNumber.Size = new System.Drawing.Size(691, 632);

            this.GroupLineNumber.Text = "Line Number";

            // 

            // layoutControlGroup8

            // 

            this.layoutControlGroup8.Items.AddRange(new DevExpress.XtraLayout.BaseLayoutItem[] {

            this.layoutControlItem13,

            this.layoutControlItem3,

            this.layoutControlItem18});

            this.layoutControlGroup8.Location = new System.Drawing.Point(0, 0);

            this.layoutControlGroup8.Name = "layoutControlGroup8";

            this.layoutControlGroup8.Size = new System.Drawing.Size(691, 632);

            this.layoutControlGroup8.Text = "ID2 Line Number";

            // 

            // layoutControlItem13

            // 

            this.layoutControlItem13.Control = this.gridControlLineNumber;

            this.layoutControlItem13.Location = new System.Drawing.Point(0, 24);

            this.layoutControlItem13.Name = "layoutControlItem13";

            this.layoutControlItem13.Size = new System.Drawing.Size(667, 563);

            this.layoutControlItem13.TextSize = new System.Drawing.Size(0, 0);

            this.layoutControlItem13.TextVisible = false;

            // 

            // layoutControlItem3

            // 

            this.layoutControlItem3.Control = this.textBoxLineNumberPath;

            this.layoutControlItem3.Location = new System.Drawing.Point(0, 0);

            this.layoutControlItem3.Name = "layoutControlItem3";

            this.layoutControlItem3.Size = new System.Drawing.Size(410, 24);

            this.layoutControlItem3.Text = "SPPID Line Number Label Path";

            this.layoutControlItem3.TextAlignMode = DevExpress.XtraLayout.TextAlignModeItem.AutoSize;

            this.layoutControlItem3.TextSize = new System.Drawing.Size(167, 14);

            this.layoutControlItem3.TextToControlDistance = 5;

            // 

            // layoutControlItem18

            // 

            this.layoutControlItem18.Control = this.checkComboBoxLineNumberLocation;

            this.layoutControlItem18.Location = new System.Drawing.Point(410, 0);

            this.layoutControlItem18.Name = "layoutControlItem18";

            this.layoutControlItem18.Size = new System.Drawing.Size(257, 24);

            this.layoutControlItem18.Text = "Label Location";

            this.layoutControlItem18.TextAlignMode = DevExpress.XtraLayout.TextAlignModeItem.AutoSize;

            this.layoutControlItem18.TextSize = new System.Drawing.Size(78, 14);

            this.layoutControlItem18.TextToControlDistance = 5;

            // 

            ((System.ComponentModel.ISupportInitialize)(this.GroupLineNumber)).EndInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlGroup8)).EndInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlItem13)).EndInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlItem3)).EndInit();

            ((System.ComponentModel.ISupportInitialize)(this.layoutControlItem18)).EndInit();

            gridViewSymbol.Columns["LEADERLINE"].Caption = "Show Leader Line(If Label Symbol)";

            foreach (DataRow item in symbolDT.Rows)

            {

                if (DBNull.Value.Equals(item["LEADERLINE"]))

                    item["LEADERLINE"] = false;

            }

            List<Tuple<string, string, string, bool>> symbolDatas = new List<Tuple<string, string, string, bool>>();

                bool _LEADERLINE = (bool)row["LEADERLINE"];

                symbolDatas.Add(new Tuple<string, string, string, bool>(_uid, _name, _SPPIDSymbolPath, _LEADERLINE));

                symbolDatas.Add(new Tuple<string, string, string, bool>(_uid, _name, _SPPIDSymbolPath, false));

                symbolDatas.Add(new Tuple<string, string, string, bool>(_uid, _name, _SPPIDSymbolPath, false));

                symbolDatas.Add(new Tuple<string, string, string, bool>(_uid, _name, _SPPIDSymbolPath, false));

                Project_DB.InsertLabelInfoMapping(labelDatas) &&