Boites de dialogue (DCL temporaire)

[(gile)]

Dans le même esprit que InputBox ou GetLayers, deux petites boites de dialogue sans fichier DCL séparé.

Le DCL est créé dans un fichier temporaire depuis le LISP et supprimé ensuite.

 

Cette méthode permet d'éviter de s'embarasser d'un fichier DCL à mettre dans un répertoire du chemin de recherche.

Ces deux routines se veulent polyvalentes pour pouvoir être utilisées facilement dans d'autres LISP. Elles ne demandent qu'un argument : le titre de la boite de dialogue (ou nil pour le titre par défaut)

 

GetBlock (uilisé ici, ou là ou encore là) pour récupérer le nom d'un bloc soit :

- en le sélectionnant

- en entrant son nom

- depuis la boite de dialogue getfiled ;

- dans une liste déroulante contenant tous les blocs du dessin.

 

seuls les noms de blocs (ou fichiers dwg) valides sont retenus.

 

;;; Getblock (gile) 03/11/07
;;; Retourne le nom du bloc entré ou choisi par l'utilisateur 
;;; dans une liste déroulante de la boite de dialogue ou depuis la boite
;;; de dialogue standard d'AutoCAD
;;; Argument : le titre (string) ou nil (défaut : "Choisir un bloc")

(defun getblock	(titre / bloc n lst tmp file what_next dcl_id nom)
 (vl-load-com)
 (while (setq bloc (tblnext "BLOCK" (not bloc)))
   (setq lst (cons (cdr (assoc 2 bloc)) lst)
   )
 )
 (setq	lst  (acad_strlsort
       (vl-remove-if
	 (function (lambda (n) (= (substr n 1 1) "*")))
	 lst
       )
     )
tmp  (vl-filename-mktemp "Tmp.dcl")
file (open tmp "w")
 )
 (write-line
   (strcat
     "getblock:dialog{label="
     (cond (titre (vl-prin1-to-string titre))
    ("\"Choisir un bloc\"")
     )
     ";initial_focus=\"bl\";:boxed_column{
     :row{:text{label=\"Sélectionner\";alignment=left;}
     :button{label=\">>\";key=\"sel\";alignment=right;fixed_width=true;}}
     spacer;:column{
     :button{label=\"Parcourir...\";key=\"wbl\";alignment=right;fixed_width=true;}}
     :column{:text{label=\"Nom :\";alignment=left;}}
     :edit_box{key=\"tp\";edit_width=25;}
     :popup_list{key=\"bl\";edit_width=25;}spacer;}
     spacer;
     ok_cancel;}"
   )
   file
 )
 (close file)
 (setq dcl_id (load_dialog tmp))
 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "getblock" dcl_id))
     (exit)
   )
   (start_list "bl")
   (mapcar 'add_list lst)
   (end_list)
   (if	(setq n	(vl-position
	  (strcase (getvar "INSNAME"))
	  (mapcar 'strcase lst)
	)
)
     (setq nom (nth n lst))
     (setq nom	(car lst)
    n	0
     )
   )
   (set_tile "bl" (itoa n))
   (action_tile "sel" "(done_dialog 5)")
   (action_tile "bl" "(setq nom (nth (atoi $value) lst))")
   (action_tile "wbl" "(done_dialog 3)")
   (action_tile "tp" "(setq nom $value) (done_dialog 4)")
   (action_tile
     "accept"
     "(setq nom (nth (atoi (get_tile \"bl\")) lst)) (done_dialog 1)"
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 3)
      (if (setq nom (getfiled "Sélectionner un fichier" "" "dwg" 0))
 (setq what_next 1)
 (setq what_next 2)
      )
     )
     ((= what_next 4)
      (cond
 ((not (read nom))
  (setq what_next 2)
 )
 ((tblsearch "BLOCK" nom)
  (setq what_next 1)
 )
 ((findfile (setq nom (strcat nom ".dwg")))
  (setq what_next 1)
 )
 (T
  (alert (strcat "Le fichier \"" nom "\" est introuvable."))
  (setq	nom nil
	what_next 2
  )
 )
      )
     )
     ((= what_next 5)
      (if (and	(setq ent (car (entsel)))
	(= "INSERT" (cdr (assoc 0 (entget ent))))
   )
 (setq nom	 (cdr (assoc 2 (entget ent)))
       what_next 1
 )
 (setq what_next 2)
      )
     )
     ((= what_next 0)
      (setq nom nil)
     )
   )
 )
 (unload_dialog dcl_id)
 (vl-file-delete tmp)
 nom
) 

 

GetLayer (utilisé ici) pour récupérer un nom de calque soit :

- en sélectionnant un objet ;

- en entrant le nom ;

- en choisissant dans la liste déoulante.

 

;;; GetLayer (gile) 03/11/07
;;; Retourne le nom du calque entré ou choisi par l'utilisateur 
;;; dans une liste déroulante de la boite de dialogue ou en sélectionnant
;;; un objet à l'écran.
;;; Argument : le titre (string) ou nil (défaut : "Choisir un calque")

(defun getlayer	(titre / lay lst tmp file what_next dcl_id nom)
 (while (setq lay (tblnext "LAYER" (not lay)))
   (setq lst (cons (cdr (assoc 2 lay)) lst))
 )
 (setq	lst  (acad_strlsort lst)
tmp  (vl-filename-mktemp "Tmp.dcl")
file (open tmp "w")
 )
 (write-line
   (strcat
     "getlayer:dialog{label="
     (cond (titre (vl-prin1-to-string titre))
    ("\"Choisir un calque\"")
     )
     ";initial_focus=\"tp\";
     :boxed_column{:row{
     :column{:text{label=\"Sélectionner un objet\";alignment=left;}}
     :column{:button{label=\">>\";key=\"obj\";alignment=right;fixed_width=true;}
     spacer;}}
     :edit_box{key=\"tp\";edit_width=25;allow_accept=true;}
     :popup_list{key=\"lay\";edit_width=25;}
     spacer;}ok_cancel;}"
   )
   file
 )
 (close file)
 (setq dcl_id (load_dialog tmp))
 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "getlayer" dcl_id))
     (exit)
   )
   (start_list "lay")
   (mapcar 'add_list lst)
   (end_list)
   (or	nom
(setq nom (vlax-ldata-get "getLayer" "n"))
(setq nom (vlax-ldata-put "getLayer" "n" "0"))
   )
   (if	(member nom lst)
     (set_tile	"lay"
	(itoa (- (length lst) (length (member nom lst))))
     )
     (set_tile "lay" "0")
   )
   (set_tile "tp" nom)
   (action_tile "obj" "(done_dialog 3)")
   (action_tile "tp" "(setq nom $value)")
   (action_tile
     "lay"
     (strcat
"(if (or (= $reason 1) (= $reason 4))"
"(progn"
"(setq nom (nth (atoi $value) lst))"
"(set_tile \"tp\" (nth (atoi $value) lst))"
"(mode_tile \"tp\" 2)))"
      )
   )
   (action_tile
     "accept"
     (strcat
"(if (tblsearch \"LAYER\" nom)"
"(progn (done_dialog 1)"
"(vlax-ldata-put \"getLayer\" \"n\" nom))"
"(progn"
"(alert (strcat \"Le calque \" nom \" est introuvable.\"))"
"(setq nom nil) (set_tile \"tp\" (vlax-ldata-get \"getLayer\" \"n\"))"
"(mode_tile \"tp\" 2)))"
      )
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 3)
      (if (setq nom (car (entsel)))
 (setq nom (cdr (assoc 8 (entget nom))))
 (setq nom nil)
      )
     )
     ((= what_next 0)
      (setq nom nil)
     )
   )
 )
 (unload_dialog dcl_id)
 (vl-file-delete tmp)
 nom
) 

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

 

[Edité le 8/11/2007 par (gile)]

[(gile)]

La dernière version de GetLayers (3 arguments).

 

GetLayers retourne la liste de calques cochés dans la boite de dialogue.

Les arguments requis sont :

- le titre (ou nil)

- la liste des calques qui seront "pré-cochés" à l'ouverture de la boite (ou nil)

- la liste des calques non cochables (grisés) ou nil

 

EDIT : ajout d'un quatrième colonne à partir de 45 calques.

 

;; GETLAYERS (gile) 02/12/07
;; Retourne la liste des calques cochés dans la boite de dialogue
;;
;; arguments
;; titre : le titre de la boite de dialogue ou nil (defaut = Choisir les calques)
;; lst1 : la liste des calques à pré-cochés ou nil
;; lst2 : la liste des calques non cochables (grisés) ou nil

(defun getlayers (titre lst1 lst2 / toggle_column tmp file lay	layers len
	   dcl_id)

 (defun toggle_column (lst)
   (apply 'strcat
   (mapcar
     (function
       (lambda (x)
	 (strcat ":toggle{key="
		 (vl-prin1-to-string x)
		 ";label="
		 (vl-prin1-to-string x)
		 ";}"
	 )
       )
     )
     lst
   )
   )
 )

 (setq	tmp  (vl-filename-mktemp "tmp.dcl")
file (open tmp "w")
 )
 (while (setq lay (tblnext "LAYER" (not lay)))
   (setq layers (cons (cdr (assoc 2 lay)) layers))
 )
 (setq	layers (vl-sort layers '	len    (length layers)
 )
 (write-line
   (strcat
     "GetLayers:dialog{label="
     (cond (titre (vl-prin1-to-string titre))
    ("\"Choisir les calques\"")
     )
     ";:boxed_row{:column{"
     (cond
((	((	 (strcat (toggle_column (sublist layers 0 (/ len 2)))
	 "}:column{"
	 (toggle_column (sublist layers (/ len 2) nil))
 )
)
((	 (strcat (toggle_column (sublist layers 0 (/ len 3)))
	 "}:column{"
	 (toggle_column (sublist layers (/ len 3) (/ len 3)))
	 "}:column{"
	 (toggle_column (sublist layers (* (/ len 3) 2) nil))
 )
)
(T
 (strcat (toggle_column (sublist layers 0 (/ len 4)))
	 "}:column{"
	 (toggle_column (sublist layers (/ len 4) (/ len 4)))
	 "}:column{"
	 (toggle_column (sublist layers (/ len 2) (/ len 4)))
	 "}:column{"
	 (toggle_column (sublist layers (* (/ len 4) 3) nil))
 )
)
     )
     "}}spacer;ok_cancel;}"
   )
   file
 )
 (close file)
 (setq dcl_id (load_dialog tmp))
 (if (not (new_dialog "GetLayers" dcl_id))
   (exit)
 )
 (foreach n lst1
   (set_tile n "1")
 )
 (foreach n lst2
   (mode_tile n 1)
 )
 (action_tile
   "accept"
   "(setq lst nil)
(foreach n layers
(if (= (get_tile n) \"1\")
(setq lst (cons n lst))))
(done_dialog)"
 )
 (start_dialog)
 (unload_dialog dcl_id)
 (vl-file-delete tmp) 
 lst
) 

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

 

[Edité le 2/12/2007 par (gile)]

[lili2006]

Bonjour à toutes et tous,

Désolé d'avance pour cette question d'ignare, MAIS,

 

Comment ça marche toutes ces fonctions (GetLayers;GetBlock;InputBox) exactement ?

Je veux dire par là, comment les utiliser efficacement .

 

Bon dimanche à tous,

[(gile)]

Salut,

 

Ce sont des routines à utiliser depuis un LISP quand on a besoin de faire choisir un bloc ou un calque ou des calques par l'utilisateur.

 

par exemple, si l'utilisateur doit spécifier un block : (setq bloc (GetBlock "Spécifier le bloc"))

GetLayers est utilisée dans gelobj.

 

http://img210.imageshack.us/img210/8451/getblockoj5.png http://img98.imageshack.us/img98/2637/getlayersi5.png http://img66.imageshack.us/img66/4552/getlayerszs5.png

[Patrick_35]

Salut (gile)

 

en regardant ta routine sublist, je me suis dit qu'on pouvait aussi faire de cette manière, sans utiliser de boucle.

Par contre avec des doublons, il faut se méfier.

 

(defun sublist (lst start leng)
 (if leng
   (member (nth start lst) (reverse (member (nth (+ start (1- leng)) lst)
(reverse lst))))
   (member (nth start lst) lst)
 )
)

 

Reste à voir au test du benchmark ce que cela donne (n'ayant pas autocad sous la main)

 

ps : non testé

 

@+

[richard-c]

salut (gile)

 

je viens d'essayer getblock sous AutoCAD 2002, il faut supprimer la ligne

 

[surligneur] :column{:button{label=\"Parcourir...\";key=\"wbl\";alignment=right;fixed_wi dth=true;}}[/surligneur]

 

car j'ai le message :

 

ligne5 => attribut incorrect => symbole "dth"

 

A+

[(gile)]

Salut,

 

à Patrick_35,

 

Ta routine devrait effectivement être plus rapide, surtout si leng est nil. Mais le résultat sra erroné s'il y a des doublons mal placés.

 

à richard-c,

 

Il ne faut pas supprimer la ligne, sinon tu supprimes le bouton qui permet de fermer la boite de dialogue pour sélectionner un bloc dans le dessin.

Il faut supprimer l'espace entre wi et dth apparu après le copier/coller.

 

J'ai formaté le code différemment, il n'y a plus de saut de ligne qui génère un espace, le copier coller devrait fonctionner.

 

 

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

[lili2006]

Bonjour à toutes et tous,

 

 

Merci (gile) de ta réponse. Si j'ai bien compris l'utilsation de GETLAYERS, par exemple (utilisé pour GELOBJ), tu indiques dans le lisp que tu vas utiliser cette routine ici, (dis moi si je me trompe) : (getlayers

"Geler dans l'onglet objet"

(mapcar 'car (vlax-ldata-get "GelerOngletObjet" "lst")) et tu colles cette routine dans ton lisp (n'importe ou? ou bien y a t-il une procédure particulière ?).

Je vais essayer de tester pour comprendre.

 

PS : Je viens de reparcourir le post sur ssb et l'utilisation de getblock et pourtant celui-ci est un fichier dcl, mis dans un dossier de recherche de autoCAD, si tu veux faire appel à lui, dans un lisp, tu te contentes de l'apeller, c'est ça le fonctionnement ?

Par exemple dans ssb, (defun getblock (titre / bloc n lst what_next dcl_id nom)

(while (setq bloc (tblnext "BLOCK" (not bloc)))

(setq lst (cons (cdr (assoc 2 bloc)) lst)

?

 

hum, j'suis quand même pas sûr d'avoir tout compris mais je perçois (me semble t-il !!), l'esprit.

 

Merci d'avance.

 

[Edité le 6/11/2007 par lili2006]

[(gile)]

Je vais essayer d'avoir une explication plus générale.

 

Toute routine LISP définie avec (defun ...) est, si elle est chargée, utilisable comme n'importe quelle fonction LISP prédéfinie.

 

Par exemple pour récupérer un nom de bloc de la part de l'utilisateur, on peut utiliser la fonction prédéfinie getstring (on vérifiera ensuite dans le LISP que le nom est valide) :

 

(getstring "\nEntrez le nom du bloc: ")

 

On peut aussi utiliser la fonction getblock (definie par defun), il faut simplement que celle-ci soit chargée :

 

(getblock "Spécifiez le bloc")

 

Quand on publie un LISP (sur CADxp, par exemple), on y ajoute (quand on ne les oublie pas) toutes les routines nécessaires à son fonctionnement.

Mais sur mon poste, par exemple, j'ai une bibliothèque de routines (on dit aussi "sous-routines") qui sont appelées par plusieurs LISP, dans ce cas il n'est pas nécessaire que la ou les sous-routines soient jointes au LISP.

 

Concernant les fichier DCL, ce sont des fichiers de description de boite de dialogue. Ils sont appelés depuis des LISP pour pouvoir ouvrir la boite de dialogue.

On peut donc :

- soit créer un fichier séparé et l'enregistrer avec l'extension .dcl dans un dossier du chemin de recherche pour ne pas avoir à donner le chemin complet quand on l'appelle depuis le LISP ;

- soit, et c'est la méthode utilisée ici, écrire directement le contenu du fichier DCL dans un fichier temporaire depuis le LISP, qui l'appellera là où il l'a créé et le supprimera à la fin du programme.

 

Avec la première méthode on a 2 fichiers à enregistrer (getblock.lsp et getblock.dcl comme dans ssb) avec la seconde un seul fichier lsp, mais le résultat est le même.

 

 

 

[lili2006]

Re,

 

Merci pour ces explications (gile), j'y vois déjà plus clair,...

En tout cas, pratique d'utilisation.

 

Juste un dernier point encore obcur pour moi, quand tu écris :

 

Mais sur mon poste, par exemple, j'ai une bibliothèque de routines (on dit aussi "sous-routines") qui sont appelées par plusieurs LISP, dans ce cas il n'est pas nécessaire que la ou les sous-routines soient jointes au LISP.

Comment sont appelées les "sous-routines" par les lisps qui les utilisent ?

Uniquement en écrivant dans le lisp " [ exemple] " (defun getblock)" ???

 

Meri d'avance.

[(gile)]

Comment sont appelées les "sous-routines" par les lisps qui les utilisent ?

 

Elles sont simplement appelées par leur nom, comme n'importe quelle fonction LISP prédéfinie.

 

Le LISP est un langage dit fonctionnel : chaque expression LISP est une liste de la forme :

(fonction [argument] ...)

Elle est évaluée (les arguments sont passés à la fonction) et le résultat de l'évaluation est retourné à l'endroit même de l'expression.

Les arguments pouvant être eux même des expressions les expression les plus profondément imbriquées sont d'abord évaluées et leurs résultats passées comme argument à l'expression "parent" (comme une expression arithmétique avec des parenthèses).

 

La fonction defun permet de créer une nouvelle fonction dont le premier argument est le nom. Une fois définie cette fonction est équivalente à une fonction LISP et est utilisée de la même façon (à ceci près qu'elle doit être chargée et que les argument ne peuvent être optionnels ou de nombre variable)

 

 

Exemple avec la sous-routine getlayer (ci-dessus) qui doit être chargée.

 

(defun c:test (/ lay)

 ;; choix d'un calque (avec getlayer)
 (if (setq lay (getlayer "Calque à rendre courant"))

   ;; test si le calque choisi est gelé
   (if	(= 1 (logand 1 (cdr (assoc 70 (tblsearch "LAYER" lay)))))

     ;; si oui : message
     (alert (strcat "Le calque \"" lay "\" est gelé"))

     ;; si non : le calque est rendu courant
     (setvar "CLAYER" lay)
   )
 )
 (princ)
) 

[lili2006]

Re,

 

Bin voilà, il suffisait de le savoir,..(hummmmmmmmmmmm..................)

 

Merci encore (gile).

 

@+,

 

[richard-c]

bonjour,

 

sur V2002, quand je lance test.lsp, (getlayers est chargé),

AutoCAD me retourne :

 

[surligneur] ; erreur: nombre d'arguments insuffisants[/surligneur]

 

autre question :

 

dans :

(if (setq lay (getlayer "Calque à rendre courant"))

ne faut t'il pas dire :

(if (setq lay ( [surligneur] getlayers[/surligneur] "Calque à rendre courant"))

 

car on dit :

[surligneur] (defun getlayers[/surligneur]

 

A+

[(gile)]

Salut,

 

L'exemple (cest juste un exemple) que j'ai donné fonctionne et devrait aussi fonctionner sur 2002.

 

Il utilise la routine getlayer (voir premier message) qui pertmet de spécifier un calque (puisqu'il s'agit de rendre ce calque courant).

 

La fonction getlayer ne requiert qu'un seul argument (le titre de la boite de dialogue).

 

Si tu as remplacé getlayer par gerlayers (qui requiert deux arguments (titre et liste de s calques à précocher) il est normal que tu ais eu ce message d'erreur.

[richard-c]

OK, merci (gile),

 

dans le même principe, peut on avoir une commande qui décale une ligne

la 1ère fois de X

la suivante de X

la suivante de X

etc

et ceci avec une boite de dialogue qui comprendrais un dizaine de lignes,

ceci afin de faire faire rapidement des profils en travers

 

merci et a+

[(gile)]

Je ne comprends pas la question et ne voit pas la rapport avec des boites de dialogue qui se veulent d'un usage polyvalent.

[richard-c]

OK, c'est vais ce n'est pas une boite polyvalente,

 

je révise et poserai ma question dans un noveau message plus tard

 

A+

[lili2006]

Re,

 

Pour mieux comprendre le fonctionnement des dcl provisoire, je tente désespérément d'utiliser la "sous-routine" "getlayer" dans le lisp "gel-fen" pour avoir la même boite que dans le lisp "gelobj". Ce qui donne ceci : Forcément, y'a un truc qui marche pas,...

 

(defun c:gel_fen (/ ss n)
(while (setq ent
(car
(nentsel
"\nSélectionnez un objet sur le calque à geler dans la fenêtre courante: "
)
)
)
(command "_vplayer"
"_freeze"
(cdr (assoc 8 (entget ent)))
""
""
)
)
(princ)
)

;;=========================================================;;

;; GETLAYERS (gile) 03/11/07
;; Retourne la liste des calques cochés dans la boite de dialogue
;;
;; arguments
;; titre : le titre de la boite de dialogue ou nil (defaut = Choisir les calques)
;; lst : la liste des calques à pré-cochés ou nil

(defun getlayers (titre lst / toggle_column tmp file lay layers len dcl_id)

(defun toggle_column (lst)
(apply 'strcat
(mapcar
(function
(lambda (x)
(strcat ":toggle{key="
(vl-prin1-to-string x)
";label="
(vl-prin1-to-string x)
";}"
)
)
)
lst
)
)
)

(setq tmp (vl-filename-mktemp "tmp.dcl")
file (open tmp "w")
)
(while (setq lay (tblnext "LAYER" (not lay)))
(setq layers (cons (cdr (assoc 2 lay)) layers))
)
(setq layers (vl-sort layers 'len (length layers)
)
(write-line
(strcat
"GetLayers:dialog{label="
(cond (titre (vl-prin1-to-string titre))
("\"Choisir les calques\"")
)
";:boxed_row{:column{"
(cond
(((((strcat (toggle_column (sublist layers 0 (/ len 2)))
"}:column{"
(toggle_column (sublist layers (/ len 2) nil))
)
)
(T
(strcat (toggle_column (sublist layers 0 (/ len 3)))
"}:column{"
(toggle_column (sublist layers (/ len 3) (/ len 3)))
"}:column{"
(toggle_column (sublist layers (* (/ len 3) 2) nil))
)
)
)
"}}spacer;ok_cancel;}"
)
file
)
(close file)
(setq dcl_id (load_dialog tmp))
(if (not (new_dialog "GetLayers" dcl_id))
(exit)
)
(foreach n lst
(set_tile n "1")
)
(action_tile
"accept"
"(setq lst nil)
(foreach n layers
(if (= (get_tile n) \"1\")
(setq lst (cons n lst))))
(done_dialog)"
)
(start_dialog)
(unload_dialog dcl_id)
(vl-file-delete tmp)
lst
) 

 

Tiens, au passage, il ne veut pas geler les bocs par selection grphique !!?? C'est peut-être voulu ?[Edité le 7/11/2007 par lili2006]

[(gile)]

Si tu veux utiliser GetLayers (avec un s) pour geler des calques dans une fenêtre (ce qui, soit dit en passant, revient au même que de le faire dans la liste déroulante des calques) il faut traiter le type de donnée que retourne la routine.

 

GetLayers retourne une liste des calques cochés dans la boite de dialogue.

Le LISP gel_fen gèle les calques au fur et à mesure qu'un objet est sélectionné à l'écran. Il fonctionne avec une boucle (while ...) tant que l'utilisateur sélectionne des objets, le calque sur lequel ils sont est gelé.

 

Il faut donc modifier gel_fen pour qu'il fonctionne avec une liste. On peut utiliser foreach pour traiter la liste

 

(defun c:gel_fen2 ()
 (foreach l (getlayers "Calque à geler dans la fenêtre courante" nil)
   (command "_.vplayer" "_freeze" l "" "")
 )
 (princ)
) 

[richard-c]

bonjour,

 

j'ai rajouté 2 petites ligne pour passer en EO flottant et revenir en EP après,

çà évite de faire un zoom intempestif das la fenêtre quand elle n'est pas vérrouillée

 

 (defun c:gel_fen2 ()
(foreach l (getlayers "Calque à geler dans la fenêtre courante" nil)
    (command "_mspace" "")
(command "_.vplayer" "_freeze" l "" "")
    (command "_pspace" "")
)
(princ)
)

 

qu'en pense (gile) ?

 

A+

[(gile)]

qu'en pense (gile) ? 

 

Oui c'est pas mal, mais ce n'est plus l'utilisateur qui choisit dans quelle fenêtre geler les calques !!!

 

Je donnais juste ce code à titre d'exemple pour répondre à lili2006 à propos de l'utilisation de GetLayers, mais comme je disais plus haut son intérêt est limité dans la mesure où cela n'apporte pas grand chose par rapport au déroulant des calques.

 

Pour bien faire il faudrait en plus que les calques gelés dans la fenêtre courante soient déjà cochés à l'ouverture de la boite et que le fait de décocher un calque dégèle celui-ci (pas mal de travail pour refaire ce que fait très bien AutoCAD).

 

[Edité le 8/11/2007 par (gile)]

[usegomme]

Merci, au poil , j'avais justement besoin de GETBLOCK pour moderniser un lisp.

Par contre pour GETLAYER j'ai un probleme avec la fonction VLAX-LDATA-GET qui n'est pas definie chez moi ?

 

[(gile)]

Salut,

 

J'ai (encore une fois) oublié de mettre (vl-load-com) en début de routine.

 

Je modifie le code

[lili2006]

Bonsoir à toutes et tous,

 

(ce qui, soit dit en passant, revient au même que de le faire dans la liste déroulante des calques)

Je donnais juste ce code à titre d'exemple pour répondre à lili2006 à propos de l'utilisation de GetLayers

 

Absolument !, je voulais voir l'écriture dans une routine d'une sous-routine,qui plus est polyvalente !(ex ici :GetLayers), voilà qui est fait.

 

Merci (gile)

[(gile)]

Les routines getBlock, getLayer, getLayers, InputBox, DoubleInputBox sont désormais réunies dans un seul fichier Dialog.lsp en téléchargement sur cette page (tout en bas)