HYTOS

using System;

using System.Collections.Generic;

using System.Collections;

using System.Configuration;

using System.Data;

using System.Data.Common;

using System.Data.SqlClient;

using System.IO;

using System.Runtime.CompilerServices;

using Microsoft.VisualBasic.CompilerServices;

using System.Runtime.InteropServices;

using System.Threading;

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.ApplicationServices.Core;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Interop;

using Autodesk.AutoCAD.Interop.Common;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

using AVEVA.PID.Components;

using AVEVA.PID.GUI;

using AVEVA.PID.Common;

using AVEVA.PID.DWGSelector;

using AVEVA.PID.Utilities;

using AVEVA.PID.CustomizationUtility.DB;

using AVEVA.PID.CustomizationUtility.Model;

using AVEVA.PID.CustomizationUtility.Properties;

using DevExpress.XtraSplashScreen;

namespace AVEVA.PID.CustomizationUtility

{

    public class AutoModeling

    {

        [DllImport("user32")]

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

        public static AutoModeling Running { get; set; }

        Model.Document document;

        AvevaInfo avevaInfo;

        private void SetConvertRule()

        {

            #region OPC Setting

            document.OPCs.Sort(SortOPC);

            int SortOPC(OPC a, OPC b)

            {

                if (a.FlowType == FlowType.In)

                    return 1;

                else

                    return 0;

            }

            #endregion

        }

        public AutoModeling(Model.Document document)

        {

            this.document = document;

            avevaInfo = AvevaInfo.GetInstance();

        }

        public void CreateDrawing()

        {

            string outPath = Project_DB.GetDirectiveValue("DRGPTH");

            string tempPath = Path.GetTempPath();

            string selectedFullPath = Path.Combine(tempPath, document.AvevaTemplateName + ".DWT");

            DWTSelector.strDrawingNumber = document.AvevaDrawingNumber;

            DWTSelector.strSheetNumber = document.AvevaSheetNumber;

            DWTSelector.strCadFileName = document.AvevaDrawingNumber + document.AvevaSheetNumber;

            DWTSelector.strCadFilePath = outPath;

            try

            {

                string text = ReadWriteDrawingData.ReadTemplateData(document.AvevaTemplateName, document.AvevaTemplateID, selectedFullPath, false);

                Autodesk.AutoCAD.Interop.AcadApplication acadApplication = Autodesk.AutoCAD.ApplicationServices.Application.AcadApplication as Autodesk.AutoCAD.Interop.AcadApplication;

                Autodesk.AutoCAD.Interop.AcadDocument acadDocument = acadApplication.Documents.Add(text);

                Commands.addLatestPidvesrionToDictionary();

                AVVPropCmd.ActivateAcad();

                if (acadDocument != null)

                {

                    Running = this;

                    acadApplication.ActiveDocument = acadDocument;

                    acadDocument.SendCommand("QSAVE ");

                    acadDocument.SendCommand("APPIDRun ");

                    acadDocument.SendCommand("QSAVE ");

                    Running = null;

                }

            }

            catch (System.Exception ex)

            {

            }

            GC.Collect();

        }

        public void Run()

        {

            try

            {

                SplashScreenManager.ShowForm(typeof(APIDSplashScreen), true, true);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllStepCount, 8);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetDocumentName, document.AvevaDrawingNumber + document.AvevaSheetNumber);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetParent, Autodesk.AutoCAD.ApplicationServices.Application.MainWindow.Handle);

                SetConvertRule();

                Zoom(0, 0, 10, 10);

                RunLineModeling();

                ZoomAll();

                RunOPCModeling();

                RunSymbolModeling();

                RunTextModeling();

                RunNoteModeling();

                RunInputLineAttribute();

                RunInputLineNumberAttribute();

                RunInputSymbolAttribute();

            }

            catch (System.Exception ex)

            {

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

            }

            finally

            {

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.ClearParent, null);

                SplashScreenManager.CloseForm(false);

            }

        }

        private void Zoom(double minX, double minY, double maxX, double maxY)

        {

            Autodesk.AutoCAD.Interop.AcadApplication acadApplication = Autodesk.AutoCAD.ApplicationServices.Application.AcadApplication as Autodesk.AutoCAD.Interop.AcadApplication;

            double[] lower = new double[3] { minX, minY, 0 };

            double[] upper = new double[3] { maxX, maxY, 0 };

            acadApplication.ZoomWindow(lower, upper);

            acadApplication.ActiveDocument.Activate();

        }

        private void ZoomAll()

        {

            Autodesk.AutoCAD.Interop.AcadApplication acadApplication = Autodesk.AutoCAD.ApplicationServices.Application.AcadApplication as Autodesk.AutoCAD.Interop.AcadApplication;

            acadApplication.ZoomAll();

            acadApplication.ActiveDocument.Activate();

        }

        #region Run Method

        private void RunLineModeling()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.LINES.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Line Modeling");

            foreach (var item in document.LINES)

            {

                if (item.Aveva.Handle == 0)

                    LineModeling(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunOPCModeling()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.OPCs.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "OPC Modeling");

            foreach (var item in document.OPCs)

            {

                if (item.Aveva.Handle == 0)

                    SymbolModeling(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunSymbolModeling()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.SYMBOLS.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Symbol Modeling");

            foreach (var item in document.SYMBOLS)

            {

                if (item.Aveva.Handle == 0)

                    SymbolModeling(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunTextModeling()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.Texts.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Text Modeling");

            foreach (var item in document.Texts)

            {

                TextModeling(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunNoteModeling()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.Notes.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Note Modeling");

            foreach (var item in document.Notes)

            {

                NoteModeling(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunInputLineAttribute()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.LINES.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Input Line Attribute");

            foreach (var item in document.LINES)

            {

                SetLineAttribute(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunInputSymbolAttribute()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.SYMBOLS.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Input Symbol Attribute");

            foreach (var item in document.SYMBOLS)

            {

                SetSymbolAttribute(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        private void RunInputLineNumberAttribute()

        {

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetAllProgress, document.LINENUMBERS.Count);

            SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.SetStep, "Input LineNumber Attribute");

            foreach (var item in document.LINENUMBERS)

            {

                SetLineNumberAttribute(item);

                SplashScreenManager.Default.SendCommand(APIDSplashScreen.SplashScreenCommand.UpProgress, null);

            }

        }

        #endregion

        #region Modeling Method

        private void LineModeling(Model.Line line)

        {

            List<Model.Line> groupLine = new List<Model.Line>();

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

            GetConnectedGroupLine(line, groupLine, false);

            CoordinateCorrection(groupLine);

            GetGroupLinePoints(groupLine, points);

            LineNumber lineNumber = null;

            if (line.Aveva.Type == Model.Type.Pipe)

            {

                foreach (var item in groupLine)

                {

                    lineNumber = document.LINENUMBERS.Find(x => x.CONNLINE == item.UID);

                    if (lineNumber != null)

                    {

                        GUIUtils.SetAutoLabelCheck(true);

                        AvevaThread.Run(ThreadType.LineNumberModeling, null);

                        break;

                    }

                }

            }

            long handle = 0;

            if (line.Aveva.Type == Model.Type.Pipe)

                handle = DrawPipe(line.Aveva.Name, points, lineNumber);

            else if (line.Aveva.Type == Model.Type.Signal)

                handle = DrawSignal(line.Aveva.Name, points);

            if (lineNumber != null)

            {

                GUIUtils.SetAutoLabelCheck(false);

                AvevaThread.Stop(ThreadType.LineNumberModeling);

            }

            foreach (var item in groupLine)

                item.Aveva.Handle = handle;

        }

        private void SymbolModeling(Symbol symbol)

        {

            DataRow[] allRows = avevaInfo.AvevaSymbolTable.Select(string.Format("Symbol_Name = '{0}'", symbol.Aveva.Name));

            if (allRows.Length == 1)

            {

                DataRow symbolRow = allRows[0];

                bool bAngle = CheckAngle(symbolRow);

                bool bBalloon = CheckBalloon(symbol);

                long handle = DrawSymbol(symbol, symbolRow, bAngle, bBalloon);

                if (handle != 0)

                {

                    symbol.Aveva.Handle = handle;

                    if (!bAngle)

                    {

                        ObjectId objectId = APIDUtils.GetObjectIdByHandle(handle);

                        if (objectId != ObjectId.Null)

                        {

                            SetBlockReferenceRotation(objectId, symbol.ANGLE);

                        }

                    }

                }

            }

        }

        private void TextModeling(Text text)

        {

            if (text.TextAngle == TextAngle.None || text.ASSOCIATION)

                return;

            if (text.Aveva.LabelType == LabelType.SingleText)

                DrawText(text.Aveva.X, text.Aveva.Y, text.Aveva.Height, text.VALUE, text.Aveva.Angle);

            else if (text.Aveva.LabelType == LabelType.MultiText)

            {

                string[] valueArray = text.VALUE.Split(new string[] { "\n" }, StringSplitOptions.None);

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

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

                    values.Insert(0, valueArray[i]);

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

                {

                    double x = text.Aveva.X;

                    double y = text.Aveva.Y;

                    int heightIndex = i;

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

                        y = y + text.Aveva.Height * i;

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

                        x = x + text.Aveva.Height * i;

                    DrawText(x, y, text.Aveva.Height, values[i], text.Aveva.Angle);

                }

            }

        }

        private void NoteModeling(Model.Note note)

        {

            if (note.TextAngle == TextAngle.None)

                return;

            if (note.Aveva.LabelType == LabelType.SingleNote)

                DrawText(note.Aveva.X, note.Aveva.Y, note.Aveva.Height, note.VALUE, note.Aveva.Angle);

            else if (note.Aveva.LabelType == LabelType.MultiNote)

            {

                string[] valueArray = note.VALUE.Split(new string[] { "\n" }, StringSplitOptions.None);

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

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

                    values.Insert(0, valueArray[i]);

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

                {

                    double x = note.Aveva.X;

                    double y = note.Aveva.Y;

                    int heightIndex = i;

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

                        y = y + note.Aveva.Height * i;

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

                        x = x + note.Aveva.Height * i;

                    DrawText(x, y, note.Aveva.Height, values[i], note.Aveva.Angle);

                }

            }

        }

        private void SetLineAttribute(Model.Line line)

        {

        }

        private void SetLineNumberAttribute(Model.LineNumber lineNumber)

        {

            Model.Line line = APIDUtils.FindObjectByUID(document, lineNumber.CONNLINE) as Model.Line;

            if (line != null && line.Aveva.Handle != 0)

            {

                List<Tuple<string, string>> datas = new List<Tuple<string, string>>();

                foreach (Model.Attribute attribute in lineNumber.ATTRIBUTES)

                {

                    AttributeInfo info = avevaInfo.AttributeInfo.Find(x => x.UID == attribute.UID);

                    if (info != null && !string.IsNullOrEmpty(info.APID_ATTRIBUTE))

                        datas.Add(new Tuple<string, string>(info.APID_ATTRIBUTE, attribute.VALUE));

                }

                if (datas.Count > 0)

                {

                    ObjectId objectId = GetFirstPolyLineObjectId(line.Aveva.Handle);

                    if (!objectId.IsNull)

                        SetAttributeByAvevaForm(objectId.Handle.Value, datas);

                }

            }

        }

        private void SetSymbolAttribute(Model.Symbol symbol)

        {

            if (symbol.Aveva.Handle != 0)

            {

                List<Tuple<string, string>> datas = new List<Tuple<string, string>>();

                foreach (var attribute in symbol.ATTRIBUTES)

                {

                    AttributeInfo info = avevaInfo.AttributeInfo.Find(x => x.UID == attribute.UID);

                    if (info != null && !string.IsNullOrEmpty(info.APID_ATTRIBUTE))

                        datas.Add(new Tuple<string, string>(info.APID_ATTRIBUTE, attribute.VALUE));

                }

                if (datas.Count > 0)

                {

                    ObjectId objectId = APIDUtils.GetObjectIdByHandle(symbol.Aveva.Handle);

                    if (!objectId.IsNull)

                        SetAttributeByAvevaForm(objectId.Handle.Value, datas);

                }

            }

        }

        #endregion

        #region Drawing Method

        private long DrawPipe(string style, List<string> coordinates, LineNumber lineNumber = null)

        {

            List<long> prevHandles = GetAllGroupHandles();

            GUIUtils.SetPipeStyle(style);

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Editor editor = acDoc.Editor;

            List<object> commandParam = new List<object>();

            //command name

            commandParam.Add("DRPIPE");

            //coordinate

            foreach (var item in coordinates)

                commandParam.Add(item);

            //enter Parent(null)

            commandParam.Add(null);

            if (lineNumber != null)

            {

                Point3d point = new Point3d(lineNumber.Aveva.X, lineNumber.Aveva.Y, 0);

                commandParam.Add(point);

                commandParam.Add(lineNumber.Aveva.Angle);

                commandParam.Add(null);

            }

            else

                commandParam.Add(null);

            editor.Command(commandParam.ToArray());

            List<long> newHandles = GetAllGroupHandles();

            List<long> otherHandles = new List<long>();

            foreach (var item in newHandles)

                if (!prevHandles.Contains(item))

                    otherHandles.Add(item);

            if (otherHandles.Count == 1)

                return otherHandles[0];

            else

                return 0;

        }

        private long DrawPipe(string style, List<string> coordinates, ObjectId objectId)

        {

            List<long> prevHandles = GetAllGroupHandles();

            GUIUtils.SetPipeStyle(style);

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Editor editor = acDoc.Editor;

            List<object> commandParam = new List<object>();

            //command name

            commandParam.Add("DRPIPE");

            //coordinate

            foreach (var item in coordinates)

                commandParam.Add(item);

            //enter

            commandParam.Add(null);

            //Input Object ID

            commandParam.Add(objectId);

            //enter

            commandParam.Add(null);

            editor.Command(commandParam.ToArray());

            List<long> newHandles = GetAllGroupHandles();

            List<long> otherHandles = new List<long>();

            foreach (var item in newHandles)

                if (!prevHandles.Contains(item))

                    otherHandles.Add(item);

            if (otherHandles.Count == 1)

                return otherHandles[0];

            else

                return 0;

        }

        private long DrawSignal(string style, List<string> coordinates)

        {

            List<long> prevHandles = GetAllGroupHandles();

            GUIUtils.SetPipeStyle(style);

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Editor editor = acDoc.Editor;

            List<object> commandParam = new List<object>();

            //command name

            commandParam.Add("VPESIGNAL");

            //coordinate

            foreach (var item in coordinates)

                commandParam.Add(item);

            //enter

            commandParam.Add(null);

            editor.Command(commandParam.ToArray());

            List<long> newHandles = GetAllGroupHandles();

            List<long> otherHandles = new List<long>();

            foreach (var item in newHandles)

                if (!prevHandles.Contains(item))

                    otherHandles.Add(item);

            if (otherHandles.Count == 1)

                return otherHandles[0];

            else

                return 0;

        }

        private long DrawSymbol(Symbol symbol, DataRow symbolRow, bool needAngle, bool needBalloon)

        {

            long handle = 0;

            try

            {

                string insertSymbolName = symbol.Aveva.Name;

                double x = symbol.Aveva.X;

                double y = symbol.Aveva.Y;

                List<long> prevHandles = GetAllBlockHandlesByName(insertSymbolName);

                AVEVA.PID.Utilities.DrawingData drawingData = new AVEVA.PID.Utilities.DrawingData();

                drawingData.InsertSymbolName = insertSymbolName;

                Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

                Editor editor = acDoc.Editor;

                List<object> commandParam = new List<object>();

                commandParam.Add("INSSYM");

                // Insert Point

                Point3d point = new Point3d(x, y, 0);

                commandParam.Add(point);

                // Check Insert Point

                if (needAngle)

                {

                    double degree = RadianToDegree(symbol.ANGLE);

                    commandParam.Add(degree);

                }

                // Check Balloon

                if (needBalloon)

                {

                    point = new Point3d(x + 20, y + 20, 0);

                    commandParam.Add(point);

                    // Check LeaderLine

                    if (GraphicalUtility.IsLeaderReqOnSymbolBalloons())

                        commandParam.Add(x + "," + y);

                }

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

                    commandParam.Add(null);

                editor.Command(commandParam.ToArray());

                List<long> newHandles = GetAllBlockHandlesByName(insertSymbolName);

                List<long> otherHandles = new List<long>();

                foreach (var item in newHandles)

                    if (!prevHandles.Contains(item))

                        otherHandles.Add(item);

                if (otherHandles.Count == 1)

                    return otherHandles[0];

                else

                    return 0;

            }

            catch (System.Exception ex)

            {

            }

            return handle;

        }

        private void DrawText(double x, double y, double height, string text, double rotation)

        {

            // Get the current document and database

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Database acCurDb = acDoc.Database;

            // Start a transaction

            using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())

            {

                // Open the Block table for read

                BlockTable acBlkTbl;

                acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId,

                                                OpenMode.ForRead) as BlockTable;

                // Open the Block table record Model space for write

                BlockTableRecord acBlkTblRec;

                acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace],

                                                OpenMode.ForWrite) as BlockTableRecord;

                // Create a single-line text object

                using (DBText acText = new DBText())

                {

                    acText.Position = new Point3d(x, y, 0);

                    acText.Height = height;

                    acText.TextString = text;

                    acText.Rotation = rotation;

                    acBlkTblRec.AppendEntity(acText);

                    acTrans.AddNewlyCreatedDBObject(acText, true);

                }

                // Save the changes and dispose of the transaction

                acTrans.Commit();

            }

        }

        #endregion

        #region Autocad Utils

        private List<long> GetAllBlockHandlesByName(string name)

        {

            List<long> handles = new List<long>();

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Database acCurDb = acDoc.Database;

            using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())

            {

                BlockTable gd = (BlockTable)acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead);

                foreach (var entry in gd)

                {

                    BlockTableRecord blockTableRecord = acTrans.GetObject(entry, OpenMode.ForRead, true) as BlockTableRecord;

                    if (blockTableRecord != null)

                    {

                        IEnumerable<BlockReference> records = AcDbLinqExtensionMethods.GetBlockReferences(blockTableRecord);

                        foreach (var item in records)

                        {

                            if (item.Name == name)

                                handles.Add(item.Handle.Value);

                        }

                    }

                }

                acTrans.Commit();

            }

            return handles;

        }

        private List<long> GetAllGroupHandles()

        {

            List<long> handles = new List<long>();

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Database acCurDb = acDoc.Database;

            using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())

            {

                DBDictionary gd = (DBDictionary)acTrans.GetObject(acCurDb.GroupDictionaryId, OpenMode.ForRead);

                foreach (var entry in gd)

                    handles.Add(entry.Value.Handle.Value);

                acTrans.Commit();

            }

            return handles;

        }

        private ObjectId GetFirstPolyLineObjectId(long groupHandle)

        {

            ObjectId result = ObjectId.Null;

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Database acCurDb = acDoc.Database;

            using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())

            {

                DBDictionary gd = (DBDictionary)acTrans.GetObject(acCurDb.GroupDictionaryId, OpenMode.ForRead);

                foreach (var entry in gd)

                {

                    if (entry.Value.Handle.Value == groupHandle)

                    {

                        Autodesk.AutoCAD.DatabaseServices.Group group = acTrans.GetObject(entry.Value, OpenMode.ForRead) as Autodesk.AutoCAD.DatabaseServices.Group;

                        foreach (var item in group.GetAllEntityIds())

                        {

                            if (acTrans.GetObject(item, OpenMode.ForRead).GetType() == typeof(Autodesk.AutoCAD.DatabaseServices.Polyline))

                            {

                                result = item;

                                break;

                            }

                        }

                        break;

                    }

                }

                acTrans.Commit();

            }

            return result;

        }

        private void SetBlockReferenceRotation(ObjectId objectId, double rotation)

        {

            Autodesk.AutoCAD.ApplicationServices.Document acDoc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;

            Database acCurDb = acDoc.Database;

            Editor acDocEd = acDoc.Editor;

            using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())

            {

                DBObject objDB = acTrans.GetObject(objectId, OpenMode.ForWrite);

                if (objDB != null)

                {

                    if (objDB.GetType() == typeof(BlockReference))

                    {

                        BlockReference block = objDB as BlockReference;

                        block.Rotation = rotation;

                    }

                }

                acTrans.Commit();

            }

        }

        #endregion

        #region For Aveva

        private void SetAttributeByAvevaForm(long handle, List<Tuple<string, string>> datas)

        {

            Entity entity = APIDUtils.GetEntityByHandle(handle);

            ComponentPropertiesHelper componentPropertiesHelper = new ComponentPropertiesHelper();

            AvevaThread.Run(ThreadType.AddProperty, datas);

            if (!componentPropertiesHelper.DisplayComponentProperties(entity))

                AvevaThread.Stop(ThreadType.AddProperty);

        }

        #endregion

        #region Modeling Utils

        private void GetConnectedGroupLine(Model.Line line, List<Model.Line> group, bool isInsert)

        {

            if (!group.Contains(line))

            {

                if (isInsert)

                    group.Insert(0, line);

                else

                    group.Add(line);

                if (line.CONNECTORS[0].ConnectedObject != null && !IsExistEndBreak(line, line.CONNECTORS[0].ConnectedObject))

                {

                    object connObj = line.CONNECTORS[0].ConnectedObject;

                    if (connObj.GetType() == typeof(Model.Line) &&

                        APIDUtils.IsConnectedLine(connObj as Model.Line, line))

                        GetConnectedGroupLine(connObj as Model.Line, group, true);

                    else if (connObj.GetType() == typeof(Model.Symbol))

                    {

                        Model.Line connLine = FindOtherLineByRun(line, connObj as Symbol);

                        if (connLine != null)

                            GetConnectedGroupLine(connLine as Model.Line, group, true);

                    }

                }

                if (line.CONNECTORS[1].ConnectedObject != null && !IsExistEndBreak(line, line.CONNECTORS[1].ConnectedObject))

                {

                    object connObj = line.CONNECTORS[1].ConnectedObject;

                    if (connObj.GetType() == typeof(Model.Line) &&

                        APIDUtils.IsConnectedLine(connObj as Model.Line, line))

                        GetConnectedGroupLine(connObj as Model.Line, group, false);

                    else if (connObj.GetType() == typeof(Model.Symbol))

                    {

                        Model.Line connLine = FindOtherLineByRun(line, connObj as Symbol);

                        if (connLine != null)

                            GetConnectedGroupLine(connLine as Model.Line, group, false);

                    }

                }

            }

        }

        private void GetGroupLinePoints(List<Model.Line> groupLine, List<string> points)

        {

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

            {

                Model.Line line = groupLine[i];

                if (i == 0)

                {

                    object connObj = line.CONNECTORS[0].ConnectedObject;

                    if (connObj != null)

                    {

                        string point = GetPointByConnectedItem(connObj, line, true);

                        if (string.IsNullOrEmpty(point))

                            points.Add(line.Aveva.Start_X + "," + line.Aveva.Start_Y);

                        else

                            points.Add(point);

                    }

                    else

                        points.Add(line.Aveva.Start_X + "," + line.Aveva.Start_Y);

                }

                else

                {

                    Model.Line prevLine = groupLine[i - 1];

                    if (line.SlopeType == SlopeType.HORIZONTAL &&

                        prevLine.SlopeType == SlopeType.VERTICAL)

                        points.Add(prevLine.Aveva.End_X + "," + line.Aveva.Start_Y);

                    else if (line.SlopeType == SlopeType.VERTICAL &&

                        prevLine.SlopeType == SlopeType.HORIZONTAL)

                        points.Add(line.Aveva.Start_X + "," + prevLine.Aveva.End_Y);

                    else

                        points.Add(line.Aveva.Start_X + "," + line.Aveva.Start_Y);

                }

                if (i == groupLine.Count - 1)

                {

                    object connObj = line.CONNECTORS[1].ConnectedObject;

                    if (connObj != null)

                    {

                        string point = GetPointByConnectedItem(connObj, line, false);

                        if (string.IsNullOrEmpty(point))

                            points.Add(line.Aveva.End_X + "," + line.Aveva.End_Y);

                        else

                            points.Add(point);

                    }

                    else

                        points.Add(line.Aveva.End_X + "," + line.Aveva.End_Y);

                }

            }

        }

        private void CoordinateCorrection(List<Model.Line> groupLine)

        {

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

            {

                Model.Line line = groupLine[i];

                Model.Line line2 = null;

                if (i + 1 < groupLine.Count)

                    line2 = groupLine[i + 1];

                if (line2 != null)

                {

                    if (APIDUtils.IsConnectedLine(line, line2))

                    {

                        #region ConnLine corrdinate

                        if (line.SlopeType == SlopeType.HORIZONTAL && line2.SlopeType == SlopeType.VERTICAL)

                        {

                            line2.Aveva.Start_X = line.Aveva.End_X;

                            line2.Aveva.End_X = line.Aveva.End_X;

                        }

                        else if (line.SlopeType == SlopeType.VERTICAL && line2.SlopeType == SlopeType.HORIZONTAL)

                        {

                            line2.Aveva.Start_Y = line.Aveva.End_Y;

                            line2.Aveva.End_Y = line.Aveva.End_Y;

                        }

                        else if (line.SlopeType == SlopeType.HORIZONTAL && line2.SlopeType == SlopeType.HORIZONTAL)

                        {

                            line2.Aveva.Start_Y = line.Aveva.End_Y;

                            line2.Aveva.End_Y = line.Aveva.End_Y;

                        }

                        else if (line.SlopeType == SlopeType.VERTICAL && line2.SlopeType == SlopeType.VERTICAL)

                        {

                            line2.Aveva.Start_X = line.Aveva.End_X;

                            line2.Aveva.End_X = line.Aveva.End_X;

                        }

                        #endregion

                    }

                    else

                    {

                        SlopeType slopeType = APIDUtils.CalcSlope(line.Aveva.End_X, line.Aveva.End_Y, line2.Aveva.Start_X, line2.Aveva.Start_Y);

                        #region corrdinate

                        if (slopeType == SlopeType.HORIZONTAL && line.SlopeType == SlopeType.HORIZONTAL && line2.SlopeType == SlopeType.HORIZONTAL)

                        {

                            line2.Aveva.Start_Y = line.Aveva.End_Y;

                            line2.Aveva.End_Y = line.Aveva.End_Y;

                        }

                        else if (slopeType == SlopeType.VERTICAL && line.SlopeType == SlopeType.VERTICAL && line2.SlopeType == SlopeType.VERTICAL)

                        {

                            line2.Aveva.Start_X = line.Aveva.End_X;

                            line2.Aveva.End_X = line.Aveva.End_X;

                        }

                        #endregion

                    }

                }

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

                {

                    foreach (var connector in line.CONNECTORS.FindAll(loop => loop.ConnectedObject != null))

                    {

                        double lineX = 0;

                        double lineY = 0;

                        int index = line.CONNECTORS.IndexOf(connector);

                        if (index == 0)

                        {

                            lineX = line.Aveva.End_X;

                            lineY = line.Aveva.End_Y;

                        }

                        else

                        {

                            lineX = line.Aveva.Start_X;

                            lineY = line.Aveva.Start_Y;

                        }

                        System.Type type = connector.ConnectedObject.GetType();

                        if (type == typeof(Model.Symbol))

                        {

                            Symbol item = connector.ConnectedObject as Symbol;

                            SlopeType slopeType = APIDUtils.CalcSlope(item.Aveva.X, item.Aveva.Y, lineX, lineY);

                            if (slopeType == line.SlopeType)

                            {

                                if (line.SlopeType == SlopeType.HORIZONTAL)

                                    item.Aveva.Y = line.Aveva.End_Y;

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

                                    item.Aveva.X = line.Aveva.End_X;

                            }

                        }

                        else if (type == typeof(OPC))

                        {

                            OPC item = connector.ConnectedObject as OPC;

                            SlopeType slopeType = APIDUtils.CalcSlope(item.Aveva.X, item.Aveva.Y, lineX, lineY);

                            if (slopeType == line.SlopeType)

                            {

                                if (line.SlopeType == SlopeType.HORIZONTAL)

                                    item.Aveva.Y = line.Aveva.End_Y;

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

                                    item.Aveva.X = line.Aveva.End_X;

                            }

                        }

                    }

                }

            }

        }

        private string GetPointByConnectedItem(object connObj, Model.Line line, bool isStart)

        {

            string result = string.Empty;

            double x;

            double y;

            if (isStart)

            {

                x = line.Aveva.Start_X;

                y = line.Aveva.Start_Y;

            }

            else

            {

                x = line.Aveva.End_X;

                y = line.Aveva.End_Y;

            }

            if (connObj.GetType() == typeof(Symbol))

            {

                Symbol connSymbol = connObj as Symbol;

                Connector connector = connSymbol.CONNECTORS.Find(loop => loop.ConnectedObject == line);

                SlopeType slopeType = APIDUtils.CalcSlope(connSymbol.X, connSymbol.Y, connector.X, connector.Y);

                if (slopeType == SlopeType.HORIZONTAL)

                    result = connSymbol.Aveva.X + "," + y;

                else if (slopeType == SlopeType.VERTICAL)

                    result = x + "," + connSymbol.Aveva.Y;

                else

                    result = x + "," + y;

            }

            else if (connObj.GetType() == typeof(OPC))

            {

                OPC connOPC = connObj as OPC;

                Connector connector = connOPC.CONNECTORS.Find(loop => loop.ConnectedObject == line);

                double locX = 0, locY = 0, sizeWidth = 0, sizeHeight = 0, aX = 0, aY = 0;

                APIDUtils.ConvertPointBystring(connOPC.LOCATION, ref locX, ref locY);

                APIDUtils.ConvertPointBystring(connOPC.SIZE, ref sizeWidth, ref sizeHeight);

                locX = locX + sizeWidth / 2;

                locY = locY + sizeHeight / 2;

                aX = locX;

                aY = locY;

                document.ConvertAvevaPoint(ref aX, ref aY);

                SlopeType slopeType = APIDUtils.CalcSlope(locX, locY, connector.X, connector.Y);

                if (slopeType == SlopeType.HORIZONTAL)

                    result = aX + "," + y;

                else if (slopeType == SlopeType.VERTICAL)

                    result = x + "," + aY;

                else

                    result = x + "," + y;

            }

            return result;

        }

        private bool IsExistEndBreak(object item1, object item2)

        {

            bool result = false;

            if (item1 != null && item2 != null)

            {

                EndBreak endBreak = document.EndBreaks.Find(x =>

            (APIDUtils.FindObjectByUID(document, x.OWNER) == item1 &&

            APIDUtils.FindObjectByUID(document, x.PROPERTIES.Find(y => y.ATTRIBUTE == "Connected Item").VALUE) == item2) ||

            (APIDUtils.FindObjectByUID(document, x.OWNER) == item2 &&

            APIDUtils.FindObjectByUID(document, x.PROPERTIES.Find(y => y.ATTRIBUTE == "Connected Item").VALUE) == item1));

                if (endBreak != null)

                    result = true;

            }

            return result;

        }

        private LineRun FindLineRun(Model.Line line)

        {

            List<LineRun> allLineRun = new List<LineRun>();

            foreach (var item in document.LINENUMBERS)

                allLineRun.AddRange(item.RUNS);

            foreach (var item in document.TRIMLINES)

                allLineRun.AddRange(item.RUNS);

            return allLineRun.Find(x => x.RUNITEMS.Contains(line));

        }

        private Model.Line FindOtherLineByRun(Model.Line line, Symbol symbol)

        {

            Model.Line result = null;

            LineRun run = FindLineRun(line);

            Connector connector = symbol.CONNECTORS.Find(x =>

            x.ConnectedObject != null &&

            x.ConnectedObject != line &&

            run.RUNITEMS.Contains(x.ConnectedObject) &&

            x.ConnectedObject.GetType() == typeof(Model.Line));

            if (connector != null)

                result = connector.ConnectedObject as Model.Line;

            return result;

        }

        private bool CheckAngle(DataRow symbolRow)

        {

            return int.Parse(symbolRow["Insert_Points"].ToString()).Equals(2);

        }

        private bool CheckBalloon(Symbol symbol)

        {

            bool result = false;

            string text = string.Empty;

            Hashtable symbolDefinitions = GraphicsUtility.GetSymbolDefinitions(symbol.Aveva.Name);

            if (symbolDefinitions.Count != 0)

            {

                text = symbolDefinitions[SymbolDefinition.symAflowType].ToString().ToUpper();

                if (text.Equals("VLP"))

                    text = "VPO";

                else if (text.Equals("IVP"))

                    text = "IPO";

                if (SymbolCategory.astrLabelBalloonBlockNames.Contains(text))

                    result = true;//dumbDwgUpgrade.addLabelBalloon(symbolForInsertion, objectId);

            }

            return result;

        }

        private double RadianToDegree(double angle)

        {

            return angle * (180.0 / Math.PI);

        }

        #endregion

        #region Test Source

        public void test()

        {

        }

        public static void TESTStatic(long handle)

        {

        }

        #endregion

    }

    public static class AcDbLinqExtensionMethods

    {

        /// <summary>

        /// Get all references to the given BlockTableRecord, including 

        /// references to anonymous dynamic BlockTableRecords.

        /// </summary>

        public static IEnumerable<BlockReference> GetBlockReferences(

           this BlockTableRecord btr,

           OpenMode mode = OpenMode.ForRead,

           bool directOnly = true)

        {

            if (btr == null)

                throw new ArgumentNullException("btr");

            var tr = btr.Database.TransactionManager.TopTransaction;

            if (tr == null)

                throw new InvalidOperationException("No transaction");

            var ids = btr.GetBlockReferenceIds(directOnly, true);

            int cnt = ids.Count;

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

            {

                yield return (BlockReference)

                   tr.GetObject(ids[i], mode, false, false);

            }

            if (btr.IsDynamicBlock)

            {

                BlockTableRecord btr2 = null;

                var blockIds = btr.GetAnonymousBlockIds();

                cnt = blockIds.Count;

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

                {

                    btr2 = (BlockTableRecord)tr.GetObject(blockIds[i],

                       OpenMode.ForRead, false, false);

                    ids = btr2.GetBlockReferenceIds(directOnly, true);

                    int cnt2 = ids.Count;

                    for (int j = 0; j < cnt2; j++)

                    {

                        yield return (BlockReference)

                           tr.GetObject(ids[j], mode, false, false);

                    }

                }

            }

        }

    }

}