(gile)

Salut, Comme spécifié dans les commentaires en en-tête, si l'utilisateur annule (ou ferme la boite de dialogue ce qui revient au même) une chaîne vide est retournée. Il aurait été préférable que nil soit retourné en cas d'annulation, ce qui permettrait de différencier le fait de valider une chaîne vide avec OK ou d'annuler. Pour ça, il suffit de supprimer l'initialisation de ret : version originale : ;; InputBox (gile) ;; Ouvre une boite de dialogue pour récupérer une valeur ;; sous forme de chaine de caractère ;; ;; Arguments ;; tous les arguments sont de chaines de caractère (ou "") ;; box : titre de la boite de dialogue ;; msg : message d'invite ;; val : valeur par défaut ;; ;; Retour ;; une chaine ("" si annulation) (defun InputBox (box msg val / subr temp file dcl_id ret) ;; Retour chariot automatique à 50 caractères (defun subr (str / pos) (if (and (< 36 (strlen str)) (setq pos (vl-string-position 32 (substr str 1 36) nil T)) ) (strcat ":text_part{label=\"" (substr str 1 pos) "\";}" (subr (substr str (+ 2 pos))) ) (strcat ":text_part{label=\"" str "\";}") ) ) ;; Créer un fichier DCL temporaire (setq temp (vl-filename-mktemp "Tmp.dcl") file (open temp "w") ret "" ) ;; Ecrire le fichier (write-line (strcat "InputBox:dialog{key=\"box\";initial_focus=\"val\";spacer;:paragraph{" (subr msg) "}spacer;:edit_box{key=\"val\";edit_width=36;allow_accept=true;}spacer;ok_cancel;}" ) file ) (close file) ;; Ouvrir la boite de dialogue (setq dcl_id (load_dialog temp)) (if (not (new_dialog "InputBox" dcl_id)) (exit) ) (set_tile "box" box) (set_tile "val" val) (action_tile "accept" "(setq ret (get_tile \"val\")) (done_dialog)" ) (start_dialog) (unload_dialog dcl_id) ;;Supprimer le fichier (vl-file-delete temp) ret ) Version modifiée ;; InputBox (gile) ;; Ouvre une boite de dialogue pour récupérer une valeur ;; sous forme de chaine de caractère ;; ;; Arguments ;; tous les arguments sont de chaines de caractère (ou "") ;; box : titre de la boite de dialogue ;; msg : message d'invite ;; val : valeur par défaut ;; ;; Retour ;; une chaine (nil si annulation) (defun InputBox (box msg val / subr temp file dcl_id ret) ;; Retour chariot automatique à 50 caractères (defun subr (str / pos) (if (and (< 36 (strlen str)) (setq pos (vl-string-position 32 (substr str 1 36) nil T)) ) (strcat ":text_part{label=\"" (substr str 1 pos) "\";}" (subr (substr str (+ 2 pos))) ) (strcat ":text_part{label=\"" str "\";}") ) ) ;; Créer un fichier DCL temporaire (setq temp (vl-filename-mktemp "Tmp.dcl") file (open temp "w") ) ;; Ecrire le fichier (write-line (strcat "InputBox:dialog{key=\"box\";initial_focus=\"val\";spacer;:paragraph{" (subr msg) "}spacer;:edit_box{key=\"val\";edit_width=36;allow_accept=true;}spacer;ok_cancel;}" ) file ) (close file) ;; Ouvrir la boite de dialogue (setq dcl_id (load_dialog temp)) (if (not (new_dialog "InputBox" dcl_id)) (exit) ) (set_tile "box" box) (set_tile "val" val) (action_tile "accept" "(setq ret (get_tile \"val\")) (done_dialog)" ) (start_dialog) (unload_dialog dcl_id) ;;Supprimer le fichier (vl-file-delete temp) ret )

L'apostrophe est un raccourci pour la fonction quote qui empêche l'évaluation de l'expression qui lui est passée en argument. '(("Layers" (ChargCalq))) est équivalent à : (quote (("Layers" (ChargCalq)))) tous deux retournent : (("Layers" (CHARGCALQ))) pour évaluer le symbole ChargCalq, il faut utiliser la fonction list et comme la liste contenant la variable est imbriquée, il faut le faire à chaque niveau : (list (list "Layers" (list ChargCalq)))

Salut, Tu l'as l'exemple avec ce que tu fais là. Tu as une liste de clés : (setq lstCles '("FlPtLong" "FlPtLarg" "PlPtEpais")) et une liste de valeurs : (setq lstValeurs (list Long Larg Epais)) et tu veux veux utiliser vlax-ldata-put pour stocker chaque valeur avec la clé correspondante dans le dictionnaire "DenisH". (vlax-ldata-put "DenisH" cle valeur) où les arguments cle et valeur prendront tour à tour les valeurs des éléments respectifs des listes lstCles et lstValeurs. Si c'est l'expression lambda qui te pose problème, tu peux toujours définir une fonction qui prends deux arguments avec defun : (defun putData (cle valeur) (vlax-ldata-put "DenisH" cle valeur)) et faire ensuite : (mapcar 'putData lstCles lstValeurs) L'utilisation d'une expression lambda consiste simplement à remplacer, dans l'expression mapcar, le nom de la fonction (putData) par sa définition anonyme (remplacer defun putData par lambda) : (mapcar '(lambda (cle valeur) (vlax-ldata-put "DenisH" cle valeur)) lstCles lstValeurs)

Salut, Tu l'as l'exemple avec ce que tu fais là. tu as une liste de clés : (setq cles '("FlPtLong" "FlPtLarg" "PlPtEpais")) et une liste de valeurs : (setq valeurs (list Long Larg Epais)) et tu veux veux utiliser vlax-ldata-put pour stocker chaque valeur avec la clé correspondante d

Il ne faut pas se laisser impressionner. mapcar retourne la liste des résultats des évaluations de la fonction passée en premier argument pour chacun des éléments de la ou des listes passées en arguments suivants. Soit une liste de chaînes de caractères : (setq lst '("alpha" "beta" "gamma")) Si on veut mettre tous les éléments de cette liste en lettres majuscules, il faut appliquer la fonction strcase à chaque élément de la liste (on dit "projeter" ou to map en anglais) et retourner la liste des résultats, c'est précisément ce que fait mapcar. (mapcar 'strcase lst) est équivalent à : (list (strcase "alpha") (strcase "beta") (strcase "gamma")) tous deux retournent : ("ALPHA" "BETA" "GAMMA") Maintenant, si on veut mettre seulement le premier caractère en majuscule et les autres en minuscules, il n'existe pas de fonction prédéfinie pour ce faire. Il faut donc définir notre propre fonction : (defun firstToUpper (str) (strcat (strcase (substr str 1 1)) (strcase (substr str 2) T) ) ) On peut maintenant l'utiliser avec mapcar. (mapcar 'firstToUpper lst) est équivalent à : (list (firstToUpper "alpha") (firstToUpper "beta") (firstToUpper "gamma")) tous deux retournent : ("Alpha" "Beta" "Gamma") Souvent on n'a pas vraiment besoin de définir une fonction séparée, c'est là qu'on peut utiliser une fonction lambda. C'est souvent le cas avec les fonctions dites "d'ordre supérieur" (les fonctions qui utilisent d'autre fonctions en argument comme mapcar, apply, vl-remove-if, etc.) Une fonction lambda est en fait une fonction anonyme. Elle ne peut donc pas être appelée ailleurs qu'à l'endroit où elle est définie et exécutée. Une fonction lambda est identique à la fonction définie avec defun équivalente à ceci près qu'il n'y a plus de nom de fonction. L'expression suivante est équivalent à celle ci-dessus : (mapcar '(lambda (str) (strcat (strcase (substr str 1 1)) (strcase (substr str 2) T) ) ) lst ) mapcar accepte aussi plusieurs listes comme arguments, dans ce cas, il faut que la fonction passée à mapcar accepte le même nombre d'arguments qu'il y a de listes. Imaginons qu'on veuille concaténer chacune des chaînes contenues dans lst avec les chaînes correspondantes d'une autre liste : ("1" "2" "3") séparées par un underscore. On ferait : (mapcar '(lambda (s1 s2) (strcat s1 "_" s2)) lst '("1" "2" "3") ) qui est équivalent à : (list (strcat "alpha" "_" "1") (strcat "beta" "_" "2") (strcat "gamma" "_" "3") ) et retourne : ("alpha_1" "beta_2" "gamma_3") Dans ta commande, tu fais mes mêmes opérations pour une liste de clés : (setq keys '("FlPtLong" "FlPtLarg" "FlPtEpais" "FlMoLong" "FlMoLarg" "FlMoEpais" "FlGrLong" "FlGrLarg" "FlGrEpais") ) Dans un premier temps tu récupères les valeurs enregistrées (ou celles par défaut) de chacune de ces clés avec vlax-ldata-get pour les afficher dans la boite de dialogue. Puis tu récupères les valeurs entrées dans la boite de dialogue pour les enregistrer avec vlax-ldata-put. mapcar utilisée avec deux listes est donc tout à fait indiquée dans les deux cas puisque vlax-ldata-get et vlax-ldata-put requièrent chacune 2 arguments (clé et valeur). (mapcar '(lambda (k v) (vlax-ldata-get "DenisH" k v) ) keys '("0.4" "0.2" "0.0" "0.8" "0.4" "0.0" "2.0" "1.0" "0.0") ) est équivalent à : (list (vlax-ldata-get "DenisH" "FlPtLong" "0.4") (vlax-ldata-get "DenisH" "FlPtLarg" "0.2") (vlax-ldata-get "DenisH" "FlPtEpais" "0.0") (vlax-ldata-get "DenisH" "FlMoLong" "0.8") (vlax-ldata-get "DenisH" "FlMoLarg" "0.4") (vlax-ldata-get "DenisH" "FlMoEpais" "0.0") (vlax-ldata-get "DenisH" "FlGrLong" "2.0") (vlax-ldata-get "DenisH" "FlGrLarg" "1.0") (vlax-ldata-get "DenisH" "FlGrEpais" "0.0") ) et retourne la liste des valeurs enregistrées (ou des valeurs par défaut) à passer à la fonction DH_Fleches_dialog pour remplir les cases (là encore, on peut utiliser mapcar avec set_tile, la liste des clés des edit_box et cette liste).

Salut, tu dois pouvoir utiliser directement cette expression LISP après avoir remplacé "03/05/2017" par la date que tu veux (mais en conservant les guillemets). Essaye d'abord en collant l'expression sur la ligne de commande, puis, si ça fonctionne, intègre là dans le script. (if (setq s (ssget "_X" '((0 . "INSERT") (2 . "BLO_CARTOUCHE")))) (repeat (setq i (sslength s)) (setpropertyvalue (ssname s (setq i (1- i))) "DATE_0" ; étiquette de l'attribut "03/05/2017" ; valeur de l'attribut ) ) )

Salut, Tout d'abord, il est souvent intéressant de séparer le code en plusieurs fonctions pour pouvoir les tester séparément (moins d’interactions facilite le débogage). Généralement, une boite de dialogue sert à récupérer des entrées utilisateur, on peut donc construire une fonction qui prend en argument les valeurs par défaut à afficher et retourne les valeurs modifiées par l'utilisateur. Une fonction ne peut avoir qu'une seule valeur de retour, en LISP, quand on doit retourner plusieurs valeurs, on retourne généralement une liste contenant ces valeurs. On peut aussi utiliser une liste comme argument en entrée quand les valeurs deviennent nombreuses. De plus, dans le cas présent les traitement de toutes les valeurs est identique (il s'agit simplement de contrôler que les valeurs entrées correspondent bien à des nombres). Et puis c'est l'occasion d'approfondir un peu les fonction de traitement des listes (mapcar, foreach). Voilà un exemple : ;; DH_Fleches_dialog ;; Affiche la boite de dialogue et retourne la liste des valeurs entrées. ;; ;; Argument ;; data : la listes des valeurs par défaut (9 chaînes représentant des nombres) (defun DH_Fleches_dialog (data / dcl_id keys status result) (setq dcl_id (load_dialog "DH_Fleches.dcl")) (if (new_dialog "DH_Fleches" dcl_Id) (progn (setq keys '("FlP1" "FlP2" "FlP3" "FlM1" "FlM2" "FlM3" "FlG1" "FlG2" "FlG3") ) (set_tile "Titre" " Configuration des flèches") (mapcar '(lambda (key val) (set_tile key val) ) keys data ) (foreach k keys (action_tile k "(if (not (distof $value)) (progn (alert \"Nombre non valide\") (mode_tile $key 2) ) )" ) ) (action_tile "accept" "(setq result (mapcar 'get_tile keys)) (done_dialog 1))" ) (action_tile "cancel" "(done_dialog 0)") (setq status (start_dialog)) (unload_dialog dcl_id) (if (= status 1) result ) ) ) ) Cet exemple peut être testé directement dans la console Visual LISP ou en ligne de commande en entrant l'expression : (DH_Fleches_dialog '("0.4" "0.2" "0.0" "0.8" "0.4" "0.0" "2.0" "1.0" "0.0")) Tu peux ensuite l'intégrer dans ta commande (là aussi, les fonctions de traitement des listes permettent de réduire le code) : (defun c:ConfigFleches (/ keys result) (setq keys '("FlPtLong" "FlPtLarg" "FlPtEpais" "FlMoLong" "FlMoLarg" "FlMoEpais" "FlGrLong" "FlGrLarg" "FlGrEpais") ) (if (setq result (DH_Fleches_dialog (mapcar '(lambda (k v) (vlax-ldata-get "DenisH" k v) ) keys '("0.4" "0.2" "0.0" "0.8" "0.4" "0.0" "2.0" "1.0" "0.0") ) ) ) (mapcar '(lambda (k v) (vlax-ldata-put "DenisH" k v) ) keys result ) ) (princ) ) Petite précision, pour que le code ci dessus fonctionne pleinement en prenant en compte le cas où l'utilisateur annulerait la commande, il faut remplacer ok_only par ok_cancel dans le DCL. Par ailleurs, l'apparence de la boite de dialogue pourrait être améliorée en utilisant une rangée de colonnes : //-------------- // DH_Fleches //-------------- DH_Fleches : dialog { key = "Titre"; : row { fixed_width = true; :column{ : text { label = "Taille de la ->"; width = 8; fixed_width = true; } } :column{ : text { key = "Fl1"; label = "Flèche "; width = 5; fixed_width = true; } : edit_box { key = "FlP1"; edit_width = 5; fixed_width = true; } : edit_box { key = "FlM1"; edit_width = 5; fixed_width = true; } : edit_box { key = "FlG1"; edit_width = 5; fixed_width = true; } } :column{ : text { key = "Fl2"; label = "Base "; width = 5; fixed_width = true; } : edit_box { key = "FlP2"; edit_width = 5; fixed_width = true; } : edit_box { key = "FlM2"; edit_width = 5; fixed_width = true; } : edit_box { key = "FlG2"; edit_width = 5; fixed_width = true; } } :column{ : text { key = "Fl3"; label = "Queue"; width = 5; fixed_width = true; } : edit_box { key = "FlP3"; edit_width = 5; fixed_width = true; } : edit_box { key = "FlM3"; edit_width = 5; fixed_width = true; } : edit_box { key = "FlG3"; edit_width = 5; fixed_width = true; } } } spacer; ok_cancel; }

On peut aussi modifier cette valeur via les "préférences" avec COM (comme toutes les options de la boite de dialogue Options) (vla-put-LayoutShowPlotSetup (vla-get-Display (vla-get-Preferences (vlax-get-acad-object)) ) :vlax-true ; ou :vlax-false )

Salut, SHOWPAGESETUPFORNEWLAYOUT est bien une variable système on la retrouve dans la base registre (pour A2018) : HKEY_LOCAL_MACHINE\SOFTWARE\Autodesk\AutoCAD\R22.0\ACAD-1001\Variables\SHOWPAGESETUPFORNEWLAYOUTS Mais cette variable est en fait liée à une variable d'environnement : ShowPlotSetup (valeur de LegacyValueName) qu'on retrouve dans la clé Drawing Window (valeur de LegacyKeyName) du profil AutoCAD courant (LegacyType): HKEY_CURRENT_USER\Software\Autodesk\AutoCAD\R22.0\ACAD-1001:40C\Profiles\\Drawing Window Donc, pour changer la valeur de SHOWPAGESETUPFORNEWLAYOUT il faut en fait utiliser setenv : (setenv "ShowPlotSetup" "1") ou (setenv "ShowPlotSetup" "0")

Ce LISP ne fait que le déplacement suivant le "l'axe X du bloc" comme demandé dans ton premier message. Si tu veux un déplacement suivant "l'axe Y du bloc", il faut ajouter 90° à la rotation du bloc. Autrement dit, en LISP, remplacer, dans la routine moveBlock : (getpropertyvalue blk "Rotation") par : (+ (getpropertyvalue blk "Rotation") (* pi 0.5))

C'est ce que font les LISPs ci-dessus (DPB pour déplacer un seul bloc ou DPSB pour déplacer une sélection de blocs).

Salut, Le lien dans le premier message est réparé.

Salut, Il me semble bien que la valeur de la variable système PLINEGEN n'influe pas sur les polylignes créées avec du code (LISP, COM, .NET) tant qu'on appelle pas la commande. Comme avec d'autres variables système (DELOBJ par exemple), c'est de la responsabilité du programme d'agir ou non en fonction de la valeur courante de la variable. En pur AutoLISP il faut jouer sur le bit 128 du groupe DXF 70, en COM avec la propriété LWPolyline.LineTypeGeneration et en .NET avec la propriété Polyline.PlineGen. Donc en .NET, si tu veux que le programme tienne compte de la valeur courante de PLINEGEN, il suffit de faire : var pline = new Polyline(); // ... pline.Plinegen = db.Plinegen;

Soit tu fais : (setq ComptTmpFin (getvar 'millisecs) ; Fin du chronomètre ComptTmp (- ComptTmpFin ComptTmpDeb) ) ;_ Fin de setq Soit tu fais directement la soustraction (setq ComptTmp (- (getvar 'millisecs) ComptTmpDeb)) Mais tu ne la fais pas deux fois...

Salut, Si ça concerne toutes les référence du même bloc insérées dans le dessin, le plus simple est de déplacer les entités dans la définition du bloc depuis l'éditeur de blocs. S'il ne faut déplacer que certaines références, tu peux utiliser le LISP ci dessous : (defun moveBlock (blk dist) (setpropertyvalue blk "Position" (polar (getpropertyvalue blk "Position") (getpropertyvalue blk "Rotation") dist ) ) ) ;; Dépalcer un bloc (defun c:DPB (/ blk dist) (and (setq blk (car (entsel "\nSélectionnez le bloc: "))) (= (getpropertyvalue blk "LocalizedName") "Référence de bloc") (setq dist (getdist "\nSpécifiez la distance de déplacement: ")) (moveBlock blk dist) ) (princ) ) ;; Déplacer une sélection de blocs (defun c:DPSB (/ ss i dist) (if (and (setq ss (ssget '((0 . "INSERT")))) (setq dist (getdist "\nSpécifiez la distance de déplacement: ")) ) (repeat (setq i (sslength ss)) (moveBlock (ssname ss (setq i (1- i))) dist) ) ) )

Salut, en général quand on chronomètre des routines on a plutôt envie d'avoir une précision à la milliseconde. On utilisera donc plutôt la variable MILLISECS qui stocke le nombre de millisecondes écoulées depuis le démarrage du système. (setq t0 (getvar 'millisecs)) ;;... ;;... (setq ti (- (getvar 'millisecs) t0)) (prompt (strcat "\nTemps écoulé : " (itoa (setq h (/ ti 3600000))) "h " (itoa (setq m (/ (setq r (- ti (* h 3600000))) 60000))) "m " (rtos (/ (- r (* m 60000)) 1000.) 2 3) "s" ) ) Mais en général, ceci suffit : (setq t0 (getvar 'millisecs)) ;;... ;;... (setq t1 (getvar 'millisecs)) (prompt (strcat "\nTemps écoulé : " (itoa (- t1 t0)) " millisecondes")) ou : (setq t0 (getvar 'millisecs)) ;;... ;;... (setq t1 (getvar 'millisecs)) (prompt (strcat "\nTemps écoulé : " (rtos (/ (- t1 t0) 1000.) 2 3) " secondes"))

Puisqu'on parle d'optimisation, j'ai fait quelques tests avec benchmark dans le sens de ce que propose Patrick_35. Et j'étais curieux de voir ce que donnait la "nouvelle" fonction setpropertyvalue. J'ai donc écrit 3 fonctions qui établissent la valeur d'un attribut avec entmod (foo), vla-put-Textstring (bar) et setpropertyvalue (baz) : (defun foo (ent tag val / elst) (while (and (setq ent (entnext ent)) (= (cdr (assoc 0 (setq elst (entget ent)))) "ATTRIB") ) (if (= (cdr (assoc 2 elst)) tag) (entmod (subst (cons 1 val) (assoc 1 elst) elst)) ) ) ) (defun bar (blk tag val / atts) (foreach att (vlax-invoke blk 'GetAttributes) (if (= (vla-get-TagString att) tag) (vla-put-TextString att val) ) ) ) (defun baz (blk tag val) (vl-catch-all-apply 'setpropertyvalue (list blk tag val)) ) Sur un bloc avec 2 attributs, on note que si l'utilisation de Visual LISP est un peu plus rapide que entmod, c'est setpropertyvalue qui semble la plus rapide. _$ (benchmark '((foo blk "ATT1" "FOO") (bar vl_blk "ATT1" "BAR") (baz blk "ATT1" "BAZ"))) Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s): (BAZ BLK "ATT2" "BAZ")........1404 / 1.46 <fastest> (BAR VL_BLK "ATT2" "BAR").....1748 / 1.17 (FOO BLK "ATT2" "FOO")........2043 / 1 <slowest> Mais avec un bloc ayant 12 attributs (de ATT1 à ATT12), l'écart se creuse : _$ (benchmark '((foo blk "ATT12" "FOO") (bar vl_blk "ATT12" "BAR") (baz blk "ATT12" "BAZ"))) Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s): (BAZ BLK "ATT12" "BAZ")........1389 / 2.73 <fastest> (BAR VL_BLK "ATT12" "BAR").....3400 / 1.12 (FOO BLK "ATT12" "FOO")........3791 / 1 <slowest> J'ai voulu pousser un peu avec une fonction utilisant entmod dans une fonction optimisée. Le fait d'utiliser une boucle (while ...) permet de sortir de la boucle dès que l'attribut a été trouvé. (defun foo2 (blk tag val / ent elst) (setq ent (entnext blk)) (while (and ent (= (cdr (assoc 0 (setq elst (entget ent)))) "ATTRIB") ) (if (= (cdr (assoc 2 elst)) tag) (progn (entmod (subst (cons 1 val) (assoc 1 elst) elst)) (setq ent nil) ) (setq ent (entnext ent)) ) ) ) Toujours avec le bloc ayant 12 attributs, mais en ciblant le premier bloc (condition optimale pour foo2). _$ (benchmark '((foo2 blk "ATT1" "FOO") (bar vl_blk "ATT1" "BAR") (baz blk "ATT1" "BAZ"))) Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s): (BAZ BLK "ATT1" "BAZ")........1373 / 2.48 <fastest> (FOO2 BLK "ATT1" "FOO").......1419 / 2.4 (BAR VL_BLK "ATT1" "BAR").....3401 / 1 <slowest> en ciblant le dernier bloc, la performance est logiquement équivalent à celle de foo qui parcourt tous les attributs. Ceci tendrait donc à montrer que l'utilisation de setpropertyvalue avec un étiquette d'attribut est équivalent à un accès direct, probablement dû l'utilisation dans l'implémentation d'une table de hachage ou d'un dictionnaire. Maintenant, il n'est pas certain que pour établir les valeurs de tous (ou presque) les attributs d'un bloc setpropertyvalue soit plus efficace si la table de hachage doit être recréée à chaque attribut...

Le premier argument pour la fonction setpropertyvalue doit être un nom d'entité (ENAME), pas une liste de données DXF. (setq ent_bloc (entlast)) (vl-catch-all-apply 'setpropertyvalue (list ent_bloc "X" "25")) (vl-catch-all-apply 'setpropertyvalue (list ent_bloc "Y" "18")) (vl-catch-all-apply 'setpropertyvalue (list ent_bloc "Z-TN" "9"))

Salut, Tu dois pouvoir supprimer certaines chose inutiles comme le test : (if (= (cdr (assoc 0 elst)) "INSERT") vu que tu utilises un filtre de sélection (par ailleurs, la variable elst n'est pas renseignée à ce stade...). La variable dxf10 semble inutile. Tu peux aussi créer une variable (setq tag (cdr (assoc 2 att))) avant le (cond ...) pour éviter d'évaluer (cdr (assoc 2 att)) à chaque fois. Mais je ne suis pas certain que tout ça te fasse gagner énormément. Par ailleurs, je ne sais pas ce que font les fonctions LISP spécifque MAP (ade_*) et donc si elles sont "couteuses". Un autre truc à essayer, serait de stocker les données de chaque bloc dans une liste pendant la boucle (une chaîne de caractères par ligne) et d'écrire le fichier CSV à partir de cette liste dans une autre boucle (foreach).

Salut, Une bonne nouvelle pour les développeurs, la "Documentation à l'attention des développeurs" de l'aide de la version 2018 est (enfin) exhaustive en ce qui concerne les APIs (DXF, AutoLISP, DCL, ActiveX, .NET, JavaScript et ObjectARX) et leurs "References", elle permet d'afficher un sommaire en arborescence et elle est aussi accessible en ligne. http://gilecad.azurewebsites.net/Resources/A2018_dev_docs.png

Salut, Idem pour LayLockSel : - soit tu désinstalles et tu réinstalles la dernière version (ici). - soit tu modifies le fichier PackageContents.xml (SerieMax="22.0") mais dans ce cas, il faut aussi lacer une "Réparation" depuis le panneau de configuration pour que la variable système soit enregistrée pour toutes les version d'AutoCAD installées.

J'ai modifié le code ci-dessus pour qu'il ne plante pas avec les textes multilignes à "aucune colonne".

Salut, Ça marche chez moi avec la nouvelle version. Ton problème est peut-être dû à un conflit entre le chargement "manuel" la DLL avec NETLOAD et le contenu du fichier PackageContents.xml. Le lien a été mis à jour pour que le plugin soit compatible avec 2018. Donc, - soit tu désinstalles l'ancienne version et tu installes la nouvelle ; - soit tu modifies le fichier PackageContents.xml dans : %programdata%\Autodesk\ApplicationPlugins\SelectiveAttSync.bundle pour autoriser les versions 2018 en mettant SeriesMax="R22.0".

La "Largeur définie" des textes multilignes est un propriété indépendante de la "Hauteur du texte" et de sa longueur (son contenu). C'est pour ça que souvent mettre la "Largeur" à 0.0 simplifie la vie. Pour ton problème, tu peux essayer ça: (defun c:test (/ ss i txt) (if (setq ss (ssget '((0 . "MTEXT") (410 . "Model")))) (repeat (setq i (sslength ss)) (setq txt (ssname ss (setq i (1- i)))) (if (/= (getpropertyvalue txt "ColumnType") 0) (setpropertyvalue txt "ColumnWidth" (* 10.0 (getpropertyvalue txt "ColumnWidth")) ) ) ) ) )

Salut, sendbox.fr est considéré par Norton comme étant un site à risque.