HYTOS

using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

using System.Threading.Tasks;

using System.Xml.Linq;

using System.IO;

using System.Data;

using System.Windows.Forms;

namespace AVEVA.PID.CustomizationUtility.Model

{

    public class Document

    {

        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 List<Text> _Texts = new List<Text>();

        private List<Note> _Notes = new List<Note>();

        private List<OPC> _OPCs = new List<OPC>();

        private bool _Enable;

        private bool _Validation;

        private bool _MappingValidation;

        private string _ValidationMessage = string.Empty;

        bool validationResult = false;

        private DataTable ID2SymbolTypeDT;

        public string AvevaDrawingNumber { get; set; }

        public string AvevaSheetNumber { get; set; }

        public string AvevaTemplateID { get; set; }

        public string AvevaTemplateName { get; set; }

        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; }

        public List<OPC> OPCs { get => _OPCs; set => _OPCs = value; }

        public List<Text> Texts { get => _Texts; set => _Texts = value; }

        public List<Note> Notes { get => _Notes; set => _Notes = value; }

        StringBuilder validationStringBuilder = new StringBuilder();

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

        public Document(string xmlPath, DataTable ID2SymbolTypeDT)

        {

            this.ID2SymbolTypeDT = ID2SymbolTypeDT;

            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("");

                    SetText(xml.Element("TEXTINFOS"));

                    SetNote(xml.Element("NOTES"));

                    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

        private void SetSymbol(XElement node)

        {

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

            {

                string sType = item.Element("TYPE").Value;

                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 if (sType == "Piping OPC's" || sType == "Instrument OPC's")

                {

                    OPC opc = new OPC()

                    {

                        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"), opc.ASSOCIATIONS);

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

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

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

                    SetChildSymbol(opc);

                    if (sType == "Piping OPC's")

                        opc.OPCType = OPCType.Pipe;

                    else if (sType == "Instrument OPC's")

                        opc.OPCType = OPCType.Signal;

                    OPCs.Add(opc);

                }

                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);

            PlantItems.AddRange(OPCs);

        }

        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);

                line.SetSlopeType();

                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);

                if (!string.IsNullOrEmpty(attribute.ASSOCITEM) && attribute.ASSOCITEM != "None")

                {

                    Text text = Texts.Find(x => x.UID == attribute.ASSOCITEM);

                    if (text != null)

                        text.ASSOCIATION = true;

                }

            }

        }

        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;

                    }

                }

            }

        }

        private void SetText(XElement node)

        {

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

            {

                Text text = new Text()

                {

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

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

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

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

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

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

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

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

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

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

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

                };

                Texts.Add(text);

            }

        }

        private void SetNote(XElement node)

        {

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

            {

                Note note = new Note()

                {

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

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

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

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

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

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

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

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

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

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

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

                };

                Notes.Add(note);

            }

        }

        #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 OPCs)

                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);

        }

        #region For Aveva

        public bool SetAvevaInfo(DataTable symbolMappingTable, DataTable lineMappingTable, DataTable opcMappingTable)

        {

            bool result = true;

            foreach (var item in LINES)

            {

                DataRow[] rows = lineMappingTable.Select(string.Format("UID = '{0}'", item.TYPEUID));

                if (rows.Length == 1 && !DBNull.Value.Equals(rows[0]["APID_SYMBOL"]) && !string.IsNullOrEmpty((string)rows[0]["APID_SYMBOL"]))

                {

                    item.Aveva = new AvevaLineInfo();

                    item.Aveva.Name = (string)rows[0]["APID_SYMBOL"];

                    double startX = item.Start_X;

                    double startY = SIZE_HEIGHT - item.Start_Y;

                    double endX = item.End_X;

                    double endY = SIZE_HEIGHT - item.End_Y;

                    ConvertAvevaPoint(ref startX, ref startY);

                    ConvertAvevaPoint(ref endX, ref endY);

                    item.Aveva.Start_X = startX;

                    item.Aveva.Start_Y = startY;

                    item.Aveva.End_X = endX;

                    item.Aveva.End_Y = endY;

                    if (item.SlopeType == SlopeType.HORIZONTAL)

                        item.Aveva.End_Y = item.Aveva.Start_Y;

                    else if (item.SlopeType == SlopeType.VERTICAL)

                        item.Aveva.End_X = item.Aveva.Start_X;

                    if (!DBNull.Value.Equals(rows[0]["DATA1"]))

                    {

                        if (rows[0]["DATA1"].ToString() == "PIPE")

                            item.Aveva.Type = Type.Pipe;

                        else if (rows[0]["DATA1"].ToString() == "SIGNAL")

                            item.Aveva.Type = Type.Signal;

                    }

                    item.Aveva.Start_X = Math.Round(item.Aveva.Start_X);

                    item.Aveva.Start_Y = Math.Round(item.Aveva.Start_Y);

                    item.Aveva.End_X = Math.Round(item.Aveva.End_X);

                    item.Aveva.End_Y = Math.Round(item.Aveva.End_Y);

                }

                else

                    result = false;

            }

            foreach (var item in SYMBOLS)

            {

                DataRow[] rows = symbolMappingTable.Select(string.Format("UID = '{0}'", item.DBUID));

                if (rows.Length == 1 && !DBNull.Value.Equals(rows[0]["APID_SYMBOL"]) && !string.IsNullOrEmpty((string)rows[0]["APID_SYMBOL"]))

                {

                    item.Aveva = new AvevaSymbolInfo();

                    double x = item.X;

                    double y = SIZE_HEIGHT - item.Y;

                    ConvertAvevaPoint(ref x, ref y);

                    item.Aveva.X = Math.Round(x);

                    item.Aveva.Y = Math.Round(y);

                    item.Aveva.FullName = (string)rows[0]["APID_SYMBOL"];

                    string[] split = item.Aveva.FullName.Split(new char[] { '\\' });

                    item.Aveva.Name = split[split.Length - 1];

                }

                else

                    result = false;

            }

            foreach (var item in OPCs)

            {

                DataRow[] rows = opcMappingTable.Select(string.Format("UID = '{0}'", item.DBUID));

                if (rows.Length == 1 && !DBNull.Value.Equals(rows[0]["IN_SYMBOL"]) && !string.IsNullOrEmpty((string)rows[0]["OUT_SYMBOL"]))

                {

                    item.Aveva = new AvevaSymbolInfo();

                    double x = item.X;

                    double y = SIZE_HEIGHT - item.Y;

                    ConvertAvevaPoint(ref x, ref y);

                    item.Aveva.X = Math.Round(x);

                    item.Aveva.Y = Math.Round(y);

                    if (item.TYPE == "Piping OPC's")

                        item.OPCType = OPCType.Pipe;

                    else if (item.TYPE == "Instrument OPC's")

                        item.OPCType = OPCType.Signal;

                    Connector connector = item.CONNECTORS.Find(loop =>

                    APIDUtils.FindObjectByUID(this, loop.CONNECTEDITEM) != null &&

                    APIDUtils.FindObjectByUID(this, loop.CONNECTEDITEM).GetType() == typeof(Line));

                    if (connector != null)

                    {

                        // out

                        if (item.CONNECTORS.IndexOf(connector) == 0)

                        {

                            item.Aveva.FullName = (string)rows[0]["OUT_SYMBOL"];

                            string[] split = item.Aveva.FullName.Split(new char[] { '\\' });

                            item.Aveva.Name = split[split.Length - 1];

                            item.FlowType = FlowType.Out;

                        }

                        // in

                        else

                        {

                            item.Aveva.FullName = (string)rows[0]["IN_SYMBOL"];

                            string[] split = item.Aveva.FullName.Split(new char[] { '\\' });

                            item.Aveva.Name = split[split.Length - 1];

                            item.FlowType = FlowType.In;

                        }

                    }

                    else

                        result = false;

                }

                else

                    result = false;

            }

            foreach (var item in LINENUMBERS)

            {

                item.Aveva = new AvevaLabelInfo();

                double x = (item.X1 + item.X2) / 2;

                double y = SIZE_HEIGHT - (item.Y1 + item.Y2) / 2;

                ConvertAvevaPoint(ref x, ref y);

                item.Aveva.X = Math.Round(x);

                item.Aveva.Y = Math.Round(y);

                item.Aveva.LabelType = LabelType.LineNumber;

                item.Aveva.Angle = RadianToDegree(item.ANGLE);

            }

            foreach (var item in Texts)

            {

                item.Aveva = new AvevaLabelInfo();

                double x = item.X1;

                double y = SIZE_HEIGHT - item.Y2;

                ConvertAvevaPoint(ref x, ref y);

                item.Aveva.X = Math.Round(x);

                item.Aveva.Y = Math.Round(y);

                if (item.TextAngle == TextAngle.Degree0 || item.TextAngle == TextAngle.Degree180)

                {

                    double height = Math.Abs(item.Y1 - item.Y2);

                    ConvertAvevaPointY(ref height);

                    item.Aveva.Height = height;

                }

                else if (item.TextAngle == TextAngle.Degree90 || item.TextAngle == TextAngle.Degree270)

                {

                    double height = Math.Abs(item.X1 - item.X2);

                    ConvertAvevaPointX(ref height);

                    item.Aveva.Height = height;

                }

                if (item.VALUE.Contains("\n"))

                {

                    item.Aveva.LabelType = LabelType.MultiText;

                    int count = item.VALUE.Length - item.VALUE.Replace("\n", "").Length + 1;

                    item.Aveva.Height = item.Aveva.Height / count;

                }

                else

                    item.Aveva.LabelType = LabelType.SingleText;

                item.Aveva.Angle = item.ANGLE;

            }

            foreach (var item in Notes)

            {

                item.Aveva = new AvevaLabelInfo();

                double x = item.X1;

                double y = SIZE_HEIGHT - item.Y2;

                ConvertAvevaPoint(ref x, ref y);

                item.Aveva.X = Math.Round(x);

                item.Aveva.Y = Math.Round(y);

                if (item.TextAngle == TextAngle.Degree0 || item.TextAngle == TextAngle.Degree180)

                {

                    double height = Math.Abs(item.Y1 - item.Y2);

                    ConvertAvevaPointY(ref height);

                    item.Aveva.Height = height;

                }

                else if (item.TextAngle == TextAngle.Degree90 || item.TextAngle == TextAngle.Degree270)

                {

                    double height = Math.Abs(item.X1 - item.X2);

                    ConvertAvevaPointX(ref height);

                    item.Aveva.Height = height;

                }

                if (item.VALUE.Contains(@"\n"))

                {

                    item.Aveva.LabelType = LabelType.MultiNote;

                    int count = item.VALUE.Length - item.VALUE.Replace("\n", "").Length + 1;

                    item.Aveva.Height = item.Aveva.Height / count;

                }

                else

                    item.Aveva.LabelType = LabelType.SingleNote;

                item.Aveva.Angle = item.ANGLE;

            }

            return result;

        }

        public void ConvertAvevaPoint(ref double x, ref double y)

        {

            decimal drawingSizeWidth = Convert.ToDecimal(Properties.Settings.Default.DrawingX);

            decimal drawingSizeHeight = Convert.ToDecimal(Properties.Settings.Default.DrawingY);

            decimal id2Width = Convert.ToDecimal(SIZE_WIDTH);

            decimal id2Height = Convert.ToDecimal(SIZE_HEIGHT);

            x = Convert.ToDouble(drawingSizeWidth / id2Width * Convert.ToDecimal(x));

            y = Convert.ToDouble(drawingSizeHeight / id2Height * Convert.ToDecimal(y));

        }

        public void ConvertAvevaPointX(ref double x)

        {

            decimal drawingSizeWidth = Convert.ToDecimal(Properties.Settings.Default.DrawingX);

            decimal id2Width = Convert.ToDecimal(SIZE_WIDTH);

            x = Convert.ToDouble(drawingSizeWidth / id2Width * Convert.ToDecimal(x));

        }

        public void ConvertAvevaPointY(ref double y)

        {

            decimal drawingSizeHeight = Convert.ToDecimal(Properties.Settings.Default.DrawingY);

            decimal id2Height = Convert.ToDecimal(SIZE_HEIGHT);

            y = Convert.ToDouble(drawingSizeHeight / id2Height * Convert.ToDecimal(y));

        }

        private double RadianToDegree(double angle)

        {

            return angle * (180.0 / Math.PI);

        }

        #endregion

    }

}