ObjectArx块操作封装

admin1

块定义

1. #include "StdAfx.h"
   
2. #include "Commands.h"
   
3. #include "Editor.h"
   
4. 
   
5. void AddCommands()
   
6. {       
   
7.         Editor::AddCommand(_T("AddBlock"), ACRX_CMD_MODAL, CreateBlock);
   
8. }
   
9. 
   
10. void CreateBlock()
    
11. {   // 创建一个空的块表对象指针pBlkTbl
    
12.         AcDbBlockTable *pBlkTbl = NULL;
    
13.         // 以写得方式打开数据库文件dwg，获得块表指针，并赋值给pBlkTbl
    
14.         acdbHostApplicationServices()->workingDatabase()->
    
15.                                 getBlockTable(pBlkTbl, AcDb::kForWrite);
    
16.         // 创建一个块表记录对象（构造函数创建的）指针pBlkRcd
    
17.         AcDbBlockTableRecord *pBlkRcd = new AcDbBlockTableRecord();
    
18.        
    
19.         // ACHAR：CAD中用于定义宽字符型变量
    
20.         ACHAR  blkName[40];
    
21.         // 与用户交互：输入是否包含空格、提示文字（无则NULL）、
    
22.         //                          接收输入变量；RTNORM为return normal
    
23.         if (acedGetString(Adesk::kFalse,
    
24.                                           _T("\n 请输入块名（空格结束）："),
    
25.                                           blkName) !=  RTNORM)
    
26.         {        // 未输入退出：关闭块表（针对dwg文件）
    
27.                 pBlkTbl->close();
    
28.                 // 删除块表指针指向的内存（释放内存）
    
29.                 delete pBlkRcd;
    
30.                 // 结束退出
    
31.                 return;
    
32.         }
    
33.         // 设置块表记录名：跟Model_Space同级，见下图
    
34.         pBlkRcd->setName(blkName);
    
35.         // 将块表记录添加进块表中
    
36.         AcDbObjectId blkDefId;
    
37.         pBlkTbl->add(blkDefId, pBlkRcd);
    
38.         // 重要：添加后，调用类方法close关闭块表，可通过pBlkRcd继续操作块表记录
    
39.         pBlkTbl->close();
    
40. 
    
41.         // 创建两个数据库线对象指针
    
42.         AcGePoint3d pt1(0, 0, 0), pt2(100, 0, 0), pt3(0, 100, 0);
    
43.         AcDbLine *pL_1 = new AcDbLine(pt1, pt2);
    
44.         AcDbLine *pL_2 = new AcDbLine(pt1, pt3);
    
45. 
    
46.         // 将对象指针添加进块表记录中，entId返回的是每次添加的对象返回的对象id
    
47.         AcDbObjectId entId;
    
48.         pBlkRcd->appendAcDbEntity(entId, pL_1);
    
49.         pBlkRcd->appendAcDbEntity(entId, pL_2);
    
50. 
    
51.         // 重要：添加后，调用close函数关闭直线对象
    
52.         pL_1->close();
    
53.         pL_2->close();
    
54.         // 重要：调用类方法close关闭块表记录
    
55.         pBlkRcd->close();
    
56. }
    

复制代码

admin1

块参照类

1. Block.h
   
2. 
   
3. #pragma once
   
4. class Block
   
5. {
   
6. public:
   
7.         Block();
   
8.         ~Block();
   
9.         // 插入块参照：块定义对象ID、插入点、比例、旋转弧度
   
10.         static AcDbObjectId InsertBlkRef(AcDbObjectId blkDefId,
    
11.                                                                           const AcGePoint3d &ptInsert,
    
12.                                                                          double scale = 1.0,
    
13.                                                                          double rotation = 0.0);
    
14.         // 设置块参照比例：块参照指针、比例
    
15.         static void   SetBlkScale(AcDbBlockReference *pBlkRef, double scale = 1.0);
    
16.         // 获取块参照ID：传入块参照名称、数据库指针
    
17.         static AcDbObjectId GetBlkDefId(const ACHAR *blkDefName,
    
18.                                                                         AcDbDatabase *pDb =
    
19.                                                                         acdbHostApplicationServices()->
    
20.                                                                         workingDatabase());
    
21. };
    
22. 
    
23. 
    
24. Block.cpp
    
25. 
    
26. #include "stdafx.h"
    
27. #include "Block.h"
    
28. #include "Database.h"
    
29. 
    
30. Block::Block(){}
    
31. Block::~Block(){}
    
32. 
    
33. // 插入块参照：块定义对象ID、插入点、比例、旋转弧度
    
34. AcDbObjectId Block::InsertBlkRef(AcDbObjectId blkDefId,
    
35.                                                                  const AcGePoint3d &ptInsert,
    
36.                                                                  double scale ,
    
37.                                                                  double rotation)
    
38. {        // 块参照对象指针：插入点，块定义对象ID
    
39.         AcDbBlockReference *pBlkRef = new AcDbBlockReference(ptInsert, blkDefId);
    
40.         // 设置块参照旋转弧度
    
41.         pBlkRef->setRotation(rotation);
    
42.         // 设置块参照比例
    
43.         SetBlkScale(pBlkRef, scale);
    
44.         // 添加进数据库文件dwg
    
45.         return Database::PostToModelSpace(pBlkRef);
    
46. 
    
47. }
    
48. 
    
49. // 设置块参照比例：块参照指针、比例
    
50. void Block::SetBlkScale(AcDbBlockReference *pBlkRef, double scale)
    
51. {        // 断言块参照指针：若为空则报错，判断括号里表达式真假
    
52.         assert(pBlkRef);
    
53.         // 设置3d比例
    
54.         AcGeScale3d geScale(scale, scale, scale);
    
55.         // 设置块参照比例:传入的需要是AcGeScale3d
    
56.         pBlkRef->setScaleFactors(geScale);
    
57. }
    
58. 
    
59. // 获取块定义ID：传入块定义名称、数据库指针
    
60. AcDbObjectId Block::GetBlkDefId(const ACHAR *blkDefName, AcDbDatabase *pDb)
    
61. {        // 块表指针
    
62.         AcDbBlockTable *pBlkTbl = NULL;
    
63.         // 获得块表指针并给pBlkTbl赋值
    
64.         Acad::ErrorStatus es = pDb->getBlockTable(pBlkTbl, AcDb::kForRead);
    
65.         // 块定义对象ID
    
66.         AcDbObjectId blkDefId;
    
67.         // 通过块定义名称获得块定义对象id
    
68.         es = pBlkTbl->getAt(blkDefName, blkDefId);
    
69.         // 关闭块表
    
70.         pBlkTbl->close();
    
71.         // 如果查找到，返回对象ID，没查找到返回空
    
72.         if (es == Acad::eOk)
    
73.         {
    
74.                 return blkDefId;
    
75.         }
    
76.         else
    
77.         {
    
78.                 return AcDbObjectId::kNull;
    
79.         }
    
80. }
    
81. 
    
82. 
    
83. 
    
84. 
    
85. 
    
86. 
    
87. 
    
88. #include "StdAfx.h"
    
89. 
    
90. void AddCommands();
    
91. void CreateBlock();
    
92. void InsertBlk();
    
93. 
    
94. 
    
95. #include "StdAfx.h"
    
96. #include "Commands.h"
    
97. #include "Editor.h"
    
98. #include "MathUtil.h"
    
99. #include "Block.h"
    
100. 
     
101. 
     
102. void AddCommands()
     
103. {        // 块定义
     
104.         Editor::AddCommand(_T("AddBlock"), ACRX_CMD_MODAL, CreateBlock);
     
105.         // 插入块参照
     
106.         Editor::AddCommand(_T("InsertBlock"), ACRX_CMD_MODAL, InsertBlk);
     
107. }
     
108. 
     
109. void CreateBlock()
     
110. {   
     
111.         ...见块定义
     
112. }
     
113. 
     
114. // 插入块参照
     
115. void InsertBlk()
     
116. {        // 块定义名称：这里需输入AddBlock命令增加的块定义的块名
     
117.         ACHAR blkName[40];
     
118.         if (acedGetString(Adesk::kFalse,
     
119.                                           _T("\n 请输入待插入的块名:"),
     
120.                                           blkName) != RTNORM)
     
121.                 return;
     
122. 
     
123.         // 获得块定义ID:传入块定义名称
     
124.         AcDbObjectId blkDefId = Block::GetBlkDefId(blkName);
     
125.         if (blkDefId.isNull())
     
126.         {
     
127.                 acutPrintf(_T("\n查无此块!"));
     
128.                 return;
     
129.         }
     
130. 
     
131.         // 用户交互：选项、提示信息、插入点（后续解释）
     
132.         ads_point pt;
     
133.         if (acedGetPoint(NULL, _T("\n 选择插入点:"), pt) != RTNORM)
     
134.                 return;
     
135.         // 将ads_point转换为AcGePoint3d
     
136.         AcGePoint3d pInsert = asPnt3d(pt);
     
137.         // 插入块参照：块定义ID、插入点、缩放比例、旋转弧度
     
138.         Block::InsertBlkRef(blkDefId, pInsert, 2.0, MathUtil::PI() / 2);
     
139. }
     
140. 
     
141. 
     
142. 
     
143. 
     
144. 
     
145. 
     
146. 
     

复制代码

admin1

// 插入带属性的块参照：块定义id、插入点、缩放比例、旋转弧度
static AcDbObjectId InsertBlkRefWithAtt(const AcDbObjectId &blkDefId,
                                                                                const AcGePoint3d &insertPoint,
                                                                                double scale = 1.0,
                                                                                double rotation = 0.0);

1. // 插入带属性的块参照：块定义id、插入点、缩放比例、旋转弧度
   
2. AcDbObjectId Block::InsertBlkRefWithAtt(const AcDbObjectId &blkDefId,
   
3.                                                                                 const AcGePoint3d &insertPoint,
   
4.                                                                                 double scale,
   
5.                                                                                 double rotation)
   
6. {        // 创建块参照对象指针：插入点、块定义id，
   
7.         //                 带属性的块参照只是在块参照上增加了个文字属性，还是块参照
   
8.         AcDbBlockReference *pBlkRef = new AcDbBlockReference(insertPoint, blkDefId);
   
9.         // 设置块参照比例：参见本文件
   
10.         SetBlkScale(pBlkRef, scale);
    
11.         // 给块参照设置旋转弧度
    
12.         pBlkRef->setRotation(rotation);
    
13. 
    
14.         // 查找块定义所在的块表记录
    
15.         AcDbBlockTableRecord *pBlkTblRcd = NULL;
    
16.         if (acdbOpenObject(pBlkTblRcd, blkDefId, AcDb::kForRead) == Acad::eOk)
    
17.         {        // 如果块表记录含有属性定义对象
    
18.                 if (pBlkTblRcd->hasAttributeDefinitions())
    
19.                 {        // 创建块表记录迭代器pItr
    
20.                         AcDbBlockTableRecordIterator *pItr = NULL;
    
21.                         // 初始化pItr
    
22.                         pBlkTblRcd->newIterator(pItr);
    
23.                         // 遍历块表记录中的每个实体对象，为了找属性定义对象
    
24.                         for (pItr->start();!pItr->done(); pItr->step())
    
25.                         {        // AcDbEntity是所有实体的基类
    
26.                                 AcDbEntity *pEnt = NULL;
    
27.                                 // 查找属性定义：打开每个实体
    
28.                                 if (pItr->getEntity(pEnt, AcDb::kForRead) == Acad::eOk)
    
29.                                 {        // 如果实体是属性定义的派生类
    
30.                                         if (pEnt->isKindOf(AcDbAttributeDefinition::desc()))
    
31.                                         {        // 强制类型转换，转成属性定义的指针pAttdef
    
32.                                                 AcDbAttributeDefinition *pAttdef =
    
33.                                                                         AcDbAttributeDefinition::cast(pEnt);
    
34.                                                 // 调用本文件的函数，将属性定义加工后添加进块参照中
    
35.                                                 appendAttributeToBlkRef(pBlkRef, pAttdef);
    
36.                                         }
    
37.                                 }// 循环内，每次打开的实体对象都要关闭
    
38.                                 pEnt->close();
    
39.                         }// 循环结束，删除迭代器
    
40.                         delete pItr;
    
41.                 }       
    
42.                 // 关闭块表记录
    
43.                 pBlkTblRcd->close();
    
44.         }// 将块参照（属性块参照）添加进数据库文件dwg中
    
45.         return Database::PostToModelSpace(pBlkRef);
    
46. }
    

复制代码

admin1

// 添加属性定义到块参照：块参照指针、属性定义指针
static  void  appendAttributeToBlkRef(AcDbBlockReference *pBlkRef,
                                                                          AcDbAttributeDefinition *pAttDef);

1. // 添加属性到块参照：块参照指针、属性定义指针
   
2. void Block::appendAttributeToBlkRef(AcDbBlockReference *pBlkRef,
   
3.                                                                         AcDbAttributeDefinition *pAttDef)
   
4. {        // 创建属性对象指针pAtt
   
5.         AcDbAttribute *pAtt = new AcDbAttribute();
   
6.         // 从块参照获得属性对象的对象特性、图层
   
7.         pAtt->setPropertiesFrom(pBlkRef);
   
8.         pAtt->setLayer(pBlkRef->layerId());
   
9.         // 从属性定义获得可见性、定位、高度、宽度因子、旋转角度
   
10.         pAtt->setInvisible(pAttDef->isInvisible());
    
11.         pAtt->setPosition(pAttDef->position());
    
12.         pAtt->setHeight(pAttDef->height());
    
13.         pAtt->setWidthFactor(pAttDef->widthFactor());
    
14.         pAtt->setRotation(pAttDef->rotation());
    
15.         // 从属性定义获得水平模式、垂直模式、对齐点、文字样式、属性
    
16.         pAtt->setHorizontalMode(pAttDef->horizontalMode());
    
17.         pAtt->setVerticalMode(pAttDef->verticalMode());
    
18.         pAtt->setAlignmentPoint(pAttDef->alignmentPoint());
    
19.         pAtt->setTextStyle(pAttDef->textStyle());
    
20.         pAtt->setAttributeFromBlock(pBlkRef->blockTransform());
    
21. 
    
22.         // 从属性定义中 获得 并设置 标签tag名，就是样例为“直径”
    
23.         ACHAR *pStr = pAttDef->tag();
    
24.         pAtt->setTag(pStr);
    
25.         // 删除字符串指针
    
26.         acutDelString(pStr);
    
27.         // 从属性定义中获得命名空间长度、设置text的value
    
28.         pAtt->setFieldLength(pAttDef->fieldLength());
    
29.         pAtt->setTextString(pAttDef->textString());
    
30. 
    
31.         // 将属性对象添加进块参照中，构成属性块参照
    
32.         pBlkRef->appendAttribute(pAtt);
    
33.         // 关闭属性对象
    
34.         pAtt->close();
    
35. 
    
36. }
    

复制代码

admin1

// 修改带属性的块参照中的属性：块参照指针、属性标签、Text对应的value新值
static bool SetBlockRefAttribute(AcDbBlockReference *pBlkRef,
                                                                 const ACHAR *tag,
                                                                 const ACHAR *val);

1. // 修改带属性的块参照的属性：块参照指针、tag标签名、text的value新值
   
2. bool Block::SetBlockRefAttribute(AcDbBlockReference *pBlkRef,
   
3.                                                                  const ACHAR *tag,
   
4.                                                                  const ACHAR *val)
   
5. {
   
6.         AcDbBlockTableRecord *pBlkTblRcd = NULL;
   
7.         bool bRet = true;
   
8.         // 提取 块参照 的 块表记录指针pBlkTblRcd：
   
9.         //                块参照指针->blockTableRecord()
   
10.         //                返回 块参照 的 块表记录 的 对象id
    
11.         if (acdbOpenObject(pBlkTblRcd,
    
12.                                            pBlkRef->blockTableRecord(),
    
13.                                            AcDb::kForRead) == Acad::eOk)
    
14.         {        // 判断模型空间中的块表记录（块参照所在的）是否含有属性
    
15.                 if (pBlkTblRcd->hasAttributeDefinitions())
    
16.                 {        // 创建 块表记录迭代器 指针 及 初始化
    
17.                         AcDbBlockTableRecordIterator *pItr = NULL;
    
18.                         pBlkTblRcd->newIterator(pItr);
    
19.                         AcDbEntity *pEnt = NULL;
    
20.                         // 通过 块表记录迭代器 遍历 块表记录中 各个实体 找 属性对象
    
21.                         for (pItr->start();!pItr->done(); pItr->step())
    
22.                         {
    
23.                                 pItr->getEntity(pEnt, AcDb::kForRead);
    
24.                                 // 如果找到属性对象：见代码下的解释
    
25.                                 if (pEnt->isKindOf(AcDbAttributeDefinition::desc()))
    
26.                                 {        // 强制类型转换为 属性定义指针（从基类到派生类）
    
27.                                         AcDbAttributeDefinition *pAttDef =
    
28.                                                                         AcDbAttributeDefinition::cast(pEnt);
    
29.                                         // 获得属性定义的tag标签名：此例为“直径”
    
30.                                         ACHAR *pszTag = pAttDef->tag();
    
31.                                         // 浅拷贝个副本
    
32.                                         CString strTag = pszTag;
    
33.                                         // 释放pszTag指针内存，未删除指针
    
34.                                         acutDelString(pszTag);
    
35.                                         // 找到目标标签tag：不区分大小写的比较strTag和tag（相同为0）
    
36.                                         if (strTag.CompareNoCase(tag) == 0)
    
37.                                         {        // 是否发现目标tag标签
    
38.                                                 bool bFound = false;
    
39.                                                 // 创建块参照 的 属性迭代器（一个属性块可以有多个属性）
    
40.                                                 // 方法的返回值为AcDbObjectIterator *
    
41.                                                 AcDbObjectIterator *attIt = pBlkRef->attributeIterator();
    
42.                                                 // 循环迭代读取每个属性
    
43.                                                 for (attIt->start();!attIt->done();attIt->step())
    
44.                                                 {       
    
45.                                                         AcDbAttribute *pAtt = NULL;
    
46.                                                         // attIt->objectId():属性遍历器获得对象ID的方法，
    
47.                                                         //                                          属性对象指针pAtt接收返回值
    
48.                                                         Acad::ErrorStatus es = acdbOpenObject(pAtt,
    
49.                                                                                                                                   attIt->objectId(),
    
50.                                                                                                                                   AcDb::kForWrite);
    
51.                                                         if (es == Acad::eOk)
    
52.                                                         {        // 提取属性对象的标签，此例“直径”
    
53.                                                                 pszTag = pAtt->tag();
    
54.                                                                 strTag = pszTag;
    
55.                                                                 acutDelString(pszTag);
    
56.                                                                 // 当当前遍历的标签名strTag和传入的目标标签名tag匹配
    
57.                                                                 if (strTag.CompareNoCase(tag) == 0)
    
58.                                                                 {        // 修改属性的text的value值
    
59.                                                                         pAtt->setTextString(val);
    
60.                                                                         bFound = true;
    
61.                                                                 }// 关闭属性对象
    
62.                                                                 pAtt->close();
    
63.                                                         }
    
64.                                                 }// 删除属性迭代器
    
65.                                                 delete attIt;
    
66.                                                 // 如果没发现匹配的属性标签tag，将属性定义添加进块参照中
    
67.                                                 if (!bFound)
    
68.                                                 {        // 将属性添加进块参照中
    
69.                                                         appendAttributeToBlkRef(pBlkRef, pAttDef);
    
70.                                                 }
    
71.                                         }
    
72.                                 }// 关闭实体
    
73.                                 pEnt->close();
    
74.                         }// 删除实体迭代器
    
75.                         delete pItr;
    
76.                 }// 提取失败：返回false
    
77.                 else
    
78.                 {        // 修改失败
    
79.                         bRet = false;
    
80.                 }// 关闭块表记录
    
81.                 pBlkTblRcd->close();
    
82.         }// 返回是否修改是否成功
    
83.         return bRet;
    
84. }
    

复制代码

admin1

1. #include "StdAfx.h"
   
2. #include "Commands.h"
   
3. #include "Editor.h"
   
4. #include "MathUtil.h"
   
5. #include "Block.h"
   
6. #include "atlstr.h"        // 需要这个，否则CString无法识别
   
7. 
   
8. 
   
9. void AddCommands()
   
10. {        // 属性块定义
    
11.         Editor::AddCommand(_T("AddAttBlk"), ACRX_CMD_MODAL, CreateAttBlk);
    
12.         // 插入属性块参照
    
13.         Editor::AddCommand(_T("InsertAtt"), ACRX_CMD_MODAL, InsertAtt);
    
14. }
    
15. 
    
16. // 创建属性块定义
    
17. void CreateAttBlk()
    
18. {        // 以下为创建块定义代码，同上一节
    
19.         AcDbBlockTable *pBlkTbl = NULL;
    
20.         acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlkTbl,
    
21.                                                                                                                                         AcDb::kForWrite);
    
22.         AcDbBlockTableRecord *pBlkRcd = new AcDbBlockTableRecord();
    
23. 
    
24.         ACHAR  blkName[40];
    
25.         if(acedGetString(Adesk::kFalse,_T("\n 请输入块名（空格结束）："),blkName) != RTNORM)
    
26.         {       
    
27.                 pBlkTbl->close();
    
28.                 delete pBlkRcd;
    
29.                 return;
    
30.         }
    
31.         pBlkRcd->setName(blkName);
    
32.         AcDbObjectId blkDefId;
    
33.         pBlkTbl->add(blkDefId, pBlkRcd);
    
34.         pBlkTbl->close();
    
35. 
    
36.         AcGePoint3d pt1(0, 0, 0), pt2(100, 0, 0), pt3(0, 100, 0);
    
37.         AcDbLine *pL_1 = new AcDbLine(pt1, pt2);
    
38.         AcDbLine *pL_2 = new AcDbLine(pt1, pt3);
    
39.         // 创建属性定义对象指针：插入点、tag标签、text的value值、提示信息
    
40.         AcDbAttributeDefinition *pAttDef = new AcDbAttributeDefinition(pt3,
    
41.                                                                                                                                    _T("20"),
    
42.                                                                                                                                    _T("直径"),
    
43.                                                                                                                                    _T("请输入直径"));
    
44.         // 将对象指针添加进块表记录中，entId返回的是每次添加的对象返回的对象id
    
45.         AcDbObjectId entId;
    
46.         pBlkRcd->appendAcDbEntity(entId, pL_1);
    
47.         pBlkRcd->appendAcDbEntity(entId, pL_2);
    
48.         // 将属性定义添加进块定义中
    
49.         pBlkRcd->appendAcDbEntity(entId, pAttDef);
    
50. 
    
51.         pL_1->close();
    
52.         pL_2->close();
    
53.         pAttDef->close();
    
54.         pBlkRcd->close();
    
55. }
    
56. 
    
57. // 插入带属性的块参照
    
58. void InsertAtt()
    
59. {
    
60.         ACHAR blkName[40];
    
61.         if (acedGetString(Adesk::kFalse, _T("\n请输入带属性的块参照名:"), blkName) != RTNORM)
    
62.         {
    
63.                 return;
    
64.         }
    
65. 
    
66.         // 调用函数获得 块定义的对象id
    
67.         AcDbObjectId blkDefId = Block::GetBlkDefId(blkName);
    
68.         if (blkDefId.isNull())
    
69.         {
    
70.                 acutPrintf(_T("查无此属性块定义"));
    
71.                 return;
    
72.         }
    
73.         ads_point pt;
    
74.         if (acedGetPoint(NULL, _T("\n请选择插入点:"), pt) != RTNORM)
    
75.         {
    
76.                 return;
    
77.         }
    
78. 
    
79.         AcGePoint3d pInsert = asPnt3d(pt);
    
80.         // 插入带属性的块参照：块定义对象id、插入点、比例、旋转角度
    
81.         AcDbObjectId blkRefId = Block::InsertBlkRefWithAtt(blkDefId,
    
82.                                                                                                        pInsert,
    
83.                                                                                                            2,
    
84.                                                                                                            MathUtil::PI()/2);
    
85.        
    
86.         AcDbBlockReference *pBlkRef = NULL;
    
87.         if (acdbOpenObject(pBlkRef, blkRefId, AcDb::kForWrite) == Acad::eOk)
    
88.         {        // 调用函数 修改块参照 的 属性值：块参照、标签名、text的value新值
    
89.                 Block::SetBlockRefAttribute(pBlkRef, _T("直径"), _T("600"));
    
90.                 pBlkRef->close();
    
91.         }
    
92. }
    

复制代码

admin1

1. ObjectArx创建自定义块
   
2. 一.  目的
   
3.        仿照AutoCad的Block命令，实现简版创建块功能!
   
4. 
   
5. 二.   开发环境
   
6. W in7操作系统，AutoCad2012， VS2008, ObjectArx_SDK_2012
   
7. 
   
8. 三.  相关函数简介
   
9. 1 )  int acedSSGet (const ACHAR *str, const void *pt1,const void *pt2, const struct resbuf *filter,ads_name ss);  
   
10. 
    
11. 选择集，个人理解：就是让你一次可以选择多个实体，与之相似的acedEntSel()一次只能选择一个实体
    
12. 
    
13. 2) int acedSSName (const ads_name ss, AdInt32 i, ads_name entres)
    
14. 
    
15. 既然选择了多个实体，我怎么得到其中的每一个实体呢？次函数即可让你得到选择实体中的任一个，参数二相当于索引，参数三就是还回的实体名
    
16. 
    
17. 3）Acad::ErrorStatus acdbGetObjectId(AcDbObjectId& objId,const ads_name objName);
    
18. 
    
19. 通过实体名获取实体ID，与之相同的另外几个函数（指针，句柄，ads_name之间的转换）
    
20. acdbopenAcDbEntity，objectid，getAcDbObject，acdbGetObjectid，acdbGetAdsName等
    
21. 
    
22. 四.代码实现流程
    
23. 1) 首先我们得获取实体，保存这些实体的ID，实现代码：
    
24. 
    
25. void MyBlock::GetPickEntity(AcDbObjectIdArray &idObjectArray)
    
26. {
    
27. ads_name adsName;
    
28. AdInt32 ssLen;
    
29. acedSSGet(NULL, NULL, NULL, NULL, adsName);
    
30. acedSSLength(adsName, &ssLen);
    
31. idObjectArray.removeAll();
    
32. for (INT32 i = 0; i < ssLen; i++)
    
33. {
    
34.   ads_name entityName;
    
35.   acedSSName(adsName, i, entityName);
    
36.   AcDbObjectId entityID;
    
37.   acdbGetObjectId(entityID, entityName);
    
38.   idObjectArray.append(entityID);
    
39. }
    
40. acedSSFree(adsName);
    
41. }
    
42. 
    
43. 2) 从当前块表中查看是否已存在此块名记录，没有则创建新的块表记录，将选择的实体Clone一份，插入到新的
    
44. 块表记录中 ，切记，关闭所有的数据库对象，实现代码（代码有点渣）：
    
45. Acad::ErrorStatus MyBlock::CreateBlock(const CString &strBlockName, const AcDbObjectIdArray &idObjectArray)
    
46. {
    
47. AcDbBlockTable *pBlockTable = NULL;
    
48. Acad::ErrorStatus es = acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlockTable, AcDb::kForRead);
    
49. if (Acad::eOk != es)
    
50. {
    
51.   return es;
    
52. }
    
53. if (Adesk::kTrue == pBlockTable->has(strBlockName))
    
54. {
    
55.   pBlockTable->close();
    
56.   return es;
    
57. }
    
58. AcDbBlockTableRecord *pBlockTableRcd = new AcDbBlockTableRecord();
    
59. es = pBlockTableRcd->setName(strBlockName);
    
60. es = pBlockTableRcd->setOrigin(AcGePoint3d::kOrigin);
    
61. es = pBlockTable->upgradeOpen();
    
62. if (Acad::eOk != es)
    
63. {
    
64.   pBlockTableRcd->close();
    
65.   pBlockTable->close();
    
66.   return es;
    
67. }
    
68. es = pBlockTable->add(pBlockTableRcd);
    
69. if (Acad::eOk != es)
    
70. {
    
71.   pBlockTable->close();
    
72.   pBlockTableRcd->close();
    
73.   return es;
    
74. }
    
75. pBlockTable->close();
    
76. AcGeMatrix3d mat;
    
77. mat.setToIdentity();
    
78. for (INT32 i = 0; i < idObjectArray.length(); i++)
    
79. {
    
80.   AcDbEntity *pEntity = NULL;
    
81.   es = acdbOpenAcDbEntity(pEntity, idObjectArray.at(i), AcDb::kForRead);
    
82.   if (Acad::eOk != es)
    
83.   {
    
84.    acDocManager->unlockDocument(curDoc());
    
85.    pBlockTableRcd->close();
    
86.    return es;
    
87.   }
    
88. 
    
89.   AcDbEntity *pNewEntity = AcDbEntity::cast(pEntity->clone());
    
90.   es = pBlockTableRcd->appendAcDbEntity(pNewEntity);
    
91.   if (Acad::eOk != es)
    
92.   {
    
93.    acDocManager->unlockDocument(curDoc());
    
94.    pBlockTableRcd->close();
    
95.    pEntity->close();
    
96.    pNewEntity->close();
    
97.    return es;
    
98.   }
    
99.   pEntity->close();
    
100.   pNewEntity->close();
     
101. }
     
102. pBlockTableRcd->close();
     
103. return es;
     
104. }
     

复制代码

admin1

1、AcDbSortentsTable
1.1、类简介
AcDbSortentsTable是绘制订单信息的持久容器。它位于关键的ACAD_SORTENTS下的关联AcDbBlockTableRecord的扩展字典中。

AcDbSortentsTable包含一组对象ID /句柄对。对象ID是要绘制的实体的对象ID, 并且句柄是块表记录中的实体的句柄(通常但不总是与关联的对象ID不同), 其表示绘制顺序中的位置。实体按递增句柄值的顺序附加到块表记录中; 换句话说, 句柄值越高, 它就越晚出现在块表记录中。当在块表记录中绘制实体时, 迭代器以附加顺序遍历块表记录。在每个实体处, 获取句柄值并用于查询sortents表。如果匹配, 则绘制与sortents表中的句柄值关联的对象ID。如果sortents表中没有匹配项,  

当修改实体的绘制顺序时, 可以修改sortents表中的许多条目。例如, 块表记录具有五个具有以下句柄的实体(通常表示为表示十六进制数字的字符串)：4A, 4B, 4C, 4D, 4E。这些句柄按升序显示。当应用程序在默认方向上迭代块表记录中的实体时, 句柄值总是从一个实体增加到next实体。

要先在空间中绘制最后一个实体(或“后面”其他实体), 必须在sortents表中创建五个条目, 如下所示：

实体ID

绘制订单处理

4E

4A

4A

4B

4B

4C

4C

4D

4D

4E

条目的顺序(表示为上表中的一行)无关紧要; 绘制订单处理在执行绘制时最终通过绘制顺序句柄对条目进行排序。换句话说, 在DXF文件中, 表条目可能按以下顺序出现, 但结果绘制顺序是相同的：

实体ID

绘制订单处理

4C

4D

4B

4C

4E

4A

4D

4E

4A

4B

作为另一示例, 空间中的最后一个实体在空间中的倒数第二个实体“下”移动, 但其余实体以“自然”顺序绘制。在这种情况下, sortents表只需要两个条目, 如下所示：

实体ID

绘制订单处理

4E

4D

4D

4E

使用隐式绘制顺序“last”将新实体添加到块表记录中不需要sortents表中的新条目。

1.2、成员方法
Acad::ErrorStatus moveToBottom( const AcDbObjectIdArray& ar);

将输入对象ID数组中指定的所有实体放置在绘制顺序的开头。被移动的实体保留其相对绘制顺序。

返回eInvalidInput如果任何输入对象ID不在相关的块, 或eDuplicateKey如果任何对象ID输入数组中出现两次。

2、代码实现
如果你要调整块内的显示顺序，就是获得AcDbBlockTableRecord的扩展辞典里面的ACAD_SORTENTS，执行完参数后记得CLOSE返回的对象。

打开块时要先以块参照AcDbBlockReference对象打开，然后用AcDbBlockReference::blockTableRecord()获取块表记录blockTableRecordId，用这个blockTableRecordId打开才是块表记录，直接用块blkid打开块，将返回eNullObjectId错误。

1. 获取块排序表对象
   
2. AcDbSortentsTable * getSortentsTable(AcDbBlockTableRecord * pRec)
   
3. {
   
4.     if (!pRec)
   
5.         return NULL;
   
6.     Acad::ErrorStatus es;
   
7.     AcDbObjectId ext_id = pRec->extensionDictionary();
   
8.     if (AcDbObjectId::kNull == ext_id)
   
9.     {
   
10.         pRec->upgradeOpen();
    
11.         es = pRec->createExtensionDictionary();
    
12.         if (es != eOk)
    
13.             return NULL;
    
14.         pRec->downgradeOpen();
    
15.         ext_id = pRec->extensionDictionary();
    
16.         if (AcDbObjectId::kNull == ext_id)
    
17.         {
    
18.             return NULL;
    
19.         }
    
20.         pRec->downgradeOpen();
    
21.     }
    
22.     AcDbDictionary *pExt;
    
23.     es = acdbOpenObject(pExt, ext_id, AcDb::kForRead);
    
24.     if (Acad::eOk != es)
    
25.         return NULL;
    
26.     AcDbObject *pObj;
    
27.     if (Acad::eOk != pExt->getAt(_T("ACAD_SORTENTS"), pObj, AcDb::kForWrite))
    
28.     {
    
29.         if (Acad::eOk != pExt->upgradeOpen())
    
30.         {
    
31.             pExt->close();
    
32.             return NULL;
    
33.         }
    
34.         AcDbSortentsTable *pSt = new AcDbSortentsTable;
    
35.         if (NULL == pSt)
    
36.         {
    
37.             pExt->close();
    
38.             return NULL;
    
39.         }
    
40.         AcDbObjectId new_id;
    
41.         if (Acad::eOk != pExt->setAt(_T("ACAD_SORTENTS"), pSt, new_id))
    
42.         {
    
43.             delete pSt;
    
44.             pExt->close();
    
45.             return NULL;
    
46.         }
    
47.         pSt->setBlockId(pRec->objectId());
    
48.         pObj = pSt;
    
49.     }
    
50.     pExt->close();
    
51.     if (!pObj->isKindOf(AcDbSortentsTable::desc()))
    
52.     {
    
53.         pObj->close();
    
54.         return NULL;
    
55.     }
    
56.     return (AcDbSortentsTable*)pObj;
    
57. }
    

复制代码

admin1

1. 遍历块实体，后置实体集合
   
2. void softBlockEntity(const AcDbObjectId& blkid)
   
3. {
   
4.     // 后置实体集合
   
5.     AcDbObjectIdArray behindids;
   
6.     AcDbBlockTableRecordIterator *iter;
   
7.     AcDbBlockReference *pBlkRef;
   
8.     AcDbBlockTableRecord *pRecord;
   
9.     Acad::ErrorStatus es = acdbOpenObject(pBlkRef, blkid, AcDb::kForRead);
   
10.     if (es != Acad::eOk)
    
11.         return;
    
12.     AcDbObjectId blockTableRecordId = pBlkRef->blockTableRecord();
    
13.     pBlkRef->close();
    
14.     es = acdbOpenObject(pRecord, blockTableRecordId, AcDb::kForWrite);
    
15.     if (es != Acad::eOk || pRecord == NULL)
    
16.         return;
    
17.     // 遍历块内实体
    
18.     pRecord->newIterator(iter);
    
19.     for (iter->start(); !iter->done(); iter->step())
    
20.     {
    
21.         AcDbObjectId id;
    
22.         es = iter->getEntityId(id);
    
23.         if (es != Acad::eOk || !id.isValid())
    
24.             continue;
    
25.         // 过滤出需要后置的实体集合           
    
26.         if (筛选条件)
    
27.             behindids.append(id);
    
28.     }
    
29.     AcDbSortentsTable *pSortentsTable = getSortentsTable(pRecord);
    
30.     // 排序表对象在使用完后记得close
    
31.     if (pSortentsTable != NULL)
    
32.     {
    
33.         es = pSortentsTable->moveToBottom(behindids);
    
34.         pSortentsTable->close();
    
35.     }
    
36.     delete iter;
    
37.     pRecord->close();
    
38. }
    

复制代码

admin1

获取指定块表，没有则创建

1. 
   
2. AcDbObjectId GetBlkId(const CString& sBlkName, bool bCreate)
   
3. {
   
4.         AcDbObjectId idBlk = AcDbObjectId::kNull;
   
5. 
   
6.         // 获取指定块表ID 没有则添加
   
7.         AcDbBlockTablePointer pTable(acdbCurDwg(), AcDb::kForRead);
   
8.         if (pTable.openStatus() != Acad::eOk)
   
9.                 return idBlk;
   
10.        
    
11.         if (pTable->has(sBlkName))// 有指定块表直接获取ID
    
12.         {
    
13.                 pTable->getAt(sBlkName, idBlk);
    
14.         }
    
15.         else if(bCreate)// 没有指定块表 且允许创建 则创建指定块表
    
16.         {
    
17.                 AcDbBlockTableRecord* pRecord = new AcDbBlockTableRecord();
    
18.                 pRecord->setName(sBlkName);
    
19.                 if (pTable->add(idBlk, pRecord) == Acad::eOk)
    
20.                         pRecord->close();
    
21.                 else
    
22.                         delete pRecord;
    
23.         }
    
24.         return idBlk;
    
25. }
    
26. 
    
27. 
    
28. 
    
29. void testCreateBlock()
    
30. {
    
31.         // 选择实体创建块参照
    
32.         AcDbObjectId entId = SelectEnt();
    
33.         if (entId.isNull())
    
34.         {
    
35.                 acutPrintf(_T("选择实体失败"));
    
36.                 return;
    
37.         }
    
38. 
    
39.         //获取指定块表Id
    
40.         AcDbObjectId idRec = GetBlkId(_BLOCK_Test_, true);
    
41.         if (idRec.isNull())
    
42.         {
    
43.                 acutPrintf(_T("获取%s块表Id失败"), _BLOCK_Test_);
    
44.                 return;
    
45.         }
    
46. 
    
47.         AcDbEntityPointer pEnt(entId, AcDb::kForRead);
    
48.         if (pEnt.openStatus() != Acad::eOk)
    
49.         {
    
50.                 acutPrintf(_T("打开实体失败"));
    
51.                 return;
    
52.         }
    
53. 
    
54.         //打开新的块表记录 添加实体至新块表中
    
55.         AcDbBlockTableRecordPointer pBlkNew(idRec, AcDb::kForWrite);
    
56.         if (pBlkNew.openStatus() != Acad::eOk)
    
57.                 return;
    
58.         pBlkNew->appendAcDbEntity(pEnt);
    
59. 
    
60.         // 打开当前块表
    
61.         AcDbBlockTablePointer pBlkTable(acdbCurDwg(), AcDb::kForRead);
    
62.         if (pBlkTable.openStatus() != Acad::eOk)
    
63.                 return;
    
64. 
    
65.         AcGePoint3d ptInsert = AcGePoint3d::kOrigin;
    
66.         // 创建块参照
    
67.         AcDbObjectPointer<AcDbBlockReference> pBlkRef;
    
68.         if (pBlkRef.create() != Acad::eOk)
    
69.                 return;
    
70. 
    
71.         pBlkRef->setDatabaseDefaults();
    
72.         pBlkRef->setPosition(ptInsert);
    
73.         pBlkRef->setBlockTableRecord(idRec);
    
74.        
    
75.         // 缩放块 两种方法：
    
76.         // 1、通过缩放比例缩放
    
77.         pBlkRef->setScaleFactors(1);//缩放比例
    
78.         // 2、通过缩放矩阵缩放
    
79.         AcGeMatrix3d scaleMat;
    
80.         scaleMat.setToScaling(3, ptInsert);
    
81.         pBlkRef->transformBy(scaleMat);
    
82.        
    
83.         // 旋转块 两种方法
    
84.         // 1、通过旋转角度旋转
    
85.         pBlkRef->setRotation(0);//旋转角度
    
86.         // 2、通过旋转矩阵旋转
    
87.         AcGeMatrix3d rotateMat;
    
88.         rotateMat.setToRotation(3.1415926 * 0.5, AcGeVector3d::kZAxis, ptInsert);
    
89.         pBlkRef->transformBy(rotateMat);
    
90. 
    
91.         // 打开当前空间的块表记录
    
92.         AcDbBlockTableRecordPointer pBlkRcd(curDoc()->database()->currentSpaceId(), AcDb::kForWrite);
    
93.         if (pBlkRcd.openStatus() != Acad::eOk)
    
94.                 return;
    
95. 
    
96.         // 添加块参照到数据库
    
97.         pBlkRcd->appendAcDbEntity(pBlkRef);
    
98.        
    
99.         return;
    
100. }
     
101. 
     
102. 
     
103. AcDbObjectId SelectEnt()
     
104. {
     
105.         ads_name ent;
     
106.         ads_point pt;
     
107.         AcDbObjectId entId = AcDbObjectId::kNull;
     
108.         int ret = RTNORM;
     
109.         ret = acedEntSel(_T("\nSelect Entity: "), ent, pt);
     
110.         if (RTNORM != ret)
     
111.                 return entId;
     
112. 
     
113.         acdbGetObjectId(entId, ent);
     
114.         return entId;
     
115. }
     
116. 
     
117. 
     
118. 
     

复制代码