ACTION SUR CALQUES D\'UN BLOC

[PHILPHIL]

bonjour

 

 

quand on gele, eteint ou verouille un calque en selectionnant un bloc on agit tjrs sur le calque ou est implanté le bloc

 

j'implante tjrs mon bloc dans le calque principal qui compose mon bloc et jamais , jamais sur le

calque zero

 

je n'ai jamais d'entité dans le calque zero ( que ce soit bloc, ou autre )

 

et j'ai souvent plusieurs calques pour composer mon bloc

 

comment peut on recuperer la liste des calques qui compose un blocs, pour pouvoir toutes les faire apparaitre ou toutes autres actions ( geler, degeler, verrouiller , deverrouiller .... )

 

le calque d'implantation du bloc pas de probleme

les calques interne du bloc = soucis

merci

 

a+

 

phil

[(gile)]

Salut,

 

Encore une fois, il s'agit de bien comprendre ce qu'est un 'bloc' :

- une définition de bloc, à savoir une collection d'entités stockée dans la 'table des blocs', chacun de ces composant ayant ses propres propriétés.

- des références de bloc, entités graphiques insérées dans le dessin, chaque référence ayant ses propres propriétés indépendamment des composants de la définition.

 

Si je comprends bien, ce que tu appelles "le calque d'implantation du bloc" est le calque d'une référence de bloc, ce que tu cherches c'est les calques des composants de la définition du bloc.

 

Il te faut donc retrouver la définition dans la table des blocs et parcourir les entités de cette définition pour en trouver les propriétés (dont le calque).

 

En AutoLISP, la fonction tblsearch retourne une liste de données pour la définition don le nom est passé comme argument. Cette liste contient un groupe -2 dont la valeur est le nom d'entité du premier composant du bloc; on retrouve les suivant avec entnext:

(setq ent (cdr (assoc -2 (tblsearch "BLOCK" "bloc-att"))))
(while ent
 (setq elst (entget ent)
ent (entnext ent)
)
 (princ
   (strcat "\n" (cdr (assoc 0 elst)) " " (cdr (assoc 8 elst)))
 )
)

 

En Visual LISP, on récupère la définition avec la méthode Item (vla-Item) de la collection de blocs, puis on parcourt cette collection avec vlax-for:

(setq blk (vla-Item
    (vla-get-Blocks
      (vla-get-ActiveDocument (vlax-get-acad-object))
    )
    "bloc-att"
  )
)
(vlax-for o blk
 (princ
   (strcat "\n" (vla-get-ObjectName o) " " (vla-get-Layer o))
 )
)

 

PS : je vais déplacer ce sujet sur le forum "Aller plus loin en LISP", celui-ci est prévu pour poster des routines.

[PHILPHIL]

ok

[Tramber]

(setq livide nil)

(foo "nombloc")
(defun foo(nom / ent elst)
(setq ent (cdr (assoc -2 (tblsearch "BLOCK" nom))))
(while ent
 (setq elst (entget ent)
ent (entnext ent)
)
 (if(=(cdr(assoc 0 elst))"INSERT")(foo(cdr(assoc 2 elst)))
   (if(not(member(cdr (assoc 8 elst))livide))(setq livide(append livide(list(cdr (assoc 8 elst)))))))
 (princ
   (strcat "\n" (cdr (assoc 0 elst)) " " (cdr (assoc 8 elst)))
 )
)
 )
livide

 

Coucou, je propose une application de formule imbriquée :

FOO regarde si le bloc contient un bloc imbriqué en appelant FOO elle-même, qui regarde si il y a un bloc imbriqué,...etc.

 

Quant à livide, c'est tout simplement une liste qui compile les noms de calques.

[PHILPHIL]

hello

 

quelques tout petits lisp sur les calques des blocs grace a gile et tramber

merci a eux

 

agit sur les calques des blocs, si par hazard il n'y a qu'un seul calque parmis les blocs qui soit inactif ou geler

 

suivant le lisp de gile :

 

libere tous les calques d'un bloc

 

 (defun c:lbloc ()
(prompt "CLIQUER SUR LE BLOC :")
 (setq bl1 (ssget (list (cons 0 "insert"))))
 (if (/= bl1 nil)
    (progn
     (setq ent1 (cdr (car (entget (ssname bl1 0)))))
     (setq rempbl (vla-get-effectivename (vlax-ename->vla-object ent1)))
     )
   )
 
 (setq blk (vla-Item
    (vla-get-Blocks
      (vla-get-ActiveDocument (vlax-get-acad-object))
    )
    rempbl
  )
)
(vlax-for o blk
;;;  (princ
;;;    (strcat "\n" (vla-get-ObjectName o) " " (vla-get-Layer o))
;;;     )
 (command "-calque" "l" (vla-get-Layer o) "" )
)
)

 

inactive tous les calques d'un bloc

 

 

 (defun c:ibloc ()
(prompt "CLIQUER SUR LE BLOC :")
 (setq bl1 (ssget (list (cons 0 "insert"))))
 (if (/= bl1 nil)
    (progn
     (setq ent1 (cdr (car (entget (ssname bl1 0)))))
     (setq rempbl (vla-get-effectivename (vlax-ename->vla-object ent1)))
     )
   )
 
 (setq blk (vla-Item
    (vla-get-Blocks
      (vla-get-ActiveDocument (vlax-get-acad-object))
    )
    rempbl
  )
)
(vlax-for o blk
;;;  (princ
;;;    (strcat "\n" (vla-get-ObjectName o) " " (vla-get-Layer o))
;;;     )
 (command "-calque" "in" (vla-get-Layer o) "" )
)
)

 

active tous les calques d'un bloc

 

 (defun c:abloc ()
(prompt "CLIQUER SUR LE BLOC :")
 (setq bl1 (ssget (list (cons 0 "insert"))))
 (if (/= bl1 nil)
    (progn
     (setq ent1 (cdr (car (entget (ssname bl1 0)))))
     (setq rempbl (vla-get-effectivename (vlax-ename->vla-object ent1)))
     )
   )
 
 (setq blk (vla-Item
    (vla-get-Blocks
      (vla-get-ActiveDocument (vlax-get-acad-object))
    )
    rempbl
  )
)
(vlax-for o blk
;;;  (princ
;;;    (strcat "\n" (vla-get-ObjectName o) " " (vla-get-Layer o))
;;;     )
 (command "-calque" "ac" (vla-get-Layer o) "" )
)
)

 

 

suivant le lisp de tramber, permet de regarder aussi les blocs imbriqués :

 

 

 (defun foo(nom / ent elst)
(setq ent (cdr (assoc -2 (tblsearch "BLOCK" nom))))
(while ent
 (setq elst (entget ent)
ent (entnext ent)
)
 (if(=(cdr(assoc 0 elst))"INSERT")(foo(cdr(assoc 2 elst)))
   (if(not(member(cdr (assoc 8 elst))livide))(setq livide(append livide(list(cdr (assoc 8 elst)))))))
;;;  (princ
;;;    (strcat "\n" (cdr (assoc 0 elst)) " " (cdr (assoc 8 elst)))
;;;  )
)
 )

 

active tous les calques d'un bloc

 

 (defun c:abloc2 ()
(setq livide nil)
(prompt "CLIQUER SUR LE BLOC :")
 (setq bl1 (ssget (list (cons 0 "insert"))))
 (if (/= bl1 nil)
    (progn
     (setq ent1 (cdr (car (entget (ssname bl1 0)))))
     (setq rempbl (vla-get-effectivename (vlax-ename->vla-object ent1)))
     (foo rempbl)
     )
   )
 (foreach ncal livide (command "-calque" "ac" ncal "" ))
)

 

 

inactive tous les calques d'un bloc

 

 (defun c:ibloc2 ()
(setq livide nil)
(prompt "CLIQUER SUR LE BLOC :")
 (setq bl1 (ssget (list (cons 0 "insert"))))
 (if (/= bl1 nil)
    (progn
     (setq ent1 (cdr (car (entget (ssname bl1 0)))))
     (setq rempbl (vla-get-effectivename (vlax-ename->vla-object ent1)))
     (foo rempbl)
     )
   )
 (foreach ncal livide (command "-calque" "in" ncal "" ))
)

 

 

libere tous les calques d'un bloc

 

 (defun c:lbloc2 ()
(setq livide nil)
(prompt "CLIQUER SUR LE BLOC :")
 (setq bl1 (ssget (list (cons 0 "insert"))))
 (if (/= bl1 nil)
    (progn
     (setq ent1 (cdr (car (entget (ssname bl1 0)))))
     (setq rempbl (vla-get-effectivename (vlax-ename->vla-object ent1)))
     (foo rempbl)
     )
   )
 (foreach ncal livide (command "-calque" "l" ncal "" ))
)

 

 

a+

 

phil

[lili2006]

Bonjour à toutes et tous,

 

Pas mal ces p'tits outils,...

 

Mais question (de pure curiosité,..), pourquoi construire des blocs de cette façon ?

 

Merci d'avance,

[(gile)]

Salut PHILPHIL,

 

C'est un peu dommage d'utiliser command dans un code écrit en vlisp.

 

Regarde les propriétés des objets Layer (Freeze, LayerOn, Lock) dans l'aide aux développeurs > ActiveX and VBA Reférence

 

Par exemple :

(command "-calque" "l" (vla-get-Layer o) "" )

peut s'écrire :

(vla-put-Freeze (vla-get-Layer o) :vlax-false) 

[lili2006]

(Gilles, as-tu vu mon MP ?)

 

Désolé PHILPHIL, ;)