HYTOS

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading.Tasks;

using Llama;

using Plaice;

namespace SPPIDAutoModeling

{

    public enum SPPID_ITEM_TYPE

    {

        SYMBOL = 1,

        LINE = 2,

        LABEL = 3,

        TEXT = 4,

    }

    public class SymbolChild

    {

        private string _Arrow;

        private string _Name;

        private int _Index;

        private string _SPPIDMAPPINGNAME;

        private object _SPPID_ITEM_OBJECT;

        public string Arrow { get => _Arrow; set => _Arrow = value; }

        public string Name { get => _Name; set => _Name = value; }

        public int Index { get => _Index; set => _Index = value; }

        public string SPPIDMAPPINGNAME { get => _SPPIDMAPPINGNAME; set => _SPPIDMAPPINGNAME = value; }

        public object SPPID_ITEM_OBJECT { get => _SPPID_ITEM_OBJECT; set => _SPPID_ITEM_OBJECT = value; }

    }

    public class Group

    {

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

        private bool _Enable = true;

        public List<object> Items { get => _Items; set => _Items = value; }

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

    }

    public class Association

    {

        private string _TYPE;

        private string _TYPE_VALUE;

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

        public string TYPE_VALUE { get => _TYPE_VALUE; set => _TYPE_VALUE = value; }

    }

    public class Drawing

    {

        #region Property

        private string _DWGNAME;

        private string _SIZE;

        private string _UNIT;

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

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

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

        private List<Text> _TEXTS = new List<Text>();

        private Dictionary<string, List<PointInfo>> _PipeRunPoint = new Dictionary<string, List<PointInfo>>();

        private List<Group> _GROUPS = new List<Group>();

        private double _WIDTH;

        private double _HEIGHT;

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

        public string SIZE

        {

            get { return _SIZE; }

            set

            {

                _SIZE = value;

                SPPIDUtill.ConvertPointBystring(_SIZE, ref _WIDTH, ref _HEIGHT);

            }

        }

        public string UNIT { get => _UNIT; set => _UNIT = value; }

        public Dictionary<string, List<PointInfo>> PipeRunPoint { get => _PipeRunPoint; set => _PipeRunPoint = 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<Text> TEXTS { get => _TEXTS; set => _TEXTS = value; }

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

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

        public List<Group> GROUPS { get => _GROUPS; set => _GROUPS = value; }

        #endregion

    }

    public class PointInfo

    {

        public PointInfo(double x, double y)

        {

            this.x = x;

            this.y = y;

        }

        public enum PointType

        {

            None = 0,

            Run = 1,

            Branch = 2,

        }

        #region Property

        private double x;

        private double y;

        private PointType _Type;

        private string _ConnectedItem;

        private string _SP_ID;

        private SPPID_ITEM _ConnectedItemObject;

        public double X { get { return x; } set { x = value; } }

        public double Y { get { return y; } set { y = value; } }

        public PointType Type { get => _Type; set => _Type = value; }

        public string ConnectedItem { get => _ConnectedItem; set => _ConnectedItem = value; }

        public SPPID_ITEM ConnectedItemObject { get => _ConnectedItemObject; set => _ConnectedItemObject = value; }

        public string SP_ID { get => _SP_ID; set => _SP_ID = value; }

        #endregion

    }

    public abstract class SPPID_ITEM

    {

        #region Property

        private string _UID;

        private string _TYPE;

        private string _NAME;

        private SPPID_ITEM_TYPE _SPPID_TYPE ;

        private string _SPPIDMAPPINGNAME;

        private bool _GROUPING;

        private string _AREA;

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

        private object _SPPID_ITEM_OBJECT;

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

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

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

        public string SPPIDMAPPINGNAME { get => _SPPIDMAPPINGNAME; set => _SPPIDMAPPINGNAME = value; }

        public bool GROUPING { get => _GROUPING; set => _GROUPING = value; }

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

        public object SPPID_ITEM_OBJECT { get => _SPPID_ITEM_OBJECT; set => _SPPID_ITEM_OBJECT = value; }

        public SPPID_ITEM_TYPE SPPID_TYPE { get => _SPPID_TYPE; set => _SPPID_TYPE = value; }

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

        #endregion

        public abstract bool Modeling();

        public abstract void AfterSetting();

        public abstract void SetAttribute();

    }

    public class Symbol : SPPID_ITEM

    {

        #region Property

        private string _ORIGINALPOINT;

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

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

        private string _CONNECTIONPOINT;

        private string _LOCATION;

        private string _SIZE;

        private double _ANGLE;

        private string _PARENT;

        private string _CHILD;

        private List<SymbolChild> _CHILD_LIST = new List<SymbolChild>();

        private string _HASINSTRUMENTLABEL;

        private string _CURRENTPOINTMODEINDEX;

        private bool _DRAWCHECKED;

        private double _LOCATION_X;

        private double _LOCATION_Y;

        private int _MIRROR = 0;

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

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

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

        public double ANGLE { get => _ANGLE; set => _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 CURRENTPOINTMODEINDEX { get => _CURRENTPOINTMODEINDEX; set => _CURRENTPOINTMODEINDEX = value; }

        public bool DRAWCHECKED { get => _DRAWCHECKED; set => _DRAWCHECKED = value; }

        public double LOCATION_X { get => _LOCATION_X; set => _LOCATION_X = value; }

        public double LOCATION_Y { get => _LOCATION_Y; set => _LOCATION_Y = value; }

        public int MIRROR { get => _MIRROR; set => _MIRROR = value; }

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

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

        public List<SymbolChild> CHILD_LIST { get => _CHILD_LIST; set => _CHILD_LIST = value; }

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

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(PARENT);

            // End

            // Angle Setting

            if (ANGLE == 1.57)

                ANGLE = 90 * Math.PI / 180;

            else if (ANGLE == 3.14)

                ANGLE = Math.PI;

            else if (ANGLE == 4.71)

                ANGLE = 270 * Math.PI / 180;

            else

                ANGLE = 0;

            // End

            // Location Setting

            SPPIDUtill.ConvertPointBystring(_ORIGINALPOINT, ref _LOCATION_X, ref _LOCATION_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _LOCATION_X, ref _LOCATION_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // SPPID Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.SYMBOL;

            // End

            // Child Setting

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

            {

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

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

                {

                    SymbolChild child = new SymbolChild()

                    {

                        Arrow = array[0],

                        Name = array[1],

                        Index = i + 1,

                    };

                    child.SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(child.Name);

                    CHILD_LIST.Add(child);

                }

            }

            // End

            // ConnectionPoint Setting

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

            {

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

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

                {

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

                    CONNECTORS[i].INDEX = Convert.ToInt32(arrConn[3]);

                }

            }

            // End

            // Input Drawing

            AutoModeling.DrawingItem.SYMBOLS.Add(this);

            // End

        }

        public override bool Modeling()

        {

            try

            {

                Placement _placement = new Placement();

                LMSymbol lmSymbol = null;

                SPPID_ITEM_OBJECT = null;

                if (!string.IsNullOrEmpty(SPPIDMAPPINGNAME))

                {

                    LMSymbol connectedSymbol = null;

                    foreach (Connector connector in CONNECTORS)

                    {

                        if (!string.IsNullOrEmpty(connector.CONNECTEDITEM) || connector.CONNECTEDITEM != "None")

                        {

                            object _obj = SPPIDUtill.FindObjectByUID(connector.CONNECTEDITEM);

                            if (_obj != null && typeof(Symbol) == _obj.GetType())

                            {

                                Symbol _symbol = _obj as Symbol;

                                if (_symbol.SPPID_ITEM_OBJECT != null)

                                    connectedSymbol = _symbol.SPPID_ITEM_OBJECT as LMSymbol;

                            }

                        }

                    }

                    if (connectedSymbol != null)

                        lmSymbol = _placement.PIDPlaceSymbol(SPPIDMAPPINGNAME, LOCATION_X, LOCATION_Y, Mirror: MIRROR, Rotation: ANGLE, TargetItem: connectedSymbol);

                    else

                        lmSymbol = _placement.PIDPlaceSymbol(SPPIDMAPPINGNAME, LOCATION_X, LOCATION_Y, Mirror: MIRROR, Rotation: ANGLE);

                    // Commit and input sppid item object

                    lmSymbol.Commit();

                    SPPID_ITEM_OBJECT = lmSymbol;

                    // End

                    // Check Child And Modeling

                    foreach (SymbolChild symoblChild in CHILD_LIST)

                    {

                        try

                        {

                            string sArrow = symoblChild.Arrow;

                            string sMappingName = symoblChild.SPPIDMAPPINGNAME;

                            double dChildAngle = 0;

                            if (sArrow == "UP")

                                dChildAngle = 0;

                            else if (sArrow == "RIGHT")

                                dChildAngle = 90 * Math.PI / 180;

                            else if (sArrow == "DOWN")

                                dChildAngle = Math.PI;

                            else

                                dChildAngle = 270 * Math.PI / 180;

                            LMSymbol _childLmSymbol = _placement.PIDPlaceSymbol(sMappingName, LOCATION_X, LOCATION_Y, Mirror: 0, Rotation: dChildAngle, TargetItem: SPPID_ITEM_OBJECT);

                            _childLmSymbol.Commit();

                            symoblChild.SPPID_ITEM_OBJECT = _childLmSymbol;

                        }

                        catch (Exception ex)

                        {

                            Console.WriteLine(ex.StackTrace);

                        }

                    }

                    // End

                    // Association Modeling

                    try

                    {

                        foreach (Association item in ASSOCIATIONS)

                        {

                            object _obj = SPPIDUtill.FindObjectByUID(item.TYPE_VALUE);

                            if (_obj != null && typeof(Text) == _obj.GetType())

                            {

                                Text text = _obj as Text;

                                if (text.NAME == "SIZE")

                                {

                                    text.OWNER = UID;

                                    text.Modeling();

                                    text.SetAttribute();

                                }

                            }

                        }

                    }

                    catch (Exception ex)

                    {

                        Console.WriteLine(ex.StackTrace);

                    }

                    // End

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.StackTrace);

                return false;

            }

            return true;

        }

        public override void SetAttribute()

        {

            throw new NotImplementedException();

        }

    }

    public class Line : SPPID_ITEM

    {

        public enum SlopeType

        {

            NONE = 0,

            VERTICAL = 1,

            HORIZONTAL = 2,

            SLOPE = 3,

        }

        #region Property

        private string _STARTPOINT;

        private string _ENDPOINT;

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

        private SlopeType _SLOPTYPE;

        private double _START_X;

        private double _START_Y;

        private double _END_X;

        private double _END_Y;

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

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

        public double START_X { get => _START_X; set => _START_X = value; }

        public double START_Y { get => _START_Y; set => _START_Y = value; }

        public double END_X { get => _END_X; set => _END_X = value; }

        public double END_Y { get => _END_Y; set => _END_Y = value; }

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

        public SlopeType SLOPTYPE { get => _SLOPTYPE; set => _SLOPTYPE = value; }

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(TYPE);

            // End

            // Point Setting

            SPPIDUtill.ConvertPointBystring(_STARTPOINT, ref _START_X, ref _START_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _START_X, ref _START_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            SPPIDUtill.ConvertPointBystring(_ENDPOINT, ref _END_X, ref _END_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _END_X,ref _END_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // Slop Setting

            SLOPTYPE = SPPIDUtill.CalcSlop(new PointInfo(_START_X, _START_Y), new PointInfo(_END_X, _END_Y));

            // End

            // SPPID Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.LINE;

            // End

            // Input Drawing

            AutoModeling.DrawingItem.LINES.Add(this);

            // End

        }

        public override bool Modeling()

        {

            throw new MissingMethodException();

        }

        public override void SetAttribute()

        {

            throw new NotImplementedException();

        }

    }

    public class LineNumber : SPPID_ITEM

    {

        public enum LineNumberType

        {

            LineNumber = 1,

            TrimLine = 2,

        }

        #region Property

        private double _ANGLE;

        private string _LOCATION;

        private double _LOCATION_X;

        private double _LOCATION_Y;

        private string _TEXT;

        private string _CONNECTLINE;

        private LineNumberType _LINENUMBERTYPE;

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

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

        public double LOCATION_X { get => _LOCATION_X; set => _LOCATION_X = value; }

        public double LOCATION_Y { get => _LOCATION_Y; set => _LOCATION_Y = value; }

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

        public string CONNECTLINE { get => _CONNECTLINE; set => _CONNECTLINE = value; }

        public LineNumberType LINENUMBERTYPE { get => _LINENUMBERTYPE; set => _LINENUMBERTYPE = value; }

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(NAME);

            // End

            // Angle Setting

            if (ANGLE == 1.57)

                ANGLE = 90 * Math.PI / 180;

            else if (ANGLE == 3.14)

                ANGLE = Math.PI;

            else if (ANGLE == 4.71)

                ANGLE = 270 * Math.PI / 180;

            else

                ANGLE = 0;

            // End

            // Location Setting

            SPPIDUtill.ConvertPointBystring(_LOCATION, ref _LOCATION_X, ref _LOCATION_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _LOCATION_X, ref _LOCATION_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // SPPID  Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.LABEL;

            // End

            // Input Drawing

            AutoModeling.DrawingItem.LINENUMBERS.Add(this);

            // End

        }

        public override bool Modeling()

        {

            try

            {

                Line targetLine = SPPIDUtill.FindObjectByUID(CONNECTLINE) as Line;

                if (targetLine != null && !string.IsNullOrEmpty(targetLine.SPPID_ITEM_OBJECT.ToString()))

                {

                    Placement _placement = new Placement();

                    Array points = new double[] { 0, LOCATION_X, LOCATION_Y };

                    LMPipeRun _pipeRun = _placement.PIDDataSource.GetPipeRun(targetLine.SPPID_ITEM_OBJECT.ToString());

                    if (_pipeRun != null)

                    {

                        foreach (LMRepresentation rep in _pipeRun.Representations)

                        {

                            if (rep.get_RepresentationType() == "Connector" && rep.get_ItemStatus() == "Active")

                            {

                                LMConnector _LmConnector = _placement.PIDDataSource.GetConnector(rep.Id);

                                LMLabelPersist _LmLabelPresist = _placement.PIDPlaceLabel(SPPIDMAPPINGNAME, ref points, Rotation: ANGLE, LabeledItem: _LmConnector.AsLMRepresentation(), IsLeaderVisible: true);

                                _LmLabelPresist.Commit();

                                SPPID_ITEM_OBJECT = _LmLabelPresist;

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.StackTrace);

                return false;

            }

            return true;

        }

        public override void SetAttribute()

        {

            try

            {

                Line targetLine = SPPIDUtill.FindObjectByUID(CONNECTLINE) as Line;

                if (targetLine != null)

                {

                    Placement _placement = new Placement();

                    LMPipeRun _pipeRun = _placement.PIDDataSource.GetPipeRun(targetLine.SPPID_ITEM_OBJECT.ToString());

                    foreach (ItemAttribute attr in ATTRIBUTES)

                    {

                        if (string.IsNullOrEmpty(attr.VALUE))

                            continue;

                        LMAAttribute lMAAttribute = _pipeRun.Attributes[attr.Attribute];

                        if (lMAAttribute != null)

                            _pipeRun.Attributes[attr.Attribute].set_Value(attr.VALUE);

                    }

                    _pipeRun.Commit();

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.StackTrace);

            }

        }

    }

    public class Text : SPPID_ITEM

    {

        #region Property

        private double _ANGLE;

        private string _LOCATION;

        private double _LOCATION_X;

        private double _LOCATION_Y;

        private string _VALUE;

        private string _OWNER;

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

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

        public double LOCATION_X { get => _LOCATION_X; set => _LOCATION_X = value; }

        public double LOCATION_Y { get => _LOCATION_Y; set => _LOCATION_Y = value; }

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

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

        #endregion

        public override void AfterSetting()

        {

            // SPPIDMAPPINGNAME Setting

            SPPIDMAPPINGNAME = SPPIDUtill.GetSPPIDMappingName(NAME);

            // End

            // Angle Setting

            if (ANGLE == 1.57)

                ANGLE = 90 * Math.PI / 180;

            else if (ANGLE == 3.14)

                ANGLE = Math.PI;

            else if (ANGLE == 4.71)

                ANGLE = 270 * Math.PI / 180;

            else

                ANGLE = 0;

            // End

            // Location Setting

            SPPIDUtill.ConvertPointBystring(_LOCATION, ref _LOCATION_X, ref _LOCATION_Y);

            SPPIDUtill.ConvertSPPIDPoint(ref _LOCATION_X, ref _LOCATION_Y, AutoModeling.DrawingItem.WIDTH, AutoModeling.DrawingItem.HEIGHT);

            // End

            // SPPID  Type Setting

            SPPID_TYPE = SPPID_ITEM_TYPE.TEXT;

            // End

            // Input Drawing

            AutoModeling.DrawingItem.TEXTS.Add(this);

            // End

        }

        public override bool Modeling()

        {

            try

            {

                if (SPPID_ITEM_OBJECT == null)

                {

                    Placement _placement = new Placement();

                    if (NAME == "TEXT" || NAME == "NOTE")

                    {

                        LMSymbol _LmSymbol = _placement.PIDPlaceSymbol(SPPIDMAPPINGNAME, LOCATION_X, LOCATION_Y, Rotation: ANGLE);

                        LMItemNote _LmItemNote = _placement.PIDDataSource.GetItemNote(_LmSymbol.ModelItemID);

                        _LmItemNote.Attributes["Note.Body"].set_Value(VALUE);

                        _LmItemNote.Commit();

                        SPPID_ITEM_OBJECT = _LmItemNote;

                    }

                    else if (NAME == "SIZE" && !string.IsNullOrEmpty(OWNER))

                    {

                        object _obj = SPPIDUtill.FindObjectByUID(OWNER);

                        if (_obj != null && typeof(Symbol) == _obj.GetType())

                        {

                            Array array = new double[] { 0, LOCATION_X, LOCATION_Y };

                            Symbol _symbol = _obj as Symbol;

                            LMSymbol _LmSymbol = _symbol.SPPID_ITEM_OBJECT as LMSymbol;

                            if (_LmSymbol != null)

                            {

                                string fileName = _LmSymbol.get_FileName();

                                if (fileName.Contains("Piping"))

                                    SPPIDMAPPINGNAME = @"\Piping\Labels - Piping Components\Nominal Diameter.sym";

                                else if (fileName.Contains("Instrumentation"))

                                    SPPIDMAPPINGNAME = @"\Instrumentation\Labels - General Instrument\Nominal Diameter.sym";

                                LMLabelPersist _LmLabelPersist = _placement.PIDPlaceLabel(SPPIDMAPPINGNAME, ref array, Rotation: ANGLE, LabeledItem: _LmSymbol.AsLMRepresentation(), IsLeaderVisible: true);

                                _LmLabelPersist.Commit();

                                SPPID_ITEM_OBJECT = _LmLabelPersist;

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.StackTrace);

                return false;

            }

            return true;

        }

        public override void SetAttribute()

        {

            try

            {

                Placement _placement = new Placement();

                if (NAME == "SIZE")

                {

                    object _obj = SPPIDUtill.FindObjectByUID(OWNER);

                    if (_obj != null && typeof(Symbol) == _obj.GetType())

                    {

                        Symbol _symbol = _obj as Symbol;

                        LMSymbol _LmSymbol = _symbol.SPPID_ITEM_OBJECT as LMSymbol;

                        if (_LmSymbol != null)

                        {

                            string fileName = _LmSymbol.get_FileName();

                            if (fileName.Contains("Piping"))

                            {

                                LMPipingComp _LmPipingComp = _placement.PIDDataSource.GetPipingComp(_LmSymbol.ModelItemID);

                                if (_LmPipingComp != null && DBNull.Value.Equals(_LmPipingComp.Attributes["NominalDiameter"].get_Value()))

                                {

                                    _LmPipingComp.Attributes["NominalDiameter"].set_Value(VALUE);

                                    _LmPipingComp.Commit();

                                }

                            }

                            else if (fileName.Contains("Instrumentation"))

                            {

                                LMInstrument _LmInstrument = _placement.PIDDataSource.GetInstrument(_LmSymbol.ModelItemID);

                                if (_LmInstrument != null && DBNull.Value.Equals(_LmInstrument.Attributes["NominalDiameter"].get_Value()))

                                {

                                    _LmInstrument.Attributes["NominalDiameter"].set_Value(VALUE);

                                    _LmInstrument.Commit();

                                }

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.StackTrace);

            }

            //throw new NotImplementedException();

        }

    }

    public class ItemAttribute

    {

        #region Property

        private string _UID;

        private string _Length;

        private string _Expression;

        private string _DisplayAttribute;

        private string _AttributeType;

        private string _Attribute;

        private string _AttrAt;

        private string _VALUE;

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

        public string VALUE { get => _VALUE; set => _VALUE = 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 AttrAt { get => _AttrAt; set => _AttrAt = value; }

        #endregion

    }

    public class Connector

    {

        #region Property

        private string _CONNECTEDITEM;

        private string _CONNECTPOINT;

        private string _SCENECONNECTPOINT;

        private int _INDEX;

        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 => _INDEX; set => _INDEX = value; }

        #endregion

    }

}