public List <Db.ObjectId> GetPipeIdByName(string[] pipeNames)
{
Ed.Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
Civ.CivilDocument civDoc = Autodesk.Civil.ApplicationServices.CivilApplication.ActiveDocument;
var pipeIds = new List <Db.ObjectId>();
// Iterate through each pipe network
using (Db.Transaction ts = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Database.TransactionManager.StartTransaction()) {
try {
foreach (Db.ObjectId networkId in civDoc.GetPipeNetworkIds())
{
CivDb.Network oNetwork = ts.GetObject(networkId, Db.OpenMode.ForWrite) as CivDb.Network;
foreach (Db.ObjectId pipeId in oNetwork.GetPipeIds())
{
CivDb.Pipe oPipe = ts.GetObject(pipeId, Db.OpenMode.ForRead) as CivDb.Pipe;
foreach (string name in pipeNames)
{
if (oPipe.Name == name)
{
pipeIds.Add(oPipe.Id);
}
}
}
}
return(pipeIds);
} catch (Autodesk.AutoCAD.Runtime.Exception ex) {
ed.WriteMessage("StructurePipesData: " + ex.Message);
return(null);
}
}
}
private static void SetDrawOrderInBlock(App.Document dwg, Db.ObjectId blkId)
{
using (Db.Transaction tran =
dwg.TransactionManager.StartTransaction())
{
Db.BlockReference bref = (Db.BlockReference)tran.GetObject(
blkId, Db.OpenMode.ForRead);
Db.BlockTableRecord bdef = (Db.BlockTableRecord)tran.GetObject(
bref.BlockTableRecord, Db.OpenMode.ForWrite);
Db.DrawOrderTable doTbl = (Db.DrawOrderTable)tran.GetObject(
bdef.DrawOrderTableId, Db.OpenMode.ForWrite);
Db.ObjectIdCollection col = new Db.ObjectIdCollection();
foreach (Db.ObjectId id in bdef)
{
if (id.ObjectClass == Rtm.RXObject.GetClass(typeof(Db.Wipeout)))
{
col.Add(id);
}
}
if (col.Count > 0)
{
doTbl.MoveToBottom(col);
}
tran.Commit();
}
}
private static void AddText(Gem.Point2d pnt, string layer, string str)
{
App.Document acDoc = App.Application.DocumentManager.MdiActiveDocument;
Db.Database acCurDb = acDoc.Database;
// старт транзакции
using (Db.Transaction acTrans = acCurDb.TransactionManager.StartOpenCloseTransaction())
{
// Открытие таблицы Блоков для чтения
Db.BlockTable acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, Db.OpenMode.ForRead) as Db.BlockTable;
// Открытие записи таблицы Блоков пространства Модели для записи
Db.BlockTableRecord acBlkTblRec = acTrans.GetObject(acBlkTbl[Db.BlockTableRecord.ModelSpace],
Db.OpenMode.ForWrite) as Db.BlockTableRecord;
Db.MText acMText = new Db.MText();
acMText.SetDatabaseDefaults();
acMText.Location = new Gem.Point3d(pnt.X, pnt.Y, 0);
acMText.Contents = str;
acMText.Height = SettingsParser.getInstance()._Scale.Coord;
acMText.Color = Autodesk.AutoCAD.Colors.
Color.FromColorIndex(Autodesk.AutoCAD.Colors.ColorMethod.ByLayer, 256);
acMText.Layer = layer;
acMText.SetDatabaseDefaults();
// Добавление нового объекта в запись таблицы блоков и в транзакцию
acBlkTblRec.AppendEntity(acMText);
acTrans.AddNewlyCreatedDBObject(acMText, true);
// Сохранение нового объекта в базе данных
acTrans.Commit();
}
}
public void DeleteAllObjects()
{
using (DocumentLock doclock = Document.LockDocument())
{
using (AcDb.Transaction trans = TransactionManager.StartTransaction())
{
foreach (var obj in (ObjectList.FindAll(p => p.ToolpathCurve != null || p.ProcessActions != null)))
{
if (obj.ToolpathCurve != null)
{
trans.GetObject(obj.ToolpathCurve.ObjectId, AcDb.OpenMode.ForWrite);
obj.ToolpathCurve.Erase();
}
else
{
obj.ProcessActions.ForEach(p =>
{
trans.GetObject(p.Toolpath.ObjectId, AcDb.OpenMode.ForWrite);
p.Toolpath.Erase();
});
}
}
trans.Commit();
Editor.UpdateScreen();
}
}
ObjectList.Clear();
}
} //WriteResourceToFile
internal static Db.ObjectId GetIDbyName <T>(Db.Database db, string strName)
{
Db.ObjectId RecId = Db.ObjectId.Null;
using (Db.Transaction tr1 = db.TransactionManager.StartTransaction())
{
if (typeof(T) == typeof(Db.MLeaderStyle))
{
Db.DBDictionary mlstyles = (Db.DBDictionary)tr1.GetObject(
db.MLeaderStyleDictionaryId,
Db.OpenMode.ForRead);
RecId = (mlstyles.Contains(strName)) ? mlstyles.GetAt(strName) : Db.ObjectId.Null;
}
else if (typeof(T) == typeof(Db.LayerTableRecord))
{
Db.LayerTable layerTable;
layerTable = (Db.LayerTable)tr1.GetObject(db.LayerTableId,
Db.OpenMode.ForRead);
RecId = (layerTable.Has(strName)) ? layerTable[strName] : Db.ObjectId.Null;
}
tr1.Commit();
}
// Все еще можно получить Db.ObjectId.Null для передачи.
return(RecId);
}
private static void AddCircle(Gem.Point2d pnt, string layer)
{
App.Document acDoc = App.Application.DocumentManager.MdiActiveDocument;
Db.Database acCurDb = acDoc.Database;
// старт транзакции
using (Db.Transaction acTrans = acCurDb.TransactionManager.StartOpenCloseTransaction())
{
// Открытие таблицы Блоков для чтения
Db.BlockTable acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId,
Db.OpenMode.ForRead) as Db.BlockTable;
// Открытие записи таблицы Блоков пространства Модели для записи
Db.BlockTableRecord acBlkTblRec = acTrans.GetObject(acBlkTbl[Db.BlockTableRecord.ModelSpace],
Db.OpenMode.ForWrite) as Db.BlockTableRecord;
Db.Circle acCircle = new Db.Circle();
acCircle.SetDatabaseDefaults();
acCircle.Center = new Gem.Point3d(pnt.X, pnt.Y, 0);
acCircle.Radius = SettingsParser.getInstance()._Scale.Circle;
acCircle.Layer = layer;
// Добавление нового объекта в запись таблицы блоков и в транзакцию
acBlkTblRec.AppendEntity(acCircle);
acTrans.AddNewlyCreatedDBObject(acCircle, true);
// Сохранение нового объекта в базе данных
acTrans.Commit();
}
}
public void DeleteObject(ProcessObject obj)
{
// TODO удалить обработчики
//obj.ProcessCurve.Modified -= ProcessCurveModifiedEventHandler;
//obj.ProcessCurve.Erased -= ProcessCurveErasedEventHandler;
if (obj.ToolpathCurve != null || obj.ProcessActions != null)
{
using (DocumentLock doclock = Document.LockDocument())
{
using (AcDb.Transaction trans = TransactionManager.StartTransaction())
{
if (obj.ToolpathCurve != null)
{
trans.GetObject(obj.ToolpathCurve.ObjectId, AcDb.OpenMode.ForWrite);
obj.ToolpathCurve.Erase();
}
else
{
obj.ProcessActions.ForEach(p =>
{
trans.GetObject(p.Toolpath.ObjectId, AcDb.OpenMode.ForWrite);
p.Toolpath.Erase();
});
}
trans.Commit();
Editor.UpdateScreen();
}
}
}
RemoveConnect(obj, VertexType.Start);
RemoveConnect(obj, VertexType.End);
ObjectList.Remove(obj);
ObjectForm.RefreshList();
}
public override List <string> GetObjectsInView()
{
var objs = new List <string>();
using (AcadDb.Transaction tr = Doc.Database.TransactionManager.StartTransaction())
{
AcadDb.BlockTable blckTbl = tr.GetObject(Doc.Database.BlockTableId, AcadDb.OpenMode.ForRead) as AcadDb.BlockTable;
AcadDb.BlockTableRecord blckTblRcrd = tr.GetObject(blckTbl[AcadDb.BlockTableRecord.ModelSpace], AcadDb.OpenMode.ForRead) as AcadDb.BlockTableRecord;
foreach (AcadDb.ObjectId id in blckTblRcrd)
{
var dbObj = tr.GetObject(id, AcadDb.OpenMode.ForRead);
if (dbObj is AcadDb.BlockReference)
{
var blckRef = (AcadDb.BlockReference)dbObj; // skip block references for now
}
else
{
objs.Add(dbObj.Handle.ToString());
}
}
// TODO: this returns all the doc objects. Need to check for visibility later.
tr.Commit();
}
return(objs);
}
public int processObjectId(DB.Transaction tr, DB.ObjectId objId, FindReplacer findReplacer)
{
int replaced = 0;
var ent = tr.GetObject(objId, DB.OpenMode.ForWrite, false);
if (ent is DB.Table)
{
var tbl = ent as DB.Table;
if (tbl.NumRows > 0 && tbl.NumColumns > 0)
{
for (var r = 0; r < tbl.NumRows; r++)
{
for (var c = 0; c < tbl.NumColumns; c++)
{
var text = tbl.GetTextString(r, c, 0, DB.FormatOption.FormatOptionNone);
var textWithoutFormat = tbl.GetTextString(r, c, 0, DB.FormatOption.IgnoreMtextFormat);
if (findReplacer.ContainsIn(text, textWithoutFormat))
{
tbl.SetTextString(r, c, text.Replace(findReplacer.Find, findReplacer.Replace));
replaced++;
}
}
}
}
}
else if (ent is DB.MText)
{
var mtext = ent as DB.MText;
var text = mtext.Contents;
var textWithoutFormat = mtext.Text;
if (findReplacer.ContainsIn(text, textWithoutFormat))
{
mtext.Contents = text.Replace(findReplacer.Find, findReplacer.Replace);
replaced++;
}
}
else if (ent is DB.DBText)
{
var dbtext = ent as DB.DBText;
var text = dbtext.TextString;
if (findReplacer.ContainsIn(text, text))
{
dbtext.TextString = text.Replace(findReplacer.Find, findReplacer.Replace);
replaced++;
}
}
else if (ent is DB.BlockReference)
{
var br = ent as DB.BlockReference;
var brId = br.IsDynamicBlock ? br.DynamicBlockTableRecord : br.BlockTableRecord;
var btr = (DB.BlockTableRecord)tr.GetObject(brId, DB.OpenMode.ForRead, false);
foreach (DB.ObjectId objId2 in btr)
{
processObjectId(tr, objId2, findReplacer);
}
}
return(replaced);
}
static public void SpaceOnAttributeName()
{
// Получение текущего документа и базы данных
App.Document acDoc = App.Application.DocumentManager.MdiActiveDocument;
Db.Database acCurDb = acDoc.Database;
Ed.Editor acEd = acDoc.Editor;
// старт транзакции
using (Db.Transaction acTrans = acCurDb.TransactionManager.StartOpenCloseTransaction())
{
Db.TypedValue[] acTypValAr = new Db.TypedValue[1];
acTypValAr.SetValue(new Db.TypedValue((int)Db.DxfCode.Start, "INSERT"), 0);
Ed.SelectionFilter acSelFtr = new Ed.SelectionFilter(acTypValAr);
Ed.PromptSelectionResult acSSPrompt = acDoc.Editor.GetSelection(acSelFtr);
if (acSSPrompt.Status == Ed.PromptStatus.OK)
{
Ed.SelectionSet acSSet = acSSPrompt.Value;
foreach (Ed.SelectedObject acSSObj in acSSet)
{
if (acSSObj != null)
{
if (acSSObj.ObjectId.ObjectClass.IsDerivedFrom(Rtm.RXClass.GetClass(typeof(Db.BlockReference))))
{
Db.BlockReference acEnt = acTrans.GetObject(acSSObj.ObjectId,
Db.OpenMode.ForRead) as Db.BlockReference;
Db.BlockTableRecord blr = acTrans.GetObject(acEnt.BlockTableRecord,
Db.OpenMode.ForRead) as Db.BlockTableRecord;
if (acEnt.IsDynamicBlock)
{
blr = acTrans.GetObject(acEnt.DynamicBlockTableRecord,
Db.OpenMode.ForRead) as Db.BlockTableRecord;
}
if (blr.HasAttributeDefinitions)
{
foreach (Db.ObjectId id in blr)
{
if (id.ObjectClass.IsDerivedFrom(Rtm.RXClass.GetClass(typeof(Db.AttributeDefinition))))
{
Db.AttributeDefinition acAttrRef = acTrans.GetObject(id,
Db.OpenMode.ForWrite) as Db.AttributeDefinition;
if (acAttrRef != null)
{
acAttrRef.Tag = acAttrRef.Tag.Replace('_', ' ');
}
}
}
}
}
}
}
}
acTrans.Commit();
}
}
void StreamCollectClipBodiesSample()
{
Database db = GetDatabase();
Editor editor = GetEditor();
editor.WriteMessage("* StreamCollectClipBodies *\n");
editor.WriteMessage("StreamCollectClipBodies clips all geometry pushed in against the supplied body.\n");
editor.WriteMessage("Pick some objects in the current drawing and then pick an mass element to define the clipping boundary. The collected graphics will be highlighted in the current view.\n");
ObjectIdCollection ids = PickObjectSet("Please pick the objects to be clipped");
if (ids.Count == 0)
{
editor.WriteMessage("No object is picked\n");
return;
}
ObjectId massElemId = PickObject(typeof(MassElement), true, "Please pick a mass element to define the clipping boundary");
if (massElemId.IsNull)
{
editor.WriteMessage("A mass element is needed to define the clipping boundary.\n");
return;
}
StreamCollectClipBodies stream = new StreamCollectClipBodies(db);
// You may tell the stream to retain bodies instead of turning bodies into shells.
// stream.SetRetainBodies(true);
// But now we use the default setting, which uses shell as output.
TransactionManager tm = db.TransactionManager;
using (Transaction trans = tm.StartTransaction())
{
MassElement masselem = trans.GetObject(massElemId, OpenMode.ForRead) as MassElement;
AecModeler.Body body = masselem.Body.Transform(masselem.Ecs);
stream.SetBodyClipVolume(body);
stream.PushDisplayParameters(DictionaryDisplayConfiguration.GetStandardDisplayConfiguration(db), trans);
foreach (ObjectId id in ids)
{
Entity entity = trans.GetObject(id, OpenMode.ForRead) as Entity;
stream.Stream(entity);
}
stream.PopDisplayParameters();
trans.Commit();
}
GraphicsStorage[] gsCollection = stream.GetCollectedGraphics();
foreach (GraphicsStorage gs in gsCollection)
{
HighlightGraphics(gs);
}
}
/// <summary>
/// This is Extension Method for the <c>Autodesk.AutoCAD.DatabaseServices.LayoutManager</c>
/// class. It gets the localized name of the Model tab.
/// </summary>
/// <param name="mng">Target <c>Autodesk.AutoCAD.DatabaseServices.LayoutManager</c>
/// instance.</param>
/// <returns>Returns the name of current space.</returns>
public static String GetModelTabLocalizedName(this Db.LayoutManager mng)
{
Db.Database db = cad.DocumentManager.MdiActiveDocument.Database;
String modelTabLocalizedName = String.Empty;
using (Db.Transaction tr = db.TransactionManager.StartTransaction())
{
Db.BlockTable bt = tr.GetObject(db.BlockTableId, Db.OpenMode.ForRead) as Db.BlockTable;
Db.BlockTableRecord btr = tr.GetObject(bt[Db.BlockTableRecord.ModelSpace], Db.OpenMode.ForRead)
as Db.BlockTableRecord;
modelTabLocalizedName = (tr.GetObject(btr.LayoutId, Db.OpenMode.ForRead) as Db.Layout).LayoutName;
}
return(modelTabLocalizedName);
}
/// <summary>
/// 清理指定图层
/// </summary>
/// <param name="strLayer">图层名</param>
/// <param name="isErase">是否删除图层</param>
public static void ClearLayer(string strLayer, bool isErase)
{
Database db = HostApplicationServices.WorkingDatabase;
Autodesk.AutoCAD.DatabaseServices.TransactionManager transactionManager = db.TransactionManager;
using (Autodesk.AutoCAD.DatabaseServices.Transaction trans = transactionManager.StartTransaction())
{
BlockTable blkTab = trans.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
foreach (ObjectId blkRecId in blkTab)
{
BlockTableRecord btr = trans.GetObject(blkRecId, OpenMode.ForRead) as BlockTableRecord;
foreach (ObjectId id in btr)
{
Entity ent = trans.GetObject(id, OpenMode.ForRead) as Entity;
if (ent.Layer == strLayer)
{
LayerTableRecord entLayer = trans.GetObject(ent.LayerId, OpenMode.ForRead) as LayerTableRecord;
if (!(entLayer.IsFrozen || entLayer.IsLocked))
{
ent.UpgradeOpen();
ent.Erase(true);
}
}
}
}
trans.Commit();
}
if (!isErase)
{
return;
}
using (Transaction trans = db.TransactionManager.StartTransaction())
{
LayerTable laTab = trans.GetObject(db.LayerTableId, OpenMode.ForWrite) as LayerTable;
if (laTab != null)
{
if (laTab.Has(strLayer))
{
ObjectId layerTabRecId = laTab[strLayer];
LayerTableRecord layerTabRec = trans.GetObject(layerTabRecId, OpenMode.ForWrite) as LayerTableRecord;
if (layerTabRec != null)
{
layerTabRec.Erase();
}
}
}
trans.Commit();
}
}
TestImageAngle()
{
Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
PromptEntityOptions prOpts = new PromptEntityOptions("\nSelect an Image");
prOpts.SetRejectMessage("\nSelected entity must by of type RasterImage");
prOpts.AddAllowedClass(typeof(RasterImage), false);
PromptEntityResult prRes = ed.GetEntity(prOpts);
if (prRes.Status == PromptStatus.OK)
{
Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = prRes.ObjectId.Database.TransactionManager;
using (Autodesk.AutoCAD.DatabaseServices.Transaction tr = tm.StartTransaction()) {
RasterImage imgObj = (RasterImage)tr.GetObject(prRes.ObjectId, OpenMode.ForRead);
CoordinateSystem3d entEcs = imgObj.Orientation;
Vector3d arbXAxis = Utils.Db.GetEcsXAxis(entEcs.Zaxis); // get AutoCAD's arbitrary X-Axis
double rotAngle1 = arbXAxis.GetAngleTo(entEcs.Xaxis, entEcs.Zaxis);
ed.WriteMessage(string.Format("\nECS rotation angle: {0}", Autodesk.AutoCAD.Runtime.Converter.AngleToString(rotAngle1, AngularUnitFormat.Current, -1)));
Plane ucsPlane = Utils.Db.GetUcsPlane(prRes.ObjectId.Database);
double rotAngle2 = entEcs.Xaxis.AngleOnPlane(ucsPlane);
ed.WriteMessage(string.Format("\nRotation angle relative to UCS: {0}", Autodesk.AutoCAD.Runtime.Converter.AngleToString(rotAngle2, AngularUnitFormat.Current, -1)));
tr.Commit();
}
}
}
private bool GetOrMakeLayer(string layerName, AcadDb.Transaction tr, out string cleanName)
{
cleanName = Utils.RemoveInvalidChars(layerName);
try
{
AcadDb.LayerTable lyrTbl = tr.GetObject(Doc.Database.LayerTableId, AcadDb.OpenMode.ForRead) as AcadDb.LayerTable;
if (lyrTbl.Has(cleanName))
{
return(true);
}
else
{
lyrTbl.UpgradeOpen();
var _layer = new AcadDb.LayerTableRecord();
// Assign the layer properties
_layer.Color = Autodesk.AutoCAD.Colors.Color.FromColorIndex(ColorMethod.ByColor, 7); // white
_layer.Name = cleanName;
// Append the new layer to the layer table and the transaction
lyrTbl.Add(_layer);
tr.AddNewlyCreatedDBObject(_layer, true);
}
}
catch { return(false); }
return(true);
}
static public void GetEnt()
{
AcEd.Editor ed = AcAp.Application.DocumentManager.MdiActiveDocument.Editor;
PromptResult rs = ed.GetString("\nВведите метку примитива (в hex-представлении): ");
if (rs.Status != PromptStatus.OK)
{
return;
}
System.Int64 l = System.Int64.Parse(rs.StringResult, System.Globalization.NumberStyles.HexNumber);
AcDb.Handle h = new AcDb.Handle(l);
AcDb.Database db = AcDb.HostApplicationServices.WorkingDatabase;
AcDb.ObjectId id = db.GetObjectId(false, h, 0);
if (!id.IsValid)
{
ed.WriteMessage("\nОшибочная метка примитива {0}", h);
return;
}
using (AcAp.DocumentLock doclock = ed.Document.LockDocument())
{
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.Entity ent = tr.GetObject(id, AcDb.OpenMode.ForRead) as AcDb.Entity;
if (ent != null)
{
ed.WriteMessage("\nEntity Class: {0}", AcRx.RXClass.GetClass(ent.GetType()).Name);
// Ну и так далее - делаешь с примитивом то, что тебе нужно...
}
else
{
ed.WriteMessage("\nЭто не примитив!");
}
}
}
}
ProcessObject(AcDb.Transaction trHelp, AcDb.ObjectId lookForObjId, AcDb.ObjectId curObjId)
{
AcDb.DBObject tmpObj = trHelp.GetObject(curObjId, AcDb.OpenMode.ForRead);
if (tmpObj != null)
{
m_count++;
ReferenceFiler filer = new ReferenceFiler();
tmpObj.DwgOut(filer); // find out who this object owns
RecordReferences(lookForObjId, tmpObj, filer); // record references for this object
// now recursively visit all the objects this one owns
for (int i = 0; i < filer.m_hardOwnershipIds.Count; i++)
{
ProcessObject(trHelp, lookForObjId, filer.m_hardOwnershipIds[i]);
}
for (int i = 0; i < filer.m_softOwnershipIds.Count; i++)
{
ProcessObject(trHelp, lookForObjId, filer.m_softOwnershipIds[i]);
}
}
else
{
m_skipped++;
}
}
Extents()
{
m_db = Utils.Db.GetCurDwg();
Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = m_db.TransactionManager;
while (true)
{
PromptEntityResult prEntRes = ed.GetEntity("\nSelect entity to show extents");
if (prEntRes.Status != PromptStatus.OK)
{
break;
}
using (Autodesk.AutoCAD.DatabaseServices.Transaction tr = tm.StartTransaction()) {
AcDb.Entity ent = (AcDb.Entity)tr.GetObject(prEntRes.ObjectId, OpenMode.ForRead);
Extents3d ext = ent.GeometricExtents;
Point3d centerPt = Utils.Ge.Midpoint(ext.MinPoint, ext.MaxPoint);
Utils.AcadUi.PrintToCmdLine(string.Format("\nEXTMIN: {0}", Utils.AcadUi.PtToStr(ext.MinPoint)));
Utils.AcadUi.PrintToCmdLine(string.Format("\nEXTMAX: {0}", Utils.AcadUi.PtToStr(ext.MaxPoint)));
Utils.AcadUi.PrintToCmdLine(string.Format("\nCENTER PT: {0}", Utils.AcadUi.PtToStr(centerPt)));
tr.Commit();
MakeExtentsBlock(ext);
}
}
}
GetSymbolTableRecId(System.Type classType, string symName, Database db)
{
ObjectId tblId = GetSymbolTableId(classType, db);
ObjectId recId = new ObjectId();
Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = db.TransactionManager;
try
{
using (Autodesk.AutoCAD.DatabaseServices.Transaction tr = tm.StartTransaction())
{
SymbolTable tbl = (SymbolTable)tr.GetObject(tblId, OpenMode.ForRead);
if (tbl.Has(symName)) // TBD: should indexer return ObjectId.null instead of throwing exception
{
recId = tbl[symName];
}
tr.Commit();
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " SymTbl.cs: line: 276");
}
return(recId);
}
idObjToTypeAndHandleStr(ObjectId objId)
{
string str = "";
if (objId.IsNull)
{
str = "(null)";
}
else
{
// open up even if erased
Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = objId.Database.TransactionManager;
try
{
using (Autodesk.AutoCAD.DatabaseServices.Transaction tr = tm.StartTransaction())
{
DBObject tmpObj = tr.GetObject(objId, OpenMode.ForRead, true);
str = idObjToTypeAndHandleStr(tmpObj);
tr.Commit();
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(ex.Message + " Db.cs: line: 388");
}
}
return(str);
}
public static ACADDB.Region AddRegion(ACADDB.ObjectId acadObjectId)
{
ACADDB.Region returnvalue = null;
// Get the current document and database
Document acDoc = Application.DocumentManager.MdiActiveDocument;
ACADDB.Database acCurDb = acDoc.Database;
// Start a transaction
using (ACADDB.Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// Open the Block table for read
ACADDB.BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId,
ACADDB.OpenMode.ForRead) as ACADDB.BlockTable;
// Open the Block table record Model space for write
ACADDB.BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[ACADDB.BlockTableRecord.ModelSpace],
ACADDB.OpenMode.ForWrite) as ACADDB.BlockTableRecord;
ACADDB.Polyline polyline = acTrans.GetObject(acadObjectId,
ACADDB.OpenMode.ForRead) as ACADDB.Polyline;
if (polyline != null)
{
ACADDB.DBObjectCollection acDBObjColl = new ACADDB.DBObjectCollection();
acDBObjColl.Add((ACADDB.DBObject)polyline.AcadObject);
// Calculate the regions based on each closed loop
ACADDB.DBObjectCollection myRegionColl = new ACADDB.DBObjectCollection();
myRegionColl = ACADDB.Region.CreateFromCurves(acDBObjColl);
ACADDB.Region acRegion = myRegionColl[0] as ACADDB.Region;
returnvalue = acRegion;
// Add the new object to the block table record and the transaction
acBlkTblRec.AppendEntity(acRegion);
acTrans.AddNewlyCreatedDBObject(acRegion, true);
// Dispose
}
// Save the new object to the database
acTrans.Commit();
}
return(returnvalue);
}
public static void StatisticsModel123_Steel4(BeamData beam, AcadDB.BlockReference blk_ref)
{
AcadDB.Database db = AcadApp.DocumentManager.MdiActiveDocument.Database;
using (AcadDB.Transaction trans = db.TransactionManager.StartTransaction())
{
AcadDB.AttributeCollection atts = blk_ref.AttributeCollection;
foreach (AcadDB.ObjectId att in atts)
{
AcadDB.AttributeReference att_ref = trans.GetObject(att, AcadDB.OpenMode.ForWrite) as AcadDB.AttributeReference;
if (null == att_ref)
{
continue;
}
if (ATT_SH == att_ref.Tag)
{
att_ref.TextString = "4";
}
if (ATT_DK == att_ref.Tag)
{
att_ref.TextString = beam.dau_goi_data.first_layer_diameter.ToString();
}
if (ATT_DAI == att_ref.Tag)
{
att_ref.TextString = (beam.Length - 2 * Beam.cover).ToString();
}
if (ATT_L2 == att_ref.Tag)
{
att_ref.TextString = "2000";
}
if (ATT_L1 == att_ref.Tag)
{
att_ref.TextString = (beam.Height - 2 * Beam.cover).ToString();
}
if (ATT_SL1 == att_ref.Tag)
{
att_ref.TextString = (beam.dau_goi_data.number_steel_first_layer).ToString();
}
if (ATT_SLA == att_ref.Tag)
{
att_ref.TextString = (beam.dau_goi_data.number_steel_first_layer).ToString();
}
if (ATT_DT == att_ref.Tag)
{
double total_len = beam.dau_goi_data.number_steel_first_layer * (beam.Length - 2 * Beam.cover);
total_len /= 1000.0;
att_ref.TextString = (total_len).ToString();
}
if (ATT_TL == att_ref.Tag)
{
att_ref.TextString = "...";
}
}
trans.Commit();
}
}
GetLineOrTwoPoints(out Point3d pt1, out Point3d pt2)
{
m_db = Utils.Db.GetCurDwg();
Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
pt1 = pt2 = Utils.Ge.kOrigin; // initialize to make compiler happy
PromptPointOptions prOpts = new PromptPointOptions("\nFirst extension line origin or RETURN to select");
prOpts.AllowNone = true;
PromptPointResult prPt1Res = ed.GetPoint(prOpts);
// user wants to select a line to specify both points
if (prPt1Res.Status == PromptStatus.None)
{
PromptEntityOptions prEntOpts = new PromptEntityOptions("\nSelect a LINE");
prEntOpts.SetRejectMessage("\nSelected entity must be of type Line");
prEntOpts.AddAllowedClass(typeof(Line), false);
PromptEntityResult prEntRes = ed.GetEntity(prEntOpts);
if (prEntRes.Status != PromptStatus.OK)
{
return(prEntRes.Status);
}
Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = m_db.TransactionManager;
using (Autodesk.AutoCAD.DatabaseServices.Transaction tr = tm.StartTransaction()) {
Line line = (Line)tr.GetObject(prEntRes.ObjectId, OpenMode.ForRead);
pt1 = Utils.Db.WcsToUcs(line.StartPoint);
pt2 = Utils.Db.WcsToUcs(line.EndPoint);
tr.Commit();
return(PromptStatus.OK);
}
}
else if (prPt1Res.Status == PromptStatus.OK)
{
PromptPointOptions prPt2Opts = new PromptPointOptions("\nSecond extension line origin");
prPt2Opts.UseBasePoint = true;
prPt2Opts.BasePoint = prPt1Res.Value;
PromptPointResult prPt2Res = ed.GetPoint(prPt2Opts);
if (prPt2Res.Status != PromptStatus.OK)
{
return(PromptStatus.Cancel);
}
pt1 = prPt1Res.Value;
pt2 = prPt2Res.Value;
return(prPt1Res.Status);
}
return(prPt1Res.Status);
}
private static void AddMLeader(Gem.Point2d pnt, Gem.Vector3d otstup,
double scale, string layer,
string mleaderStyleName, string str)
{
SettingsParser settings = SettingsParser.getInstance();
App.Document acDoc = App.Application.DocumentManager.MdiActiveDocument;
Db.Database acCurDb = acDoc.Database;
using (Db.Transaction acTrans = acCurDb.TransactionManager.StartOpenCloseTransaction())
{
Db.BlockTable acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId,
Db.OpenMode.ForRead) as Db.BlockTable;
Db.BlockTableRecord acBlkTblRec = acTrans.GetObject(acBlkTbl[Db.BlockTableRecord.ModelSpace],
Db.OpenMode.ForWrite) as Db.BlockTableRecord;
Db.MLeader acML = new Db.MLeader();
acML.SetDatabaseDefaults();
acML.Layer = layer;
acML.MLeaderStyle = CheckLocalRepository.GetIDbyName <Db.MLeaderStyle>(acCurDb, mleaderStyleName);
acML.ContentType = Db.ContentType.MTextContent;
Db.MText mText = new Db.MText();
mText.SetDatabaseDefaults();
mText.Contents = str;
mText.TextHeight = scale;
mText.BackgroundFill = settings.MTextMask;
mText.UseBackgroundColor = settings.MTextMask;
if (settings.MTextMask)
{
mText.BackgroundScaleFactor = settings.MTextMaskKoefficient;
}
mText.Location = (new Gem.Point3d(pnt.X, pnt.Y, 0) + otstup);
acML.MText = mText;
int idx = acML.AddLeaderLine(new Gem.Point3d(pnt.X, pnt.Y, 0));
acML.Scale = 1;
acBlkTblRec.AppendEntity(acML);
acTrans.AddNewlyCreatedDBObject(acML, true);
acTrans.Commit();
}
}
private static List <AcadGeo.Point3d> ParseLine(AcadDB.ObjectId id, List <AcadDB.ObjectId> ids)
{
List <AcadGeo.Point3d> pnts = new List <AcadGeo.Point3d>();
using (AcadDB.Transaction tr = AcadFuncs.GetActiveDB().TransactionManager.StartTransaction())
{
AcadDB.Entity ent = tr.GetObject(id, AcadDB.OpenMode.ForRead) as AcadDB.Entity;
if (!(ent is AcadDB.Line))
{
return(pnts);
}
AcadDB.Line line = ent as AcadDB.Line;
pnts.Add(line.StartPoint);
pnts.Add(line.EndPoint);
foreach (var tmp_id in ids)
{
if (id == tmp_id)
{
continue;
}
AcadDB.Entity tmp_ent = tr.GetObject(tmp_id, AcadDB.OpenMode.ForRead) as AcadDB.Entity;
AcadGeo.Point3dCollection intersected_pnts = new AcadGeo.Point3dCollection();
line.IntersectWith(tmp_ent, AcadDB.Intersect.OnBothOperands, intersected_pnts, (IntPtr)0, (IntPtr)0);
for (int i = 0; i < intersected_pnts.Count; i++)
{
if (intersected_pnts[i].IsEqualTo(line.StartPoint) || intersected_pnts[i].IsEqualTo(line.EndPoint))
{
continue;
}
pnts.Add(intersected_pnts[i]);
}
}
}
pnts.Sort((x, y) => x.DistanceTo(pnts.First()).CompareTo(y.DistanceTo(pnts.First())));
pnts = pnts.Distinct().ToList();
return(pnts);
}
/// <summary>
/// This is Extension Method for the <c>Autodesk.AutoCAD.DatabaseServices.LayoutManager</c>
/// class. It gets the name of the current space in the current Database.
/// </summary>
/// <param name="mng">Target <c>Autodesk.AutoCAD.DatabaseServices.LayoutManager</c>
/// instance.</param>
/// <returns>Returns the name of current space.</returns>
public static String GetCurrentSpaceName(this Db.LayoutManager mng)
{
SpaceEnum space = GetCurrentSpaceEnum(mng);
Db.Database db = cad.DocumentManager.MdiActiveDocument.Database;
String modelSpaceLocalizedName = String.Empty;
using (Db.Transaction tr = db.TransactionManager.StartTransaction())
{
Db.BlockTable bt = tr.GetObject(db.BlockTableId, Db.OpenMode.ForRead) as Db.BlockTable;
Db.BlockTableRecord btr = tr.GetObject(bt[Db.BlockTableRecord.ModelSpace], Db.OpenMode.ForRead)
as Db.BlockTableRecord;
modelSpaceLocalizedName = (tr.GetObject(btr.LayoutId, Db.OpenMode.ForRead) as Db.Layout).LayoutName;
}
String result = space == SpaceEnum.Viewport ?
"Model" as String : mng.CurrentLayout;
return(result);
}
private void DeleteLayersWithPrefix(string prefix, AcadDb.Transaction tr)
{
// Open the Layer table for read
var lyrTbl = (AcadDb.LayerTable)tr.GetObject(Doc.Database.LayerTableId, AcadDb.OpenMode.ForRead);
foreach (AcadDb.ObjectId layerId in lyrTbl)
{
AcadDb.LayerTableRecord layer = (AcadDb.LayerTableRecord)tr.GetObject(layerId, AcadDb.OpenMode.ForRead);
string layerName = layer.Name;
if (layerName.StartsWith(prefix))
{
layer.UpgradeOpen();
// cannot delete current layer: swap current layer to default layer "0" if current layer is to be deleted
if (Doc.Database.Clayer == layerId)
{
var defaultLayerID = lyrTbl["0"];
Doc.Database.Clayer = defaultLayerID;
}
layer.IsLocked = false;
// delete all objects on this layer
// TODO: this is ugly! is there a better way to delete layer objs instead of looping through each one?
var bt = (AcadDb.BlockTable)tr.GetObject(Doc.Database.BlockTableId, AcadDb.OpenMode.ForRead);
foreach (var btId in bt)
{
var block = (AcadDb.BlockTableRecord)tr.GetObject(btId, AcadDb.OpenMode.ForRead);
foreach (var entId in block)
{
var ent = (AcadDb.Entity)tr.GetObject(entId, AcadDb.OpenMode.ForRead);
if (ent.Layer == layerName)
{
ent.UpgradeOpen();
ent.Erase();
}
}
}
layer.Erase();
}
}
}
public override List <string> GetObjectsInView() // TODO: this returns all visible doc objects. handle views later.
{
var objs = new List <string>();
using (AcadDb.Transaction tr = Doc.Database.TransactionManager.StartTransaction())
{
AcadDb.BlockTable blckTbl = tr.GetObject(Doc.Database.BlockTableId, AcadDb.OpenMode.ForRead) as AcadDb.BlockTable;
AcadDb.BlockTableRecord blckTblRcrd = tr.GetObject(blckTbl[AcadDb.BlockTableRecord.ModelSpace], AcadDb.OpenMode.ForRead) as AcadDb.BlockTableRecord;
foreach (AcadDb.ObjectId id in blckTblRcrd)
{
var dbObj = tr.GetObject(id, AcadDb.OpenMode.ForRead);
if (dbObj.Visible())
{
objs.Add(dbObj.Handle.ToString());
}
}
tr.Commit();
}
return(objs);
}
public override List <ISelectionFilter> GetSelectionFilters()
{
var layers = new List <string>();
using (AcadDb.Transaction tr = Doc.Database.TransactionManager.StartTransaction())
{
AcadDb.LayerTable lyrTbl = tr.GetObject(Doc.Database.LayerTableId, AcadDb.OpenMode.ForRead) as AcadDb.LayerTable;
foreach (AcadDb.ObjectId objId in lyrTbl)
{
AcadDb.LayerTableRecord lyrTblRec = tr.GetObject(objId, AcadDb.OpenMode.ForRead) as AcadDb.LayerTableRecord;
layers.Add(lyrTblRec.Name);
}
tr.Commit();
}
return(new List <ISelectionFilter>()
{
new ListSelectionFilter {
Name = "Layers", Icon = "Filter", Description = "Selects objects based on their layers.", Values = layers
}
});
}
//public void GetLengedPoints(T model)
//{
// Document doc = Application.DocumentManager.MdiActiveDocument;
// ObjectIdCollection ids = new ObjectIdCollection();
// PromptSelectionResult ProSset = null;
// TypedValue[] filList = new TypedValue[1] { new TypedValue((int)DxfCode.LayerName, MethodCommand.LegendLayer)};
// SelectionFilter sfilter = new SelectionFilter(filList);
// LayoutManager layoutMgr = LayoutManager.Current;
// string ss= layoutMgr.CurrentLayout;
// ProSset = doc.Editor.SelectAll(sfilter);
//// List<ObjectId> idss= GetEntitiesInModelSpace();
// Database db = doc.Database;
// if (ProSset.Status == PromptStatus.OK)
// {
// using (Transaction tran = db.TransactionManager.StartTransaction())
// {
// SelectionSet sst = ProSset.Value;
// ObjectId[] oids = sst.GetObjectIds();
// model.LegendList = new Dictionary<int, List<System.Drawing.PointF>>();
// int ad = 0;
// List<string> aa = new List<string>();
// LayerModel lm = new LayerModel();
// LayerTable lt = (LayerTable)db.LayerTableId.GetObject(OpenMode.ForRead);
// foreach (ObjectId layerId in lt)
// {
// LayerTableRecord ltr = (LayerTableRecord)tran.GetObject(layerId, OpenMode.ForRead);
// if (ltr.Name == MethodCommand.LegendLayer)
// {
// lm.Color = System.Drawing.ColorTranslator.ToHtml(ltr.Color.ColorValue);
// }
// }
// for (int i = 0; i < oids.Length; i++)
// {
// // if (idss.Contains(oids[i]))
// // {
// DBObject ob = tran.GetObject(oids[i], OpenMode.ForRead);
// if (!aa.Contains((ob as Polyline).BlockName)) { aa.Add((ob as Polyline).BlockName); }
// if (ob is Polyline&&(ob as Polyline).BlockName.ToLower()== "*model_space")
// {
// lengedList.Add(ob as Polyline);
// model.LegendList.Add(ad,PolylineMethod.GetPolyLineInfoPt(ob as Polyline));
// ad++;
// }
// // }
// }
// model.allLines = new List<LayerModel>();
// model.allLines.Add(lm);
// }
// }
//}
public List <Autodesk.AutoCAD.DatabaseServices.ObjectId> GetEntitiesInModelSpace()
{
List <Autodesk.AutoCAD.DatabaseServices.ObjectId> objects = new List <Autodesk.AutoCAD.DatabaseServices.ObjectId>();
using (Autodesk.AutoCAD.DatabaseServices.Transaction transaction = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.TransactionManager.StartTransaction())
{
Autodesk.AutoCAD.DatabaseServices.BlockTable blockTable =
(Autodesk.AutoCAD.DatabaseServices.BlockTable)transaction.GetObject(
Autodesk.AutoCAD.DatabaseServices.HostApplicationServices.WorkingDatabase.BlockTableId,
Autodesk.AutoCAD.DatabaseServices.OpenMode.ForRead);
Autodesk.AutoCAD.DatabaseServices.BlockTableRecord blockTableRecord =
(Autodesk.AutoCAD.DatabaseServices.BlockTableRecord)transaction.GetObject(
blockTable[Autodesk.AutoCAD.DatabaseServices.BlockTableRecord.ModelSpace],
Autodesk.AutoCAD.DatabaseServices.OpenMode.ForRead);
foreach (Autodesk.AutoCAD.DatabaseServices.ObjectId objId in blockTableRecord)
{
objects.Add(objId);
}
transaction.Commit();
}
return(objects);
}
