CClass

using System.
IO;
using System.Windows.Forms;
using System;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using GenXCTool.utils;
using System.Collections;
using Application = Autodesk.AutoCAD.ApplicationServices.Application;
using Polyline = Autodesk.AutoCAD.DatabaseServices.Polyline;
using System.Collections.Generic;
using System.Data.SQLite;
using Autodesk.AutoCAD.ApplicationServices;
using System.Data;
using Exception = System.Exception;

using OpenMode = Autodesk.AutoCAD.DatabaseServices.OpenMode;
using System.Linq;
using System.Net;
using System.Xml;
using Autodesk.AutoCAD.GraphicsInterface;
using Viewport = Autodesk.AutoCAD.DatabaseServices.Viewport;
using Autodesk.AutoCAD.Runtime;
using Calculator;
using System.Text.RegularExpressions;
using Excel = Microsoft.Office.Interop.Excel;

using System.Xml.Linq;
using GenXCTool.Ruisel.BaldwinCommands;
using Autodesk.AutoCAD.Customization;
namespace GenXCTool.Class
{
public class CClass
{
}
public class CTable_Excel

{
static public List<string> GetSheetNames(string excelFileName)
{
var listSheets = new List<string>();
var excel = new Excel.Application();
var wbs = excel.Workbooks.Open(excelFileName);
foreach (Excel.Worksheet sheet in wbs.Worksheets)

{
listSheets.Add(sheet.Name);
}
excel.Quit();
return listSheets;
}
static public void TableFromSpreadsheet(string Arc, int She, string Ran,

Point3d Pc)
{
string dlName = "Import table from Excel";
var doc = Application.DocumentManager.MdiActiveDocument;
var db = doc.Database;
var ed = doc.Editor;
doc.LockDocument();
var sheetNames = GetSheetNames(Arc);
var dlm = db.DataLinkManager;
var dlId = dlm.GetDataLink(dlName);
if (dlId != ObjectId.Null)
{
dlm.RemoveDataLink(dlId);
var dl = new DataLink();
dl.DataAdapterId = "AcExcel";
dl.Name = dlName;
//dl.Description = "Excel fun with Through the Interface";
dl.ConnectionString = Arc + "!" + sheetNames[She - 1] + "!" + Ran;
//ed.WriteMessage("\n" + dl.ConnectionString);
dl.DataLinkOption = DataLinkOption.PersistCache;
dl.UpdateOption |= (int)UpdateOption.AllowSourceUpdate;
dlId = dlm.AddDataLink(dl);
using (var tr = doc.TransactionManager.StartTransaction())

{
tr.AddNewlyCreatedDBObject(dl, true);
var bt = (BlockTable)tr.GetObject(db.BlockTableId,
OpenMode.ForRead);
var tb = new Autodesk.AutoCAD.DatabaseServices.Table();
//tb.TableStyle = db.Tablestyle;
tb.Position = Pc;
//tb.Cells.TextHeight = 0.14;
tb.Cells.SetDataLink(dlId, true);
tb.GenerateLayout();
tb.Width = 2;
var btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId,

OpenMode.ForWrite);
btr.AppendEntity(tb);
tr.AddNewlyCreatedDBObject(tb, true);
tr.Commit();
}
}
public void TableFromSpreadsheet5(string Arc, int She, string Ran, Point3d

Pc)
{
//b
CTransaction Trans = new CTransaction();
Trans.Start_Trans();
Trans.document.LockDocument();
const string dlName = "Example";
// Ask the user to select an XLS(X) file
/* var ofd = new Autodesk.AutoCAD.Windows.OpenFileDialog( "Select Excel

spreadsheet to link",null,"xls;
xlsx","ExcelFileToLink",Autodesk.AutoCAD.Windows.OpenFileDialog.OpenFileDialogFlags
. DoNotTransferRemoteFiles);
var dr = ofd.ShowDialog();
if (dr != System.Windows.Forms.DialogResult.OK)
return;*/
// Display the name of the file and the contained sheets
Trans.editor.WriteMessage("\nFile selected was \"{0}\". Contains these

sheets:",Arc);
// First we get the sheet names
if (sheetNames.Count == 0)
{
Trans.editor.WriteMessage("\nWorkbook doesn't contain any

sheets.");
return;
}
// And loop through, printing their names
for (int i = 0; i < sheetNames.Count; i++)

{
var name = sheetNames[i];
Trans.editor.WriteMessage("\n{0} - {1}", i + 1, name);

}
// Ask the user to select one
/* var pio = new PromptIntegerOptions("\nSelect a sheet");
pio.AllowNegative = false;
pio.AllowZero = false;
pio.DefaultValue = 1;
pio.UseDefaultValue = true;
pio.LowerLimit = 1;
pio.UpperLimit = sheetNames.Count;
var pir = ed.GetInteger(pio);
if (pir.Status != PromptStatus.OK)
return;*/
// Ask the user to select a range of cells in the spreadsheet
// We'll use a Regular Expression that matches a column (with
// one or more letters) followed by a numeric row (which we're
// naming "row1" so we can validate it's > 0 later),
// followed by a colon and then the same (but with "row2")
const string rangeExp ="^[A-Z]+(?<row1>[0-9]+):[A-Z]+(?<row2>[0-9]+)$";
bool done = false;
string range = "";
/*do
{*/
/* var psr = ed.GetString("\nEnter cell range <entire sheet>");
if (psr.Status != PromptStatus.OK)
return;
if (String.IsNullOrEmpty(psr.StringResult))
{
// Default is to select entire sheet
done = true;
}*/
/*else*/
{
// If a string was entered, make sure it's a
// valid cell range, which means it matches the
// Regular Expression and has positive (non-zero)
// row numbers
var m =Regex.Match( Ran, rangeExp, RegexOptions.IgnoreCase);
//if (m.Success && Int32.Parse(m.Groups["row1"].Value) > 0 &&

Int32.Parse(m.Groups["row2"].Value) > 0)
{
done = true;
range = Ran.ToUpper();
// else
{
Trans.editor.WriteMessage("\nInvalid range, please try

again.");
/* } while (!done);*/
// Ask for the insertion point of the table
/* var ppr = ed.GetPoint("\nEnter table insertion point");
if (ppr.Status != PromptStatus.OK)
return;*/
try
{
// Remove any Data Link, if one exists already
var dlm = Trans.database.DataLinkManager;
var tb = new Table();
tb.TableStyle = Trans.database.Tablestyle;
tb.Position = Pc;
//tb.Cells.SetDataLink(dlId, true);
Trans.Insert(tb);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
Trans.End_Trans();
}
public void TableFromSpreadsheet3(ObjectId Idt, Point3d Pc, CTransaction

Trans)
{
tb.Position = Pc;
tb.UpgradeOpen();
Trans.Insert(tb);
tb.Cells.SetDataLink(Idt, false);
public void SaveDatalink(string Arc, int She, string Ran)

{
string dlName = "Example";

{
// Create and add the new Data Link, this time with
// a direction connection to the selected sheet
dl.Name = dlName;
dl.Description = "Excel fun with Through the Interface";
dl.ConnectionString = Arc + "!" + sheetNames[She - 1] + "!" +

Ran.ToUpper();
CTable_Excel E = new CTable_Excel();
E.TableFromSpreadsheet3(dlId, new Point3d(0, 0, 0), Trans);
Trans.End_Trans();
}
public void TableFromSpreadsheet2(string Arc, int She, string Ran, Point3d

Pc)
{
Trans.document.LockDocument();
const string dlName = "Example";
// Ask the user to select an XLS(X) file

/* var ofd = new Autodesk.AutoCAD.Windows.OpenFileDialog( "Select Excel
spreadsheet to link",null,"xls;
xlsx","ExcelFileToLink",Autodesk.AutoCAD.Windows.OpenFileDialog.OpenFileDialogFlags
. DoNotTransferRemoteFiles);
var dr = ofd.ShowDialog();
if (dr != System.Windows.Forms.DialogResult.OK)
return;*/
// Display the name of the file and the contained sheets
Trans.editor.WriteMessage("\nFile selected was \"{0}\". Contains these

sheets:", Arc);
// First we get the sheet names
if (sheetNames.Count == 0)
{
Trans.editor.WriteMessage("\nWorkbook doesn't contain any

sheets.");
return;
// And loop through, printing their names
for (int i = 0; i < sheetNames.Count; i++)

{
var name = sheetNames[i];
Trans.editor.WriteMessage("\n{0} - {1}", i + 1, name);

}
// Ask the user to select one
/* var pio = new PromptIntegerOptions("\nSelect a sheet");
pio.AllowNegative = false;
pio.AllowZero = false;
pio.DefaultValue = 1;
pio.UseDefaultValue = true;
pio.LowerLimit = 1;
pio.UpperLimit = sheetNames.Count;
var pir = ed.GetInteger(pio);
if (pir.Status != PromptStatus.OK)
return;*/
// Ask the user to select a range of cells in the spreadsheet
// We'll use a Regular Expression that matches a column (with
// one or more letters) followed by a numeric row (which we're
// naming "row1" so we can validate it's > 0 later),
// followed by a colon and then the same (but with "row2")
const string rangeExp = "^[A-Z]+(?<row1>[0-9]+):[A-Z]+(?<row2>[0-9]+)

$";
bool done = false;
string range = "";
/*do
{*/
/* var psr = ed.GetString("\nEnter cell range <entire sheet>");
if (psr.Status != PromptStatus.OK)
return;
if (String.IsNullOrEmpty(psr.StringResult))
{
// Default is to select entire sheet
done = true;
}*/
/*else*/
{
// If a string was entered, make sure it's a
// valid cell range, which means it matches the
// Regular Expression and has positive (non-zero)
// row numbers
var m = Regex.Match(Ran, rangeExp, RegexOptions.IgnoreCase);
//if (m.Success && Int32.Parse(m.Groups["row1"].Value) > 0 &&

Int32.Parse(m.Groups["row2"].Value) > 0)
{
done = true;
range = Ran.ToUpper();
// else
{
Trans.editor.WriteMessage("\nInvalid range, please try

again.");
/* } while (!done);*/
// Ask for the insertion point of the table
/* var ppr = ed.GetPoint("\nEnter table insertion point");
return;*/
{
// Create and add the new Data Link, this time with
// a direction connection to the selected sheet
dl.Name = dlName;
dl.Description = "Excel fun with Through the Interface";
dl.ConnectionString = Arc + "!" + sheetNames[She - 1] + "!" +

Ran.ToUpper();
try
{
// Remove any Data Link, if one exists already
tb.Position = Pc;
//tb.Cells.SetDataLink(dlId, true);
Trans.Insert(tb);
}
{
}
Trans.End_Trans();
}
public class Point2

{
public Point3d LatLongFromPoint2(Point3d P)
{
var lonlat = TranslateGeoPoint(db, P, true);

var p = new Point3d(lonlat.X, lonlat.Y, 0);
return p;
}
//public Point2d LatLongFromPoint2(Point2d P)

//{
// var doc = Application.DocumentManager.MdiActiveDocument;
// var ed = doc.Editor;
// var db = doc.Database;
// var lonlat = TranslateGeoPoint(db, P, true);

// var p = new Point2d(lonlat.X, lonlat.Y);
// return p;
//}
public Point3d LatLongFromPoint2d(Point3d P)

{

var p = new Point3d(lonlat.X, lonlat.Y, 0);
return p;
}
private Point3d TranslateGeoPoint(Database db, Point3d inPt, bool fromDwg)

{
using (var tr = db.TransactionManager.StartOpenCloseTransaction())
{
// Get the drawing's GeoLocation object
var gd = tr.GetObject(db.GeoDataObject, OpenMode.ForRead) as

GeoLocationData;
// Get the output point...

// dwg2lonlat if fromDwg is true,
// lonlat2dwg otherwise
var outPt = (fromDwg ? gd.TransformToLonLatAlt(inPt) :

gd.TransformFromLonLatAlt(inPt));
tr.Commit();
return outPt;
}
}
public Point3d PointFromLatLong(Point3d Point)

{
// Translate the lat-lon to a drawing point
var dwgPt = TranslateGeoPoint(db, Point, false);

return dwgPt;
}
public Point2d Point2FromLatLon(Point3d Point)

{

Point2d p2 = new Point2d(dwgPt.X, dwgPt.Y);
return p2;
}
public string getBetween(string Data, string St, string En)

{
int Start, End;
if (Data.Contains(St) && Data.Contains(En))
{
Start = Data.IndexOf(St, 0) + St.Length;
End = Data.IndexOf(En, Start);
return Data.Substring(Start, End - Start);
}
else
{
return "";
}
}
public void InsertGeoRef(Point3d PC)

{
if (doc == null)
return;
var msId = SymbolUtilityServices.GetBlockModelSpaceId(db);
bool hasGeoData = false;
try
{
var gdId = db.GeoDataObject;
hasGeoData = true;
}
catch { }
if (hasGeoData)
{
ed.WriteMessage("\nDrawing already has geo-location data!");
return;
}
var data = new GeoLocationData();
data.BlockTableRecordId = msId;
data.PostToDb();
data.CoordinateSystem = "WORLD-MERCATOR";
data.TypeOfCoordinates = TypeOfCoordinates.CoordinateTypeGrid;
var wcsPt = data.TransformFromLonLatAlt(PC);
data.DesignPoint = wcsPt;
data.ReferencePoint = PC;
}
public class BClass

{
CTransaction CT = new CTransaction();
public double BulgeFromCurve(Curve cv, bool clockwise)

{
double bulge = 0.0;
Arc a = cv as Arc;
if (a != null)
{
double newStart;
if (a.StartAngle > a.EndAngle)

{
newStart = a.StartAngle - 8 * Math.Atan(1);
}
else
{
newStart = a.StartAngle;
}
bulge = Math.Tan((a.EndAngle - newStart) / 4);
if (clockwise)
{
bulge = -bulge;
}
}
return bulge;
}
public Point2d ArcCentroid(Point2d start, Point2d end, Point2d cen, double
tmpArea)
{
double chord = start.GetDistanceTo(end);
double angle = (end - start).Angle;
return Polar2d(cen, angle - (Math.PI / 2.0), (chord * chord * chord) /
(12.0 * tmpArea));
}
public double ArcAlgebricArea(double rad, double ang)

{
return rad * rad * (ang - Math.Sin(ang)) / 2.0;
}
public Point2d Polar2d(Point2d org, double angle, double distance)
{
return org + new Vector2d(distance * Math.Cos(angle), distance *
Math.Sin(angle));
}
public double[] GetArcGeom(Polyline pl, double bulge, int index1, int
index2)
{
CircularArc2d arc = (pl.GetArcSegment2dAt(index1));
double arcRadius = arc.Radius;
Point2d arcCenter = arc.Center;
double arcAngle = 4.0 * Math.Atan(bulge);
double tmpArea = ArcAlgebricArea(arcRadius, arcAngle);
Point2d tmpPoint = ArcCentroid(pl.GetPoint2dAt(index1),
pl.GetPoint2dAt(index2), arcCenter, tmpArea);
return new double[3] { tmpArea, tmpPoint.X, tmpPoint.Y };
}
public Point2d TriangleCentroid(Point2d p0, Point2d p1, Point2d p2)

{
return (p0 + p1.GetAsVector() + p2.GetAsVector()) / 3.0;
}
public double TriangleAlgebricArea(Point2d p0, Point2d p1, Point2d p2)

{
return (((p1.X - p0.X) * (p2.Y - p0.Y)) - ((p2.X - p0.X) * (p1.Y -
p0.Y))) / 2.0;
}
public Point3d GetCentroid(Polyline pl)
{
Point2d p0 = pl.GetPoint2dAt(0);
Point2d cen = new Point2d(0.0, 0.0);
double area = 0.0;
int last = pl.NumberOfVertices - 1;
double tmpArea;
Point2d tmpPoint;
if (pl.GetSegmentType(0) == SegmentType.Arc)
{
double[] datas = GetArcGeom(pl, pl.GetBulgeAt(0), 0, 1);
area = datas[0];
cen = new Point2d(datas[1], datas[2]) * datas[0];
}
for (int i = 1; i < last; i++)
{
tmpArea = TriangleAlgebricArea(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
tmpPoint = TriangleCentroid(p0, pl.GetPoint2dAt(i),
cen += (tmpPoint * tmpArea).GetAsVector();
area += tmpArea;
if (pl.GetSegmentType(i) == SegmentType.Arc)
{
double[] datas = GetArcGeom(pl, pl.GetBulgeAt(i), i, i + 1);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
}
if (pl.GetSegmentType(last) == SegmentType.Arc)
{
double[] datas = GetArcGeom(pl, pl.GetBulgeAt(last), last, 0);
area += datas[0];
}
cen = cen.DivideBy(area);
Point3d result = new Point3d(cen.X, cen.Y, pl.Elevation);
return result.TransformBy(Matrix3d.PlaneToWorld(pl.Normal));
}
}
public class CTransaction

{
public Editor editor;
public Autodesk.AutoCAD.ApplicationServices.Document document;
public Database database;
public BlockTable blockTable;
public LayerTable layerTable;
public Transaction transaction;
public BlockTableRecord blockTableRecordMe;
public BlockTableRecord blockTableRecordPe;
public DocumentLock documentloc;
public void Start_Trans()

{
document = Application.DocumentManager.MdiActiveDocument;
documentloc = document.LockDocument();
database = document.Database;
transaction = database.TransactionManager.StartTransaction();
blockTable = transaction.GetObject(database.BlockTableId,
OpenMode.ForWrite) as BlockTable;
layerTable = transaction.GetObject(database.LayerTableId,
OpenMode.ForWrite) as LayerTable;
blockTableRecordMe =
transaction.GetObject(blockTable[BlockTableRecord.ModelSpace], OpenMode.ForWrite)
as BlockTableRecord;
blockTableRecordPe =
transaction.GetObject(blockTable[BlockTableRecord.PaperSpace], OpenMode.ForWrite)
as BlockTableRecord;
editor = document.Editor;
}
public Point3dCollection Buffer(Polyline Route, double dist)

{
Point3dCollection buffer = new Point3dCollection();
List<Polyline> pllist = new List<Polyline>();
if (Route != null)
{
Polyline rute = Route.Clone() as Polyline;
if (dist > 0)
{
DBObjectCollection PloffSet1 = rute.GetOffsetCurves(dist);
rute.ReverseCurve();
DBObjectCollection PloffSet2 = rute.GetOffsetCurves(dist);
rute.ReverseCurve();
Polyline pl1buffer = new Polyline();
Polyline pl2buffer = new Polyline();
foreach (Polyline item in PloffSet1) pl1buffer = item;
foreach (Polyline item in PloffSet2) pl2buffer = item;
//Line ln = new Line(pl1buffer.EndPoint, pl2buffer.EndPoint);
//pl1buffer.JoinEntity(ln);
//pl1buffer.JoinEntity(pl2buffer);
//pl1buffer.Closed = true;
//REVISAR ESTO
//pl2buffer.ReverseCurve();
pllist.Add(pl1buffer);
pllist.Add(pl2buffer);
}
else
{
pllist.Add(rute);
}
foreach (Polyline PlB in pllist)
{
for (int i = 0; i < PlB.NumberOfVertices; i++)
{
buffer.Add(PlB.GetPoint3dAt(i));
if (PlB.GetPoint3dAt(i) !=
PlB.GetPoint3dAt(PlB.NumberOfVertices - 1))
{
if (PlB.GetSegmentType(i).ToString() == "Arc")
{
for (double j =
PlB.GetDistAtPoint(PlB.GetPoint3dAt(i)) + 1; j <
PlB.GetDistAtPoint(PlB.GetPoint3dAt(i + 1)); j++)
{
if (!buffer.Contains(PlB.GetPointAtDist(j)))
{
buffer.Add(PlB.GetPointAtDist(j));
}
}
}
}
}
if (PlB.Closed)
{
if (PlB.GetSegmentType(PlB.NumberOfVertices - 1).ToString()
== "Arc")
{
for (double j =
PlB.GetDistAtPoint(PlB.GetPoint3dAt(PlB.NumberOfVertices - 1)) + 1; j < PlB.Length;
j++)
{
buffer.Add(PlB.GetPointAtDist(j));
}
}
buffer.Add(PlB.EndPoint);
}
}
}
return buffer;
public Point3dCollection Buffer(Polyline rute, double dist, bool Draw)

{
Point3dCollection LBuffer = Buffer(rute, dist);
if (Draw)
{
Polyline pl = new Polyline();
foreach (Point3d item in LBuffer)
{
pl.AddVertexAt(pl.NumberOfVertices, item.Convert2d(new
Plane()), 0, 0, 0);
}
Insert(pl, true);
}
return LBuffer;
}
public void End_Trans()

{
editor.Regen();
transaction.Commit();
transaction.Dispose();
}
public void Restart_Trans()

{
End_Trans();
Start_Trans();
}
public void Insert(Line OB, bool M)

{
if (M)
{
blockTableRecordMe.AppendEntity(OB);
}
else
{
blockTableRecordPe.AppendEntity(OB);
}
transaction.AddNewlyCreatedDBObject(OB, true);
}
public void Hyper(Entity ent, string description, string name, string

sublocation)
{
HyperLinkCollection linkCollection = ent.Hyperlinks;
HyperLink hyperLink = new HyperLink();
hyperLink.Description = description;
hyperLink.Name = name;
hyperLink.SubLocation = sublocation;
linkCollection.Add(hyperLink);
}
public void Insert(Polyline OB, bool M)

{
if (M)
else
}
public void Insert(BlockReference OB)

{
if (Verify_Exist_Block(CBlock.GetBlockName(OB)))
{
}
else
{
MessageBox.Show("Error When Copying Or Inserting Block" + "\n" +
CBlock.GetBlockName(OB));
}
}
public void Insert(Point3d Location, String Block_Name, bool M)

{
if(Verify_Exist_Block(Block_Name))
{
BlockReference Br = new BlockReference(Location,
blockTable[Block_Name]);
if (M)
blockTableRecordMe.AppendEntity(Br);
else
blockTableRecordPe.AppendEntity(Br);
transaction.AddNewlyCreatedDBObject(Br, true);
}
else
{
Block_Name);
}
}
public void Insert(BlockReference OB, bool M)

{
string name = "";

if (Verify_Exist_Block(CBlock.GetBlockName(OB)))
{
name = CBlock.GetBlockName(OB);
BlockTableRecord blockDef =
blockTable[name].GetObject(OpenMode.ForRead) as BlockTableRecord;
if (M)
else
DynamicBlockReferencePropertyCollection pc =
OB.DynamicBlockReferencePropertyCollection;
foreach (ObjectId id2 in blockDef)

{
DBObject obj = id2.GetObject(OpenMode.ForRead);
if (obj is AttributeDefinition)
{
AttributeDefinition attDef = obj as AttributeDefinition;
using (AttributeReference attRef = new

AttributeReference())
{
attRef.SetAttributeFromBlock(attDef,
OB.BlockTransform);
attRef.Visible = true;
OB.AttributeCollection.AppendAttribute(attRef);
transaction.AddNewlyCreatedDBObject(attRef, true);
}
}
}
}
else
{
CBlock.GetBlockName(OB));
}
public void Insert(Circle OB, bool M)

{
if (M)
else
}
public void Insert(MText OB, bool M)
{
OB.Attachment = AttachmentPoint.MiddleCenter;
if (M)
else
}
public void Insert(Viewport OB, bool M)

{
if (M)
else
}
public void Insert(Table OB)

{
}
public void Insert(Entity OB, bool M)

{
if (M)
else
if (OB is BlockReference)
{
BlockReference blockReference = (BlockReference)OB;
string name = blockReference.IsDynamicBlock ?

((BlockTableRecord)blockReference.DynamicBlockTableRecord.GetObject(OpenMode.ForRea
d)).Name : blockReference.Name;
BlockTableRecord blockDef =
blockTable[name].GetObject(OpenMode.ForRead) as BlockTableRecord;
foreach (ObjectId id2 in blockDef)

{
DBObject obj = id2.GetObject(OpenMode.ForRead);
AttributeDefinition attDef = obj as AttributeDefinition;
if ((attDef != null))
{

{
blockReference.BlockTransform);
attRef.TextString = "";
blockReference.AttributeCollection.AppendAttribute(attRef);
transaction.AddNewlyCreatedDBObject(attRef, true);
}
}
}
}
else
{
}
}
public ObjectId Get(string Dialog, CTransaction Trans, string Typee)

{
ObjectId En = new ObjectId();
bool Select = false;
while (!Select)
{
PromptSelectionOptions promptPointOptions = new
PromptSelectionOptions();
promptPointOptions.MessageForAdding = (Dialog);
PromptSelectionResult selectLinesFollow =
Trans.editor.GetSelection(promptPointOptions);
if (selectLinesFollow.Status == PromptStatus.OK)
{
foreach (ObjectId Obj in
selectLinesFollow.Value.GetObjectIds())
{
DBObject entity = Trans.transaction.GetObject(Obj,
OpenMode.ForWrite);
if (entity.GetType().Name == Typee)
{
Select = true;
En = Obj;
}
else
{
MessageBox.Show("Type: " + entity.GetType().Name);
}
}
}
else
{
DialogResult result = MessageBox.Show("Do you want to cancel?",
"Cancel", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
break;
}
}
}
return En;
}
public List<ObjectId> Get_Multi(string Dialog, CTransaction Trans)

{
List <ObjectId> En = new List<ObjectId>();

promptPointOptions.MessageForAdding = (Dialog);
{
foreach (ObjectId Obj in selectLinesFollow.Value.GetObjectIds())
{
En.Add(Obj);
}
}
return En;
}
public void End_Trans(bool regen, bool dispose)

{
if (regen) editor.Regen();
if (dispose) transaction.Dispose();
}
public bool Verify_Exist_Block(string Block_Name)

{
bool Find = false;
// Check each block in the block table

foreach (ObjectId BlockTableRecord_Id in blockTable)
{
BlockTableRecord Blocktablerecord =
(BlockTableRecord)transaction.GetObject(BlockTableRecord_Id, OpenMode.ForRead,
false);
// Only add named & non-layout blocks to the copy list

if (!Blocktablerecord.IsAnonymous && !Blocktablerecord.IsLayout &&
Blocktablerecord.Name == Block_Name)
Find = true;
}
if(!Find)
{
if (Copy_Block(Block_Name))
{
return true;
}
else
{
return false;
}
}
else
{
return true;
}
}
public bool Verify_Exist_Layer(string Layer_Name)

{
CLayer CLAYERS = new CLayer();
bool Find = false;
ArrayList Layers = CLAYERS.GetLayerName();
foreach(string S in Layers)
{
if (S == Layer_Name)
{
Find = true;
}
}
if (!Find)
{
if (Copy_Layer(Layer_Name))
{
return true;
}
else
{
return false;
}
}
else
{
return true;
}
}
public bool Copy_Block(string Block_Name)

{
CDatabase Db = new CDatabase
{
DataSource = @"C:\GenXCTool\DBS\UpdateCheking.db"
};
System.Data.DataTable Dt = Db.Select("Select * From OneDrive");
string Dir = Dt.Rows[0][0].ToString();
bool RETURN = false;

DocumentCollection Document_Collect = Application.DocumentManager;
Editor EDITOR = Document_Collect.MdiActiveDocument.Editor;
Database Des_DB = Document_Collect.MdiActiveDocument.Database;
Database Sor_Db = new Database(false, true);
try
{
// Get name of DWG from which to copy blocks
// sourceFileName = ed.GetString("\nEnter the name of the source

drawing: ");
//sourceFileName = @"Z:\Desktop\Template 1.6.2.dwg";
// Read the DWG into a side database

Sor_Db.ReadDwgFile(Dir + "/Autocad/Blocks/" + Block_Name + ".dwg",
System.IO.FileShare.Read, true, "");
//MessageBox.Show(Dir + "/Autocad/Blocks/" + Block_Name + ".dwg");
// Create a variable to store the list of block identifiers

ObjectIdCollection Blocks_Id = new ObjectIdCollection();
Autodesk.AutoCAD.DatabaseServices.TransactionManager
Sor_Trans_Manager = Sor_Db.TransactionManager;
using (Transaction Sor_Trans =

Sor_Trans_Manager.StartTransaction())
{
// Open the block table
BlockTable Block_Table =
(BlockTable)Sor_Trans.GetObject(Sor_Db.BlockTableId, OpenMode.ForRead, false);
// Check each block in the block table
foreach (ObjectId Block_Table_Id in Block_Table)

{
BlockTableRecord Block_Table_Record =
(BlockTableRecord)Sor_Trans.GetObject(Block_Table_Id, OpenMode.ForRead, false);
// Only add named & non-layout blocks to the copy list
if (!Block_Table_Record.IsAnonymous && !
Block_Table_Record.IsLayout && Block_Table_Record.Name == Block_Name)
Blocks_Id.Add(Block_Table_Id);
Block_Table_Record.Dispose();
}
// Copy blocks from source to destination database
IdMapping Mapping = new IdMapping();
Sor_Db.WblockCloneObjects(Blocks_Id, Des_DB.BlockTableId, Mapping,

DuplicateRecordCloning.Replace, false);
EDITOR.WriteMessage("\nCopied " + Blocks_Id.Count.ToString() + "

block definitions to the current drawing.");
RETURN = true;
}
catch (Autodesk.AutoCAD.Runtime.Exception ex)
{
EDITOR.WriteMessage("\nError during copy: " + ex.Message);
RETURN = false;
}
Sor_Db.Dispose();
return RETURN;
}
public bool Copy_Layer(string Layer_Name)

{
CDatabase Db = new CDatabase
{
DataSource = @"C:\GenXCTool\DBS\UpdateCheking.db"
};
System.Data.DataTable Dt = Db.Select("Select * From OneDrive");
string Dir = Dt.Rows[0][0].ToString();
bool RETURN = false;
DocumentCollection Document_Collect = Application.DocumentManager;
Editor EDITOR = Document_Collect.MdiActiveDocument.Editor;
var curDb = HostApplicationServices.WorkingDatabase;

string dwgPath = Dir + "/Autocad/Blocks/" + "Layers.dwg";
using (var db = new Database(false, true))
{
db.ReadDwgFile(dwgPath, FileOpenMode.OpenForReadAndAllShare, true,
null);
{
var layerTable = (LayerTable)tr.GetObject(db.LayerTableId,
OpenMode.ForRead);
if (!layerTable.Has(Layer_Name))
{
EDITOR.WriteMessage("\nError during copy: " + Layer_Name);
return false;
}
else
{
var ids = new ObjectIdCollection();
ids.Add(layerTable[Layer_Name]);
var mapping = new IdMapping();
db.WblockCloneObjects(ids, curDb.LayerTableId, mapping,
DuplicateRecordCloning.Replace, false);
EDITOR.WriteMessage("\nCopied " + Layer_Name + " Layer

definitions to the current drawing.");
return true;
}
}
}
return RETURN;
}
public Point3dCollection IntersecT(Polyline Pl, BlockReference Br)

{
Point3dCollection P3DC = new Point3dCollection();
Pl.IntersectWith(Br, Intersect.OnBothOperands, P3DC, IntPtr.Zero,

IntPtr.Zero);
return P3DC;
}
public SelectionFilter SelectFilter(int[] typeValue, object[] value)

{
TypedValue[] typedValue = new TypedValue[typeValue.Length];
if (typeValue.Length == value.Length)
{
typedValue = new TypedValue[value.Length];
for (int i = 0; i < typedValue.Length; i++)
{
typedValue.SetValue(new TypedValue(typeValue[i], value[i]), i);
}
SelectionFilter sF = new SelectionFilter(typedValue);

return sF;
}
public void ZoomObjects(ObjectIdCollection idCol)

{
using (ViewTableRecord view = editor.GetCurrentView())
{
Matrix3d WCS2DCS = Matrix3d.PlaneToWorld(view.ViewDirection);
WCS2DCS = Matrix3d.Displacement(view.Target - Point3d.Origin) *
WCS2DCS;
WCS2DCS = Matrix3d.Rotation(-view.ViewTwist, view.ViewDirection,
view.Target) * WCS2DCS;
WCS2DCS = WCS2DCS.Inverse();
Entity ent = (Entity)transaction.GetObject(idCol[0],
OpenMode.ForRead);
Extents3d ext = ent.GeometricExtents;
ext.TransformBy(WCS2DCS);
for (int i = 1; i < idCol.Count; i++)
{
ent = (Entity)transaction.GetObject(idCol[i],
OpenMode.ForRead);
Extents3d tmp = ent.GeometricExtents;
tmp.TransformBy(WCS2DCS);
ext.AddExtents(tmp);
}
double ratio = view.Width / view.Height;
double width = ext.MaxPoint.X - ext.MinPoint.X;
double height = ext.MaxPoint.Y - ext.MinPoint.Y;
if (width > (height * ratio))
height = width / ratio;
Point2d center = new Point2d((ext.MaxPoint.X + ext.MinPoint.X) /
2.0, (ext.MaxPoint.Y + ext.MinPoint.Y) / 2.0);
view.Height = height;
view.Width = width;
view.CenterPoint = center;
editor.SetCurrentView(view);
}
}
}
public class CCentroide

{
#region Geometric Center of Polyline
public double BulgeFromCurve(Curve cv, bool clockwise)
{
double bulge = 0.0;
Arc a = cv as Arc;
if (a != null)
{
double newStart;
// The start angle is usually greater than the end,
// as arcs are all counter-clockwise.
// (If it isn't it's because the arc crosses the
// 0-degree line, and we can subtract 2PI from the
// start angle.)
if (a.StartAngle > a.EndAngle)
{
newStart = a.StartAngle - 8 * Math.Atan(1);
}
else
{
newStart = a.StartAngle;
}
// Bulge is defined as the tan of
// one fourth of the included angle

bulge = Math.Tan((a.EndAngle - newStart) / 4);
// If the curve is clockwise, we negate the bulge
if (clockwise)
{
bulge = -bulge;
}
}
return bulge;

{
double area = 0.0;
double bulge = pl.GetBulgeAt(0);
double tmpArea;
Point2d tmpPoint;
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, 0, 1);
area = datas[0];
}
{
area += tmpArea;
bulge = pl.GetBulgeAt(i);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, i, i + 1);
area += datas[0];
}
}
bulge = pl.GetBulgeAt(last);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, last, 0);
area += datas[0];
}
}
public Point2d GetCentroid_2d(Polyline pl)

{
double area = 0.0;
double tmpArea;
Point2d tmpPoint;
if (bulge != 0.0)
{
area = datas[0];
}
{
area += tmpArea;
if (bulge != 0.0)
{
area += datas[0];
}
}
if (bulge != 0.0)
{
area += datas[0];
}
result = result.TransformBy(Matrix3d.PlaneToWorld(pl.Normal));
return new Point2d(result.X, result.Y);
}
private static double[] GetArcGeom(Polyline pl, double bulge, int index1,

int index2)
{
}
private static Point2d TriangleCentroid(Point2d p0, Point2d p1, Point2d p2)

{
}
private static double TriangleAlgebricArea(Point2d p0, Point2d p1, Point2d

p2)
{
p0.Y))) / 2.0;
}
private static Point2d ArcCentroid(Point2d start, Point2d end, Point2d cen,

double tmpArea)
{
(12.0 * tmpArea));
}
private static double ArcAlgebricArea(double rad, double ang)

{
}
private static Point2d Polar2d(Point2d org, double angle, double distance)

{
Math.Sin(angle));
}
#endregion
}
public class CPole

{
/* private string pole_tag = " ";
private string pole_owner = " ";
private string material = " ";
private string pole_class = " ";
private string ground = " ";
private string telco_first_attachment = " ";
private string telco_second_attachment = " ";
private string comcast = " ";
private string catv_second_attachment = " ";
private string streetlight = " ";
private string secondaryneutral = " ";
private string transfer = " ";
private string pole_address_full = " ";
private string proposed_or_existing_1 = " ";

private string bearing_1 = " ";
private string lead_1 = " ";
private string photo = " ";
private int pole_tag_p = 0;

private int pole_owner_p = 0;
private int material_p = 0;
private int pole_class_p = 0;
private int ground_p = 0;
private int telco_first_attachment_p = 0;
private int telco_second_attachment_p = 0;
private int comcast_p = 0;
private int catv_second_attachment_p = 0;
private int streetlight_p = 0;
private int secondaryneutral_p = 0;
private int transfer_p = 0;
private int proposed_or_existing_1_p = 0;

private int bearing_1_p = 0;
private int lead_1_p = 0;
private int photo_p = 0;
private int latitude_p = 0;
private int longitude_p = 0;*/
//public string Pole_Detail(string S, int P)

//{
// try
// {
// string Data = "";
// var reader = new StreamReader(S);
// int lines = 0;
// while (!reader.EndOfStream)
// {
// string[] comas;
// string line = reader.ReadLine();
// string[] values = line.Split(',');
// if (lines == 0)
// for (int c = 0; c < values.Length; c++)
// if (values[c] == "pole_owner")
// pole_owner_p = c;
// else if (values[c] == "material")
// material_p = c;
// else if (values[c] == "pole_class")
// pole_class_p = c;
// else if (values[c] == "ground")
// ground_p = c;
// else if (values[c] == "telco_first_attachment")
// telco_first_attachment_p = c;
// else if (values[c] == "telco_second_attachment")
// telco_second_attachment_p = c;
// else if (values[c] == "comcast")
// comcast_p = c;
// else if (values[c] == "catv_second_attachment")
// catv_second_attachment_p = c;
// else if (values[c] == "streetlight")
// streetlight_p = c;
// else if (values[c] == "secondaryneutral")
// secondaryneutral_p = c;
// else if (values[c] == "transfer" || values[c] ==
"general_notes")
// transfer_p = c;
// else if (values[c] == "pole_tag")
// pole_tag_p = c;
// if (lines == P && P != 0)
// {
// pole_owner = values[pole_owner_p];
// if (pole_tag_p != 0)
// {
// pole_tag = values[pole_tag_p];
// }
// if (pole_owner != "Cross Messenger")

// {
// if(material_p != 0)
// material = values[material_p];
// if(pole_class_p != 0)
// pole_class = values[pole_class_p];
// if (ground_p != 0)
// ground = values[ground_p];
// if(telco_first_attachment_p != 0)
// telco_first_attachment =
values[telco_first_attachment_p];
// if(telco_second_attachment_p != 0)
// telco_second_attachment =
values[telco_second_attachment_p];
// if(comcast_p != 0)
// comcast = values[comcast_p];
// if(catv_second_attachment_p != 0)
// catv_second_attachment =
values[catv_second_attachment_p];
// if(streetlight_p != 0)
// streetlight = values[streetlight_p];
// if(secondaryneutral_p != 0)
// secondaryneutral = values[secondaryneutral_p];
// if(transfer_p != 0)
// transfer = values[transfer_p];
// try
// {
// if (pole_tag != " " && pole_tag != "")
// {
// Data += "Pole#: " +
Convert.ToInt32(pole_tag).ToString();
// }
// }
// catch (Exception)
// {
// Data += pole_tag;
// }
// if (pole_owner == "BST Pole")

// Data += "\n" + "TELCO POLE";
// else
// Data += "\n" + pole_owner;
// if (material != "" && material != " ")

// Data += "\n" + material;
// if (pole_class != " " && pole_class != "")

// {
// comas = pole_class.Split('-');
// pole_class = comas[0] + " - " + comas[1];
// Data += "\n" + material;
// Data += "\n" + "CLASS: " + pole_class;
// }
// if (ground != " " && ground != "")

// {
// Data += "\n" + "MGNV: " + ground;
// }
// if (telco_first_attachment != " " &&

telco_first_attachment != "")
// {
// comas = telco_first_attachment.Split('-');
// telco_first_attachment = comas[0] + "' - " +
comas[1] + "\" ";
// Data += "\n" + "TELCO: " +
telco_first_attachment;
// }
// if (telco_second_attachment != " " &&

telco_second_attachment != "")
// {
// comas = telco_second_attachment.Split('-');
// telco_second_attachment = comas[0] + "' - " +
comas[1] + "\" ";
// Data += "\n" + "TELCO: " +
telco_second_attachment;
// }
// if (comcast != " " && comcast != "")

// {
// comas = comcast.Split('-');
// comcast = comas[0] + "' - " + comas[1] + "\" ";
// Data += "\n" + "CATV: " + comcast;
// }
// if (catv_second_attachment != " " &&

catv_second_attachment != "")
// {
// comas = catv_second_attachment.Split('-');
// catv_second_attachment = comas[0] + "' - " +
comas[1] + "\" ";
// Data += "\n" + "CATV: " + catv_second_attachment;
// }
// if (streetlight != " " && streetlight != "")

// {
// comas = streetlight.Split('-');
// streetlight = comas[0] + "' - " + comas[1] + "\"
";
// Data += "\n" + "LIGHT: " + streetlight;
// }
// if (secondaryneutral != " " && secondaryneutral !=

"")
// {
// comas = secondaryneutral.Split('-');
// secondaryneutral = comas[0] + "' - " + comas[1] +
"\" ";
// Data += "\n" + "POWER: " + secondaryneutral;
// }
// if (transfer.Contains("Yes") ||
transfer.Contains("Transfer"))
// {
// Data += "\n" + transfer;
// }
// }
// else
// {
// try
// {
// if (pole_tag != " " && pole_tag != "")
// {
// Data += "Pole#: " +
Convert.ToInt32(pole_tag).ToString();
// }
// }
// catch (Exception)
// {
// Data += pole_tag;
// }
// Data += "\n" + pole_owner;

// }
// }
// lines++;
// }
// return Data.ToUpper();
// }
// catch (Exception Ex)
// {
// MessageBox.Show(Ex + "");
// return "Explote";
// }
//}
private string fulcrum_id = " ";

private string fulcrum_parent_id = " ";
private string fulcrum_record_id = " ";
private string version = " ";
private string latitude = " ";
private string longitude = " ";
private string geometry = " ";
private string created_at = " ";
private string updated_at = " ";
private string created_by = " ";
private string updated_by = " ";
private string pole_owner = " ";
private string pole_tag = " ";
private string pole_address_sub_thoroughfare = " ";
private string pole_address_thoroughfare = " ";
private string pole_address_suite = " ";
private string pole_address_locality = " ";
private string pole_address_sub_admin_area = " ";
private string pole_address_admin_area = " ";
private string pole_address_postal_code = " ";
private string pole_address_country = " ";
private string pole_address_full = " ";
private string pole_boc_eop_measurement = " ";
private string pole_class = " ";
private string material = " ";
private string strand_size = " ";
private string guying = " ";
private string joint_use_anchor_1 = " ";
private string anchor_size_1 = " ";
private string down_guy_wire_size_1 = " ";
private string guy_quantity_1 = " ";
private string guy_hoa_1 = " ";
private string pull_1 = " ";
private string number_of_eyes_1 = " ";
private string telco_first_attachment = " ";
private string telco_second_attachment = " ";
private string roadside_attachment = " ";
private string catv_first_attachment = " ";
private string catv_second_attachment = " ";
private string roadside_attachment_2 = " ";
private string provider_1 = " ";
private string hoa_1 = " ";
private string secondaryneutral = " ";
private string streetlight = " ";
private string transformer = " ";
private string ground = " ";
private string general_notes = " ";
private string damage_notes = " ";
private string photo = " ";
private string photo_caption = " ";
private string photo_url = " ";
private int fulcrum_id_p = 0;

private int fulcrum_parent_id_p = 0;
private int fulcrum_record_id_p = 0;
private int version_p = 0;
private int longitude_p = 0;
private int geometry_p = 0;
private int created_at_p = 0;
private int updated_at_p = 0;
private int created_by_p = 0;
private int updated_by_p = 0;
private int pole_owner_p = 0;
private int pole_tag_p = 0;
private int pole_address_sub_thoroughfare_p = 0;
private int pole_address_thoroughfare_p = 0;
private int pole_address_suite_p = 0;
private int pole_address_locality_p = 0;
private int pole_address_sub_admin_area_p = 0;
private int pole_address_admin_area_p = 0;
private int pole_address_postal_code_p = 0;
private int pole_address_country_p = 0;
private int pole_address_full_p = 0;
private int pole_boc_eop_measurement_p = 0;
private int pole_class_p = 0;
private int material_p = 0;
private int strand_size_p = 0;
private int guying_p = 0;
private int joint_use_anchor_1_p = 0;
private int anchor_size_1_p = 0;
private int down_guy_wire_size_1_p = 0;
private int guy_quantity_1_p = 0;
private int guy_hoa_1_p = 0;
private int pull_1_p = 0;
private int number_of_eyes_1_p = 0;
private int telco_first_attachment_p = 0;
private int telco_second_attachment_p = 0;
private int roadside_attachment_p = 0;
private int catv_first_attachment_p = 0;
private int catv_second_attachment_p = 0;
private int roadside_attachment_2_p = 0;
private int provider_1_p = 0;
private int hoa_1_p = 0;
private int secondaryneutral_p = 0;
private int streetlight_p = 0;
private int transformer_p = 0;
private int ground_p = 0;
private int general_notes_p = 0;
private int damage_notes_p = 0;
private int photo_p = 0;
private int photo_caption_p = 0;
private int photo_url_p = 0;
public string Pole_Detail(string S, int P)

{
try
{
string Data = "";
var reader = new StreamReader(S);
int lines = 0;
while (!reader.EndOfStream)
{
string[] comas;
string line = reader.ReadLine();
string[] values = line.Split(',');
if (lines == 0)
for (int c = 0; c < values.Length; c++)
if (values[c] == "fulcrum_id")
fulcrum_id_p = c;
else if (values[c] == "fulcrum_parent_id")
fulcrum_parent_id_p = c;
else if (values[c] == "fulcrum_record_id")
fulcrum_record_id_p = c;
else if (values[c] == "version")
version_p = c;
else if (values[c] == "latitude")
latitude_p = c;
else if (values[c] == "longitude")
longitude_p = c;
else if (values[c] == "geometry")
geometry_p = c;
else if (values[c] == "created_at")
created_at_p = c;
else if (values[c] == "updated_at")
updated_at_p = c;
else if (values[c] == "created_by")
created_by_p = c;
else if (values[c] == "updated_by")
updated_by_p = c;
else if (values[c] == "pole_owner")
pole_owner_p = c;
else if (values[c] == "pole_tag")
pole_tag_p = c;
else if (values[c] == "pole_address_sub_thoroughfare")
pole_address_sub_thoroughfare_p = c;
else if (values[c] == "pole_address_thoroughfare")
pole_address_thoroughfare_p = c;
else if (values[c] == "pole_address_suite")
pole_address_suite_p = c;
else if (values[c] == "pole_address_locality")
pole_address_locality_p = c;
else if (values[c] == "pole_address_sub_admin_area")
pole_address_sub_admin_area_p = c;
else if (values[c] == "pole_address_admin_area")
pole_address_admin_area_p = c;
else if (values[c] == "pole_address_postal_code")
pole_address_postal_code_p = c;
else if (values[c] == "pole_address_country")
pole_address_country_p = c;
else if (values[c] == "pole_address_full")
pole_address_full_p = c;
else if (values[c] == "pole_boc_eop_measurement")
pole_boc_eop_measurement_p = c;
else if (values[c] == "pole_class")
pole_class_p = c;
else if (values[c] == "material")
material_p = c;
else if (values[c] == "strand_size")
strand_size_p = c;
else if (values[c] == "guying")
guying_p = c;
else if (values[c] == "joint_use_anchor_1")
joint_use_anchor_1_p = c;
else if (values[c] == "proposed_or_existing_1")
proposed_or_existing_1_p = c;
else if (values[c] == "anchor_size_1")
anchor_size_1_p = c;
else if (values[c] == "down_guy_wire_size_1")
down_guy_wire_size_1_p = c;
else if (values[c] == "lead_1")
lead_1_p = c;
else if (values[c] == "guy_quantity_1")
guy_quantity_1_p = c;
else if (values[c] == "guy_hoa_1")
guy_hoa_1_p = c;
else if (values[c] == "pull_1")
pull_1_p = c;
else if (values[c] == "bearing_1")
bearing_1_p = c;
else if (values[c] == "number_of_eyes_1")
number_of_eyes_1_p = c;
lead_2_p = c;
guy_hoa_2_p = c;
pull_2_p = c;
bearing_2_p = c;
lead_3_p = c;
guy_hoa_3_p = c;
pull_3_p = c;
bearing_3_p = c;
lead_4_p = c;
guy_hoa_4_p = c;
pull_4_p = c;
bearing_4_p = c;
else if (values[c] == "telco_first_attachment")
telco_first_attachment_p = c;
else if (values[c] == "telco_second_attachment")
telco_second_attachment_p = c;
else if (values[c] == "roadside_attachment")
roadside_attachment_p = c;
else if (values[c] == "catv_first_attachment")
catv_first_attachment_p = c;
else if (values[c] == "catv_second_attachment")
catv_second_attachment_p = c;
else if (values[c] == "roadside_attachment_2")
roadside_attachment_2_p = c;
else if (values[c] == "provider_1")
provider_1_p = c;
else if (values[c] == "hoa_1")
hoa_1_p = c;
provider_2_p = c;
hoa_2_p = c;
provider_3_p = c;
hoa_3_p = c;
provider_4_p = c;
hoa_4_p = c;
provider_5_p = c;
hoa_5_p = c;
else if (values[c] == "secondaryneutral")
secondaryneutral_p = c;
else if (values[c] == "streetlight")
streetlight_p = c;
else if (values[c] == "transformer")
transformer_p = c;
else if (values[c] == "ground")
ground_p = c;
else if (values[c] == "general_notes")
general_notes_p = c;
else if (values[c] == "damage_notes")
damage_notes_p = c;
else if (values[c] == "photo")
photo_p = c;
else if (values[c] == "photo_caption")
photo_caption_p = c;
else if (values[c] == "photo_url")
photo_url_p = c;
if (fulcrum_id_p != 0)
fulcrum_id = values[fulcrum_id_p];
if (fulcrum_parent_id_p != 0)
fulcrum_parent_id = values[fulcrum_parent_id_p];
if (fulcrum_record_id_p != 0)
fulcrum_record_id = values[fulcrum_record_id_p];
if (version_p != 0)
version = values[version_p];
if (latitude_p != 0)
latitude = values[latitude_p];
if (longitude_p != 0)
longitude = values[longitude_p];
if (geometry_p != 0)
geometry = values[geometry_p];
if (created_at_p != 0)
created_at = values[created_at_p];
if (updated_at_p != 0)
updated_at = values[updated_at_p];
if (created_by_p != 0)
created_by = values[created_by_p];
if (updated_by_p != 0)
updated_by = values[updated_by_p];
if (pole_owner_p != 0)
pole_owner = values[pole_owner_p];
if (pole_tag_p != 0)
pole_tag = values[pole_tag_p];
if (pole_address_sub_thoroughfare_p != 0)
pole_address_sub_thoroughfare =
values[pole_address_sub_thoroughfare_p];
if (pole_address_thoroughfare_p != 0)
pole_address_thoroughfare =
values[pole_address_thoroughfare_p];
if (pole_address_suite_p != 0)
pole_address_suite = values[pole_address_suite_p];
if (pole_address_locality_p != 0)
pole_address_locality = values[pole_address_locality_p];
if (pole_address_sub_admin_area_p != 0)
pole_address_sub_admin_area =
values[pole_address_sub_admin_area_p];
if (pole_address_admin_area_p != 0)
pole_address_admin_area =
values[pole_address_admin_area_p];
if (pole_address_postal_code_p != 0)
pole_address_postal_code =
values[pole_address_postal_code_p];
if (pole_address_country_p != 0)
pole_address_country = values[pole_address_country_p];
if (pole_address_full_p != 0)
pole_address_full = values[pole_address_full_p];
if (pole_boc_eop_measurement_p != 0)
pole_boc_eop_measurement =
values[pole_boc_eop_measurement_p];
if (pole_class_p != 0)
pole_class = values[pole_class_p];
if (material_p != 0)
material = values[material_p];
if (strand_size_p != 0)
strand_size = values[strand_size_p];
if (guying_p != 0)
guying = values[guying_p];
if (joint_use_anchor_1_p != 0)
joint_use_anchor_1 = values[joint_use_anchor_1_p];
if (proposed_or_existing_1_p != 0)
proposed_or_existing_1 = values[proposed_or_existing_1_p];
if (anchor_size_1_p != 0)
anchor_size_1 = values[anchor_size_1_p];
if (down_guy_wire_size_1_p != 0)
down_guy_wire_size_1 = values[down_guy_wire_size_1_p];
if (lead_1_p != 0)
lead_1 = values[lead_1_p];
if (guy_quantity_1_p != 0)
guy_quantity_1 = values[guy_quantity_1_p];
if (guy_hoa_1_p != 0)
guy_hoa_1 = values[guy_hoa_1_p];
if (pull_1_p != 0)
pull_1 = values[pull_1_p];
if (bearing_1_p != 0)
bearing_1 = values[bearing_1_p];
if (number_of_eyes_1_p != 0)
number_of_eyes_1 = values[number_of_eyes_1_p];
if (lead_2_p != 0)
if (pull_2_p != 0)
if (lead_3_p != 0)
if (pull_3_p != 0)
if (lead_4_p != 0)
if (pull_4_p != 0)
if (telco_first_attachment_p != 0)
telco_first_attachment = values[telco_first_attachment_p];
if (telco_second_attachment_p != 0)
telco_second_attachment =
values[telco_second_attachment_p];
if (roadside_attachment_p != 0)
roadside_attachment = values[roadside_attachment_p];
if (catv_first_attachment_p != 0)
catv_first_attachment = values[catv_first_attachment_p];
if (catv_second_attachment_p != 0)
catv_second_attachment = values[catv_second_attachment_p];
if (roadside_attachment_2_p != 0)
roadside_attachment_2 = values[roadside_attachment_2_p];
if (provider_1_p != 0)
provider_1 = values[provider_1_p];
if (hoa_1_p != 0)
hoa_1 = values[hoa_1_p];
if (hoa_2_p != 0)
if (hoa_3_p != 0)
if (hoa_4_p != 0)
if (hoa_5_p != 0)
if (secondaryneutral_p != 0)
secondaryneutral = values[secondaryneutral_p];
if (streetlight_p != 0)
streetlight = values[streetlight_p];
if (transformer_p != 0)
transformer = values[transformer_p];
if (ground_p != 0)
ground = values[ground_p];
if (general_notes_p != 0)
general_notes = values[general_notes_p];
if (damage_notes_p != 0)
damage_notes = values[damage_notes_p];
if (photo_p != 0)
photo = values[photo_p];
if (photo_caption_p != 0)
photo_caption = values[photo_caption_p];
if (photo_url_p != 0)
photo_url = values[photo_url_p];
if (lines == P && P != 0)
{
if (pole_owner != " " && pole_owner != "")
{
Data += "pole_owner: " + pole_owner + "\n";
}
if (pole_tag != " " && pole_tag != "")
{
Data += "pole_tag: " + pole_tag + "\n";
}
if (pole_address_full != " " && pole_address_full != "")
{
Data += "pole_address_full: " + pole_address_full + "\
n";
}
if (pole_boc_eop_measurement != " " &&
pole_boc_eop_measurement != "")
{
Data += "pole_boc_eop_measurement: " +
pole_boc_eop_measurement + "\n";
}
if (pole_class != " " && pole_class != "")
{
Data += "pole_class: " + pole_class + "\n";
}
if (material != " " && material != "")
{
Data += "material: " + material + "\n";
}
if (strand_size != " " && strand_size != "")
{
Data += "strand_size: " + strand_size + "\n";
}
if (guying != " " && guying != "")
{
Data += "guying: " + guying + "\n";
}
if (joint_use_anchor_1 != " " && joint_use_anchor_1 != "")
{
Data += "joint_use_anchor_1: " + joint_use_anchor_1 +
"\n";
}
if (proposed_or_existing_1 != " " && proposed_or_existing_1
!= "")
{
Data += "proposed_or_existing_1: " +
proposed_or_existing_1 + "\n";
}
if (anchor_size_1 != " " && anchor_size_1 != "")
{
Data += "anchor_size_1: " + anchor_size_1 + "\n";
}
if (down_guy_wire_size_1 != " " && down_guy_wire_size_1 !=
"")
{
Data += "down_guy_wire_size_1: " + down_guy_wire_size_1
+ "\n";
}
if (lead_1 != " " && lead_1 != "")
{
Data += "lead_1: " + lead_1 + "\n";
}
if (guy_quantity_1 != " " && guy_quantity_1 != "")
{
Data += "guy_quantity_1: " + guy_quantity_1 + "\n";
}
if (guy_hoa_1 != " " && guy_hoa_1 != "")
{
Data += "guy_hoa_1: " + guy_hoa_1 + "\n";
}
if (pull_1 != " " && pull_1 != "")
{
Data += "pull_1: " + pull_1 + "\n";
}
if (bearing_1 != " " && bearing_1 != "")
{
Data += "bearing_1: " + bearing_1 + "\n";
}
if (number_of_eyes_1 != " " && number_of_eyes_1 != "")
{
Data += "number_of_eyes_1: " + number_of_eyes_1 + "\n";
}
{
"\n";
}
!= "")
{
}
{
}
"")
{
+ "\n";
}
if (lead_2 != " " && lead_2 != "")
{
Data += "lead_2: " + lead_2 + "\n";
}
{
}
if (guy_hoa_2 != " " && guy_hoa_2 != "")
{
}
if (pull_2 != " " && pull_2 != "")
{
Data += "pull_2: " + pull_2 + "\n";
}
{
}
{
}
{
"\n";
}
!= "")
{
}
{
}
"")
{
+ "\n";
}
if (lead_3 != " " && lead_3 != "")
{
Data += "lead_3: " + lead_3 + "\n";
}
{
}
if (guy_hoa_3 != " " && guy_hoa_3 != "")
{
}
if (pull_3 != " " && pull_3 != "")
{
Data += "pull_3: " + pull_3 + "\n";
}
{
}
{
}
{
"\n";
}
!= "")
{
}
{
}
"")
{
+ "\n";
}
if (lead_4 != " " && lead_4 != "")
{
Data += "lead_4: " + lead_4 + "\n";
}
{
}
if (guy_hoa_4 != " " && guy_hoa_4 != "")
{
}
if (pull_4 != " " && pull_4 != "")
{
Data += "pull_4: " + pull_4 + "\n";
}
{
}
{
}
if (telco_first_attachment != " " && telco_first_attachment
!= "")
{
Data += "telco_first_attachment: " +
telco_first_attachment + "\n";
}
if (telco_second_attachment != " " &&
telco_second_attachment != "")
{
Data += "telco_second_attachment: " +
telco_second_attachment + "\n";
}
if (roadside_attachment != " " && roadside_attachment !=
"")
{
Data += "roadside_attachment: " + roadside_attachment +
"\n";
}
if (catv_first_attachment != " " && catv_first_attachment !
= "")
{
Data += "catv_first_attachment: " +
catv_first_attachment + "\n";
}
if (catv_second_attachment != " " && catv_second_attachment
!= "")
{
Data += "catv_second_attachment: " +
catv_second_attachment + "\n";
}
if (roadside_attachment_2 != " " && roadside_attachment_2 !
= "")
{
Data += "roadside_attachment_2: " +
roadside_attachment_2 + "\n";
}
if (provider_1 != " " && provider_1 != "")
{
Data += "provider_1: " + provider_1 + "\n";
}
if (hoa_1 != " " && hoa_1 != "")
{
Data += "hoa_1: " + hoa_1 + "\n";
}
{
}
if (hoa_2 != " " && hoa_2 != "")
{
Data += "hoa_2: " + hoa_2 + "\n";
}
{
}
if (hoa_3 != " " && hoa_3 != "")
{
Data += "hoa_3: " + hoa_3 + "\n";
}
{
}
if (hoa_4 != " " && hoa_4 != "")
{
Data += "hoa_4: " + hoa_4 + "\n";
}
{
}
if (hoa_5 != " " && hoa_5 != "")
{
Data += "hoa_5: " + hoa_5 + "\n";
}
if (secondaryneutral != " " && secondaryneutral != "")
{
Data += "secondaryneutral: " + secondaryneutral + "\n";
}
if (streetlight != " " && streetlight != "")
{
Data += "streetlight: " + streetlight + "\n";
}
if (transformer != " " && transformer != "")
{
Data += "transformer: " + transformer + "\n";
}
if (ground != " " && ground != "")
{
Data += "ground: " + ground + "\n";
}
if (general_notes != " " && general_notes != "")
{
Data += "general_notes: " + general_notes + "\n";
}
if (damage_notes != " " && damage_notes != "")
{
Data += "damage_notes: " + damage_notes + "\n";
}
}
lines++;
}
return Data.ToUpper();
}
catch (Exception Ex)
{
MessageBox.Show(Ex + "");
return "Explote";
}
}
public string Pole_Photo(Double Lat, Double Lon, string s)

{
try
{
string Data = "";
var reader = new StreamReader(s);
int lines = 0;
{
if (lines == 0)
if (values[c] == "photo")
photo_p = c;
latitude_p = c;
longitude_p = c;
if (lines != 0)
{
decimal lat1 = Math.Round(Convert.ToDecimal(Lat), 5);
decimal lon1 = Math.Round(Convert.ToDecimal(Lon), 5);
decimal lat2 =
Math.Round(Convert.ToDecimal(values[latitude_p]), 5);
decimal lon2 =
Math.Round(Convert.ToDecimal(values[longitude_p]), 5);
if (Convert.ToDouble(Math.Abs(lat1 - lat2)) <= 0.0002 &&

Convert.ToDouble(Math.Abs(lon1 - lon2)) <= 0.0002)
{
Data = values[photo_p];
return Data;
}
}
lines++;
}
}
{
return "Explote";
}
}
public string Dow_Anc_Detail(string S, int P)

{
try
{
string Data = "";
int lines = 0;
{
if (lines == 0)
if (values[c] == "proposed_or_existing_1")
bearing_1_p = c;
lead_1_p = c;
if (lines == P && P != 0)
{
if (proposed_or_existing_1 == "Proposed")
Data += "PROPOSED DOWNGUY AND ANCHOR AT " + lead_1 + "'
LEAD FROM POLE ";
else if (proposed_or_existing_1 == "Existing")
Data += "EXISTING DOWNGUY BEARING" + " " + bearing_1;
//return Dow_Anc_Details.ToUpper();
}
lines++;
}
}
{
return "Explote";
}
}
}
public class CSpan
{
private string environment = " ";
private string aerial_value = " ";
private int environment_p = 0;

private int aerial_value_p = 0;
public string Span_Detail(string S, int P)

{
try
{
string Data = "";
int lines = 0;
{
if (lines == 0)
if (values[c] == "environment")
environment_p = c;
else if (values[c] == "aerial_value")
aerial_value_p = c;
if (lines == P && P != 0)
{
environment = values[environment_p];
aerial_value = values[aerial_value_p];
if (environment == "Buried")
Data = "{\\fArial|b1|;\\LDIRECTIONAL BORE -MAX\nBACK
REAMER SIZE =6\" \\P}INSTALL 1\'-2\" HDPE \\PCONDUIT PULL 1-FIBER OPTIC CABLE \\
P(84\" MIN. GROUND COVER)";
else if (environment == "Aerial")
Data = "{\\fArial|b1|;\\LOVERLASH \\P}OVERLASH 1 - FOC
TO \\PEXISTING STRAND \\P{\\C5;" + aerial_value + "\'}";
}
lines++;
}
return Data;
}
{
return "Explote";
}
}
}
public class CBuried

{
private string buried_reference = " ";
private int buried_reference_p = 0;
private int buried_ref_notes_p = 0;
private int buried_ref_photos_P = 0;
private int longitude_p = 0;
public string Buried_Detail(string S, int P)

{
string Data = "";
try
{
int lines = 0;
{
if (lines == 0)
if (values[c] == "buried_reference")
buried_reference_p = c;
else if (values[c] == "buried_ref_notes")
buried_ref_notes_p = c;
if (lines == P && P != 0)
{
buried_reference = values[buried_reference_p];
//buried_ref_notes = values[buried_ref_notes_p];
if (buried_reference != " " /*|| buried_ref_notes != " "*/)

Data += buried_reference /*+ " - " +
buried_ref_notes*/;
}
lines++;
}
}
{
return Data;
}
}
public string Buried_Photo(Double Lat, Double Lon, string s)

{
try
{
string Data = "";
var reader = new StreamReader(s);
int lines = 0;
{
if (lines == 0)
if (values[c] == "buried_ref_photos")
buried_ref_photos_P = c;
latitude_p = c;
longitude_p = c;
if (lines != 0)
{
decimal lat1 = Math.Round(Convert.ToDecimal(Lat), 5);
decimal lon1 = Math.Round(Convert.ToDecimal(Lon), 5);
decimal lat2 =
Math.Round(Convert.ToDecimal(values[latitude_p]), 5);
decimal lon2 =
Math.Round(Convert.ToDecimal(values[longitude_p]), 5);
if (Convert.ToDouble(Math.Abs(lat1 - lat2)) <= 0.0002 &&

Convert.ToDouble(Math.Abs(lon1 - lon2)) <= 0.0002)
{
Data = values[buried_ref_photos_P];
return Data;
}
}
lines++;
}
}
{
return "Explote";
}
}
}
public class CClearance

{
private string midspan_clearance = " ";
private int midspan_clearance_p = 0;
public string Clearance_Detail(string S, int P)

{
string Data = "";
try
{
int lines = 0;
{
if (lines == 0)
if (values[c] == "midspan_clearance")
midspan_clearance_p = c;
if (lines == P && P != 0)
{
midspan_clearance = values[midspan_clearance_p];
values = midspan_clearance.Split('-');
Data = "Clearance " + values[0] + "\'-" + values[1] + "\"";
}
lines++;
}
}
{
return Data;
}
}
}
public class CPoint

{
private double Lat = 0;
private double Lon = 0;
public double GSLat { get => Lat; set => Lat = value; }
public double GSLon { get => Lon; set => Lon = value; }
public Point3d Regla_3(Polyline Ori, Polyline Des, Point3d Pb)

{
double OriL = Ori.Length / 100;
double DesL = Des.Length / 100;
double Pr = Ori.GetDistAtPoint(Pb) / OriL;
return (Des.GetPointAtDist(DesL * Pr));

}
public Point3d PointFromLatLong(Point3d Point)

{

return dwgPt;
}
public Point3d PointFromLatLong(double lat, double lon)

{
Point3d Point = new Point3d(lat, lon, 0);


return dwgPt;
}
public Point2d LatLongFromPoint2(Point3d P)

{
// Translate the drawing point to a lat-lon

var p = new Point2d(lonlat.X, lonlat.Y);
return p;
}
private Point3d TranslateGeoPoint(Database db, Point3d inPt, bool fromDwg)

{
{
// Get the drawing's GeoLocation object
var gd = tr.GetObject(db.GeoDataObject, OpenMode.ForRead) as

GeoLocationData;
// Get the output point...

// dwg2lonlat if fromDwg is true,
// lonlat2dwg otherwise
var outPt = (fromDwg ? gd.TransformToLonLatAlt(inPt) :

gd.TransformFromLonLatAlt(inPt));
tr.Commit();
return outPt;
}
}
public double Distance(Point2d A, Point2d B)

{
double Lat1 = 0;
double lon1 = 0;
double Lat2 = 0;
double lon2 = 0;
double deg2radMultiplier = Math.PI / 180;
Lat1 *= deg2radMultiplier;
lon1 *= deg2radMultiplier;
Lat2 *= deg2radMultiplier;
lon2 *= deg2radMultiplier;
double radius = 6378.137; // earth mean radius defined by WGS84

double dlon = lon2 - lon1;
double distance = Math.Acos(Math.Sin(Lat1) * Math.Sin(Lat2) +
Math.Cos(Lat1) * Math.Cos(Lat2) * Math.Cos(dlon)) * radius;
return (distance);
}
#region Geometric Center of Polyline

{
double area = 0.0;
double tmpArea;
Point2d tmpPoint;
if (bulge != 0.0)
{
area = datas[0];
}
{
area += tmpArea;
if (bulge != 0.0)
{
area += datas[0];
}
}
if (bulge != 0.0)
{
area += datas[0];
}
}
private static double[] GetArcGeom(Polyline pl, double bulge, int index1,

int index2)
{
}
private static Point2d TriangleCentroid(Point2d p0, Point2d p1, Point2d p2)

{
}
private static double TriangleAlgebricArea(Point2d p0, Point2d p1, Point2d

p2)
{
p0.Y))) / 2.0;
}
private static Point2d ArcCentroid(Point2d start, Point2d end, Point2d cen,

double tmpArea)
{
(12.0 * tmpArea));
}
private static double ArcAlgebricArea(double rad, double ang)

{
}
private static Point2d Polar2d(Point2d org, double angle, double distance)

{
Math.Sin(angle));
}
#endregion
}
public class CStations

{
private string station_reference = " ";
private int station_referenceP = 0;
private string sta = " ";
private int staP = 0;
public string STATIONS_Detail(string SF, int P)

{
string Data = "";
try
{
var reader = new StreamReader(SF);
int lines = 0;
{
if (lines == 0)
if (values[c] == "station_reference")
station_referenceP = c;
else if (values[c] == "sta")
staP = c;
if (lines == P && P != 0)
{
station_reference = values[station_referenceP];
sta = values[staP];
Data = (station_reference + "\n" + sta).ToString();
}
lines++;
}
}
{
return Data;
}
}
}
public class CLayer

{
public void GetLayerName(ComboBox CbLayer)
{
ArrayList Layers = new ArrayList();
// Get the current document and database
// Start a transaction
using (Transaction acTrans = db.TransactionManager.StartTransaction())
{
// Open the Layer table for read
LayerTable acLyrTbl;
acLyrTbl = acTrans.GetObject(db.LayerTableId, OpenMode.ForRead) as
LayerTable;
foreach (ObjectId acObjId in acLyrTbl)
{
LayerTableRecord acLyrTblRec;
acLyrTblRec = acTrans.GetObject(acObjId, OpenMode.ForRead) as
LayerTableRecord;
Layers.Add(acLyrTblRec.Name);
}
}
foreach (string S in Layers)

CbLayer.Items.Add(S);
}
public ArrayList GetLayerName()

{
ArrayList Layers = new ArrayList();
{
acLyrTbl = acTrans.GetObject(db.LayerTableId, OpenMode.ForRead) as
LayerTable;
{
LayerTableRecord;
Layers.Add(acLyrTblRec.Name);
}
}
Layers.Sort();
return Layers;
}
public bool GetLayerOnOff(string layerName)

{
{
var layerTable = acTrans.GetObject(db.LayerTableId,
OpenMode.ForRead) as LayerTable;
var layerTableRecord = acTrans.GetObject(layerTable[layerName],
OpenMode.ForWrite) as LayerTableRecord;
return layerTableRecord.IsOff;
}
}
}
public class CBlock

{
public void GetBlockName(ComboBox CbBlock)
{
ArrayList Blocks = new ArrayList();

Document acDoc = Application.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
using (Transaction acTrans =
acCurDb.TransactionManager.StartTransaction())
{
BlockTable table =
(BlockTable)acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead);
foreach (ObjectId acObjId in table)

{
BlockTableRecord acLyrTblRec;
BlockTableRecord;
Blocks.Add(acLyrTblRec.Name);
}
}
Blocks.Sort();
foreach (string S in Blocks)

CbBlock.Items.Add(S);
}
static public ArrayList GetBlockName()

{
ArrayList Blocks = new ArrayList();

{
BlockTable table =
(BlockTable)acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead);
foreach (ObjectId acObjId in table)

{
BlockTableRecord acLyrTblRec;
BlockTableRecord;
if (!acLyrTblRec.Name.Contains("*"))
Blocks.Add(acLyrTblRec.Name);
}
}
Blocks.Sort();
return Blocks;
}
static public string GetBlockName(BlockReference Br)

{
return Br.IsDynamicBlock ?
((BlockTableRecord)Br.DynamicBlockTableRecord.GetObject(OpenMode.ForWrite)).Name :
Br.Name;
}
}
public class CCSV

{
private string[] headers;
public void Load(TextBox TbLoa, ComboBox CbLongitude, ComboBox CbLatitude)

{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Excel Files|
*.xls;*.xlsx;*.xlsm;*.csv;*.txt;*.kml";//Filtro para solo buscar archivos Excel
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
TbLoa.Text = openFileDialog.FileName;
TbLoa.SelectionStart = openFileDialog.FileName.Length;
try
{
using (var reader = new StreamReader(TbLoa.Text))
{
bool header = true;
{
if (header)
{
headers = values;
header = false;
}
else
{
break;
}
}
}
CbLatitude.Items.AddRange(headers);
CbLongitude.Items.AddRange(headers);
CbLatitude.Text = "latitude";
CbLongitude.Text = "longitude";
}
catch (Exception)
{
Application.ShowAlertDialog("Close file and try");
TbLoa.Text = "";
}
}
}
}
public class CKML

{
public int orientation = 0;
public void SimplePolyline(TextBox TBLoadKML)
{
{
// Open the Block table for read
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(db.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;
string s;
using (var reader = new StreamReader(TBLoadKML.Text))
{
{
s = reader.ReadLine();
if (s.Contains("<coordinates>"))
{
string info = getBetween(s, "<coordinates>",
"</coordinates>");
acBlkTbl = acTrans.GetObject(db.BlockTableId,
OpenMode.ForRead) as BlockTable;
acBlkTblRec =
BlockTableRecord;
using (Polyline acPoly = new Polyline())
{
acPoly.Layer = "ROW";
ArrayList TemArrLis = new ArrayList();

string[] TempArrayData;
string[] j = info.Split(' ');

for (int c = 1; c <= j.Length - 2; c++)
{
TempArrayData = j[c].Split(',');
TemArrLis.Add(TempArrayData[0]);
}
TempArrayData = j[0].Split(',');
int p = 0;
for (int c = 0; c < TemArrLis.Count - 1; c += 2)

{
Point3d Point = new
Point3d(Convert.ToDouble(TemArrLis[c]), Convert.ToDouble(TemArrLis[c + 1]), 0);
Class.CPoint P = new Class.CPoint();
acPoly.AddVertexAt(acPoly.NumberOfVertices, new
Point2d(P.PointFromLatLong(Point).X, P.PointFromLatLong(Point).Y), 0, 0, 0);
}
acBlkTblRec.AppendEntity(acPoly);
acTrans.AddNewlyCreatedDBObject(acPoly, true);
acPoly.Closed = true;
}
}
}
}
acTrans.Commit();
acTrans.Dispose();
}
db.Dispose();
MessageBox.Show("Draw Complete");
}
public string getBetween(string Data, string St, string En)

{
int Start, End;
if (Data.Contains(St) && Data.Contains(En))
{
Start = Data.IndexOf(St, 0) + St.Length;
End = Data.IndexOf(En, Start);
return Data.Substring(Start, End - Start);
}
else
{
return "";
}
}
public void Draw_Early(TextBox TBLoadKML, Point3d BRP)

{
Polyline acPoly = new Polyline();
var Pol = new Polyline();

CPoint Cp = new CPoint();
double minddis = 15011515;
string s = "";
int pbm = 0;
using (var reader = new StreamReader(TBLoadKML.Text))

{
s = reader.ReadLine();
pbm++;
}
pbm = 0;
var Dm = Application.DocumentManager.MdiActiveDocument;
Database Db = Dm.Database;
using (Transaction acTrans = Db.TransactionManager.StartTransaction())

{
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(Db.BlockTableId, OpenMode.ForRead) as
BlockTable;
BlockTableRecord acBlkTblRec;
acBlkTblRec =
BlockTableRecord;
var reader = new StreamReader(TBLoadKML.Text);
int NLines = 0;
{
acPoly = new Polyline();
string Data = reader.ReadLine();
pbm++;
string Rute = "";

try
{
if (Data.Contains("<coordinates>"))
{
Rute = getBetween(Data, "<coordinates>",

"</coordinates>");

string[] j = Rute.Split(' ');

for (int c = 0; c < j.Length; c++)
{
}

{
Point3d Point = new
Point2d(Cp.PointFromLatLong(Point).X, Cp.PointFromLatLong(Point).Y), 0, 0, 0);
}
Point3d P1 = acPoly.GetClosestPointTo(BRP, false);

var BRP2 = new Point2d(BRP.X, BRP.Y);
Line l = new Line(P1, BRP);
if (l.Length < minddis)

minddis = l.Length;
}
}
{
}
NLines++;
}
reader = new StreamReader(TBLoadKML.Text);
Polyline[] Lines = new Polyline[NLines];
NLines = 1;
{
acPoly = new Polyline();
var Data = reader.ReadLine();

pbm++;
var Rute = "";

try
{
if (Data.Contains("<coordinates>"))
{
Rute = getBetween(Data, "<coordinates>",

"</coordinates>");

string[] j = Rute.Split(' ');

for (int c = 0; c < j.Length; c++)
{
}

{
Point3d Point = new
Point2d(Cp.PointFromLatLong(Point).X, Cp.PointFromLatLong(Point).Y), 0, 0, 0);
}
Point3d P1 = acPoly.GetClosestPointTo(BRP, false);

var BRP2 = new Point2d(BRP.X, BRP.Y);
Line l = new Line(P1, BRP);
if (l.Length == minddis)
{
Lines[0] = new Polyline();
Lines[0] = acPoly;
}
else
{
Lines[NLines] = new Polyline();
Lines[NLines] = acPoly;
NLines++;
}
}
}
{
}
}
bool Fin = false;

int Poliline = 1;
OffSet(Lines[0], BRP, acTrans, acBlkTblRec, minddis);
while (!Fin)
{
try
{
Lines[0].JoinEntity(Lines[Poliline]);
//OffSet(Lines[Poliline], BRP, acTrans, acBlkTblRec,
minddis, OLines);
OffSet(Lines[0], BRP, acTrans, acBlkTblRec, minddis);

}
{
//MessageBox.Show(ex.ToString());
}
finally
{
Poliline++;
}
if (Poliline == NLines - 1)
Fin = true;
}
Fin = false;
while (!Fin)
{
try
{
Lines[0].JoinEntity(Lines[Poliline]);
//OffSet(Lines[Poliline], BRP, acTrans, acBlkTblRec,
minddis, OLines);
}
catch (Exception)
{
}
finally
{
Poliline--;
}
if (Poliline == 0)
Fin = true;
}
acBlkTblRec.AppendEntity(Lines[0]);
acTrans.AddNewlyCreatedDBObject(Lines[0], true);
acTrans.Commit();
}
MessageBox.Show("Drawing Complete");
}
public void OffSet(Polyline Lines, Point3d BRP, Transaction acTrans,

BlockTableRecord acBlkTblRec, double minddis, Polyline P0)
{
try
{
Editor editor = Dm.Editor;
Point3d viewDir =
(Point3d)Application.GetSystemVariable("VIEWDIR");
orientation = GeometryTool.IsRightDirection(Lines as Curve,
BRP.TransformBy(editor.CurrentUserCoordinateSystem), viewDir.GetAsVector()) ? 1 : -
1;
DBObjectCollection acDbObjColl = Lines.GetOffsetCurves(minddis *

orientation);
foreach (Entity acEnt in acDbObjColl)

{
double Xdif;
double Ydif;
double min;
var pl = (acEnt) as Polyline;
Point3d Sp = pl.StartPoint;
Point3d Ep = pl.EndPoint;
Polyline l1 = new Polyline();
l1.AddVertexAt(l1.NumberOfVertices, new
Point2d(pl.StartPoint.X, pl.StartPoint.Y), 0, 0, 0);
l1.AddVertexAt(l1.NumberOfVertices, new
Point2d(P0.GetClosestPointTo(Ep, false).X, P0.GetClosestPointTo(Ep, false).Y), 0,
0, 0);
if (l1.Length > minddis * 2 - 1 && l1.Length < minddis * 2 + 1)

{
Xdif = l1.StartPoint.X - l1.EndPoint.X;
Ydif = l1.StartPoint.Y - l1.EndPoint.Y;
}
else
{
l1.StartPoint = Sp;
l1.EndPoint = P0.GetClosestPointTo(Sp, false);
Xdif = l1.StartPoint.X - l1.EndPoint.X;

Ydif = l1.StartPoint.Y - l1.EndPoint.Y;
}
Polyline PL = new Polyline();
PL.AddVertexAt(PL.NumberOfVertices, new Point2d((Sp.X + Xdif),

(Sp.Y + Ydif)), 0, 0, 0);
PL.AddVertexAt(PL.NumberOfVertices, new Point2d((Ep.X + Xdif),

(Ep.Y + Ydif)), 0, 0, 0);
acBlkTblRec.AppendEntity(PL);
acTrans.AddNewlyCreatedDBObject(PL, true);
P0.JoinEntity(PL);
}
}
{
}
}
public Line OffSet(Polyline Lines, Point3d BRP, Transaction acTrans,

BlockTableRecord acBlkTblRec, double minddis)
{
Editor editor = Dm.Editor;
Point3d viewDir = (Point3d)Application.GetSystemVariable("VIEWDIR");
orientation = GeometryTool.IsRightDirection(Lines as Curve,
BRP.TransformBy(editor.CurrentUserCoordinateSystem), viewDir.GetAsVector()) ? 1 : -
1;
DBObjectCollection acDbObjColl = Lines.GetOffsetCurves(minddis *

orientation);
Polyline Pl = new Polyline();
foreach (Entity acEnt in acDbObjColl)

{
Pl = (acEnt) as Polyline;
acBlkTblRec.AppendEntity(Pl);
acTrans.AddNewlyCreatedDBObject(Pl, true);
}
Line L = new Line();

L.StartPoint = Pl.StartPoint;
L.EndPoint = Pl.EndPoint;
return L;
}
}
public class CParcel

{
public string Id;
public Polyline Body;
public bool Status = false;
public Point3d Cp;
public string Cable;
public string Type;
public CParcel(Polyline body)

{
Body = body;
}
public CParcel()
{
public void SetId(List<MText> Text, Polyline Pr)

{
double max = 0;
double min = 1000;
Point3d SP = new Point3d();

Point3d Ep = new Point3d();
Line L;
for (int c = 0; c < Body.NumberOfVertices; c++)

{
L = new Line(Body.GetPoint3dAt(c),
Pr.GetClosestPointTo(Body.GetPoint3dAt(c), false));
if (L.Length > max)
{
max = L.Length;
Ep = L.StartPoint;
}
else if (L.Length < min)
{
min = L.Length;
SP = L.StartPoint;
}
}
L = new Line(SP, Ep);

SP = L.GetPointAtDist(L.Length / 2);
//max = 1000;
min = 1000;
foreach (MText T in Text)

{
L = new Line(SP, T.Location);
if (L.Length < min)
{
min = L.Length;
string[] Data = T.Contents.Split('\n');
Id = Data[0];
Cp = new Point3d(T.Location.X, T.Location.Y + 10, 0);

}
}
}
}
public class CCable

{
public string Id;
public string Parent;
public Polyline Body;
public Polyline Buffer;
public bool Status = false;
public CCable()
{
public CCable(Polyline body, string id, string parent)

{
Body = body;
Id = id;
Parent = parent;
}
public override string ToString()

{
return "Id: " + Id + " Parent: " + Parent + " Status:" +
Status.ToString();
}
}
public class CHH

{
public string Id;
public CHH Terminal;
public Point3d Body;
public string Fibers;
public string Station;
public string type;
public List<CParcel> Parcels = new List<CParcel>();
public CHH()
{
}
}
class CDatabase
{
//Local Database
static SQLiteConnection conn;
static SQLiteDataReader dr;
static SQLiteCommand cmd;
static System.Data.DataTable dt;
public string DataSource = (@"C:\GenXCTool\DB\Plannin");
public CDatabase(string dataSource)

{
DataSource = dataSource;
}
public CDatabase()
{
}
//If there's any error, Write a Log
public static void Log(string text)

{
string file = @"C:\GenXCTool\DB\Log.txt";
string txt = text;
File.AppendAllText(file, txt + "\n");

}
//Functions Local Database

public void conect()
{
try
{
string Coneccion = ("Data Source = " + DataSource);
conn = new SQLiteConnection(Coneccion);
conn.Open();
}

{
MessageBox.Show("Error al conectar con la base de datos= " +
Ex.ToString());
}
}
public void Save(string commd)

{
conect();
cmd = new SQLiteCommand(commd, conn);

cmd.ExecuteNonQuery();
conn.Close();
}
public void eliminar(string commd)

{
conect();

conn.Close();
}
public void Update(string commd)

{
conect();

conn.Close();
public System.Data.DataTable Select(string commd)

{
conect();

dr = cmd.ExecuteReader();
dt = new System.Data.DataTable();
dt.Load(dr);
conn.Close();
return dt;
}
public Boolean Existe(string commd)

{
try
{
int q = 0;
conect();
dr = cmd.ExecuteReader();
while (dr.Read())
{
q++;
}
if (q == 0)
return false;
else
return true;
}
{
//MessageBox.Show("Error al Cargar datos de la base de datos = " +
Ex.ToString());
File.AppendAllText(@"C:\GenXCTool\Temp Arc\Data.txt", commd + "\

n");
return false;
}
finally
{
conn.Close();
}
}
}
public class CPostgres

{
static System.Data.SQLite.SQLiteConnection Con;
//static SQLiteDataAdapter Da;
static SQLiteDataReader Dr;
static SQLiteCommand Com;
static string DataSource = @"C:\GenXCTool\DB\dbPrueba.db";
//static string DataSource = @"C:\GenXCTool\DB\KmlConf.db";
//static string DataSource1 = @"C:\Users\genxc\OneDrive - GenXC Group\
Documents - IT\GenXC Apps\Dinanyeli\Planning.db";
public void ClassDB(string Ds)

{
DataSource = Ds;
}
public void ClassDB()

{
public static void Ds(string Ds)

{
DataSource = Ds;
}
public void Conectar(string DataSource)

{
try
{
string Conexion = ("Data Source = " + DataSource);
Con = new System.Data.SQLite.SQLiteConnection(Conexion);
Con.Open();
//MessageBox.Show("done");
}
{
MessageBox.Show("Error al conectar con la base de datos= " +
Ex.ToString());
}
}
public void Set(string query, string DataSource)

{
try
{
Conectar(DataSource);
Com = new SQLiteCommand(query, Con);
Com.ExecuteNonQuery();
}
{
MessageBox.Show("Error al guardar en la base de datos= " +
Ex.ToString() + "\n" + query);
}
finally
{
Con.Close();
}
}
public void Guardar(string query)
{
try
{
MessageBox.Show("Cambios guardados Correctamente", "Guardar",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
{
Ex.ToString() + "\n" + query);
}
finally
{
Con.Close();
}
}
public Boolean Existe(string query)
{
try
{
int q = 0;
Dr = Com.ExecuteReader();
while (Dr.Read())
{
q++;
}
if (q == 0)
return false;
else
return true;
}
{
MessageBox.Show("Error al Cargar datos de la base de datos = " +
Ex.ToString());
return false;
}
finally
{
Con.Close();
}
}
#region Foto
public Byte[] Get(string query)

{
Byte[] Dat = null;
try
{
Dr = Com.ExecuteReader();
while (Dr.Read())
{
Dat = (byte[])Dr[0];
}
}
{
MessageBox.Show("Error al Conectar en la base de datos= " +
Ex.ToString());
}
finally
{
Con.Close();
}
return Dat;
}
public void GuardarFoto(byte[] B)
{
try
{
Com = new SQLiteCommand("Insert into Imagen Values(@imagen)", Con);
Com.Parameters.AddWithValue("@imagen", B);
MessageBox.Show("Cambios guardados Correctamente", "Guardar",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
{
Ex.ToString());
}
finally
{
Con.Close();
}
}
#endregion
public SQLiteCommand select(string query, string DataSource)
{
try
{
}
{
Ex.ToString());
}
finally
{
//Con.Close();
}
return Com;
}
public void ExecuteQuery(string txtQuery)

{
Com = Con.CreateCommand();
Com.CommandText = txtQuery;
Con.Close();
}
public System.Data.DataTable Datatable1(string cod, string DataSource)

{
System.Data.DataTable dt = new System.Data.DataTable();
DataSet ds = new DataSet();
Com = Con.CreateCommand();
SQLiteDataAdapter DB = new SQLiteDataAdapter(cod, Con);

ds.Reset();
DB.Fill(ds);
dt = ds.Tables[0];
Con.Close();
return dt;
}
public void Dispose()

{
Com.Dispose();
}
}
class CPolyline
{
public static void Lin2Pol(Polyline Pl, Line L)
{
Pl.AddVertexAt(Pl.NumberOfVertices, (new Point2d(L.StartPoint.X,
L.StartPoint.Y)), 0, 0, 0);
Pl.AddVertexAt(Pl.NumberOfVertices, (new Point2d(L.EndPoint.X,
L.EndPoint.Y)), 0, 0, 0);
Pl.Layer = L.Layer;
}
}
class CLayout
{
CBlock cBlock = new CBlock();
DBObjectCollection DB0 = new DBObjectCollection();
bool Layn = true;
CCentroide centroide = new CCentroide();
CPoint cPoint = new CPoint();
string Page = "";
public void Create_Viewport_Auto(CTransaction Trans, string Typ)

{
bool J = true;
int ViewportN = 0;
ArrayList Conts = new ArrayList();
while (J)
{
promptPointOptions.MessageForAdding = ("Select Cable");
{
foreach (ObjectId Obj in
{
DBObject entity = Trans.transaction.GetObject(Obj,
OpenMode.ForWrite);
if (entity is Polyline)
{
Polyline Pl = (Polyline)entity;
double Cont = 0;
//List<BlockReference> Vports = new

List<BlockReference>();
PromptSelectionResult selectLinesFollow3 =
Trans.editor.SelectAll();
if (selectLinesFollow3.Status == PromptStatus.OK)
{
foreach (ObjectId Obj3 in
selectLinesFollow3.Value.GetObjectIds())
{
DBObject entity3 =
Trans.transaction.GetObject(Obj3, OpenMode.ForWrite);
if (entity3 is BlockReference)
{
BlockReference Br =
(BlockReference)entity3;
string name = Br.IsDynamicBlock ?

((BlockTableRecord)Br.DynamicBlockTableRecord.GetObject(OpenMode.ForRead)).Name :
Br.Name;
if (name == "Vport")
{
Point3dCollection AB = new
Point3dCollection();
DBObjectCollection dBObjectCollection =
new DBObjectCollection();
Br.Explode(dBObjectCollection);
foreach (DBObject Db in
dBObjectCollection)
{
if (Db is Polyline)
{
Polyline Tpl = (Polyline)Db;
Tpl.IntersectWith(Pl,
Intersect.OnBothOperands, AB, IntPtr.Zero, IntPtr.Zero);
if (AB.Count > 0)
{
foreach (Point3d P in AB)
{
if
(Pl.GetDistAtPoint(P) > Cont)
{
Cont =
Pl.GetDistAtPoint(P);
}
}
}
}
}
foreach (ObjectId attId in

Br.AttributeCollection)
{
var acAtt =
Trans.transaction.GetObject(attId, OpenMode.ForWrite) as AttributeReference;
if (acAtt.Tag == "PAGE")
{
if
(Convert.ToInt32(acAtt.TextString) > ViewportN)
ViewportN =
Convert.ToInt32(acAtt.TextString);
}
}
}
}
}
}
ViewportN = ViewportN + 1;
while (Cont < Pl.Length)

{
bool LengF = false;
ObjectId ObjId = Trans.blockTable["Vport"];
BlockReference Br = new
BlockReference(Pl.GetPointAtDist(Cont), ObjId);
Br.Layer = "Vport";
if (Br.Position != new Point3d(0, 0, 0))

{
Line TempAngle = new Line();
if (Pl.Length > Cont + 50)

{
TempAngle = new
Line(Pl.GetPointAtDist(Cont), Pl.GetPointAtDist(Cont + 50));
}
else if (Cont - 50 > 0)
{
TempAngle = new Line(Pl.GetPointAtDist(Cont
- 50), Pl.GetPointAtDist(Cont));
LengF = true;
}
double RealAngle = 0;
RealAngle = TempAngle.Angle;
if(Typ == "360")
{
Br.Rotation = RealAngle;
}
if(Typ == "0_90")
{
if (RealAngle >= 0 && RealAngle <=
Math.PI / 180 * 45)
{
Br.Rotation = 0;
}
else if (RealAngle >= Math.PI / 180 * 315)

{
Br.Rotation = 0;
}
else if (RealAngle >= Math.PI / 180 * 135

&& RealAngle <= Math.PI / 180 * 225)
{
Br.Rotation = Math.PI / 180 * 180;
}
else if (RealAngle > Math.PI / 180 * 45 &&

RealAngle < Math.PI / 180 * 135)
{
}
else if (RealAngle > Math.PI / 180 * 225 &&

RealAngle < Math.PI / 180 * 315)
{
}
}
else if (Typ == "0")
{
Point3d Pos = new Point3d(0, 0, 0);
DBObjectCollection DbObjCol = new

DBObjectCollection();
Br.Explode(DbObjCol);
foreach (DBObject Db in DbObjCol)

{
if (Db is Polyline)
{
double Hi =
Tpl.GetDistanceAtParameter(2) - Tpl.GetDistanceAtParameter(1);
double Le =
Tpl.GetDistanceAtParameter(1);
Pos = new Point3d(Br.Position.X -

Le / 2, Br.Position.Y - Hi / 2, Br.Position.Z);
}
}
Br = new BlockReference(Pos, ObjId);
Br.Layer = "Vport";
Br.Rotation = 0;
Trans.Insert(Br, true);

{
var acAtt =
{
acAtt.TextString =
ViewportN.ToString("000");
ViewportN++;
}
}
DBObjectCollection dBObjectCollection = new

foreach (DBObject Db in dBObjectCollection)

{
if (Db is Polyline)
{
Tpl.IntersectWith(Pl,
Intersect.OnBothOperands, AB, IntPtr.Zero, IntPtr.Zero);
if (AB.Count > 0)
{
List<Point3d> LIP = new
List<Point3d>();
foreach (Point3d P in AB)

{
if (Pl.GetDistAtPoint(P) >
Cont)
Cont =
Pl.GetDistAtPoint(P);
}
}
}
if (!Conts.Contains(Cont.ToString()))
{
Conts.Add(Cont.ToString());
}
else
{
Cont += Cont;
}
if (LengF)
Cont += Pl.Length;
}
}
}
}
}
else
{
J = false;
}
J = false;
}
}
public void Create(CTransaction Trans)

{
List<BlockReference> LVp = Get_LVp(Trans);
while(Layn)
{
BlockReference Used_Vport = Get_Used_Vport(Trans, LVp);
if(Layn)
{
Create_Layout(Trans, Used_Vport);
SetLayoutOrder(Trans);
Create_Cover(Trans, Page);
Create_MatchLine(Trans, Used_Vport, LVp);
Create_North(Trans, Used_Vport);
}
}
}
public List<BlockReference> Get_LVp(CTransaction Trans)

{
List<BlockReference> LViewPort = new List<BlockReference>();
PromptSelectionResult selectLinesFollow = Trans.editor.SelectAll();

{
foreach (ObjectId objectid in
{
DBObject entityp = Trans.transaction.GetObject(objectid,
OpenMode.ForWrite);
if (entityp is BlockReference)
{
BlockReference Br = (BlockReference)entityp;
if (CBlock.GetBlockName(Br) == "Vport")
LViewPort.Add(entityp as BlockReference);
}
}
}
return LViewPort;
}
public BlockReference Get_Used_Vport(CTransaction Trans,

List<BlockReference> LVp)
{
BlockReference Used_Vport = new BlockReference(new Point3d(0, 0, 0),
Trans.blockTable["Vport"]);
double NearVport = 500;
PromptPointOptions promptPointOptions = new

PromptPointOptions("Point");
PromptPointResult selectStartPoint =
Trans.editor.GetPoint(promptPointOptions);
if (selectStartPoint.Status == PromptStatus.OK)
{
Point3d P3d = selectStartPoint.Value;
foreach (BlockReference Pl in LVp)

{
Point3dCollection P3dc = new Point3dCollection();
Pl.Explode(DB02);
foreach (DBObject Db in DB02)

{
if (Db is Polyline)
{
Polyline Tpol = (Polyline)Db;
Point3d Pc_Polyline_viewport =
centroide.GetCentroid(Tpol);
if (new Line(Pc_Polyline_viewport, P3d).Length <

NearVport)
{
NearVport = new Line(Pl.Position, P3d).Length;
Used_Vport = Pl;
}
}
}
}
}
else
{
Layn = false;
}
return Used_Vport;
}
private void Create_Layout(CTransaction Trans, BlockReference Used_Vport)

{
Viewport Vport = new Viewport();
Polyline PLC = new Polyline();
//Get Page In Vport

{
foreach (ObjectId attId in Used_Vport.AttributeCollection)
{
var acAtt = Trans.transaction.GetObject(attId,
OpenMode.ForWrite) as AttributeReference;
{
Page = acAtt.TextString;
}
}
}
//Get Polyline In Vport

{
DBObjectCollection DBOC = new DBObjectCollection();
Used_Vport.Explode(DBOC);
foreach (DBObject Db in DBOC)

{
if (Db is Polyline)
{
PLC = (Polyline)Db;
}
}
}
Point2d PC2d = centroide.GetCentroid_2d(PLC);
Application.SetSystemVariable("TILEMODE", 0);
Trans.editor.SwitchToPaperSpace();
LayoutManager acLayoutMgr = LayoutManager.Current;
if (acLayoutMgr.LayoutExists(Page))
{
acLayoutMgr.DeleteLayout(Page);
}
// Create the new layout with default settings

ObjectId objID = acLayoutMgr.CreateLayout(Page);
//lo coloque yo
Layout Aclayout = Trans.transaction.GetObject(objID, OpenMode.ForWrite)
as Layout;
//Set the layout current if it is not already

acLayoutMgr.CurrentLayout = Page;
//Set Page Setup

{
DBDictionary acPlSet =
Trans.transaction.GetObject(Trans.database.PlotSettingsDictionaryId,
OpenMode.ForRead) as DBDictionary;
if (acPlSet.Contains("11 X 17") == true)

{
PlotSettings plSet = acPlSet.GetAt("11 X
17").GetObject(OpenMode.ForRead) as PlotSettings;
Aclayout.UpgradeOpen();
Aclayout.CopyFrom(plSet);
}
}
//Creando y alineando Layout

{
var vpIds = Aclayout.GetViewports();
//configurando los viewports existentes
foreach (ObjectId vpId in vpIds)
{
Vport = Trans.transaction.GetObject(vpId, OpenMode.ForWrite) as
Viewport;
Vport.SetDatabaseDefaults();
//Vport.CenterPoint = new Point3d(/*7.0534*/7.4127,

/*6.1598*/6.9896, 0);
Vport.CenterPoint = new Point3d(7.4127, 5.5623, 0);
Vport.Width = 13.3000;
//Vport.Height = 8.3000;
//Vport.Height = 6.6282;
Vport.Height = 9.5000;
Vport.CustomScale = (1.0 / 30.0);
Circle C = new Circle();

C.Radius = 40;
C.Center = new Point3d(PC2d.X, PC2d.Y, 0);
Vport.ViewCenter = PC2d;
Vport.On = true;
}
SpaceAlign_General(Trans, vpIds, PLC);

}
}
public void Create_MatchLine(CTransaction Trans, BlockReference Used_Vport,

List<BlockReference> LVp)
{
Trans.End_Trans();
LayoutManager.Current.CurrentLayout = "Model";
List<Polyline> LRutes = new List<Polyline>();
Point3dCollection P3dc = new Point3dCollection();
Point3dCollection CableIntersectionPoint = new Point3dCollection();
Polyline VpPolyOri = new Polyline();
DB0 = new DBObjectCollection();
Used_Vport.Explode(DB0);

{
if (Db is Polyline)
{
for (int i = 0; i < Tpol.NumberOfVertices; i++)

{
P3dc.Add(Tpol.GetPoint3dAt(i));
}
P3dc.Add(Tpol.GetPoint3dAt(0));
VpPolyOri = Tpol;
}
}
List<Polyline> Lpl = new List<Polyline>();
Trans.editor.SelectCrossingPolygon(P3dc);
{

{
OpenMode.ForWrite);
if (entityp is Polyline)
{
Polyline polyline = (Polyline)entityp;
if ((polyline.Layer == "PROPOSED_AERIAL" || polyline.Layer

== "PROPOSED_UG" || polyline.Layer == "PROPOSED_BURIED") && polyline.Length > 10)
{
Point3dCollection intersectionPoints = new
polyline.IntersectWith(VpPolyOri,
Intersect.OnBothOperands, intersectionPoints, IntPtr.Zero, IntPtr.Zero);
if (intersectionPoints.Count > 0)
{
foreach (Point3d item in intersectionPoints)
{
CableIntersectionPoint.Add(item);
}
LRutes.Add(polyline);
}
Lpl.Add(polyline);
}
}
}
List<string> ml = new List<string>();

////polilineas
foreach (Polyline Pl in Lpl)
{
List<Point3d> LCorInter = new List<Point3d>();
double Max = 0;
double Min = Pl.Length;
Point3dCollection MyCableIntersectionPoint = new

foreach (Point3d Pd3 in CableIntersectionPoint)

{
if (Pl.GetClosestPointTo(Pd3, false) == Pd3)
{
if (Pl.GetDistAtPoint(Pd3) > Max)
Max = Pl.GetDistAtPoint(Pd3);
else if (Pl.GetDistAtPoint(Pd3) < Min)
Min = Pl.GetDistAtPoint(Pd3);
MyCableIntersectionPoint.Add(Pd3);
}
}
double Dc = Max - Min;
List<BlockReference> LVportVec = new List<BlockReference>();
foreach (BlockReference Br in LVp)

{
foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
{
Polyline polyline = Obj as Polyline;

polyline.IntersectWith(Pl,
{
LVportVec.Add(Br);
}
}
}
}
for (int i = 0; i < LVportVec.Count; i++)

{
for (int i2 = i; i2 < LVportVec.Count; i2++)
{
if
(Pl.GetDistAtPoint(Pl.GetClosestPointTo(LVportVec[i].Position, false)) >
Pl.GetDistAtPoint(Pl.GetClosestPointTo(LVportVec[i2].Position, false)))
{
BlockReference Tem = LVportVec[i];
LVportVec[i] = LVportVec[i2];
LVportVec[i2] = Tem;
}
}
}

{
MText mText = new MText();
mText.TextHeight = 10;
mText.Contents = i.ToString();
mText.Location = LVportVec[i].Position;
//Trans.Insert(mText, true);

LVportVec[i].AttributeCollection)
{
{
//MessageBox.Show(acAtt.TextString);
}
}
}
List<BlockReference> LFVportVec = new List<BlockReference>();

List<BlockReference> LFVportVecU = new List<BlockReference>();

{
{
{
if (acAtt.TextString == Page)
{
if (i > 0)
{
LFVportVec.Add(LVportVec[i - 1]);
}
if (LVportVec.Count > (i + 1))

{
LFVportVec.Add(LVportVec[i + 1]);
}
}
}
}
}
//MessageBox.Show("New Cable");
foreach (BlockReference BR in LFVportVec)

{
foreach (ObjectId attId in BR.AttributeCollection)
{
{
// MessageBox.Show(acAtt.TextString);
}
}
}
ArrayList IntvsVport = new ArrayList();
foreach (Point3d point3D in MyCableIntersectionPoint)

{
double Dist = 1500;
string PaGe = "";
BlockReference Tembr;
foreach (BlockReference Br in LFVportVec)

{
if (!LFVportVecU.Contains(Br))
{

{
{

{
foreach (Point3d P3f in
intersectionPoints)
{
if (new Line(point3D, P3f).Length <
Dist)
{
Dist = new Line(point3D,
P3f).Length;

{
var acAtt =
{
PaGe =
acAtt.TextString;
}
}
}
}
}
}
}
}
}

{
{

{
{

{
intersectionPoints)
{
if (new Line(point3D, P3f).Length
== Dist)
{
LFVportVecU.Add(Br);

{
var acAtt =
{
}
}
}
}
}
}
}
}
}
IntvsVport.Add(point3D.ToString() + "\n" + PaGe);

}
Polyline Dest = new Polyline();
//rectangulo
ObjectId Obj_Id = Trans.blockTable["vPORT2"];
// Insert the block into the current space

if (Obj_Id != ObjectId.Null)
{
//using (BlockReference Br = new BlockReference(new
Point3d(7.0536, 6.1437, 0), Obj_Id))
using (BlockReference Br = new BlockReference(new
Point3d(7.4127, 6.9896, 0), Obj_Id))
{
Br.ScaleFactors = new Scale3d(1, 1, 1);
Br.Layer = "Vport2";
BlockTableRecord Btr =
(BlockTableRecord)Trans.blockTable["vPORT2"].GetObject(OpenMode.ForWrite);


{
{
Dest = Obj as Polyline;
}
}
}
}
//Matchlines
foreach (Point3d P in MyCableIntersectionPoint)

{
bool Der = false;
if
(Dest.GetDistAtPoint(Dest.GetClosestPointTo(cPoint.Regla_3(VpPolyOri, Dest, P),
false)) < Dest.GetDistanceAtParameter(1))
{
Der = true;
}
else if
(Dest.GetDistAtPoint(Dest.GetClosestPointTo(cPoint.Regla_3(VpPolyOri, Dest, P),
{
Der = true;
}
string BlockName = "MatchLine";
if (Der)
BlockName = "MatchLine2";
//if (Pl.GetClosestPointTo(P, false) == P)

{
Obj_Id = Trans.blockTable[BlockName];

{
using (BlockReference Br = new
BlockReference(cPoint.Regla_3(VpPolyOri, Dest, P), Obj_Id))
{
Br.ScaleFactors = new Scale3d(0.8, 0.8, 0.8);
if
(Dest.GetDistAtPoint(Dest.GetClosestPointTo(Br.Position, false)) <
Dest.GetDistanceAtParameter(1))
{
//Br.Position = new Point3d(Br.Position.X,

Br.Position.Y + 0.1463, 0);
if (Br.Position.X > 12.7061)

{
Br.Position = new Point3d(12.7061,
Dest.GetClosestPointTo(Br.Position,false).Y, 0);
}
else if (Br.Position.X < 2.2615)
{
Dest.GetClosestPointTo(Br.Position, false).Y, 0);
}
else
{
Br.Position =
Dest.GetClosestPointTo(Br.Position, false);
}
//MessageBox.Show((Br.Rotation / Math.PI *
180).ToString());
}
else if
{
//Br.Position = new Point3d(Br.Position.X +

0.1463, Br.Position.Y, 0);
//if (Br.Position.Y < 3.2861)

//{
// Br.Position = new
Point3d(Br.Position.X, 3.2861, 0);
//}
if (Br.Position.Y < 2.2301)

{
Br.Position = new
Point3d(Dest.GetClosestPointTo(Br.Position, false).X, 2.2301, 0);
}
else if (Br.Position.Y > 8.9014)

{
Br.Position = new
}
else
{
Br.Position =
}
180).ToString());
}
else if
{

Br.Position.Y - 0.1463, 0);

{
}
{
}
else
{
Br.Position =
}
180).ToString());
}
else
{
//Br.Position = new Point3d(Br.Position.X -

//if (Br.Position.Y < 3.3957)

//{
// Br.Position = new
//}

{
Br.Position = new
}
{
Br.Position = new
}
else
{
Br.Position =
}
// MessageBox.Show((Br.Rotation / Math.PI *
180).ToString());
}
string Pag = "";
foreach (string S in IntvsVport)

{
if (S.Contains(P.ToString()))
{
Pag = S.Split('\n')[1];
}
}
if (!ml.Contains(Pag))
{
BlockTable blockTable =
Trans.transaction.GetObject(Trans.database.BlockTableId, OpenMode.ForWrite) as
BlockTable;
BlockTableRecord blkTbRecPaper =
Trans.transaction.GetObject(blockTable[BlockTableRecord.PaperSpace],
OpenMode.ForWrite) as BlockTableRecord;
blkTbRecPaper.AppendEntity(Br);
(BlockTableRecord)blockTable[BlockName].GetObject(OpenMode.ForWrite);
foreach (ObjectId id in Btr)

{
DBObject obj =
id.GetObject(OpenMode.ForWrite);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && !attDef.Constant)
{
using (AttributeReference attRef =
new AttributeReference())
{
attRef.SetAttributeFromBlock(attDef, Br.BlockTransform);
Br.AttributeCollection.AppendAttribute(attRef);
Trans.transaction.AddNewlyCreatedDBObject(attRef, true);
if (attRef.Tag ==
"DESCRIPTION")
{
attRef.TextString = "SEE
DRAWING# ";
}
else if (attRef.Tag == "PAGE"
|| attRef.Tag == "REF#")
{
attRef.TextString = Pag;
}
else
{
}
}
}
}
DynamicBlockReferencePropertyCollection
pcFST = Br.DynamicBlockReferencePropertyCollection;
foreach (DynamicBlockReferenceProperty dP
in pcFST)
{
if (dP.PropertyName == "Flip state1")
{
/* Trans.editor.WriteMessage(
$"\nName: {dP.PropertyName} " +
$"Type code: {dP.PropertyTypeCode}
" +
$"Unit type: {dP.UnitsType} " +
$"Allowed values: [{string.Join(",
", dP.GetAllowedValues())}]");*/
//dP.Value = "1";
}
}
bool Del = false;

{
var acAtt =
{
if (acAtt.TextString == "")
{
Del = true;
}
}
}
if (Del)
{
Br.Erase();
}
ml.Add(Pag);
}
}
}
}
}
}
}
}
public void Create_Cover(CTransaction Trans, string Page)

{
Trans.End_Trans();
//BlockReference Br = new BlockReference(new Point3d(8.3815, 5.3826,

0), Trans.blockTable["COVER"]);
BlockReference Br = new BlockReference(new Point3d(-0.2997, -0.0747,

0), Trans.blockTable["COVER"]);

DynamicBlockReferencePropertyCollection DBRC =
Br.DynamicBlockReferencePropertyCollection;
foreach (DynamicBlockReferenceProperty prop in DBRC)

{
if (prop.PropertyName == "PAGE")
{
prop.Value = Page;
}
}
Trans.Insert(Br, false);
}
public void Create_North(CTransaction Trans, BlockReference Used_Vport)

{
Trans.End_Trans();
Point3d PC = new Point3d(0, 0, 0);
PromptSelectionResult PSR = Trans.editor.SelectAll();

if (PSR.Status == PromptStatus.OK)
{
foreach (ObjectId Obj in PSR.Value.GetObjectIds())
{
DBObject DbObj = Trans.transaction.GetObject(Obj,
OpenMode.ForWrite);
if (DbObj is BlockReference)
{
BlockReference Br = DbObj as BlockReference;

Br.Name;
if (name == "NORTH ARROW")

{
PC = new Point3d(Br.Position.X, Br.Position.Y, 0);
}
}
}
}
Line L = new Line();

L.StartPoint = PC;
L.EndPoint = new Point3d(PC.X + 1, PC.Y, PC.Z);
var ang = L.GetFirstDerivative(L.GetParameterAtPoint(L.StartPoint));

ang = ang.GetNormal() * 0.53;
ang = ang.TransformBy(Matrix3d.Rotation(Used_Vport.Rotation, L.Normal,
Point3d.Origin));
var Li = new Line(L.GetPointAtDist(0) + ang, L.GetPointAtDist(0) -
ang);
//Trans.Insert(Li, true);
PLC.AddVertexAt(PLC.NumberOfVertices, new Point2d(Li.StartPoint.X,

Li.StartPoint.Y), 0, 0, 0);
PLC.AddVertexAt(PLC.NumberOfVertices, new Point2d(Li.EndPoint.X,
Li.EndPoint.Y), 0, 0, 0);
//Trans.Insert(PLC, true);
Layout Aclayout =
Trans.transaction.GetObject(acLayoutMgr.GetLayoutId(acLayoutMgr.CurrentLayout),
OpenMode.ForRead) as Layout;
Viewport acVport = new Viewport();

acVport.SetDatabaseDefaults();
//acVport.CenterPoint = new Point3d(13.1869, 1.5377, 0);

//acVport.Width = 0.8681;
//acVport.Height = 0.8681;
//acVport.CustomScale = 1;
acVport.CenterPoint = new Point3d(15.7268, 9.9652, 0);

acVport.Width = 0.8681;
acVport.Height = 0.8681;
acVport.CustomScale = 1;
acVport.ViewCenter = new Point2d(PC.X,PC.Y);
Trans.Insert(acVport, false);
acVport.On = true;
SpaceAlign_General_North(Trans, acVport, PLC);
}
public void SpaceAlign2(Polyline Pl, Viewport Vp)

{
var documentloc = doc.LockDocument();
ArrayList Lp = new ArrayList();
using (var tr = db.TransactionManager.StartTransaction())

{
{
var modelPt1 =
Pl.GetPointAtDist((Pl.GetDistAtPoint(Pl.GetPoint3dAt(1)) +
Pl.GetDistAtPoint(Pl.GetPoint3dAt(2))) / 2);
C.Radius = 15;
C.Center = modelPt1;
//Trans.Insert(C, true);
var modelPt2 =
Pl.GetPointAtDist((Pl.GetDistAtPoint(Pl.GetPoint3dAt(3)) + Pl.Length) / 2);
C = new Circle();
C.Radius = 15;
C.Center = modelPt2;
modelPt1 =
modelPt1.TransformBy(ed.CurrentUserCoordinateSystem);
modelPt2 =
C = new Circle();
C.Radius = 15;
C.Center = centroide.GetCentroid(Pl);
// ed.SwitchToPaperSpace();
var paperPt2 = new Point3d(1.2694, 6.1092, 0);

C = new Circle();
C.Radius = 2;
C.Center = paperPt2;
//Trans.Insert(C, false);

C = new Circle();
C.Radius = 2;
C.Center = paperPt1;
//Trans.Insert(C, false);
paperPt1 =
paperPt1.TransformBy(ed.CurrentUserCoordinateSystem);
paperPt2 =
var ucs = ed.CurrentUserCoordinateSystem;

AlignSpace(Vp, modelPt1, modelPt2, paperPt1, paperPt2);
//ed.SwitchToModelSpace();
}
tr.Commit();
}
}
public void SetLayoutOrder(CTransaction Trans)
{
string[] array =
((IEnumerable<string>)GetLayoutNames()).OrderBy<string, string>((Func<string,
string>)(l => l)).ToArray<string>();
Database workingDatabase = HostApplicationServices.WorkingDatabase;
LayoutManager current = LayoutManager.Current;
int num = 1;
foreach (string name in array)
{
(Trans.transaction.GetObject(current.GetLayoutId(name),
Autodesk.AutoCAD.DatabaseServices.OpenMode.ForWrite) as Layout).TabOrder = num;
++num;
}
}
public string[] GetLayoutNames()

{
List<Layout> source = new List<Layout>();
Database workingDatabase = HostApplicationServices.WorkingDatabase;
using (Transaction transaction =
workingDatabase.TransactionManager.StartTransaction())
{
foreach (DBDictionaryEntry dbDictionaryEntry in
(DBDictionary)transaction.GetObject(workingDatabase.LayoutDictionaryId,
Autodesk.AutoCAD.DatabaseServices.OpenMode.ForWrite))
{
ObjectId id = dbDictionaryEntry.Value;
source.Add(transaction.GetObject(id,
Autodesk.AutoCAD.DatabaseServices.OpenMode.ForWrite) as Layout);
}
}
int count = source.Count;
return source.Where<Layout>((Func<Layout, bool>)(l =>
l.LayoutName.ToUpper() != "MODEL")).Select<Layout, string>((Func<Layout, string>)(l
=> l.LayoutName)).ToArray<string>();
}
public void SpaceAlign_General(CTransaction Trans, ObjectIdCollection

vpIds, Polyline Pl)
{

{
Viewport Vport = Trans.transaction.GetObject(vpId,
OpenMode.ForWrite) as Viewport;
var modelPt1 =
Pl.GetPointAtDist(Pl.GetDistAtPoint(Pl.GetPoint3dAt(3)) + (Pl.Length -
Pl.GetDistAtPoint(Pl.GetPoint3dAt(3))) / 2);
//richTextBox1.Text += modelPt1.ToString() + "\n";
var modelPt2 =
Pl.GetPointAtDist(Pl.GetDistAtPoint(Pl.GetPoint3dAt(1)) +
(Pl.GetDistAtPoint(Pl.GetPoint3dAt(2)) - Pl.GetDistAtPoint(Pl.GetPoint3dAt(1))) /
2);
modelPt1 =
modelPt1.TransformBy(Trans.editor.CurrentUserCoordinateSystem);
modelPt2 =
var paperPt1 = new Point3d(Vport.CenterPoint.X - Vport.Width / 2,

Vport.CenterPoint.Y , 0);
//richTextBox1.Text += paperPt1.ToString() + "\n";
var paperPt2 = new Point3d(Vport.CenterPoint.X + Vport.Width / 2,

Vport.CenterPoint.Y, 0);
//Verify Points
{
Circle C = new Circle
{
Center = modelPt1,
Radius = 5
};
// Trans.Insert(C, true);
C = new Circle
{
Center = modelPt2,
Radius = 5
};
C = new Circle
{
Center = paperPt1,
Radius = 1
};
// Trans.Insert(C, false);
C = new Circle
{
Center = paperPt2,
Radius = 1
};
}
paperPt1 =
paperPt1.TransformBy(Trans.editor.CurrentUserCoordinateSystem);
paperPt2 =
var ucs = Trans.editor.CurrentUserCoordinateSystem;

AlignSpace(Vport, modelPt1, modelPt2, paperPt1, paperPt2);
}
}
public void SpaceAlign_General_North(CTransaction Trans, Viewport vpIds,
Polyline Pl)
{
var modelPt1 = Pl.EndPoint;
var modelPt2 = Pl.StartPoint;

modelPt1 =
modelPt2 =
//var paperPt1 = new Point3d(12.8216, 1.5396, 0);

////richTextBox1.Text += paperPt1.ToString() + "\n";
//var paperPt2 = new Point3d(13.6897, 1.5396, 0);

////richTextBox1.Text += paperPt2.ToString() + "\n";


//Verify Points
{
Circle C = new Circle
{
Center = modelPt1,
Radius = 5
};
C = new Circle
{
Center = modelPt2,
Radius = 5
};
C = new Circle
{
Center = paperPt1,
Radius = 1
};
C = new Circle
{
Center = paperPt2,
Radius = 1
};
}
paperPt1 =
paperPt2 =
var ucs = Trans.editor.CurrentUserCoordinateSystem;

AlignSpace(vpIds, modelPt1, modelPt2, paperPt1, paperPt2);
}
public void SpaceAlign2(Polyline Pl)

{
//this.Hide();
//MessageBox.Show(objectId.ToString());

var documentloc = doc.LockDocument();
ArrayList Lp = new ArrayList();
using (var tr = db.TransactionManager.StartTransaction())

{
Viewport vp;
if ((short)Application.GetSystemVariable("cvport") == 1)
{
promptPointOptions.MessageForAdding = ("\nSelect Viewport: ");
ed.GetSelection(promptPointOptions);
{
foreach (ObjectId objectId in
{
DBObject dBObject = tr.GetObject(objectId,
OpenMode.ForWrite);
if (dBObject is Viewport)
{
vp = (Viewport)tr.GetObject(objectId,
OpenMode.ForWrite);
ed.SwitchToModelSpace();
Application.SetSystemVariable("cvport", vp.Number);
/* var ppo = new PromptPointOptions("\nFirst

alignment point in model space: ");
var ppr = ed.GetPoint(ppo);
return;*/
/* ppo.Message = "\nSecond alignment point in model

space: ";
ppo.UseBasePoint = true;
ppo.BasePoint = modelPt1;
ppr = ed.GetPoint(ppo);
return;*/
var modelPt2 = Pl.GetPoint3dAt(2);
modelPt1 =
modelPt2 =
ed.SwitchToPaperSpace();

////richTextBox1.Text += paperPt1.ToString() + "\
n";

paperPt1 =
paperPt2 =

AlignSpace(vp, modelPt1, modelPt2, paperPt1,
paperPt2);
}
}
}
}
else
{
vp = (Viewport)tr.GetObject(ed.ActiveViewportId,
OpenMode.ForWrite);
var modelPt2 = Pl.GetPoint3dAt(2);

modelPt1 =
modelPt2 =
ed.SwitchToPaperSpace();


paperPt1 =
paperPt2 =

AlignSpace(vp, modelPt1, modelPt2, paperPt1, paperPt2);
tr.Commit();
}
//this.Show();
}
private void AlignSpace(Viewport vp, Point3d modelPoint1, Point3d

modelPoint2, Point3d paperPoint1, Point3d paperPoint2)
{
if (!vp.IsWriteEnabled)
vp.UpgradeOpen();
var locked = vp.Locked;

if (locked) vp.Locked = false;
modelPoint2 = new Point3d(modelPoint2.X, modelPoint2.Y, modelPoint1.Z);

var psdcs2wcs = DCS2WCS(vp) * PSDCS2DCS(vp);
var wcsPaperPt2 = new Point3d(paperPoint2.X, paperPoint2.Y,
paperPoint1.Z).TransformBy(psdcs2wcs);
var wcsPaperPt1 = paperPoint1.TransformBy(psdcs2wcs);
var vector1 = modelPoint1.GetVectorTo(modelPoint2);
var vector2 = wcsPaperPt1.GetVectorTo(wcsPaperPt2);
double rotation = vector1.GetAngleTo(vector2, Vector3d.ZAxis);
vp.TwistAngle += rotation;
var scale = vector2.Length / vector1.Length;
vp.CustomScale *= scale;
vp.UpdateDisplay();
wcsPaperPt1 = paperPoint1.TransformBy(DCS2WCS(vp) * PSDCS2DCS(vp));
var wcsPaperPt2d = new Point2d(wcsPaperPt1.X, wcsPaperPt1.Y);
vp.ViewCenter += new Vector2d(modelPoint1.X - wcsPaperPt2d.X,
modelPoint1.Y - wcsPaperPt2d.Y).TransformBy(Matrix2d.Rotation(rotation,
wcsPaperPt2d));
vp.Locked = locked;
}
public Matrix3d DCS2WCS(Viewport vp)

{
return
Matrix3d.Rotation(-vp.TwistAngle, vp.ViewDirection, vp.ViewTarget)
*
Matrix3d.Displacement(vp.ViewTarget - Point3d.Origin) *
Matrix3d.PlaneToWorld(vp.ViewDirection);
}
public Matrix3d WCS2DCS(Viewport vp)

{
return DCS2WCS(vp).Inverse();
}
public static Matrix3d DCS2PSDCS(Viewport vp)

{
return
Matrix3d.Scaling(vp.CustomScale, vp.CenterPoint) *
Matrix3d.Displacement(vp.CenterPoint.GetAsVector()) *
Matrix3d.Displacement(new Vector3d(-vp.ViewCenter.X, -
vp.ViewCenter.Y, 0.0));
}
public Matrix3d PSDCS2DCS(Viewport vp)

{
return DCS2PSDCS(vp).Inverse();
}
public void Clayout_Manual(CTransaction Trans)

{
CPoint Poi = new CPoint();
bool Layn = true;
Point3d P3d = new Point3d();
string name = "";
List<BlockReference> LViewPort = new List<BlockReference>();
List<Polyline> Cables = new List<Polyline>();
List<BlockReference> Vecinos = new List<BlockReference>();
Point3dCollection P3dc;
PromptPointOptions promptPointOptions = new

PromptPointOptions("Point");
PromptPointResult selectStartPoint =
Trans.editor.GetPoint(promptPointOptions);
if (selectStartPoint.Status == PromptStatus.OK)
{
P3d = selectStartPoint.Value;
}
else
{
Layn = false;
}
if (Layn)
{
PromptSelectionResult selectLinesFollow = Trans.editor.SelectAll();
{
{
OpenMode.ForWrite);
{
name = Br.IsDynamicBlock ?
Br.Name;
LViewPort.Add(entityp as BlockReference);
}
}
}
double dist = 5000;
ObjectId ObjId = Trans.blockTable["Vport"];
BlockReference Used_Vport = new BlockReference(new Point3d(0, 0,

0), ObjId);
double NearVport = 5000;
foreach (BlockReference Pl in LViewPort)

{
//if(new Line(Pl.Position,P3d).Length < NearVport)
{
P3dc = new Point3dCollection();
Pl.Explode(DB0);

{
if (Db is Polyline)
{
Point3d Pc_Polyline_viewport =
Poi.GetCentroid(Tpol);
if (new Line(Pc_Polyline_viewport, P3d).Length <

NearVport)
{
NearVport = new Line(Pl.Position, P3d).Length;
Used_Vport = Pl;
}
}
}
}
}
{
P3dc = new Point3dCollection();
Used_Vport.Explode(DB0);

{
if (Db is Polyline)
{
for (int i = 0; i < Tpol.NumberOfVertices; i++)

{
P3dc.Add(Tpol.GetPoint3dAt(i));
}
P3dc.Add(Tpol.GetPoint3dAt(0));
}
}

PLC.Layer = "0";
foreach (Point3d P in P3dc)

{
PLC.AddVertexAt(PLC.NumberOfVertices, new Point2d(P.X,
P.Y), 0, 0, 0);
}
//Trans.Insert(PLC, true);
string Page = "000";
foreach (ObjectId attId in Used_Vport.AttributeCollection)

{
{
Page = acAtt.TextString;
// MessageBox.Show(Page);
}
//MessageBox.Show(acAtt.Tag + " " + acAtt.TextString);

}
Polyline VpPolyOri = new Polyline();
Polyline VpPolyDes = new Polyline();
DBObjectCollection collection = new DBObjectCollection();
Used_Vport.Explode(collection);
foreach (DBObject item in collection)

{
if (item is Polyline)
VpPolyOri = (Polyline)item;
}
Create_Layout(P3dc, Page, Trans);

}
}
else
{
Trans.End_Trans();
}
}
private void Create_Layout(Point3dCollection P3dc, string Page,

CTransaction Trans)
{
CPoint Poi = new CPoint();
int CabCon = 1;
int Hhcon = 0;
double MaxX = 0;
double MinX = 0;
double MaxY = 0;
double MinY = 0;
double MaxWidth = 0;
Polyline Space = new Polyline();
Polyline VpPolyOri = PLC;
//Polyline VpPolyDes;
List<Polyline> LCable = new List<Polyline>();
Point3dCollection CableIntersectionPoint = new Point3dCollection();
foreach (Point3d P in P3dc)

PLC.AddVertexAt(PLC.NumberOfVertices, new Point2d(P.X, P.Y), 0, 0,
0);
//Trans.Insert(PLC,true);
Polyline PL05 = new Polyline();
List<BlockReference> LBR = new List<BlockReference>();

List<Polyline> Lpl = new List<Polyline>();
List<BlockReference> LVp = new List<BlockReference>();

ObjectIdCollection oidC = new ObjectIdCollection();
Trans.editor.SelectCrossingPolygon(P3dc);
{
PromptSelectionResult selectLines = Trans.editor.SelectAll();
if (selectLines.Status == PromptStatus.OK)
{
foreach (ObjectId objectid in selectLines.Value.GetObjectIds())
{
OpenMode.ForWrite);
{

Br.Name;
{
LVp.Add(Br);
}
}
}
}
Point3d PC3d = Poi.GetCentroid(PLC);

Point2d PC2d = new Point2d(PC3d.X, PC3d.Y);
if (acLayoutMgr.LayoutExists(Page))
{
acLayoutMgr.DeleteLayout(Page);
}
// Create the new layout with default settings

ObjectId objID = acLayoutMgr.CreateLayout(Page);
//lo coloque yo
Layout Aclayout = Trans.transaction.GetObject(objID,
OpenMode.ForWrite) as Layout;
{
Trans.transaction.GetObject(Trans.database.PlotSettingsDictionaryId,
OpenMode.ForRead) as DBDictionary;
if (acPlSet.Contains("11-17") == true)
{
PlotSettings plSet = acPlSet.GetAt("11-
Aclayout.CopyFrom(plSet);
}
}
// Set the layout current if it is not already
var vpIds = Aclayout.GetViewports();

//configurando los viewports existentes
{
var vp2 = Trans.transaction.GetObject(vpId, OpenMode.ForWrite)
as Viewport;
//MessageBox.Show("Vpid = " + vpId.ToString());
//vp2.ViewCenter = PC2d;
vp2.CenterPoint = new Point3d(10.2319, 7.7190, 0);
//vp2.StandardScale = StandardScaleType.Scale1To8inchAnd1ft;
//
vp2.Width = 9;
vp2.Height = 7;
vp2.CustomScale = (1.0 / 30.0);
//Application.ShowAlertDialog(vp2.ViewCenter.ToString());

C.Radius = 40;
C.Center = new Point3d(PC2d.X, PC2d.Y, 0);
vp2.ViewCenter = PC2d;
//vp2.ViewCenter = new Point2d(1282, 205);
vp2.On = true;
//freezing los layer dentro del viewport
ObjectIdCollection Layers = new ObjectIdCollection();
ObjectIdCollection Layers2 = new ObjectIdCollection();
acLyrTbl =
Trans.transaction.GetObject(Trans.database.LayerTableId, OpenMode.ForRead) as
LayerTable;
{
acLyrTblRec = Trans.transaction.GetObject(acObjId,
OpenMode.ForRead) as LayerTableRecord;
if (acLyrTblRec.Name == "FST-Schematic" || acLyrTblRec.Name

== "Vport")
{
Layers.Add(acLyrTblRec.ObjectId);
}
else
{
Layers2.Add(acLyrTblRec.ObjectId);
}
}
// vp2.FreezeLayersInViewport(Layers.GetEnumerator());
// vp2.ThawLayersInViewport(Layers2.GetEnumerator());
// vp2.Locked = true;
}
////cover
ObjectId Obj_Id = Trans.blockTable["AT&T_COVER"];

{
using (BlockReference Br = new BlockReference(new Point3d(9.5,
6.5, 0), Obj_Id))
{

{
if (prop.PropertyName == "PAGE")
{
prop.Value = Page;
}
}
BlockTable;
(BlockTableRecord)blockTable["AT&T_COVER"].GetObject(OpenMode.ForWrite);

{
DBObject obj = id.GetObject(OpenMode.ForWrite);
{
{
Br.BlockTransform);
}
}
}
}
}
////datos
Obj_Id = Trans.blockTable["BURIED STAMP"];

{
Point3d(15.1306, 5.3922, 0), Obj_Id))
{
Br.ScaleFactors = new Scale3d(10 / 12, 10 / 12, 10 / 12);

{
prop.Value = Page;
}
BlockTable;
BlockTableRecord Btr = (BlockTableRecord)blockTable["BURIED

STAMP"].GetObject(OpenMode.ForWrite);

{
{
{
Br.BlockTransform);
attRef.TextString = Page;
}
}
}
}
}
////detalles
Obj_Id = Trans.blockTable["Placement_Detail"];
{
//using (BlockReference Br = new BlockReference(new
Point3d(16.4035, 9.4734, 0), Obj_Id))
Point3d(16.2434, 10.1228, 0), Obj_Id))
{
//Br.ScaleFactors = new Scale3d(0.8, 0.8, 0.8);
BlockTable;
//Br.Rotation = Math.PI / 180 * 270;
(BlockTableRecord)blockTable["Placement_Detail"].GetObject(OpenMode.ForWrite);

{
{
{
Br.BlockTransform);
}
}
}
}
}
Polyline Dest = new Polyline();
//rectangulo
Obj_Id = Trans.blockTable["vPORT2"];

{
Point3d(10.2319, 7.7190, 0), Obj_Id))
{
BlockTable;
(BlockTableRecord)blockTable["vPORT2"].GetObject(OpenMode.ForWrite);

{
{
{
Br.BlockTransform);
}
}
}


{
{
Dest = Obj as Polyline;
}
}
}
}
List<string> ml = new List<string>();
////polilineas
///
foreach (Polyline Pl in Lpl)

{
List<Point3d> LCorInter = new List<Point3d>();
double Max = 0;
double Min = Pl.Length;
Point3dCollection MyCableIntersectionPoint = new

foreach (Point3d Pd3 in CableIntersectionPoint)

{
if (Pl.GetClosestPointTo(Pd3, false) == Pd3)
{
if (Pl.GetDistAtPoint(Pd3) > Max)
Max = Pl.GetDistAtPoint(Pd3);
else if (Pl.GetDistAtPoint(Pd3) < Min)
Min = Pl.GetDistAtPoint(Pd3);
MyCableIntersectionPoint.Add(Pd3);
}
}
double Dc = Max - Min;
List<BlockReference> LVportVec = new List<BlockReference>();
foreach (BlockReference Br in LVp)

{

{
{

{
LVportVec.Add(Br);
}
}
}
}

{
for (int i2 = i; i2 < LVportVec.Count; i2++)
{
if
(Pl.GetDistAtPoint(Pl.GetClosestPointTo(LVportVec[i].Position, false)) >
Pl.GetDistAtPoint(Pl.GetClosestPointTo(LVportVec[i2].Position, false)))
{
BlockReference Tem = LVportVec[i];
LVportVec[i] = LVportVec[i2];
LVportVec[i2] = Tem;
}
}
}

{
MText mText = new MText();
mText.TextHeight = 10;
mText.Contents = i.ToString();
mText.Location = LVportVec[i].Position;
//Trans.Insert(mText, true);

{
{
}
}
}
List<BlockReference> LFVportVec = new List<BlockReference>();

List<BlockReference> LFVportVecU = new List<BlockReference>();

{
{
{
if (acAtt.TextString == Page)
{
if (i > 0)
{
LFVportVec.Add(LVportVec[i - 1]);
}
if (LVportVec.Count > (i + 1))

{
LFVportVec.Add(LVportVec[i + 1]);
}
}
}
}
}
//MessageBox.Show("New Cable");
foreach (BlockReference BR in LFVportVec)

{
foreach (ObjectId attId in BR.AttributeCollection)
{
{
// MessageBox.Show(acAtt.TextString);
}
}
}
/* for (int i = 0; i < CableIntersectionPoint.Count; i++)

{
for (int i2 = i; i2 < CableIntersectionPoint.Count; i2++)
{
if(Pl.GetDistAtPoint(CableIntersectionPoint[i]) >
Pl.GetDistAtPoint(CableIntersectionPoint[i2]))
{
Point3d Tem = CableIntersectionPoint[i];
CableIntersectionPoint[i] =
CableIntersectionPoint[i2];
CableIntersectionPoint[i2] = Tem;
}
}
}*/
ArrayList IntvsVport = new ArrayList();
foreach (Point3d point3D in MyCableIntersectionPoint)

{
double Dist = 1500;
string PaGe = "";
BlockReference Tembr;

{
{

{
{

{
intersectionPoints)
{
if (new Line(point3D, P3f).Length <
Dist)
{
Dist = new Line(point3D,
P3f).Length;

{
var acAtt =
{
PaGe =
acAtt.TextString;
//
MessageBox.Show(point3D.ToString() + "\n" +PaGe);
}
}
}
}
}
}
}
}
}

{
{

{
{

{
intersectionPoints)
{
if (new Line(point3D, P3f).Length
== Dist)
{
LFVportVecU.Add(Br);

{
var acAtt =
{
}
}
}
}
}
}
}
}
}
IntvsVport.Add(point3D.ToString() + "\n" + PaGe);

}
//Matchlines
foreach (Point3d P in MyCableIntersectionPoint)

{
bool Der = false;
if
(Dest.GetDistAtPoint(Dest.GetClosestPointTo(Poi.Regla_3(VpPolyOri, Dest, P),
{
Der = true;
}
else if
(Dest.GetDistAtPoint(Dest.GetClosestPointTo(Poi.Regla_3(VpPolyOri, Dest, P),
{
Der = true;
}
string BlockName = "MatchLine";
if (Der)
BlockName = "MatchLine2";
//if (Pl.GetClosestPointTo(P, false) == P)

{
Obj_Id = Trans.blockTable[BlockName];

{
using (BlockReference Br = new
BlockReference(Poi.Regla_3(VpPolyOri, Dest, P), Obj_Id))
{
if
{

Br.Position.Y + 0.1463, 0);

{
Br.Position.Y, 0);
}
{
Br.Position.Y, 0);
}
180).ToString());
}
else if
{
//Br.Position = new Point3d(Br.Position.X +


{
Br.Position = new
}
{
Br.Position = new
}
180).ToString());
}
else if
{

Br.Position.Y - 0.1463, 0);

{
Br.Position.Y, 0);
}
{
Br.Position.Y, 0);
}
180).ToString());
}
else
{
//Br.Position = new Point3d(Br.Position.X -


{
Br.Position = new
}
{
Br.Position = new
}
// MessageBox.Show((Br.Rotation / Math.PI *
180).ToString());
}
string Pag = "";
foreach (string S in IntvsVport)

{
if (S.Contains(P.ToString()))
{
Pag = S.Split('\n')[1];
}
}
if (!ml.Contains(Pag))
{
BlockTable;
(BlockTableRecord)blockTable[BlockName].GetObject(OpenMode.ForWrite);

{
DBObject obj =
id.GetObject(OpenMode.ForWrite);
{
using (AttributeReference attRef =
new AttributeReference())
{
attRef.SetAttributeFromBlock(attDef, Br.BlockTransform);
if (attRef.Tag ==
"DESCRIPTION")
{
attRef.TextString = "SEE
PAGE# ";
}
else if (attRef.Tag == "PAGE"
|| attRef.Tag == "REF#")
{
attRef.TextString = Pag;
}
else
{
}
}
}
}
DynamicBlockReferencePropertyCollection
pcFST = Br.DynamicBlockReferencePropertyCollection;
foreach (DynamicBlockReferenceProperty dP
in pcFST)
{
if (dP.PropertyName == "Flip state1")
{
/* Trans.editor.WriteMessage(
$"\nName: {dP.PropertyName} " +
$"Type code: {dP.PropertyTypeCode}
" +
$"Unit type: {dP.UnitsType} " +
$"Allowed values: [{string.Join(",
", dP.GetAllowedValues())}]");*/
//dP.Value = "1";
}
}
bool Del = false;

{
var acAtt =
{
if (acAtt.TextString == "")
{
Del = true;
}
}
}
if (Del)
{
Br.Erase();
}
ml.Add(Pag);
}
}
}
}
}
}
////set vecinos
// Get the current document and database, and start a transaction


{
// Reference the Layout Manager
// Get the current layout and output its name in the Command Line
window
Layout acLayout =
acTrans.GetObject(acLayoutMgr.GetLayoutId(acLayoutMgr.CurrentLayout),
OpenMode.ForRead) as Layout;
acTrans.GetObject(acCurDb.PlotSettingsDictionaryId,
OpenMode.ForRead) as
DBDictionary;
// Check to see if the page setup exists

if (acPlSet.Contains("11-17") == true)
{
PlotSettings plSet = acPlSet.GetAt("11-
// Update the layout

acLayout.UpgradeOpen();
acLayout.CopyFrom(plSet);
// Save the new objects to the database

acTrans.Commit();
}
else
{
// Ignore the changes made
acTrans.Abort();
}
}
//Update the display*
acDoc.Editor.Regen();
//Trans.editor.SwitchToModelSpace();
SpaceAlign2(PLC);
}
static public void Create_plot()

{
BCLayout lay = new BCLayout();
lay.Trans = Trans;
lay.CreatePlot(
new string[] { "11 X 17", "11X17" },
new string[] { "DWF6 ePlot.pc3", "Microsoft Print to PDF" },
new string[] { "ANSI_FULL_BLEED_B_(11.00_x_17.00_Inches)",
"Tabloid" },
new bool[] { true, false });
Trans.End_Trans();
}
}
class CStreet
{
public void AddCl(CTransaction Trans)
{
WebClient Client = new WebClient();
GeoLocationData geo =
Trans.transaction.GetObject(Trans.database.GeoDataObject, OpenMode.ForWrite) as
GeoLocationData;
PromptPointOptions ppo = new PromptPointOptions("First Point:");

PromptPointResult psr = Trans.editor.GetPoint(ppo);
if (psr.Status == PromptStatus.OK)
{
PromptPointOptions ppo1 = new PromptPointOptions("Second Point:");
ppo1.BasePoint = psr.Value;
ppo1.UseBasePoint = true;
PromptPointResult psr1 = Trans.editor.GetPoint(ppo1);
if (psr1.Status == PromptStatus.OK)
{
List<double> X = new List<double>();

List<double> Y = new List<double>();
X.Add(geo.TransformToLonLatAlt(psr.Value).X);
X.Add(geo.TransformToLonLatAlt(psr1.Value).X);
//Application.ShowAlertDialog(geo.TransformToLonLatAlt(psr.Value).ToString());
//Application.ShowAlertDialog(geo.TransformToLonLatAlt(psr1.Value).ToString());
Y.Add(geo.TransformToLonLatAlt(psr.Value).Y);
Y.Add(geo.TransformToLonLatAlt(psr1.Value).Y);
string LongMin = X.Min().ToString("0.000");
string LatMin = Y.Min().ToString("0.000");
string LongMax = X.Max().ToString("0.000");
string LatMax = Y.Max().ToString("0.000");
if (File.Exists(@"C:\GenXCTool\Temp Arc\CL.txt"))
{
File.Delete(@"C:\GenXCTool\Temp Arc\CL.txt");
}
File.WriteAllText(@"C:\GenXCTool\Temp Arc\CL.txt",
Client.DownloadString("http://api.openstreetmap.org/api/0.6/map?bbox=" + LongMin +
"," + LatMin + "," + LongMax + "," + LatMax));
XmlDocument XDoc = new XmlDocument();
XDoc.Load(@"C:\GenXCTool\Temp Arc\CL.txt");
XmlNodeList xnNode = XDoc.GetElementsByTagName("node");
XmlNodeList xnWay = XDoc.GetElementsByTagName("way");
List<string> way = new List<string>();
string[] highway = new string[] { "motorway", "trunk",
"primary", "secondary", "tertiary", "unclassified", "residential", "road" };
bool flag = false;
bool flag0 = false;
foreach (XmlNode xWay in xnWay)
{
List<string> IdNode = new List<string>();
string Name = "";

string EOP = "";
string pre = "";
string Base = "";
string sux = "";
string IDWAY = "";
foreach (XmlAttribute xATT in xWay.Attributes)
{
if (xATT.Value == "id")
{
IDWAY = xATT.Value;
}
}
flag = false;
flag0 = false;
foreach (XmlNode xWayNode in xWay)
{
if (xWayNode.Name == "nd")
{
IdNode.Add(xWayNode.Attributes[0].Value);
}
if (xWayNode.Name == "tag")
{
if (xWayNode.Attributes[0].Value == "highway" &&

highway.Contains(xWayNode.Attributes[1].Value))
{
flag = true;
if (xWayNode.Attributes[1].Value ==
"residential")
{
EOP = "20.0";
}
}
"tiger:name_direction_prefix")
{
pre = xWayNode.Attributes[1].Value;
}
"tiger:name_base")
{
Base = xWayNode.Attributes[1].Value;
}
"tiger:name_type")
{
sux = xWayNode.Attributes[1].Value;
}
if (xWayNode ==
xWay.ChildNodes[xWay.ChildNodes.Count - 1])
{
flag0 = true;
}
}
if (flag && flag0)

{
Name = (pre + " " + Base + " " + sux).ToUpper();
Polyline pl = new Polyline();

foreach (string item in IdNode)
{
foreach (XmlNode xNo in xnNode)
{
bool flag2 = false;
double lon = 0.0;
double lat = 0.0;
foreach (XmlAttribute xATT in
xNo.Attributes)
{
if (xATT.Name == "id" && xATT.Value ==

item)
{
flag2 = true;
}
if (flag2)
{
if (xATT.Name == "lon")
{
lon =
Convert.ToDouble(xATT.Value);
}
if (xATT.Name == "lat")
{
lat =
Convert.ToDouble(xATT.Value);
}
}
if (flag2)
{
//Application.ShowAlertDialog(lat.ToString()+","+lon.ToString());
pl.AddVertexAt(pl.NumberOfVertices, new
Point2d(geo.TransformFromLonLatAlt(new Point3d(lon, lat, 0)).X,
geo.TransformFromLonLatAlt(new Point3d(lon, lat, 0)).Y), 0, 0, 0);
}
Trans.Insert(pl, true);
Trans.Hyper(pl, Name, EOP, "");
//dgvCenterLine.Rows.Add(pl.Handle.Value.ToString(),Name, pl.Hyperlinks[0].Name,
pl.Hyperlinks[0].SubLocation);
pl.Layer = "Streets";
}
}
}
}
}
}
}

CClass

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CClass

Uploaded by

Copyright:

Available Formats

using System.

using Exception = System.Exception;

using Excel = Microsoft.Office.Interop.Excel;

public class CTable_Excel

var excel = new Excel.Application();

var wbs = excel.Workbooks.Open(excelFileName);

foreach (Excel.Worksheet sheet in wbs.Worksheets)

static public void TableFromSpreadsheet(string Arc, int She, string Ran,

var doc = Application.DocumentManager.MdiActiveDocument;

var sheetNames = GetSheetNames(Arc);

var dlm = db.DataLinkManager;

var dlId = dlm.GetDataLink(dlName);

var dl = new DataLink();

//dl.Description = "Excel fun with Through the Interface";

dl.ConnectionString = Arc + "!" + sheetNames[She - 1] + "!" + Ran;

using (var tr = doc.TransactionManager.StartTransaction())

var tb = new Autodesk.AutoCAD.DatabaseServices.Table();

var btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId,

public void TableFromSpreadsheet5(string Arc, int She, string Ran, Point3d

const string dlName = "Example";

// Ask the user to select an XLS(X) file

/* var ofd = new Autodesk.AutoCAD.Windows.OpenFileDialog( "Select Excel

// Display the name of the file and the contained sheets

Trans.editor.WriteMessage("\nFile selected was \"{0}\". Contains these

// First we get the sheet names

var sheetNames = GetSheetNames(Arc);

Trans.editor.WriteMessage("\nWorkbook doesn't contain any

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

Trans.editor.WriteMessage("\n{0} - {1}", i + 1, name);

// Ask the user to select one

/* var pio = new PromptIntegerOptions("\nSelect a sheet");

var pir = ed.GetInteger(pio);

// Ask the user to select a range of cells in the spreadsheet

// We'll use a Regular Expression that matches a column (with

// one or more letters) followed by a numeric row (which we're

// naming "row1" so we can validate it's > 0 later),

// followed by a colon and then the same (but with "row2")

const string rangeExp ="^[A-Z]+(?<row1>[0-9]+):[A-Z]+(?<row2>[0-9]+)$";

bool done = false;

string range = "";

/* var psr = ed.GetString("\nEnter cell range <entire sheet>");

// Default is to select entire sheet

// If a string was entered, make sure it's a

// valid cell range, which means it matches the

// Regular Expression and has positive (non-zero)

var m =Regex.Match( Ran, rangeExp, RegexOptions.IgnoreCase);

//if (m.Success && Int32.Parse(m.Groups["row1"].Value) > 0 &&

Trans.editor.WriteMessage("\nInvalid range, please try

// Ask for the insertion point of the table

/* var ppr = ed.GetPoint("\nEnter table insertion point");

var dlm = Trans.database.DataLinkManager;

var dlId = dlm.GetDataLink(dlName);

var tb = new Table();

public void TableFromSpreadsheet3(ObjectId Idt, Point3d Pc, CTransaction

var tb = new Table();

public void SaveDatalink(string Arc, int She, string Ran)

var sheetNames = GetSheetNames(Arc);

string dlName = "Example";

var dlId = dlm.GetDataLink(dlName);

// a direction connection to the selected sheet

var dl = new DataLink();

dl.Description = "Excel fun with Through the Interface";

dl.ConnectionString = Arc + "!" + sheetNames[She - 1] + "!" +

CTable_Excel E = new CTable_Excel();