(gile)

Salut, Tu trouveras dans Introduction à AutoLISP (sur cette page) des informations en français sur le chargement des fichiers LISP dans la section 3 et sur l'affichage des messages (prompt) dans la section 11. Tu peux aussi consulter l'aide (en anglais) pour les fonctions load, autoload et prompt.

Un truc en LISP, mais sans les effets visuels (commande : CATENAIRE). (defun c:catenaire (/ catenary startPt endpt numPts tension) (defun catenary (startPt endPt numPts tension / cosh sinh asinh compute lg ht sp a b c pts x i) (defun cosh (x) (/ (+ (exp x) (exp (- x))) 2.) ) (defun sinh (x) (/ (- (exp x) (exp (- x))) 2.) ) (defun asinh (x) (log (+ x (sqrt (+ (* x x) 1.)))) ) (defun compute (x) (list x (+ (* tension (1- (cosh (/ (- x d1) tension)))) d2) 0.) ) (setq lg (- (car endPt) (car startPt)) ht (- (cadr startPt) (cadr endPt)) sp (/ lg (1- numPts)) a (/ ht (* 2. tension (sinh (/ lg (* 2 tension))))) b (+ (/ lg 2.) (* tension (asinh a))) c (* tension (1- (cosh (/ b tension)))) x (car startPt) d1 (+ (car startPt) B) d2 (- (cadr startPt) c) pts (list startPt) ) (repeat (setq i (- numPts 2)) (setq pts (cons (compute (setq x (+ x sp))) pts)) ) (reverse (cons endPt pts)) ) (setq numPts (vlax-ldata-get "GILE_CURVE" "NumFitPoints" 13)) (if (and (setq startPt (getpoint "\nPoint de départ: ")) (setq endPt (getpoint startPt "\nPoint de fin: ")) ) (if (setq tension (getdist startPt "\nTension horizontale: ")) (if (< (* 0.02 (abs (- (car startPt) (car endPt)))) tension) (progn (setq numPts (cond ((getint (strcat "\nNombre de points de lissage <" (itoa numPts) ">: "))) (T numPts) ) ) (if (< 6 numPts 256) (progn (command "_.spline") (foreach p (catenary startPt endPt numPts tension) (command "_non" p) ) (command "" "" "") (vlax-ldata-put "GILE_CURVE" "NumFitPoints" numPts) ) (prompt "\nLe nombre de point doit être compris entre 7 et 255 inclus.") ) ) (prompt "\nTension insuffisante.") ) ) ) (princ) )

Salut, Tu confonds le fichier acaddoc.lsp et la fonction LISP autoload. La fonction load permet de charger un fichier LISP. La fonction autoload permet de charger un fichier LISP au premier appel d'une commande LISP définie dans ce fichier. Le fichier acaddoc.lsp est chargé à l'ouverture de chaque nouveau dessin. La fichier toto.mnl est chargé à l'ouverture de chaque nouveau dessin si le fichier toto.cuix est aussi chargé. Donc, le plus simple : Tu enregistres les fichiers LISP dans un répertoire des chemins de recherche (et approuvés si A2014 ou plus). Tu crées un fichier acaddoc.lsp dans un répertoire des chemins de recherche. Dans ce fichier tu écris des expressions LISP qui seront évaluées à chaque ouverture d'un nouveau dessin. (prompt "\nChargement de accadoc.lsp.") (load "LongT.lsp" "Le fichier 'LongT.lsp' n'a pas pu être chargé") (autoload "MesCommandes.lsp" '("cmd1" "cmd2")) À l'ouverture de chaque dessin tu devrais voir en ligne de commande : Chargement de accadoc.lsp. Le LISP 'LongT.lsp' sera chargé ou tu verras le message d'erreur. La première fois que tu lancera CMD1 ou CMD2, tu verras "Initialisation..." en ligne de commande, signe que le fichier 'MesCommandes.lsp' est en train de se charger.

Salut, Comme dit plus haut, une chainette (catenary) n'est pas une parabole (même si les deux courbes sont proches au voisinage du sommet de la parabole c'est à dire pour une grande tension dans la chainette). Équation de la parabole : y = ax² + bx + c Équation de la chainette : y = a cosh(x/a) ou a est le rapport entre la composante horizontale de la tension et la masse linéique. J'avais des trucs en .NET dans mes cartons (c'est plus difficile de faire l'equivalent en LISP), je l'ai mis au propre pour le proposer ici. Télécharger et installer CustomCurvesSetup.msi (compatible AutoCAD 2013-2019). La commande PARABOLE (_PARABOLA) dessine une spline de degrés 2 par points de contrôle qui représente "exactement" un arc parabolique et un point figurant son foyer. La commande CHAINETTE (_CATENARY) dessine une spline qui est une approximation d'une chaînette par points de lissage (le nombre de points est paramétrable de 7 à 255). L'utilisateur spécifie la "tension horizontale" (pour une masse linéique = 1) à la souris ou au clavier. Le nombre de points de lissage et la tension sont enregistrées dans le dessin.

Salut, Chez moi l'affichage est similaire sur Firefox, Chrome et IE.

Cette méthode fonctionne si l'objet sélectionné n'a subit aucune transformation : entité d'une référence (xref ou bloc) insérée en 0,0 sans rotation ni changement d'échelle. Il est donc plus prudent d'appliquer à l'entité nouvellement créée avec entmake(x) la matrice de transformation retournée par nentselp (qui est différente de celle retournée par nentsel). ;; l'évaluation s'arrêtera à la première expression qui retourne nil (and (setq nent (nentselp "\nSélectionnez une entité imbriquée: ")) (setq ent (entmakex (entget (car nent)))) (and (< 2 (length nent)); entité imbriquée (vla-TransformBy (vlax-ename->vla-object ent) (vlax-tmatrix (caddr nent))) ) )

Salut, Un exemple minimaliste Le fichier "ListBox.dcl" ListBox : dialog { // titre de la boite de dialogue label = "Couleur"; // message : text { label = "Choisir une couleur dans la liste"; } spacer; // boite de liste : list_box { key = "lst"; } spacer; ok_cancel; } Le code d'une fonction LISP qui affiche la boite de dialogue et retourne la couleur sélectionnée dans la boite si l'utilisateur a fait OK, nil s'il a fait Annuler. (defun ListBox (/ dcl_id lst status choice) (setq dcl_id (load_dialog "ListBox")) (if (new_dialog "ListBox" dcl_id) (progn ;; liste à afficher (setq lst '("Rouge" "Jaune" "Vert" "Cyan" "Bleu" "Magenta")) ;; initialisation de la boite de liste (start_list "lst") (mapcar 'add_list lst) (end_list) ;; réactions aux actions sur les contrôles (action_tile "lst" "(setq choice (nth (atoi $value) lst))") (action_tile "accept" "(done_dialog 1)") (action_tile "cancel" "(done_dialog 0)") ;; affichage de la boite dialogue (setq status (start_dialog)) ;; déchargement de la boite de dialogue (unload_dialog dcl_id) (if (= status 1) choice ) ) ) ) PS : si tu débutes en LISP, commencer par les boites de dialogue n'est pas une bonne idée. S'attaquer au DCL et surtout à la gestion des boites de dialogue suppose certains pré-requis.

Salut, En "pur DCL", ce n'est pas possible, les boites de dialogues ne peuvent être que modales. Avec ObjectDCL ou OpenDCL il est possible de définir des boites de dialogue non-modales (modeless). Ce type de boite de dialogue est beaucoup plus délicat à gérer.

Salut, Voir la fonction LISP vlax-product-key.

Salut, Il s'agit de l'"Object Model" ActiveX qui fait partie de l'aide aux développeurs (anciennement sous forme de fichier .chm : acadauto.chm).

Salut, Un petit LISP vite fait : (defun c:MOVEATT (/ ent elst lst) (while (setq ent (car (nentsel "\nSélectionnez un attribut: "))) (if (= (cdr (assoc 0 (setq elst (entget ent)))) "ATTRIB") (if (zerop (cdr (assoc 280 (reverse elst)))) (setq lst (cons elst lst)) (prompt "La position de l'attribut est verrouillée.") ) (prompt "L'objet sélectionné n'est pas un attribut.") ) ) (if (setq pt (getpoint "\nSpécifiez le point d'insertion: ")) (foreach l lst (if (assoc 11 l) (setq l (subst (cons 11 (trans pt 1 0)) (assoc 11 l) l)) ) (entmod (subst (cons 10 (trans pt 1 0)) (assoc 10 l) l)) ) ) (princ) )

Salut, Un petit LISP vite fait : (defun c:RDMPL (/ rad ss i) (if (setq rad (getdist (strcat "\nSpécifiez le rayon <" (rtos (getvar 'filletrad)) ">: "))) (setvar 'filletrad rad) ) (if (setq ss (ssget '((0 . "LWPOLYLINE")))) (repeat (setq i (sslength ss)) (command "_.fillet" "_polyline" (ssname ss (setq i (1- i)))) ) ) (princ) )

Salut, Dans les propriétés (F1) de paramètre de distance, dans la rubrique Jeu de valeurs, tu spécifies Type de dist = Incrément et les valeurs que tu veux pour Dist incrément, Dist minimum et Dist maximum.

Salut, Est-ce qu'il ne serait pas possible de simplement redéfinir le bloc (dans l'éditeur de bloc) puis de synchroniser les attributs (ATTSYNC) ?

Salut, À mon avis la question de la portée d'une variable ne se pose pas tant en terme d'utilisation de la mémoire qu'en terme de fonctionnement du code. Je ne sais pas ce que tu appelles "variable globale" quand tu dis par ailleurs "tout le projet". Je pense qu'une bonne pratique est de limiter la portée d'une variable au minimum nécessaire : Si la variable est spécifique à une méthode, il faut la déclarer localement dans la méthode. Si la variable doit être accessible pour plusieurs méthodes d'une même classe mais n'a pas besoin d'être visible à l'extérieur de la classe, il faut la déclarer au niveau de la classe en tant que champ privé. Si la variable doit être accessible pour les instances de cette classe, il faut en faire une propriété publique. Si la variable doit être accessible indépendamment des instances de la classe, il faut en faire une propriété publique statique (dans ce cas, il est préférable que la propriété soit en lecture seule).

Avec la même expression : Dim dialog = New ModelessDialog() Si option Infer = On, le type de dialog est ModelessDialog => liaison précoce (early binding) Si option Infer = Off, le type de dialog est Object => liaison tardive (late binding) Tu as pu constater par toi même les conséquences sur les performances que peut provoquer la liaison tardive.

Parce que c'est plus court à taper ;) Et aussi parce que : ModelessDialog dialog = new ModelessDialog(); c'est un peu redondant, non ? Il s'agit de ce qu'on appelle : l'inférence de type, le mot clé var permet de pas indiquer explicitement le type et de laisser le soin au compilateur de le faire. La variable dialog est tout de même fortement typée (si tu places ton curseur sur la variable un peu plus loin dans le code, tu verras que Visual Studio sait que le type de dialog est ModelessDialog. Voir cet article. On peut fiare le même genre de chose en VB en activant l'option Infer (encore une option de compilation). Mais encore une fois VB peut rendre le code confus : Dim dialog As ModelessDialog = New ModelessDialog() le type de la variable dialog est ModelessDialog Dim dialog = New ModelessDialog() le type de la variable dialog sera ModelessDialog si Infer = On, mais sera Object si Infer = Off (=> liaison tardive implicite). À mon avis, un langage dont le même code est compilé différemment en fonction d'options de compilation pas toujours visible est à éviter. Le plus strict les langages .NET de première classe (C#, C++/CLI, F#, VB) est F# qui n'accepte aucune conversion implicite (on ne peut pas additionner un nombre entier (int) avec un nombre un réel (float)). Cette rigueur permet que l'inférence de type soit utilisée par défaut. F# let isEven x = x % 2 = 0Aucun type n'est spécifié mais le compilateur déduit que isEven est une fonction qui prend un nombre entier et retourne un booléen (signature : int -> bool). Avec C# ou VB il faut spécifier le type de retour et le type de l'argument C# bool IsEven(int x) => x % 2 == 0; VB Function IsEven(ByVal x As Integer) As Boolean Return x Mod 2 = 0 EndFunction

L'attribut CommandClass n'est pas obligatoire mais il permet d'optimiser le chargement en indiquant au compilateur les classes du projet qui définissent des commandes. Il faut donc : soit ne pas l'utiliser du tout ; soit le mettre pour toutes les classes du projet qui définissent des commandes (avec l'attribut CommandMethod). C'est la cas dans le tutoriel dont tu parles, toutes les classes qui définissent des commandes (et seulement celles-ci) ont cet attribut. Tu peux voir ce sujet en anglais.

La suite, ou comment créer un modèle de projet (Template) à partir du projet précédemment créé.

Salut, Le projet d'un plugin AutoCAD (voué à être chargé avec NETLOAD) doit être un projet de type "Bibliothèque de classe". Ceci n'est pas spécifique à C#, c'est valable pour tout projet .NET quel que soit le langage (C#, C++/CLI, F#, VB, etc). Tu peux voir ce screencast fait pour AutoCAD 2015 avec Visual Studio 2015, mais très facilement transposable à d'autres versions d'AutoCAD et/ou de Visual Studio.

Comprendre la récursivité (de même que comprendre les fonctions dites d'ordre supérieur comme mapcar ou apply et les expressions lambda) est une étape importante (si ce n'est essentielle) dans l'apprentissage du LISP (ou de tout autre langage fonctionnel). LISP est définit récursivement : une expression LISP est un atome ou une liste d'expressions LISP. De même les listes LISP (listes chaînées) sont des structures de données récursives. Une expression LISP contenant des expressions imbriquées est une sorte d'arborescence (structure récursive) comparable à un "empilement" d'appels récursifs. Son évaluation fonctionne comme le "dépilement" dans l'évaluation d'une fonction récursive. Compare la version itérative et la version récursive, j'ai modifiée cette dernière pour bien faire apparaître les similitudes et les différences entre les deux.

Je vais essayer de répondre ici avant caderix... Un peu de logique binaire. La macro suivante bascule la valeur de la variable système TOOLTIPS : ^C^Ctooltips;$M=$(xor, 1, $(getvar,tooltips)) L'opérateur logique XOR utilisé avec 1 retourne 1 si TOOLTIPS = 0 (1 XOR 0 = 1) ou retourne 0 si TOOLTIPS = 1 (1 XOR 1 = 0) Un autre classique est d'utiliser l'arithmétique en soustrayant la valeur (1 ou 0) de 1 (1 - 0 = 1 et 1 - 1 = 0). ^C^Ctooltips;$M=$(-, 1, $(getvar,tooltips))

Aleck Ultimate, si tu veux utiliser les listes DXF telles que retournées par entget, il faut étudier attentivement ces listes en te servant de l'aide (en français). Comme dit plus haut, pour récupérer les sommets d'une entité de type POLYLINE, il faut parcourir ses sous entité de type VERTEX. On fait ça avec entnext en testant que l'entité est bien du type VERTEX. (defun vertices (ent / elst pts) (setq ent (entnext ent) ; entité suivante dans la base de données elst (entget ent) ; liste DXF de l'entité ) (while (= (cdr (assoc 0 elst)) "VERTEX") ; tant que l'entité est de type VERTEX (setq pts (cons (cdr (assoc 10 elst)) pts) ; on ajoute le sommet à la liste ent (entnext ent) ; on passe à l'entité suivante elst (entget ent) ; et à sa liste DXF ) ) (reverse pts) ; on remet la liste dans l'ordre pour la retourner ) ou, récursivement : (defun vertices (ent / elst) (setq ent (entnext ent) elst (entget ent) ) (if (= (cdr (assoc 0 elst)) "VERTEX") (cons (cdr (assoc 10 elst)) (vertices ent)) ) ) Comme montré par bonuscad, on peut aussi utiliser les fonctions vlax-curve-*, dans ce cas, ça fonctionne avec tous les types de polylignes. (defun vertices (ent / i pts) (vl-load-com) (setq i (1+ (fix (vlax-curve-getEndParam ent)))) (repeat i (setq lst (cons (vlax-curve-getPointAtParam ent (setq i (1- i))) lst)) ) )

D'après ce que tu décris, l'objet sélectionné n'est pas une polyligne "optimisée" (LWPOLYLINE) mais peut-être une polyligne 2d "lourde" ou une polyligne 3d (POLYLINE dans ces deux cas). Regarde ce que te contient le code de groupe 0 : (0 . "LWPOLYLINE") => polyligne "optimisée" => un groupe 10 pour chaque sommet dans système de coordonnées de l'objet (SCO) (0 . "POLYLINE") => polyligne 2d / 3d (ou maillage), il s'agit d'une entité dite "complexe", c'est à dire composée de sous-entités de type VERTEX, il faut dans ce cas parcourir ces entités avec entnext pour récupérer leurs positions avec le code 10 de leur liste DXF. PS: les codes 20-29 et 30-39 ne sont utilisés que dans les fichiers DXF pour, respectivement, les coordonnées x et y. Dans les listes retournées par entget seuls les groupes 10 (et parfois 11) sont utilisés.

Si tu veux te convertir au C#, je ne peux que t'encourager. Tu trouveras plus d'exemples que tu pourras lire plus facilement. Sinon, avec l'option Strict = On, Visual Studio t'obligera à écrire du code VB aussi rigoureux en terme de typage qu'avec C#.