Fonctionne malgrès l\'erreur

[willy95]

Bonjour a tous,

Voila j'ai un petit probleme avec cette petite suite

de commande pour tramer une zone :

ca fonctionne mais plusieurs messages d'erreur

apparaissent, que dois-je faire pour ne plus

voir ces messages ?

 

(defun	TM (/ cc)
  (setq cc (getvar "clayer"))
  (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "")
  (command "chprop" Pol "" "_color" "DuCalque" "")
  (command "_.bhatch" "_properties" "solid" "_draw" "_back" pause "")
  (command "chprop" Pol "" "_color" "DuCalque" "")
  (setvar "clayer" cc)
  (command "chprop" Pol "" "_color" "DuCalque" "")
  (princ)
)

[(gile)]

Salut,

 

Ta routine utilise une variable : Pol qui n'est jamais initialisée.

 

Pourquoi fais tu 3 fois :

(command "chprop" Pol "" "_color" "DuCalque" "")

 

À part ça, je ne vois pas d'erreur.

 

[willy95]

 (defun C:TM (/ cc Pol)

 (setq cc (getvar "clayer"))

 (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "")

 (command "chprop" Pol "" "_color" "DuCalque" "")

 (command "_.bhatch" "_properties" "solid" "_draw" "_back" pause "")

 (setvar "clayer" cc)

 (princ)

) 

 

Effectivement, la je pense que c'est mieux mais existe-il une fonction pour ne

pas faire apparaitre tous les détails dans la fenetre de commande ?

[(gile)]

Là tu déclares Pol mais tu ne l'initialises toujours pas, en faisant ça Pol est nil.

 

Si Pol est bien, comme je le pense, la polyligne à hachurer, tu dois lui attribuer une valeur :

(setq Pol (car (entsel)))

De plus, ainsi tu n'as plus besoin de faire une pause pour spécifier un point interne :

(command "_.bhatch" "_properties" "solid" "_draw" "_back" "_select" Pol "" "")

 

Pour ne pas avoir les échos des commandes, il faut mettre la variable système CMDECHO à 0 (et lui réattribuer sa valeur initiale à la fin du code).

[willy95]

 (defun C:TM (/ cc )

 (Setvar "cmdecho" 0)

 (Princ "\nCliquer dans la zone a Hachurer : ")

 (setq cc (getvar "clayer"))

 (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "")

 (command "_.bhatch" "_properties" "solid" "_draw" "_back" pause "")

 (setvar "clayer" cc)

 (princ)

) 

 

 

Voila la c'est exatement ce que je voulais faire :)

Je n'avais pas besoin de sectionner une polyligne en particulier mais plutot

une zone fermée, du coup grace a Gile j'ai compris plusieurs fonctions.

MERCI Gile

 

[VDH-Bruno]

Bonsoir,

 

Si tu permets, il y a encore 2 ou 3 petites améliorations possible pour ta macro.

Pour rester dans la logique de ta routine (sans écrire une routine d’erreur), pour cmdecho, tu peux reprendre la syntaxe utilisé pour sauvegarder clayer du type :

 
;;svg des variables
 (setq  cc  (getvar "clayer")  cmd (getvar "cmdecho")  ) 

 ;; configuration des variables
 (Setvar "cmdecho" 0)
 ….
 ;; mon programme
 ….
 ….

;; restitution des valeurs
 (setvar "clayer" cc)
 (setvar "cmdecho" cmd)

 

Rappel : dans la fonction command (comme sur la ligne de commande) il est tout à fait possible de répondre aux invites par une instruction Lisp, dans ce cas la fonction getpoint pourrait t’interesser (et à l’usage tu te rendras compte que les fonctions getxxx avec initget sont plus confortable que l’utilisation de princ / pause).

 

Pour résumer ton programme pourrait également s’écrire comme cela :

 
(defun C:TM (/ cc cmd)
 (setq	cc  (getvar "clayer")
cmd (getvar "cmdecho")
 ) 
 (Setvar "cmdecho" 0)

 (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "") 
 (command "_.bhatch"   "_properties"
   "solid"
   "_draw"
   "_back"
   (getpoint "\nCliquer dans la zone a Hachurer : ")
   ""
 ) 

 (setvar "clayer" cc)
 (setvar "cmdecho" cmd)
 (princ)

) ;_ Fin de defun

 

 

Et comme je suppose que tu n’a pas qu’une zone à pocher soit tu lance la commande multiple avant d’appeler ta fonction tm ou alors tu peux simplement créer une boucle dans ton programme avec sur la valeur de retour de la fonction getpoint .

 

Voici une autre version possible de ta routine pour des pochages multiples.

 
(defun C:TM (/ cc cmd osm pt)

 (setq	cc  (getvar "clayer")
cmd (getvar "cmdecho")
osm (getvar "osmode")
 ) 

 (setvar "cmdecho" 0)
 (setvar "osmode" 0)

 (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "") 
 (while (setq pt
	(getpoint
	  "\nCliquer dans la zone à Hachurer (Entrée pour quitter):"
	) 
 ) 
   (command "_.bhatch"	"_properties" "solid" "_draw" "_back" pt "") 
 ) 

 (setvar "clayer" cc)
 (setvar "cmdecho" cmd)
 (setvar "osmode" osm)

 (princ)

) 

 

Cordialement,

 

 

 

 

 

 

 

 

 

 

[willy95]

J'avoue que je n'ai pas la meme maitrise alors j'explique mon ideal :

 

Apres avoir créer une barre d'outil de Trames pour differentes couleurs de solide dans un meme calque j'ai pour le moment plusieurs routines qui doivent surrement pouvoir ce transformer en une seule.

 

 (defun C:T91 (/ cc )

 (Setvar "cmdecho" 0)

 (Princ "\nCliquer dans la zone a Hachurer : ")

 (setq cc (getvar "clayer"))

 (command "_.layer" "_make" "Trames" "_color" 7 "Trames" "")

 (command "_.bhatch" "_properties" "solid" "_draw" "_back" pause "")

 (Command "CHPROP" "D" "" "CO" "91" "")

 (setvar "clayer" cc)

 (princ)

) 

 

 

(defun C:T241 (/ cc Pol)

 (Setvar "cmdecho" 0)

 (Princ "\nCliquer dans la zone a Hachurer : ")

 (setq cc (getvar "clayer"))

 (command "_.layer" "_make" "Trames" "_color" 7 "Trames" "")

 (command "_.bhatch" "_properties" "solid" "_draw" "_back" pause "")

 (Command "CHPROP" "D" "" "CO" "241" "")

 (setvar "clayer" cc)

 (princ)

)

 

Pour tout dire sa fonctionne bien mais autant de fichier lisp que de couleur.

Alors je vais étudier de plus près tout sa pour tenté de faire quelquechose de mieux construit.

[VDH-Bruno]

Salut,

 

J'avoue que je n'ai pas la meme maitrise

Rassure toi je n’en n’ai pas tant que cela en Lisp disons seulement que ça m’intéresse, et c’est ton jour (ou nuit) de chance j’ai un peu de disponibilité..

 

 

Je pense que la fonction acad_colordlg devrait répondre à ton besoin de souplesse (évitant la multiplication de macro) dans le choix de la couleur de ta trame.

Elle permet d’afficher la boîte de sélection de couleur et renvoie un nombre compris entre 0 et 256 (ou nil) correspondant à la couleur sélectionnée.

 

De plus la variable CECOLOR devrait également t’intéresser, elle va permettre de t’affranchir de la syntaxe suivante : (Command "CHPROP" "D" "" "CO" "91" "")

 

Qui ne fait que forcer la couleur de la dernière entitée créé ( si tu code avec command je t’invite grandement à t’intéresser aux variables système, tu y trouvera très souvent ton bonheur de plus cela t’apportera beaucoup dans la maîtrise d’AutoCAD)

 

 

Version du code avec pochage multiple et choix de la couleur (pour le principe):

 

 (defun C:TM (/ cc cmd osm cec pt)

 (setq	cc  (getvar "clayer")
cmd (getvar "cmdecho")
osm (getvar "osmode")
cec (getvar "cecolor")
 )
 
 (setvar "cmdecho" 0)
 (setvar "osmode" 0)
 (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "")
 (setvar "cecolor" (itoa (acad_colordlg 256)))
 
 (while (setq pt
	(getpoint
	  "\nCliquer dans la zone à Hachurer (Entrée pour quitter):"
	) 
 ) 
   (command "_.bhatch" "_properties" "solid" "_draw" "_back" pt "") 
 ) 

 (setvar "clayer" cc)
 (setvar "cmdecho" cmd)
 (setvar "osmode" osm)
 (setvar "cecolor" cec)

 (princ)

) 

 

A+ Bruno

 

[willy95]

Merci c'est vraiment mieux que ma bidouille.

[VDH-Bruno]

Salut,

 

Ravis que cela te convienne, toute fois on peut encore parfaire un petit peu mieux son fonctionnement en lui introduisant une gestion d’erreur.

 

Je m’explique dans ta routine 2 chemins sont possibles : Soit elle s’exécute jusqu’à son terme et la pas de problème (toutes tes variables sont réinitialisées) ou alors tu quittes (touche échap) avant terme et là tes variables AutoCAD ne sont pas réinitialisées (plus d’accroche objet, calque trame devient le calque courant ect..).

 

En ce sens la fonction prédéfinie *error* peut t’aider (voir ici), car rien ne t’empêche de la redéfinir localement, elle a la particularité d’être systématiquement évalué en cas d’interruption de ta routine.

 

 

Pincipe de construction d’une gestion des erreurs

 

Etape 1 : Pour plus de clarté, on pourrait regrouper dans des fonctions spécialisés la sauvegarde et la restitution des valeurs par défaut des variables AutoCAD, un peu sur ce principe :

 

 ;; Sauvegarder les variables AutoCAD 
(defun svgvar ()
 (setq	cc  (getvar "clayer")
cmd (getvar "cmdecho")
osm (getvar "osmode")
cec (getvar "cecolor")
 )
)

;; Restaurer les variables AutoCAD 
(defun resvar ()
 (setvar "clayer" cc)
 (setvar "cmdecho" cmd)
 (setvar "osmode" osm)
 (setvar "cecolor" cec)
)

Note : La fonction svgvar ne se justifie pas vraiment contrairement à resvar (c’est juste pour le principe)

 

 

Etape 2 : Puis écrire ta routine d’erreur qui s’exécutera automatique en cas de besoin. Tu peux en gros la construire sur ce modèle :

 

 ;; Redéfinition de la fonction *error*
(defun *error* (msg)
 (princ (strcat "\nErreur : " msg)); renvoie un msg d'erreur
 (resvar)		; Restore les variables AutoCAD 
 (princ)		; Quitte silencieusement
)

En fait la fonction *error* ne fait que reprendre les actions que ton programme n’a pu mener à terme.

 

 

Etape 3 : Et enfin intégrer tout cela dans ta routine principal de la façon suivante :

 

Déclarer les fonctions dans ta fonction principal, très important surtout pour t’assurer que la redéfinition de la fonction *error* reste localisé à ta routine.

 (defun C:TM (/ cc cmd osm cec pt svgvar resvar *error*)

 

Puis en début de programme ajouter cette ligne pour sauvegarder la valeur des variables

 (svgvar)

 

Et celle-ci en sortie pour restituer tes variables AutoCAD

 (resvar)

 

 

Code finalisé: Maintenant ton code finalisé pourrait ressembler à ça :

 
(defun C:TM (/ cc cmd osm cec pt svgvar resvar *error*)

 ;; Sauvegarder les variables AutoCAD 
 (defun svgvar	()
   (setq cc  (getvar "clayer")
  cmd (getvar "cmdecho")
  osm (getvar "osmode")
  cec (getvar "cecolor")
   )
 )

 ;; Restaurer les variables AutoCAD 
 (defun resvar	()
   (setvar "clayer" cc)
   (setvar "cmdecho" cmd)
   (setvar "osmode" osm)
   (setvar "cecolor" cec)
 )

 ;; Redéfinition de la fonction *error*
 (defun *error* (msg)
   (princ (strcat "\nErreur: " msg))	; renvoie un msg d'erreur
   (resvar)				; Restore les variables AutoCAD 
   (princ)				; Quitte silencieusement
 )

 ;; Début du programme principal
 (svgvar)
 (setvar "cmdecho" 0)
 (setvar "osmode" 0)
 (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "")
 (setvar "cecolor" (itoa (acad_colordlg 256)))

 (while (setq pt
	(getpoint
	  "\nCliquez dans la zone à Hachurer (Entrez pour quitter):"
	)
 )
   (command "_.bhatch" "_properties" "solid" "_draw" "_back" pt "")
 )

 ;; Sortie du programme principal
 (resvar)
 (princ)
)

 

Voilà on peut faire plus sophistiqué ( ce à quoi je m’exerce en ce moment) mais dans ce cas cela ne se justifie pas vraiment. Je pense que c’est déjà une bonne base pour commencer, qui sait après mon retour de congés, j’essaierai peut être de faire un topic «mécanique de la gestion d’erreur». Il y a déjà beaucoup de post sur le sujet pas sur qu’il soit judicieux d’en faire un de plus, à voir...

 

En espérant avoir été suffisamment explicite.

Cordialement,

 

(Ps: Toutes remarques ou complément est le bienvenu)

 

 

Edit du 18/11/2011 : Rétablie le lien référençant l’article de (gile) sur la fonction *error* dans le post Arguments et Variables.