(gile)

Non, je peux aussi utiliser 'foo' assez souvent mais généralement de façon locale (d'où l'importance de déclarer les variables et aussi les noms de fonction localement).

Salut, Comme dit @Luna, il va falloir que tu utilises un réacteur (vaste programme)... Ce serait à la fermeture de chaque document dans lequel le LISP est exécuté (LISP s'exécute toujours dans le contexte du document) avec la fonction vlr-dwg-reactor et l'évènement :vlr-beginClose. Un exemple simple: ;; charger les fonction COM/ActiveX (vl-load-com) ;; définir un réacteur pour l'évènement :vlr-beginClose (vlr-dwg-reactor nil '((:vlr-beginClose . alerteFermeture))) ;; fonction callback à exécuter lors de l'évènement :vlr-beginClose (defun alerteFermeture (rea lst) (alert (strcat (getvar 'dwgname) " va fermer")) ) Attention, manipuler les réacteurs n'est pas une chose simple qui demande beaucoup de rigueur.

Salut, As-tu essayé de contrôler le dessin (commande CONTROLE (_AUDIT) ?

Pour avoir rapidement une réponse à ce genre de question, il suffit de tester. La console Visual LISP est ta meilleure amie.

Si tu lances l'expression (getkword ...) depuis la console, la réponse s'affiche dans la console, si tu le fais depuis la ligne de commande, la réponse s'affiche sur la ligne de commande.

Salut, Encore une fois, fais des test avec des expressions simples (c'est si facile en LISP depuis la console ou la ligne de commande). Quelle est la valeur renvoyée quand tu fais Entrée en réponse à un getkword ? Pourquoi testes-tu si cette valeur est une liste ?

Salut, Il n'est pas possible de "sélectionner" des objets "au sein d'un bloc". Ces objets n'existent qu'au sein de la définition du bloc. S'il s'agit de supprimer ces objets ainsi que le calque la méthode suggérée par @didier est adéquate. S'il s'agit de mettre ces objets sur un autre calque, il faudra le faire pour tous les espaces (objet et papier) et pour les définitions de bloc qui contiennent des objets sur ce calque. Ça peut se faire avec la "sélection rapide" (et l'éditeur de bloc pur les définition de bloc) ou par programmation (hors AutoCAD LT).

En compilant le fichier Dist.lsp en DistGile.vlx sans rien modifier dans le code source, cette expression devrait fonctionner : (autoload "G:\\Mon Drive\\ ... \\LIPS\\lisp autocad\\DistGile.vlx" '("dist"))

Salut, Utilise plutôt le plugin (.NET) Increment qui offre plus de possibilités depuis la même interface. Tu insères les blocs en incrémentant le premier attribut à partir de l'onglet "Attribut", puis tu incrémentes le second attribut avec l'onglet "Sélection" ou, si ça correspond à ta demandes, avec l'onglet "Auto". Un screencast qui montre ce fonctionnement.

Il te faut donc parcourir la table des calques jusqu'à trouver un calque dont le nom correspond au modèle. La fonction pour comparer une chaîne à un modèles est wcmatch. Cette fonction est sensible à la casse donc pour contourner ce problème, on compare les chaînes passées en majuscules avec strcase, ce qui supprime les accents. (wcmatch (strcase "BETON") "*BETON*") => T (wcmatch (strcase "Beton") "*BETON*") => T (wcmatch (strcase "BÉTON") "*BETON*") => T (wcmatch (strcase "Béton") "*BETON*") => T Un exemple de fonction qui cherche un nom de calque correspondant au modèle (pattern) et renvoie T s'il l'a trouvé ; nil sinon. (defun layerExists (pattern / found layer) (setq pattern (strcase pattern)) (while (and (not found) (setq layer (tblnext "layer" (not layer))) ) (setq found (wcmatch (strcase (cdr (assoc 2 layer))) pattern)) ) found )

Salut, Un simple test* t'aurait tout de suite fait voir que la fonction tblsearch n'est pas sensible à la casse, mais qu'elle ne supporte pas les caractères génériques (que devrait-elle renvoyer s'il existe plusieurs claques contenant "BETON" ? Sinon, l'utilisation de lettres accentuées dans les noms de symboles (calques, blocs, etc.) devrait être proscrite. * c'est si simple de tester en LISP depuis la ligne commande ou la console de l'éditeur Visual LISP.

Salut, Tu peux essayer ZombieKiller.

Salut, Ça devrait fonctionner avec des fichiers .lsp, .fas ou .vlx (CF la documentation) à condition qu'une commande nommée "RIBLOCK" soit définie dans le VLX (defun c:RIBLOCK ...).

@bonuscad Super, une nouvelle approche. Comme je disais plus haut, la caractéristique du nombre d'or, c'est qu'il permet de générer une suite géométrique : Un+1 = Un * phi qui est aussi une suite de type Fibonacci : Un+2 = Un+1 + Un. Autrement dit, avec n0 = 1, n+1 = phi, on a n+2 = phi * phi ou n+2 = 1 + phi Ce qui permet de simplifier le calcul en remplaçant les appels à la fonction expt par de simples additions. (setq phi (* (1+ (sqrt 5)) 0.5) l_r '(1.0) cnt 0 ) (initget 7) (repeat (getint "\nNombre de répétion?: ") (setq l_r (cons (expt phi (setq cnt (1+ cnt))) l_r)) ) par (setq l_r (list (* (1+ (sqrt 5)) 0.5) 1.0)) (initget 7) (repeat (1- (getint "\nNombre de répétion?: ")) (setq l_r (cons (+ (car l_r) (cadr l_r)) l_r)) )

Salut, Depuis ce sujet. (defun c:PTALT (/ ss i blk pt) (if (setq ss (ssget "_X" '((0 . "INSERT") (2 . "TCPOINT") (410 . "Model")))) (repeat (setq i (sslength ss)) (setq blk (ssname ss (setq i (1- i))) pt (getpropertyvalue blk "Position") ) (setpropertyvalue blk "Position" (list (car pt) (cadr pt) (atof (getpropertyvalue blk "ALT")))) ) ) (command-s "_attsync" "_name" "TCPOINT") (princ) )

Pour la spirale d'or, on peut, comme l'ont fait Bruno et Didier, multiplier le terme précédent par le nombre d'or pour obtenir le suivant, mais ce qui caractérise le nombre d'or, c'est qu'on peut aussi obtenir le terme suivant avec la somme des deux termes précédents, comme avec la suite de Fibonacci. D'ailleurs le rapport entre deux termes successifs de la suite de Fibonacci tend vers le nombre d'or quand cette suite tend vers l'infini. On peut donc reprendre une des routines ayant servi à la suite de Fibonacci en remplaçant les deux premiers termes (0 et 1) par 1 et le nombre d'or. Style fonctionnel : (defun goldenSpiral (p i / loop b) (setq b (- (sqrt 2.) 1.)) (defun loop (i p n m x y) (vl-list* (cons 10 p) (cons 42 b) (if (< 0 i) (loop (1- i) (mapcar '+ p (list (* x n) (* y n))) m (+ n m) (- y) x ) ) ) ) (entmakex (append (list (cons 0 "LWPOLYLINE") (cons 100 "AcDbEntity") (cons 100 "AcDbPolyline") (cons 90 (+ i 1)) ) (loop i p 1 (+ (sqrt 1.25) 0.5) -1 1) ) ) ) Impératif : (defun goldenSpiral (p i / b x y n m l) (setq b (- (sqrt 2.) 1.) n 1. m (+ (sqrt 1.25) 0.5) x -1. y 1. ) (repeat (setq i (1+ i)) (setq l (cons (cons 42 b) (cons (cons 10 p) l)) p (mapcar '+ p (list (* x n) (* y n))) ) (mapcar 'set '(n m x y) (list m (+ n m) (- y) x)) ) (entmakex (append (list (cons 0 "LWPOLYLINE") (cons 100 "AcDbEntity") (cons 100 "AcDbPolyline") (cons 90 i) ) (reverse l) ) ) )

Avec des arcs: (defun spiralFib (p i / loop a) (defun loop (i c n m s e x y) (entmake (mapcar 'cons '(0 10 40 50 51) (list "ARC" c m s e))) (if (< 1 i) (loop (1- i) (mapcar '+ c (list (* x n) (* y n))) m (+ n m) e (+ e a) (- y) x) ) ) (setq a (* 0.5 pi)) (loop i (mapcar '+ p '(-1. 0.)) 0. 1. 0. a 0. -1.) )

Ça fonctionne (toujours avec un arc de trop)

Pour la spirale de Fibonacci, on avait le choix entre dessiner une polyligne ou des arcs. Jusque là, il semble que la polyligne ait eu un peu plus de succès. Ensuite, on peut adopter un style fonctionnel avec une fonction auxiliaire récursive (comme à fait @VDH-Bruno) ou un style plus impératif avec la fonction repeat (comme a fait @didier) Pour donner quelque chose d'un peu différent des précédentes réponses, je voudrais juste montrer comment on peut calculer les sommets de la polyligne sans utiliser la fonction polar. Dans les routines suivantes, les variables ou arguments n et m stockent deux termes consécutifs de la suite de Fibonacci, les variables ou arguments x et y stockent les signes (+1 ou -1) utilisés pour déplacer le sommet. Style fonctionnel: (defun fibSpiral (p i / loop b) (setq b (- (sqrt 2.) 1.)) (defun loop (i p n m x y) (vl-list* (cons 10 p) (cons 42 b) (if (< 0 i) (loop (1- i) (mapcar '+ p (list (* x m) (* y m))) m (+ n m) (- y) x ) ) ) ) (entmakex (append (list (cons 0 "LWPOLYLINE") (cons 100 "AcDbEntity") (cons 100 "AcDbPolyline") (cons 90 (+ i 1)) ) (loop i p 0 1 -1 1) ) ) ) Style impératif: (defun fibSpiral (p i / b x y n m l) (setq b (- (sqrt 2.) 1.) n 0 m 1 x -1 y 1 ) (repeat (setq i (1+ i)) (setq l (cons (cons 42 b) (cons (cons 10 p) l)) p (mapcar '+ p (list (* x m) (* y m))) ) (mapcar 'set '(n m x y) (list m (+ n m) (- y) x)) ) (entmakex (append (list (cons 0 "LWPOLYLINE") (cons 100 "AcDbEntity") (cons 100 "AcDbPolyline") (cons 90 i) ) (reverse l) ) ) ) Toutes les précédentes réponses utilisent entmake(x) pour créer la polyligne, je ne peux pas résister à poster un exemple (plus concis) avec command: (defun fibSpiral (p i / b x y n m) (setq b (- (sqrt 2.) 1.) n 0 m 1 x -1 y 1 ) (command "_.pline" "_non" p "_arc" "_direction" (mapcar '+ p '(0. 1.))) (repeat i (command "_non" (setq p (mapcar '+ p (list (* x m) (* y m))))) (mapcar 'set '(n m x y) (list m (+ n m) (- y) x)) ) (command "") )

@didier La routine spiralfib génère un arc de plus que demandé, sinon, "elle fait le job", même plus. La routine spiralgold plante, et même après correction du nom d'une variable, "elle ne fait pas le job".

Super. Des routine dans un style fonctionnel, on n'en attendait pas moins de toi. Tu pars en vacances en Corse ? Ça expliquerait Bonifacci(o) en lieu de Fibonacci. J'attends que d'autres postent des réponse pour voir si je peux proposer quelque chose de différent.

Juste pour compléter l'excellente réponse de @Luna Tu as dû partiellement copier un bout de code, ce qui expliquerait le : (and (vl-catch-all-error-p (vl-catch-all-apply ...))) qui était probablement là pour tester si ajouter la propriété provoquait une erreur (ce qui signifie que la propriété existe déjà) et, dans ce cas, appeler vla-SetCustomByKey. Comme quoi il est impératif de comprendre ce qu'on copie/colle ...

Les fichiers .dcl doivent être enregistrés dans un dossier des chemins de support.

Je ne comprends pas ce que tu veux dire. Peux-tu être plus explicite, s'il te plait ? Il n'y a aucune raison que ces LISPs ne soient pas "à jour" (qu'ils ne fonctionne pas sur les versions récentes d'AutoCAD), par contre, il existe peut-être des versions plus récentes de certains d'entre eux sur cette page.