HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data;

using Llama;

using 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.get_ItemStatus() == "Active" && _TO_OPC != null && _TO_OPC.get_ItemStatus() == "Active")

            {

                string symbolPath = GetSPPIDFileName(_FROM_OPC);

                LMOPC pairOPC = _FROM_OPC.pairedWithOPCObject;

                foreach (LMRepresentation rep in pairOPC.Representations)

                    if (rep.DrawingID != "0")

                        isPaired = true;

                try

                {

                    if (!isPaired)

                    {

                        foreach (LMRepresentation rep in _TO_OPC.Representations)

                        {

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

                            if (removeSymbol != null)

                            {

                                ZoomObjectByGraphicOID(removeSymbol.get_GraphicOID().ToString());

                                int mirror = removeSymbol.get_IsMirroredIndex();

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

                                double x = removeSymbol.get_XCoordinate();

                                double y = removeSymbol.get_YCoordinate();

                                LMSymbol newOPC = null;

                                foreach (LMConnector LMConnector in removeSymbol.Avoid1Connectors)

                                {

                                    _placement.PIDRemovePlacement(removeSymbol.AsLMRepresentation());

                                    ReleaseCOMObjects(removeSymbol);

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

                                    break;

                                }

                                if (newOPC == null)

                                {

                                    foreach (LMConnector LMConnector in removeSymbol.Avoid2Connectors)

                                    {

                                        _placement.PIDRemovePlacement(removeSymbol.AsLMRepresentation());

                                        ReleaseCOMObjects(removeSymbol);

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

                                        break;

                                    }

                                }

                                if (newOPC != null)

                                {

                                    result = true;

                                    foreach (var attribute in toOPCAttributes)

                                    {

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

                                        if (_attribute != null)

                                            _attribute.set_Value(attribute[1]);

                                    }

                                    newOPC.Commit();

                                }

                                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;

        }

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

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

                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.get_FileName()) && !string.IsNullOrEmpty(rep.get_FileName()))

                {

                    symbolPath = rep.get_FileName();

                    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;

            }

        }

    }

}