Copy Block From file to file
While you said you have "very clear steps", your code shown in your later post says otherwise.
In your latest posted code, you are trying to copy/place BlockReference from source drawing into BlockTable of the destination drawing, which would fail for sure.
The process itself, as you described, is not too complicated: the 2 main tasks are to identify BlockReferences to be replaced, and import/insert/identify a new block definition (BlockTableRecord) into the drawing, so that you can create new BlockReferencesto replace the existing ones.
For the first one, you can either loop through each layout to find BlockReferences with that name (if it is dynamic block, extra attention is needed, regarding its name). Or you can simply use Editor.SelectAll with proper filter to select all block refernces regardless layout (assume the drawing is opened in AutoCAD editor).
For the second task, it is not very clear fromo your description: is the source drawing a NewBlock itself, or is the NewBlock one of the block definitions stored in source drawing? If it is the former, then ut is very simple: you simply insert this drawing as block definition; if it is latter, then you indeed need to WBlockCloneObjects() this block defeinition (BlockTableRecord!) from the source drawing into destination drawing's BlockTable.
So here is the pseudo-code of what you do:
For each DrawingFileName in DrawingFileNameList
Open the drawing in AutoCAD/Or oepn the drawing as side database
Test if the NewBlock definition exists.
If NewBlock definition is ot found Then
Database.Insert()/SourceDatabase.WblockCloneObjects() //depending on the source drawing
End
Search drawing/DB for the OldBlock to get a list of ObjectId (of the OldBlock references
For each oldBlock Id in olbBlockIds
Open the oldBlockrefernce to obtain attribute values, keyed by attribute tags, and its position
Insert blockreferences of NewBlock at the position, set its attributes
Delete the pldBlock reference
Next
Savethe drawing/DB, and close it
Next
@micle.space wrote:
Thank you Norman, you are right, I'm bit confuse (due to the low knoweledge of hierarchy autocad class) , this is my first program and it is not my job... but I would like to socceed.
in these days with a bit of your suggestions and a bit other researchs on the web I got some results but the routine is not working properly yet.
I wonder if could be possible have the same approach of your suggestion and research by layout.
Following the pseudo-code:
For each DrawingFileName in DrawingFileNameList
......
If NewBlock definition is not found Then <<<<<This search has to be done for each Layout (not for Model_Space)
Database.Insert()/SourceDatabase.WblockCloneObjects() //depending on the source drawing
End
......
Next
Block definition (BlockTableRecord) is "per database" (per drawing), not "per layout"!
It is the next step (searching "OldBlock" references to be replaced where you may want to limit the search on specific layout.
I happened to have a bit time, so, I put together a chunk of code that works in following condition:
1. 2 target drawings to be processed. Each has a few block references named as "OldBlock" inserted on various layouts. The "OldBlock" has a few attributes"; and the block is not dynamic block (so, when searching block references, the code only compare BlockReference.Name is equal "OldBlock" or not).
2. The block used to replace "OldBlock" references existing in target drawings is named as "NewBlock", which has the same set of attributes (i.e. the attributes have the same tags); "NewBlock" is not defined in target drawings; "NewBlock" exists as a block drawing file.
3. The code open the target drawing as side database (not opening it in AutoCAD editor visibly).
4. To find existing "OldBlock" references, I simply loop through all Layout blocks. It can also be done in other ways, such as firstly find the "OldBlock" definition, and call its GetBlockReferenceIds(), and then traces back to the block reference's owner block, thus the layout...
Here is the code that works well:
using System.Collections.Generic;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
using CadApp = Autodesk.AutoCAD.ApplicationServices.Application;
[assembly: CommandClass(typeof(ReplaceBlocks.MyCommands))]
namespace ReplaceBlocks
{
internal class BlockAttributeData
{
public ObjectId BlkRefId { set; get; }
public string Layer { set; get; }
public Dictionary<string, string> Attributes { private set; get; }
internal BlockAttributeData()
{
BlkRefId = ObjectId.Null;
Attributes = new Dictionary<string, string>();
}
}
internal class DrawingAttributeData : Dictionary<ObjectId, IEnumerable<BlockAttributeData>>
{
}
public class MyCommands
{
[CommandMethod("ReplaceBlk")]
public static void RunDocCommand()
{
string[] dwgFiles = new string[]
{
@"C:\Users\norman.yuan\Documents\Visual Studio 2017\Projects\AutoCAD2017\ReplaceBlocks\TestDwgs\TestDrawingA.dwg",
@"C:\Users\norman.yuan\Documents\Visual Studio 2017\Projects\AutoCAD2017\ReplaceBlocks\TestDwgs\TestDrawingB.dwg"
};
string newBlockFile =
@"C:\Users\norman.yuan\Documents\Visual Studio 2017\Projects\AutoCAD2017\ReplaceBlocks\TestDwgs\NewBlock.dwg";
var workingDb = HostApplicationServices.WorkingDatabase;
try
{
foreach (var dwgfile in dwgFiles)
{
// Open target drawing as side database.
// It makes the processing a lot faster than opening
// drawing in Editor visibly.
// One can choose open the drawing in Editor, if desired.
using (var db = OpenSideDatabase(dwgfile))
{
HostApplicationServices.WorkingDatabase = db;
ReplaceBlocks(db, "OldBlock", "NewBlock", newBlockFile);
db.SaveAs(dwgfile, true, DwgVersion.Current, null);
}
}
}
catch (System.Exception ex)
{
CadApp.ShowAlertDialog("Error:\r\n" + ex.Message);
}
finally
{
HostApplicationServices.WorkingDatabase = workingDb;
Autodesk.AutoCAD.Internal.Utils.PostCommandPrompt();
}
}
private static Database OpenSideDatabase(string dwgFileName)
{
var db = new Database(false, true);
db.ReadDwgFile(
dwgFileName, FileOpenMode.OpenForReadAndWriteNoShare, false, null);
return db;
}
private static void ReplaceBlocks(
Database db, string oldBlkName, string newBlkName, string newBlockFile)
{
// Find all "OldBlock" references and collect their attribute data
// If only blockreference on certain layout is targeted, this is where
// one can decide which layout to be excluded
var dwgAttData = CollectOldBlockAttributeData(db, oldBlkName);
if (dwgAttData.Count==0)
{
CadApp.ShowAlertDialog("No \"" + oldBlkName + "\" found!");
return;
}
// Make sure "NewBlock" is defined in the drawing. If not, get it from
// a block drawing file (Database.Insert(); or the the block definition
// is in a drawing where many blocks are defined, use
// use Database.WblockCloneObjects() to bring this block definition
// into this drawing
var newBlkDefId = EnsureNewBlockDefinition(db, newBlkName, newBlockFile);
if (newBlkDefId.IsNull)
{
CadApp.ShowAlertDialog(
"NewBlock definition is not found in source drawing!");
return;
}
// Replacing "OldBlock" references by
// 1. Insert "NewBlock" at the same position/same layer
// 2. Sych attribute values (because both old and new blocks have the same Attrs.
// 3. Erase "OldBlock" reference
ReplaceOldBlocks(db, newBlkDefId, dwgAttData);
}
#region find all "OldBlock" and their attribute information
private static DrawingAttributeData CollectOldBlockAttributeData(
Database db, string oldBlkName)
{
var attData = new DrawingAttributeData();
using (var tran = db.TransactionManager.StartTransaction())
{
var dic = (DBDictionary)tran.GetObject(
db.LayoutDictionaryId, OpenMode.ForRead);
foreach (DBDictionaryEntry entry in dic)
{
var layout = (Layout)tran.GetObject(entry.Value, OpenMode.ForRead);
var layoutAttData = CollectOldBlockAttributeDataOnLayout(
oldBlkName, layout.BlockTableRecordId, tran);
if (layoutAttData.Count > 0)
{
attData.Add(layout.BlockTableRecordId, layoutAttData);
}
}
tran.Commit();
}
return attData;
}
private static List<BlockAttributeData> CollectOldBlockAttributeDataOnLayout(
string oldBlkName, ObjectId layoutBlockId, Transaction tran)
{
var layoutAttData = new List<BlockAttributeData>();
var layoutBlock = (BlockTableRecord)tran.GetObject(layoutBlockId, OpenMode.ForRead);
foreach (ObjectId id in layoutBlock)
{
if (id.ObjectClass.DxfName.ToUpper()=="INSERT")
{
var blk = (BlockReference)tran.GetObject(id, OpenMode.ForRead);
if (blk.Name.ToUpper()==oldBlkName.ToUpper())
{
var blkAttData = CollectOldBlockAttributes(blk, tran);
if (blkAttData.Attributes.Count > 0)
{
layoutAttData.Add(blkAttData);
}
}
}
}
return layoutAttData;
}
private static BlockAttributeData CollectOldBlockAttributes(
BlockReference bref, Transaction tran)
{
var blkAttData = new BlockAttributeData();
blkAttData.BlkRefId = bref.ObjectId;
blkAttData.Layer = bref.Layer;
foreach (ObjectId id in bref.AttributeCollection)
{
var att = (AttributeReference)tran.GetObject(id, OpenMode.ForRead);
if (att.IsConstant) continue;
if (!blkAttData.Attributes.ContainsKey(att.Tag.ToUpper()))
{
blkAttData.Attributes.Add(att.Tag.ToUpper(), att.TextString);
}
}
return blkAttData;
}
#endregion
#region make sure "NewBlock" definition exists
private static ObjectId EnsureNewBlockDefinition(
Database db, string newBlkName, string newBlockFile)
{
var blkId = ObjectId.Null;
using (var tran=db.TransactionManager.StartTransaction())
{
var bt =
(BlockTable)tran.GetObject(db.BlockTableId, OpenMode.ForRead);
if (bt.Has(newBlkName)) blkId = bt[newBlkName];
tran.Commit();
}
if (blkId.IsNull)
{
blkId = InsertNewBlockDefinition(db, newBlkName, newBlockFile);
}
return blkId;
}
private static ObjectId InsertNewBlockDefinition(
Database db, string blkName, string blkFile)
{
var blkId = ObjectId.Null;
using (var blkDb = new Database(false, true))
{
blkDb.ReadDwgFile(
blkFile, FileOpenMode.OpenForReadAndReadShare, false, null);
blkId = db.Insert(blkName, blkDb, false);
}
return blkId;
}
#endregion
#region do the replacing work
private static void ReplaceOldBlocks(
Database db, ObjectId newBlkDefId,
DrawingAttributeData dwgAttData)
{
using (var tran = db.TransactionManager.StartTransaction())
{
foreach (var item in dwgAttData)
{
var layoutBlock =
(BlockTableRecord)tran.GetObject(item.Key, OpenMode.ForWrite);
var newBlock =
(BlockTableRecord)tran.GetObject(newBlkDefId, OpenMode.ForRead);
foreach (var blkData in item.Value)
{
var oldBlk =
(BlockReference)tran.GetObject(blkData.BlkRefId, OpenMode.ForRead);
var position = oldBlk.Position;
CreateNewBlockReference(
db, layoutBlock, newBlock,
position, blkData.Layer,
blkData.Attributes, tran);
oldBlk.UpgradeOpen();
oldBlk.Erase();
}
}
tran.Commit();
}
}
private static void CreateNewBlockReference(
Database db, BlockTableRecord layoutBlock,
BlockTableRecord newBlock, Point3d position,
string layer, Dictionary<string, string> attData,
Transaction tran)
{
var bref = new BlockReference(position, newBlock.ObjectId);
bref.SetDatabaseDefaults(db);
bref.Layer = layer;
var brefId = layoutBlock.AppendEntity(bref);
tran.AddNewlyCreatedDBObject(bref, true);
SetAttributes(brefId, newBlock, attData, tran);
}
private static void SetAttributes(
ObjectId brefId, BlockTableRecord newBlock,
Dictionary<string, string> attData, Transaction tran)
{
var bref = (BlockReference)tran.GetObject(brefId, OpenMode.ForWrite);
foreach (ObjectId id in newBlock)
{
var attDef = tran.GetObject(id, OpenMode.ForRead) as AttributeDefinition;
if (attDef!=null)
{
var att = new AttributeReference();
att.SetAttributeFromBlock(attDef, bref.BlockTransform);
if (!attDef.Constant)
{
if (attData.ContainsKey(att.Tag.ToUpper()))
{
att.TextString = attData[att.Tag.ToUpper()];
}
}
bref.AttributeCollection.AppendAttribute(att);
tran.AddNewlyCreatedDBObject(att, true);
}
}
}
#endregion
}
}
HTH
