public static void ManualInsertbAttribute(string nameBlock)
{
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTable blockTable = (AcDb.BlockTable)tr.GetObject(db.BlockTableId, AcDb.OpenMode.ForRead);
if (!blockTable.Has(nameBlock))
{
ed.WriteMessage("\nНезнайдено блок '{0}' у таблиці блоків креслення.", nameBlock);
return;
}
AcDb.BlockTableRecord curSpace = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
AcDb.BlockReference blockReference = new AcDb.BlockReference(AcGe.Point3d.Origin, blockTable[nameBlock]);
blockReference.TransformBy(ed.CurrentUserCoordinateSystem);
curSpace.AppendEntity(blockReference);
tr.AddNewlyCreatedDBObject(blockReference, true);
AcDb.BlockTableRecord btr = (AcDb.BlockTableRecord)tr.GetObject(blockTable[nameBlock], AcDb.OpenMode.ForRead);
AcDb.DBText text;
foreach (AcDb.ObjectId id in btr)
{
if (id.ObjectClass.Name == "AcDbAttributeDefinition")
{
AcDb.AttributeDefinition attDef =
(AcDb.AttributeDefinition)tr.GetObject(id, AcDb.OpenMode.ForRead);
text = new AcDb.DBText
{
TextString = "jig_test"
};
TextPlacementJig jig = new TextPlacementJig(text);
//PromptResult pr = ed.Drag(jig);
AcEd.PromptStatus stat = AcEd.PromptStatus.Keyword;
while (stat == AcEd.PromptStatus.Keyword)
{
AcEd.PromptResult pr = ed.Drag(jig);
stat = pr.Status;
if (stat != AcEd.PromptStatus.OK && stat != AcEd.PromptStatus.Keyword)
{
return;
}
}
AcDb.AttributeReference attRef = new AcDb.AttributeReference();
attRef.SetAttributeFromBlock(attDef, blockReference.BlockTransform);
AcDb.ObjectId attId = blockReference.AttributeCollection.AppendAttribute(attRef);
tr.AddNewlyCreatedDBObject(attRef, true);
tr.Commit();
//if (pr.Status != PromptStatus.OK) blockReference.Erase();
}
}
//tr.Commit();
}
}
public static AcDb.ObjectId CreateLayer(String layerName)
{
AcDb.ObjectId layerId;
AcDb.Database db = CurrentCAD.Database;
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.LayerTable layerTable = (AcDb.LayerTable)tr.GetObject(db.LayerTableId, AcDb.OpenMode.ForWrite);
if (layerTable.Has(layerName))
{
layerId = layerTable[layerName];
}
else
{
AcDb.LayerTableRecord layerTableRecord = new AcDb.LayerTableRecord
{
Name = layerName
};
layerId = layerTable.Add(layerTableRecord);
tr.AddNewlyCreatedDBObject(layerTableRecord, true);
}
tr.Commit();
}
return(layerId);
}
public static AcDb.ObjectId CreateFontStyle(String textStyleName, AcGi.FontDescriptor font)
{
AcDb.ObjectId txtStyleId = AcDb.ObjectId.Null;
using (AcDb.Transaction tr = doc.Database.TransactionManager.StartTransaction())
{
AcDb.TextStyleTable newTextStyleTable = tr.GetObject(doc.Database.TextStyleTableId, AcDb.OpenMode.ForRead) as AcDb.TextStyleTable;
if (!newTextStyleTable.Has(textStyleName))
{
newTextStyleTable.UpgradeOpen();
AcDb.TextStyleTableRecord newTextStyleTableRecord = new AcDb.TextStyleTableRecord();
//newTextStyleTableRecord.FileName = "romans.shx";
newTextStyleTableRecord.Name = textStyleName;
newTextStyleTableRecord.Font = font;
newTextStyleTable.Add(newTextStyleTableRecord);
tr.AddNewlyCreatedDBObject(newTextStyleTableRecord, true);
txtStyleId = newTextStyleTable[textStyleName];
}
tr.Commit();
}
return(txtStyleId);
}
private void CreateOrModifyLayer(LayerInfo layerInfo, _AcAp.Document doc, _AcDb.Database db, _AcDb.Transaction trans, _AcDb.LayerTable layTb)
{
if (layTb.Has(layerInfo.NewLayer))
{
var oid = layTb[layerInfo.NewLayer];
_AcDb.LayerTableRecord ltr = (_AcDb.LayerTableRecord)trans.GetObject(oid, _AcDb.OpenMode.ForWrite);
layerInfo.ModifyLayer(ltr, trans, db);
}
else
{
using (_AcDb.LayerTableRecord ltr = new _AcDb.LayerTableRecord())
{
// Assign the layer a name
ltr.Name = layerInfo.NewLayer;
// Upgrade the Layer table for write
//layTb.UpgradeOpen();
// Append the new layer to the Layer table and the transaction
layTb.Add(ltr);
trans.AddNewlyCreatedDBObject(ltr, true);
layerInfo.ModifyLayer(ltr, trans, db);
}
}
}
public static void ManualInsertMText(AcDb.MText oMText)
{
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTableRecord btr = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
oMText.Normal = ed.CurrentUserCoordinateSystem.CoordinateSystem3d.Zaxis;
btr.AppendEntity(oMText);
tr.AddNewlyCreatedDBObject(oMText, true);
MTextPlacementJig pj = new MTextPlacementJig(oMText);
AcEd.PromptStatus stat = AcEd.PromptStatus.Keyword;
while (stat == AcEd.PromptStatus.Keyword)
{
AcEd.PromptResult res = ed.Drag(pj);
stat = res.Status;
if (stat != AcEd.PromptStatus.OK && stat != AcEd.PromptStatus.Keyword)
{
return;
}
}
tr.Commit();
//return (MText)pj.Entity;
}
}
private _AcDb.ObjectId CreateNewLayer(_AcAp.Document doc, _AcDb.Database db)
{
using (_AcDb.Transaction trans = doc.TransactionManager.StartTransaction())
{
try
{
string layerName = "MyTest";
_AcDb.LayerTable layTb = trans.GetObject(db.LayerTableId, _AcDb.OpenMode.ForRead) as _AcDb.LayerTable;
using (_AcDb.LayerTableRecord acLyrTblRec = new _AcDb.LayerTableRecord())
{
// Assign the layer a name
acLyrTblRec.Name = layerName;
// Upgrade the Layer table for write
layTb.UpgradeOpen();
// Append the new layer to the Layer table and the transaction
layTb.Add(acLyrTblRec);
trans.AddNewlyCreatedDBObject(acLyrTblRec, true);
int transparenz = 10;
Byte alpha = TransparenzToAlpha(transparenz);
_AcCm.Transparency tr = new _AcCm.Transparency(alpha);
acLyrTblRec.Transparency = tr;
_AcCm.Color col = _AcCm.Color.FromColorIndex(_AcCm.ColorMethod.ByColor, 2);
//_AcCm.Color col = _AcCm.Color.FromRgb(10, 20, 30);
acLyrTblRec.Color = col;
_AcDb.ObjectId ltOid = GetLinetypeFromName("Continuous", trans, db);
if (!ltOid.IsNull)
{
acLyrTblRec.LinetypeObjectId = ltOid;
}
_AcDb.LineWeight lw = _AcDb.LineWeight.LineWeight030;
acLyrTblRec.LineWeight = lw;
// ???
//acLyrTblRec.PlotStyleName = "hugo";
acLyrTblRec.Description = "My new Layer";
return(acLyrTblRec.ObjectId);
}
}
finally
{
trans.Commit();
}
}
}
public static AcDb.ObjectId InsertObject(AcDb.Entity entityObject)
{
AcDb.ObjectId objectId;
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTableRecord btr = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
btr.AppendEntity(entityObject);
tr.AddNewlyCreatedDBObject(entityObject, true);
objectId = entityObject.ObjectId;
btr.Dispose();
tr.Commit();
}
return(objectId);
}
public static string CreateBlock(
AcDb.DBObjectCollection blockElements,
string nameBlock)
{
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTable blockTable = tr.GetObject(db.BlockTableId, AcDb.OpenMode.ForRead) as AcDb.BlockTable;
string oldNameBlock = nameBlock;
int iNameBlock = 0;
mark_reNameBlock:
if (blockTable.Has(nameBlock))
{
iNameBlock++;
nameBlock = oldNameBlock + iNameBlock.ToString("_000");
goto mark_reNameBlock;
}
AcDb.BlockTableRecord blockTableRecord = new AcDb.BlockTableRecord
{
Name = nameBlock
};
blockTable.UpgradeOpen();
AcDb.ObjectId btrId = blockTable.Add(blockTableRecord);
tr.AddNewlyCreatedDBObject(blockTableRecord, true);
foreach (AcDb.Entity ent in blockElements)
{
blockTableRecord.AppendEntity(ent);
tr.AddNewlyCreatedDBObject(ent, true);
}
tr.Commit();
}
return(nameBlock);
}
public static void ReplaceAttributeBlock(AcDb.BlockReference blockReference,
Dictionary <string, string> tags,
Boolean visible)
{
using (AcDb.Transaction trAdding = db.TransactionManager.StartTransaction())
{
AcDb.BlockTable btTable = (AcDb.BlockTable)trAdding.GetObject(db.BlockTableId, AcDb.OpenMode.ForRead);
AcDb.BlockTableRecord btrTable =
(AcDb.BlockTableRecord)btTable[blockReference.Name].GetObject(AcDb.OpenMode.ForRead);
if (btrTable.HasAttributeDefinitions)
{
var attDefs = btrTable.Cast <AcDb.ObjectId>()
.Where(n => n.ObjectClass.Name == "AcDbAttributeDefinition")
.Select(n => (AcDb.AttributeDefinition)n.GetObject(AcDb.OpenMode.ForRead));
foreach (AcDb.AttributeDefinition attDef in attDefs)
{
AcDb.AttributeReference attRef = new AcDb.AttributeReference();
attRef.SetAttributeFromBlock(attDef, blockReference.BlockTransform);
foreach (var tag in tags)
{
attRef.UpgradeOpen();
if (tag.Key.ToUpper() == attRef.Tag)
{
attRef.TextString = tag.Value;
}
else
{
attRef.TextString = "NoneValue";
}
attRef.Visible = visible;
attRef.Rotation = 0;
}
blockReference.AttributeCollection.AppendAttribute(attRef);
trAdding.AddNewlyCreatedDBObject(attRef, false);
}
}
else
{
ed.WriteMessage("\n < ERROR > ");
}
trAdding.Commit();
}
}
private void ExplodeBlocks(_AcDb.Database db, List <_AcDb.ObjectId> allXrefsInMs, List <_AcDb.ObjectId> newlyCreatedObjects, bool deleteRef, bool deleteBtr)
{
log.Debug("ExplodeXRefs");
using (_AcDb.Transaction tr = _TransMan.StartTransaction())
{
_AcDb.BlockTable bt = (_AcDb.BlockTable)tr.GetObject(db.BlockTableId, _AcDb.OpenMode.ForRead);
_AcDb.BlockTableRecord btr = (_AcDb.BlockTableRecord)tr.GetObject(_AcDb.SymbolUtilityServices.GetBlockModelSpaceId(db), _AcDb.OpenMode.ForWrite);
foreach (var oid in allXrefsInMs)
{
_AcDb.DBObjectCollection objs = new _AcDb.DBObjectCollection();
_AcDb.BlockReference block = (_AcDb.BlockReference)tr.GetObject(oid, _AcDb.OpenMode.ForRead);
log.DebugFormat(CultureInfo.CurrentCulture, "Explode von Block '{0}'.", block.Name);
block.Explode(objs);
log.DebugFormat(CultureInfo.CurrentCulture, "Block enthält {0} Entities.", objs.Count);
_AcDb.ObjectId blockRefTableId = block.BlockTableRecord;
foreach (_AcDb.DBObject obj in objs)
{
_AcDb.Entity ent = (_AcDb.Entity)obj;
btr.AppendEntity(ent);
tr.AddNewlyCreatedDBObject(ent, true);
newlyCreatedObjects.Add(ent.ObjectId);
}
if (deleteRef)
{
log.DebugFormat(CultureInfo.CurrentCulture, "Lösche Block '{0}'.", block.Name);
block.UpgradeOpen();
block.Erase();
}
if (deleteBtr)
{
log.DebugFormat("DeleteBtr");
// funkt nicht -> xref würde gelöscht
var bd = (_AcDb.BlockTableRecord)tr.GetObject(blockRefTableId, _AcDb.OpenMode.ForWrite);
bd.Erase();
log.DebugFormat("Endof DeleteBtr");
}
}
tr.Commit();
}
}
static void AddRegAppTableRecord(string regAppName)
{
AcAp.Document doc = AcApp.DocumentManager.MdiActiveDocument;
AcEd.Editor ed = doc.Editor;
AcDb.Database db = doc.Database;
using (AcDb.Transaction tr = doc.TransactionManager.StartTransaction())
{
AcDb.RegAppTable rat =
(AcDb.RegAppTable)tr.GetObject(db.RegAppTableId, AcDb.OpenMode.ForRead, false);
if (!rat.Has(regAppName))
{
rat.UpgradeOpen();
AcDb.RegAppTableRecord ratr = new AcDb.RegAppTableRecord();
ratr.Name = regAppName;
rat.Add(ratr);
tr.AddNewlyCreatedDBObject(ratr, true);
}
tr.Commit();
}
}
public static void BuildingOrthogonalPolylines()
{
try
{
AcDb.Database db = CurrentCAD.Database;
jigger = new OrthogonalPolylinesJig();
AcEd.PromptResult jigRes;
do
{
jigRes = CurrentCAD.Editor.Drag(jigger);
if (jigRes.Status == AcEd.PromptStatus.OK)
{
jigger.allVertexes.Add(jigger.lastVertex);
}
} while (jigRes.Status == AcEd.PromptStatus.OK);
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTableRecord btr = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
Teigha.DatabaseServices.Polyline ent = new Teigha.DatabaseServices.Polyline();
ent.SetDatabaseDefaults();
for (int i = 0; i < jigger.allVertexes.Count; i++)
{
AcGe.Point3d pt3d = jigger.allVertexes[i];
AcGe.Point2d pt2d = new AcGe.Point2d(pt3d.X, pt3d.Y);
ent.AddVertexAt(i, pt2d, 0, db.Plinewid, db.Plinewid);
}
ent.TransformBy(jigger.UCS);
btr.AppendEntity(ent);
tr.AddNewlyCreatedDBObject(ent, true);
tr.Commit();
}
}
catch (System.Exception ex)
{
CurrentCAD.Editor.WriteMessage(ex.ToString());
}
}
public static AcDb.ObjectId ManualInsertBlock(string nameBlock,
double scaleBlock,
Dictionary <string, string> tags)
{
AcDb.ObjectId idBlock = AcDb.ObjectId.Null;
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTable blockTable = (AcDb.BlockTable)tr.GetObject(db.BlockTableId, AcDb.OpenMode.ForRead);
if (!blockTable.Has(nameBlock))
{
ed.WriteMessage("\nНезнайдено блок '{0}' у таблиці блоків креслення.", nameBlock);
return(idBlock);
}
AcDb.BlockTableRecord curSpace = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
AcDb.BlockReference blockReference = new AcDb.BlockReference(AcGe.Point3d.Origin, blockTable[nameBlock])
{
ScaleFactors = new AcGe.Scale3d(scaleBlock, scaleBlock, scaleBlock)
};
blockReference.TransformBy(ed.CurrentUserCoordinateSystem);
curSpace.AppendEntity(blockReference);
tr.AddNewlyCreatedDBObject(blockReference, true);
AcDb.BlockTableRecord btr = (AcDb.BlockTableRecord)tr.GetObject(blockTable[nameBlock], AcDb.OpenMode.ForRead);
BlockPlacementJig jig = new BlockPlacementJig(blockReference, tags);
AcEd.PromptResult pr = ed.Drag(jig);
if (pr.Status != AcEd.PromptStatus.OK)
{
blockReference.Erase();
}
tr.Commit();
}
return(idBlock);
}
public static AcDb.ObjectId InsertBlock(
string nameBlock,
AcGe.Point3d insertionPoint,
double scale,
double rotation,
AcDb.ObjectId layerId,
Dictionary <string, string> tags)
{
AcDb.ObjectId idBlock = AcDb.ObjectId.Null;
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTable blockTable = (AcDb.BlockTable)tr.GetObject(db.BlockTableId, AcDb.OpenMode.ForRead);
if (!blockTable.Has(nameBlock))
{
ed.WriteMessage("\nНезнайдено блок '{0}' у таблиці блоків креслення.", nameBlock);
return(idBlock);
}
AcDb.BlockTableRecord curSpace = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
AcDb.BlockReference blockReference = new AcDb.BlockReference(insertionPoint, blockTable[nameBlock])
{
LayerId = layerId,
ScaleFactors = new AcGe.Scale3d(scale, scale, scale),
Rotation = rotation
};
blockReference.TransformBy(ed.CurrentUserCoordinateSystem);
curSpace.AppendEntity(blockReference);
tr.AddNewlyCreatedDBObject(blockReference, true);
if (tags != null)
{
ReplaceAttributeBlock(blockReference, tags, true);
}
idBlock = blockReference.ObjectId;
tr.Commit();
}
return(idBlock);
}
// Transaction extensions
///<summary>
/// Create a bounding rectangle around a piece of text (for debugging).
///</summary>
///<param name="txt">The text object around which to create a box.</param>
public static void CreateBoundingBox(this _AcDb.Transaction tr, _AcDb.DBText txt)
{
var ms =
tr.GetObject(
_AcDb.SymbolUtilityServices.GetBlockModelSpaceId(txt.Database),
_AcDb.OpenMode.ForWrite
) as _AcDb.BlockTableRecord;
if (ms != null)
{
var corners = txt.ExtractBounds();
if (corners.Count >= 4)
{
var doc = _AcAp.Application.DocumentManager.MdiActiveDocument;
if (doc == null)
{
return;
}
var ed = doc.Editor;
var ucs = ed.CurrentUserCoordinateSystem;
var cs = ucs.CoordinateSystem3d;
var pl = new _AcDb.Polyline(4);
for (int i = 0; i < 4; i++)
{
pl.AddVertexAt(i, corners[i].ProjectToUcs(cs), 0, 0, 0);
}
pl.Closed = true;
pl.TransformBy(ucs);
ms.AppendEntity(pl);
tr.AddNewlyCreatedDBObject(pl, true);
}
}
}
public static void BuildingRectangle()
{
try
{
AcDb.Database db = CurrentCAD.Database;
AcEd.Editor ed = CurrentCAD.Editor;
AcEd.PromptKeywordOptions pko;
AcEd.PromptPointOptions ppt;
AcEd.PromptPointResult ppr;
AcGe.Point3d basePoint;
AcGe.Point3d diractionPoint;
pko = new AcEd.PromptKeywordOptions("\nПобудова прямокутника");
pko.Keywords.Add("по Діагоналі");
pko.Keywords.Add("по Напрямку та діагоналі");
pko.Keywords.Add("по Ширині та висота");
pko.Keywords.Default = "по Ширині та висота";
pko.AllowNone = false;
AcEd.PromptResult pkr = ed.GetKeywords(pko);
if (pkr.Status != AcEd.PromptStatus.OK)
{
return;
}
MethodConstructingRectangle methodConstructing;
if (pkr.StringResult == "Діагоналі")
{
methodConstructing = MethodConstructingRectangle.Diagonal;
}
else if (pkr.StringResult == "Напрямку")
{
methodConstructing = MethodConstructingRectangle.DirectionAndDiagonal;
}
else
{
methodConstructing = MethodConstructingRectangle.HeightAndWidth;
}
ppt = new AcEd.PromptPointOptions("\nВкажіть першу точку прямокутника:");
ppr = ed.GetPoint(ppt);
if (ppr.Status != AcEd.PromptStatus.OK)
{
return;
}
basePoint = ppr.Value;
if (methodConstructing == MethodConstructingRectangle.Diagonal)
{
diractionPoint = basePoint.Add(AcGe.Vector3d.XAxis);
}
else
{
ppt = new AcEd.PromptPointOptions("\n");
if (methodConstructing == MethodConstructingRectangle.DirectionAndDiagonal)
{
ppt.Message = "\nВкажіть точку напрямку прямокутника:";
}
else if (methodConstructing == MethodConstructingRectangle.DirectionAndDiagonal)
{
ppt.Message = "\nВкажіть ширину прямокутника:";
}
ppt.UseBasePoint = true;
ppt.BasePoint = basePoint;
ppr = ed.GetPoint(ppt);
if (ppr.Status != AcEd.PromptStatus.OK)
{
return;
}
diractionPoint = ppr.Value;
}
jigger = new RectangleJig(methodConstructing, basePoint, diractionPoint);
ed.Drag(jigger);
using (AcDb.Transaction tr = db.TransactionManager.StartTransaction())
{
AcDb.BlockTableRecord btr = (AcDb.BlockTableRecord)tr.GetObject(db.CurrentSpaceId, AcDb.OpenMode.ForWrite);
Teigha.DatabaseServices.Polyline ent = new Teigha.DatabaseServices.Polyline();
ent.SetDatabaseDefaults();
for (int i = 0; i < jigger.Corners.Count; i++)
{
AcGe.Point3d pt3d = jigger.Corners[i];
AcGe.Point2d pt2d = new AcGe.Point2d(pt3d.X, pt3d.Y);
ent.AddVertexAt(i, pt2d, 0, db.Plinewid, db.Plinewid);
}
ent.Closed = true;
ent.TransformBy(jigger.UCS);
btr.AppendEntity(ent);
tr.AddNewlyCreatedDBObject(ent, true);
tr.Commit();
}
}
catch (System.Exception ex)
{
CurrentCAD.Editor.WriteMessage(ex.ToString());
}
}
/// <summary>
/// Applies an action to the specified viewport from this layout.
/// Creates a new viewport if none is found withthat number.
/// </summary>
/// <param name="tr">The transaction to use to open the viewports.</param>
/// <param name="vpNum">The number of the target viewport.</param>
/// <param name="f">The action to apply to each of the viewports.</param>
public static void ApplyToViewport(
this _AcDb.Layout lay, _AcDb.Transaction tr, int vpNum, Action <_AcDb.Viewport> f
)
{
var vpIds = lay.GetViewports();
_AcDb.Viewport vp = null;
foreach (_AcDb.ObjectId vpId in vpIds)
{
var vp2 = tr.GetObject(vpId, _AcDb.OpenMode.ForWrite) as _AcDb.Viewport;
if (vp2 != null && vp2.Number == vpNum)
{
// We have found our viewport, so call the action
vp = vp2;
break;
}
}
if (vp == null)
{
// We have not found our viewport, so create one
var btr =
(_AcDb.BlockTableRecord)tr.GetObject(
lay.BlockTableRecordId, _AcDb.OpenMode.ForWrite
);
vp = new _AcDb.Viewport();
// Add it to the database
btr.AppendEntity(vp);
tr.AddNewlyCreatedDBObject(vp, true);
// Turn it - and its grid - on
vp.On = true;
vp.GridOn = true;
}
// Finally we call our function on it
f(vp);
}
public void AttachRasterImage()
{
// Get the current database and start a transaction
AcDb.Database acCurDb;
acCurDb = AcAp.Application.DocumentManager.MdiActiveDocument.Database;
using (AcDb.Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// Define the name and image to use
string strImgName = "5525";
string strFileName = "C:\\_Temp_\\5525.TIF";
AcDb.RasterImageDef acRasterDef;
bool bRasterDefCreated = false;
AcDb.ObjectId acImgDefId;
// Get the image dictionary
AcDb.ObjectId acImgDctID = AcDb.RasterImageDef.GetImageDictionary(acCurDb);
// Check to see if the dictionary does not exist, it not then create it
if (acImgDctID.IsNull)
{
acImgDctID = AcDb.RasterImageDef.CreateImageDictionary(acCurDb);
}
// Open the image dictionary
AcDb.DBDictionary acImgDict = acTrans.GetObject(acImgDctID, AcDb.OpenMode.ForRead) as AcDb.DBDictionary;
// Check to see if the image definition already exists
if (acImgDict.Contains(strImgName))
{
acImgDefId = acImgDict.GetAt(strImgName);
acRasterDef = acTrans.GetObject(acImgDefId, AcDb.OpenMode.ForWrite) as AcDb.RasterImageDef;
}
else
{
// Create a raster image definition
AcDb.RasterImageDef acRasterDefNew = new AcDb.RasterImageDef
{
// Set the source for the image file
SourceFileName = strFileName
};
acImgDict.UpgradeOpen();
acImgDefId = acImgDict.SetAt(strImgName, acRasterDefNew);
// Load the image into memory
acRasterDefNew.Load();
// Add the image definition to the dictionary
////acImgDict.UpgradeOpen();
////acImgDefId = acImgDict.SetAt(strImgName, acRasterDefNew);
acTrans.AddNewlyCreatedDBObject(acRasterDefNew, true);
/***/
acRasterDef = acRasterDefNew;
bRasterDefCreated = true;
}
// Open the Block table for read
AcDb.BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, AcDb.OpenMode.ForRead) as AcDb.BlockTable;
// Open the Block table record Model space for write
AcDb.BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[AcDb.BlockTableRecord.ModelSpace],
AcDb.OpenMode.ForWrite) as AcDb.BlockTableRecord;
// Create the new image and assign it the image definition
using (AcDb.RasterImage acRaster = new AcDb.RasterImage())
{
acRaster.ImageDefId = acImgDefId;
// Use ImageWidth and ImageHeight to get the size of the image in pixels (1024 x 768).
// Use ResolutionMMPerPixel to determine the number of millimeters in a pixel so you
// can convert the size of the drawing into other units or millimeters based on the
// drawing units used in the current drawing.
// Define the width and height of the image
AcGe.Vector3d width;
AcGe.Vector3d height;
// Check to see if the measurement is set to English (Imperial) or Metric units
if (acCurDb.Measurement == AcDb.MeasurementValue.English)
{
width = new AcGe.Vector3d((acRasterDef.ResolutionMMPerPixel.X * acRaster.ImageWidth) / 25.4, 0, 0);
height = new AcGe.Vector3d(0, (acRasterDef.ResolutionMMPerPixel.Y * acRaster.ImageHeight) / 25.4, 0);
}
else
{
width = new AcGe.Vector3d(acRasterDef.ResolutionMMPerPixel.X * acRaster.ImageWidth, 0, 0);
height = new AcGe.Vector3d(0, acRasterDef.ResolutionMMPerPixel.Y * acRaster.ImageHeight, 0);
}
// Define the position for the image
AcGe.Point3d insPt = new AcGe.Point3d(52000.0, 56000.0, 100.0);
// Define and assign a coordinate system for the image's orientation
AcGe.CoordinateSystem3d coordinateSystem = new AcGe.CoordinateSystem3d(insPt, width * 2, height * 2);
acRaster.Orientation = coordinateSystem;
// Set the rotation angle for the image
acRaster.Rotation = 0;
// Add the new object to the block table record and the transaction
acBlkTblRec.AppendEntity(acRaster);
acTrans.AddNewlyCreatedDBObject(acRaster, true);
// Connect the raster definition and image together so the definition
// does not appear as "unreferenced" in the External References palette.
/*AcDb.RasterImage.EnableReactors(true);*/
acRaster.AssociateRasterDef(acRasterDef);
acRaster.ShowImage = true;
acRaster.ColorIndex = 200;
acRaster.ImageTransparency = true;
acRaster.Orientation = new AcGe.CoordinateSystem3d(insPt, new AcGe.Vector3d(1000, 0, 0), new AcGe.Vector3d(0, 2000, 0));
if (bRasterDefCreated)
{
acRasterDef.Dispose();
}
}
// Save the new object to the database
acTrans.Commit();
// Dispose of the transaction
}
}
public static void ImportLayout(string layoutName, string filename)
{
// Get the current document and database
_AcAp.Document acDoc = _AcAp.Application.DocumentManager.MdiActiveDocument;
_AcDb.Database acCurDb = acDoc.Database;
// Specify the layout name and drawing file to work with
//string layoutName = "MAIN AND SECOND FLOOR PLAN";
//string filename = "C:\\AutoCAD\\Sample\\Sheet Sets\\Architectural\\A-01.dwg";
// Create a new database object and open the drawing into memory
_AcDb.Database acExDb = new _AcDb.Database(false, true);
acExDb.ReadDwgFile(filename, Autodesk.AutoCAD.DatabaseServices.FileOpenMode.OpenForReadAndAllShare, true, "");
// Create a transaction for the external drawing
using (_AcDb.Transaction acTransEx = acExDb.TransactionManager.StartTransaction())
{
// Get the layouts dictionary
_AcDb.DBDictionary layoutsEx = acTransEx.GetObject(acExDb.LayoutDictionaryId, _AcDb.OpenMode.ForRead) as _AcDb.DBDictionary;
// Check to see if the layout exists in the external drawing
if (layoutsEx.Contains(layoutName) == true)
{
// Get the layout and block objects from the external drawing
_AcDb.Layout layEx = layoutsEx.GetAt(layoutName).GetObject(_AcDb.OpenMode.ForRead) as _AcDb.Layout;
_AcDb.BlockTableRecord blkBlkRecEx = acTransEx.GetObject(layEx.BlockTableRecordId, _AcDb.OpenMode.ForRead) as _AcDb.BlockTableRecord;
// Get the objects from the block associated with the layout
_AcDb.ObjectIdCollection idCol = new _AcDb.ObjectIdCollection();
foreach (_AcDb.ObjectId id in blkBlkRecEx)
{
idCol.Add(id);
}
// Create a transaction for the current drawing
using (_AcDb.Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// Get the block table and create a new block
// then copy the objects between drawings
_AcDb.BlockTable blkTbl = acTrans.GetObject(acCurDb.BlockTableId, _AcDb.OpenMode.ForWrite) as _AcDb.BlockTable;
using (_AcDb.BlockTableRecord blkBlkRec = new _AcDb.BlockTableRecord())
{
int layoutCount = layoutsEx.Count - 1;
blkBlkRec.Name = "*Paper_Space" + layoutCount.ToString();
blkTbl.Add(blkBlkRec);
acTrans.AddNewlyCreatedDBObject(blkBlkRec, true);
acExDb.WblockCloneObjects(idCol, blkBlkRec.ObjectId, new _AcDb.IdMapping(), _AcDb.DuplicateRecordCloning.Ignore, false);
// Create a new layout and then copy properties between drawings
_AcDb.DBDictionary layouts = acTrans.GetObject(acCurDb.LayoutDictionaryId, _AcDb.OpenMode.ForWrite) as _AcDb.DBDictionary;
using (_AcDb.Layout lay = new _AcDb.Layout())
{
lay.LayoutName = layoutName;
lay.AddToLayoutDictionary(acCurDb, blkBlkRec.ObjectId);
acTrans.AddNewlyCreatedDBObject(lay, true);
lay.CopyFrom(layEx);
_AcDb.DBDictionary plSets = acTrans.GetObject(acCurDb.PlotSettingsDictionaryId, _AcDb.OpenMode.ForRead) as _AcDb.DBDictionary;
// Check to see if a named page setup was assigned to the layout,
// if so then copy the page setup settings
if (lay.PlotSettingsName != "")
{
// Check to see if the page setup exists
if (plSets.Contains(lay.PlotSettingsName) == false)
{
plSets.UpgradeOpen();
using (_AcDb.PlotSettings plSet = new _AcDb.PlotSettings(lay.ModelType))
{
plSet.PlotSettingsName = lay.PlotSettingsName;
plSet.AddToPlotSettingsDictionary(acCurDb);
acTrans.AddNewlyCreatedDBObject(plSet, true);
_AcDb.DBDictionary plSetsEx = acTransEx.GetObject(acExDb.PlotSettingsDictionaryId, _AcDb.OpenMode.ForRead) as _AcDb.DBDictionary;
_AcDb.PlotSettings plSetEx = plSetsEx.GetAt(lay.PlotSettingsName).GetObject(_AcDb.OpenMode.ForRead) as _AcDb.PlotSettings;
plSet.CopyFrom(plSetEx);
}
}
}
}
}
// Regen the drawing to get the layout tab to display
acDoc.Editor.Regen();
// Save the changes made
acTrans.Commit();
}
}
else
{
// Display a message if the layout could not be found in the specified drawing
acDoc.Editor.WriteMessage("\nLayout '" + layoutName +
"' could not be imported from '" + filename + "'.");
}
// Discard the changes made to the external drawing file
acTransEx.Abort();
}
// Close the external drawing file
acExDb.Dispose();
}
public static void AttachRasterImage(LandRasterImage landRastr)
{
AcEd.Editor ed = AcApp.DocumentManager.MdiActiveDocument.Editor;
//bool bRasterDefCreated = false;
AcDb.Database curDb = AcApp.DocumentManager.MdiActiveDocument.Database;
using (AcDb.Transaction tr = curDb.TransactionManager.StartTransaction())
{
AcDb.RasterImageDef rasterDef;
AcDb.ObjectId imgDefId;
AcDb.ObjectId imgDctID = AcDb.RasterImageDef.GetImageDictionary(curDb);
if (imgDctID.IsNull)
{
imgDctID = AcDb.RasterImageDef.CreateImageDictionary(curDb);
}
AcDb.DBDictionary imgDict = (AcDb.DBDictionary)tr.GetObject(imgDctID, AcDb.OpenMode.ForRead);
if (imgDict.Contains(landRastr.ImageName))
{
imgDefId = imgDict.GetAt(landRastr.ImageName);
rasterDef = (AcDb.RasterImageDef)tr.GetObject(imgDefId, AcDb.OpenMode.ForWrite);
if (rasterDef.IsLoaded)
{
//return;
}
}
else
{
AcPApp.AcadApplication app = AcApp.AcadApplication as AcPApp.AcadApplication;
AcPApp.AcadDocument doc = app.ActiveDocument;
AcPDb.AcadModelSpace mSpace = doc.ModelSpace;
AcPDb.AcadRasterImage ri = mSpace.AddRaster(landRastr.FileName, landRastr.InsertPoint.ToArray(), 1000, 0);
ri.Name = landRastr.ImageName;
ri.Transparency = true;
ServiceCAD.CreateLayer(landRastr.Layer);
ri.Layer = landRastr.Layer;
ri.ImageHeight = 1000;
ri.ImageWidth = 1000;
tr.Commit();
return;
}
AcDb.BlockTable blkTbl =
(AcDb.BlockTable)tr.GetObject(curDb.BlockTableId, AcDb.OpenMode.ForRead);
AcDb.BlockTableRecord acBlkTblRec =
(AcDb.BlockTableRecord)tr.GetObject(blkTbl[AcDb.BlockTableRecord.ModelSpace], AcDb.OpenMode.ForWrite);
using (AcDb.RasterImage rasterImage = new AcDb.RasterImage())
{
rasterImage.ImageDefId = imgDefId;
AcGe.Vector3d width;
AcGe.Vector3d height;
AcGe.Matrix3d ucs = ed.CurrentUserCoordinateSystem;
double size = 1000;
width = new AcGe.Vector3d(size, 0, 0);
height = new AcGe.Vector3d(0, size, 0);
AcGe.Point3d insPt = landRastr.InsertPoint;
AcGe.CoordinateSystem3d coordinateSystem = new AcGe.CoordinateSystem3d(insPt.TransformBy(ucs), width.TransformBy(ucs), height.TransformBy(ucs));
rasterImage.Orientation = coordinateSystem;
rasterImage.Rotation = 0;
rasterImage.ShowImage = true;
acBlkTblRec.AppendEntity(rasterImage);
tr.AddNewlyCreatedDBObject(rasterImage, true);
rasterImage.AssociateRasterDef(rasterDef);
}
tr.Commit();
}
}
private void SubVarianLoadRaster()
{
String PIC_NAME = "C:\\_Temp_\\5525.TIF";
AcDb.Database CurDb = AcAp.Application.DocumentManager.MdiActiveDocument.Database;
using (AcDb.Transaction acTrans = CurDb.TransactionManager.StartTransaction())
{
try
{
AcDb.ObjectId dictId = AcDb.RasterImageDef.GetImageDictionary(CurDb);
if (dictId == null)
{
dictId = AcDb.RasterImageDef.CreateImageDictionary(CurDb);
}
AcDb.DBDictionary dict = acTrans.GetObject(dictId, AcDb.OpenMode.ForRead) as AcDb.DBDictionary;
String recName = "5525";
AcDb.RasterImageDef rid = new AcDb.RasterImageDef
{
SourceFileName = PIC_NAME
};
dict.UpgradeOpen();
AcDb.ObjectId defId = dict.SetAt(recName, rid);
rid.Load();
acTrans.AddNewlyCreatedDBObject(rid, true);
AcDb.RasterImage ri = new AcDb.RasterImage
{
ImageDefId = defId,
ShowImage = true,
Orientation = new AcGe.CoordinateSystem3d(new AcGe.Point3d(200, 300, 0), new AcGe.Vector3d(1, 0, 0), new AcGe.Vector3d(0, 1, 0))
};
AcDb.BlockTable bt = acTrans.GetObject(CurDb.BlockTableId, AcDb.OpenMode.ForRead, false) as AcDb.BlockTable;
AcDb.BlockTableRecord btr = acTrans.GetObject(bt[AcDb.BlockTableRecord.ModelSpace], AcDb.OpenMode.ForWrite, false) as AcDb.BlockTableRecord;
btr.AppendEntity(ri);
acTrans.AddNewlyCreatedDBObject(ri, true);
ri.AssociateRasterDef(rid);
ri.TransformBy(AcGe.Matrix3d.Scaling(1000, new AcGe.Point3d(200, 300, 0)));
}
catch
{
return;
}
}
/*
* Try
* Dim PIC_NAME As String = original_picture_name
* Dim dictId As ObjectId = RasterImageDef.GetImageDictionary(Db)
* If dictId = Nothing Then
* dictId = RasterImageDef.CreateImageDictionary(Db)
* End If
* Dim dict As DBDictionary = CType(acTrans.GetObject(dictId, OpenMode.ForRead), DBDictionary)
* Dim recName As String = Picture_name_in_drawing
* Dim rid As RasterImageDef = New RasterImageDef
* rid.SourceFileName = PIC_NAME
* dict.UpgradeOpen()
* Dim defId As ObjectId = dict.SetAt(recName, rid)
* rid.Load()
* acTrans.AddNewlyCreatedDBObject(rid, True)
* Dim ri As RasterImage = New RasterImage
* ri.ImageDefId = defId
* ri.ShowImage = True
* ri.Orientation = New CoordinateSystem3d(New Point3d(x1, y1, 0), New Vector3d(1, 0, 0), New Vector3d(0, 1, 0))
* Dim bt As BlockTable
* Dim btr As BlockTableRecord
* bt = acTrans.GetObject(Db.BlockTableId, OpenMode.ForRead, False)
* btr = acTrans.GetObject(bt(BlockTableRecord.ModelSpace), OpenMode.ForWrite, False)
* btr.AppendEntity(ri)
* acTrans.AddNewlyCreatedDBObject(ri, True)
* ri.AssociateRasterDef(rid)
* ri.TransformBy(Matrix3d.Scaling(picture_scale, New Point3d(x1, y1, 0)))
* Catch
*
* Exit Sub
* End Try
*
*/
}
