HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data;

using Ingr.SPPID.Llama;

using Ingr.SPPID.Plaice;

using Ingr.RAD2D.Interop.RAD2D;

using Ingr.RAD2D.Internal;

using Ingr.RAD2D.Helper;

using Converter.BaseModel;

using Converter.SPPID.Model;

using Converter.SPPID.Properties;

using Converter.SPPID.Util;

using Converter.SPPID.DB;

using Ingr.RAD2D.MacroControls.CmdCtrl;

using Ingr.RAD2D;

using System.Windows;

using System.Threading;

using System.Drawing;

using Microsoft.VisualBasic;

using Newtonsoft.Json;

using DevExpress.XtraSplashScreen;

namespace Converter.SPPID.OPC

{

    public class AutoModeling_OPC

    {

        dynamic application;

        dynamic drawing;

        Ingr.RAD2D.Application radApp;

        string fromOPCModelId;

        string toOPCModelId;

        string toDrawingName;

        List<string[]> toOPCAttributes;

        public AutoModeling_OPC(dynamic application, Ingr.RAD2D.Application radApp, string fromOPCModelId, string toOPCModelId, string toDrawingName, List<string[]> toOPCAttributes)

        {

            this.application = application;

            this.radApp = radApp;

            this.fromOPCModelId = fromOPCModelId;

            this.toOPCModelId = toOPCModelId;

            this.toDrawingName = toDrawingName;

            this.toOPCAttributes = toOPCAttributes;

        }

        public bool Run()

        {

            bool result = false;

            if (OpenDrawing(toDrawingName))

                result = PairedOPCModeling();

            CloseDrawing();

            return result;

        }

        public bool PairedOPCModeling()

        {

            Placement _placement = new Placement();

            LMADataSource dataSource = _placement.PIDDataSource;

            bool result = false;

            bool isPaired = false;

            LMOPC _FROM_OPC = dataSource.GetOPC(fromOPCModelId);

            LMOPC _TO_OPC = dataSource.GetOPC(toOPCModelId);

            if (_FROM_OPC != null && _FROM_OPC.ItemStatus.ToString() == "Active" && _TO_OPC != null && _TO_OPC.ItemStatus.ToString() == "Active")

            {

                string symbolPath = GetSPPIDFileName(_FROM_OPC);

                LMOPC pairOPC = _FROM_OPC.pairedWithOPCObject;

                foreach (LMRepresentation rep in pairOPC.Representations)

                    if (rep.DrawingID.ToString() != "0")

                        isPaired = true;

                try

                {

                    if (!isPaired)

                    {

                        foreach (LMRepresentation rep in _TO_OPC.Representations)

                        {

                            LMSymbol removeSymbol = dataSource.GetSymbol(rep.Id);

                            if (removeSymbol != null)

                            {

                                ZoomObjectByGraphicOID(removeSymbol.GraphicOID.ToString());

                                int mirror = removeSymbol.IsMirroredIndex;

                                double angle = Convert.ToDouble(removeSymbol.RotationAngle);

                                double x = Convert.ToDouble(removeSymbol.XCoordinate);

                                double y = Convert.ToDouble(removeSymbol.YCoordinate);

                                LMSymbol newOPC = null;

                                LMConnector connConnector = null;

                                int connConnectorIndex = 0;

                                foreach (LMConnector LMConnector in removeSymbol.Avoid1Connectors)

                                {

                                    if (LMConnector.ItemStatus.ToString() == "Active")

                                    {

                                        connConnector = LMConnector;

                                        if (!DBNull.Value.Equals(connConnector.ConnectItem1SymbolID) && connConnector.ConnectItem1SymbolID == removeSymbol.Id)

                                            connConnectorIndex = 1;

                                        else if (!DBNull.Value.Equals(connConnector.ConnectItem2SymbolID) && connConnector.ConnectItem2SymbolID == removeSymbol.Id)

                                            connConnectorIndex = 2;

                                        break;

                                    }

                                }

                                if (connConnector == null)

                                {

                                    foreach (LMConnector LMConnector in removeSymbol.Avoid2Connectors)

                                    {

                                        if (LMConnector.ItemStatus.ToString() == "Active")

                                        {

                                            connConnector = LMConnector;

                                            if (!DBNull.Value.Equals(connConnector.ConnectItem1SymbolID) && connConnector.ConnectItem1SymbolID == removeSymbol.Id)

                                                connConnectorIndex = 1;

                                            else if (!DBNull.Value.Equals(connConnector.ConnectItem2SymbolID) && connConnector.ConnectItem2SymbolID == removeSymbol.Id)

                                                connConnectorIndex = 2;

                                            break;

                                        }

                                    }

                                }

                                if (connConnector != null)

                                {

                                    _placement.PIDRemovePlacement(removeSymbol.AsLMRepresentation());

                                    ReleaseCOMObjects(removeSymbol);

                                    newOPC = _placement.PIDPlaceSymbol(symbolPath, x, y, Mirror: mirror, Rotation: angle, ExistingItem: pairOPC.AsLMAItem());

                                    if (newOPC != null)

                                    {

                                        LMModelItem modelItem = connConnector.ModelItemObject;

                                        string _symbolPath = null;

                                        foreach (LMRepresentation representation in modelItem.Representations)

                                        {

                                            if (!DBNull.Value.Equals(representation.FileName) && !string.IsNullOrEmpty(representation.FileName.ToString()))

                                            {

                                                _symbolPath = representation.FileName.ToString();

                                                break;

                                            }

                                        }

                                        if (!string.IsNullOrEmpty(_symbolPath))

                                        {

                                            LMAItem _LMAItem = _placement.PIDCreateItem(_symbolPath);

                                            List<double[]> vertices = GetConnectorVertices(connConnector);

                                            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

                                            double[] point = null;

                                            if (connConnectorIndex == 1)

                                                point = new double[] { vertices[0][0], vertices[0][1] };

                                            else

                                                point = new double[] { vertices[vertices.Count - 1][0], vertices[vertices.Count - 1][1] };

                                            placeRunInputs.AddSymbolTarget(newOPC, point[0], point[1]);

                                            placeRunInputs.AddConnectorTarget(connConnector, point[0], point[1]);

                                            LMConnector _lMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

                                            ReleaseCOMObjects(_LMAItem);

                                            _LMAItem = null;

                                            ReleaseCOMObjects(placeRunInputs);

                                            placeRunInputs = null;

                                            ReleaseCOMObjects(_lMConnector);

                                            _lMConnector = null;

                                        }

                                        ReleaseCOMObjects(modelItem);

                                        modelItem = null;

                                    }

                                }

                                if (newOPC != null)

                                {

                                    LMModelItem modelitem = newOPC.ModelItemObject;

                                    result = true;

                                    foreach (var attribute in toOPCAttributes)

                                    {

                                        LMAAttribute _attribute = modelitem.Attributes[attribute[0]];

                                        if (_attribute != null)

                                            _attribute.Value = attribute[1];

                                    }

                                    newOPC.Commit();

                                    modelitem.Commit();

                                    ReleaseCOMObjects(modelitem);

                                    modelitem = null;

                                }

                                ReleaseCOMObjects(connConnector);

                                connConnector = null;

                                ReleaseCOMObjects(newOPC);

                                newOPC = null;

                                ReleaseCOMObjects(removeSymbol);

                                removeSymbol = null;

                                break;

                            }

                            ReleaseCOMObjects(removeSymbol);

                            removeSymbol = null;

                        }

                    }

                }

                catch (Exception ex)

                {

                    Log.Write("error OPC");

                }

                finally

                {

                    ReleaseCOMObjects(_placement);

                    _placement = null;

                    ReleaseCOMObjects(dataSource);

                    dataSource = null;

                    ReleaseCOMObjects(_FROM_OPC);

                    _FROM_OPC = null;

                    ReleaseCOMObjects(_TO_OPC);

                    _TO_OPC = null;

                    ReleaseCOMObjects(pairOPC);

                    pairOPC = null;

                }

            }

            return result;

        }

        private List<double[]> GetConnectorVertices(LMConnector connector)

        {

            List<double[]> vertices = new List<double[]>();

            if (connector != null)

            {

                dynamic OID = connector.GraphicOID.ToString();

                Ingr.RAD2D.Components.Connector.Connector drawingObject = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID] as Ingr.RAD2D.Components.Connector.Connector;

                Ingr.RAD2D.LineStringGeometry2d lineStringGeometry = drawingObject.GetGeometry() as Ingr.RAD2D.LineStringGeometry2d;

                int verticesCount = lineStringGeometry.VertexCount;

                double[] value = null;

                lineStringGeometry.GetVertices(ref verticesCount, ref value);

                for (int i = 0; i < verticesCount; i++)

                {

                    double x = 0;

                    double y = 0;

                    lineStringGeometry.GetVertex(i + 1, ref x, ref y);

                    vertices.Add(new double[] { x, y });

                }

            }

            return vertices;

        }

        /// <summary>

        /// Graphic OID로 해당 Symbol의 크기를 구하여 Zoom

        /// </summary>

        /// <param name="graphicOID"></param>

        /// <param name="milliseconds"></param>

        private void ZoomObjectByGraphicOID(string graphicOID, int milliseconds = 150)

        {

            if (radApp.ActiveDocument.ActiveSheet.DrawingObjects[graphicOID] != null)

            {

                double minX = 0;

                double minY = 0;

                double maxX = 0;

                double maxY = 0;

                ((GraphicObject)radApp.ActiveDocument.ActiveSheet.DrawingObjects[graphicOID]).Range(out minX, out minY, out maxX, out maxY);

                // TODO : ZOOM FIT

                //radApp.ActiveWindow.ZoomArea2(minX - 0.007, minY - 0.007, maxX + 0.007, maxY + 0.007, null);

                Thread.Sleep(milliseconds);

            }

        }

        private string GetSPPIDFileName(LMOPC opc)

        {

            string symbolPath = null;

            foreach (LMRepresentation rep in opc.Representations)

            {

                if (!DBNull.Value.Equals(rep.FileName) && !string.IsNullOrEmpty(rep.FileName.ToString()))

                {

                    symbolPath = rep.FileName.ToString();

                    break;

                }

            }

            return symbolPath;

        }

        public void ReleaseCOMObjects(params object[] objVars)

        {

            if (objVars != null)

            {

                int intNewRefCount = 0;

                foreach (object obj in objVars)

                {

                    if (!Information.IsNothing(obj) && System.Runtime.InteropServices.Marshal.IsComObject(obj))

                        intNewRefCount = intNewRefCount + System.Runtime.InteropServices.Marshal.FinalReleaseComObject(obj);

                }

            }

        }

        private bool OpenDrawing(string drawingName)

        {

            bool result = false;

            try

            {

                drawing = application.Drawings.OpenDrawing(drawingName);

                drawing.Activate();

                result = true;

            }

            catch (Exception ex)

            {

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

            }

            return result;

        }

        private void CloseDrawing()

        {

            if (drawing != null)

            {

                drawing.CloseDrawing(true);

                ReleaseCOMObjects(drawing);

                drawing = null;

            }

        }

    }

}