Kean专题：拖动一个属性块（JIG拖拽）

原文转载自：http://through-the-interface.typepad.com/through_the_interface/jigs/（该口已无法访问）

可访问转载入口：http://bbs.mjtd.com/thread-75618-1-1.html（转载自明镜通道by雪山飞狐_lzh）

原kean博客已经无法看到，故转载明经通道 雪山飞狐_lzh 老师整理内容

1.kean原文翻译

March 18, 2009
Jigging an AutoCAD block with attributes using .NET

利用.net做AutoCAD的属性块拖动
Thanks, once again, to Philippe Leefsma, a DevTech engineer based in Prague, for contributing the code for this post.再次感谢  Philippe Leefsma 一名位于布拉格的开发技术工程师，贡献了这篇文章中的代码

While researching an issue he was working on Philippe stumbled across a comment on this previous post where I more-or-less said jigging attributes wasn’t possible. 在研究一个他工作中的问题的时候，Philippe

突然发现在之前的文章中发表的一个评论，或多或少的提到拖动属性块是不可能的

Ahem. Anyway, Philippe decided to – quite rightly – prove me wrong, and the result is today’s post. :-)

Philippe决定用正确的方式证明我是不对的，所有就有了个今天这篇帖子
It turns out that the trick to jigging a block with attributes is to add the block reference to the database prior to running the jig.他证实拖动属性块的技巧是在进行拖动之前先将块参照添加到数据库中

I’d been coming at this from another direction – working out how to call through to the right version of the ObjectARX function, the one that allows the block reference to be in-memory rather than db-resident – but Philippe’s approach means that’s no longer needed.对于这个问题我一直朝着另一个方向，通过如何调用正确的ObjectARX 功能来完成一个允许将块属性保存在内存中而不是宿主在图形数据库中，这也就是意味着Philippe采用的方法不再被需要啦

I see this technique as potentially being useful when jigging other entities that benefit from being database resident (Solid3d objects spring to mind), so I really appreciate Philippe’s hard work on this.我知道这个技术在拖拽其他受益于宿主图形数据库中的实体是非常有用的，所有我真的很欣赏Philippe对于这方面做出的努力
Here’s the C# code which I’ve edited for posting:

1. using Autodesk.AutoCAD.Runtime;

2. using Autodesk.AutoCAD.ApplicationServices;

3. using Autodesk.AutoCAD.DatabaseServices;

4. using Autodesk.AutoCAD.EditorInput;

5. using Autodesk.AutoCAD.Geometry;

6. using System.Collections.Generic;

7. 

8. namespace BlockJig

9. {

10. class CBlockJig : EntityJig

11.   {

12. private Point3d _pos;

13. private Dictionary<string, Point3d> _attPos;

14. private Transaction _tr;

15. 

16. public CBlockJig(Transaction tr, BlockReference br)

17.       : base(br)

18.     {

19.       _pos = br.Position;

20. 

21. // Initialize our dictionary with the tag /

22. // AttributeDefinition position

23. 

24.       _attPos = new Dictionary<string, Point3d>();

25. 

26.       _tr = tr;

27. 

28.       BlockTableRecord btr =

29. (BlockTableRecord)_tr.GetObject(

30.           br.BlockTableRecord,

31.           OpenMode.ForRead

32. );

33. 

34. if (btr.HasAttributeDefinitions)

35.       {

36. foreach (ObjectId id in btr)

37.         {

38.           DBObject obj =

39.             tr.GetObject(id, OpenMode.ForRead);

40.           AttributeDefinition ad =

41.             obj as AttributeDefinition;

42. 

43. if (ad != null)

44.           {

45.             _attPos.Add(ad.Tag, ad.Position);

46.           }

47.         }

48.       }

49.     }

50. 

51. protected override bool Update()

52.     {

53.       BlockReference br = Entity as BlockReference;

54. 

55.       br.Position = _pos;

56. 

57. if (br.AttributeCollection.Count != 0)

58.       {

59. foreach (ObjectId id in br.AttributeCollection)

60.         {

61.           DBObject obj =

62.             _tr.GetObject(id, OpenMode.ForRead);

63.           AttributeReference ar =

64.             obj as AttributeReference;

65. 

66. // Apply block transform to att def position

67. 

68. if (ar != null)

69.           {

70.             ar.UpgradeOpen();

71.             ar.Position =

72.               _attPos[ar.Tag].TransformBy(br.BlockTransform);

73.           }

74.         }

75.       }

76. return true;

77.     }

78. 

79. protected override SamplerStatus Sampler(JigPrompts prompts)

80.     {

81.       JigPromptPointOptions opts =

82. new JigPromptPointOptions(" Select insertion point:");

83.       opts.BasePoint = new Point3d(0, 0, 0);

84.       opts.UserInputControls =

85.         UserInputControls.NoZeroResponseAccepted;

86. 

87.       PromptPointResult ppr = prompts.AcquirePoint(opts);

88. 

89. if (_pos == ppr.Value)

90.       {

91. return SamplerStatus.NoChange;

92.       }

93. 

94.       _pos = ppr.Value;

95. 

96. return SamplerStatus.OK;

97.     }

98. 

99. public PromptStatus Run()

100.     {

101. Document doc =

102. Application.DocumentManager.MdiActiveDocument;

103. Editor ed = doc.Editor;

104. 

105.       PromptResult promptResult = ed.Drag(this);

106. return promptResult.Status;

107.     }

108.   }

109. 

110. public class Commands

111.   {

112. [CommandMethod("BJ")]

113. static public void BlockJig()

114.     {

115. Document doc =

116. Application.DocumentManager.MdiActiveDocument;

117. Database db = doc.Database;

118. Editor ed = doc.Editor;

119. 

120.       PromptStringOptions pso =

121. new PromptStringOptions(" Enter block name: ");

122.       PromptResult pr = ed.GetString(pso);

123. 

124. if (pr.Status != PromptStatus.OK)

125. return;

126. 

127.       Transaction tr =

128.         doc.TransactionManager.StartTransaction();

129. using (tr)

130.       {

131.         BlockTable bt =

132. (BlockTable)tr.GetObject(

133.             db.BlockTableId,

134.             OpenMode.ForRead

135. );

136.         BlockTableRecord space =

137. (BlockTableRecord)tr.GetObject(

138.             db.CurrentSpaceId,

139.             OpenMode.ForRead

140. );

141. 

142. if (!bt.Has(pr.StringResult))

143.         {

144.           ed.WriteMessage(

145. " Block "" + pr.StringResult + "" not found.");

146. return;

147.         }

148. 

149.         space.UpgradeOpen();

150. 

151.         BlockTableRecord btr =

152. (BlockTableRecord)tr.GetObject(

153.             bt[pr.StringResult],

154.             OpenMode.ForRead);

155. 

156. // Block needs to be inserted to current space before

157. // being able to append attribute to it

158. 

159.         BlockReference br =

160. new BlockReference(new Point3d(), btr.ObjectId);

161.         space.AppendEntity(br);

162.         tr.AddNewlyCreatedDBObject(br, true);

163. 

164. if (btr.HasAttributeDefinitions)

165.         {

166. foreach (ObjectId id in btr)

167.           {

168.             DBObject obj =

169.               tr.GetObject(id, OpenMode.ForRead);

170.             AttributeDefinition ad =

171.               obj as AttributeDefinition;

172. 

173. if (ad != null && !ad.Constant)

174.             {

175.               AttributeReference ar =

176. new AttributeReference();

177.               ar.SetAttributeFromBlock(ad, br.BlockTransform);

178.               ar.Position =

179.                 ad.Position.TransformBy(br.BlockTransform);

180. 

181.               ar.TextString = ad.TextString;

182. 

183.               br.AttributeCollection.AppendAttribute(ar);

184.               tr.AddNewlyCreatedDBObject(ar, true);

185.             }

186.           }

187.         }

188. 

189. // Run the jig

190. 

191.         CBlockJig myJig = new CBlockJig(tr, br);

192. 

193. if (myJig.Run() != PromptStatus.OK)

194. return;

195. 

196. // Commit changes if user accepted, otherwise discard

197. 

198.         tr.Commit();

199.       }

200.     }

201.   }

202. }

When you run the BJ command (short for BlockJig) and specify the name of a block in the current drawing which contains attributes, you’ll now see the attributes with their default values shown as part of the block being jigged.当你运行一个BJ命令并且制定一个块名在当前包含特性的图形中，你会看到定义的属性值作为作为被拖拽块的一部分被显示

Implementing the code to allow editing of those attributes after insertion is left as an exercise for the reader.

编写一段代码允许编辑已经插入的属性留给读者作为练习完成

练习部分由我完成

Update:
This code didn't work for a few situations, such as when using justification (attributes would end up at the origin after being dragged) or with MText attributes (which would start at the origin until the mouse was moved).

这个代码不能工作在一些情况，例如当你使用对正（再被拖拽后属性将会回到原点处）或多行文本（当鼠标被移动是属性将从原点开始）等情况
A big thanks to Roland Feletic from PAUSER ZT-GMBH for helping identify and diagnose the various cases.
Here's the updated C# code:

1. using Autodesk.AutoCAD.Runtime;

2. using Autodesk.AutoCAD.ApplicationServices;

3. using Autodesk.AutoCAD.DatabaseServices;

4. using Autodesk.AutoCAD.EditorInput;

5. using Autodesk.AutoCAD.Geometry;

6. using System.Collections.Generic;

7. 

8. namespace BlockJigApplication

9. {

10. class AttInfo

11.   {

12. private Point3d _pos;

13. private Point3d _aln;

14. private bool _aligned;

15. 

16. public AttInfo(Point3d pos, Point3d aln, bool aligned)

17.     {

18.       _pos = pos;

19.       _aln = aln;

20.       _aligned = aligned;

21.     }

22. 

23. public Point3d Position

24.     {

25.       set { _pos = value; }

26.       get { return _pos; }

27.     }

28. 

29. public Point3d Alignment

30.     {

31.       set { _aln = value; }

32.       get { return _aln; }

33.     }

34. 

35. public bool IsAligned

36.     {

37.       set { _aligned = value; }

38.       get { return _aligned; }

39.     }

40.   }

41. 

42. class BlockJig : EntityJig

43.   {

44. private Point3d _pos;

45. private Dictionary<ObjectId, AttInfo> _attInfo;

46. private Transaction _tr;

47. 

48. public BlockJig(

49.       Transaction tr,

50.       BlockReference br,

51.       Dictionary<ObjectId, AttInfo> attInfo

52. ) : base(br)

53.     {

54.       _pos = br.Position;

55.       _attInfo = attInfo;

56.       _tr = tr;

57.     }

58. 

59. protected override bool Update()

60.     {

61.       BlockReference br = Entity as BlockReference;

62. 

63.       br.Position = _pos;

64. 

65. if (br.AttributeCollection.Count != 0)

66.       {

67. foreach (ObjectId id in br.AttributeCollection)

68.         {

69.           DBObject obj =

70.             _tr.GetObject(id, OpenMode.ForRead);

71.           AttributeReference ar =

72.             obj as AttributeReference;

73. 

74. // Apply block transform to att def position

75. 

76. if (ar != null)

77.           {

78.             ar.UpgradeOpen();

79.             AttInfo ai = _attInfo[ar.ObjectId];

80.             ar.Position =

81.               ai.Position.TransformBy(br.BlockTransform);

82. if (ai.IsAligned)

83.             {

84.               ar.AlignmentPoint =

85.                 ai.Alignment.TransformBy(br.BlockTransform);

86.             }

87. if (ar.IsMTextAttribute)

88.             {

89.               ar.UpdateMTextAttribute();

90.             }

91.           }

92.         }

93.       }

94. return true;

95.     }

96. 

97. protected override SamplerStatus Sampler(JigPrompts prompts)

98.     {

99.       JigPromptPointOptions opts =

100. new JigPromptPointOptions(" Select insertion point:");

101.       opts.BasePoint = new Point3d(0, 0, 0);

102.       opts.UserInputControls =

103.         UserInputControls.NoZeroResponseAccepted;

104. 

105.       PromptPointResult ppr = prompts.AcquirePoint(opts);

106. 

107. if (_pos == ppr.Value)

108.       {

109. return SamplerStatus.NoChange;

110.       }

111. 

112.       _pos = ppr.Value;

113. 

114. return SamplerStatus.OK;

115.     }

116. 

117. public PromptStatus Run()

118.     {

119. Document doc =

120. Application.DocumentManager.MdiActiveDocument;

121. Editor ed = doc.Editor;

122. 

123.       PromptResult promptResult = ed.Drag(this);

124. return promptResult.Status;

125.     }

126.   }

127. 

128. public class Commands

129.   {

130. [CommandMethod("BJ")]

131. static public void BlockJigCmd()

132.     {

133. Document doc =

134. Application.DocumentManager.MdiActiveDocument;

135. Database db = doc.Database;

136. Editor ed = doc.Editor;

137. 

138.       PromptStringOptions pso =

139. new PromptStringOptions(" Enter block name: ");

140.       PromptResult pr = ed.GetString(pso);

141. 

142. if (pr.Status != PromptStatus.OK)

143. return;

144. 

145.       Transaction tr =

146.         doc.TransactionManager.StartTransaction();

147. using (tr)

148.       {

149.         BlockTable bt =

150. (BlockTable)tr.GetObject(

151.             db.BlockTableId,

152.             OpenMode.ForRead

153. );

154. 

155. if (!bt.Has(pr.StringResult))

156.         {

157.           ed.WriteMessage(

158. " Block "" + pr.StringResult + "" not found.");

159. return;

160.         }

161. 

162.         BlockTableRecord space =

163. (BlockTableRecord)tr.GetObject(

164.             db.CurrentSpaceId,

165.             OpenMode.ForWrite

166. );

167. 

168.         BlockTableRecord btr =

169. (BlockTableRecord)tr.GetObject(

170.             bt[pr.StringResult],

171.             OpenMode.ForRead);

172. 

173. // Block needs to be inserted to current space before

174. // being able to append attribute to it

175. 

176.         BlockReference br =

177. new BlockReference(new Point3d(), btr.ObjectId);

178.         space.AppendEntity(br);

179.         tr.AddNewlyCreatedDBObject(br, true);

180. 

181.         Dictionary<ObjectId, AttInfo> attInfo =

182. new Dictionary<ObjectId,AttInfo>();

183. 

184. if (btr.HasAttributeDefinitions)

185.         {

186. foreach (ObjectId id in btr)

187.           {

188.             DBObject obj =

189.               tr.GetObject(id, OpenMode.ForRead);

190.             AttributeDefinition ad =

191.               obj as AttributeDefinition;

192. 

193. if (ad != null && !ad.Constant)

194.             {

195.               AttributeReference ar =

196. new AttributeReference();

197. 

198.               ar.SetAttributeFromBlock(ad, br.BlockTransform);

199.               ar.Position =

200.                 ad.Position.TransformBy(br.BlockTransform);

201. 

202. if (ad.Justify != AttachmentPoint.BaseLeft)

203.               {

204.                 ar.AlignmentPoint =

205.                   ad.AlignmentPoint.TransformBy(br.BlockTransform);

206.               }

207. if (ar.IsMTextAttribute)

208.               {

209.                 ar.UpdateMTextAttribute();

210.               }

211. 

212.               ar.TextString = ad.TextString;

213. 

214.               ObjectId arId =

215.                 br.AttributeCollection.AppendAttribute(ar);

216.               tr.AddNewlyCreatedDBObject(ar, true);

217. 

218. // Initialize our dictionary with the ObjectId of

219. // the attribute reference + attribute definition info

220. 

221.               attInfo.Add(

222.                 arId,

223. new AttInfo(

224.                   ad.Position,

225.                   ad.AlignmentPoint,

226.                   ad.Justify != AttachmentPoint.BaseLeft

227. )

228. );

229.             }

230.           }

231.         }

232. // Run the jig

233. 

234.         BlockJig myJig = new BlockJig(tr, br, attInfo);

235. 

236. if (myJig.Run() != PromptStatus.OK)

237. return;

238. 

239. // Commit changes if user accepted, otherwise discard

240. 

241.         tr.Commit();

242.       }

243.     }

244.   }

245. }

A few comments on this code:
It's been refactored to make a single pass through the block definition to both create the block reference and collect the attribute information to store in our dictionary.
The attribute information is now held in a class, which allows us to store more than just the position in our dictionary (without using multiple dictionaries), I went to the effort of exposing public properties for the various private members, as this is generally a good technique to use (if a little redundant, here).
The dictionary now stores this attribute information against an ObjectId rather than the tag string. Roland made the excellent point that blocks can contain attributes with duplicate tags, so this is much safe. We also had to use the ObjectId of the AttributeReference, as later on inside the jig's Update() function we no longer have access to the AttributeDefinition.

一些对于这些代码的评价

它被重构用来定义一个块来创建块参照并收集属性信息存储在我们的字典。

属性信息现在被约束在一个类中，它可以让我们存储更多的不仅仅是位置在我们的字典中（在不使用多个词典的情况下），我们努力为更多的私有成员暴漏他们的公有属性，因为这通常是一个良好的技术使用（但是在这有点多余）。

字典存储现在针对的ObjectId，而不是标记字符串该属性信息。罗兰提出，块可以包含重复的标记属性非常好的一点，所以这是非常安全的。我们也可以用AttributeReference的的ObjectId，作为后来拖拽的更新（）函数中我们不再有机会获得AttributeDefinition。