Réacteur déjà présent ?

[Patrick_35]

Bonjour à tous

Voila un bout de code qui permet de faire un facteur d'échelle fixe lors de l'insertion d'un bloc

Il fonctionne à merveille, mais lorsque que j'ouvre un nouveau dessin, ce réacteur est toujours actif, et la variable qui le détermine est passé à nil, ce qui est normal pour un nouveau dessin.

Comment faire pour savoir si mon réacteur est actif afin d’éviter de le lancer une deuxième fois, ce qui à pour conséquence qu’il s’additionne à lui même :mad:

Il y a bien la possibilité de faire un (vlr-remove-all) mais ça supprime tous les réacteurs présents, ce que je voudrais éviter. Serge a bien donné une explication sur ce sujet, mais je n'arrive pas à la comprendre :casstet:

 

@+

(defun reacteur_echelle_inserer(rea cde / ent)
 (if (= (car cde) "INSERT")
   (progn
     (setq ent (entget (entlast)))
     (setq ent (subst (cons 41 (* (cdr (assoc 41 ent)) echelle_inserer)) (assoc 41 ent) ent))
     (setq ent (subst (cons 42 (* (cdr (assoc 42 ent)) echelle_inserer)) (assoc 42 ent) ent))
     (setq ent (subst (cons 43 (* (cdr (assoc 43 ent)) echelle_inserer)) (assoc 43 ent) ent))
     (entmod ent)
     (entupd (cdr (assoc -1 ent)))
   )
 )
 (princ)
)

(vl-load-com)
(if reacteur_echelle
 (vlr-remove reacteur_echelle)
)
(if (setq echelle_inserer (getreal "Facteur d'échelle pour les blocs : "))
 (setq reacteur_echelle (vlr-command-reactor nil '((:vlr-commandended . reacteur_echelle_inserer)))
)
(princ)

[Patrick_35]

Toujours pas de réponse ? Bon, bah tans pis, il va falloir trouver autre chose

 

@+

[Serge]

Patrick_35,

 

Il y a 2 choses. La première est qu'il est préférable de s'en tenir à une seule approche. Si on utilise du vla, le faire bout à bout. Si on utilise des ent (e.g. entmake, entmod et entupd), ne pas utiliser de vla. en autant que faire se peut.

 

Deuxièmement, si tu veux lire ton facteur d'échelle d'un dessin à l'autre, tu peux utiliser

 

(setq echelle_inserer (getreal "Facteur d'échelle pour les blocs : "))

(vl-propagate ' echelle_inserer)

 

Serge

 

 

 

[Serge]

Patrick_35,

 

Je n'avais pas tout lu. Tu peux te servir des fonctions du tableau noir (blackboard), une zone au dessus de tous les dessins. Un flag te permettra de savoir si le réacteur est chargé.

 

(vl-bb-ref 'variable) pour recevoir la valeur du blackboard.

(vl-bb-set 'variable valeur) pour transmettre la valeur au blackboard.

(vl-load-all "nom_de_fichier") pour charger dans tous les fichiers ouverts et à ouvrir (mais le mnl le fera aussi)

(vl-propagate 'variable) pour copier la valeur de la variable à tous les dessins ouverts et à ouvrir.

 

Serge

 

[Patrick_35]

Rien à dire, j’ai trouvé mon maître, merci Serge

 

Il y a 2 choses. La première est qu'il est préférable de s'en tenir à une seule approche. Si on utilise du vla, le faire bout à bout. Si on utilise des ent (e.g. entmake, entmod et entupd), ne pas utiliser de vla. en autant que faire se peut.

C’est juste pour le style je pense. Perso, je vais au plus simple et ça ne me dérange pas de mélanger autolisp et le visual lisp. Je me sers plus facilement d’un tblsearch que d’un vlax-for

 

@+

[LUDWIG]

Je sais que le sujet est vieux et mon post peut être hors sujet (je ne parcours ce sujet que maintenant car je m'intéresse aux réacteurs). J'ai trouvé par hasard ça dans l'aide de autocad 2005 et j'ai l'impression que ç peut aider :

 

Les réacteurs sont extrêmement actifs. Si vous concevez une application ayant recours à eux, vous risquez de passer beaucoup de temps à réparer les pannes de votre programme et même d'AutoCAD. Il peut être utile de disposer d'un outil permettant de supprimer, en cas de nécessité, tous les réacteurs que vous avez ajoutés.

 

Le fichier gpreact.lsp contient une fonction gp:clean-all-reactors qui n'a pas de réelle action intrinsèque. En revanche, elle appelle la fonction CleanReactors. Ajoutez cette fonction à votre fichier utils.lsp en copiant le code suivant à la fin du fichier :

 

;;;--------------------------------------------------------------;

;;; Function: CleanReactors ;

;;;--------------------------------------------------------------;

;;; Description: General utility function used for cleaning up ;

;;; reactors. It can be used during debugging, as ;

;;; well as cleaning up any open reactors before ;

;;; a drawing is closed. ;

;;;--------------------------------------------------------------;

(defun CleanReactors ()

(mapcar 'vlr-remove-all

'(:VLR-AcDb-reactor

:VLR-Editor-reactor

:VLR-Linker-reactor

:VLR-Object-reactor

)

)

)

 

Pitié ne me blâmez pas si je suis à côté de la plaque !

[Patrick_35]

Merci Ludwig

Effectivement ce n'est pas récent et la solution que tu proposes efface tous les réacteurs, pas uniquement celui qui peut m'intéresser

Le lisp ci-joint à un exemple qui supprime que le/les réacteur(s) souhaité(s)

 

(defun Attributs_ini(Rea Cde)
 (setq dernier_ent (entlast))
)

(defun Attributs_xyz(Rea Cde / bl js n xyz)
 (cond
   ((or (eq (car Cde) "MOVE") (eq (car Cde) "STRETCH"))
     (setq js (ssget "_p"))
   )
   ((or (eq (car Cde) "GRIP_MOVE") (eq (car Cde) "GRIP_STRETCH"))
     (setq js (cadr (ssgetfirst)))
   )
   ((eq (car Cde) "INSERT")
     (setq js (ssadd))
     (ssadd (entlast) js)
   )
   ((eq (car Cde) "COPY")
     (setq js (ssadd) n (entnext dernier_ent))
     (while n
       (ssadd n js)
       (setq n (entnext n))
     )
   )
   ((eq (car Cde) "UCS")
     (setq js (ssget "x" (list (cons 0 "INSERT") (cons 2 Nom_bloc))))
   )
 )
 (if js
   (progn
     (setq n 0)
     (while (ssname js n)
       (setq bl (entget (ssname js n)))
       (if (and (eq (cdr (assoc 0 bl)) "INSERT") (eq (strcase (cdr (assoc 2 bl))) (strcase Nom_bloc)))
         (if (cdr (assoc 66 bl))
           (progn
             (setq xyz (trans (cdr (assoc 10 bl)) (cdr (assoc -1 bl)) 1))
             (while (not (eq (cdr (assoc 0 bl)) "SEQEND"))
               (if (eq (cdr (assoc 0 bl)) "ATTRIB")
                 (cond
                   ((eq (strcase (cdr (assoc 2 bl))) (strcase Eti_X))
                     (setq bl (subst (cons 1 (rtos (car xyz))) (assoc 1 bl) bl))
                     (entmod bl)
                     (entupd (cdr (assoc -1 bl)))
                   )
                   ((eq (strcase (cdr (assoc 2 bl))) (strcase Eti_Y))
                     (setq bl (subst (cons 1 (rtos (cadr xyz))) (assoc 1 bl) bl))
                     (entmod bl)
                     (entupd (cdr (assoc -1 bl)))
                   )
                   ((eq (strcase (cdr (assoc 2 bl))) (strcase Eti_Z))
                     (setq bl (subst (cons 1 (rtos (caddr xyz))) (assoc 1 bl) bl))
                     (entmod bl)
                     (entupd (cdr (assoc -1 bl)))
                   )
                 )
               )
               (setq bl (entget (entnext (cdr (assoc -1 bl)))))
             )
           )
         )
       )
       (setq n (1+ n))
     )
   )
 )
 (princ)
)

(defun c:spt(/ i j n)
 (if (setq i (vlr-reactors :vlr-Command-Reactor))
   (progn
     (setq n 1 i (nth n (car i)))
     (while i
       (setq j nil)
       (if (or (eq (cdr (car (vlr-reactions i))) 'ATTRIBUTS_XYZ) (eq (cdr (car (vlr-reactions i))) 'ATTRIBUTS_INI))
         (setq j i)
       )
       (if j
         (vlr-remove j)
         (setq n (1+ n))
       )
       (if (setq i (vlr-reactors :vlr-Command-Reactor))
         (setq i (nth n (car i)))
       )
     )
     (if mrea_mpt
       (princ (strcat "\n\tDésactivation de la mise à jour XYZ du bloc " Nom_bloc "."))
     )
     (setq mrea_mpt nil)
   )
 )
 (princ)
)

(defun c:mpt()
 (if (not mrea_mpt)
   (progn
     (c:spt)
     (vlr-command-reactor nil '((:vlr-commandwillstart . Attributs_ini)))
     (setq mrea_mpt (vlr-command-reactor nil '((:vlr-commandEnded . Attributs_xyz))))
     (princ (strcat "\n\tActivation de de la mise à jour XYZ du bloc " Nom_bloc "."))
   )
   (princ (strcat "\n\tLa mise à jour XYZ du bloc " Nom_bloc " est déjà activée."))
 )
 (princ)
)

(vl-load-com)
(setq Nom_bloc "XY"
     Eti_X    "X"
     Eti_Y    "Y"
     Eti_Z    "Z")
(princ (strcat "\n\tPour activer la mise à jour XYZ du bloc " Nom_bloc ", lancez la commande MPT.\n\tPour revenir à la normale, faites la commande SPT."))
(princ)