Attacher des réacteurs à un dessin AutoCAD

< retour


Un réacteur est un objet que vous attachez aux objets dans les dessins d'AutoCAD afin d'avoir un message qui prévient votre application lorsqu'un événement qui vous intéresse se produit.


Par exemple, si un utilisateur déplace une entité dont votre application à attacher un réacteur, votre application recevra un message qui préviendra du déplacement de cette entité.


Un réacteur communique avec votre application en appelant une fonction que vous avez associé au réacteur. Telles que les fonctions rétro-appel(callback). Il n'y a rien de particulièrement exceptionnel dans ces fonctions callback, elles sont comme les autres fonctions que vous écrivez avec Visual LISP. Elles deviennent des fonctions callback quand vous les attachez aux événements d'un réacteur.


Si vous êtes débutant, ne vous inquiétez pas si vous échouez à la première tentative. Considérez ceci comme un avant-goût des fonctions très puissantes mais techniquement plus complexes de Visual LISP®.


Types de réacteurs et événements

Il y a plusieurs types de réacteurs AutoCAD, chacun correspondant à des catégories générales d'événements auxquelles votre application correspond :


Réacteurs d'éditeur (:VLR-Editor-Reactor)
   Notifient votre application chaque fois qu'une commande AutoCAD est appelée.


Réacteurs d'éditeur de liens (:VLR-Linker-Reactor)
   Notifient votre application chaque fois qu'une application ObjectARX® est chargée ou déchargée.


Réacteurs de base de données (:VLR-AcDb-Reactor)
   Correspondent à des entités ou à des objets spécifiques à l'intérieur d'une base de données. Exemple : lorsqu'un objet a été ajouté a la base de données (le dessin).


Réacteurs de documents (:VLR-DocManager-Reactor)
   En mode MDI, notifient votre application d'un changement apporté au document de dessin en cours, tel que l'ouverture d'un nouveau document de dessin, l'activation d'une autre fenêtre de document ou la modification de l'état de verrouillage d'un document.


Réacteurs d'objet (:VLR-Object-Reactor)
   Vous informent chaque fois qu'un objet est modifié, copié ou supprimé.


La fonction vlr-types retourne une liste de types de réacteurs Visual LISP.


Pour chaque type de réacteur il y a plusieurs événements rétro-appel qui avertissent votre application sous des circonstances spécifiques. Par exemple, quand un dessin est sauvegardé, l'événement :vlr-beginSave se produit, le dessin est sauvegardé, et finalement l'événement :vlr-saveComplete se produit.


Dans un dessin contenant des réacteurs, c'est à vous de déterminer les événements qui vous intéresse. Et d'écrire les fonctions rétro-appel qui les déclenchent lorsque ces événements se produisent.


La fonction vlr-reaction-names retourne une liste de tous les événements possibles pour un type de réacteur donné :


Par exemple :
_$ (vlr-reaction-names :VLR-Editor-Reactor)
(:vlr-unknownCommand :vlr-commandWillStart :vlr-commandEnded....

Vous pouvez imprimer une liste de tous les événements des réacteurs possibles, classés par type de réacteur, par chargement et exécution du code suivant dans Visual LISP


(progn
   (
foreach rtype (vlr-types)
     (terpri)
     (princ rtype)
     (foreach rnom (vlr-reaction-names rtype)
      (terpri)
        (princ "\t")
        (princ rnom)
     )
   )

   (princ)
)

Définition des fonctions rétro-appel (callback)

Une fonction rétro-appel (callback) est une fonction AutoLISP normale, que vous définissez en utilisant defun. Après avoir défini une fonction rétro-appel (callback), vous liez la fonction à un événement par la création d'un objet réacteur.


Notez que quelques fonctions AutoLISP ne peuvent pas être utilisées dans une fonction rétro-appel (callback). Vous ne pouvez pas appeler des commandes AutoCAD utilisant la fonction command. Notez aussi que pour accéder à des objets d'un dessin, vous devez utiliser les fonctions ActiveX (vla-*); entget et entmod n'est pas permis dans une fonction rétro-appel (callback).


Création de Réacteurs

Pour ajouter un réacteur à votre application, vous avez, tout d'abord, besoin d'écrire une fonction rétro-appel (callback) qui exécute les tâches voulues lors de l'événement du réacteur. Par exemple, voici une fonction nommée sauveDwgInfo qui affiche le chemin d'accès au fichier et sa taille. Cette fonction sera attachée à un réacteur de l'éditeur qui le lancera quand un dessin AutoCAD est sauvé:


(defun sauveDwgInfo (appel-reactor commandInfo / nomDwg TailleFich)
   (setq nomDwg  (cadr commandInfo)
           TailleFich (vl-file-size nomDwg)
   )
   (alert (strcat "La taille du fichier " nomDwg " = " (itoa TailleFich) " Octets."))
   (princ)
)

La fonction retrouve le nom du dessin à partir du paramètre commandInfo, puis utilise la fonction vl-file-size pour retrouver la taille du fichier dessin. Les informations sont ensuite affichées dans une boîte alerte dans la fenêtre d'AutoCAD.


Les réacteurs de l'éditeur contrôlent les commandes AutoCAD tel que la commande Save. L'expression suivante définit un réacteur de l'éditeur qui répond à un utilisateur émettant une sauvegarde par l'appel de la fonction sauveDwgInfo :


_$(vlr-editor-reactor nil '((:vlr-saveComplete . sauveDwgInfo)))

Le premier argument est nil parce qu'il n'y a pas de données spécifiques à l'application pour l'attacher à ce réacteur. Le deuxième argument est une liste constituée de listes de couples. Chaque liste de couple identifie un événement associé au réacteur, et la fonction rétro-appel (callback) pour être exécutée en réponse à cet événement. Dans ce cas seulement un événement,: vlr-save-Complete, réagira.


Notez qu'un réacteur de l'éditeur est averti chaque fois que l'utilisateur lance une commande, à partir de la ligne de commande d'AutoCAD, d'un menu, d'une barre d'outils, ou à travers un programme LISP. Donc, la fonction rétro-appel (callback) pour ce réacteur de l'éditeur a besoin de déterminer précisément ce à quoi il répond. Dans l'exemple précédent, sauveDwgInfo vérifie simplement la commande Save.