Décomposer le dernier bloc crée

[Aleck_Ultimate]

Bonjour à tous.

 

Je suis partit de ça :

 

(command "_explode" (entlast))

Mais mes sous-entités restaient sur le calque 0, qui forcément était gelé. Je vous dit pas le temps qu'il m'a fallut pour trouver l’erreur. Du coup je me suis retroussé les manches et j'ais fini par arriver à ça :

 

(defun c:ALK_decomposer-dernier	(/
            	ent ;_ Entité (brute)
            	sousent ;_ Sous-entité (brute)
            	entcalc ;_ Calque de l'entité (paire pointée DXF 8)
			)
 (setq ent (entlast))
 (if (/= (setq entcalc (assoc 8 (entget ent))) '(8 . "0")) ;_ Vérification du calque de l'entité
   (progn
     (setq sousent (entnext ent)) ;_ Définition de la premiére sous-entité
     (if (/= (assoc 8 (entget sousent)) '(8 . "0")) ;_ Test premiére sous-entité
(progn (setq sousent (subst entcalc (assoc 8 (entget sousent)) sousent)) ;_ Remplacement du calque si différent de 0
 	(entmod sousent) ;_ Remplacement de la premiére sous-entité
) ;_ Fin de progn
     ) ;_ Fin de if
     (while (setq sousent (entnext sousent)) ;_ Démarage de la boucle des autres sous-entités
(if (/= (assoc 8 (entget sousent)) '(8 . "0")) ;_ Test des autres sous-entités
 	(progn (setq sousent (subst entcalc (assoc 8 (entget sousent)) sousent)) ;_ Remplacement du calque si différent de 0
		(entmod sousent) ;_ Remplacement des autres sous-entité
 	) ;_ Fin de progn
) ;_ Fin de if
     ) ;_ Fin de while
   ) ;_ Fin de progn
 ) ;_ Fin de if
 (command "_explode" ent)
) ;_ Fin de defun

La bonne nouvelle : j'ais enfin compris comment fonctionnait if et progn, et que while avait besoin de entnext, et ca me parais bien plus simple que ce que je craignais.

 

La mauvaise : à par rajouter des entget un peut partout là où ils manquaient (du moins j'ais crue le comprendre), je suis partit trop loin et je ne maîtrise plus suffisamment ce que j'ais codé pour déboguer le tout. Ça m’échappe complètement.

 

Si vous pouviez au moins me donner des pistes de travail ? Si possible je préférerais corriger moi-même étant donné qu'a priori j'ais le temps... dans la mesure de mes compétences.

 

Merci.

[Patrick_35]

Salut

 

1) Tester si l'objet choisit est bien un bloc.

2) Pointer sur le dernier objet du dessin.

3) Décomposer le bloc.

4) Commencer une boucle depuis le dernier objet pointé (avec entnext).

5) Changer les objets de calque.

6) Fermer la boucle.

 

@+

[Aleck_Ultimate]

Ou la la... c'est pas forcément une mauvaise chose mais ça m'apporte bien plus de questions que de réponses.

 

Je fait exprès de ne pas vérifier le type d'objet. Je préférerait faire une commande le plus universel possible, pouvant s'utiliser sur tout type d'objets comme les réseaux ou les groupes, mais aussi ceux qui n'ont pas de sous-entité. C'est peut-être pas une bonne idée ? Ou ça complexifie beaucoup le code ?

 

Pour ce qui est de décomposer le bloc avant de changer le calque des objets, puisque l'objet est décomposé je comprend pas comment je peut les sélectionner vue que l'objet cible a disparu ? Il ne disparaît pas en faite ? Il reste une rémanence du bloc décomposé ? Surtout que j'avais dans l'idée de faire une autre version qui sélectionne manuellement l'objet à décomposer... donc entnext ne risque t-il pas de continuer à agir plus loin que les sous-entité voulues ? Parce que ce qui arrête entnexte, pour moi ça disparais aussi à la décomposition du bloc. Non-plus ?

 

D'un autre côté je comprend bien que modifier un bloc avant de le décomposer ça va poser des problèmes à toutes les autres occurrence sauf si il est dynamique. Non, c'est même pas ça... une référence de bloc, ça n'a pas vraiment de sous-entités avant d’être décomposé ?

 

Désolé, c'est comme en physique quantique, plus j'en apprend et moins j'en sais

[Olivier Eckmann]

Bonjour,

 

Tu as la commande XPLODE sans le E qui dispose de pas mal d'option:

CA pour spécifier le calque dans lequel envoyer le résultat de la décomposition

H (hérite du bloc parent) qui permet d'affecter au objets issus de la décomposition les mêmes propriétés (calque / couleur / Type de ligne) que le bloc initial.

Par contre c'est déjà un Lisp donc pas possible de mettre dans un autre Lisp il me semble.

 

Sinon le plus simple, c'est de créer un jeu de sélection (ssadd) avec tous les objets issus de la décomposition , puis d'appliquer un changement de propriété globale au jeu de sélection.

(command "_CHPROP" JEU "" "_LA" (getvar "CLAYER") "")[/size][size=2]

Olivier

[Patrick_35]

Je fait exprès de ne pas vérifier le type d'objet. Je préférerait faire une commande le plus universel possible, pouvant s'utiliser sur tout type d'objets comme les réseaux ou les groupes, mais aussi ceux qui n'ont pas de sous-entité. C'est peut-être pas une bonne idée ? Ou ça complexifie beaucoup le code ?

Non, c'est juste que tu parlais de blocs, pour éviter que si tu utilises le lisp sur des poly, mtext, etc..., celui-ci plante et donne un message d'erreur.

C'est alors à toi d'envisager toutes les combinaisons possibles par l'utilisateur du lisp.

 

Pour ce qui est de décomposer le bloc avant de changer le calque des objets, puisque l'objet est décomposé je comprend pas comment je peut les sélectionner vue que l'objet cible a disparu ? Il ne disparaît pas en faite ? Il reste une rémanence du bloc décomposé ? Surtout que j'avais dans l'idée de faire une autre version qui sélectionne manuellement l'objet à décomposer... donc entnext ne risque t-il pas de continuer à agir plus loin que les sous-entité voulues ? Parce que ce qui arrête entnexte, pour moi ça disparais aussi à la décomposition du bloc. Non-plus ?

L'idée est de pointer de dernier objet dans le dessin, puis de décomposer le bloc. Ainsi, les objets décomposés sont ajoutés à la suite du dernier objet pointé auparavant.

Donc un (entnext (entlast)) donne le 1er objet décomposé (dans l'idée).

 

D'un autre côté je comprend bien que modifier un bloc avant de le décomposer ça va poser des problèmes à toutes les autres occurrence sauf si il est dynamique. Non, c'est même pas ça... une référence de bloc, ça n'a pas vraiment de sous-entités avant d’être décomposé ?

Si, un bloc est une référence et les objets qui le composent le sont aussi. De plus, tu peux avoir des blocs imbriqués dans des blocs.

 

Désolé, c'est comme en physique quantique, plus j'en apprend et moins j'en sais

C'est comme tout, c'est en forgeant qu'on devient forgeron.

 

@+

[Aleck_Ultimate]

Olivier Eckmann :

Tu as la commande XPLODE sans le E

Parfait. Cette option c'est juste ce que je cherchait à faire moi-même :

 

Hérite du bloc parent

Définit la couleur, le type et l'épaisseur de ligne, et le calque des objets composants de manière à ce qu'ils utilisent les propriétés de l'objet décomposé, si la couleur, le type et l'épaisseur de ligne des composants sont de type DUBLOC et sont dessinés sur le calque 0.

Effectivement, si je l'appel avec command j'ais une erreur "commande inconnue".

 

Je m'avoue pas vaincue, j'ais lue quelque-chose autour des commandes lambda (ou plutôt de la commande dans laquelle on les utilise) qui fait dire que y'a peut-être un moyen de l'appeler autrement. Et puis sinon je créerait une MACRO que je rentrerais tel quel avec command. Sur un malentendu ça peut passer Parce que une MACRO en tant que tel on peut pas la lier à un alia, juste à un bouton. C'est pas top.

 

 

Patrick_35 :

 

Ok, là ça devient chaud. Comme je n'ais "rien à faire" pour l'instant je vais quand même essayer de finir ce LISP pour l'xp, mais comme XPLODE résous au moins en partit mon problème je n'ais plus que la motivation de la découverte vue que je perd un bonne partie de celle de l'utilité (quoique XPLODE c'est pas gagné non plus).

 

L'idée est de pointer de dernier objet dans le dessin, puis de décomposer le bloc. Ainsi, les objets décomposés sont ajoutés à la suite du dernier objet pointé auparavant.

Dit comme ça je comprend le fonctionnement, mais il me chiffonne toujours le fait que la dernière entité crée c'est précisément le bloc que je vais exploser, donc je perd mon point de repaire dans la liste. Non, c'est bon, le cas échéant j'ajoute un entlast si ma sélection est identique à mon point de repaire. Je vais arrêter de dire que c'est simple, en LISP ça me porte malheur.

 

Par contre je vais forcément avoir plusieurs blocs imbriqués dans ceux que je compte décomposer, et je sais pas comment empêcher que entnext scan l'intérieur du premier objet complexe qu'il croise et arrête la boucle à son drapeau SEQEND.

[Patrick_35]

Par contre je vais forcément avoir plusieurs blocs imbriqués dans ceux que je compte décomposer, et je sais pas comment empêcher que entnext scan l'intérieur du premier objet complexe qu'il croise et arrête la boucle à son drapeau SEQEND.

Le SEQEND est là pour indiquer la fin des attributs.

Pour ce qui est des blocs imbriqués, il suffit simplement de les décomposer au fur et a mesure que tu les trouvent.

Les objets décomposés seront ajoutés à la suite du dernier et comme tu es dans une boucle. Par contre, dans ce cas, attention aux objets non décomposables (boucle infinie).

 

@+

[Aleck_Ultimate]

Le problème c'est que je ne veut pas décomposer les blocs imbriqués, seulement changer leur calque. Le but pour moi c'est d'insérer un ensemble de blocs dynamique en même temps, et de pouvoir les modifier individuellement après avoir décomposé le bloc source. Sans compter l'idée de faire un quantitatif avec EXTRACTDONNEE.

 

EDIT : D’après l'Evan(gile) selon Chanteau (16.1 entnexte) SEQEND sert de drapeau de fin de toutes liste de sous-entités, pas seulement des attributs. Si j'ais bien suivi...

[Patrick_35]

Alors, tu ne décomposes que le 1er. Pas besoin de tester si c'est un bloc imbriqué.

 

Pour le SEQEND, au clavier

Sélection d'un bloc

(setq ent (car (entsel)))

Codes dxf

(entget ent)

Entité suivante

(setq ent (entnext ent))

Codes dxf --> Attribut

(entget ent)

Entité suivante

(setq ent (entnext ent))

Codes dxf --> Attribut

(entget ent)

...

Entité suivante

(setq ent (entnext ent))

Codes dxf --> SEQEND

(entget ent)

 

Autre exemple

(setq ent (car (entsel)))
(setq ent (entget ent))

(while (/= (cdr (assoc 0 ent)) "SEQEND")
 (princ (strcat "\n" (cdr (assoc 0 ent))))
 (setq ent (entget (entnext (cdr (assoc -1 ent)))))
)

 

@+

[Olivier Eckmann]

Parfois un dessin vaut mieux qu'un long discours

 

https://i.goopics.net/QmOkV.jpg

 

 

Olivier

[Aleck_Ultimate]

Vous êtes vraiment gentils de prendre le temps de m'expliquer tout ça en détail, mais le problème n'est pas là. Vous remarquerez que excepté la sélection qui chez Patrick_35 est (car (entsel)) et chez moi (entlaste), j'utilise exactement les mêmes phrases dans mon code, boucles et conditions en plus.

 

Ce qui me mettait la tête à l'envers c’était que entnexte parcoure les sous-entités, ce pourquoi je voulait changer le calque des sous-entités avant de décomposer mon bloc, sans penser que entnexte allait selon toute logique aussi me chercher les sous-entité de mes sous-entité et stopper ma boucle (car retour nill) à la dernière sous-entité SEQEND. Probablement l'erreur dans mon code, si on part du principe que j'ais pas fait de faute de syntaxe.

 

Bref, je suis remonté à la source au cas où SACRILÈGE il y aurait eu une erreur dans l'Evan(gile) à propos de cette histoire de parcourt de sous-entité qui semble ne vous faire ni chaud ni froid et j'ais trouvé par hasard la solution dans cette note chez todesk (page "entnext (AutoLISP)", uniquement en anglais) :

 

En anglais :

Note: The entities selected by ssget are main entities, not attributes of blocks or vertices of polylines. You can access the internal structure of these complex entities by walking through the subentities with entnext. Once you obtain a subentity's name, you can operate on it like any other entity. If you obtain the name of a subentity with entnext, you can find the parent entity by stepping forward with entnext until a seqend entity is found, then extracting the -2 group from that entity, which is the main entity's name.

 

En français (traduit automatiquement)

Note: Les entités sélectionnées par ssget sont des entités principales, pas des attributs de blocs ou de sommets de polylignes. Vous pouvez accéder à la structure interne de ces entités complexes en parcourant les sous-entités avec entnext. Une fois que vous obtenez le nom d'une sous-entité, vous pouvez y travailler comme n'importe quelle autre entité. Si vous obtenez le nom d'une sous-entité avec entnext, vous pouvez trouver l'entité mère en avançant avec entnext jusqu'à ce qu'une entité seqend soit trouvée, puis extraire le groupe -2 de cette entité, qui est le nom de l'entité principale.

 

Je vais donc refaire mon code de 0 en décomposant mon bloc avant de changer les calques comme proposé par Patrick_35, mais en ajoutant des sécurité pour ne pas modifier mes blocs imbriqués et ne pas laisser stopper ma boucle sur la première entité complexe qui passe.

 

Je pense (écrit directement ici) à

 

(if (/= (assoc -2 (entget ent)) nill) (setq ent (assoc -2 (entget ent))) (mon code de changement de calque)) 

Et puis on se revois pour le débogage de ce code là

 

EDIT : Va falloir creuser un peut plus, parce que ce code là (en plus d’être faux il manque un cdr) lancerait une boucle infini.

[Aleck_Ultimate]

P***** de b***** de m****

 

Désolé Patrick_35, j'était tellement focalisé sur les premières lignes qui répétaient les miennes que j'ais négligée la dernière "Codes dxf --> SEQEND".

 

Je garde ma ligne de code, mais si elle est vraie je lance une autre boucle qui évalue les sous-entés sans les modifier jusqu’à atteindre un SEQEND, et là j'ais ce qu'il faut pour obtenir le nom de la dernière entité.

 

Sachant qu'avec un nombre indéfinissable d'entités complexes imbriquées il va falloir mettre le tout dans un autre boucle.

Et ba si j'arrive à coder ça sans votre aide c'est que je suis vraiment bon

 

Alez, on se motive en on y va !

 

Merci.

[Patrick_35]

Salut

 

C'est beaucoup plus simple que tu ne le pense.

Tu prends un exemple et tu fais ton lisp au pas à pas, en effectuant chaque étape.

 

Par exemple

Je sélectionne mon bloc qui est le dernier objet de mon dessin.

(setq ent (entlast))

J'indique que c'est aussi de dernier objet du dessin

(setq der ent)

Je décompose mon bloc

(vl-cmdf "_.explode" ent)

Je recherche le 1er objet de mon bloc décomposé

(setq ent (entnext der))

Je fais une boucle pour voir tout les types d'objets décomposés

(while ent
 (princ (strcat "\n" (cdr (assoc 0 (entget ent)))))
 (setq ent (entnext ent))
)

 

Et tu vas comprendre comment faire.

 

@+

[Aleck_Ultimate]

Bon, désolé, j'ais pas fait ce que t'a dit parce que quant je t'ais lue il me restait que trois-quatre lignes à faire sur ce code là :

 

(defun c:ALK_decomposer-dernier	(/ ent ;_ Entité principale (nom brute)
	         drapeau ;_ Point de départ de la boucle principale (nom brute)
	         sousent ;_ Sous-entité à évaluer (nom brute)
	         entcalc ;_ Calque de l'entité (chaine)
)
 (setq ent (entlast))
 (if
   (and
     (/= (assoc -2 (entget ent)) "nil") ;_ Test si ent est une entité complexe
     (/= (assoc 8 (entget ent)) '(8 . "0")) ;_ Test si ent est sur le calque 0
   ) ;_ Fin de and
	(progn
  	(setq entcalc (cdr (assoc 8 (entget ent))))
  	(if (= ent (entlast)) ;_ Vérification que drapeau est diférant de ent
	(setq drapeau (entlast ent))
	(setq drapeau (entlast))
  	) ;_ Fin de if
  	(command "_.explode" ent) ;_ Décomposition de ent si complexe
  	(setq sousent drapeau ;_ Aplication du drapeau à sousent
    	drapeau nil ;_ Supression du drapeau (c'est deux lignes superflu mais sinon je m'y perd)
  	)

  	
  	(while (setq sousent (entnext sousent)) ;_ Démarage de la boucle
	(if (/= (assoc -2 (entget sousent)) "nil") ;_ vérification que sousent n'est pas une sous-entité de second degré
  	(progn
    	(while (/= (assoc -2 (entget sousent)) "nil") ;_ Démarage de la boucle secondaire
      	(setq sousent (entnext sousent)) ;_ Tant que c'est une sous-entité elle passe au suivant
    	) ;_ Fin de while
  	) ;_ Fin de progn
  	(progn
    	(setq sousent
   		(subst entcalc (assoc 8 (entget sousent)) sousent) ;_ Remplacement du calque si différent de 0
    	)
    	(entmod sousent) ;_ Remplacement des autres sous-entité
  	) ;_ Fin de progn
	) ;_ fin de if
  	) ;_ FIn de while

  	
	) ;_ Fin de progn
	(command "_.explode" ent) ;_ Décomposition de ent si non complexe
 ) ;_ Fin de if
) ;_ Fin de defun

 

 

Ça marche pas, mais j'ais pu isoler l'erreur : elle est dans la boucle entre espaces. Types d'argument incorrect : lentityp nil

 

Le truc c'est que cette boucle je voie vraiment pas comment tester les morceau individuellement.

 

 

Pour ton exo... je vois pas comment ent et der peuvent être les même vue que pour moi ent est sensé ne plus exister quant on l'explose, mais je te croie sur parole.

 

Pour ce qui est de le faire pour me rendre compte de ce que donne princ je verrais ça demain. Là j'ais la tête à l'envers à cause d'autrechose. Je serais plus capable de rien.

[Patrick_35]

Pour ton exo... je vois pas comment ent et der peuvent être les même vue que pour moi ent est sensé ne plus exister quant on l'explose, mais je te croie sur parole.

Justement, c'est pour trouver le 1er élément décomposé --> (entnext der)

Pas pour l'utiliser vu qu'il a été décomposé.

 

@+

[Aleck_Ultimate]

Ce n'est pas ce que je veut dire : si ent a été explosé je ne comprend pas comment ont peut encore s'y référer. Vue qu'on peut par exemple purger le bloc.

 

...

 

En fait c'est un peut comme d'avoir des numéros de lignes de mettons 001 à 999, et si je dit que j'ais marqué TOTO à la ligne 253 et que je stock 253 dans "der", même si j’efface TOTO de ma ligne 253 je pourrais toujours trouver 254 par rapport au numéro de ligne 253 ?

[Patrick_35]

En fait c'est un peut comme d'avoir des numéros de lignes de mettons 001 à 999, et si je dit que j'ais marqué TOTO à la ligne 253 et que je stock 253 dans "der", même si j’efface TOTO de ma ligne 253 je pourrais toujours trouver 254 par rapport au numéro de ligne 253 ?

Oui, mais tu ne pourras plus exploiter 253.

 

@+

[Aleck_Ultimate]

Contrairement à la mémoire informatique, une fois qu'un espace est libéré il n'est plus réutilisé. Il est juste nil.

 

Le flash ! C'est pour ça que les noms d'objets changent à chaque ouverture du fichier : à chaque fois on renomme tout en ignorant les espaces vides, qui n'existent plus.

 

Ok, merci.

[Aleck_Ultimate]

Alors comme entretemps j'ais eu du boulot à faire j'ais repris que ce matin. C'est la boucle qui coince, elle me retourne "type d'argument incorrect : FILE <nom d'entité>"

 

EDIT : Tout simple même s'il m'a fallut du temps pour trouver parce que je cherchait à tester les éléments individuellement. Il manquait bêtement un parenthèse pour fermer le princ quant je l'ais recopiée.

[Aleck_Ultimate]

Bon, bah je vient de recevoir une grosse modélisation à faire, entre ça et mes cours qui vont pas tarder à reprendre j'ais peur de pas pouvoir m'y remettre avant un moment.

 

Stand by... ... ...

[mattoti]

Bonjour,

 

Si j'ai bien compris l'histoire, tu cherches à exploser le bloc sans exploser les blocs imbriqués et tu changes le calque des entités créées si elles sont sur le calque "0" ?

 

Mais je n'ai pas bien compris sur quel calque les entités devaient être placées...

 

J'ai fait un bout de code qui semble correspondre à ce que tu veux.

(Je déplace les entités sur le calque "0" vers le calque courant).

 

(defun c:ALK_decomposer-dernier ( / der sslst clq ent entl cpteur)
(setq der (entlast))					; Dernière entité 
(command "_explode" der)				; décompose l'entité
(setq sslst (ssget "_P") cpteur 0)		; récupère les entités 'principales'
(setq clq (getvar "clayer"))			; calque courant
(while (setq ent (ssname sslst cpteur))	
	(if (= (cdr (assoc 8 (entget ent))) "0")	; vérifie si l'entité est sur le calque "0"
		(progn
			(setq entl (entget ent))
			(setq entl (subst (cons 8 clq) (assoc 8 entl) entl))	; place l'entité sur le calque courant
			(entmod entl)
			(entupd ent)
		)
	)
	(setq cpteur (1+ cpteur))
)
)

 

Bon week-end à tous...

[La Lozère]

Je vais être surement complétement être à coté de la plaque, mais je dis ma bêtise quand même dès fois que ça donne des idées :(rires forts):

 

Quand on utilise la commande xplode sur un bloc, c'est objet se retrouve par défaut comme la dernière sélection d'objet.

Alors si on utilise dans l'ordre:

- xplode

- select

- p (pour précédent)

- chprop

- CA (pour calque)

- via le lisp récupérer le calque courant et le remettre ici

 

Mais bon, je n'ai pas tout compris à la demande :P

[Aleck_Ultimate]

L'idée c'est que si j'explose un bloc sur le calque "toto" les entités de ce bloc qui sont sur le calque 0 passent sur le calque "toto", indépendamment du calque courant, et même si les blocs que j'exploses sont sur des calques différents. Je comptais faire d’abord un LISP qui explose le dernier objet crée, et ensuit seulement l'adapter pour d'autres types de sélection. Si les entités sélectionnées sont sur des calques différents il faut ajouter une boucle englobant tout le reste du code pour traiter indépendamment chaque calque, mais je m'égare... petit bout par petit bout, sinon je me perd, moi.

 

Au fait Patrique_35, au sujet de la proposition que tu m'avait faite par ailleurs, si c'est toujours d'accord j'utilise mon joker pour les solutions que tu a préparé, même si je risque de pas pouvoir m'y pencher avant quelques semaines. Je renonce à mon copyright exclusif sur ce code là , je doute de pouvoir y arriver sans aide. Sans beaucoup d'aide.

 

Merci.

[Patrick_35]

Version simple, en pur autolisp.

(defun c:exp(/ der ent dxf)
 (if (and (setq ent (entsel "\nSélectionnez un bloc : "))
   (setq dxf (entget (car ent)))
   (= (cdr (assoc 0 dxf)) "INSERT")
     )
   (progn
     (setq der (entlast))
     (vl-cmdf "_.explode" (car ent))
     (setq ent (entnext der))
     (while ent
(setq ent (entget ent))
(if (not (vl-position (cdr (assoc 0 ent)) '("ATTRIB" "SEQEND")))
  (entmod (subst (cons 8 (getvar "clayer")) (assoc 8 ent) ent))
)
(setq ent (entnext (cdr (assoc -1 ent))))
     )
   )
 )
 (princ)
)

 

Version sans if, avec utilisation du and et du or comme condition if.

(defun c:exp(/ der ent dxf)
 (and	(setq ent (entsel "\nSélectionnez un bloc : "))
(setq dxf (entget (car ent)))
(= (cdr (assoc 0 dxf)) "INSERT")
   (progn
     (setq der (entlast))
     (vl-cmdf "_.explode" (car ent))
     (setq ent (entnext der))
     (while ent
(setq ent (entget ent))
(or (vl-position (cdr (assoc 0 ent)) '("ATTRIB" "SEQEND"))
  (entmod (subst (cons 8 (getvar "clayer")) (assoc 8 ent) ent))
)
(setq ent (entnext (cdr (assoc -1 ent))))
     )
   )
 )
 (princ)
)

 

Version vlisp, car (vlax-invoke ent 'explode) retourne directement la liste des objets décomposés. C'est quand même plus simple.

(defun c:exp(/ ent new)
 (and	(setq ent (entsel "\nSélectionnez un bloc : "))
(setq ent (vlax-ename->vla-object (car ent)))
(= (vla-get-objectname ent) "AcDbBlockReference")
   (progn
     (foreach new (vlax-invoke ent 'explode)
(vla-put-layer new (getvar "clayer"))
     )
     (vla-delete ent)
   )
 )
 (princ)
)

 

ps : je t'ai laissé travailler avec le code dxf -2, mais regarde quand tu en as besoin. Perso, jamais.

pps : L'idée de mattoti (et suggéré par La Lozère) d'utiliser le (ssget "_p") est excellente. J'avais complétement zappé cette solution. A force de faire du vlisp ;)

 

@+

[Aleck_Ultimate]

Whaou... Décidément j'aime le LISP aussi dur que soit les débuts. C'est tellement incroyable ce qu'on peut faire quant on passe de l'autre côté du miroir des programmes. J'aurais peut-être du m'orienter codage plutôt que DAO, si j'avais sut ! Mais bon, j'ais un boulot en or et qui me plais aussi, je vais pas tout plaquer pour si peut

 

Va bien falloir que je me mette au VLISP un de ses jour. Je commence peut-être à avoir le niveau requis, il parais que c'est une sacrée marche même quant on connais bien le LISP.

 

Je décortiquerais tout ça dés que j'aurais à nouveau le temps.

 

Merci encore.