Pb de rappel de boite de dialogue

[Matt666]

Bonjour à tous !

J'ai un petit problème de programmation. Peut être que le sujet a déjà été traité, je n'ai pas vraiment pris le temps de regarder dans le forum. J'ai beau avoir cherché quelques temps sur internet, je n'ai rien trouvé...

 

Il faut savoir que je débute en dcl. Le lisp devient de plus en plus familier, et je suis arrivé à avoir vraiment besoin d'une boîte de dialogue pour un lisp.

 

Ce lisp sert à incrémenter des caractères.

Il ressemble à ceci :

 

;;XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

;Incrémente des chiffres et des lettres. Créé par Matthieu Noblet

(defun c:incmt ()

(setq

temperror *error*

*error* myerror

count 0

cntr 0

endv 0

inc 1

a (findfile "GTPI_MACRO_BCAD/VAR.txt")

)

(if a

(progn

(setq refi (open a "R"))

(while (setq aa (read-line refi))

(if (or (eq aa "M")(eq aa "CM")(eq aa "MM")) (setq l1 aa))

)

(close refi)

); end of progn

); end of if

(setq h_txt (cdr (assoc 40 (tblsearch "STYLE" (getvar "textstyle")))))

(if (or (eq h_txt nil)(eq h_txt 0))

(if (eq l1 "M")

(setq h_txte 0.15)

(if (eq l1 "CM")

(setq h_txte 15)

(if (eq l1 "MM")

(setq h_txte 150)

)))

(setq h_txte h_txt)

); end of if

(initget 1 "A N")

(setq alpnum (getkword "Alphabétique ou Numérique [A/N] : "))

(if (eq alpnum "N")

(progn

(while (>= count endv)

(initget)

(setq count (getint "Valeur de début: "))

(initget 1)

(setq endv (getint "Valeur de fin: "))

(initget 1)

(setq inc (getint "Incrément: "))

); end of while

); end of progn

(progn

(while (>= count endv)

(setq count (ascii (getstring "Caratère de début: "))

endv (ascii (getstring "Caractère de fin: ")))

); end of while

); end of progn

); end of if

(if alpnum

(progn

(initget 1)

(setq start (getpoint "Point de départ : "))

(initget (+ 1 2 4))

(setq

displ (getdist start "\nDécalage : ")

ang (getangle start "Direction <0> : ")

htxt (getreal (strcat "Hauteur du texte <" (rtos h_txte 2 2) "> : "))

rot (getangle "Angle de rotation du texte <0> : ")

)

(initget 1 "G C D")

(setq jus (getkword "Justification du texte [G/C/D] : "))

(if (eq jus "G")(setq jus "MG")(if (eq jus "C")(setq jus "MC")(if (eq jus "D")(setq jus "MR"))))

(if (null htxt)(setq htxt h_txte))

(if (null ang)(setq ang 0))

(if (null rot)(setq rot 0)(setq rot (angtos rot)))

(while (<= count endv)

(if (eq alpnum "N")

(progn

(if (< count 10)(setq count (strcat "0" (itoa count))))

(if (or (eq h_txt nil)(eq h_txt 0))

(command "_text" "j" jus start h_txte rot count)

(command "_text" "j" jus start rot count)

)

)

(if (or (eq h_txt nil)(eq h_txt 0))

(command "_text" "j" jus start h_txte rot (chr count))

(command "_text" "j" jus start rot (chr count))

)

);end of if

(if (eq (type count) 'STR)(setq count (atoi count)))

(setq start (polar start ang displ) count (+ count inc) cntr (1+ cntr))

);end of while

(princ (strcat "\n" (itoa cntr) " textes créés."))

); end of progn

); end of if

(princ)

);end of defun

;;XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

 

Si vous essayez de le charger, vous comprendrez très vite l'utilité d'une boîte de dialogue... En effet il faut entrer pas moins de 10 paramètres pour pouvoir générer ces textes.

 

Au passage, je travaille sous BricsCad, et les commandes ont parfois une sémantique différente... Donc vérifiez bien l'appel de la commande _text et ses paramètres avant de lancer cette routine sous autoCad... A terme je transformerai cette commande en un entmake, mais pas trop le temps pour ça !!

 

Bref... Je blablate....

 

Donc j'ai tenté d'écrire un petit programme en dcl, qui ressemble à ceci :

 

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

dincr : dialog {

aspect_ratio = 0 ;

label = "Incrémentation caractères" ;

: column {

:boxed_column {

: popup_list { label = "Mode :" ; list = "Numérique\nAlphabétique" ; key ="Incmtmode"; mnemonic = "M"; alignment = right ; edit_width=14;}

}

spacer ;

:boxed_column { label = "Valeur textes" ; key = "box2";

: edit_box { label = "Valeur de Début :"; key ="Incmtvald"; mnemonic = "d"; edit_width=10 ; }

: edit_box { label = "Valeur de Fin :"; key ="Incmtvalf"; mnemonic = "f"; edit_width=10 ; }

: edit_box { label = "Incrément :"; key ="Incmtincmt"; mnemonic = "I"; edit_width=10 ; }

}

spacer ;

:boxed_column { label = "Position textes" ; key = "box3";

: row {

: text {

label = "Point de départ :";

alignment = left;

fixed_width=true;

width=10;

}

: button {

label = ">>";

mnemonic = "o";

alignment=right;

fixed_height=true;

key = "incmpt";

fixed_width=true;

width=10;

is_default = false;

}

}

: row {

: text { label = "Décalage : "; alignment = left; }

: button {

label = ">>";

mnemonic = "d";

fixed_height=true;

fixed_width=true;

width=4;

key = "incmdec";

is_default = false;

}

: edit_box {

label = "";

key ="Incmtdec";

mnemonic = "e";

alignment=right;

fixed_width=true;

width=10;

}

}

: row {

: text {label = "Direction (en degrés) :"; alignment = left; }

: button {

label = ">>";

mnemonic = "r";

fixed_width=true;

fixed_height=true;

width=4;

key = "Incmdir";

is_default = false;

}

: edit_box { label = ""; key ="Incmtdir"; mnemonic = "i"; alignment=right; fixed_width=true ; width=10; }

}

}

spacer ;

:boxed_column { label = "Options de texte" ; key = "box4";

: edit_box { label = "Hauteur :"; key ="Incmthtext"; mnemonic = "h"; edit_width=10 ; }

: edit_box { label = "Angle rotation :"; key ="Incmtang"; mnemonic = "a"; edit_width=10 ; }

: popup_list {

label = "Justification :";

list = "Gauche\nCentre\nDroite";

key ="Incmtjust";

mnemonic = "j";

alignment = right;

edit_width=10 ;

}

}

}

ok_cancel ;

spacer_1 ;

: text {label = "Créé par Matthieu Noblet"; alignment = center;}

}

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

 

Bon ce programme est bien joli, avec tout ce qu'il faut pour valider la routine d'incrémentation...

 

Maintenant il faut créer la routine qui permettra de "dialoguer" avec la boîte...

 

Et là, c'est le drame...

Je nage !! Je n'en suis qu'au début, et mon problème principal, c'est que je n'arrive pas à rappeler la boîte de dialogue lorsque le point d'insertion a été entré...

 

Si qqn pouvait m'aider, ça m'arrangerait énormément !!! Merci !

Adtal, comme on dit par chez nous !

 

PS : Je vous montre où j'en suis rendu... J'ai commencé par le plus dur, je n'ai pas du tout codé les champs de saisie....

 

(defun C:essai ()

(defun do_act (key_pr)

(setq op key_pr)

(if (= key_pr "cancel")

(setq loop 0)

)

(setq dlg_pt (done_dialog loop))

)

(setq dcl_id (load_dialog "essai.dcl"))

(if (not (new_dialog "dincr" dcl_id))

(progn (princ "\nBoîte de dialogue 'essai.dcl' introuvable.") (exit))

)

(setq loop 1

bug 0

)

(while (and (/= loop 0) (< bug 20))

(setq bug (1+ bug))

(action_tile "cancel" "(do_act $key)")

(action_tile "accept" "(do_act $key)")

(action_tile "incmpt" "(done_dialog 1)(setq a 1)")

(action_tile "incmdec" "(done_dialog 2)(setq a 2)")

(action_tile "Incmdir" "(done_dialog 3)(setq a 3)")

(start_dialog)

(cond

((or (eq op "incmpt") (eq a 1))

(setq ptstart (getpoint "Point de départ : "))

;(unload_dialog dcl_id)

; (new_dialog "dincr" dcl_id)

)

((or (eq op "incmdec") (eq a 2))

(setq displ (getdist start "\nDécalage : "))

; (unload_dialog dcl_id)

; (new_dialog "dincr" dcl_id)

)

((or (eq op "Incmdir") (eq a 3))

(setq ang (getangle start "Direction <0> : "))

; (unload_dialog dcl_id)

; (new_dialog "dincr" dcl_id)

)

)

(if (eq bug 20)

(princ "\nAttention boucle redondante.")

)

(unload_dialog dcl_id)

(princ)

)

)

 

 

Merci d'avance, et bon courage pour la lecture !!!

Désolé...

 

[Patrick_35]

Salut

A la lecture de ton lisp, tu peux affecter une variable à un (start_dialog) car il prend la valeur d'un (done_dialog)

 

ex : (action_tile "toto_45" "(done_dialog 45)")

(setq loop (start_dialog))

 

loop --> 45, donc action de la clé "toto_45"

 

De plus, cela permet une boucle qui ne sort par exemple que si loop = 0

 

@+

[Matt666]

Merci pour ta réponse Patrick 35...

 

Je vais tenter ça, mais je me demande si j'ai bien compris...

 

Ce que je veux faire, c'est par exemple définir un point d'insertion comme suit :

- je clique d'abord sur le bouton qui permet de sortir de la boîte de dialogue (donc action_tile)

- Ensuite la boîte de dialogue disparait et je donne un point d'insertion dans la zone de travail d'autocad

- Pour finir la boîte de dialogue revient, avec tous les champs préalablement remplis et le point d'insertion pris en compte dans une variable.

 

En fait pour tout te dire, le problème vient du fait que je ne comprends pas les done_dialog et start_dialog... Donc faut vraiment que je trouve des définitions pour comprendre ce qui se passe...

 

Merci encore pour ton aide, et à bientot !!

 

Vive la Bretagne !!!

Take care.

Matt.

 

[Patrick_35]

- je clique d'abord sur le bouton qui permet de sortir de la boîte de dialogue (donc action_tile)

Non

 

je clique d'abord sur le bouton

Donc action_tile

 

sortir de la boîte de dialogue

C'est le (done_dialog n)

La valeur n est la valeur que peut prendre le (start_dialog)

 

Pour finir la boîte de dialogue revient

Du moment que c'est dans une boucle comme tu l'as fait

J'ai ce tutorial en anglais, mais qui est très bien fait

 

@+

[(gile)]

Salut,

 

tu trouveras un exemple simple pour fermer une boite de dialogue le temps d'une sélection à l'écran ici (hidedcl).

[Matt666]

Bonjour !

 

Tout d'abord un grand merci à Patrick_35 et (gile) pour leurs conseils, ça m'a beaucoup aidé....

 

J'ai enfin réussi à masquer la boîte de dialogue lors du clic sur un bouton de sélection... J'avais juste un problème de parenthèses (tiens donc !!!) dans mon lisp !

En fin de compte mon "new_dialog" n'était pas au sein de la boucle, donc forcément, il n'allait pas la rappeler !!

 

Voilà... Maintenant j'ai un autre soucis... Je suis conscient d'être un chiant, mais si vous pouviez m'aider, ça m'arrangerait beaucoup !

 

C'est au sujet des boutons radios...

Je n'arrive pas à affecter une variable lorsque je choisis un bouton radio...

Le problème aussi c'est que j'aimerai affecter un bouton radio coché par défaut, puisque ce sera le paramètre le plus courant...

 

Je ne sais pas si je suis clair, alors je vous montre d'abord le dcl, qui se nomme essai.dcl...

dincr : dialog {
 aspect_ratio = 0 ; 
 initial_focus
= "Incmtvald";
 label = "Incrémentation caractères" ;
 : column {
   : radio_row { label = "Mode" ; key = "box1";
     : radio_button { label = "Numérique"; key = "incmtnum"; value = "1" ;}
     : radio_button { label = "Alphabétique"; key = "incmtalp" ;}
   }
   :boxed_column { label = "Valeur textes" ; key = "box2";
     : edit_box { label = "Valeur de Début :"; is_tab_stop = True; key ="Incmtvald"; mnemonic = "d"; edit_width=10 ; }
     : edit_box { label = "Valeur de Fin :"; key ="Incmtvalf"; mnemonic = "f"; edit_width=10 ; }
     : edit_box { label = "Incrément :"; key ="Incmtincmt"; mnemonic = "I"; edit_width=10 ; }
   }
   :boxed_column { label = "Position textes" ; key = "box3";
     : row {
       : text {
         label = "Point de départ :";
         alignment = left;
         fixed_width=true;
         width=10;
       }
       : button {
         label = ">>";
         mnemonic = "o";
         alignment=right;
         key = "incmpt";
         fixed_width=true;
         width=10;
       }
    }
    : row {
      : text {label = "Décalage :                  "; alignment = left; }
      : button {
         label = ">>";
         mnemonic = "d";
         fixed_width=true;
         width=4;
         key = "incmdec";
      }
      : edit_box {
         label = "";
         key ="Incmtdec";
         mnemonic = "e";
         alignment=right;
         fixed_width=true;
         width=10;
      }
    }
   : row {
     : text {label = "Direction (en degrés) :"; alignment = left; }
     : button {label = ">>"; mnemonic = "r"; fixed_width=true; width=4; key = "Incmdir";}
     : edit_box { label = ""; key ="Incmtdir"; mnemonic = "i"; alignment=right; fixed_width=true ; width=10; }
     }
   }
}
   :boxed_column { label = "Options de texte" ; key = "box4";
     : edit_box { label = "Hauteur :"; key ="Incmthtext"; mnemonic = "h"; edit_width=10 ; }
     : edit_box { label = "Angle rotation :"; key ="Incmtang"; mnemonic = "a"; edit_width=10 ; }
     : popup_list {
            label = "Justification :                        " ;
            list = "Gauche\nCentre\nDroite" ;
     value = "0" ;
            key ="Incmtjust";
            popup_height = 50 ;
            alignment = right ;
            mnemonic = "j";
            edit_width=15 ;
     }
   }
 ok_cancel ;
 spacer ;
}

 

Voilà pour le dcl... priori, je ne vois aucun problème dans ce fichier...

Maintenant le lisp. C'est là que ça se gâte !!! Pour infos, pour l'instant il n'y a aucun traitement des valeurs des champs, j'essaie juste de rappatrier les données de la boîte de dialogue...

 

Le fichier se nomme essai.lsp (original dites-donc !!)

 
(defun C:essai ()
    (while dcl_id (unload_dialog dcl_id)(setq dcl_id nil))
    (setq dcl_id (load_dialog "essai.dcl"))
    (setq loop 2 bug 0)
    (while (and (>= loop 2) (< bug 20))
         (if (not (new_dialog "dincr" dcl_id))
              (progn (princ "\nBoîte de dialogue 'essai.dcl' introuvable.") (exit))
         )
         (setq bug (1+ bug))
         (action_tile "Incmtnum" "(setq modan 1)")
         (action_tile "Incmtalp" "(setq modan 2)")
         (action_tile "Incmtvalf" "(progn (setq Incmtvalf $value))")
         (action_tile "Incmtincmt" "(progn (setq Incmtincmt $value))")
         (action_tile "Incmtdec" "(progn (setq Incmtdec $value))")
         (action_tile "Incmtdir" "(progn (setq Incmtdir $value))")
         (action_tile "Incmthtext" "(progn (setq Incmthtext $value))")
         (action_tile "Incmtang" "(progn (setq Incmtang $value))")
         (action_tile "Incmtjust" "(setq Incmtjust $value)")
         (action_tile "cancel" "(done_dialog 0)")
         (action_tile "accept" "(done_dialog 1)")
         (action_tile "incmpt" "(done_dialog 3)")
         (action_tile "incmdec" "(done_dialog 4)")
         (action_tile "Incmdir" "(done_dialog 5)")
         (if modan 
              (progn 
                   (if (eq modan 1)
                        (progn 
                             (set_tile "incmtnum" "1")
                             (set_tile "incmtalp" "0")
                        )
                        (if (eq modan 2)
                             (progn
                                  (set_tile "incmtalp" "1")
                                  (set_tile "incmtnum" "0")
                             )
                             (setq modan (get_tile "box1"))
                        )
                   )
              )
         )
         (if Incmtdec (set_tile "Incmtdec" Incmtdec))
         (if Incmtdir (set_tile "Incmtdir" Incmtdir))
         (if Incmthtext (set_tile "Incmthtext" Incmthtext))
         (if Incmtang (set_tile "Incmtang" Incmtang))
         (if Incmtjust (set_tile "Incmtjust" Incmtjust)(setq incmtjust (get_tile "Incmtjust")))
         (if (and incmtvald incmtvalf)
              (if (> incmtvald incmtvalf)
                   (princ (strcat 
                             "\nLa valeur de début (" (itoa incmtvald) ") doit être inférieure à la valeur de fin (" (itoa incmtvalf) ")."
                   ))
                   (progn 
                        (if incmtvald (set_tile "Incmtvald" incmtvald))
                        (if Incmtvalf (set_tile "Incmtvalf" Incmtvalf))
                        (if Incmtincmt (set_tile "Incmtincmt" Incmtincmt))
                   ) ; end of progn
              ) ; end of if
         ) ; end of if
         (setq loop (start_dialog))
         (cond 
              ((eq loop 3) 
                   (setq ptstart (getpoint "Point de départ : "))
              )
              ((eq loop 4)
                   (setq displ (getdist (if (null ptstart) (setq ptstart (getpoint "Premier point du décalage :"))ptstart)  "\nDécalage : "))
                   (setq incmtdec (rtos displ 2 2))
              )
              ((eq loop 5)
                   (setq ptang (getangle (if (null ptstart) (setq ptstart (getpoint "point de départ de l'angle :"))ptstart) "\nDirection : "))
                   (setq incmtdir (angtos ptang))
              )
              ((eq loop 0)(prompt "\nFonction annulée..."))
              ((eq loop 1)
                   (if (eq modan "Incmtnum")(princ "\nAlphabétique...")(princ "\nAucune valeur dans le champ modan num."))
                   (if (eq modan "Incmtalp")(princ "\nNumérique...")(princ "\nAucune valeur dans le champ modan alpha."))
                   (if Incmtvald (princ "\nValeur de champ début Incmtvald ok.")(princ "\nAucune valeur dans le champ début."))
                   (if Incmtvalf (princ "\nValeur de champ fin Incmtvalf ok.")(princ "\nAucune valeur dans le champ fin."))
                   (if Incmtincmt (princ "\nValeur de champ incrément Incmtincmt ok.")(princ "\nAucune valeur dans le champ incrément."))
                   (if Incmtjust (princ "\nValeur de champ incrément Incmtjust ok.")(princ "\nAucune valeur dans le champ justification."))
                   
              )
         ) ; end of cond
         (if (eq bug 20) (princ "\nAttention boucle redondante."))
    ) ; end of while
    (unload_dialog dcl_id)
    (princ)
)

 

Voilà... Personnellement je suis perdu, là ! C'est la valeur provenant d'un des champs ci dessous qui m'intéresse..

: radio_row { label = "Mode" ; key = "box1";
     : radio_button { label = "Numérique"; key = "incmtnum"; value = "1" ;}
     : radio_button { label = "Alphabétique"; key = "incmtalp" ;}
   }

 

codée dans le lisp comme ceci...

(action_tile "Incmtnum" "(setq modan 1)")
(action_tile "Incmtalp" "(setq modan 2)")

 
(if modan 
 (progn 
   (if (eq modan 1)
     (progn 
       (set_tile "incmtnum" "1")
       (set_tile "incmtalp" "0")
     ); end of progn
     (if (eq modan 2)
       (progn
         (set_tile "incmtalp" "1")
         (set_tile "incmtnum" "0")
       ); end of progn
       (setq modan (get_tile "box1"))
     ); end of if
   ); end of if
 ) ; end of progn
); end of if

Bon j'ai essayé plein de trucs, donc il se pourrait que vous rigoliez à voir les conditions pour la variable "modan", qui prend la valeur des boutons radios... désespéré, je vous dis !!

 

Voilà... J'espère avoir été assez clair !

 

Au fait, Patrick_35 (35 de Rennes ?), j'ai vu que tu avais déjà répondu à qqn pour ce genre de problème, mais je n'ai pas réussi à régler le mien avec tes exemples....

http:// http://www.cadxp.com/modules.php?op=modload&name=XForum&file=viewthread&tid=15311

 

Merci d'avance, et longue vie à ce très bon forum !

[Matt666]

Voici une copie d'écran de la boîte dialogue que j'ai créée... Attention c'est ma première boîte de dialogue, pas de moqueries !!!

 

http://xs116.xs.to/xs116/07234/incmt.jpg

[Patrick_35]

Pour une première boite, bravo :)

Sinon, pour te simplifier la vie

Dans ton dcl

: radio_row { label = "Mode" ; key = "box1";
: radio_button { label = "Numérique"; key = "mode1";;}
: radio_button { label = "Alphabétique"; key = "mode2" ;}
}

Dans le lisp

...
(or modan
 (setq modan "1")
) ; pour initialiser la variable la 1ère fois
...
(mode_tile (strcat "mode" modan) 2)
...
(action_tile "mode1" "(setq modan \"1\")")
(action_tile "mode2" "(setq modan \"2\")")
...

 

@+

[Matt666]

Alors là, bluffé....Génial ça marche !!

 

Je sais pas d'où tu as sorti le

(or modan (setq modan "1"))

, c'est la première fois que je vois ça... D'ailleurs je comprends mal la logique du OR, je vais chercher... Mais merci, ça marche très bien maintenant !!

 

Je vous donnerai les codes de tout ça une fois que ce sera fini... Yen a plus pour longtemps, maintenant !

 

Merci encore, et bonne continuation !!

 

A bientôt pour d'autres questions...

[Matt666]

Eh oui c'est remoi.... Bon voilà j'ai fini ma routine, et elle tourne très bien !!

Merci encore à vous, pour vos conseils et votre patience...

 

Mais avant de vous donner cette routine, j'ai encore une question... Une dernière j'espère !

 

J'ai lu sur ce site

http://aidacad.com/fr/aiddcl.htm

Qu'on pouvait intégrer le fichier dcl au sein du fichier lisp, pour éviter à Autocad de chercher partout :)

Est-ce que vous avez une idée de comment faire ??

 

Voilà...

Merci d'avance !

 

Matt.

[(gile)]

Salut,

 

(or modan (setq modan "1"))

 

C'est une autre manière (élégante a mon goût) d'écrire :

 

(if (not modan)
 (setq modan "1")
)

 

La fonction or évalue les expressions successives jusqu'à ce qu'une des expressions retourne une valeur autre que nil. Si modan est non nil l'évaluation s'arrête et retourne T, si modan est nil, l'expression suivante est évaluée : "1" est attribué à modan et l'expression (or ...) retourne T.

 

La différence avec (if ...) est le résultat retourné par l'expression (T au lieu de la valeur de modan), je trouve que c'est regrétable, mais bon ...

 

 

intégrer le fichier dcl au sein du fichier lisp

Je te propose deux solutions pour "compiler" LISP et DCL en un seul fichier.

 

1_ Tu peux créer une application (fichier VLX), ce fichier sera illisible et non modifiable (crypté) ce qui peut être considéré comme un avantage ou un inconvénient, c'est selon ... Voir ici.

 

2_ Tu peux écrire ton DCL dans un fichier temporaire :

 

(defun C:essai (/ tmp-dcl file dcl_id) ; variables locales

(setq tmp-dcl (vl-filename-mktemp nil nil ".dcl")
     file    (open tmp-dcl "w")
)
(write-line
 "dincr : dialog {
aspect_ratio = 0 ;
initial_focus = \"Incmtvald\";
label = \"Incrémentation caractères\" ;

;; le reste du texte du DCL (penser à mettre un \ avant chaque guillemet)

ok_cancel ;
spacer ;
}"
 file
)
(close file)

(setq dcl_id (load_dialog temp-dcl))
(if (not (new_dialog "dincr" dcl_id))
 (exit)
) 

;; La suite du LISP

(unload_dialog dcl_id)
(princ)
)

 

[Edité le 7/6/2007 par (gile)]

[(gile)]

Un exemple concret d'utilisation d'un fichier DCL temporaire avec le LISP hidedcl.

 

(defun c:hidedcl (/ tmp-dcl file dcl_id what_next pt)

 ;; Écriture du fichier DCL temporaire
 (setq	tmp-dcl	(vl-filename-mktemp nil nil ".dcl")
file	(open tmp-dcl "w")
 )
 (write-line
   "hidedcl:dialog{
   label=\"Hide exemple\";
   : boxed_column{
   label=\"Sélectionner un point\";
   :row{
   :row{
   :retirement_button{
   label = \"Choisir le point >>\";
   key = \"hide\";
   mnemonic = \"H\";
   alignment= centered;
   }
   }
   :column{
   :edit_box{
   label=\"X\";
   key=\"x_coord\";
   value=\"0.0000\";
   fixed_width=true;
   allow_accept=true;
   }
   :edit_box{
   label=\"Y\";
   key=\"y_coord\";
   value=\"0.0000\";
   fixed_width=true;
   allow_accept=true;
   }
   :edit_box{
   label=\"Z\";
   key=\"z_coord\";
   value=\"0.0000\";
   fixed_width=true;
   allow_accept=true;
   }
   }
   }
   }
   ok_cancel;
   }"
   file
 )
 (close file)

 ;; Chargement du fichier DCL temporaire
 (setq dcl_id (load_dialog tmp-dcl))

 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "hidedcl" dcl_id))
     (exit)
   )
   (action_tile
     "accept"
     (strcat
"(progn"
"(setq pt (list (atof (get_tile \"x_coord\"))"
"(atof (get_tile \"y_coord\"))"
"(atof (get_tile \"z_coord\"))))"
"(done_dialog 1)"
"(princ pt))"
      )
   )
   (action_tile
     "hide"
     "(done_dialog 4)"
   )
   (if	pt
     (progn
(set_tile "x_coord" (rtos (car pt)))
(set_tile "y_coord" (rtos (cadr pt)))
(set_tile "z_coord" (rtos (caddr pt)))
     )
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 4)
      (setq pt (getpoint "\nSélectionnez un point: "))
     )
     ((= what_next 0)
      (prompt "\nFONCTION ANNULEE")
     )
   )
 )
 (unload_dialog dcl_id)
 (princ)
) 

[Matt666]

Salut !! Merci (gile) de ta réponse rapide et concise...

 

Le problème c'est que je n'utilise pas AutoCad, mais BricsCad, basé sur un moteur IntelliCad. Ce logiciel ne supporte pas le VLX...

 

J'ai l'impression que toi et patrick_35 aimez beaucoup le VLX... je ne connais pas ses possibilités (elles doivent être conséquentes !!), mais j'avoue que de voir "(vl-filename-mktemp...)", bref un bon gros VL me filerai limite des boutons !!! :)

 

Peut-être cela vient-il du fait que

- je ne peux pas l'exploiter,

- mais surement aussi que je trouve qu'utiliser le VLX dans une routine lisp revient à utiliser "command" alors qu'un bon vieux "entmake" est beaucoup plus..... noble? en tout cas plus sain ou beau...

 

Je ne sais pas comment dire ceci, et tu dois me trouver extrême autant que fou, mais voilà je ne peux et ne veux pas utiliser de VLX....

 

Hum hum... Mais merci quand même ! Je ne remets pas en cause la qualité de ta réponse, très très bien, vraiment !!

 

Voilà. Si je vous saoule, promis je ferai deux fichiers !

Dites moi, vraiment !!

 

Merci !

A bientôt.... Et longue vie à ce forum !

Matt.

[Patrick_35]

Salut

Tu confonds le fichier compilé (vlx) et le visual-lisp

Un fichier compilé permet de regrouper le lsp et le dcl et se charge comme n'importe quel lsp

le visual lisp est l'évolution d'autolisp agrémenté des fonctions activex (vlax-...), des réacteurs (vlr-...), de fonctions plus évoluées (vl-...) et sans oublié les (vla-...) qui sont un vba à la mode lisp

Je me suis amusé à comparer le trie d'une liste entre acad_strlsort et vl-sort. Eh bien, le vl-sort est trois fois plus rapide.

 

Juste un aperçu et pour le fun (si tu veux faire une blague avec autocad, ce lisp est l'idéal ;) )

 

(defun autocad_qui_parle (texte / sapi)
 (setq sapi (vlax-create-object "Sapi.SpVoice"))
 (vlax-invoke sapi "Speak" texte 0)
 (vlax-release-object sapi)
)

(defun autocad_qui_parle_debut (rea cde)
 (autocad_qui_parle (strcat "La commande ," (getcname (strcat "_" (car cde))) " commence"))
)

(defun autocad_qui_parle_inconnu (rea cde)
 (autocad_qui_parle (strcat "Commande inconnu ," (car cde)))
)

(defun autocad_qui_parle_cancel (rea cde)
 (autocad_qui_parle (strcat "La commande ," (getcname (strcat "_" (car cde))) " est abandonnée"))
)

(defun autocad_qui_parle_failed (rea cde)
 (autocad_qui_parle (strcat "La commande ," (getcname (strcat "_" (car cde))) " est interrompue"))
)

(defun autocad_qui_parle_fin (rea cde)
 (autocad_qui_parle (strcat "La commande ," (getcname (strcat "_" (car cde))) " est terminée"))
)

(or pourrir_la_vie
 (setq pourrir_la_vie (vlr-command-reactor nil (list	(cons :vlr-commandWillStart (function autocad_qui_parle_debut))
					       	(cons :vlr-unknownCommand   (function autocad_qui_parle_inconnu))
					       	(cons :vlr-commandCancelled (function autocad_qui_parle_cancel))
					       	(cons :vlr-commandFailed    (function autocad_qui_parle_failed))
					       	(cons :vlr-commandEnded     (function autocad_qui_parle_fin))
					 )
 		       )
 )
)
(princ)

 

Pour effacer les réacteurs et qu'autocad ne parle plus continuellement, tu fais

(vlr-remove pourrir_la_vie)

 

et pour avoir la voix en français

 

@+

[Matt666]

Ah oui euh pardon !! Effectivement VLX et VL, c'est pas la même chose..

 

Ce qui ne résout quand même pas mon problème... BricsCad ne sait ni lire le FAS, ni le VLX... Raah c'est bien les logiciels pas chers !!

 

J'ai envoyé une demande d'information directement chez BrisCad, pour voir ce qu'ils en pensent. Je vous informerai de la réponse, si elle vous intéresse bien sur !

 

Je comprends mieux maintenant l'intérêt des fonctions supplémentaires de visual lisp... Plus de facilité, rapidité, etc... Dommage que BricsCad n'utilise que de l'autolisp...

 

Sur le problème de regroupement des fichiers, je reste persuadé qu'on peut scindé les deux directement en un seul lisp... Je continue à chercher de mon coté...

 

Merci à vous deux de m'aider comme ça...

 

A bientot !

-Chacun compte pour un, et nul ne compte pour plus d'un- Jeremy Bentham.

[(gile)]

Je vais essayer de faire une routine équivalente à vl-filename-mktemp, comme je l'avais fait pour plusieurs fonctions vl-. (voir ici).

[(gile)]

Voici une première tentative d'alternative à vl-filename-mktemp, je ne suis pas sûr que ça puisse fonctionner en l'état dans d'autres logiciel qu'AutoCAD. Les variables d'environnement TMP et TEMP existent-elles ? La variable système DWGPREFIX existe-t-elle aussi ?

À tester ...

 

Sinon, il y a certainement moyen de faire quelque chose de moins "générique", plus "spécifique" à l'écriture d'un fichier DCL dans un dossier du chemin de recherche de ton logiciel.

 

EDIT : apporté quelques modifications pour que le comportement ressemble plus à celui de la fonction vl-filename-mktemp.

 

;; filename-mktemp
;; Tentative de fonction équivalente à vl-filename-mktemp pour les logiciels
;; ou applications qui n'ont pas de fonctions vl-*
;;
;; Calcule un nom de fichier unique pour être utilisé comme fichier temporaire
;;
;; Arguments :
;; - nom : chaine de caractères, le modèle du nom du fichier ou nil.
;; Si nil : $VL~~ est utilisé
;;
;; - rep : chaine de caractères, le chemin du dossier ou nil.
;; Si nil : un répertoire est choisit dans l'ordre suivant :
;; - le répertoire spécifié dans la variable d'environnement TMP
;; - le répertoire spécifié dans la variable d'environnement TEMP
;; - le répertoire courant (variable système DWGPREFIX)
;;
;; ext : chaine de caractères, l'extension du fichier ou nil
;; Si nil : extension spécifiée dans l'argument nom (peut être une chaine vide)
;;
;; Retour
;; Une chaine de caractère qui contient le chemin et le nom du fichier du style :
;; Chemin_du_répertoire\basexxx.extension
;; où base est constitué au plus des 5 premiers caractères de l'argument nom
;; et xxx une chaine hexadécimale incrémentée.
;;
;; Exemples :
;;
;; (filename-mktemp nil nil nil) -> "C:\\DOCUME~1\\XXX~1\\LOCALS~1\\Temp\\$VL~~001"
;; (filename-mktemp nil nil ".txt") -> "C:\\DOCUME~1\\XXX~1\\LOCALS~1\\Temp\\$VL~~002.txt"
;; (filename-mktemp "temporaire.txt" nil nil) -> "C:\\DOCUME~1\\XXX~1\\LOCALS~1\\Temp\\tempo003.txt"
;; (filename-mktemp "temporaire" "C:" ".txt") -> "C:\\tempo004.txt"
;;
;; NOTA : Cette routine utilise HEX de Patrick_35 ainsi que d'autres routines équivalentes à des
;; fonctions vl- (file-name-extension, string-position, string-right-trim, string->list, position)
;; disponibles sur CADxp :
;;
;; http://www.cadxp.com/modules.php?op=modload&name=XForum&fil e=viewthread&tid=8465#pid

(defun filename-mktemp (nom rep ext / str pos)
 (if *mktempinc*
   (setq *mktempinc* (1+ *mktempinc*))
   (setq *mktempinc* 1)
 )
 (and nom (setq pos (string-position (ascii ".") nom nil T)))
 (and rep (setq rep (string-right-trim "\\/" rep)))
 (setq	ext (cond
      (ext)
      (pos (substr nom (1+ pos)))
      ("")
    )
nom (if	nom
      (if pos
	(substr nom 1 (min 5 pos))
	(substr nom 1 5)
      )
      "$VL~~"
    )
rep (cond
      ((and rep
	    (not (filename-extension rep))
	    (findfile rep)
       )
       rep
      )
      ((getenv "TMP"))
      ((getenv "TEMP"))
      ((getvar "DWGPREFIX"))
    )
 )
 (while (findfile
   (setq str
	  (strcat
	    rep
	    "\\"
	    nom
	    ((lambda (x)
	       (cond
		 ((= (strlen x) 1) (strcat "00" x))
		 ((= (strlen x) 2) (strcat "0" x))
		 (x)
	       )
	     )
	      (hex *mktempinc*)
	    )
	    ext
	  )
   )
 )
   (setq *mktempinc* (1+ *mktempinc*))
 )
 str
)


;; HEX Patrick_35
;; convertit un entier en hexadécimal

(defun hex (n / r i)
 (setq r "")
 (while (> n 0)
   (setq i (rem n 16)
  n (lsh n -4)
  r (strcat
      (if (		(itoa i)
	(chr (+ 55 i))
      )
      r
    )
   )
 )
) 

[Edité le 9/6/2007 par (gile)]

 

[Edité le 10/6/2007 par (gile)]

[Matt666]

Dément.... Simplement dément !!! J'adhère totalement à cette initiative... On signe où ???

 

Pour la dernière routine, je tente ça direc' lundi... Je te'en donnerai des news.... Mais faut que je regarde ça d'un peu plus près... Ca me taquine cette histoire de fichier temporaire !

 

Merci pour tout, et a bientot !!

 

Matt.

[Matt666]

Salut !

 

Bon eh bien voilà, j'ai essayé la fameuse routine qui permet de créer un fichier dcl temporaire ..

 

Et j'ai un petit soucis, enfin deux pour être exact... BricsCad (le logiciel basé sur le moteur IntelliCad), tout comme AutoCad ne connait pas les fonctions "string-position" et "string-right-trim"...

 

Pourrais-tu m'expliquer à quoi elles correspondent, et quelles actions elles produisent au sein de ce lisp.... Parce que ce lisp est bien balaise, bravo !! Ca dépasse de très loin mes (petites) compétences de développement lisp...

 

Merci !!

 

Bon courage pour la suite...

 

Matt.

 

[(gile)]

Salut,

 

C'est écrit dans le commentaire du LISP, les routines sont ici, je te conseille de les charger toutes, certaines en appellent d'autres dans leur définition.

[Matt666]

Rooh la classe chu passé ceinture jaune !! Tout ça en ne posant que des questions (débiles parfois... souvent !!)...

 

Comme celle à laquelle tu viens de répondre, gile !!!!

 

Merci, ça fonctionne bien maintenant. Ta routine "filename-mktemp" est très pratique merci !!!

 

Maintenant, j'ai encore autre chose à te demander.... Décidément.. Le bougre.. Peut pas se débrouiller tout seuf sui là... Relou.

 

Voilà : J'ai ouvert 5 ou 6 fois la routine, ce qui a généré 5 ou 6 fichiers DCL différents !

 

La ligne de code est celle-ci :

(setq 
tmp-dcl (filename-mktemp "incmt" "c:\\program files\\Bricscad\\Bricscad" ".dcl")
file (open tmp-dcl "w")
)

 

Ce que j'aimerais bien (tu dois t'en douter, je pense) ce serait d'avoir une condition à cette routine !

Genre si un "incmtXXX.dcl" existe, réutiliser celui-ci !

Voilà... Ca doit pas être bien compliqué, mais bon j'ai un pb de compréhension dès que la routine n'est pas moi...

 

D'ailleurs ta routine est assez ardue, la bougresse ! En fait je ne savais pas qu'on pouvait donner une variable à une fonction ! C'est assez génial comme truc....

Sinon g un peu étudié les réacteurs visual lisp, et j'avoue être très très malheureux de ne pas avoir la possibilité de les utiliser dans BricsCad... Sniff.

 

Voilà. Merci pour tout, c'est vraiment cool d'aider comme ça !

bravo, bravo, et bravo !

 

Matt.

 

 

 

[(gile)]

Voilà : J'ai ouvert 5 ou 6 fois la routine, ce qui a généré 5 ou 6 fichiers DCL différents !

 

Eh oui, c'est comme ça que fonctionne vl-filename-mktemp et j'ai essayer que ma routine ait le même comportement. Si tu ne spécifies pas de chemin (argument rep) les fichiers sont créés dans le répertoire de fichiers temporaires (C:\Documents and Settings\xxx\Local Settings\Temp), répertoire qu'il est bon de "nettoyer" régulièrement.

 

Si tu veux toujours mettre les fichiers DCL dans un répertoire particulier, tu peux faire, directement depuis ton LISP, un test pour savoir si le fichier existe et sinon le créer.

 

Exemple avec hidedcl :

 

(defun c:hidedcl (/ dcl file dcl_id what_next pt)

 ;; Écriture du fichier DCL dans le répertoire spécifié s'il n'existe pas déjà
 (setq	dcl "C:\\Program Files\\Bricscad\\Bricscad\\hidedcl.dcl"))
   (or
     (findfile dcl)
     (and
(setq file (open dcl "w"))
(write-line
  "hidedcl:dialog{
label=\"Hide exemple\";
: boxed_column{
label=\"Sélectionner un point\";
:row{
:row{
:retirement_button{
label = \"Choisir le point >>\";
key = \"hide\";
mnemonic = \"H\";
alignment= centered;
}
}
:column{
:edit_box{
label=\"X\";
key=\"x_coord\";
value=\"0.0000\";
fixed_width=true;
allow_accept=true;
}
:edit_box{
label=\"Y\";
key=\"y_coord\";
value=\"0.0000\";
fixed_width=true;
allow_accept=true;
}
:edit_box{
label=\"Z\";
key=\"z_coord\";
value=\"0.0000\";
fixed_width=true;
allow_accept=true;
}
}
}
}
ok_cancel;
}"
  file
)
(close file)
     )
   )

 ;; Chargement du fichier DCL
 (setq dcl_id (load_dialog dcl))

 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "hidedcl" dcl_id))
     (exit)
   )
   (action_tile
     "accept"
     (strcat
"(progn"
"(setq pt (list (atof (get_tile \"x_coord\"))"
"(atof (get_tile \"y_coord\"))"
"(atof (get_tile \"z_coord\"))))"
"(done_dialog 1)"
"(princ pt))"
      )
   )
   (action_tile
     "hide"
     "(done_dialog 4)"
   )
   (if	pt
     (progn
(set_tile "x_coord" (rtos (car pt)))
(set_tile "y_coord" (rtos (cadr pt)))
(set_tile "z_coord" (rtos (caddr pt)))
     )
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 4)
      (setq pt (getpoint "\nSélectionnez un point: "))
     )
     ((= what_next 0)
      (prompt "\nFONCTION ANNULEE")
     )
   )
 )
 (unload_dialog dcl_id)
 (princ)
)