Bubble pour AutoCAD
L'auxiliaire d'informations gratuit pour les utilisateurs d'AutoCAD

Comment puis-je écrire un module pour Bubble ? C'est facile si vous connaissez Autolisp. Suivez ces instructions : Les modules ne fonctionnent que sur AutoCAD 2000 et postérieurs. Pas sur R14. Pas sur LT :

1. Créez un nouveau fichier Autolisp. Ajoutez votre en-tête (un commentaire) :

;; -----------------------------------------------------------------
;; Bubble 2 : Mon module Bubble 1.0 - (c) 2002 Asuni CAD
;; -----------------------------------------------------------------

2. Ajoutez cette fonction de chargement TELLE QUELLE, vous ne devez pas la modifier :

;; Il s'agit de la fonction de chargement
;; NE PAS MODIFIER
(defun ASUNI:BUBBLE:AddPlugIn (PlgInFunction)
  (if ASUNI:BUBBLE:GETDATA
    (setq ASUNI:BUBBLE:GETDATA
      (append ASUNI:BUBBLE:GETDATA
        (list
          '(setq temp ASUNI:BUBBLE:DATA)
          (list (read PlgInFunction) 'handle)
          '(setq ASUNI:BUBBLE:DATA 
             (append temp '("[-]") ASUNI:BUBBLE:DATA)
          )
          '(princ)
        )
      )
    )
    (progn
      (defun-q ASUNI:BUBBLE:GETDATA (handle / temp)
        (setq ASUNI:BUBBLE:OBJECT nil)
      )
      (setq ASUNI:BUBBLE:GETDATA
        (append ASUNI:BUBBLE:GETDATA
          (list
            (list (read PlgInFunction) 'handle)
            '(princ)
          )
        )
      )
    )
  )
)

3. Vous devez écrire ensuite la fonction qui fait le travail. Le nom de la fonction devra être précédée de "ASUNI:BUBBLE:" comme dans l'exemple. Ceci permet d'éviter toute confusion avec d'autres fonctions Autolisp. 

DONNÉES ENVOYÉES À LA FONCTION :

Cette fonction reçoit un paramètre appelé "handle" qui contient le handle de l'entité que Bubble essaie de montrer. 

DONNÉES  RENVOYÉES PAR LA FONCTION À BUBBLE :

Cette fonction renvoie l'information à Bubble sous forme de 2 variables :

ASUNI:BUBBLE:DATA - L'information à montrer par Bubble, sous forme d'une liste de listes constituée du nom et de la valeur de la propriété. 
ASUNI:BUBBLE:OBJECT - Le nom de l'objet. Si vous donnez un nom à l'objet, seule votre information et les propriétés communes sont montrées pour cet objet. Si cette variable est nulle, les données sont ajoutées à la fin de la liste d'informations actuelle.

(defun ASUNI:BUBBLE:MyBpiPlugIn (handle / ename eget p1 p2)
  (setq ename (handent handle))
  (setq ASUNI:BUBBLE:DATA nil)
  ;; s'il s'agit d'une ligne
  (if (and ename (= "LINE" (cdr (assoc 0 (setq eget (entget ename))))))
    (progn
      (setq p1 (cdr (assoc 10 eget)))
      (setq p2 (cdr (assoc 11 eget)))
      (setq ASUNI:BUBBLE:OBJECT "MyLine")
      (setq ASUNI:BUBBLE:DATA
        (list
          (if ASUNI:BUBBLE:MyBpi:MyLine:DeltaX
            (strcat "DeltaX: " (rtos (abs (- (car p2) (car p1)))))
          )
          (if ASUNI:BUBBLE:MyBpi:MyLine:DeltaY
            (strcat "DeltaY: " (rtos (abs (- (cadr p2) (cadr p1)))))
          )
          (if ASUNI:BUBBLE:MyBpi:MyLine:DeltaZ
            (strcat "DeltaZ: " (rtos (abs (- (caddr p2) (caddr p1)))))
          )
	)
      )
    )
  )
  (princ)
)
 

4. Nous définissons ensuite la structure de données nécessaire pour que Bubble puisse afficher les propriétés de notre module dans la fenêtre de Bubble, afin que l'utilisateur puisse sélectionner les informations à montrer. Il s'agit d'une liste comprenant les composants suivants :

• Un code (handle) du module : Bubble l'utilise pour créer les variables de données d'Autolisp. Ce doit aussi être le nom du dossier dans le répertoire des modules. 
• Une description (utilisée dans la fenêtre des propriétés).
• Le nom de l'icône du module. (Ce paramètre est facultatif, s'il n'est pas indiqué, une icône par défaut est utilisée.)
• Une liste pour chaque objet contenant :
• Code de l'objet
• Nom de l'icône de l'objet (fichier ICO) à associer avec l'objet dans la fenêtre de propriétés. (Ce paramètre est facultatif, s'il n'est pas indiqué, une icône par défaut est utilisée)
• Une liste avec les couples : code de la propriété et valeur réelle (T = activée, false = désactivée)

Bubble crée des variables basées sur les codes avec le système de nom suivant :

ASUNI:BUBBLE:[CodeModule]:[CodeObjet]:[CodePropriété]

La valeur est T, si la propriété est activée ou nil si la propriété est désactivée.

(setq ASUNI:BUBBLE:PROPS
 '(("MyBpi" "Mon module Bubble"
    ("MyLine" "MaLigne.ico"
      ("DeltaX" T)
      ("DeltaY" T)
      ("DeltaZ" T)
    )
  ))
)

Dans cet exemple, Bubble créer les variable Autolisp suivantes :

• ASUNI:BUBBLE:MyBpi:MaLigne:DeltaX
• ASUNI:BUBBLE:MyBpi:MaLigne:DeltaY
• ASUNI:BUBBLE:MyBpi:MaLigne:DeltaZ

qui sont utilisées dans la fonction ASUNI:BUBBLE:MyBpiPlugIn .

5. La dernière fonction relie le module et Bubble. Elle indique à Bubble les informations sur le module. Elle ajoute tout d'abord notre module à la liste getdata (pour que tous les modules obtiennent des informations sans créer de conflit avec les autres), en utilisant la fonction ASUNI:BUBBLE:AddPlugIn, définie auparavant dans le fichier lisp (1er point). La dernière fonction indique à Bubble "Je suis là". ASUNI:BUBBLE:LoadProps 

;; Le chargement est alors exécuté :
(if (null ASUNI:BUBBLE:MyBpi:Loaded)
  (progn
    (princ "\nBubble 2: Mon module Bubble 1.0 - (c) 2001 Asuni CAD")
    ;; Pour éviter plusieurs chargements
    (setq ASUNI:BUBBLE:MyBpi:Loaded T)
    ;; Pour ajouter la fonction à la liste GetData :
    (ASUNI:BUBBLE:AddPlugIn "ASUNI:BUBBLE:MyBpiPlugIn")
    ;; Pour charger les propriétés dans Bubble :
    (ASUNI:BUBBLE:LoadProps)
  )
)