HYTOS

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Data;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using System.Threading;

using System.IO;

using Microsoft.VisualBasic;

using Ingr.RAD2D;

using Converter.BaseModel;

using Converter.SPPID.Properties;

using Converter.SPPID.DB;

using Converter.SPPID.Util;

using Converter.SPPID.Form;

using Converter.SPPID.Model;

using Plaice;

using Llama;

using DevExpress.XtraSplashScreen;

using Newtonsoft.Json;

using System.Runtime.InteropServices;

using System.Reflection;

using Converter.SPPID.OPC;

namespace Converter.SPPID.Wrapper

{

    public partial class ConverterDocking : UserControl

    {

        Ingr.RAD2D.Application application;

        static bool addEvent = false;

        public ConverterDocking()

        {

            InitializeComponent();

            spinEditSymmetry.Properties.Mask.EditMask = "f0";

            dynamic dApplication = Interaction.GetObject("", "PIDAutomation.Application");

            WrapperApplication wApp = new WrapperApplication(dApplication.Application);

            application = wApp.RADApplication;

            ReleaseCOMObjects(dApplication);

            dApplication = null;

            try

            {

                textEditDrawingX.EditValue = Settings.Default.DrawingX;

                textEditDrawingY.EditValue = Settings.Default.DrawingY;

                Project_Info _ProjectInfo = Project_Info.GetInstance();

                _ProjectInfo.DefaultPath = Settings.Default.ProjectPath;

                _ProjectInfo.DBType = (ID2DB_Type)Settings.Default.ProjectDBType;

                _ProjectInfo.ServerIP = Settings.Default.ProjectServerIP;

                _ProjectInfo.Port = Settings.Default.ProjectPort;

                _ProjectInfo.DBUser = Settings.Default.ProjectDBUser;

                _ProjectInfo.DBPassword = Settings.Default.ProjectDBPassword;

                if (!addEvent)

                {

                    application.EventObject.BeforeApplicationExit += ApplicationEvents_ApplicationExit;

                    addEvent = true;

                }

                RegisterHotKey(this.Handle, 0, (int)KeyModifier.Shift, Keys.A.GetHashCode());

            }

            catch (Exception ex)

            {

                StringBuilder sb = new StringBuilder();

                sb.AppendLine(ex.Message);

                sb.AppendLine(ex.StackTrace);

                MessageBox.Show(sb.ToString());

            }

        }

        private void ApplicationEvents_ApplicationExit(out bool cancel)

        {

            cancel = false;

        }

        /// <summary>

        /// 선택한 도면들을 읽어서 SPPID로 변환한다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void btnConverter_Click(object sender, EventArgs e)

        {

            ConverterForm converterForm = new ConverterForm();

            if (converterForm.ShowDialog() == DialogResult.OK)

            {

                //Ingr.RAD2D.Document doc = application.Documents.Add();

                try

                {

                    CloseOPCForm.Run();

                    for (int i = 0; i < converterForm.Documents.Count; i++)

                    {

                        SPPID_Document document = converterForm.Documents[i];

                        if (document.SetSPPIDMapping() && document.Enable)

                        {

                            using (AutoModeling modeling = new AutoModeling(document, converterForm.checkEditCloseDocument.Checked))

                            {

                                modeling.DocumentLabelText = string.Format("Drawing Name : {0} ({1}/{2})", document.DrawingName, i + 1, converterForm.Documents.Count);

                                modeling.Run();

                            }

                        }

                    }

                }

                catch (Exception ex)

                {

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

                }

                finally

                {

                    CloseOPCForm.Stop();

                    //doc.SaveOnClose = false;

                    //doc.Close(false);

                    //dynamic dApplication = Interaction.GetObject("", "PIDAutomation.Application");

                    //dApplication.Drawings[1].CloseDrawing(false);

                    //ReleaseCOMObjects(dApplication);

                    //dApplication = null;

                }

                MessageBox.Show(Msg.EndConvert, Msg.Information, MessageBoxButtons.OK, MessageBoxIcon.Information);

            }

        }

        private void btnLinkOPC_Click(object sender, EventArgs e)

        {

            DataTable tOPCInfo = Project_DB.SelectOPCInfo();

            DataTable tOPCRelations = Project_DB.SelectOPCRelations();

            DataTable tDrawingInfo = Project_DB.SelectDrawingInfo();

            dynamic dApplication = Interaction.GetObject("", "PIDAutomation.Application");

            foreach (DataRow row in tOPCInfo.Rows)

            {

                if (!Convert.ToBoolean(row["PAIRED"]))

                {

                    string drawingUID = row["ID2_DRAWING_UID"].ToString();

                    string OPCUID = row["ID2_OPC_UID"].ToString();

                    DataRow[] rows = tOPCRelations.Select(string.Format("(From_Drawings_UID = '{0}' AND From_OPC_UID = '{1}') OR (To_Drawings_UID = '{0}' AND To_OPC_UID = '{1}')", drawingUID, OPCUID));

                    if (rows.Length == 2)

                    {

                        string fromDrawingsUID1 = rows[0]["From_Drawings_UID"].ToString();

                        string fromDrawingsUID2 = rows[1]["From_Drawings_UID"].ToString();

                        string fromOPCUID1 = rows[0]["From_OPC_UID"].ToString();

                        string fromOPCUID2 = rows[1]["From_OPC_UID"].ToString();

                        string toDrawingsUID1 = rows[0]["To_Drawings_UID"].ToString();

                        string toDrawingsUID2 = rows[1]["To_Drawings_UID"].ToString();

                        string toOPCUID1 = rows[0]["To_OPC_UID"].ToString();

                        string toOPCUID2 = rows[1]["To_OPC_UID"].ToString();

                        DataRow[] fromDrawing = tDrawingInfo.Select(string.Format("ID2_DRAWING_UID = '{0}'", fromDrawingsUID1));

                        DataRow[] toDrawing = tDrawingInfo.Select(string.Format("ID2_DRAWING_UID = '{0}'", toDrawingsUID1));

                        DataRow[] fromOPCInfoRows = tOPCInfo.Select(string.Format("ID2_OPC_UID = '{0}'", fromOPCUID1));

                        DataRow[] toOPCInfoRows = tOPCInfo.Select(string.Format("ID2_OPC_UID = '{0}'", toOPCUID1));

                        if (fromOPCUID1 == toOPCUID2 && fromOPCUID2 == toOPCUID1 && fromDrawing.Length == 1 && toDrawing.Length == 1 && fromOPCInfoRows.Length == 1 && toOPCInfoRows.Length == 1)

                        {

                            DataRow fromOPCInfoRow = fromOPCInfoRows[0];

                            DataRow toOPCInfoRow = toOPCInfoRows[0];

                            string fromOPCModelId = fromOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString();

                            string toOPCModelId = toOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString();

                            string toDrawingName = toDrawing[0]["DRAWINGNAME"].ToString();

                            List<string[]> toOPCAttributes = JsonConvert.DeserializeObject<List<string[]>>(toOPCInfoRow["ATTRIBUTES"].ToString());

                            AutoModeling_OPC opc = new AutoModeling_OPC(dApplication, application, fromOPCModelId, toOPCModelId, toDrawingName, toOPCAttributes);

                            if (opc.Run())

                            {

                                fromOPCInfoRow["PAIRED"] = true;

                                toOPCInfoRow["PAIRED"] = true;

                                Project_DB.InsertOPCInfo(fromOPCInfoRow["ID2_OPC_UID"].ToString(), fromOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString(), fromOPCInfoRow["ID2_DRAWING_UID"].ToString(), true);

                                Project_DB.InsertOPCInfo(toOPCInfoRow["ID2_OPC_UID"].ToString(), toOPCInfoRow["SPPID_OPC_MODELITEM_ID"].ToString(), toOPCInfoRow["ID2_DRAWING_UID"].ToString(), true);

                            }

                        }

                    }

                }

            }

            tOPCInfo.Dispose();

            tOPCRelations.Dispose();

            tDrawingInfo.Dispose();

            ReleaseCOMObjects(dApplication);

            dApplication = null;

            MessageBox.Show(Msg.EndConvert, Msg.Information, MessageBoxButtons.OK, MessageBoxIcon.Information);

        }

        public void ReleaseCOMObjects(params object[] objVars)

        {

            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 void btnGetDrawingSize_Click(object sender, EventArgs e)

        {

            dynamic application = Interaction.GetObject("", "PIDAutomation.Application");

            WrapperApplication wApp = new WrapperApplication(application.Application);

            Ingr.RAD2D.Application radApp = wApp.RADApplication;

            if (radApp.ActiveSelectSet.Count > 0)

            {

                DependencyObject line2D = radApp.ActiveSelectSet[0] as DependencyObject;

                if (line2D != null)

                {

                    double minX = 0;

                    double minY = 0;

                    double maxX = 0;

                    double maxY = 0;

                    line2D.Range(out minX, out minY, out maxX, out maxY);

                    Settings.Default.DrawingX = maxX - minX;

                    Settings.Default.DrawingY = maxY - minY;

                    Settings.Default.Save();

                    textEditDrawingX.EditValue = Settings.Default.DrawingX;

                    textEditDrawingY.EditValue = Settings.Default.DrawingY;

                }

                else

                    MessageBox.Show(Msg.SelectLine, Msg.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);

            }

            else

                MessageBox.Show(Msg.SelectLine, Msg.Warning, MessageBoxButtons.OK, MessageBoxIcon.Warning);

        }

        #region SPPID Utils

        #region Symmetry

        private void btnSymmetry_Click(object sender, EventArgs e)

        {

            if (application.ActiveSelectSet.Count == 1 && application.ActiveSelectSet[0].GetType() == typeof(Symbol2d))

            {

                int symCount = (int)spinEditSymmetry.Value;

                Symbol2d symbol = application.ActiveSelectSet[0] as Symbol2d;

                double x, y;

                symbol.GetOrigin(out x, out y);

                string rep = GetRepresentationId(symbol);

                List<string> verticalRepID = new List<string>();

                List<string> horizontalRepID = new List<string>();

                if ((symbol.LinearName.Contains("Piping") ||

                    symbol.LinearName.Contains("Instrument")) &&

                    !string.IsNullOrEmpty(rep))

                {

                    Placement placement = new Placement();

                    LMADataSource dataSource = placement.PIDDataSource;

                    List<List<string>> datas = SetSymbol(dataSource, rep, x, y, symCount);

                    Dictionary<SymmetryArrow, List<string>> resultDatas = new Dictionary<SymmetryArrow, List<string>>();

                    if (datas.Count >= 2 && datas.Find(loop => loop.Count != symCount) == null)

                    {

                        SymmetryArrow arrow = SymmetryArrow.None;

                        foreach (var data in datas)

                        {

                            LMSymbol firstSymbol = dataSource.GetSymbol(data[0]);

                            double fX = firstSymbol.get_XCoordinate();

                            double fY = firstSymbol.get_YCoordinate();

                            SlopeType type = SPPIDUtil.CalcSlope(x, y, fX, fY, 1);

                            if (type == SlopeType.HORIZONTAL)

                            {

                                if (fX < x)

                                {

                                    arrow |= SymmetryArrow.Left;

                                    resultDatas.Add(SymmetryArrow.Left, data);

                                }

                                else

                                {

                                    arrow |= SymmetryArrow.Right;

                                    resultDatas.Add(SymmetryArrow.Right, data);

                                }

                            }

                            else if (type == SlopeType.VERTICAL)

                            {

                                if (fY < y)

                                {

                                    arrow |= SymmetryArrow.Down;

                                    resultDatas.Add(SymmetryArrow.Down, data);

                                }

                                else

                                {

                                    arrow |= SymmetryArrow.Up;

                                    resultDatas.Add(SymmetryArrow.Up, data);

                                }

                            }

                            ReleaseCOMObjects(firstSymbol);

                        }

                        SymmetryForm form = new SymmetryForm(arrow);

                        if (form.ShowDialog() == DialogResult.OK)

                        {

                            MoveByResult(dataSource, resultDatas, x, y, form.Result, rep);

                        }

                    }

                    else

                        MessageBox.Show("Check Symmetry Rules", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                    ReleaseCOMObjects(dataSource);

                    ReleaseCOMObjects(placement);

                }

            }

            return;

            List<Symbol2d> symbols = new List<Symbol2d>();

            foreach (var item in application.ActiveSelectSet)

            {

                Type type = item.GetType();

                if (type == typeof(Symbol2d))

                {

                    Symbol2d symbol = item as Symbol2d;

                    if (symbol.LinearName.Contains("Piping") ||

                        symbol.LinearName.Contains("Instrument"))

                        symbols.Add(symbol);

                }

                //if (item.GetType() == typeof(Symbol2d) || item.GetType() == typeof(Point2d))

                //    items.Add(item);

            }

            List<Symbol2d> verticalSymbols = new List<Symbol2d>();

            List<Symbol2d> horizontalSymbols = new List<Symbol2d>();

            Symbol2d mainSymbol = null;

            for (int i = 0; i < symbols.Count - 1; i++)

            {

                Symbol2d symbol1 = symbols[i];

                for (int j = 1; j < symbols.Count; j++)

                {

                    Symbol2d symbol2 = symbols[j];

                    if (symbol1 != symbol2)

                    {

                        double x1, y1, x2, y2;

                        symbol1.GetOrigin(out x1, out y1);

                        symbol2.GetOrigin(out x2, out y2);

                        SlopeType slopeType = SPPIDUtil.CalcSlope(x1, y1, x2, y2, 1);

                        if (slopeType == SlopeType.HORIZONTAL)

                        {

                            if (!horizontalSymbols.Contains(symbol1))

                                horizontalSymbols.Add(symbol1);

                            if (!horizontalSymbols.Contains(symbol2))

                                horizontalSymbols.Add(symbol2);

                            if (verticalSymbols.Contains(symbol1))

                                mainSymbol = symbol1;

                            if (verticalSymbols.Contains(symbol2))

                                mainSymbol = symbol2;

                        }

                        else if (slopeType == SlopeType.VERTICAL)

                        {

                            if (!verticalSymbols.Contains(symbol1))

                                verticalSymbols.Add(symbol1);

                            if (!verticalSymbols.Contains(symbol2))

                                verticalSymbols.Add(symbol2);

                            if (horizontalSymbols.Contains(symbol1))

                                mainSymbol = symbol1;

                            if (horizontalSymbols.Contains(symbol2))

                                mainSymbol = symbol2;

                        }

                    }

                }

            }

            application.ActiveSelectSet.RemoveAll();

            foreach (var item in verticalSymbols)

                application.ActiveSelectSet.Add(item);

            foreach (var item in horizontalSymbols)

                application.ActiveSelectSet.Add(item);

            if (MessageBox.Show("Continue?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)

            {

                application.ActiveSelectSet.RemoveAll();

            }

        }

        private void MoveByResult(LMADataSource dataSource,Dictionary<SymmetryArrow, List<string>> resultDatas, double x, double y, SymmetryArrow arrow, string centerRepID)

        {

            List<string> datas = resultDatas[arrow];

            foreach (var item in resultDatas)

            {

                if (item.Key != arrow)

                {

                    for (int i = 0; i < item.Value.Count; i++)

                    {

                        Symbol2d moveSymbol2d = GetSymbol2DByRepID(dataSource, item.Value[i]);

                        Symbol2d symbol2d = GetSymbol2DByRepID(dataSource, datas[i]);

                        double x1, y1, x2, y2;

                        symbol2d.GetOrigin(out x1, out y1);

                        moveSymbol2d.GetOrigin(out x2, out y2);

                        double distance = SPPIDUtil.CalcPointToPointdDistance(x, y, x1, y1);

                        string symbol1RepID;

                        string symbol2RepID;

                        List<Point2d> point2ds;

                        if (i == 0)

                        {

                            symbol1RepID = centerRepID;

                            symbol2RepID = item.Value[i];

                        }

                        else

                        {

                            symbol1RepID = item.Value[i - 1];

                            symbol2RepID = item.Value[i];

                        }

                        point2ds = FindAllPoint2d(dataSource, symbol1RepID, symbol2RepID);

                        double moveX = 0;

                        double moveY = 0;

                        if (item.Key == SymmetryArrow.Left)

                            moveX = x - distance - x2;

                        else if (item.Key == SymmetryArrow.Right)

                            moveX = x + distance - x2;

                        else if (item.Key == SymmetryArrow.Down)

                            moveY = y - distance - y2;

                        else if (item.Key == SymmetryArrow.Up)

                            moveY = y + distance - y2;

                        moveSymbol2d.Move(0, 0, moveX, moveY);

                        MovePoint2d(dataSource, item.Value[i], arrow, moveX, moveY);

                        foreach (var point in point2ds)

                        {

                            LMSymbol branch = dataSource.GetSymbol(GetRepresentationId(point));

                            LMSymbol connSymbol = GetFirstSymbolBySlope(dataSource, branch, symbol1RepID, symbol2RepID);

                            point.Move(0, 0, moveX, moveY);

                            if (connSymbol != null)

                            {

                                Symbol2d connSymbol2d = GetSymbol2DByRepID(dataSource, connSymbol.AsLMRepresentation().Id);

                                connSymbol2d.Move(0, 0, moveX, moveY);

                                ReleaseCOMObjects(connSymbol);

                            }

                            ReleaseCOMObjects(branch);

                        }

                    }

                }

            }

        }

        private LMSymbol GetFirstSymbolBySlope(LMADataSource dataSource, LMSymbol branch, string symbol1RepID, string symbol2RepID)

        {

            LMSymbol result = null;

            foreach (LMConnector connector in branch.Connect1Connectors)

            {

                if (connector.ConnectItem1SymbolObject != null && 

                    connector.ConnectItem1SymbolObject.get_ItemStatus() == "Active" &&

                    connector.ConnectItem1SymbolObject.get_RepresentationType() != "Branch")

                {

                    string repID = connector.ConnectItem1SymbolObject.AsLMRepresentation().Id;

                    if (repID != symbol1RepID && repID != symbol2RepID)

                        result = connector.ConnectItem1SymbolObject;

                }

                if (connector.ConnectItem2SymbolObject != null &&

                    connector.ConnectItem2SymbolObject.get_ItemStatus() == "Active" &&

                    connector.ConnectItem2SymbolObject.get_RepresentationType() != "Branch")

                {

                    string repID = connector.ConnectItem2SymbolObject.AsLMRepresentation().Id;

                    if (repID != symbol1RepID && repID != symbol2RepID)

                        result = connector.ConnectItem2SymbolObject;

                }

            }

            foreach (LMConnector connector in branch.Connect2Connectors)

            {

                if (connector.ConnectItem1SymbolObject != null &&

                    connector.ConnectItem1SymbolObject.get_ItemStatus() == "Active" &&

                    connector.ConnectItem1SymbolObject.get_RepresentationType() != "Branch")

                {

                    string repID = connector.ConnectItem1SymbolObject.AsLMRepresentation().Id;

                    if (repID != symbol1RepID && repID != symbol2RepID)

                        result = connector.ConnectItem1SymbolObject;

                }

                if (connector.ConnectItem2SymbolObject != null &&

                    connector.ConnectItem2SymbolObject.get_ItemStatus() == "Active" &&

                    connector.ConnectItem2SymbolObject.get_RepresentationType() != "Branch")

                {

                    string repID = connector.ConnectItem2SymbolObject.AsLMRepresentation().Id;

                    if (repID != symbol1RepID && repID != symbol2RepID)

                        result = connector.ConnectItem2SymbolObject;

                }

            }

            return result;

        }

        private string GetRepresentationId(Symbol2d symbol)

        {

            foreach (var attributes in symbol.AttributeSets)

            {

                foreach (var attribute in attributes)

                {

                    string name = attribute.Name;

                    object value = attribute.GetValue();

                    if (name == "DrawingID")

                    {

                        return value.ToString();  

                    }

                }

            }

            return null;

        }

        private string GetRepresentationId(Point2d point2d)

        {

            foreach (var attributes in point2d.AttributeSets)

            {

                foreach (var attribute in attributes)

                {

                    string name = attribute.Name;

                    object value = attribute.GetValue();

                    if (name == "DrawingID")

                    {

                        return value.ToString();

                    }

                }

            }

            return null;

        }

        private List<List<string>> SetSymbol(LMADataSource dataSource, string rep, double x, double y, int count)

        {

            LMSymbol _LMSymbol = dataSource.GetSymbol(rep);

            List<List<string>> result = new List<List<string>>();

            List<string> oldIDs = new List<string>() { rep };

            foreach (LMConnector connector in _LMSymbol.Connect1Connectors)

            {

                if (connector.get_ItemStatus() != "Active")

                    continue;

                string repID = connector.AsLMRepresentation().Id;

                string status = connector.get_ItemStatus();

                if (status == "Active" && !oldIDs.Contains(repID))

                {

                    List<string> symbols = new List<string>();

                    oldIDs.Add(repID);

                    loop(dataSource, oldIDs, symbols, connector, x, y, count);

                    result.Add(symbols);

                }

            }

            foreach (LMConnector connector in _LMSymbol.Connect2Connectors)

            {

                if (connector.get_ItemStatus() != "Active")

                    continue;

                string repID = connector.AsLMRepresentation().Id;

                string status = connector.get_ItemStatus();

                if (status == "Active" && !oldIDs.Contains(repID))

                {

                    List<string> symbols = new List<string>();

                    oldIDs.Add(repID);

                    loop(dataSource, oldIDs, symbols, connector, x, y, count);

                    result.Add(symbols);

                }

            }

            ReleaseCOMObjects(_LMSymbol);

            return result;

        }

        private void loop(LMADataSource dataSource, List<string> oldIDs, List<string> symbols, LMConnector connector, double x, double y, int count)

        {

            if (symbols.Count >= count)

                return;

            if (connector.ConnectItem1SymbolObject != null && !oldIDs.Contains(connector.ConnectItem1SymbolObject.AsLMRepresentation().Id))

            {

                string repID = connector.ConnectItem1SymbolObject.AsLMRepresentation().Id;

                oldIDs.Add(repID);

                if (connector.ConnectItem1SymbolObject.get_RepresentationType() != "Branch" && connector.ConnectItem1SymbolObject.get_ItemStatus() == "Active")

                {

                    double sX = connector.ConnectItem1SymbolObject.get_XCoordinate(), sY = connector.ConnectItem1SymbolObject.get_YCoordinate(); ;

                    SlopeType slopeType = SPPIDUtil.CalcSlope(x, y, sX, sY, 1);

                    if (slopeType == SlopeType.HORIZONTAL || slopeType == SlopeType.VERTICAL)

                        symbols.Add(repID);

                }

                loop(dataSource, oldIDs, symbols, connector.ConnectItem1SymbolObject, x, y, count);

            }

            if (symbols.Count >= count)

                return;

            if (connector.ConnectItem2SymbolObject != null && !oldIDs.Contains(connector.ConnectItem2SymbolObject.AsLMRepresentation().Id))

            {

                string repID = connector.ConnectItem2SymbolObject.AsLMRepresentation().Id;

                oldIDs.Add(repID);

                if (connector.ConnectItem2SymbolObject.get_RepresentationType() != "Branch" && connector.ConnectItem2SymbolObject.get_ItemStatus() == "Active")

                {

                    double sX = connector.ConnectItem2SymbolObject.get_XCoordinate(), sY = connector.ConnectItem2SymbolObject.get_YCoordinate(); ;

                    SlopeType slopeType = SPPIDUtil.CalcSlope(x, y, sX, sY, 1);

                    if (slopeType == SlopeType.HORIZONTAL || slopeType == SlopeType.VERTICAL)

                        symbols.Add(repID);

                }

                loop(dataSource, oldIDs, symbols, connector.ConnectItem2SymbolObject, x, y, count);

            }

        }

        private void loop(LMADataSource dataSource, List<string> oldIDs, List<string> symbols, LMSymbol _LMSymbol, double x, double y, int count)

        {

            if (symbols.Count >= count)

                return;

            foreach (LMConnector connector in _LMSymbol.Connect1Connectors)

            {

                if (connector.get_ItemStatus() != "Active")

                    continue;

                string repID = connector.AsLMRepresentation().Id;

                string status = connector.get_ItemStatus();

                if (status == "Active" && !oldIDs.Contains(repID))

                {

                    oldIDs.Add(repID);

                    loop(dataSource, oldIDs, symbols, connector, x, y, count);

                }

            }

            foreach (LMConnector connector in _LMSymbol.Connect2Connectors)

            {

                if (connector.get_ItemStatus() != "Active")

                    continue;

                string repID = connector.AsLMRepresentation().Id;

                string status = connector.get_ItemStatus();

                if (status == "Active" && !oldIDs.Contains(repID))

                {

                    oldIDs.Add(repID);

                    loop(dataSource, oldIDs, symbols, connector, x, y, count);

                }

            }

        }

        private Symbol2d GetSymbol2DByRepID(LMADataSource dataSource, string repID)

        {

            LMSymbol _LMSymbol = dataSource.GetSymbol(repID);

            Symbol2d symbol2D = application.ActiveDocument.ActiveSheet.DrawingObjects[_LMSymbol.get_GraphicOID().ToString()];

            ReleaseCOMObjects(_LMSymbol);

            return symbol2D;

        }

        private void MovePoint2d(LMADataSource datasource, string repID, SymmetryArrow arrow, double moveX, double moveY)

        {

            LMSymbol _LMSymbol = datasource.GetSymbol(repID);

            foreach (LMConnector connector in _LMSymbol.Connect1Connectors)

            {

                if (connector.get_ItemStatus() == "Active" && Convert.ToBoolean(connector.get_IsZeroLength()))

                {

                    if (connector.ConnectItem1SymbolObject != null && connector.ConnectItem1SymbolObject.get_RepresentationType() == "Branch")

                    {

                        Point2d point = application.ActiveDocument.ActiveSheet.DrawingObjects[connector.ConnectItem1SymbolObject.get_GraphicOID().ToString()];

                        point.X += moveX;

                        point.Y += moveY;

                    }

                    else if (connector.ConnectItem2SymbolObject != null && connector.ConnectItem2SymbolObject.get_RepresentationType() == "Branch")

                    {

                        Point2d point = application.ActiveDocument.ActiveSheet.DrawingObjects[connector.ConnectItem2SymbolObject.get_GraphicOID().ToString()];

                        point.X += moveX;

                        point.Y += moveY;

                    }

                }

            }

            foreach (LMConnector connector in _LMSymbol.Connect2Connectors)

            {

                if (connector.get_ItemStatus() == "Active" && Convert.ToBoolean(connector.get_IsZeroLength()))

                {

                    if (connector.ConnectItem1SymbolObject != null && connector.ConnectItem1SymbolObject.get_RepresentationType() == "Branch")

                    {

                        Point2d point = application.ActiveDocument.ActiveSheet.DrawingObjects[connector.ConnectItem1SymbolObject.get_GraphicOID().ToString()];

                        point.X += moveX;

                        point.Y += moveY;

                    }

                    else if (connector.ConnectItem2SymbolObject != null && connector.ConnectItem2SymbolObject.get_RepresentationType() == "Branch")

                    {

                        Point2d point = application.ActiveDocument.ActiveSheet.DrawingObjects[connector.ConnectItem2SymbolObject.get_GraphicOID().ToString()];

                        point.X += moveX;

                        point.Y += moveY;

                    }

                }

            }

            ReleaseCOMObjects(_LMSymbol);

        }

        private List<Point2d> FindAllPoint2d(LMADataSource dataSource, string repID, string nextRepID)

        {

            LMSymbol _LMSymbol = dataSource.GetSymbol(repID);

            List<string> endIDs = new List<string>() { repID };

            List<string> graphicOIDs = new List<string>();

            List<Point2d> result = new List<Point2d>();

            FindPointsLoop(dataSource, _LMSymbol, endIDs, nextRepID, graphicOIDs);

            ReleaseCOMObjects(_LMSymbol);

            foreach (var item in graphicOIDs)

            {

                Point2d point = application.ActiveDocument.ActiveSheet.DrawingObjects[item] as Point2d;

                result.Add(point);

            }

            return result;

        }

        private bool FindPointsLoop(LMADataSource dataSource, LMSymbol _LMSymbol, List<string> endIDs, string targetRepID, List<string> graphicOIDs)

        {

            foreach (LMConnector connector in _LMSymbol.Connect1Connectors)

            {

                if (connector.get_ItemStatus() != "Active")

                    continue;

                if (connector.ConnectItem1SymbolObject != null && connector.ConnectItem1SymbolObject.get_ItemStatus() == "Active")

                {

                    string repID = connector.ConnectItem1SymbolObject.AsLMRepresentation().Id;

                    if (!endIDs.Contains(repID))

                    {

                        endIDs.Add(repID);

                        if (connector.ConnectItem1SymbolObject.get_RepresentationType() == "Branch")

                        {

                            if (FindPointsLoop(dataSource, connector.ConnectItem1SymbolObject, endIDs, targetRepID, graphicOIDs))

                            {

                                if (!Convert.ToBoolean(connector.get_IsZeroLength()))

                                    graphicOIDs.Add(connector.ConnectItem1SymbolObject.get_GraphicOID().ToString());

                                return true;

                            }

                        }

                        else if (targetRepID == repID)

                        {

                            return true;

                        }

                    }

                }

                if (connector.ConnectItem2SymbolObject != null && connector.ConnectItem2SymbolObject.get_ItemStatus() == "Active")

                {

                    string repID = connector.ConnectItem2SymbolObject.AsLMRepresentation().Id;

                    if (!endIDs.Contains(repID))

                    {

                        endIDs.Add(repID);

                        if (connector.ConnectItem2SymbolObject.get_RepresentationType() == "Branch")

                        {

                            if (FindPointsLoop(dataSource, connector.ConnectItem2SymbolObject, endIDs, targetRepID, graphicOIDs))

                            {

                                if (!Convert.ToBoolean(connector.get_IsZeroLength()))

                                    graphicOIDs.Add(connector.ConnectItem2SymbolObject.get_GraphicOID().ToString());

                                return true;

                            }

                        }

                        else if (targetRepID == repID)

                        {

                            return true;

                        }

                    }

                }

            }

            foreach (LMConnector connector in _LMSymbol.Connect2Connectors)

            {

                if (connector.get_ItemStatus() != "Active")

                    continue;

                if (connector.ConnectItem1SymbolObject != null && connector.ConnectItem1SymbolObject.get_ItemStatus() == "Active")

                {

                    string repID = connector.ConnectItem1SymbolObject.AsLMRepresentation().Id;

                    if (!endIDs.Contains(repID))

                    {

                        endIDs.Add(repID);

                        if (connector.ConnectItem1SymbolObject.get_RepresentationType() == "Branch")

                        {

                            if (FindPointsLoop(dataSource, connector.ConnectItem1SymbolObject, endIDs, targetRepID, graphicOIDs))

                            {

                                if (!Convert.ToBoolean(connector.get_IsZeroLength()))

                                    graphicOIDs.Add(connector.ConnectItem1SymbolObject.get_GraphicOID().ToString());

                                return true;

                            }

                        }

                        else if (targetRepID == repID)

                        {

                            return true;

                        }

                    }

                }

                if (connector.ConnectItem2SymbolObject != null && connector.ConnectItem2SymbolObject.get_ItemStatus() == "Active")

                {

                    string repID = connector.ConnectItem2SymbolObject.AsLMRepresentation().Id;

                    if (!endIDs.Contains(repID))

                    {

                        endIDs.Add(repID);

                        if (connector.ConnectItem2SymbolObject.get_RepresentationType() == "Branch")

                        {

                            if (FindPointsLoop(dataSource, connector.ConnectItem2SymbolObject, endIDs, targetRepID, graphicOIDs))

                            {

                                if (!Convert.ToBoolean(connector.get_IsZeroLength()))

                                    graphicOIDs.Add(connector.ConnectItem2SymbolObject.get_GraphicOID().ToString());

                                return true;

                            }

                        }

                        else if (targetRepID == repID)

                        {

                            return true;

                        }

                    }

                }

            }

            return false;

        }

        #endregion

        #region SpecBreak

        private void btnSpecBreakRelocation_Click(object sender, EventArgs e)

        {

            dynamic dApplication = Interaction.GetObject("", "PIDAutomation.Application");

            WrapperApplication wApp = new WrapperApplication(dApplication.Application);

            application = wApp.RADApplication;

            int count = application.ActiveSelectSet.Count;

            int dependencyCount = 0;

            foreach (var item in application.ActiveSelectSet)

                if (item.GetType() == typeof(DependencyObject))

                    dependencyCount++;

            if ((count == 3 || count == 4) && application.ActiveSelectSet[0].GetType() == typeof(Symbol2d) &&

                (dependencyCount == 2 || dependencyCount == 3))

            {

                Symbol2d symbol = application.ActiveSelectSet[0] as Symbol2d;

                if (!symbol.DefinitionName.Contains(@"Design\Annotation\Graphics\"))

                {

                    MessageBox.Show("Select SpecBreak!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                    return;

                }

                DependencyObject dependency1 = application.ActiveSelectSet[1] as DependencyObject;

                DependencyObject dependency2 = application.ActiveSelectSet[2] as DependencyObject;

                DependencyObject dependency3 = null;

                if (count == 4)

                    dependency3 = application.ActiveSelectSet[3] as DependencyObject;

                application.ActiveSelectSet.RemoveAll();

                double angle = symbol.Angle;

                if (symbol.GetTransform().HasReflection)

                    angle += Math.PI;

                double degree = double.NaN;

                if (angle > -0.1 && angle < 0.1)

                    degree = 0;

                else if (angle > 1.56 && angle < 1.58)

                    degree = 90;

                else if (angle > 3.13 && angle < 3.15)

                    degree = 180;

                else if (angle > 4.7 && angle < 4.72)

                    degree = 270;

                else if (angle > 6.27 && angle < 6.29)

                    degree = 0;

                else if (angle > -1.58 && angle < -1.56)

                    degree = 270;

                else

                    throw new Exception("Error");

                double originX, originY;

                symbol.GetOrigin(out originX, out originY);

                double crossX = 0;

                double crossY = 0;

                double topX = 0;

                double topY = 0;

                foreach (var item in symbol.DrawingObjects)

                {

                    Line2d line2d = item as Line2d;

                    if (line2d != null)

                    {

                        double x1, y1, x2, y2;

                        line2d.GetStartPoint(out x1, out y1);

                        line2d.GetEndPoint(out x2, out y2);

                        SlopeType slopeType = SPPIDUtil.CalcSlope(x1, y1, x2, y2, 0.1);

                        if (slopeType == SlopeType.HORIZONTAL)

                        {

                            if (crossY == 0)

                                crossY = y1;

                            else

                                crossY = (crossY + y1) / 2;

                            switch (degree)

                            {

                                case 90:

                                    if (topX == 0)

                                        topX = Math.Min(x1, x2);

                                    else

                                        topX = Math.Min(topX, Math.Min(x1, x2));

                                    break;

                                case 270:

                                    if (topX == 0)

                                        topX = Math.Max(x1, x2);

                                    else

                                        topX = Math.Max(topX, Math.Max(x1, x2));

                                    break;

                                default:

                                    break;

                            }

                        }

                        else if (slopeType == SlopeType.VERTICAL)

                        {

                            if (crossX == 0)

                                crossX = x1;

                            else

                                crossX = (crossX + x1) / 2;

                            switch (degree)

                            {

                                case 0:

                                    if (topY == 0)

                                        topY = Math.Max(y1, y2);

                                    else

                                        topY = Math.Max(topY, Math.Max(y1, y2));

                                    break;

                                case 180:

                                    if (topY == 0)

                                        topY = Math.Min(y1, y2);

                                    else

                                        topY = Math.Min(topY, Math.Min(y1, y2));

                                    break;

                                default:

                                    break;

                            }

                        }

                    }

                }

                switch (degree)

                {

                    case 0:

                        crossX = originX;

                        topX = crossX;

                        break;

                    case 90:

                        crossY = originY;

                        topY = crossY;

                        break;

                    case 180:

                        crossX = originX;

                        topX = crossX;

                        break;

                    case 270:

                        crossY = originY;

                        topY = crossY;

                        break;

                    default:

                        break;

                }

                SpecBreakRelocation(degree, crossX, crossY, topX, topY, dependency1, dependency2, dependency3);

            }

            else

            {

                MessageBox.Show("Check Rule!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);

            }

        }

        private void SpecBreakRelocation(double degree, double crossX, double crossY, double topX, double topY, DependencyObject dependency1, DependencyObject dependency2, DependencyObject dependency3)

        {

            double d1X1, d1Y1, d1X2, d1Y2, d2X1, d2Y1, d2X2, d2Y2;

            string type1 = GetDrawingItemType(dependency1);

            string type2 = GetDrawingItemType(dependency2);

            if (type1 == "Connector")

            {

            }

            if (type2 == "Connector")

            {

            }

            return;

            Ingr.RAD2D.TextBox textBox1 = FindTextBoxArea(dependency1, out d1X1, out d1Y1, out d1X2, out d1Y2);

            Ingr.RAD2D.TextBox textBox2 = FindTextBoxArea(dependency2, out d2X1, out d2Y1, out d2X2, out d2Y2);

            switch (degree)

            {

                case 0:

                    textBox1.Move(d1X2, d1Y2, crossX, crossY);

                    textBox2.Move(d2X1, d2Y2, crossX, crossY);

                    break;

                case 90:

                    textBox1.Move(d1X1, d1Y2, crossX, crossY);

                    textBox2.Move(d2X1, d2Y1, crossX, crossY);

                    break;

                case 180:

                    textBox1.Move(d1X2, d1Y1, crossX, crossY);

                    textBox2.Move(d2X1, d2Y1, crossX, crossY);

                    break;

                case 270:

                    textBox1.Move(d1X2, d1Y2, crossX, crossY);

                    textBox2.Move(d2X2, d2Y1, crossX, crossY);

                    break;

                default:

                    break;

            }

        }

        private string GetDrawingItemType(DependencyObject dependency)

        {

            string result = string.Empty;

            foreach (var attributes in dependency.AttributeSets)

            {

                foreach (var attribute in attributes)

                {

                    if (attribute.Name == "DrawingItemType")

                        return attribute.GetValue().ToString();

                }

            }

            return result;

        }

        private Ingr.RAD2D.TextBox FindTextBoxArea(DependencyObject dependency, out double x1, out double y1, out double x2, out double y2)

        {

            x1 = 0;

            y1 = 0;

            x2 = 0;

            y2 = 0;

            Ingr.RAD2D.TextBox textBox = null;

            foreach (var item in dependency.DrawingObjects)

            {

                if (item.GetType() == typeof(Ingr.RAD2D.TextBox))

                {

                    textBox = item as Ingr.RAD2D.TextBox;

                    textBox.Range(out x1, out y1, out x2, out y2);

                    break;

                }

            }

            return textBox;

        }

        #endregion

        #region Hot Key

        [System.Runtime.InteropServices.DllImport("user32.dll")]

        private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);

        [System.Runtime.InteropServices.DllImport("user32.dll")]

        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        enum KeyModifier

        {

            None = 0,

            Alt = 1,

            Control = 2,

            Shift = 4,

            WinKey = 8

        }

        protected override void WndProc(ref Message m)

        {

            base.WndProc(ref m);

            if (m.Msg == 0x0312)

            {

                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);

                KeyModifier modifier = (KeyModifier)((int)m.LParam & 0xFFFF);

                int id = m.WParam.ToInt32();

                application.RunCommand(CommandConstants.igcmdGridSnap);

            }

        }

        #endregion

        #endregion

        #region TEST

        private void simpleButton1_Click(object sender, EventArgs e)

        {

            Placement placement = new Placement();

            if (application.ActiveSelectSet.Count > 0)

            {

                string modelItemId = null;

                Symbol2d symbol2D = application.ActiveSelectSet[0] as Symbol2d;

                DependencyObject dependency = application.ActiveSelectSet[0] as DependencyObject;

                application.ActiveSelectSet.RemoveAll();

                if (symbol2D != null)

                {

                    return;

                    foreach (var attributes in symbol2D.AttributeSets)

                    {

                        foreach (var attribute in attributes)

                        {

                            if (attribute.Name == "ModelID")

                                modelItemId = attribute.GetValue().ToString();

                        }

                    }

                    if (modelItemId!=null)

                    {

                        LMADataSource dataSource = new LMADataSource();

                        LMModelItem modelItem = dataSource.GetModelItem(modelItemId);

                        foreach (LMRepresentation item in modelItem.Representations)

                        {

                            if (item.ModelItemID == modelItemId)

                            {

                                dataSource = placement.PIDDataSource;

                                LMSymbol symbol = dataSource.GetSymbol(item.Id);

                                double oldx = symbol.get_XCoordinate();

                                double oldy = symbol.get_YCoordinate();

                                symbol2D.Move(0, 0, 0, GridSetting.GetInstance().Length);

                                dataSource = new LMADataSource();

                                //dataSource = placement.PIDDataSource;

                                symbol = dataSource.GetSymbol(item.Id);

                                double x = symbol.get_XCoordinate();

                                double y = symbol.get_YCoordinate();

                            }

                        }

                    }

                }

                else if (dependency != null)

                {

                    foreach (dynamic item in dependency.DrawingObjects)

                    {

                        item.Move(0, 0, 0, GridSetting.GetInstance().Length);

                    }

                }

            }

            return;

            Thread outThread = new Thread(func2 =>

            {

                for (int i = 100; i < 120; i++)

                {

                    Thread thread = new Thread(func =>

                    {

                        dynamic application = Interaction.GetObject("", "PIDAutomation.Application");

                        //WrapperApplication wApp = new WrapperApplication(application.Application);

                        //Ingr.RAD2D.Application radApp = wApp.RADApplication;

                        dynamic drawing = application.Drawings.Add("Unit1", "D-Size.pid", i.ToString(), i.ToString());//application.Drawings.OpenDrawing("123");

                        Thread.Sleep(5000);

                        drawing.CloseDrawing(true);

                        //application.Quit();

                        ReleaseCOMObjects(application);

                        application = null;

                        ReleaseCOMObjects(drawing);

                        drawing = null;

                        Thread.Sleep(5000);

                    });

                    thread.Start();

                    thread.Join();

                }

            });

            outThread.Start();

            //radApp.Documents.Add(@"\\server70\DEVDOF1Site\GS\PLANT\PLANT1\Unit1\11111.pid");

            //radApp.ActiveDocument.Close(true);

            //drawing.CloseDrawing(true);

            //ReleaseCOMObjects(application);

            //ReleaseCOMObjects(drawing);

            //application = null;

            //wApp = null;

            //radApp = null;

            //drawing = null;

        }

        private void AutoJoinPipeRun()

        {

            dynamic application = Interaction.GetObject("", "PIDAutomation.Application");

            WrapperApplication wApp = new WrapperApplication(application.Application);

            Ingr.RAD2D.Application radApp = wApp.RADApplication;

            string modelItemId = null;

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

            if (radApp.ActiveSelectSet.Count == 0)

            {

                return;

            }

            dynamic OID = radApp.ActiveSelectSet[0].Key();

            DependencyObject drawingObject = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID];

            foreach (var attributes in drawingObject.AttributeSets)

            {

                foreach (var attribute in attributes)

                {

                    if (attribute.Name == "ModelID")

                        modelItemId = attribute.GetValue().ToString();

                }

            }

            radApp.ActiveSelectSet.RemoveAll();

        }

        #endregion

        [DllImport("user32.dll")]

        public static extern int FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll", SetLastError = true)]

        static extern int GetWindowThreadProcessId(IntPtr hWnd, out int processId);

        private void ConverterDocking_Load(object sender, EventArgs e)

        {

#if DEBUG

            this.layoutControlItem2.Visibility = DevExpress.XtraLayout.Utils.LayoutVisibility.Always;

#else

            this.layoutControlItem2.Visibility = DevExpress.XtraLayout.Utils.LayoutVisibility.Never;

#endif

        }

    }

}