vba中如何嵌套块？

tataki · 发表于 2012-6-8 11:58:14

马上注册，结识高手，享用更多资源，轻松玩转三维网社区。

您需要登录才可以下载或查看，没有帐号？注册

x

本帖最后由 woaishuijia 于 2012-6-8 17:40 编辑

得到斑竹上次解答后，现在可以根据blockB的数量灵活插入需要的块了，（原帖http://www.3dportal.cn/discuz/viewthread.php?tid=1140006&;extra=page%3D3）但现在遇上一个新问题，不好意思又开了一个贴....
问题是这样的，图纸上右侧是原始块，左侧是我想要做成的块。
为简化问题，现在只要插入1个blockA，n个blockB，n的数量通过文本框来确定，blockC和blockD不用插入。
当我完成插入1个blockA，n个blockB后，我要把左侧这n+1个块组成一个新块 blockE，这应该算是嵌套块吧？可是这个创建blockE的代码怎么写呢？
特别的是：n是不确定的，比如某一次是1个A，3个B块，另外一次是1个A，5个B块，怎么来处理这种情况呢？
我感觉不能通过块的名字嵌套吧，因为右侧的原始块有一样的名字，而且原始块是不能删除的。
谢谢，附上图纸和代码

Private Sub cmdInsert_Click()
8 H) B- C9 x0 M9 L+ M0 D
Dim ptInsert(2) As Double
+ q5 V% c# X* F( N! ^- m
Dim lastBlock As Variant
$ o5 _8 W. i1 j, ], X1 v# ^. ^
ptInsert(0) = 0
3 d: `% }0 C" D
ptInsert(1) = 0; Z; b& _/ c* i! ~
ptInsert(2) = 0
. K( D" _; S/ r4 K
+ x* u5 U$ n B: Z; x
'----------插入块A 仅仅一个---------------------------------& `0 g3 i+ X4 R) q4 n5 h7 a$ Q
Dim B As AcadBlockReference '声明一个块参照变量
7 f t4 t% U: Y3 X! ^
Dim P As Variant '声明一个变体变量用于接收三维点坐标! G4 p R5 H) ]# z! ` l
Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)' y& p4 W7 @+ b0 z- y
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组- i( T) i& T6 J4 Q* b
'----------插入块A 完成---------------------------------
& E& r0 B7 A, `# {. O O
& y* E' b" |8 c @
'----------插入块B---------------------------------! q+ l- ~% g7 u, ?# }
Dim pNew(2) As Double ` `* F: C. V: Z6 A1 A# C
pNew(0) = P(0) - 500* A+ l8 A; g& g0 F9 }, h) `! Q1 j: R# i
pNew(1) = P(1) + 1405.08; D. v: g. L1 n: _9 `( F
pNew(2) = P(2)
" D9 X0 B# a% `( V& ?+ c7 b8 W
Set B = ThisDrawing.ModelSpace.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
, M7 D% v& N2 d, F
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
9 v! }3 C7 ]( W$ [
$ U# p9 {3 M6 K' v8 B/ Q
2 v' e' A8 ?: J/ ~* b% W
For i = 2 To Val(blkBNum.Text) Step 1
) `0 d1 Y; ?5 S: N
Dim pBNew(2) As Double8 _4 g3 k: g0 G9 w" {4 @
pBNew(0) = P(0)
' A1 |& a7 |: L: m
pBNew(1) = P(1) + 2000
. U- X/ Q3 t! L ?9 e& |
pBNew(2) = P(2)3 r5 c8 M5 E! X* u7 \: i
Set B = ThisDrawing.ModelSpace.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)4 w* v. y ?5 l
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
3 c1 Y% O7 f0 \& b) k
Next
J6 k/ q8 [" R! `0 S) h! q
'----------插入块B完成---------------------------------
6 H$ ?, O9 c- D! e, M
'最后的效果是左侧的块A和B组成了一个最终的块BlockE
3 u) N2 v& X; v0 a* M$ t
. u! Y7 C$ ~7 v* d
% R7 K8 Y, G$ \/ ?% M
ThisDrawing.Regen acActiveViewport, {" r& D5 v4 X0 r- R% B7 Z
$ L6 j5 I, X, u+ L
End Sub
& H' G3 O3 l6 x+ D+ z. h# X

复制代码

woaishuijia · 发表于 2012-6-8 17:41:32

1# tataki

Private Sub cmdInsert_Click()
/ _ {. S5 c* ~ n
Dim ptInsert(2) As Double6 }0 c9 f3 F& D
Dim lastBlock As Variant
' \! V* Z( ]1 v \5 {5 ?2 N
ptInsert(0) = 0
2 f9 g3 S V6 \) n
ptInsert(1) = 0
% w' n/ Y" ?; n' Z9 d
ptInsert(2) = 0
- H' I- d& w+ n) V* D
Dim BR As AcadBlock
* ]- V/ O* K$ ]1 z, b" v+ Z
Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
# K! t; L- i% @9 ^- X# J' h
& L- j* Y! ?' H" |$ }' x8 x
'----------插入块A 仅仅一个---------------------------------! ^! l/ Q- J5 s4 @1 w% I7 j" {# N2 `5 h
Dim B As AcadBlockReference '声明一个块参照变量+ o8 N8 Q" ^2 B+ v" b1 p5 Q
Dim P As Variant '声明一个变体变量用于接收三维点坐标9 D! H7 y9 }, n
'Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
1 o- j* c7 v7 o6 T3 G' C
Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
. r" ?9 G( s1 G
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组0 }& A% k" O* @ J7 r& j
'----------插入块A 完成---------------------------------% y7 t- z6 \ @2 G: h; n/ N' b9 A# c
& X. b- o* Z7 v/ v4 o
'----------插入块B---------------------------------
' U7 [: i$ N1 B# [, z, }/ L
Dim pNew(2) As Double0 a+ s. S+ b+ d1 J; }4 s c
pNew(0) = P(0) - 500
' y9 l8 E' e- Q0 |
pNew(1) = P(1) + 1405.088 P6 S3 x1 X# f: [ p
pNew(2) = P(2)8 I" U+ v+ J, `
'Set B = ThisDrawing.ModelSpace.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)( I% f2 E' H# D% J/ O( H
Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
2 B( s; n1 ]* ]' w
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
8 Y. i8 V/ {1 g) x" {( \
& K2 T9 G9 m8 j) f2 W6 ~
1 {6 ]+ I. k8 ]1 D( Q
For i = 2 To Val(blkBNum.Text) Step 1
( w+ y$ ^5 f9 n7 k* O) b, W
Dim pBNew(2) As Double$ C+ z5 q) B% j* [5 G4 i! {
pBNew(0) = P(0)
' E; C5 }9 k, ^
pBNew(1) = P(1) + 2000
* P9 Z l1 w& n, N2 X. h( m
pBNew(2) = P(2)
2 V( g* }4 p! m# _9 E
'Set B = ThisDrawing.ModelSpace.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
4 Y- j' ~2 |! d! j1 Y
Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
3 N+ @& P- `4 R. M# _, ~; n+ a
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组! B( o2 r8 ~" E1 a7 d
Next2 h" O9 e; J0 b+ L& \& ?5 [
'----------插入块B完成---------------------------------' o: ]1 b+ P8 h
'最后的效果是左侧的块A和B组成了一个最终的块BlockE
, D0 H; m" d3 A5 _. w
# x" I4 k" H V) e, C8 o1 O
Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0) u+ Y$ f* A2 ]$ D: r
5 Y" }: o6 j( T! T8 P
ThisDrawing.Regen acActiveViewport& P* }8 J# e! k. s
2 N U. a7 N) T) ?* U( U2 R
End Sub
6 s* C* \+ P3 R' Q: ]. A

复制代码

tataki · 发表于 2012-6-10 11:33:54

本帖最后由 woaishuijia 于 2012-6-10 12:14 编辑

谢谢斑竹

原来是要先创建blockE块，最后在模型空间中插入即可。我还局限在创建一个块然后和上一个块合并，依次进行呢。
另外我有一个疑惑，为什么块中嵌套块不能像块中添加实体，比如一个圆或者直线一样进行呢？
在书上见过这样的例子，给已经定义的块添加直线：

Dim BL As AcadBlock
$ G3 o: i; {4 `8 |
8 e4 S+ Q: \9 u3 s; y
Dim ptInsert(2) As Double; o% |+ f! W% h3 f" P8 v3 Z
ptInsert(0) = 0, E! p7 \8 z; R' o) B4 X
ptInsert(1) = 0' N7 J) h: |9 Y7 g# o" N2 C
ptInsert(2) = 0! ]# _# C. z. o8 a6 o% v( }
, O" X( _$ |: }) r W& Q
Dim pt1(2) As Double '直线起点pt1
- w2 L" J, X9 R& O+ K
pt1(0)=100:pt1(1)=100:pt1(2)=1009 c9 h: L( l' b2 J
, F9 n0 E# K" {* n* }
Dim pt2(2) As Double '直线终点pt2
, _* p' Q' J5 M/ e7 e# M
pt2(0)=500:pt2(1)=500:pt2(2)=500 K' P" H( W* v. P
& L* r8 R! N; W. j) x. [
Set BL = ThisDrawing.Blocks.Add(ptInsertBase, "blockE" ) '先定义3 w R: D. K1 X' d2 ^% c
ThisDrawing.Blocks.Item("blockE" ).AddLine Pt1,Pt2

复制代码

'直接在块中添加直线了，这个里面 " ) . 这段代码怎么出现表情了啊？？？
后面的就不写了。。。。

我就是有点纳闷块里有直接添加实体的方法，addline ,addcircle等等，就是没有添加块的方法，另外，我看到一个AddMInsertBlock方法，最开始还以为是添加块，结果发现不是，于是就不知道该怎么整了。恰好我看的那些VBA书中也没有提及怎么嵌套块...看了斑竹的思路才知道我的想法大方向都错了。哎，经验不足，见到的例子太少了

woaishuijia · 发表于 2012-6-10 12:09:18

强调一下:块是一个定义,文档中任何一个可见的"块"都是块参照,即该块定义的实例,所谓"嵌套块"是指一个块定义中包含有其它块的参照.
无论在模型空间(ModelSpace对象),图纸空间(PaperSpace对象)还是块定义(Block对象)中添加块参照都是使用"InsertBlock"方法.
PS:帖子代码中出现表情是因为代码中挨在一起的的双引号和右括号与论坛的表情代码吻合,被理解为表情了

.以后发帖时在双引号和右括号之间添加一个半角空格就OK了.呵呵

tataki · 发表于 2012-6-10 14:00:36

4# woaishuijia
"嵌套块"是指一个块定义中包含有其它块的参照% {9 Y, t& J5 B- Z; @
原来是这样的啊，需要在“块定义”中添加“块参照”，就像在模型空间里添加块参照一样。就是说这样的嵌套块只是个定义好了块，下一步就是在模型空间里把这个块的块参照给insertBlock出来。
弄明白了问题的本质，呵呵，谢谢斑竹。

woaishuijia · 发表于 2012-6-10 21:02:53

就像在模型空间里添加块参照一样。就是说这样的嵌套块只是个定义好了块，下一步就是在模型空间里把这个块的块参照给insertBlock出来。

心有灵犀,甚好甚慰.

tataki · 发表于 2012-6-11 19:29:36

6# woaishuijia
呵呵，还有很多要向斑竹学习！
今天我有遇见了一个问题：我把blockC里面增加了两个圆，然后把BlockE插入后整体旋转，现在我想找出blockE中的 blockC里两个圆的圆心坐标，结果失败了...
我是这么想的，用两重循环，第一层遍历blockE，找到名字是 blockC的块后就进入第二层循环，然后遍历blockC中的各个图元：圆，直线，文字等等，找到圆就提取圆心坐标。可是就在第二层遍历的时候就出错了，不知道为什么...斑竹帮忙看看怎么解决，新的图纸和代码上传了。

woaishuijia · 发表于 2012-6-11 21:12:54

本帖最后由 woaishuijia 于 2012-6-12 07:04 编辑

你的目的是

找到名字是 blockC的块后就进入第二层循环，然后遍历blockC中的各个图元

但你代码中

Dim temA As AcadBlockReference

复制代码

temA是blockC的块参照,不是blockC

Private Sub cmdInsert_Click()
! V1 `# b: k0 t/ |; N- A
& i i& T! [" c+ t' T+ Q' R
Dim ptInsert(2) As Double '原点
" F; j: N1 l0 k0 f [
ptInsert(0) = 0
' y$ C/ b1 m, ?: `% t& ]) F( K
ptInsert(1) = 0% x" H+ u0 x5 W. D3 F F9 X6 p W9 Q7 f' D( K
ptInsert(2) = 0
7 G) i, Z$ D7 B b9 X% H' Z7 {; ^
- O: N% h- p) J( w
Dim BR As AcadBlock '定义块8 y9 A% O' N6 \9 W, x& i
Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
* L- c, [6 C5 W: A' d8 B1 q/ e
4 j9 A3 u; Y0 z/ P, P# ^! V
'清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
0 ^9 H( X. r2 `! _) z+ Y
Dim E As AcadEntity
4 K: Y+ {* n' ]0 c& v, c; M
For Each E In BR
4 `+ G, w7 A9 k& F% l3 W$ ]
E.Delete+ w/ C7 {4 A# W9 g
Next. I/ O R% |% |0 P4 w
3 n3 V' ~2 Y- ^! l
'----------插入块A 仅一个---------------------------------" q: _: F" z2 N2 r' I+ _; |: m* h
Dim B As AcadBlockReference '声明一个块参照变量2 v8 C+ l( ^1 o$ S) n# H
Dim P As Variant '声明一个变体变量用于接收三维点坐标+ e/ B L5 g2 z, Y! K
Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
, E. G+ K" }- y: A0 D; Q5 o3 C
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组+ y: L3 y1 \& C0 A! s
/ B5 z0 e/ e, f2 j
/ g: o Z7 z/ `' ^! g* n7 ^$ L
'----------插入块B---------------------------------
4 }! d$ r1 r, ^" L! p9 c
8 E3 d5 V' U. ], n& B& H/ Y7 V
Dim pNew(2) As Double
3 n' U- U, K3 X6 H! A% [' L
pNew(0) = P(0) - 500
, m6 }5 ~' C, B% i) }
pNew(1) = P(1) + 1405.08* m4 E: p6 o) V3 Y' K
pNew(2) = P(2)% k b/ c( m8 R7 W) h, D' T
Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
7 a1 |' C# K9 x& |
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
3 ?( ]! F( H0 |& |- G0 F
% l* U3 e# P$ x* k ~9 T- n7 `
0 s# m- O1 K2 Z6 h% ]
Dim I As Integer9 F. }% w8 f6 \" j% B" r, o7 {# u
For I = 2 To Val(blkBNum.Text) Step 1/ y6 ^) R9 i* n6 r
Dim pBNew(2) As Double3 z. H9 C2 N/ m) ]; C
pBNew(0) = P(0). b2 ~8 S& n }; V
pBNew(1) = P(1) + 2000
a# j- {1 V, A+ N
pBNew(2) = P(2)
! k8 ^/ ~; a0 B5 t* e l6 F
0 b. |$ ~& v y1 f/ a! k4 ~* I
Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)5 v7 z. l' D, F4 a3 e# u2 W
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
! {) Q. J1 [$ L7 p
Next
+ \: U7 ]. Y. q f
3 Z; l r) o6 ~9 l
; ]' M. d5 H+ c" `
'----------插入块C 仅一个---------------------------------
# }, \: a! l$ A! H# V
Dim pCNew(2) As Double" G# m1 ?* f7 J2 x9 ?
pCNew(0) = P(0)! w( @/ o: M5 L) t
pCNew(1) = P(1) + 2000
+ S& u4 p) J$ b, p3 |, U
pCNew(2) = P(2) L, U$ _; N3 Q. e+ a
Set B = BR.InsertBlock(pCNew, blkCName.Text, 1, 1, 1, 0); G. `- _# g3 `* @
Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)
9 Y' H, H' \. U
( }7 N% W* c1 m- Y
; K; |1 Y: ~) ~; f+ V
'----------旋转块E---------------------------------0 J* U4 a" Z8 u+ h) ~3 S" j
B.Rotate ptInsert, 0.2
, F) @& I. P; ]" J
6 Z9 o$ ~! [- n1 x; r7 e9 s( l! x1 e
'----------查找块E中的块C的两个圆的圆心坐标---------------------------------* p8 i, R9 {+ g8 M' i+ l. O
9 z5 y3 U0 e5 b+ z+ Q# j% N
Dim temA As AcadBlockReference
9 y4 i, D; j7 ~2 a/ i( U) _
Dim temB As AcadEntity6 H! o/ E& W6 w8 J0 ]5 O2 l
Dim ptCir1(2) As Double '第一个圆圆心坐标) K. n% Q; \. }# }$ m' }
Dim ptCir2(2) As Double '第二个圆圆心坐标
2 ` x; L8 `- v0 z& Y+ ^/ l. U
Dim C As Variant, J As Integer
0 v( w7 @1 F5 Q! H! j* E4 `
' j7 Q3 S# [% U) U
For Each temA In BR '这个遍历就行
1 U K! @) k/ Q# Y9 z7 Q* c. z
If temA.Name = blkCName.Text Then" H0 r, z" R/ o! n8 ~# {
P = temA.InsertionPoint '提取块C参照在块E中的插入点坐标! F/ J6 _" j" S5 m4 O ? u: P) {
J = 1
$ U9 e7 S( U d5 L, J
' For Each temB In temA '在这里就开始出错了，因为这个temA是BlockReference,是块C的参照
4 G# Q9 g9 a5 k" @2 u
For Each temB In ThisDrawing.Blocks(temA.Name) '这个才是真正的块C,呵呵
/ E2 { H x+ s, R8 {
'开始找圆，找到圆就提取坐标
) m+ R- q: |0 J' V" i$ k
If temB.ObjectName = "AcDbCircle" Then& C* d% w$ ~" e6 A4 a! Y
C = temB.Center '提取圆心坐标
/ h0 E0 \- v9 @+ `; D, g4 N
C(0) = ptInsert(0) + P(0) + C(0) '计算该圆心在模型空间的坐标--块E参照未旋转时1 ~* Z6 b$ J( c: G
C(1) = ptInsert(1) + P(1) + C(1)5 ]+ u& z% p9 z8 p7 \6 M% ^0 m
C(2) = ptInsert(2) + P(2) + C(2) V. d$ g6 |4 p& F
If J = 1 Then5 P9 X' s7 X* P/ y! _
ptCir1(0) = C(0) * Cos(0.2) - C(1) * Sin(0.2). N9 ~: e" {8 x7 p
ptCir1(1) = C(0) * Sin(0.2) + C(1) * Cos(0.2)5 z7 l+ t/ H' L4 a8 W! F
ptCir1(2) = C(2)# N) P: k7 V- W) d6 Z! O+ m
J = 22 V4 g, f" f6 d& w
Else
) U, q! J. y; I* l, `0 F
ptCir2(0) = C(0) * Cos(0.2) - C(1) * Sin(0.2)
4 K$ ]! C7 [7 `9 s
ptCir2(1) = C(0) * Sin(0.2) + C(1) * Cos(0.2)0 O, Z9 }/ T% p3 w
ptCir2(2) = C(2)+ E+ L7 O. K. Y3 z4 K! ?
End If& k" a9 k K5 A7 j5 J3 c3 U- F, S
End If: N' \. N# \/ o! h {) E, |) }
Next7 v6 g9 y1 j- x! k: ?; |# U
End If
2 G7 r0 n) \( x8 D0 {0 Y
Next
5 Z) z" v9 a( x3 N
% e. c4 j- D4 X4 f
! k0 k( r$ I$ }
ThisDrawing.Regen acActiveViewport4 K% s1 _: X' W; }6 L
; h( v. L7 u5 G" \# D6 [5 n
End Sub

复制代码

计算圆心在块E参照旋转后在模型空间的坐标,除了上面用三角函数计算的方法外,还可以借助UCS变换或使用辅助线(点)的方法,下面是UCS变换

Private Sub cmdInsert_Click()
( v. u5 t$ B$ l3 ]2 i
Dim ptInsert(2) As Double '原点, Z6 d$ B1 R9 Z% d2 b# S
ptInsert(0) = 03 |& p/ l/ A" Q" W* d7 H; @ u: h( y
ptInsert(1) = 0& x. r" J3 p' E' [. Z* c6 o
ptInsert(2) = 0
! E+ m- V! O" U% n- L9 U
Dim BR As AcadBlock '定义块
' T+ p4 s' z" ~+ v4 `
Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
2 V; @5 w" m" E. E% p# p
'清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
4 h% F& z% \0 s I
Dim E As AcadEntity2 Y9 ^- H2 z, L a
For Each E In BR- S2 \3 n* u- A) z9 {' V8 q, q
E.Delete- H, Q4 c* \0 s! C. `& A. ^& c
Next) Z0 h' f% [6 `3 m% ^: E$ A
& }8 {/ f( N6 f% k
'----------插入块A 仅一个---------------------------------1 Q/ K; N! P5 D' e3 S
Dim B As AcadBlockReference '声明一个块参照变量
# h2 s3 \& s; y# {$ w" P
Dim P As Variant '声明一个变体变量用于接收三维点坐标 G* b3 \; p6 ~3 [% H6 n) W0 t2 X& R
Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
/ d& X' o8 b# S; d+ i% \
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组 H7 m& w: s1 ] w9 B
' k6 I$ c9 \( f
'----------插入块B---------------------------------1 w$ z$ ?- w# e- Z% ] b
Dim pNew(2) As Double$ s2 t* B' G) N
pNew(0) = P(0) - 5003 {% _+ l% N7 j B$ ]: ]
pNew(1) = P(1) + 1405.08
6 y4 H) F1 \" e
pNew(2) = P(2)- N0 _' v- h' m
Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
9 G: n; K$ Y; w( L
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组$ J. l8 W8 j" q2 X! k
Dim I As Integer3 Z. B$ ^8 \: ^" e' f
For I = 2 To Val(blkBNum.Text) Step 1: t" h* j8 O$ d9 N0 }
Dim pBNew(2) As Double6 R1 J2 L$ Y, h
pBNew(0) = P(0)
6 m7 h$ |9 b+ l6 p. Y8 l( W! ]
pBNew(1) = P(1) + 2000
" m$ y, U) a& G8 o% [, w5 l0 A
pBNew(2) = P(2)
" E4 N0 x) n% E; L# |2 _4 n
: k6 Y4 Z0 n+ A+ |' {
Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
& ?' o1 J7 n4 \' R! R7 x
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
! F, u# i2 W1 i; R; J
Next
, t- x. {3 r# Y- q9 J1 X g
3 w7 f5 v- ? s, @& [" u! n/ ]
'----------插入块C 仅一个---------------------------------9 c" t) ^% w5 { k7 b l0 k+ F
Dim pCNew(2) As Double4 @: _+ J" ?* R' u
pCNew(0) = P(0)/ e ]; J& b$ t0 k+ P9 j
pCNew(1) = P(1) + 2000
. L. w7 u' f6 [$ \+ w
pCNew(2) = P(2)
6 y4 Q; y( l2 t# g3 j* Z, a% e
Set B = BR.InsertBlock(pCNew, blkCName.Text, 1, 1, 1, 0)
, V5 X1 U( m& G: d
Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)
- O; B! Q& D" j/ P3 j
' ^; G! E, C; Q" ? x I
'----------旋转块E---------------------------------3 m2 [9 h* t# S; D4 }1 `: |
B.Rotate ptInsert, 0.2
/ w5 o- K9 V* Z. O! C
'创建两个UCS,用于下一步转换圆心在模型空间的坐标
( g+ m# p% V( u
'其中,MyUcs是绕原点右旋0.2弧度,对应块E左旋的0.2弧度
& w; V: d/ s' h' W( M. a
Dim MyUcs As AcadUCS, MyWcs As AcadUCS
0 g g4 H2 Q. b* K3 w) W' ^) F2 ^
Dim XP As Variant, YP As Variant& e4 Z1 p. o% Z# G1 Q9 \
With ThisDrawing; N5 v P! Z: t4 H0 y& |! u' H- z
With .Utility+ e; Z) t! r; }5 h- l8 s
XP = .PolarPoint(ptInsert, -0.2, 1)
0 @. O: H$ ]* s9 S+ |8 W
YP = .PolarPoint(ptInsert, -0.2 + .AngleToReal(90, acDegrees), 1)# L8 e/ l8 X) ^& X# Q
End With
5 _0 F% w- f* F/ |1 E' P. d( ~, r$ ~
Set MyUcs = .UserCoordinateSystems.Add(ptInsert, XP, YP, "MyUcs")9 G) U+ u0 q' I: C5 W! {* N
XP(0) = 1: XP(1) = 0
0 B& O2 L$ K% w; B( W! ]/ O; y
YP(0) = 0: YP(1) = 1
% ]% O, H7 H2 H
Set MyWcs = .UserCoordinateSystems.Add(ptInsert, XP, YP, "MyWcs"); ]% B5 r7 O* M* F7 \
End With* z h6 A% V! M) C- m. K. _# Y: H( l
7 N G, [; E* g7 j# c) w# i$ E/ D
'----------查找块E中的块C的两个圆的圆心坐标---------------------------------
7 `/ U0 {7 y T$ S% F6 _
Dim temA As AcadBlockReference
% I ]% M, C s, E
Dim temB As AcadEntity
' Q2 _/ i8 \# c) f8 i4 b$ {( N
Dim ptCir1(2) As Double '第一个圆圆心坐标( P- J2 ?* w; X- z5 O. P$ ]/ |3 N
Dim ptCir2(2) As Double '第二个圆圆心坐标
6 i. |* s( Z6 E
Dim C As Variant, J As Integer
, f V& h/ p$ @" U0 Z) A
For Each temA In BR '这个遍历就行- B' g6 ^! w5 v4 S7 u& ?
If temA.Name = blkCName.Text Then
4 {' a, T' x. J! U N
P = temA.InsertionPoint '提取块C参照在块E中的插入点坐标
/ l1 x! j- ^8 q* i" d& Z6 b2 T6 x
J = 1
' x8 o1 r4 e; J. n6 c2 k- }& V/ U
' For Each temB In temA '在这里就开始出错了，因为这个temA是BlockReference,是块C的参照
' T/ k$ h" b+ B8 o2 v6 T
For Each temB In ThisDrawing.Blocks(temA.Name) '这个才是真正的块C,呵呵
% j) \( t4 P+ S' u
'开始找圆，找到圆就提取坐标' g5 j, D( c# v6 N. v9 n
If temB.ObjectName = "AcDbCircle" Then2 h; N. Z7 p2 |
C = temB.Center '提取圆心坐标
1 ~' W6 v! _" Y9 T6 {: _
C(0) = ptInsert(0) + P(0) + C(0) '计算该圆心在模型空间的坐标--块E参照未旋转时
& L8 C. p D H' k* X
C(1) = ptInsert(1) + P(1) + C(1)# |4 }; S! O6 h! l8 A5 [2 W
C(2) = ptInsert(2) + P(2) + C(2)/ m& n, w* C: `! T; o
ThisDrawing.ActiveUCS = MyUcs '把当前坐标系改为MyUcs
) G, A' l5 @$ e
C = ThisDrawing.Utility.TranslateCoordinates(C, acWorld, acUCS, False) '得到该圆心在UCS中的坐标--块E参照旋转0.2弧度后该圆心在模型空间的真正位置
$ R& x' a/ r, b( n# o
ThisDrawing.ActiveUCS = MyWcs '把当前坐标系改回WCS3 M9 _, A7 N- f F/ j
If J = 1 Then8 h% `0 u4 R0 V; {+ Y2 T
ptCir1(0) = C(0)
+ t0 c* X6 ^0 F7 v1 l
ptCir1(1) = C(1)+ {/ X6 p# F( ]! e0 L& R
ptCir1(2) = C(2)* K- i# O2 M* \" e
J = 2
9 O& P. i" Q, G0 x
Else
7 O8 P1 ^' {+ V/ q d. g4 T5 |2 P
ptCir2(0) = C(0)$ M& _" {# } \$ s
ptCir2(1) = C(1)
; z1 D6 M$ N' o: }" D* A( o* u
ptCir2(2) = C(2)4 [0 g a7 @0 B
End If
+ O% h( f% J* l# m& w! g( P1 n
End If+ d6 a# ~. n; m! p' R( |3 C2 m+ J
Next+ i9 t0 z# s. i2 h
End If
+ y, _- _; E- D- _
Next- S" `; H. v `; i3 Q
) V0 T" \/ W5 x; U0 [& z0 V
6 T5 e d; v5 a1 r% N' x- B
ThisDrawing.Regen acActiveViewport
8 a* `. ~* i2 R- }! f2 X7 h
End Sub

复制代码

下面是使用辅助点

Private Sub cmdInsert_Click()
" T: i- R* T9 J2 Q& S$ y0 y
Dim ptInsert(2) As Double '原点4 w- U5 o5 e* q7 M2 Z2 x8 }& d
ptInsert(0) = 0
+ j/ ^9 |* ]; | `2 {) a2 O+ M0 Q
ptInsert(1) = 0. c* @ c' n+ t- G; g2 a
ptInsert(2) = 0, w$ w. G/ d6 y7 N) @# A
Dim BR As AcadBlock '定义块
; k" }! q% X6 ^+ } W, ^
Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")! r7 L$ [4 S! X; R
'清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
) a# ~% Y% R/ N
Dim E As AcadEntity
9 J( a% q6 O3 b! R( w# }5 P$ v
For Each E In BR" q1 ~5 `( v: i* A/ G1 ` s
E.Delete
& a# j3 _4 k$ [6 ^
Next
) X% X( D# k. x$ @8 E5 x
'----------插入块A 仅一个---------------------------------& I' ?. X$ w5 g* q/ w: g
Dim B As AcadBlockReference '声明一个块参照变量, m% U" x/ z" h b& ^6 O j
Dim P As Variant '声明一个变体变量用于接收三维点坐标7 n4 K6 y+ \) Y( d
Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
5 c* y9 O2 b6 l$ a1 g2 f
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
9 u5 T3 H* B6 v1 v* k! @
4 r' G$ F( h5 s ]! k* Z0 `
'----------插入块B---------------------------------9 V5 I8 u3 f1 g6 C5 `% r/ M% t
Dim pNew(2) As Double$ D! `1 k+ N# l3 E/ F
pNew(0) = P(0) - 500) d+ T: s) U: K8 A" ?$ t+ u
pNew(1) = P(1) + 1405.08
" v s. `$ H2 {" T: u
pNew(2) = P(2)
4 J% ?# c; `) K
Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
0 Z/ n! F5 n# r- u
$ Y& o0 I( o3 N- p
Dim I As Integer8 n- Y2 _9 F) D, v( L* ~
For I = 2 To Val(blkBNum.Text) Step 1
/ \) X' q6 g2 g
Dim pBNew(2) As Double
$ ]2 y) Z# l4 e3 G
pBNew(0) = P(0)
4 c& t# H: m6 R+ A. w( D
pBNew(1) = P(1) + 2000
$ a* X. T6 y0 T- O
pBNew(2) = P(2)
2 h, r, D B/ ^; [% L, Q: |6 {% x7 J
8 H) Q3 j" V: J; |0 T
Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
# q0 a" v8 y8 }" q: F
P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组/ Z: [8 u: S5 d& F* ~6 k( @
Next9 \; w8 a$ m# ]2 c
5 o7 ]! g# B1 ^9 A7 f) c
'----------插入块C 仅一个---------------------------------
' c9 c! H e$ T! }6 ^' A# Z
Dim pCNew(2) As Double8 x& ~ K& }1 q1 \
pCNew(0) = P(0)
" U. |! M& ]( b2 v0 ^$ \' {
pCNew(1) = P(1) + 20007 ~3 _0 q9 ?# w" y* i: ?' o& P
pCNew(2) = P(2)
8 K5 _1 W0 X+ }4 B% i4 [
Set B = BR.InsertBlock(pCNew, blkCName.Text, 1, 1, 1, 0)
( S: j% w: _9 J7 w& w! [
Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)' U( g! Q( U4 t5 D) |5 ^' R
) @; j4 B/ { o: T! H
'----------旋转块E---------------------------------
1 @# W9 ?3 {/ p) C# J
B.Rotate ptInsert, 0.2
2 J+ W9 \/ d- t/ s0 B5 B( q
'----------查找块E中的块C的两个圆的圆心坐标---------------------------------- V% D: L% M* _0 ?( f) [
Dim temA As AcadBlockReference5 d; e4 X8 |4 n
Dim temB As AcadEntity
: C4 Z! R0 ~% M1 W* a) O
Dim ptCir1(2) As Double '第一个圆圆心坐标
8 q" }1 v) {! H& v
Dim ptCir2(2) As Double '第二个圆圆心坐标! Z$ v/ d# R( S5 h! b
Dim C As Variant, J As Integer
& U- [. t# I* g* k( d. f
Dim ObjP As AcadPoint '点对象,用于下一步计算圆心坐标
% S" E. J1 Q# @3 f: K: x! Q
For Each temA In BR '这个遍历就行4 q$ o' [) v' V* y
If temA.Name = blkCName.Text Then/ [8 m* N4 L) ~$ Z
P = temA.InsertionPoint '提取块C参照在块E中的插入点坐标
8 W K: @+ t+ S5 h
J = 13 R4 }8 U8 D3 Q
' For Each temB In temA '在这里就开始出错了，因为这个temA是BlockReference,是块C的参照8 x4 f: K- c7 q# Y5 V, W1 g& R: R
For Each temB In ThisDrawing.Blocks(temA.Name) '这个才是真正的块C,呵呵
5 N. T- D9 [; Z7 q+ ]3 g3 l
'开始找圆，找到圆就提取坐标
7 {! Q8 Z; t! S& f! m6 o0 h/ m: O
If temB.ObjectName = "AcDbCircle" Then* W2 H! Y+ j- t4 c2 N' Q
C = temB.Center '提取圆心坐标
. L4 w! _/ B% ]6 p; J4 ?, N: C7 I9 H
C(0) = ptInsert(0) + P(0) + C(0) '计算该圆心在模型空间的坐标--块E参照未旋转时
5 Z/ `/ o: c" B K2 r& i
C(1) = ptInsert(1) + P(1) + C(1)+ Y! H5 A: A& p+ n0 y$ I: g6 |0 [8 e l
C(2) = ptInsert(2) + P(2) + C(2)9 I. x" U$ \! \0 w5 f& P$ ]
Set ObjP = ThisDrawing.ModelSpace.AddPoint(C) '在块E参照未旋转时的该圆圆心画一个辅助点5 e* M7 m. Y# @
ObjP.Rotate ptInsert, 0.2 '和块E一样,让该点以原点为基点旋转0.2弧度
2 {! b8 l3 y8 h5 B, @
C = ObjP.Coordinates '提取点坐标,即该圆心在模型空间真正的位置8 ?" i/ Q( D7 j& e% C' k. p! q$ }
ObjP.Delete '删除用过的辅助点
% H8 `. J3 Z/ W& M0 T
If J = 1 Then* `0 A8 c' a8 Z7 B5 t: {1 c
ptCir1(0) = C(0)
$ I6 F; e" C/ T: g
ptCir1(1) = C(1)
. ]2 c% i9 h \$ T. `/ P% ^
ptCir1(2) = C(2)" V7 E% Z$ Y: e" w4 Z# p& s/ o
J = 2! i* A- \* u5 X. y% G( B8 I2 l4 ?9 W
Else. E6 F3 i: Y! `0 e+ {! q6 l
ptCir2(0) = C(0)
" a3 R2 Z0 g/ H* G9 L+ i: f
ptCir2(1) = C(1)
. M9 A2 e# a& S/ p: U5 F
ptCir2(2) = C(2)0 ?0 P' j; D5 B4 n8 ]0 v% S" K; ~
End If
% I0 ]- O* |1 e+ z+ K
End If* A6 c" r4 P2 @0 F
Next7 Y6 h2 {2 P0 \$ Y8 F6 B! ]( j
End If
% x* Q$ ?2 [5 a B
Next1 O R) K8 Q5 G- Y& ]! O
* X0 h8 b& y" [; j* o
ThisDrawing.Regen acActiveViewport
$ T9 O( D& e8 v, D' k' _: W
End Sub

复制代码

tataki · 发表于 2012-6-12 09:49:48

本帖最后由 tataki 于 2012-6-12 10:01 编辑

8# woaishuijia
昨晚看到斑竹的回复，今天早上正准备给回复呢，没想到你一大早就重新编辑了帖子，还把圆心坐标的算法都用了三种方法给求解，让我这个7点还在睡觉的无地自容....
你以前说过“所谓"嵌套块"是指一个块定义中包含有其它块的参照.3 G* n9 B1 ?% L) K( U4 \+ Q”，所以我temA定义的是AcadBlockReference，呵呵，这个我觉得没问题。
当然我也想过定义 temA为 AcadEntity 或者 Object，不过遇到了错误，这里一并询问（稍后我问，呵呵，先说block）

斑竹的意思是不是说不论给“块”添加图元或者要遍历，都是以“块”为对象的，而不是块参照。
我第一层遍历 For Each temA In BR 没有错，因为BR就是我定义的“块”，属于blocks集合里面，
而到了第二层，我原来写的是 For Each temB In temA  ‘temA定义的是“块参照”，当然也就错了...应该从blocks这个集合里面找到原始的"块" blockC 来遍历，所以你用了.Blocks(temA.Name)这个写法找到了“块”，嘿嘿，understand！

另外，斑竹写的这一段让我发现自己考虑不周到，呵呵，确实是没运行一次，blockE里面的东西越来越多...
'清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
Dim E As AcadEntity
For Each E In BR
E.Delete
Next

第二个就是圆心坐标，我昨晚这么写了一下:
Dim temA As AcadBlockReference
Dim temB As AcadEntity
Dim ptCir(1) As Variant  '圆心坐标

For Each temA In BR '这个遍历就行
If temA.Name = blkCName.Text Then
i = 0
For Each temB In ThisDrawing.Blocks(temA.Name)
'开始找圆，找到圆就提取坐标
If temB.ObjectName = "AcDbCircle" Then
   ptCir(i) = temB.Center: i = i + 1
End If
  Next
End If
Next

这样找到的圆心坐标并不是我要求的，我调试了一下发现，这样求的坐标实际上是“块” blockC里两个圆的圆心坐标，而这两个坐标应该是从blockC 的“坐标系”开始算的吧，我的blockC刚好是矩形，所以计算坐标原点恰好是矩形左下角点，我推测，如果blockC不规则，那么坐标原点应该是对blockC使用getboundary后确定的那个边框的左下角点，呵呵，猜测的，还没验证。
所以斑竹用了三种方法算需要的坐标，当然，用三角函数这个确实最合理，呵呵。我能看懂。
另外使用UCS，这个方法好~上周发过贴恰好问过lisp中trans的用法，这次在vba中见到你那篇帖子里提到的对应的TranslateCoordinates的用法了，我得学习消化下
辅助点这个方法，说实话，我都不敢用，我怕的就是往图纸上添加一个点容易，删除一个点麻烦了，呵呵，水平不够，要努力！

说完了这个，我再问问定义temA的问题，我是这么想的：
因为blockE里面只有块参照，所以temA自然而然的定义成了AcadBlockReference，对应的使用temA.Name就行
后来我想过为什么不定义temA为AcadEntity（我也试过了定义AcadObject）呢，因为这样的用法很常见啊，但是发现错了，因为就没有temA.Name属性了，只有temA.ObjectName属性，但是后者返回的是“AcdbBlockReference”，并不是块的名字...我再想是不是因为“块”比较特殊，有特定的名字，所以只能定义temA为AcadBlockReference后才能找到块的名字，其他的都不行。
进一步讲，定义temA为AcadBlockReference，我觉得局限性挺大的，因为我这里的blockE确实只含有“块参照”，没有其他图元，比如直线，文字等，如果我给blockE里面再添加一点直线或者文字（块里面添加文字应该很常用），这样我遍历BlockE的时候，就会出错，因为文字里面没有temA.Name属性...所以要想完整的遍历包含块参照和各种图元的块且不出错该怎么做好呢？

woaishuijia · 发表于 2012-6-12 13:52:23

本帖最后由 woaishuijia 于 2012-6-12 14:01 编辑

9# tataki

斑竹的意思是不是说不论给“块”添加图元或者要遍历，都是以“块”为对象的，而不是块参照。

正确.
多说几句:能够"遍历"的前提是对象是一个集合,而集合是有"Item"方法的.比如Documents,ModelSpace,PaperSpace,SelectionSets,SelectionSet,Groups,Group,Blocks,Block,TextStyles,Layers,LineTypes等等,都是集合,都可以遍历.但BlockReference不行,它不是集合,而是一个块定义的实例.文档中同一个块的每个参照包含的子对象都是一样的(除其中的属性值外),它包含的图元种类数量位置都完全相同,因为这取决于其定义,所以想提取任何一个块参照内部子对象的特性,只能到其定义中去找.除了块参照对象的属性值是用BlockReference的GetAttributes方法,获取其属性参照对象数组.而属性定义对象本身的添加和编辑也是要在Block对象中进行

我调试了一下发现，这样求的坐标实际上是“块” blockC里两个圆的圆心坐标，而这两个坐标应该是从blockC 的“坐标系”开始算的吧

正确

我的blockC刚好是矩形，所以计算坐标原点恰好是矩形左下角点，我推测，如果blockC不规则，那么坐标原点应该是对blockC使用getboundary后确定的那个边框的左下角点，呵呵，猜测的，还没验证。

错了.
我们在使用Blocks集合对象的Add方法新建Block对象时有两个参数,第二个是块名称字符串,你懂的;而第一个InsertionPoint,就是块基点.我们在图形界面选择一个块参照对象时,块参照会有一个蓝色亮显的夹持点,这就是块基点.正像你前面说是那样,块定义是有自己的坐标系的.我们往块定义中添加图元是使用块定义的坐标系,同样,创建块定义时给定的块基点也是使用这个坐标系.通常我们在创建块时把块基点放在块定义的坐标系的原点,就是InsertionPoint参数使用(0,0,0).这样可以减少坐标换算的麻烦.
在我们向模型空间或图纸空间或其它块定义中添加块参照时,块参照是以块基点为准放到插入点(就是InsertBlock方法的InsertionPoint参数)上的.
就是说,当我们把块定义的块基点设为(0,0,0)时,块参照的子对象的位置坐标就等于其在块中的坐标与块参照的插入点坐标之和.
当块定义的块基点不是(0,0,0)时,块参照的子对象的位置坐标等于其在块中的坐标与块基点坐标之差再与块参照的插入点坐标之和.
GetBoundingBox方法可以得到的矩形框的左下角点,在本例中与块C参照的块基点坐标重合,只是巧合而已.如果块C的块基点不在左下角,或块C参照被旋转了一个角度,就不重合了.

要想完整的遍历包含块参照和各种图元的块且不出错该怎么做好呢？

增加一个条件语句就可以了

Dim temA As AcadEntity
. {! V1 ]6 [9 L" p' _
Dim temB As AcadEntity
" z0 s6 P% I3 z, ^6 x
Dim ptCir(1) As Variant '圆心坐标6 A1 w) h" p' E
For Each temA In BR '这个遍历针对块中的Entity$ |2 Y! m9 ^& h2 F
If temA.ObjectName = "AcDbBlockReference" Then'先检查temA是否块参照 h% K8 c W( `* G I/ I) U3 h
If temA.Name = blkCName.Text Then'确定是块参照后再检查其名称
3 Z% u8 k9 B3 I D* D! u
i = 0
) {5 y' Z' u# u* {+ Q. T" D
For Each temB In ThisDrawing.Blocks(temA.Name)) D* @7 m' T8 J$ e N' M
'开始找圆，找到圆就提取坐标+ f% V8 h) S" c0 `, e2 t; w
If temB.ObjectName = "AcDbCircle" Then
% m8 L2 x2 O9 u+ h+ U- J
ptCir(i) = temB.Center: i = i + 14 r/ u! Y# x5 G* r7 y4 { `# W
End If- P/ Z& x2 Q" N" N- h
Next
, O/ M" T2 Z7 s. X! r& H" e& q5 w
End If
* @# ~/ G( }4 K/ p' J" o7 b% {* Y: P
End If
$ u& l, ]( T* h2 a" ]6 @
Next

复制代码

tataki · 发表于 2012-6-12 20:50:03

本帖最后由 tataki 于 2012-6-12 20:51 编辑

“通常我们在创建块时把块基点放在块定义的坐标系的原点,就是InsertionPoint参数使用(0,0,0).这样可以减少坐标换算的麻烦.”
你这一句一下让我想到了一件事：
我的blockE是我在代码中指定的基点 0,0,0
但是其他几个块A B C D是我用GUI方式定义在图纸里面的，当时我觉得方便就把C块基点设置在了左下角（cad提示我选择基点）
对于GUI方式设置的基点，cad会默认把块坐标系的原点设置在这个基点上！而且基点的坐标就是0,0,0，感觉很诡异，这个在cad2011里面很明显，打开块编辑器后，明显的看到块坐标系的原点就是默认设置到我选择的基点上，图里左边是模型空间的坐标显示，右边就是块编辑的坐标显示！！！！这个我一直没注意！而我当初给blockE设置基点的时候只是图了方便设置到原点上，看来真是碰巧！也就是说，如果通过GUI方式，默认的就是基点和原点重合且是0,0,0，这样确实方便了以后的编辑！而用代码方式就是要指定基点了。
我这样理解的对吗？

呵呵，还有后面那个完整的遍历包含块参照和各种图元的块且不出错的代码真好，先用objectName找出是块参照的，然后再查询块参照的name进行对比，满足后再进入块的子项

woaishuijia · 发表于 2012-6-12 20:56:02

11# tataki 完全正确

cctv9527 · 发表于 2014-5-14 16:41:20

“就像在模型空间里添加块参照一样。就是说这样的嵌套块只是个定义好了块，下一步就是在模型空间里把这个块的块参照给insertBlock出来”
这话还是有点不明白
子函数1 我定义块A 里面放个梯形
子函数2 再定义块B 里面放个矩形再插入块A
图形空间中我会反复调用A B
画图能画 VBA B插入A 不明白
新手望指导下

weisad · 发表于 2017-4-21 22:12:40

插入块好像挺难的

		自动登录	找回密码
密码			注册

通知

[已答复] vba中如何嵌套块？

马上注册，结识高手，享用更多资源，轻松玩转三维网社区。

评分

浏览过的版块