Bred

Merci Bonuscad, désolé de mon retard de remerciement, mais je suis un peu surchargé en ce moment. Ta manière de faire répond en partie à mon souci, car je veux pouvoir faire une selection de plusieurs fenêtre si j'ai envie ... mais ta manière de faire et donc je pense pouvoir y arriver... je vous tiens au courant sur mon avancement ... Par contre, ta routine m'a permis de connaitre une manière de "filtrer" les entités que je ne connaissais pas le '((0 . "VIEWPORT,LWPOLYLINE")) ... merci encore !!!

Bonjour à tous. J'ai un gros problème ... que je n'arrive pas à résoudre depuis trééééés longtemps, et donc au bout d'un moment j'ai l'impression de tourner en rond... Je veux réaliser un outils qui me change la couleur d'une fenêtre de présentation... j'y arrive si c'est une fenêtre "simple", mais si c'est une fenêtre polygonale, un problème se pose : la fenêtre polygonale est constitué de 2 objets (fenêtre et polyligne). Donc comment je pourrais faire pour identifier une polyligne qui appartient à une fenêtre polygonale et lui applique la même couleur que l’objet fenêtre de cette même fenêtre polygonale ???... Voici un petit résumé de ce que j’ai commencé à faire : J’arrive à identifier (enget...) une polyligne « normale » d’une polyligne appartenant à une fenêtre polygonale grâce au code de groupe 102 ("{ACAD_REACTORS"). Le code de groupe 340 de l’objet fenêtre d’une fenêtre polygonale comporte le nom de l’entité de la polyligne de la fenêtre polygonale mais je n’arrive pas à sélectionner la polyligne à l’aide de ce code de groupe 340. Je suis bloqué là... il y a peut être d’autre méthodes plus simple pour arriver à mon but. (j'y arrive en script, mais en lisp je suis coincé. ex: ^C^Cselect;\-fenetres v a precedent; changer precedent; proprietes couleur rouge;;) ... merci de votre aide

Bonsoir Dominique, Tu pourrais argumenter ??? Personellement après avoir testé Inventor et TopSolid en profondeur, je peux te dire que ni l'un ni l'autre n'arrive à faire ce que l'on peut faire avec Autocad... quand il y a du volume 3D à traiter en mise en plan 2D !!!... (en fait, c'est simple : le même test sur les 3 logiciels d'un ensemble de 8000 éléments : seul Autocad à pû en sortir un tirage papier ...) [Edité le 5/7/2006 par Bred]

- merci bonuscad - ... alors, en "tripatouillant" tout ça et en faisant quelque tests, je pense être arrivé à quelque chose de pas mal (en fait c'est une synthèse de tous vos conseils que j'ai remis à plat petit à petit...): ;;; INTRODUCTION du PROGRAMME - Redéfinition de *error* (defun INTRO_PRG_ERR () (vla-StartUndoMark (vla-get-ActiveDocument (vlax-get-acad-object))) (SAVE&SET_VAR "cmdecho" 0) [b] (command "_undo" "_mark")[/b] (setq Sauv_EXerror *error*) ; enregistrement *error* autocad ; Enregistrement du environnement Actif (SCU / Calque /... (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir") (getvar "ucsicon") (getvar "clayer") (getvar "orthomode") (getvar "osmode"))) ; Gestion des Erreur remplaçant celle d'Autocad (setq *error* REDEF_ERROR) ) ;;; ROUTINE de GESTION des ERREURS remplaçant celle d'Autocad (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) (princ (strcat "\nErreur: " msg)) ) [b] (command "_undo" "_back") (END_PRG_ERR)[/b] ) ;;; ROUTINE ENREGISTREMENT VARIABLE+MODIF VARIABLE ((gile) cadXP) (defun SAVE&SET_VAR (var val) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst)) (if val (setvar var val))) ) ) ;;; FIN de PROGRAMME - ; retour *error* initial (defun END_PRG_ERR () ; Restauration de l'environnement Actif enregistré (command "_ucs" "_w" "_ucs" "_3" "_non" '(0 0 0) "_non" (nth 1 list_env_actif) "_non" (nth 2 list_env_actif) "_ucs" "_o" "_non" (trans (nth 0 list_env_actif) 0 1)) (setvar "ucsicon" (nth 3 list_env_actif)) (setvar "clayer" (nth 4 list_env_actif)) (setvar "orthomode"(nth 5 list_env_actif)) (setvar "osmode" (nth 6 list_env_actif)) (mapcar 'eval SavedSysVarLst) ;remise à nil (setq *error* Sauv_EXerror list_env_actif nil SavedSysVarLst nil Sauv_EXerror nil scu_init nil) (vla-EndUndoMark (vla-get-ActiveDocument (vlax-get-acad-object))) ) Donc, pour expliquer ma logique (que j'espère juste) : 1 - Je lance une routine d'introduction (INTRO_PRG_ERR) qui me créé un départ d'undo en -vl (donc pas écrit en ligne de commande), je met "cmdecho à 0, et je créé une marque d'annulation, puis enregistrement des variables actives et remplacement de *error* ... 2- J'écris mon lisp en rentrant les variables modifiés avec SAVE&SET_VAR (gile) ... 3 - Si le lisp se passe bien, je vais jusqu'à (END_PRG_ERR) qui me réinitialise toutes mes modification d'état d'autocad, et créé une fin d'undo en -vl (pas écrit en ligne de commande donc)... 4 - Si j'ai une erreur (echap...) ma routine (REDEF_ERROR) se lance, [surligneur] retourne à la marque undo de (INTRO_PRG_ERR) et puis lance à la suite (END_PRG_ERR) [/surligneur](voir ci-dessus) ... afin de supprimer toutes les actions réaliser depuis le début du lisp (dessins, modifications, etc...) ... en fait j'avais un doute sur : retour à la marque / puis le (END_PRG_ERR), mais ça à l'air de fonctionner ... Je suis prêt aux critiques... (heu... soyez sympa quand-même !!!!....) merci

merci (gile) mea-culpa, je me suis précipité sur les commandes -vl sans faire attention ... par souci de compréhension je vais revenir avec les (command ...) ... Par contre, concernant les undo : j'ai mis un (command "_.undo" "_b") , en pensant que _b" était pour "beginning" (retour)... donc je fait une "marque" en introduction du lisp (command "_.undo" "_m"), et si le message d'erreur se lance, le _undo "_b" fait un retour à ma marque précédente (en tout début de lisp donc), et rétablis toutes les modifs faites jusque-là, donc je n'ai pas besoin de lancer une procédure "compliqué" de remise de SCU ou autre, vu que le _undo le fait. ... j'ai tort ???

Salut, Avec un collègue nous avons réalisé des outils métiers permettant de "monter" des échafaudages en 3D, uniquement sous Autocad. Je l'utilise maintenant depuis un an à 90 % en 3D, (un peu de reste en 2D car la bibliothèque n'est pas complète) ... ... arrive pas à mettre une image ... [Edité le 5/7/2006 par Bred]

Salut, ce message fait suite à celui-ci http:// http://www.cadxp.com/XForum+viewthread-fid-100-tid-10775-page-2.html qui commençait à denenir "chargé" ... Le but de ce message étant de réaliser une routine de gestion des erreur+Remise initial de l'environnement en fin de programme... Donc, grâce à l'aide de [surligneur] (gile) et de Patrick_35[/surligneur], je suis arrivé à ceci (il ne reste plus grand chose de mon code original, mais c'est tellement bien ce que l'on me propose que je suis obligé de m'en servir) : ;;; INTRODUCTION du PROGRAMME - Redéfinition de *error* (defun INTRO_PRG_ERR () (SAVE&SET_VAR "cmdecho" 0) [b] (command "_.undo" "_m") ;;; marque undo[/b] (setq Sauv_EXerror *error*) ; enregistrement *error* autocad ; Enregistrement du environnement Actif (SCU / Calque /... (setq list_env_actif (list (getvar "ucsicon") (getvar "clayer") (getvar "orthomode") (getvar "osmode"))) ;Enregistrement su SCU (if (= "" (getvar "UCSNAME")) (setq scu_init (vla-add (vla-get-UserCoordinateSystems (vla-get-ActiveDocument (vlax-get-acad-object))) (vlax-3d-point (trans '(0 0 0) 1 0)) (vlax-3d-point (trans '(1 0 0) 1 0)) (vlax-3d-point (trans '(0 1 0) 1 0)) "SCU_init")) (setq scu_init (vla-get-ActiveUCS (vla-get-ActiveDocument (vlax-get-acad-object))))) ; Gestion des Erreur remplaçant celle d'Autocad (setq *error* REDEF_ERROR) ) ;;; ROUTINE de GESTION des ERREURS remplaçant celle d'Autocad (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) (princ (strcat "\nErreur: " msg)) ) (mapcar 'eval SavedSysVarLst) [b] (command "_.undo" "_b") [/b] ) ;;; ROUTINE ENREGISTREMENT VARIABLE+MODIF VARIABLE ((gile) cadXP) (defun SAVE&SET_VAR (var val) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst)) (if val (setvar var val))) ) ) ;;; FIN de PROGRAMME - ; retour *error* initial (defun END_PRG_ERR () ; Restauration des Variables modifiables enregistrer avec SAVE&SET_VAR (mapcar 'eval SavedSysVarLst) ; Restauration de l'environnement Actif enregistré (vla-put-activeucs (vla-get-activedocument (vlax-get-acad-object)) scu_init) (vla-delete scu_init) (setvar "ucsicon" (nth 0 list_env_actif)) (setvar "clayer" (nth 1 list_env_actif)) (setvar "orthomode"(nth 2 list_env_actif)) (setvar "osmode" (nth 3 list_env_actif)) (setq *error* Sauv_EXerror list_env_actif nil SavedSysVarLst nil Sauv_EXerror nil scu_init nil) (command "_.undo" "_end") ; fin undo ) ... il suffit de mettre (INTRO_PRG_ERR) en début de lisp, puis (END_PRG_ERR) en fin, en utilisant dans le lisp (SAVE&SET_VAR "variable" nouv-valeur) pour modifier des variables... ... et bien j'ai une erreur que je ne comprend pas : si je fais déroulé mon lisp jusqu'à la fin sans erreur, il en active une, et donc annule tout la dernière commande. L'erreur en ligne de commande est : ... merci de votre aide [Edité le 5/7/2006 par Bred]

... "dacodac" (gile) .... et pour suprimer le "SCU_init" en vl- ???

... bon ... ben je vais rester à mon traitement du SCU avec des (command) pour l'instant ... Par contre je chercher, je cherche, et je ne trouve ni dans l'aide, ni sur internet une manière de répondre à l'un de mes (ultra-nombreuse) question : - Est-il possible de faire une gestion d'erreur incluant un "malfonctionnement" du lisp... c'est à dire: en prenant l'exemple precedement cité, lorsque j'ai une action hors-affichage et qu'il me la refuse (quelquefois), j'ai le lisp qui continue quand même à défiler j'usqu'à la fin, en écrivant des " "comande" commande inconnu - appuyer sur F1..." ... j'aurais aimé qu'il revienne à mon "_undo", au lieu de faire n'importe quoi et de le laisser !!!... ... (gile) : concernant le lien internet que je donne, le sujet est en haut de page en fait ... [Edité le 4/7/2006 par Bred]

J'ai ça comme erreur : (sur la console) erreur: Erreur Automation Identificateur d’objet nul ... et je ne suis plus sur le même ordinateur, sauf qu'ils ont tous les 2 2006 ... Sur le Web : http:// http://groups.google.fr/group/autodesk.autocad.customization/browse_thread/thread/d8a42ff194b663c6/3b90a8df3c9b4a2b?lnk=st&q=vla-get-activeucs&rnum=2&hl=fr#3b90a8df3c9b4a2b ... je suis nul en englais... certainement que je n'ai pas compris mais j'ai l'impression qu'ils parle du nom du SCU ...

... ou alors tu est en "ombrage caché" dans l'espace papier... se mettre en "filaire 2D"...

Heu... merci Patrick... mais tes commandes vl ne fonctionne pas... j'ai fait une recherche sur internet, et je crois avoir compris (in english) que pour que ça fonctionne il faut avoir un SCU nommé... non ??? ... j'édite : Je confirme, après avoir tester, il faut que le SCU soit nommé... [Edité le 4/7/2006 par Bred]

Allez... je continu ... Je suis allez regarder les posts que vous me conseillez. Je ne comprends pas pourquoi l'utilisation de _undo avec une "marque" et un "retour" à la marque est moins bien que "Début" ou "fin" ... de plus le fait d'utiliser les marques évite le problème de la variable undoctl... non ???... Ce qui m'a amener à réfléchir sur l'affichage du "undo", vu que l'on change "cmdecho" après... donc ce que je fait c'est que dans la routine de gestion d'erreur, je remet (mapcar 'eval SavedSysVarLst) qui remettra toutes les valeurs des variables à l'état initial... (je sais, le fait de faire _undo le fait aussi... je double... c'est grave ???) ... donc voilà ce que ça donne : ;;; INTRODUCTION du PROGRAMME - Redéfinition de *error* (defun INTRO_PRG_ERR () (SAVE&SET_VAR "cmdecho" 0) (command "_.undo" "m") ;;;début "undo" (setq Sauv_EXerror *error*) ; enregistrement *error* autocad ; Traitements des variables habituels (à voir/à compléter/modifier) ; (SAVE&SET_VAR "orthomode" 0) ; Enregistrement du environnement Actif (SCU / Calque) (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir") (getvar "ucsicon") (getvar "clayer"))) ; Gestion des Erreur remplaçant celle d'Autocad (setq *error* REDEF_ERROR) ) ;;; ROUTINE de GESTION des ERREURS remplaçant celle d'Autocad (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) (princ (strcat "\nErreur: " msg)) ) (mapcar 'eval SavedSysVarLst) (command "_.undo" "r") ) ;;; ROUTINE ENREGISTREMENT VARIABLE+MODIF VARIABLE ((gile) cadXP) (defun SAVE&SET_VAR (var val) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst)) (if val (setvar var val))) ) ) ;;; FIN de PROGRAMME - ; retour *error* initial (defun END_PRG_ERR () ; Restauration des Variables modifiables enregistrer avec SAVE&SET_VAR (mapcar 'eval SavedSysVarLst) ; Restauration de l'environnement Actif enregistré (command "_ucs" "_w" "_ucs" "_3" "_non" '(0 0 0) "_non" (nth 1 list_env_actif) "_non" (nth 2 list_env_actif) "_ucs" "_o" "_non" (trans (nth 0 list_env_actif) 0 1)) (setvar "ucsicon" (nth 3 list_env_actif)) (setvar "clayer" (nth 4 list_env_actif)) (setq *error* Sauv_EXerror list_env_actif nil SavedSysVarLst nil Sauv_EXerror nil) (command "_.undo" "m") ; fin undo ) ... n'ayez pas peur de me réprimender si je fait n'importe quoi... je suis un "bidouilleur", et j'apprend beaucoup comme ça !!!...

Merci à vous deux ... mais quelque chose m'échappe ... Je comprends tout à fait que l'on puisse utiliser les _undo pour revenir à l'état initial en cas d'erreur ... mais si le lisp fonctionne, et que je veux automatiser aussi la remise en état général de l'environnement, je ne peux pas passer par _undo... non ??? (ou je ne suis pas au courant de toutes les options de _undo... il y aurait un "filtre" ???) ... ... quoi qu'il en soit, comme la remise en état initial de mon SCU me posait problème, j'ai fait un petit retour en arrière pour le gérer comme je le faisais precedement, en tenant compte des remarques que vous m'avez faits : ; Enregistrement du environnement Actif (SCU / Calque) (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir") (getvar "ucsicon") (getvar "clayer"))) (command "_ucs" "_w" "_ucs" "_3" "_non" '(0 0 0) "_non" (nth 1 list_env_actif) "_non" (nth 2 list_env_actif) "_ucs" "_o" (trans (nth 0 list_env_actif) 0 1)) (setvar "ucsicon" (nth 3 list_env_actif)) (setvar "clayer" (nth 4 list_env_actif))) ... ça à l'air de fonctionner ... j'étais parti au début sur un test pour savoir si le SCU était parralèle au SCG et si l'origine coincidait, mais la manip écrit ci-dessus répond à tous les cas ... (je crois ... jusqu'à maintenant en tout cas...) ... bon, ben il faut que je me replonge dans les _undo, et ai_setCmdEcho ... ... si vous avez une autre manière de gérér la remise initial du SCU, je suis preneur... (la manip de l'enregistrement du SCU actif à déjà été proposé par (gile) ... y'aurait bien un truc en vl- ... non ???... Patrick ???.... bon...) ...merci en tout cas de passer autant de temps sur mes problèmes !!!

Re... Patrick_35 : ... le "retour à la marque" (command "_undo" "r") répond justement à toutes ta remarques : j'ai dans l'idée que lorque ma gestion d'erreur se lance, elle retourne justement à l'"undo" qui est dans INTRO_PRG_ERR, et donc ramène toutes mes variables à leur état initial... le "retour" à la marque en vl- je ne le connais pas, donc j'ai laissé (command "_undo" "r")... .. de plus je ne vois pas pourquoi il me faut faire une "fin de undo" dans ma gestion d'erreur : si justement elle se lance, je ne veux pas arréter un groupe mais revenir en arrière au groupe précedent... mais j'avoue ne pas être certain de tout ça... .... Grrr... et un souci suplémentaire, un !... : la remise au SCU actif ne fonctionne pas dans tous la cas... si j'ai un SCU=SCG, et que je l'enregistre dans cette configuration, puis que je le modifie, le retour au scu actif fonctionne... par contre, si je fais le contraire, c.à.d. si je met le scu en "vrac", que je l'enregistre tel quel, que je le modifie (je le passe en général), le rétablissement ne fonctionne pas... j'ai beau cherché depuis quelques heures, je ne vois pas pourquoi!!! ... (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir")) (command "_.ucs""_3" "_non"(trans (nth 0 list_env_actif) 0 1) "_non" (trans (nth 1 list_env_actif) 0 1) "_non" (trans (nth 2 list_env_actif) 0 1)) [Edité le 4/7/2006 par Bred]

Alors... je me pencherais plus sur les fonctions entmake et autre plus tard, et je lancerais un nouveau post, mais là il faut que je revienne à la gestion d'erreur (si je commence à "m'éparpiller" je n'avancerais pas...) 1 - je n'ai pas trouvé ai_setCmdEcho.lsp ... 2 - ... donc j'ai utilisé les commandes vl- comme suit : ;;; INTRODUCTION du PROGRAMME - Redéfinition de *error* (defun INTRO_PRG_ERR () (setq Sauv_EXerror *error*) ; enregistrement *error* autocad (vla-startundomark (vla-get-activedocument (vlax-get-acad-object)));;;début "undo" ; Traitements des variables habituels (à compléter/modifier) (SAVE&SET_VAR "cmdecho" 0) ; Enregistrement du environnement Actif (SCU / Calque) (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir") (getvar "ucsicon") (getvar "clayer"))) ; Gestion des Erreur remplaçant celle d'Autocad (setq *error* REDEF_ERROR) ) ;;; ROUTINE de GESTION des ERREURS remplaçant celle d'Autocad (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) (princ (strcat "\nErreur: " msg)) ) (command "_undo" "r") ) ;;; Routine d'enregistrementde variable modifiable ((gile) cadXP) (defun SAVE&SET_VAR (var val) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst)) (if val (setvar var val))) ) ) ;;; FIN de PROGRAMME - ; retour *error* initial (defun END_PRG_ERR () ; Restauration des Variables modifiables enregistrer avec SAVE&SET_VAR (mapcar 'eval SavedSysVarLst) ; Restauration de l'environnement Actif enregistré (command "_.ucs""_3" "_non"(trans (nth 0 list_env_actif) 0 1) "_non" (trans (nth 1 list_env_actif) 0 1) "_non" (trans (nth 2 list_env_actif) 0 1)) (setvar "ucsicon" (nth 3 list_env_actif)) (setvar "clayer" (nth 4 list_env_actif)) (setq *error* Sauv_EXerror list_env_actif nil SavedSysVarLst nil Sauv_EXerror nil) (vla-endundomark (vla-get-activedocument (vlax-get-acad-object))); fin du "undo" ) ... he bien je lance un lisp avec (INTRO_PRG_ERR) au début ..... puis (END_PRG_ERR) à la fin, ça fonctionne 1fois... et ça me fait planter Autocad (!!!)... je ne vois pas pourquoi... 3 - Est-il possible de faire une gestion d'erreur incluant un "malfonctionnement" du lisp... c'est à dire: en prenant l'exemple precedement cité, lorsque j'ai une action hors-affichage et qu'il me la refuse (quelquefois), j'ai le lisp qui continue quand même à défiler j'usqu'à la fin, en écrivant des " "x" commande inconnu - appuyer sur F1..." ... j'aurais aimé qu'il revienne à mon "_undo", au lieu de faire n'importe quoi et de le laisser !!! ... merci de votre aide...

... heu... je ne comprend pas : Save&Set_var t'enregitre la variable active et te modifie la variable comme demandé... qu'est-ce qui t'empèches dans ta routine de faire un (setvar "osmode" valeur) ... quoiqu'il arrive ton Save&Set_var reinitialiseras la variables, même si celle-ci à la "même valeur" ... non ???

OK...OK... merci mais je ne suis vraiment pas assez bon pour ne plus avoir besoin de (command...)... J'ai écris dernièrement un lisp (grâce à l'aide des personnes de ce site) qui récupère des données dans un tableau Excel afin de dessiner des profilés métalliques en 3D... la récupération je la fait en vl (et c'est justement grâce à ton aide, Patrick) mais le dessin de la section en polyligne, j'ai été totalement incapable de le faire sans (command ...)... avec (entmake) je ne réussis qu'a dessiner un rond rouge (c'est l'exemple de l'aide d'Autocad), mais tracer une polyligne à plusieurs (trés nombreux) sommets, je me suis épuisé dessus, alors qu'avec (command) je l'ai fait "simplement" ..... par contre il est vrais que j'ai un bug de dessin "hors Ecran" ... mais ceci est une autre histoire et je me pencherais dessus... quand j'aurais le temp !!! Hop là, j'ai raté la réponse de (gile) en parrallèle de ma réponse donc "j'édite"... merci (gile), je vais allez voir ça... [Edité le 3/7/2006 par Bred]

Hé!Hé!Hé! ... elle voulait rester tranquille pour regarder le match !!! :D [Edité le 3/7/2006 par Bred]

Merci Patrick_35, j'ai compris l'utilité des commandes vl pour certaines choses, mais pourrais-tu m'expliquer le "bienfait" ce commandes vl ici, comparé à un "_undo" ?... merci encore

Ce ne serait pas quelqu'un qui travaille habituellement en bi-Ecran , et la fenêtre de personalisation s'affiche habituellement sur l'autre ??? (ça m'est déjà arrivé avec le gestionnaire de calque)...

Bon ben après reflexion je simplifie encore : c'est vraiment n'importe quoi de faire une marque d'annulation ET de restaurer les variables (l'annulation le fait trés bien, comme la routine de (gile) précedement cité le fait!!!...) Donc : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Introduction du programme - Redéfinition de *error* (defun INTRO_PRG_ERR () (setq Sauv_EXerror *error*) (command "_undo" "m");;;marque d'annulation ; Traitements des variables habituels (à compléter/modifier) (SAVE&SET_VAR "cmdecho" 0) ; Enregistrement du environnement Actif (SCU / Calque) (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir") (getvar "clayer"))) ; Gestion des Erreur remplaçant celle d'Autocad (setq *error* REDEF_ERROR) ) ;;; Routine de Gestion des Erreur remplaçant celle d'Autocad (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) (princ (strcat "\nErreur: " msg)) ) (command "_undo" "r") ) ;;; Routine d'enregistrementde variable modifiable ((gile) cadXP) (defun SAVE&SET_VAR (var val) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst)) (if val (setvar var val))) ) ) ;;; Fin de Programme - ; retour *error* initial (defun END_PRG_ERR () ; Restauration des Variables modifiables enregistrer avec SAVE&SET_VAR (mapcar 'eval SavedSysVarLst) ; Restauration de l'environnement Actif enregistré (command "_.ucs""_3" "_non"(trans (nth 0 list_env_actif) 0 1) "_non" (trans (nth 1 list_env_actif) 0 1) "_non" (trans (nth 2 list_env_actif) 0 1)) (setvar "clayer" (nth 3 list_env_actif)) (setq *error* Sauv_EXerror list_env_actif nil SavedSysVarLst nil Sauv_EXerror nil) (command "_undo" "m"); marque d'annulation ) ... c'est plus malin et avec moins "d'aller-retour" .... non ??? [Edité le 3/7/2006 par Bred]

Salut (gile) J'ai jeté un coup d'oeuil sur ton lisp que tu cites ci-dessus, et j'ai compris la manière dont tu utilises "_undo". Je touve ta routine SAVE&SET_VAR tellement bien et facile d'utilisation que je vais l'utiliser en priorité... (au sujet de cette routine d'ailleur, je n'utilise jamais le maillage 3D en 3D, mais les solides... donc je n'ai aucune remarque "constructive" à faire, à part que tu fais vraiment des truc épatant :D ...) Par contre l'utilisation de "-undo" m'a donné l'idée de mettre une "marque" en début de programme, et de la rappeler en cas d'erreur : ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Introduction du programme - Redéfinition de *error* (defun INTRO_PRG_ERR () (setq Sauv_EXerror *error*) (command "_undo" "m") (TRAIT_VAR_TYPE) (TRAIT_ENV_ACTIF) (setq *error* REDEF_ERROR) ) ;;; Routine de Gestion des Erreur remplaçant celle d'Autocad (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (princ) (princ (strcat "\nErreur: " msg)) ) (command "_undo" "r") (END_PRG_ERR) ) ... et de refaire une marque si le lisp arrive au bout ;;; Fin de Programme - ; retour *error* initial (defun END_PRG_ERR () (SET_VAR_SAVE) (SET_ENV_SAVE) (setq *error* Sauv_EXerror list_env_actif nil SavedSysVarLst nil Sauv_EXerror nil) (command "_undo" "m") ) (D'ailleur, je connais (getcname) pour traduire une commande, mais pour connaitre le choix de l'option en anglais, je ne sais pas comment faire...) De plus, j'ai rajouté dans mon introduction de gestion d'erreur, en + du SCU, le calque actif... je verrai à l'utilisation ce que je peux rajouter comme paramètres d'environnement suplémentaire...peut-être l'espace objet/papier, mais je n'en vois pas l'utilité pour l'instant. ;;; Enregistrement du environnement Actif (SCU / Calque) (defun TRAIT_ENV_ACTIF () (setq list_env_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir") (getvar "clayer"))) ) ;;; Restauration de l'Environnement (SCU / Calque) (defun SET_ENV_SAVE () (command "_.ucs""_3" "_non"(trans (nth 0 list_env_actif) 0 1) "_non" (trans (nth 1 list_env_actif) 0 1) "_non" (trans (nth 2 list_env_actif) 0 1)) (setvar "clayer" (nth 3 list_env_actif)) ) ... merci des remarques... [Edité le 3/7/2006 par Bred]

Salut, merci (gile) pour tes remarques. j'ai donc modifiés mes erreurs comme tu me l'as préconisé. Concernant le nombre de variables à "re-initialisé", j'ai simplifié l'"Enregistrement du SCU Actif" : ;;; Enregistrement du SCU Actif (defun TRAIT_SCU_ACTIF () (setq list_scu_actif (list (getvar "ucsorg") (getvar "ucsxdir") (getvar "ucsydir")) ) que je traite donc comme ceci : ;;; Restauration du SCU (defun SET_SCU_SAVE () (command "_.ucs""_3" "_non"(trans (car list_scu_actif) 0 1) "_non" (trans (cadr list_scu_actif) 0 1) "_non" (trans (caddr list_scu_actif) 0 1)) ) .. et je n'est donc "plus que" 3 variables à mettre à nil, que je fais comme tu me la proposer dans END_PRG_ERR : ;;; Fin de Programme - ; retour *error* initial (defun END_PRG_ERR () (SET_VAR_SAVE) (SET_SCU_SAVE) (setq *error* Sauv_EXerror list_scu_actif nil SavedSysVarLst nil Sauv_EXerror nil) ) ............................ ... je l'avais compris, mais je suis "faignant", et comme dans la plupart de mes lisps j'utilise quasiment toujour les même variables, je me craierais une liste "type"... juqu'au jour ou je me rendrais sompte que c'est inutile !!!... mais le fait de créér une liste type ne m'interdis pas dans mon programme de rajouter des variables ponctuellement grâce à ton (SAVE&SET_VAR ...) ... merci en tout cas pour ton aide (encore)... et tu peux continuer, ça ne me dérange pas du tout (;))... j'apprends énormément par ton aide (et aussi par l'aide d'autre de ce forum, je ne les oublies pas!!!)

... ben voilà à quoi j'arrive ... pour avis (surtout la manière de traiter le SCU!!!...) ;;; TRAITEMENT - EXEMPLES ;;;-------------------------- ; (defun c: mon_programme () ; (INTRO_PRG_ERR); ; ---- ( ... programme - modif variable avec (SAVE&SET_VAR "variable" nouv-valeur) ... ; ... modif sens SCU si besoin ...) . ; . ; fin de programme (END_PRG_ERR) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Traitements des variables habituels (à compléter) (defun TRAIT_VAR_TYPE () (SAVE&SET_VAR "cmdecho" 0) (SAVE&SET_VAR "attdia" 0) (SAVE&SET_VAR "attreq" 1) ) ;;; Enregistrement du SCU Actif (defun TRAIT_SCU_ACTIF () (setq orig (getvar "ucsorg") dirx (getvar "ucsxdir")) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Introduction du programme - Redéfinition de *error* (defun INTRO_PRG_ERR () (setq Sauv_EXerror *error*) (TRAIT_VAR_TYPE) (TRAIT_SCU_ACTIF) (setq *error* REDEF_ERROR) ) ;;; Routine d'enregistrementde variable modifiable ((gile) cadXP) (defun SAVE&SET_VAR (var val) (setq SavedSysVarLst nil) (cond ((getvar var) (setq SavedSysVarLst (cons (list 'setvar var (getvar var)) SavedSysVarLst)) (if val (setvar var val))) ) ) ;;; Restauration des Variables modifiables enregistrer avec SAVE&SET_VAR ((gile) cadXP) (defun SET_VAR_SAVE () (mapcar 'eval SavedSysVarLst) ) ;;; Restauration du SCU (defun SET_SCU_SAVE () (command "_ucs" "_w" "_ucs" "_o" orig "_ucs" "_3" '(0 0 0) dirx "") ) ;;; Routine de Gestion des Erreur remplaçant celle d'Autocad (setq msg "Fonction annulée") (defun REDEF_ERROR (msg) (if (or (= msg "Fonction annulée") (= msg "Function cancelled") (= msg "quitter / sortir abandon") (= msg "quit / exit abort")) (progn (princ "Action: ")(princ msg)(princ)) ) (SET_VAR_SAVE) (SET_SCU_SAVE) (setq *error* Sauv_EXerror) ; retour *error* initial ) ;;; Fin de Programme - ; retour *error* initial (defun END_PRG_ERR () (SET_VAR_SAVE) (SET_SCU_SAVE) (setq *error* Sauv_EXerror) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ... alors ????