Tutoriel Autodesk® en français: développement d’une application Visual LISP pour AutoCAD

Développement Programmation AutoLISP
, ,
1

Tutoriel Autodesk® en français guidant l’utilisateur à travers le développement d’une application Visual LISP pour AutoCAD®, en se concentrant sur la création d’un outil de dessin de sentier de jardin. Le texte aborde l’organisation du code, la conception d’une interface utilisateur via des boîtes de dialogue, la manipulation d’entités AutoCAD® en utilisant diverses méthodes (ActiveX, entmake, command), et l’implémentation de fonctionnalités interactives avancées à l’aide de réacteurs. Le document fournit des instructions détaillées, des exemples de code, et des explications sur le débogage et le test de l’application en cours de construction.

didactitiel-visual-lisp-autocad-français
didactitiel-visual-lisp-autocad-français598×637 87.7 KB

vlisptut.pdf (3,3 Mo)

Analyse du Didacticiel Visual LISP​:trade_mark:Autodesk®

Introduction

Ce document présente une analyse détaillée du didacticiel « DIDACTICIEL VISUAL LISP​:trade_mark: » d’Autodesk®, Inc. Copyright © 2000. Il met en lumière les thèmes principaux, les idées importantes et les faits marquants contenus dans les extraits fournis.

Thèmes Principaux

Le didacticiel se concentre sur l’apprentissage et l’utilisation de Visual LISP (VLISP) pour développer des applications AutoLISP personnalisées, illustré par la création d’une application de dessin de sentier de jardin. Les thèmes principaux abordés sont:

  • Introduction à Visual LISP et à son environnement de développement intégré (IDE): Familiarisation avec les outils de VLISP pour l’édition, le débogage et l’exécution de code AutoLISP.

  • Principes fondamentaux de la programmation en AutoLISP: Définition de fonctions, utilisation de variables (locales et globales), structures de contrôle (conditionnelles if, boucles while), manipulation de listes (notamment les listes associatives).

  • Interaction avec AutoCAD® via AutoLISP: Création et modification d’entités AutoCAD® (lignes, polylignes, cercles) en utilisant différentes méthodes: fonctions AutoLISP standard (entmake), automatisation ActiveX (vla-), et la ligne de commande d’AutoCAD®.

  • Débogage de code Visual LISP: Utilisation des outils de débogage de VLISP tels que les points d’arrêt, l’espion de variables, et le parcours du code pas à pas pour identifier et corriger les erreurs.

  • Conception d’interfaces utilisateur avec les boîtes de dialogue (DCL): Création et gestion de boîtes de dialogue personnalisées pour interagir avec l’utilisateur et recueillir des informations.

  • Utilisation des réacteurs: Implémentation de réacteurs pour rendre les applications plus interactives et réactives aux événements se produisant dans AutoCAD® (modification d’entités, exécution de commandes).

  • Organisation de projets Visual LISP: Structuration du code en fichiers multiples et gestion des projets pour faciliter le développement d’applications plus complexes.

Idées et Faits Importants par Section

Introduction et Mise en Route (Pages 2-13)

  • Le didacticiel présente une approche pratique de l’apprentissage de Visual LISP à travers la création d’une application spécifique: un générateur de sentier de jardin.

  • Il décrit le fonctionnement attendu de l’application: dessiner un contour, demander les dimensions des dalles et les espacer de manière alternée à l’intérieur du contour.

  • La section introduit l’environnement VLISP et explique ce qui se passe lorsque VLISP attend qu’AutoCAD® lui rende le contrôle.

  • Les premières étapes pour créer un nouveau fichier dans VLISP et y entrer du code AutoLISP sont détaillées, avec l’exemple de la fonction principale C:GPath.

;;; Function C:GPath is the main program function and defines the
;;; AutoCAD GPATH command.
(defun C:GPath ()
  ;; Ask the user for input: first for path location and
  ;; direction, then for path parameters. Continue only if you have
  ;; valid input.
  (if (gp:getPointInput)
     ;
     (if (gp:getDialogInput)
       (progn
         ;; At this point, you have valid input from the user.
         ;; Draw the outline, storing the resulting polyline
         ;; "pointer" in the variable called PolylineName.
         (setq PolylineName (gp:drawOutline))
         (princ "\nThe gp:drawOutline function returned <")
         (princ PolylineName)
         (princ ">")
         (Alert "Congratulations - your program is complete!")
       )
     (princ "\nFunction cancelled.")
       )
    (princ "\nIncomplete information to draw a boundary.")
  )
  (princ)  ; exit quietly
)
;;; Display a message to let the user know the command name.
(princ "\nType gpath to draw a garden path.")
(princ)
  • L’importance du formatage du code VLISP pour la lisibilité et la détection rapide des erreurs est soulignée. VLISP utilise la coloration syntaxique pour distinguer les différents éléments du langage.

Utilisation des Outils de Débogage Visual LISP (Pages 15-33)

  • Cette leçon aborde la distinction entre les variables locales et globales, expliquant leur portée et leur durée de vie.

[!note]
« Les variables globales sont accessibles par l’intermédiaire de toutes les fonctions chargées dans le document (un dessin AutoCAD®). Elles peuvent conserver leur valeur une fois que le programme qui les a définies s’achève. »

[!note]
« Une fois la fonction gp:getPointInput complète, les variables, tout comme les valeurs qui leur sont affectées, n’existent plus. »

  • L’utilisation de variables locales dans la fonction gp:getPointInput est illustrée, avec la définition des variables / StartPt EndPt HalfWidth.

  • Le concept de listes associatives pour grouper des données est introduit, montrant comment elles sont utilisées pour stocker les informations du sentier (gp_PathData). L’ordre des éléments dans une liste associative n’est pas significatif, contrairement aux listes ordinaires.

    ((10 4.46207 4.62318 0.0) (11 7.66688 4.62318 0.0) (40 . 1.018248))

    Ici, 10, 11, et 40 sont des clés identifiant respectivement le point de départ, le point d’arrivée et la largeur.

  • L’outil Espion de VLISP est présenté comme un moyen d’examiner les variables en détail, y compris les variables locales pendant l’exécution d’une fonction.

  • La mise en place de points d’arrêt pour interrompre l’exécution du code et examiner l’état des variables est expliquée.

[!note]
« Un point d’arrêt est un symbole (point) que vous placez dans le code source pour indiquer l’emplacement où vous souhaitez que l’exécution du pro-gramme s’interrompe. »

  • Les différentes actions possibles lors d’une interruption (parcourir le code pas à pas, examiner les variables) sont détaillées.

  • Il est démontré comment sortir d’une fonction en cours de débogage (Pas à pas sortant) et comment les variables locales sont réinitialisées à nil une fois la fonction terminée.

Dessin du Contour du Sentier (Pages 35-51)

  • Cette leçon se concentre sur la création des fonctions utilitaires nécessaires au dessin du contour du sentier.

  • La fonction Degrees->Radians pour convertir les angles est introduite.

    (defun Degrees->Radians (numberOfDegrees)
  (* pi (/ numberOfDegrees 180.0))
)

  • Une fonction 3dPoint->2dPoint est créée pour convertir des points 3D (renvoyés par getpoint) en points 2D.

  • Différentes méthodes pour dessiner des entités AutoCAD® sont mentionnées: en utilisant les fonctions ActiveX (vla-), la fonction entmake, et la ligne de commande d’AutoCAD®.

  • La fonction gp:drawOutline est développée pour dessiner le contour rectiligne du sentier, en utilisant la fonction polar pour calculer les coordonnées des sommets.

[!note]
« La fonction polar renvoie un point 3D à une certaine distance et sous un certain angle par rapport à un point donné. »

  • L’utilisation de listes associatives (BoundaryData) pour transmettre les paramètres aux fonctions est illustrée.

  • Le code ActiveX dans gp:drawOutline est expliqué, incluant l’obtention d’un pointeur vers l’espace objet (*ModelSpace*), la construction d’un réseau de points de polyligne, et la création d’un variant à partir de la liste de points pour les fonctions ActiveX.

  • Les variables locales utilisées dans gp:drawOutline sont listées.

Création d’un Projet et Ajout de l’Interface (Pages 53-71)

  • La leçon aborde la décomposition du code en éléments modulaires et l’utilisation de projets Visual LISP (.prj) pour organiser les fichiers.

  • L’ajout d’une interface de boîte de dialogue pour recueillir les paramètres des dalles (taille et espacement) est détaillé.

  • La création de la boîte de dialogue à l’aide du langage DCL (Dialog Control Language) est expliquée, avec un exemple de code DCL.

[!note]
« Une définition par le langage DCL ne fait que créer une boîte de dialogue inerte. Vous devez connecter cette boîte de dialogue inerte à votre code dynamique AutoLISP à l’aide de la fonction action_tile… »

  • Les étapes pour enregistrer un fichier DCL (gpdialog.dcl) et afficher un aperçu de la boîte de dialogue sont fournies.

  • L’interaction avec la boîte de dialogue à partir du code AutoLISP est décrite, incluant le chargement du fichier DCL (load_dialog), le chargement d’une boîte de dialogue spécifique en mémoire (new_dialog), et l’initialisation des valeurs par défaut (set_tile).

  • L’assignation d’actions aux composants de la boîte de dialogue à l’aide de la fonction action_tile est expliquée, montrant comment récupérer les valeurs entrées par l’utilisateur (get_tile, atof) et fermer la boîte de dialogue (done_dialog).

    (action_tile
  "accept"
  (strcat "(progn (setq tileRad (atof (get_tile \"gp_trad\")))"
    "(setq tileSpace (atof (get_tile \"gp_spac\")))"
    "(done_dialog) (setq UserClick T))"
  )
)

  • Le déchargement de la boîte de dialogue (unload_dialog) est également mentionné.

  • L’assemblage du code pour la fonction gp:getDialogInput est effectué.

Ajout des Dalles (Pages 73-86)

  • Cette leçon se concentre sur l’implémentation de la logique et de la géométrie nécessaires pour dessiner les dalles à l’intérieur du contour du sentier.

  • Les nouvelles fonctionnalités d’édition de VLISP (appariement des parenthèses, achèvement automatique des mots, aide sur les fonctions) sont présentées.

  • La logique pour espacer et dessiner les dalles en rangées alternées est expliquée à travers un pseudo-code.

  • La fonction gp:Calculate-and-Draw-Tiles est introduite, qui calcule la position des dalles et appelle une autre fonction (gp:calculate-Draw-TileRow) pour dessiner chaque rangée.

    (defun gp:Calculate-and-Draw-Tiles (BoundaryData / PathLength
         TileSpace TileRadius SpaceFilled SpaceToFill
         RowSpacing offsetFromCenter
         rowStartPoint pathWidth pathAngle
         ObjectCreationStyle   TileList)
  (setq PathLength    (cdr (assoc 41 BoundaryData))
        TileSpace     (cdr (assoc 43 BoundaryData))
        TileRadius    (cdr (assoc 42 BoundaryData))
        SpaceToFill   (- PathLength TileRadius)
        RowSpacing    (* (+ TileSpace (* TileRadius 2.0))
                       (sin (Degrees->Radians 60))
                    ) ;_ end of *
        SpaceFilled   RowSpacing
        offsetFromCenter 0.0
        offsetDistance (/ (+ (* TileRadius 2.0) TileSpace) 2.0)
        rowStartPoint  (cdr (assoc 10 BoundaryData))
        pathWidth      (cdr (assoc 40 BoundaryData))
        pathAngle      (cdr (assoc 50 BoundaryData))
        ObjectCreationStyle (strcase (cdr (assoc 3 BoundaryData)))
  ) ;_ end of setq
  ;; ... (suite du code) ...
)

  • La fonction gp:calculate-Draw-TileRow est détaillée, montrant comment elle calcule le centre des dalles et les dessine en utilisant différentes méthodes de création d’objets (ActiveX, entmake, command) en fonction de la valeur de ObjectCreationStyle.

  • L’utilisation d’une instruction cond pour choisir la fonction de création d’objet appropriée est illustrée.

  • Le test du code en chargeant les fichiers de projet et en exécutant la commande gpath avec différentes méthodes de création d’entités est suggéré.

Utilisation des Réacteurs (Pages 87-99)

  • Cette leçon introduit le concept de réacteurs AutoCAD®, qui permettent à une application d’être notifiée lorsque des événements spécifiques se produisent dans AutoCAD®.

[!note]
« Les réacteurs permettent à votre application d’être avertie par AutoCAD® lorsque des événements particuliers surviennent. »

  • Les principes de base et les types de réacteurs (réacteurs d’objet, réacteurs de commandes, réacteurs de dessin, etc.) sont présentés.

  • La conception de réacteurs pour l’application de sentier de jardin est abordée, en se concentrant sur la réaction à l’effacement du contour et à la fin des commandes.

  • La planification des fonctions de rétro-appel (callbacks) associées aux réacteurs est décrite.

  • L’enregistrement d’un réacteur de commandes pour détecter la fin des commandes (:vlr-commandEnded) et d’un réacteur de dessin pour effectuer un nettoyage à la fermeture du dessin (:vlr-beginClose) est illustré dans la fonction C:GPath.

    ;; Next, register a command reactor to adjust the polyline
;; when the changing command is finished.
(if (not *commandReactor*)
  (setq *commandReactor*
    (VLR-Command-Reactor
      nil          ; No data is associated with the command reactor
      '(
        (:vlr-commandWillStart . gp:command-will-start)
        (:vlr-commandEnded . gp:command-ended)
      )
    ) ;_ end of vlr-command-reactor
  )
)
;; The following code removes all reactors when the drawing is
;; closed. This is extremely important!!!!!!!!!
;; Without this notification, AutoCAD may crash upon exiting!
(if (not *DrawingReactor*)
  (setq *DrawingReactor*
    (VLR-DWG-Reactor
      nil          ; No data is associated with the drawing reactor
      '((:vlr-beginClose . gp:clean-all-reactors)
      )
    ) ;_ end of vlr-DWG-reactor
  )
)

  • L’importance de détacher les réacteurs avant la fermeture du dessin pour éviter les plantages d’AutoCAD® est soulignée. Une fonction CleanReactors est introduite pour cela.

  • Le test des réacteurs est brièvement mentionné.

Assemblage (Pages 101-129)

  • Cette dernière leçon aborde la planification de la procédure complète des réacteurs pour gérer les modifications du contour du sentier.

  • La nécessité de réagir à d’autres commandes AutoCAD® susceptibles d’affecter les objets de l’application (comme la commande ÉTIRER) est soulignée.

  • L’enregistrement des informations nécessaires dans les données associées aux réacteurs (VLR-Data) est expliqué.

  • L’ajout d’une nouvelle fonctionnalité de réacteur pour redéfinir le contour de la polyligne lorsque ses sommets sont déplacés est détaillé.

  • Les fonctions de rétro-appel des réacteurs d’objets (comme gp:outline-changed) sont introduites, ainsi que la gestion de différents types d’entités et l’utilisation des méthodes ActiveX dans ces fonctions.

  • La gestion des séquences de réacteurs non linéaires est abordée.

  • Le code de la fonction gp:command-ended est développé pour effacer les dalles associées à un contour effacé.

  • La fonction gp:Calculate-and-Draw-Tiles est modifiée pour tenir compte du style de création d’objet.

  • Les fonctions gp:RedefinePolyBorder, gp:FindMovedPoint, gp:FindPointInList, et gp:recalcPolyCorners sont présentées pour gérer la redéfinition du contour de la polyligne après le déplacement d’un sommet.

  • Des fonctions utilitaires comme gp:pointEqual, gp:rtos2, et gp:zeroSmallNum sont expliquées pour gérer les problèmes de précision numérique lors des comparaisons de points.

[!note]
« Avez-vous remarqué que, au moment de répertorier les informations associées à une entité AutoCAD®, vous voyez apparaître quelquefois une valeur du type 1.0e-017 ? Ce nombre est proche de zéro mais, lorsque vous le comparez à zéro dans un programme à l’intérieur d’un programme LISP, proche de n’est pas pris en compte. »

  • Les étapes finales pour créer une application VLX à l’aide de l’Assistant Créer une application sont décrites.

  • Une bibliographie LISP et AutoLISP est fournie.

Marques de Tiers et Logiciels d’Autres Sociétés

Le document inclut une section listant les marques de fabrique et copyrights appartenant à d’autres sociétés, reconnaissant ainsi la propriété intellectuelle des outils et composants tiers utilisés ou mentionnés dans le didacticiel (par exemple, Élan License Manager, Microsoft Windows, ACIS®, Active Delivery​:trade_mark:, Correcteur orthographique de Lernout & Hauspie, InstallShield​:trade_mark:, WexTech AnswerWorks®, Wise for Installation System for Windows Installer). Ceci est une pratique standard pour la documentation logicielle.

Conclusion

Les extraits du « DIDACTICIEL VISUAL LISP​:trade_mark: » offrent un guide structuré et progressif pour apprendre à développer des applications AutoLISP à l’aide de l’environnement Visual LISP. À travers l’exemple concret de la création d’une application de sentier de jardin, le didacticiel aborde les concepts fondamentaux de la programmation en AutoLISP, l’utilisation des outils de débogage, la conception d’interfaces utilisateur, et l’implémentation de fonctionnalités avancées comme les réacteurs. L’accent est mis sur les bonnes pratiques de programmation, l’organisation du code et la gestion des interactions avec AutoCAD®.