[Résolu] Incompréhension entre un LSP et un DCL

[DenisHen]

Bonjour à tous.

 

J'ai développé une suite de routines qui dessinent des flèches. il y a trois type de flèche, une petite, une moyenne et une grande (pour une utilisation à plusieurs échelles).

 

J'ai fini par écrire un fichier DCL pour configurer le tout (longueur de la pointe, largeur de la pointe et largeur de la queue).

 

Mais lorsque je lance mon Lisp et que la fenêtre s'affiche, je ne peut changer qu'une valeur et en plus, l'affiche ne transmet pas les informations changées dans la fenêtre vers le Lisp.

 

Si quelqu'un as une idée, une astuce... Je suis preneur.

 

Voici le LISP :

;;;******************************************
;;;   Configuration des tailles de flèches   
;;;******************************************
(defun c:ConfigFleches
      (/ *DH_Fleches@ Dcl_Id% FlP1$ FlP2$ FlP3$ FlM1$ FlM2$ FlM3$ FlG1$ FlG2$ FlG3$)
 (princ "\nDéveloppé par Denis H. (v1.1)")
 (princ "\nDéfinir les valeurs en mm papier, leurs tailles seront selon l'échelle du dessin")
 (if (not *DH_Fleches@)
   (setq *DH_Fleches@ (list nil "" "" "" "" "" "" "" "" ""))
 ) ;_ Fin de if
 ;; Attribution des valeurs pour la DCL**************
 (setq FlP1$ (vlax-ldata-get "DenisH" "FlPtLong" "0.4")
       FlP2$ (vlax-ldata-get "DenisH" "FlPtLarg" "0.2")
       FlP3$ (vlax-ldata-get "DenisH" "FlPtEpais" "0.0")
 ) ;_ Fin de setq
 ;;
 (setq FlM1$ (vlax-ldata-get "DenisH" "FlMoLong" "0.8")
       FlM2$ (vlax-ldata-get "DenisH" "FlMoLarg" "0.4")
       FlM3$ (vlax-ldata-get "DenisH" "FlMoEpais" "0.0")
 ) ;_ Fin de setq
 ;;
 (setq FlG1$ (vlax-ldata-get "DenisH" "FlGrLong" "2")
       FlG2$ (vlax-ldata-get "DenisH" "FlGrLarg" "1")
       FlG3$ (vlax-ldata-get "DenisH" "FlGrEpais" "0.0")
 ) ;_ Fin de setq
 ;; Chargement de la fenêtre de dialog
 (setq Dcl_Id% (load_dialog "DH_Fleches.dcl"))
 (if (not (new_dialog "DH_Fleches" Dcl_Id%))
   (exit)
 ) ;_ Fin de if
 ;; Initialise les valeurs***************************
 (set_tile "Titre" " Configuration des flèches")
 ;;
 (set_tile "Txt1" "Petite :")
 (set_tile "Txt2" "Moyenne :")
 (set_tile "Txt3" "Grande :")
 ;;
 (set_tile "FlP1" FlP1$)
 (set_tile "FlP2" FlP2$)
 (set_tile "FlP3" FlP3$)
 ;;
 (set_tile "FlM1" FlM1$)
 (set_tile "FlM2" FlM2$)
 (set_tile "FlM3" FlM3$)
 ;;
 (set_tile "FlG1" FlG1$)
 (set_tile "FlG2" FlG2$)
 (set_tile "FlG3" FlG3$)
 ;; Actions******************************************
 (action_tile "FlP1" "(check_editreal \"FlP1$\")")
 (action_tile "FlP2" "(check_editreal \"FlP2$\")")
 (action_tile "FlP3" "(check_editreal \"FlP3$\")")
 ;;
 (action_tile "FlM1" "(check_editreal \"FlM1$\")")
 (action_tile "FlM2" "(check_editreal \"FlM2$\")")
 (action_tile "FlM3" "(check_editreal \"FlM3$\")")
 ;;
 (action_tile "FlG1" "(check_editreal \"FlG1$\")")
 (action_tile "FlG2" "(check_editreal \"FlG2$\")")
 (action_tile "FlG3" "(check_editreal \"FlG3$\")")
 ;; Décharge la DCL**********************************
 (setq Return# (start_dialog))
 (setq *DH_Fleches@ (list nil FlP1$ FlP2$ FlP3$ FlM1$ FlM2$ FlM3$ FlG1$ FlG2$ FlG3$))
 (princ *DH_Fleches@) ;<<<--- C'est ici la preuve que le retour ne se fait pas *********
 (unload_dialog Dcl_Id%)
 ;; Attribution des nouvelles valeurs**************
 (vlax-ldata-put "DenisH" "FlPtLong" (nth 1 *DH_Fleches@))
 (vlax-ldata-put "DenisH" "FlPtLarg" (nth 2 *DH_Fleches@))
 (vlax-ldata-put "DenisH" "FlPtEpais" (nth 3 *DH_Fleches@))
 ;;
 (vlax-ldata-put "DenisH" "FlMoLong" (nth 4 *DH_Fleches@))
 (vlax-ldata-put "DenisH" "FlMoLarg" (nth 5 *DH_Fleches@))
 (vlax-ldata-put "DenisH" "FlMoEpais" (nth 6 *DH_Fleches@))
 ;;
 (vlax-ldata-put "DenisH" "FlGrLong" (nth 7 *DH_Fleches@))
 (vlax-ldata-put "DenisH" "FlGrLarg" (nth 8 *DH_Fleches@))
 (vlax-ldata-put "DenisH" "FlGrEpais" (nth 9 *DH_Fleches@))
 (princ)
) ;_ Fin de defun

 

Et le fichier DCL :

//--------------
// DH_Fleches   
//--------------
DH_Fleches : dialog {
 key = "Titre";
 label = "";
 spacer;
   : row {
     fixed_width = true;
     : row {
       width =7;
       fixed_width = true;
       spacer;
       : text {
         key = "Fl0";
         label = "Taille de la ->           ";
         width = 8;
         fixed_width = true;
         }
       : text {
         key = "Fl1";
         label = "Flèche   ";
         width = 5;
         fixed_width = true;
         }
       : text {
         key = "Fl2";
         label = "Base  ";
         width = 5;
         fixed_width = true;
         }
       : text {
         key = "Fl3";
         label = "Queue";
         width = 5;
         fixed_width = true;
         }
      }
   }
   : row {
     fixed_width = true;
     : row {
       width =10;
       fixed_width = true;
       spacer;
       : text {
         key = "Txt1";
         label = "";
         width = 15;
         fixed_width = true;
         }
       : edit_box {
         key = "FlP1";
         edit_width = 5;
         fixed_width = true;
         }
       : edit_box {
         key = "FlP2";
         edit_width = 5;
         fixed_width = true;
         }
       : edit_box {
         key = "FlP3";
         edit_width = 5;
         fixed_width = true;
         }
      }
   }
   : row {
     fixed_width = true;
     : row {
       fixed_width = true;
       spacer;
       : text {
         key = "Txt2";
         label = "";
         width = 15;
         fixed_width = true;
         }
       : edit_box {
         key = "FlM1";
         edit_width = 5;
         fixed_width = true;
         }
       : edit_box {
         key = "FlM2";
         edit_width = 5;
         fixed_width = true;
         }
       : edit_box {
         key = "FlM3";
         edit_width = 5;
         fixed_width = true;
         }
      }
   }
   : row {
     fixed_width = true;
     : row {
       fixed_width = true;
       spacer;
       : text {
        key = "Txt3";
        label = "";
        width = 15;
        fixed_width = true;
        }
      : edit_box {
        key = "FlG1";
        edit_width = 5;
        fixed_width = true;
        }
      : edit_box {
        key = "FlG2";
        edit_width = 5;
        fixed_width = true;
        }
      : edit_box {
        key = "FlG3";
        edit_width = 5;
        fixed_width = true;
        }
    }
 }
 spacer;
 ok_only;
}

[DenisHen]

Pfff...

En plus, l'aide est super light...

[DenisHen]

Je viens d'aller faire un tour chez Lee Mac, Draftsperson.net, Jeffery P Sanders, Ron Leigh, Pixel Graphics Inc., A'CAD Solutions, CAD Digest...

 

Mais tout est en anglais et pas forcément très "limpide" pour le débutant que je suis...

[vincentp010]

Salut,

 

Il te faut une ligne pour récupérer les valeurs lorsque tu clique su OK; à mettre juste avant (start_dialog)

(action_tile "accept" "(setq *DH_Fleches@ (list nil (get_tile\"FlP1$\") (get_tile\"FlP2$\") (get_tile\"FlP3$\") (get_tile\"FlM1$\") (get_tile\"FlM2$\") (get_tile\"FlM3$\") (get_tile\"FlG1$\") (get_tile\"FlG2$\") (get_tile\"FlG3$\")))")

[DenisHen]

Salut Vincent, et merci pour ton aide.

 

J'ai bien placé ta phrase avant le (start_dialog), mais AutoCAD me répond ceci à la fermeture de la fenêtre :

; erreur: no function definition: CHECK_EDITREAL

[(gile)]

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;
}

[DenisHen]

Salut (gile), et merci pour cette réponse...

 

Tu m'avais déjà parlé de séparer le dialogue et la routine mais je n'avais pas bien saisi. C'est chose faite...

 

J'ai de quoi faire pour bien comprendre, mais déjà que mapcar et lambda me pose certains problèmes de compréhension, alors les deux en même temps, c'est pas sympa... ;)

 

Je me suis permis d'étoffer la DCL (la ou le ?), ça donne ceci pour ceux à qui ça intéresse :

//--------------
// DH_Fleches   
//--------------
DH_Fleches : dialog {
 key = "Titre";
   : row {
     fixed_width = true;
     :column{
       : text {
         label = "Taille de la ->";
         width = 8;
         fixed_width = true;
         }
         : text {
         label = "Petite";
         width = 8;
         }
         : text {
         label = "Moyenne";
         width = 8;
         }
         : text {
         label = "Grande";
         width = 8;
         fixed_width = true;
         }
     }
     :column{
       : text {
         key = "Fl1";
         label = "Pointe   ";
         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;
}

 

Encore un grand merci pour ton aide...

 

Denis...

[(gile)]

J'ai de quoi faire pour bien comprendre, mais déjà que mapcar et lambda me pose certains problèmes de compréhension, alors les deux en même temps, c'est pas sympa... ;)

 

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).

[Patrick_35]

Bonjour à vous tous

 

 

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.

Juste une précision. Les listes n'ont pas obligatoirement le même nombre d'arguments. Dans ce cas, ce qui est retourné comme résultat correspond à la liste la plus petite.

Par exemple

(mapcar 'strcat '("a" "b" "c" "d") '("a" "b"))

Retourne ("aa" "bb")

 

@+

[DenisHen]

Salut Patrick_35, et merci pour ton aide...

 

C'est expliqué dans le "Introduction_a_AutoLISP" de Maître (gile) mais je trouve ça trop "condensé" (pour moi).

 

Je commence à mieux comprendre le truc, je tente avec

      (setq keys '("FlP1" "FlP2" "FlP3" "FlM1" "FlM2" "FlM3" "FlG1" "FlG2" "FlG3"))
     (mapcar '(lambda (key val) (set_tile key val)) keys data)

Mais ce n'est pas si facile que ça... ;)

 

Voici je que j'en comprend :

lambda (key val) -> on déclare les deux variables

set_tile key val -> je ne saisi pas trop

keys data -> je ne saisi pas du tout

 

Mais peut-être que mon exemple (Lisp + DCL) est trop complexe pour une première approche...

 

Encore merci...

[Patrick_35]

(gile) à très bien expliqué la fonction mapcar.

Une fois que tu auras intégré que c'est un boucle qui traite les listes qui lui sont fournie et retourne les arguments (sous forme de liste) en fonction de la fonction indiqué (prédéfinie ou perso), tu auras fait un grand pas :D

 

Le mieux, est de faire des tests, de regarder les résultats afin de bien comprendre la fonction.

 

Je vois que tu commences à jouer avec les fonctions des boites de dialogues.

N'oublie pas que c'est du texte et que l'on peut condenser/optimiser ses fonctions comme le montre (gile) avec la fonction action_tile.

On peut même se servir de listes pour gérer ses affichages/actions. Chaque chose en son temps ;)

 

@+

[DenisHen]

Merci pour ton aide Patrick_35.

 

Je n'ai rien sous le coude pour faire des testes, mais j'ai déjà ça dans un lisp :

  (vlax-ldata-put "DenisH" "FlPtLong" Long)
 (vlax-ldata-put "DenisH" "FlPtLarg" Larg)
 (vlax-ldata-put "DenisH" "FlPtEpais" Epais)

Suis-je loin en faisant ça ?

  (setq LstPut "FlPtLong" "FlPtLarg" "PlPtEpais"
       LstVal Long Larg Epais)
 (mapcar '(lambda (LstPut LstVal) (vlax-ldata-put "Denis" LstPut LstVal)))

Je cherche un exemple concret pour le tester mais je n'ai pas d'idée (si quelqu'un en a une pour m'exercer)...

[Patrick_35]

Tu peux faire

 

(mapcar '(lambda(LstPut LstVal)(vlax-ldata-put "DenisH" LstPut LstVal)) '("FlPtLong" "FlPtLarg" "FlPtEpais") (list Long Larg Epais))

 

Ce qui revient à faire ce que tu as montré.

 

@+

[DenisHen]

Merci Patrick_35, je commence à piger le truc alors ? ;)

 

Il était temps... :huh:

 

Je cherche un exemple à faire pour bien capter le truc...

[(gile)]

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

[(gile)]

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)

[DenisHen]

Salut (gile) et merci pour cette précision...

 

Je ferais un peu plus de mapcar et de lambda, maintenant que je commence à comprendre le truc... Faut juste que je prenne le réflexe pour les utiliser...

 

Encore merci à vous deux...

[Patrick_35]

Pour trouver des exemples, dès que tu as une/des liste(s) à traiter par une boucle.

Pour ton exemple, on peut très bien utiliser un foreach à la place d'un mapcar car le résultat du mapcar importe peu.

Par exemple

(foreach ele (list (cons "FlPtLong" Long) (cons "FlPtLarg" Larg) (cons "PlPtEpais" Epais))
 (vlax-ldata-put "DenisH" (car ele) (cdr ele))
)

 

@+

[DenisHen]

Merci pour cette précision...

 

Mais j'ai cru lire, quelque part sur CadXP, que mapcar était plus "rapide" qu'un foreach...

 

Bien que ça doit ce jouer sur des millièmes de secondes...

 

Encore merci...

[Patrick_35]

C'est là où c'est interessant de faire un Benchmark

 

(defun ben_foreach()
 (foreach ele (list (cons "FlPtLong" Long) (cons "FlPtLarg" Larg) (cons "PlPtEpais" Epais))
   (vlax-ldata-put "DenisH" (car ele) (cdr ele))
 )
)

 

(defun ben_mapcar()
 (mapcar '(lambda(LstPut LstVal)(vlax-ldata-put "DenisH" LstPut LstVal)) '("FlPtLong" "FlPtLarg" "FlPtEpais") (list Long Larg Epais))
)

 

(benchmark (list '(ben_foreach) '(ben_mapcar)))

 

Résultat

Elapsed milliseconds / relative speed for 8192 iteration(s):

 

(BEN_FOREACH)......5312 / 2.25 <fastest>

(BEN_MAPCAR)......11953 / 1 <slowest>

 

Comme quoi ;)

 

@+

[DenisHen]

Ben ouais...

 

Perdu, c'est le foreach qui gagne...