(gile)

Bien sûr, F2 définie à l'extérieur du (defun c: ...) est accessible pour F1 comme n'importe quelle autre fonction LISP (prédéfinie ou définie par l'utilisateur). En résumé, il y a trois raisons de déclarer localement des fonctions : - pour redéfinir localement une fonction (typiquement *error*) - pour utiliser/modifier des variables locales à une fonction parent - pour éviter les conflits de nom

Pour le nombre d'objets sélectionnés, tu peux utiliser la fonction sslength. Le nombre de clics, je ne comprends pas. En tous cas ce n'est pas significatif parce qu'on peut faire une sélection de multiples manières (fenêtre, polygone, clic).

Salut, Oui, une fonction locale peut utiliser et modifier les variables locales de la fonction parent. La portée d'une variable locale (ou d'un argument) est limitée à la fonction dans laquelle elle est déclarée, mais elle est "globale" pour toutes les fonctions locales. (defun main (x / sub1 sub2 a) (defun sub1 (x) (* 2 x) ) (defun sub2 () (setq a (sub1 a) x (+ a x) ) ) (setq a 12) (sub2) (list a x) ) _$ (setq x 5) => 5 _$ (main x) => (24 29) _$ x => 5 Tu peux voir aussi ce message.

Comme ça, ça devrait marcher avec les attributs multilignes (defun getAttribs (blk / elst result) (setq elst (entget (entnext blk))) (while (= (cdr (assoc 0 elst)) "ATTRIB") (setq result (cons (cons (cdr (assoc 2 elst)) (cdr (assoc 1 (reverse elst))) ) result ) elst (entget (entnext (cdr (assoc -1 elst)))) ) ) result ) (defun setAttribValues (blk values / elst tag) (setq elst (entget (entnext blk))) (while (= (cdr (assoc 0 elst)) "ATTRIB") (setq tag (cdr (assoc 2 elst))) (if (setq val (cdr (assoc tag values))) (entmod (subst (cons 1 val) (assoc 1 (reverse elst)) elst)) ) (setq elst (entget (entnext (cdr (assoc -1 elst))))) ) ) (defun c:copyatt (/ blk attribs ss i) (and (setq blk (car (entsel "\nSélectionnez le bloc d'origine: "))) (setq attribs (getAttribs blk)) (princ "\nSélectionnez les blocs destinataires.") (setq ss (ssget '((0 . "INSERT") (66 . 1)))) (repeat (setq i (sslength ss)) (setAttribValues (ssname ss (setq i (1- i))) attribs) ) ) (princ) )

Salut, Tu peux essayer ce petit LISP vite fait (pas testé) (defun getAttribs (blk / elst result) (setq elst (entget (entnext blk))) (while (= (cdr (assoc 0 elst)) "ATTRIB") (setq result (cons (cons (cdr (assoc 2 elst)) (cdr (assoc 1 elst)) ) result ) elst (entget (entnext (cdr (assoc -1 elst)))) ) ) result ) (defun setAttribValues (blk values / elst tag) (setq elst (entget (entnext blk))) (while (= (cdr (assoc 0 elst)) "ATTRIB") (setq tag (cdr (assoc 2 elst))) (if (setq val (cdr (assoc tag values))) (entmod (subst (cons 1 val) (assoc 1 elst) elst)) ) (setq elst (entget (entnext (cdr (assoc -1 elst))))) ) ) (defun c:copyatt (/ blk attribs ss i) (and (setq blk (car (entsel "\nSélectionnez le bloc d'origine: "))) (setq attribs (getAttribs blk)) (princ "\nSélectionnez les blocs destinataires.") (setq ss (ssget '((0 . "INSERT") (66 . 1)))) (repeat (setq i (sslength ss)) (setAttribValues (ssname ss (setq i (1- i))) attribs) ) ) (princ) )

Salut, Il n'y a pas de variable pour ce point dans le code proposé. J'en ai rajouté une dans le code ci-dessous. (defun c:XXX (/ br elst p0 ss i pt) (and (setq br (car (entsel "\nSelectionnez le bloc de départ: "))) (setq elst (entget br)) (= (cdr (assoc 0 elst)) "INSERT") (setq p0 (trans (cdr (assoc 10 elst)) br 1)) ; point d'insertion du bloc de départ (princ "\nSélectionnez les blocs à relier.") (setq ss (ssget '((0 . "INSERT")))) (or (ssdel br ss) T) ; supprimer le bloc de départ du jeu de sélection ;; parcourir le jeu de sélection (repeat (setq i (sslength ss)) (setq elst (entget (ssname ss (setq i (1- i)))) ; données DXF du bloc pt (trans (cdr (assoc 10 elst)) (cdr (assoc 210 elst)) 1) ; point d'insertion du bloc ) ;; construction de la ligne (command "_.line" p0 pt "") ) ) (princ) )

Salut, Tu peux essayer ça : (defun c:XXX (/ br elst pt ss i) (and (setq br (car (entsel "\nSelectionnez le bloc de départ: "))) (setq elst (entget br)) (setq pt (trans (cdr (assoc 10 elst)) br 0)) (= (cdr (assoc 0 elst)) "INSERT") (princ "\nSélectionnez les blocs à relier.") (setq ss (ssget '((0 . "INSERT")))) (or (ssdel br ss) T) (repeat (setq i (sslength ss)) (setq elst (entget (ssname ss (setq i (1- i))))) (entmakex (list (cons 0 "LINE") (cons 10 pt) (cons 11 (trans (cdr (assoc 10 elst)) (cdr (assoc 210 elst)) 0)) ) ) ) ) (princ) )

Salut, Personnellement, je ne vois pas d'option Actif/Inactif pour une délimitation de fenêtre. Peux tu décrire précisément ce que tu fais (sans LISP) pour activer/désactiver la délimitation.

Salut, Pour faciliter l'utilisation des fonctions vla- qui utilisent des types variant et safearray, j'avais écrit une petite bibliothèque (gc_AutomationHelpers.lsp en bas de cette page). Cette bibliothèque fournit des fonctions qui permettent d'utiliser l'API COM avec des types de données AutoLISP classique. Par exemple, dans ton cas, pour affecter des données étendues à une entité viewport : (setq Select (car (entsel "\nSélectionner la fenêtre du plan de détails"))) (gc:SetXdata (vlax-ename->vla-object select) '((1001 . "TetraCAD") (1000 . "Details"))) Pour lire les données étendues d'une entité pour l'application spécifiée : (setq Select (car (entsel "\nSélectionner la fenêtre du plan de détails"))) (gc:GetXdata (vlax-ename->vla-object select) "TetraCAD")

Je pense que tu as fait une erreur en pensant "corriger" "une petite erreur de parenthèses".

Je n'ai pas noté ça sur CADxp. C'est peut-être dû à ton navigateur ou à ton système d'exploitation. La tendance étant d'essayer de faire des interfaces qui soient à la fois compatible avec l'affichage sur les écrans des smartphones et les écrans 4k 28 pouces ou plus...

Salut ssget renvoie nil si aucun objet n'est sélevtionné : (if (setq ss (ssget "_X" (list (cons 8 "Test")))) (prompt "\nLe calque n'est pas vide")) (prompt "\nLe calque est vide")) )

Salut Les fonctions (comme les variables) peuvent être locales ou globales. Les fonctions globales, une fois chargées, sont accessibles par toute autre expression LISP. Comme le dit Fraid, ça peut être intéressant pour des fonctions très utiles (et souvent utilisées). Le risque avec ce type de fonction est le conflit de nom (c'est la dernière fonction de même nom chargée dans le dessin qui est active. Déclarer localement les fonctions permet d'éviter ce problème. Dans ce cas la fonction locale doit être définie avant son utilisation dans la fonction parent (exactement comme une variable locale).

Salut, Quand tu poses une question sur le forum, il faut que tu fasses comme quand tu codes. L'interpréteur LISP, comme ceux qui vont te lire ne peuvent pas deviner ce que tu ne leur dit pas explicitement. D'où sortent pt1 pt2 pt3 ? À quoi servent pt2_ep et pt4_ep ? Par ailleurs, n'avait-on pas parlé très récemment de l'inutilité du tiret (-) devant les noms de commande ?

Salut, Si je comprends bien, tu voudrais que le point (20, 50) du Système de Coordonnées Général (WCS) soit au centre de la vue dans la fenêtre. La propriété Viewport.ViewCenter permet d'accéder au centre la vue définit dans le Système de Coordonnées d'Affichage (DCS) de la fenêtre flottante. Il te faut donc convertir le point (20, 50) en coordonnées WCS. Tu peux utiliser la méthode d'extension suivante (extraite de GeometryExtension disponible sur cette page). /// <summary> /// Fournit des méthodes d'extension pour le type Viewport /// </summary> public static class ViewportExtension { /// <summary> /// Obtient la matrice de transformation du système de coordonnées général (WCS) /// vers le système de coordonnées de l'affichage (DCS) de la fenêtre spécifiée. /// </summary> /// <param name="vp">L'instance à laquelle s'applique la méthode.</param> /// <returns>La matrice de transformation du WCS vers le DCS.</returns> public static Matrix3d WCS2DCS(this Viewport vp) => Matrix3d.WorldToPlane(vp.ViewDirection) * Matrix3d.Displacement(vp.ViewTarget.GetAsVector().Negate()) * Matrix3d.Rotation(vp.TwistAngle, vp.ViewDirection, vp.ViewTarget); } using (Transaction transaction = database.TransactionManager.StartTransaction()) { BlockTable blockTable = transaction.GetObject(database.BlockTableId, OpenMode.ForRead) as BlockTable; BlockTableRecord blockTableRecordPaper = transaction.GetObject(blockTable[blockTableRecord.PaperSpace], OpenMode.ForWrite) as BlockTableRecord; database.TileMode = false; editor.SwitchToPaperSpace(); using (Viewport viewPort = new Viewport()) { viewPort.CenterPoint = new Point3d(110, 220, 0); viewPort.Width = 1000; viewPort.Height = 500; blockTableRecordPaper.AppendEntity(viewPort); transaction.AddNewlyCreatedDBObject(viewPort, true); viewPort.TwistAngle = Math.PI / 2.0; viewPort.CustomScale = 0.02; Point3d viewCenter = new Point3d(20, 50, 0).TransformBy(viewPort.WCS2DCS()); viewPort.ViewCenter = new Point2d(viewCenter.X, viewCenter.Y); viewPort.On = true; } transaction.Commit(); }

Les fondamentaux Une expression LISP est : - soit un atome : un nombre (INT, REAL), une chaine STR, un nom d'entité (ENAME), un jeu de sélection (PICKSET), une fonction (SUBR, USUBR, EXRXSUBR), etc. - soit une liste d'expressions LISP Une liste LISP commence par une parenthèse ouvrante et se termine par une parenthèse fermante. Entre ces parenthèses elle peut contenir des expressions LISP (CF ci-dessus) séparées par des espaces, ou rien (cas particulier de la liste vide : nil). En règle générale, quand la liste n'est pas vide, la première expression juste derrière la parenthèse ouvrante est une fonction, les expressions suivantes sont les arguments de cette fonction. On appelle ce type de liste une "application de fonction". La seule exception au cas général ci-dessus est la liste utilisée comme structure de données, autrement dit une collection d'expressions ne devant pas être évaluées (une liste de trois nombres pour représenter un point, par exemple). Dans ce cas, il faut empêcher l'évaluation de la liste, on utilise pour ça la fonction quote ou son abréviation : l'apostrophe ('). En résumé, toute parenthèse ouvrante non précédée de la fonction quote (ou d'une apostrophe) est considérée comme le début d'une application de fonction et doit donc être directement suivie d'une expression de type fonction.

Petite précision, quand on appelle des commandes en LISP avec les fonctions command, vl-cmdf ou command-s il est inutile de précéder le nom de la commande avec un tiret (-). Extrait de "Introduction à AutoLISP" chapitre 5 :

Salut, Dans la console de l'éditeur Visual LISP (ou directement en ligne de commande), teste les expressions suivantes : (setq pt1_ep (list (0.1 0.1))) (list (0.1 0.1)) (0.1 0.1) Relis attentivement le chapitre 1.2 de "Introduction à AutoLISP" : 1.2.1 Évaluation des applications de fonction 1.2.2 Données sous forme de listes (quote) Ainsi que le chapitre 8.1 : Construction des listes (quote list cons) Pose toi la question : comment interpréter le message d'erreur ? Les messages d'erreur AutoLISP on en général la forme : ; erreur: :

Salut, Si je comprends bien, tu voudrais "sélectionner une polyligne dans l'EO pour en faire une fenêtre dans l'EP" et, parce que tu as trouvé des routines qui transforment un bloc en fenêtre flottante, tu cherches maintenant à transformer une polyligne en bloc. C'est un peu comme si tu voulais aller de Paris à Marseille et que, parce que tu as trouvé un truc pour aller de Florence à Marseille, tu cherches maintenant comment faire de Paris à Florence.

Encore un grain de sel : Les fonctions vla- (Visual Lisp Automation) ne concernent que l'API COM d'AutoCAD autrement dit toutes les propriétés, méthodes et évènements de l'Object Model d'AutoCAD, ce qui représente un nombre considérable de fonctions. Personnellement, je ne me lancerais pas dans une description exhaustive de ces fonctions, je me contenterais d'expliquer comment utiliser l'aide ActiveX pour transposer propriétés et méthodes en fonctions Visual LISP (cette aide comporte depuis plusieurs versions des exemples Visual LISP en plus des exemples VBA). Les fonctions vlax- (Visual Lisp ActiveX) concernent généralement l'accès à toute API ActiveX (celle d'AutoCAD comme celles d'applications tierces). On y trouve aussi les fonctions géométriques vlax-curve-* qui peuvent s'avérer très utiles. Comme pour les fonctions vla-, l'utilisation des fonctions vlax-get-(property), vlax-put-(property) et vlax-invoke-(method) suppose une connaissance ou un accès à la documentation de l'API concernée (AutoCAD ou autre). De nombreuses fonctions sont incontournables pour convertir des objets de types COM (variants, safearray, vla-object) en types AutoLISP et inversement. C'est à mon sens la partie la plus "lourdingue" du "Visual LISP" et c'est pourquoi j'avais écrit les routines de AutomationHelpers.lsp qu'on trouve en bas de cette page. Les fonctions vlr- (Visual Lisp Reactors) concernent les réacteurs. Je pense qu'elle ne concernent que des LISPeurs avertis dont le niveau d'expérience comprend certainement aussi la compréhension de la documentation en anglais.

Je me suis mal exprimé, ce que je voulais dire c'est que les descriptions de certaines fonctions sont inexacts : vl-member-if Recherche dans une chaîne (string) vl-member-if-not Recherche dans une chaîne (string) bis

Quelques commentaires vite faits : vl-consp : vérifie si l'argument est une liste non vide (parce que (listp nil) renvoie T) vl-member-if : renvoie la liste à partir de du premier élément vérifiant le prédicat. À propos des fonction vl-, tu peux voir ce sujet qui définit des équivalences en "pur AutoLISP".

Salut, Même si elles sont arrivées en même temps que Visual LISP (l'éditeur VLIDE et les fonctions vla-, vlax- et vlr-) avec les versions R14 et 2000, je considère les fonctions vl- comme une extension des fonctions AutoLISP. Elle n'ont rien à voir avec l'interface COM/ActiveX (utilisée par le VBA AutoCAD qui arrive dans AutoCAD à la même époque) ou avec les réacteurs (fonctions vlr-). D'ailleurs les fonctions vl- sont supportées par AutoCAD MAC contrairement aux fonctions (vla-, vlax- et vlr-).

Salut, Ça ne répond pas directement à ta question, mais ce petit screencast montre comment utiliser les formules dans les champs (ici pour la pente 2D d'une ligne). Les fonctions utilisables dans les formules de champ.

Salut, Essaye de nommer tes variable avec des noms plus explicites, ça t'éviteras des confusions... (setq PtPerp (DistanceTo pt12 pt1 pt2))contrairement à ce que son nom tendrait à faire croire, PtPerp est une distance (un nombre réel), pas un point...