HYTOS

    <Compile Include="Model\PlantItem\EndBreak.cs" />

    <Compile Include="Model\PlantItem\LineNumber.cs" />

    <Compile Include="Model\PlantItem\Other\APIDInfo.cs" />

    <Compile Include="Model\PlantItem\Other\LineRun.cs" />

    <Compile Include="Model\PlantItem\SpecBreak.cs" />

    <Compile Include="Model\PlantItem\TrimLine.cs" />

using System.Windows.Forms;

        private string _DWGNAME;

        private string _SIZE;

        private double _SIZE_WIDTH;

        private double _SIZE_HEIGHT;

        private string _UID;

        private List<Symbol> _SYMBOLS = new List<Symbol>();

        private List<Line> _LINES = new List<Line>();

        private List<LineNumber> _LINENUMBERS = new List<LineNumber>();

        private List<TrimLine> _TRIMLINES = new List<TrimLine>();

        private List<EndBreak> _EndBreaks = new List<EndBreak>();

        private List<SpecBreak> _SpecBreaks = new List<SpecBreak>();

        private List<Equipment> _Equipments = new List<Equipment>();

        private bool _Enable;

        private bool _Validation;

        private bool _MappingValidation;

        private string _ValidationMessage = string.Empty;

        bool validationResult = false;

        public string ValidationMessage { get => _ValidationMessage; set => _ValidationMessage = value; }

        public List<Symbol> SYMBOLS { get => _SYMBOLS; set => _SYMBOLS = value; }

        public List<Line> LINES { get => _LINES; set => _LINES = value; }

        public List<LineNumber> LINENUMBERS { get => _LINENUMBERS; set => _LINENUMBERS = value; }

        public List<EndBreak> EndBreaks { get => _EndBreaks; set => _EndBreaks = value; }

        public List<SpecBreak> SpecBreaks { get => _SpecBreaks; set => _SpecBreaks = value; }

        public List<Equipment> Equipments { get => _Equipments; set => _Equipments = value; }

        public string DWGNAME { get => _DWGNAME; set => _DWGNAME = value; }

        public string SIZE

        {

            get

            {

                return _SIZE;

            }

            set

            {

                _SIZE = value;

                string[] pointArr = _SIZE.Split(new char[] { ',' });

                if (pointArr.Length == 2)

                {

                    _SIZE_WIDTH = Convert.ToDouble(pointArr[0]);

                    _SIZE_HEIGHT = Convert.ToDouble(pointArr[1]);

                }

            }

        }

        public double SIZE_WIDTH { get => _SIZE_WIDTH; }

        public double SIZE_HEIGHT { get => _SIZE_HEIGHT; }

        public List<TrimLine> TRIMLINES { get => _TRIMLINES; set => _TRIMLINES = value; }

        public string PATH { get; set; }

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

        public bool Validation { get => _Validation; set => _Validation = value; }

        public bool MappingValidation { get => _MappingValidation; set => _MappingValidation = value; }

        public string UID { get => _UID; set => _UID = value; }

        StringBuilder validationStringBuilder = new StringBuilder();

        public List<PlantItem> PlantItems = new List<PlantItem>();

            validationStringBuilder.AppendLine("Document Path : " + xmlPath);

            validationStringBuilder.AppendLine("");

            try

            {

                if (xmlPath != null)

                {

                    PATH = xmlPath;

                    XElement xml = XElement.Load(xmlPath);

                    DWGNAME = xml.Element("DWGNAME").Value;

                    SIZE = xml.Element("SIZE").Value;

                    validationStringBuilder.AppendLine("Drawing Name : " + DWGNAME);

                    validationStringBuilder.AppendLine("");

                    SetSymbol(xml.Element("SYMBOLS"));

                    SetLine(xml.Element("LINEINFOS"));

                    SetLineNumber(xml.Element("LINENOS"));

                    SetTrimLine(xml.Element("TRIMLINENOS"));

                    SetAllConnectors();

                    Enable = true;

                }

            }

            catch (Exception ex)

            {

                Enable = false;

                MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);

        #region READ XML

                DataRow[] rows = ID2SymbolTypeDT.Select(string.Format("Type = '{0}'", sType.Replace("'", "''")));

                string sCategory = rows[0]["Category"].ToString();

                if (sType == "Segment Breaks")

                {

                    SpecBreak specBreak = new SpecBreak()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), specBreak.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), specBreak.CONNECTORS, specBreak.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), specBreak.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), specBreak.ATTRIBUTES);

                    SetSpecBreakAttribute(specBreak);

                    SpecBreaks.Add(specBreak);

                }

                else if (sType == "End Break")

                {

                    EndBreak endBreak = new EndBreak()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), endBreak.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), endBreak.CONNECTORS, endBreak.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), endBreak.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), endBreak.ATTRIBUTES);

                    EndBreaks.Add(endBreak);

                }

                else if (sCategory == "Equipment" ||

                    sCategory == "Equipment Components")

                {

                    Equipment equipment = new Equipment()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), equipment.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), equipment.CONNECTORS, equipment.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), equipment.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), equipment.ATTRIBUTES);

                    Equipments.Add(equipment);

                }

                else

                {

                    Symbol symbol = new Symbol()

                    {

                        UID = item.Element("UID").Value,

                        DBUID = item.Element("DBUID").Value,

                        NAME = item.Element("NAME").Value,

                        TYPE = item.Element("TYPE").Value,

                        OWNER = item.Element("OWNER").Value,

                        ORIGINALPOINT = item.Element("ORIGINALPOINT").Value,

                        CONNECTIONPOINT = item.Element("CONNECTIONPOINT").Value,

                        LOCATION = item.Element("LOCATION").Value,

                        SIZE = item.Element("SIZE").Value,

                        ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                        PARENT = item.Element("PARENT").Value,

                        CHILD = item.Element("CHILD").Value,

                        HASINSTRUMENTLABEL = item.Element("HASINSTRUMENTLABEL").Value,

                        AREA = item.Element("AREA").Value,

                        FLIP = Convert.ToInt32(item.Element("FLIP").Value),

                        CURRENTPOINTMODEINDEX = Convert.ToInt32(item.Element("CURRENTPOINTMODEINDEX").Value)

                    };

                    SetAssociations(item.Element("ASSOCIATIONS"), symbol.ASSOCIATIONS);

                    SetSymbolConnectors(item.Element("CONNECTORS"), symbol.CONNECTORS, symbol.CONNECTIONPOINT);

                    SetProperties(item.Element("PROPERTIES"), symbol.PROPERTIES);

                    SetAttributes(item.Element("SYMBOLATTRIBUTES"), symbol.ATTRIBUTES);

                    SetChildSymbol(symbol);

                    SYMBOLS.Add(symbol);

                }

            }

            PlantItems.AddRange(SpecBreaks);

            PlantItems.AddRange(EndBreaks);

            PlantItems.AddRange(Equipments);

            PlantItems.AddRange(SYMBOLS);

        }

        private void SetLine(XElement node)

        {

            foreach (XElement item in node.Elements("LINE"))

            {

                Line line = new Line()

                {

                    OWNER = item.Attribute("OWNER").Value,

                    UID = item.Element("UID").Value,

                    STARTPOINT = item.Element("STARTPOINT").Value,

                    ENDPOINT = item.Element("ENDPOINT").Value,

                    TYPE = item.Element("TYPE").Value,

                    TYPEUID = item.Element("TYPE").Attribute("TYPEUID").Value,

                    AREA = item.Element("AREA").Value,

                    THICKNESS = item.Element("THICKNESS").Value,

                };

                int flowMarkPercent = 0;

                if (int.TryParse(item.Element("FLOWMARK").Value, out flowMarkPercent))

                {

                    line.FLOWMARK = true;

                    line.FLOWMARK_PERCENT = flowMarkPercent;

                }

                else

                    line.FLOWMARK = false;

                SetAssociations(item.Element("ASSOCIATIONS"), line.ASSOCIATIONS);

                SetConnectors(item.Element("CONNECTORS"), line.CONNECTORS);

                SetAttributes(item.Element("SYMBOLATTRIBUTES"), line.ATTRIBUTES);

                LINES.Add(line);

            }

            PlantItems.AddRange(LINES);

        }

        private void SetLineNumber(XElement node)

        {

            foreach (XElement item in node.Elements("LINE_NO"))

            {

                LineNumber lineNumber = new LineNumber()

                {

                    UID = item.Element("UID").Value,

                    TEXT = item.Element("TEXT").Value,

                    LOCATION = item.Element("LOCATION").Value,

                    WIDTH = item.Element("WIDTH").Value,

                    HEIGHT = item.Element("HEIGHT").Value,

                    ANGLE = Convert.ToDouble(item.Element("ANGLE").Value),

                    AREA = item.Element("AREA").Value,

                    SCENE = item.Element("SCENE").Value

                };

                if (item.Element("CONNLINE") != null)

                    lineNumber.CONNLINE = item.Element("CONNLINE").Value;

                else

                {

                    validationStringBuilder.AppendLine("Not exist CONNLINE!" + "\r\nLineNumber UID : " + lineNumber.UID);

                    validationStringBuilder.AppendLine();

                    validationResult = true;

                }

                SetLineNumberRuns(item, lineNumber.RUNS);

                SetProperties(item.Element("PROPERTIES"), lineNumber.PROPERTIES);

                SetAttributes(item, lineNumber.ATTRIBUTES);

                LINENUMBERS.Add(lineNumber);

            }

            PlantItems.AddRange(LINENUMBERS);

        }

        private void SetTrimLine(XElement node)

        {

            foreach (XElement item in node.Elements("TRIM_LINE_NO"))

            {

                TrimLine trimLine = new TrimLine()

                {

                    UID = item.Element("UID").Value,

                };

                SetLineNumberRuns(item, trimLine.RUNS);

                TRIMLINES.Add(trimLine);

            }

            PlantItems.AddRange(TRIMLINES);

        }

        private void SetAssociations(XElement node, List<Association> associations)

        {

            foreach (XElement item in node.Elements("ASSOCIATION"))

            {

                Association association = new Association()

                {

                    TYPE = item.Attribute("TYPE").Value,

                    VALUE = item.Value

                };

                associations.Add(association);

            }

        }

        private void SetConnectors(XElement node, List<Connector> connectors)

        {

            foreach (XElement item in node.Elements("CONNECTOR"))

            {

                connectors.Add(new Connector()

                {

                    UID = item.Attribute("UID").Value,

                    CONNECTED_AT = Convert.ToInt32(item.Attribute("CONNECTED_AT").Value),

                    CONNECTEDITEM = item.Element("CONNECTEDITEM").Value,

                    CONNECTPOINT = item.Element("CONNECTPOINT").Value,

                    SCENECONNECTPOINT = item.Element("SCENECONNECTPOINT").Value,

                });

            }

        }

        private void SetSymbolConnectors(XElement node, List<Connector> connectors, string CONNECTIONPOINT)

        {

            foreach (XElement item in node.Elements("CONNECTOR"))

            {

                connectors.Add(new Connector()

                {

                    UID = item.Attribute("UID").Value,

                    CONNECTED_AT = Convert.ToInt32(item.Attribute("CONNECTED_AT").Value),

                    CONNECTEDITEM = item.Element("CONNECTEDITEM").Value,

                    CONNECTPOINT = item.Element("CONNECTPOINT").Value,

                    SCENECONNECTPOINT = item.Element("SCENECONNECTPOINT").Value,

                });

            }

        }

        private void SetProperties(XElement node, List<Property> properties)

        {

            foreach (XElement item in node.Elements("PROPERTY"))

            {

                properties.Add(new Property()

                {

                    UID = item.Attribute("UID").Value,

                    LENGTH = item.Attribute("Length").Value,

                    EXPRESSION = item.Attribute("Expression").Value,

                    DISPLAYATTRIBUTE = item.Attribute("DisplayAttribute").Value,

                    ATTRIBUTETYPE = item.Attribute("AttributeType").Value,

                    ATTRIBUTE = item.Attribute("Attribute").Value,

                    VALUE = item.Value

                });

            }

        }

        private void SetAttributes(XElement node, List<Attribute> attributes)

        {

            foreach (XElement item in node.Elements("ATTRIBUTE"))

            {

                Attribute attribute = new Attribute()

                {

                    UID = item.Attribute("UID").Value,

                    LENGTH = item.Attribute("Length").Value,

                    EXPRESSION = item.Attribute("Expression").Value,

                    DISPLAYATTRIBUTE = item.Attribute("DisplayAttribute").Value,

                    ATTRIBUTETYPE = item.Attribute("AttributeType").Value,

                    ATTRIBUTE = item.Attribute("Attribute").Value,

                    ATTRAT = item.Attribute("AttrAt").Value,

                    ASSOCITEM = item.Attribute("AssocItem").Value,

                    VALUE = item.Value

                };

                attributes.Add(attribute);

            }

        }

        private void SetSpecBreakAttribute(SpecBreak specBreak)

        {

            string upStream = specBreak.ATTRIBUTES.Find(x => x.ATTRIBUTE == "UpStream").VALUE;

            string downStream = specBreak.ATTRIBUTES.Find(x => x.ATTRIBUTE == "DownStream").VALUE;

            specBreak.UpStreamUID = upStream;

            specBreak.DownStreamUID = downStream;

        }

        private void SetLineNumberRuns(XElement node, List<LineRun> lineNumberRuns)

        {

            foreach (XElement item in node.Elements("RUN"))

            {

                LineRun run = new LineRun()

                {

                    TYPE = item.Attribute("TYPE").Value

                };

                foreach (XElement element in item.Elements())

                {

                    if (element.Name == "SYMBOL")

                    {

                        Symbol symbol = GetSymbolByUID(element.Element("UID").Value);

                        Equipment equipment = GetEquipmentByUID(element.Element("UID").Value);

                        if (symbol == null && equipment == null)

                        {

                            validationStringBuilder.AppendLine("Missing Item!" + "\r\nUID : " + element.Element("UID").Value);

                            validationStringBuilder.AppendLine();

                            validationResult = true;

                        }

                        if (symbol != null)

                            run.RUNITEMS.Add(symbol);

                        else if (equipment != null)

                            run.RUNITEMS.Add(equipment);

                    }

                    else if (element.Name == "LINE")

                    {

                        Line line = GetLineByUID(element.Element("UID").Value);

                        if (line == null)

                        {

                            validationStringBuilder.AppendLine("Missing Item!" + "\r\nUID : " + element.Element("UID").Value);

                            validationStringBuilder.AppendLine();

                            validationResult = true;

                        }

                        run.RUNITEMS.Add(line);

                    }

                }

                lineNumberRuns.Add(run);

            }

        }

        private void SetChildSymbol(Symbol symbol)

        {

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

            if (!string.IsNullOrEmpty(symbol.CHILD) && symbol.CHILD != "None")

            {

                string[] childArray = symbol.CHILD.Split(new char[] { '/' });

                foreach (string sChild in childArray)

                {

                    string[] sChildInfo = sChild.Split(new char[] { ',' });

                    childList.Add(new ChildSymbol()

                    {

                        ParentAt = Convert.ToInt32(sChildInfo[0]),

                        Direction = sChildInfo[1],

                        NAME = sChildInfo[2]

                    });

                }

                foreach (ChildSymbol child in childList)

                {

                    if (child.ParentAt == 0)

                        symbol.ChildSymbols.Add(child);

                    else

                        childList[child.ParentAt - 1].ChildSymbols.Add(child);

                }

            }

            if (!string.IsNullOrEmpty(symbol.CONNECTIONPOINT) && symbol.CONNECTIONPOINT != "None")

            {

                // 현재 부모 Symbol에 자식 Connector까지 들어가 있음

                string[] connectionArray = symbol.CONNECTIONPOINT.Split(new char[] { '/' });

                string[] array = symbol.CONNECTIONPOINT.Split(new char[] { '/' });

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

                {

                    string[] arrConn = array[i].Split(new char[] { ',' });

                    int connIndex = Convert.ToInt32(arrConn[3]);

                    if (connIndex != 0)

                    {

                        childList[connIndex - 1].Connectors.Add(symbol.CONNECTORS[i]);

                        symbol.CONNECTORS[i].Index = connIndex;

                    }

                }

        #endregion

        public void SetAllConnectors()

        {

            foreach (var item in SYMBOLS)

                foreach (var connector in item.CONNECTORS)

                    connector.ConnectedObject = APIDUtils.FindObjectByUID(this, connector.CONNECTEDITEM);

            foreach (var item in LINES)

                foreach (var connector in item.CONNECTORS)

                    connector.ConnectedObject = APIDUtils.FindObjectByUID(this, connector.CONNECTEDITEM);

            foreach (var item in Equipments)

                foreach (var connector in item.CONNECTORS)

                    connector.ConnectedObject = APIDUtils.FindObjectByUID(this, connector.CONNECTEDITEM);

        }

        public Symbol GetSymbolByUID(string uid)

        {

            return SYMBOLS.Find(x => x.UID == uid);

        }

        public Equipment GetEquipmentByUID(string uid)

        {

            return Equipments.Find(x => x.UID == uid);

        }

        public Line GetLineByUID(string uid)

        {

            return LINES.Find(x => x.UID == uid);

        }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AVEVA.PID.CustomizationUtility.Model

{

    public class EndBreak : Symbol

    {

    }

}

    public class Equipment : Symbol

    public enum SlopeType

    {

        None,

        Slope,

        HORIZONTAL,

        VERTICAL

    }

        private string _OWNER;

        private string _UID;

        private string _TYPEUID;

        private string _STARTPOINT;

        private string _ENDPOINT;

        private string _TYPE;

        private string _AREA;

        private string _THICKNESS;

        private bool _FLOWMARK;

        private int _FLOWMARK_PERCENT;

        public SlopeType SlopeType { get; set; }

        private List<Connector> _CONNECTORS = new List<Connector>();

        private List<Association> _ASSOCIATIONS = new List<Association>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        public string OWNER { get => _OWNER; set => _OWNER = value; }

        public string UID { get => _UID; set => _UID = value; }

        public string STARTPOINT { get => _STARTPOINT; set => _STARTPOINT = value; }

        public string ENDPOINT { get => _ENDPOINT; set => _ENDPOINT = value; }

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public string THICKNESS { get => _THICKNESS; set => _THICKNESS = value; }

        public List<Connector> CONNECTORS { get => _CONNECTORS; set => _CONNECTORS = value; }

        public string TYPEUID { get => _TYPEUID; set => _TYPEUID = value; }

        public bool FLOWMARK { get => _FLOWMARK; set => _FLOWMARK = value; }

        public int FLOWMARK_PERCENT { get => _FLOWMARK_PERCENT; set => _FLOWMARK_PERCENT = value; }

        public List<Association> ASSOCIATIONS { get => _ASSOCIATIONS; set => _ASSOCIATIONS = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AVEVA.PID.CustomizationUtility.Model

{

    public class LineNumber : PlantItem

    {

        private string _TEXT;

        private string _LOCATION;

        private string _WIDTH;

        private string _HEIGHT;

        private double _ANGLE;

        private string _AREA;

        private string _CONNLINE;

        private string _SCENE;

        private List<LineRun> _RUNS = new List<LineRun>();

        private List<Property> _PROPERTIES = new List<Property>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        public string TEXT { get => _TEXT; set => _TEXT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public string HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public double ANGLE

        {

            get

            {

                return _ANGLE;

            }

            set

            {

                double gap = 0.05;

                if (value < gap)

                    value = 0;

                else if (1.57 - gap < value && value < 1.57 + gap)

                    value = 90 * Math.PI / 180;

                else if (3.14 - gap < value && value < 3.14 + gap)

                    value = Math.PI;

                else if (4.71 - gap < value && value < 4.71 + gap)

                    value = 270 * Math.PI / 180;

                _ANGLE = value;

            }

        }

        public string AREA { get => _AREA; set => _AREA = value; }

        public List<LineRun> RUNS { get => _RUNS; set => _RUNS = value; }

        public List<Property> PROPERTIES { get => _PROPERTIES; set => _PROPERTIES = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

        public string CONNLINE { get => _CONNLINE; set => _CONNLINE = value; }

        public string SCENE

        {

            get

            {

                return _SCENE;

            }

            set

            {

                string[] split = value.Split(',');

                X1 = Convert.ToDouble(split[0]);

                Y1 = Convert.ToDouble(split[1]);

                X2 = X1 + Convert.ToDouble(split[2]);

                Y2 = Y1 + Convert.ToDouble(split[3]);

            }

        }

        public double X1 { get; set; }

        public double X2 { get; set; }

        public double Y1 { get; set; }

        public double Y2 { get; set; }

    }

}

        private string _TYPE;

        private string _VALUE;

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

        private string _UID;

        private string _LENGTH;

        private string _EXPRESSION;

        private string _DISPLAYATTRIBUTE;

        private string _ATTRIBUTETYPE;

        private string _ATTRIBUTE;

        private string _VALUE;

        private string _ATTRAT;

        private string _ASSOCITEM;

        public string UID { get => _UID; set => _UID = value; }

        public string LENGTH { get => _LENGTH; set => _LENGTH = value; }

        public string EXPRESSION { get => _EXPRESSION; set => _EXPRESSION = value; }

        public string DISPLAYATTRIBUTE { get => _DISPLAYATTRIBUTE; set => _DISPLAYATTRIBUTE = value; }

        public string ATTRIBUTETYPE { get => _ATTRIBUTETYPE; set => _ATTRIBUTETYPE = value; }

        public string ATTRIBUTE { get => _ATTRIBUTE; set => _ATTRIBUTE = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

        public string ATTRAT { get => _ATTRAT; set => _ATTRAT = value; }

        public string ASSOCITEM { get => _ASSOCITEM; set => _ASSOCITEM = value; }

        private int _ParentAt;

        private string _Direction;

        private string _NAME;

        private List<ChildSymbol> _ChildSymbols = new List<ChildSymbol>();

        private List<Connector> _Connectors = new List<Connector>();

        public string NAME { get => _NAME; set => _NAME = value; }

        public List<ChildSymbol> ChildSymbols { get => _ChildSymbols; set => _ChildSymbols = value; }

        public int ParentAt { get => _ParentAt; set => _ParentAt = value; }

        public string Direction { get => _Direction; set => _Direction = value; }

        public List<Connector> Connectors { get => _Connectors; set => _Connectors = value; }

        private string _UID;

        private int _CONNECTED_AT;

        private string _CONNECTEDITEM;

        private string _CONNECTPOINT;

        private string _SCENECONNECTPOINT;

        private object _ConnectedObject;

        public string UID { get => _UID; set => _UID = value; }

        public int CONNECTED_AT { get => _CONNECTED_AT; set => _CONNECTED_AT = value; }

        public string CONNECTEDITEM { get => _CONNECTEDITEM; set => _CONNECTEDITEM = value; }

        public string CONNECTPOINT { get => _CONNECTPOINT; set => _CONNECTPOINT = value; }

        public string SCENECONNECTPOINT { get => _SCENECONNECTPOINT; set => _SCENECONNECTPOINT = value; }

        public int Index { get; set; }

        public object ConnectedObject { get => _ConnectedObject; set => _ConnectedObject = value; }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AVEVA.PID.CustomizationUtility.Model

{

    public class LineRun

    {

        private string _TYPE;

        private List<object> _RUNITEMS = new List<object>();

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public List<object> RUNITEMS { get => _RUNITEMS; set => _RUNITEMS = value; }

    }

}

        private string _UID;

        private string _LENGTH;

        private string _EXPRESSION;

        private string _DISPLAYATTRIBUTE;

        private string _ATTRIBUTETYPE;

        private string _ATTRIBUTE;

        private string _VALUE;

        public string UID { get => _UID; set => _UID = value; }

        public string LENGTH { get => _LENGTH; set => _LENGTH = value; }

        public string EXPRESSION { get => _EXPRESSION; set => _EXPRESSION = value; }

        public string DISPLAYATTRIBUTE { get => _DISPLAYATTRIBUTE; set => _DISPLAYATTRIBUTE = value; }

        public string ATTRIBUTETYPE { get => _ATTRIBUTETYPE; set => _ATTRIBUTETYPE = value; }

        public string ATTRIBUTE { get => _ATTRIBUTE; set => _ATTRIBUTE = value; }

        public string VALUE { get => _VALUE; set => _VALUE = value; }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AVEVA.PID.CustomizationUtility.Model

{

    public class SpecBreak : Symbol

    {

        public string UpStreamUID { get; set; }

        public string DownStreamUID { get; set; }

    }

}

        private string _DBUID;

        private string _NAME;

        private List<Association> _ASSOCIATIONS = new List<Association>();

        private string _TYPE;

        private string _OWNER;

        private string _ORIGINALPOINT;

        private List<Connector> _CONNECTOR = new List<Connector>();

        private string _CONNECTIONPOINT;

        private string _LOCATION;

        private string _SIZE;

        private double _ANGLE;

        private string _PARENT;

        private string _CHILD;

        private string _HASINSTRUMENTLABEL;

        private string _AREA;

        private int _FLIP;

        private List<Property> _PROPERTIES = new List<Property>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        private int _CURRENTPOINTMODEINDEX;

        private List<ChildSymbol> _ChildSymbols = new List<ChildSymbol>();

        public string NAME { get => _NAME; set => _NAME = value; }

        public List<Association> ASSOCIATIONS { get => _ASSOCIATIONS; set => _ASSOCIATIONS = value; }

        public string TYPE { get => _TYPE; set => _TYPE = value; }

        public string OWNER { get => _OWNER; set => _OWNER = value; }

        public string ORIGINALPOINT { get => _ORIGINALPOINT; set => _ORIGINALPOINT = value; }

        public List<Connector> CONNECTORS { get => _CONNECTOR; set => _CONNECTOR = value; }

        public string CONNECTIONPOINT { get => _CONNECTIONPOINT; set => _CONNECTIONPOINT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string SIZE { get => _SIZE; set => _SIZE = value; }

        public double ANGLE

        {

            get

            {

                return _ANGLE;

            }

            set

            {

                double gap = 0.05;

                if (value < gap)

                    value = 0;

                else if (1.57 - gap < value && value < 1.57 + gap)

                    value = 90 * Math.PI / 180;

                else if (3.14 - gap < value && value < 3.14 + gap)

                    value = Math.PI;

                else if (4.71 - gap < value && value < 4.71 + gap)

                    value = 270 * Math.PI / 180;

                _ANGLE = value;

            }

        }

        public string PARENT { get => _PARENT; set => _PARENT = value; }

        public string CHILD { get => _CHILD; set => _CHILD = value; }

        public string HASINSTRUMENTLABEL { get => _HASINSTRUMENTLABEL; set => _HASINSTRUMENTLABEL = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public int FLIP { get => _FLIP; set => _FLIP = value; }

        public List<Property> PROPERTIES { get => _PROPERTIES; set => _PROPERTIES = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

        public int CURRENTPOINTMODEINDEX { get => _CURRENTPOINTMODEINDEX; set => _CURRENTPOINTMODEINDEX = value; }

        public List<ChildSymbol> ChildSymbols { get => _ChildSymbols; set => _ChildSymbols = value; }

        public string DBUID { get => _DBUID; set => _DBUID = value; }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AVEVA.PID.CustomizationUtility.Model

{

    public class TrimLine : PlantItem

    {

        private string _TEXT;

        private string _LOCATION;

        private string _WIDTH;

        private string _HEIGHT;

        private double _ANGLE;

        private string _AREA;

        private List<LineRun> _RUNS = new List<LineRun>();

        private List<Property> _PROPERTIES = new List<Property>();

        private List<Attribute> _ATTRIBUTES = new List<Attribute>();

        public string TEXT { get => _TEXT; set => _TEXT = value; }

        public string LOCATION { get => _LOCATION; set => _LOCATION = value; }

        public string WIDTH { get => _WIDTH; set => _WIDTH = value; }

        public string HEIGHT { get => _HEIGHT; set => _HEIGHT = value; }

        public double ANGLE { get => _ANGLE; set => _ANGLE = value; }

        public string AREA { get => _AREA; set => _AREA = value; }

        public List<LineRun> RUNS { get => _RUNS; set => _RUNS = value; }

        public List<Property> PROPERTIES { get => _PROPERTIES; set => _PROPERTIES = value; }

        public List<Attribute> ATTRIBUTES { get => _ATTRIBUTES; set => _ATTRIBUTES = value; }

    }

}

using AVEVA.PID.CustomizationUtility.DB;

using AVEVA.PID.CustomizationUtility.Model;

using AVEVA.PID.CustomizationUtility.Properties;

        public static object FindObjectByUID(Document document, string UID)

        {

            if (!string.IsNullOrEmpty(UID) && UID != "None")

            {

                foreach (PlantItem item in document.PlantItems)

                {

                    if (item.UID == UID)

                        return item;

                }

            }

            return null;

        }