; Ce fichier lisp contient toutes les fonctions utiles pour
; CHOISIR LES ECHELLES DES FENETRES CONTENUES DANS LES PRESENTATIONS
;
; la commande à utiliser est :
; - cefp pour : Choisir Echelle Fenêtre Présentation
;
; BLAES Sébastien
; version du 29/07/2009
;
; les variables écrites en majuscules, sont des variables globales

(vl-load-com)

;------------------------------------------;
; nom: get_all_fen                         ;
; role: retourne sous forme de liste de    ;
;       quadruplets, toutes les fenêtres   ;
;       existantes dans les des différentes;
;       présentations. Les quadruplets sont;
;       de cette forme:                    ;
;       - objet vla de la fenêtre          ;
;       - nom de la présentation           ;
;       - echelle personnalisée            ;
;       - verrouillage (V verrouillée ou   ;
;                      D déverrouillée)    ;
; param: aucun                             ;
; retour: liste de quadruplets             ;
;         nil si erreur                    ;
; date:  29/07/2009                        ;
; Sébastien BLAES                          ;
;------------------------------------------;
(defun get_all_fen( / res vla_doc vla_pre tmp)
	(setq res nil
	      tmp nil

	      ; ces variables seront globales et servent à stocker le nombre maximum de caractères
	      ; que prennent l'id, le nom de la présentation ainsi que l'échelle
	      VAR_CEFP_ID_MAX 0
	      VAR_CEFP_PRE_MAX 0
	      VAR_CEFP_SCALE_MAX 0
	      VAR_CEFP_FIX_SCALE_MAX 0
	) ; setq

  	(setvar "CTAB" "Model")

	(cond
	  	; on cherche toutes les fenêtres sauf l'espace objet et les présentations elle-même
		((= (setq select (ssget "X" '((0 . "VIEWPORT")(-4 . "<NOT")(69 . 1)(-4 . "NOT>")))) nil)
		 	(princ (strcat "\nIl n'y a pas de fenêtres dans le fichier"))
		)

		(t
		 	(setq res nil)

		 	(while (/= (setq ent (ssname select 0)) nil)
				(setq lent (entget ent)
				      vla_ent (vlax-ename->vla-object ent)
				      pre_name (cdr (assoc 410 lent))
				      scale (vla-get-CustomScale vla_ent)
				      lock (vla-get-DisplayLocked vla_ent)
				      res (cons (list vla_ent pre_name scale lock) res)
				) ; setq

			  	; on s'occupe des variables globales
			  	(if (> (strlen (cdr (assoc 5 lent))) VAR_CEFP_ID_MAX)
				  	(setq VAR_CEFP_ID_MAX (strlen (cdr (assoc 5 lent))))
				) ; if
			  	(if (> (strlen pre_name) VAR_CEFP_PRE_MAX)
				  	(setq VAR_CEFP_PRE_MAX (strlen pre_name))
				) ; if
			  	(if (> (strlen (rtos scale)) VAR_CEFP_SCALE_MAX)
				  	(setq VAR_CEFP_SCALE_MAX (strlen (rtos scale)))
				) ; if
				(if (> (strlen (itoa (fix scale))) VAR_CEFP_FIX_SCALE_MAX)
				  	(setq VAR_CEFP_FIX_SCALE_MAX (strlen (itoa (fix scale))))
				) ; if
			  
			  	; on supprime ent de la sélection
			  	(ssdel ent select)
			) ; while
		)
	) ; cond
  
  	(reverse res)
) ; get_all_fen

;-------------------------------------------;
; nom: choisir_echelle_fenetre_presentation ;
; role: ouvre une dcl pour choisir l'échelle;
;       personnalisée des fenêtres contenues;
;       dans les présentations              ;
; param: aucun                              ;
; retour: t si tout c'est bien passé        ;
;         nil si erreur                     ;
; date:  28/07/2009                         ;
; Sébastien BLAES                           ;
;-------------------------------------------;
(defun choisir_echelle_fenetre_presentation( / res liste_pre_fen tmp_dcl desc_tmp_dcl)
  	(setq res nil)

  	(cond
	  	; on récupère les présentations et leur fenêtres
	  	((= (setq liste_pre_fen (get_all_fen)) nil)
		 	(princ (strcat "\nIl y a eu une erreur de recherche des fenêtres dans les présentations"))
		)

		; on va créer un fichier temporaire pour la dcl
		((= (setq tmp_dcl (vl-filename-mktemp "tmp.dcl")) nil)
		)

		; on va l'ouvrir
		((= (setq desc_tmp_dcl (open tmp_dcl "w")) nil)
		)

		(t
		 	;;;;;;;;;;;;;;;;;
		 	;  FICHIER DCL  ;
		 	;;;;;;;;;;;;;;;;;
		 
		 	; on va écrire dans le fichier temporaire
		 	; on déclare la boite de dialogue
			(write-line (strcat "cefp_dialog: dialog{label=\"CEFP V2 - BSEB67\";") desc_tmp_dcl)
				(write-line ":row{" desc_tmp_dcl)
		 			; LISTE DES PRESENTATIONS
					(write-line ":column{" desc_tmp_dcl)
						(write-line (strcat ":text {label=\"Liste des fenêtres (id_fenêtre nom_présentation échelle verrouillage): " (itoa (length liste_pre_fen)) "\";}") desc_tmp_dcl)
		 				(write-line ":list_box {key=\"k_liste_fen\";height=15;fixed_width_font=true;multiple_select=true;}" desc_tmp_dcl)
					(write-line "}" desc_tmp_dcl)

		 			; ECHELLE PERSONNALISEE ET VEROUILLAGE
		 			(write-line ":column{" desc_tmp_dcl)
		 				(write-line ":column{" desc_tmp_dcl)
			 				(write-line ":spacer {height=2;}" desc_tmp_dcl)
		 					(write-line ":edit_box{key=\"k_ech_perso\";label=\"Echelle\";}" desc_tmp_dcl)
		 						(write-line ":radio_column{label=\"Verrouillage\";" desc_tmp_dcl)
		 							(write-line ":radio_button{key=\"k_verr\";label=\"verrouiller\";}" desc_tmp_dcl)
		 							(write-line ":radio_button{key=\"k_deverr\";label=\"déverrouiller\";}" desc_tmp_dcl)
		 							(write-line ":radio_button{key=\"k_before\";label=\"ne pas changer\";}" desc_tmp_dcl)
								(write-line "}" desc_tmp_dcl)
			 				(write-line ":button{key=\"k_apply\";label=\"Appliquer\";}" desc_tmp_dcl)
		 				(write-line "}" desc_tmp_dcl)
		 			(write-line "}" desc_tmp_dcl)
		 		(write-line "}" desc_tmp_dcl)

		 		(write-line ":spacer {height=2;}" desc_tmp_dcl)
		 		
		 		; BOUTON OK
		 		(write-line ":row{" desc_tmp_dcl)
		 			(write-line ":spacer {width=2;}" desc_tmp_dcl)
		 			(write-line ":button{key=\"k_ok\";label=\"Ok\";is_default=true;}" desc_tmp_dcl)
		 			(write-line ":spacer {width=2;}" desc_tmp_dcl)
		 		(write-line "}" desc_tmp_dcl)
		 	; on ferme la boite de dialogue
		 	(write-line "}" desc_tmp_dcl)

		 	; on ferme le fichier
			(close desc_tmp_dcl)

		 	;;;;;;;;;;;;;;;;;
		 	;FIN FICHIER DCL;
		 	;;;;;;;;;;;;;;;;;

			(cond
			  	((= (setq dcl_id (load_dialog tmp_dcl)) nil)
				)
				((= (new_dialog "cefp_dialog" dcl_id) nil)
				)
			  	(t
				 	; cette fonction sert à mettre de façon clair les données
				 	(defun en_chaine( lst / res)
					  	(setq espace1 "" espace2 "" espace3 "" espace4 "")
					  	(repeat (+ (- VAR_CEFP_ID_MAX (strlen (cdr (assoc 5 (entget (vlax-vla-object->ename (nth 0 lst))))))) 4) (setq espace1 (strcat espace1 " ")))
					  	(repeat (+ (- VAR_CEFP_PRE_MAX (strlen (nth 1 lst))) 4) (setq espace2 (strcat espace2 " ")))
					  	(repeat (- VAR_CEFP_FIX_SCALE_MAX (strlen (itoa (fix (nth 2 lst))))) (setq espace3 (strcat espace3 " ")))
						(repeat 4 (setq espace4 (strcat espace4 " ")))
					  	
					  	(strcat
						  	(cdr (assoc 5 (entget (vlax-vla-object->ename (nth 0 lst)))))
							espace1

							(nth 1 lst)
							espace2

							espace3
							(rtos (nth 2 lst) 2 5)
							espace4

							(if (= (nth 3 lst) :vlax-true)
							  	"V"
							    	"D"
							) ; if
						) ; strcat
					) ; en_chaine

				 	(defun applique_verrouillage( chx / liste_choix tmp_choix tmp verr)
					  	; on boucle sur choix afin de chercher les fenêtres concernées
					 	(setq liste_choix '() tmp_choix chx)

					 	(while (/= (setq tmp (read tmp_choix)) nil)
							(setq liste_choix (cons (car (nth tmp liste_pre_fen)) liste_choix))

						  	; on retire de choix la valeur tmp
						  	(cond
							  	((vl-string-search (strcat (itoa tmp) " ") tmp_choix)
						  			(setq tmp_choix (vl-string-subst "" (strcat (itoa tmp) " ") tmp_choix))
								)
								((vl-string-search (strcat (itoa tmp) "") tmp_choix)
						  			(setq tmp_choix (vl-string-subst "" (strcat (itoa tmp) "") tmp_choix))
								)
							) ; cond
						) ; while

					 	; on va simplement appliquer la verrouillage demandé
					 	(setq verr (if (= (get_tile "k_verr") "1") :vlax-true :vlax-false))
					 	(mapcar '(lambda (elem)
							   	(vla-put-DisplayLocked elem verr)
							)
							liste_choix
						) ; mapcar

					 	(cond
						  	((= (setq liste_pre_fen (get_all_fen)) nil)
						 		(princ (strcat "\nIl y a eu une erreur de recherche des fenêtres dans les présentations"))
							)

							(t
						  		; on remplit la liste des présentations
 								(fill_liste_pre)
							 	(set_tile "k_liste_fen" chx)
							)
						) ; cond
					) ; applique_verrouillage

				 	(defun applique_echelle( scale / choix tmp_choix liste_choix tmp)
					  	(cond
						  	; on teste s'il y a des éléments cochés dans la liste
						  	((= (setq choix (get_tile "k_liste_fen")) "")
							 	(princ (strcat "\nAucun élément de sélectionné dans la liste!"))
							 	(princ)
							)
							
							(t
							 	; on boucle sur choix afin de chercher les fenêtres concernées
							 	(setq liste_choix '() tmp_choix choix)

							 	(while (/= (setq tmp (read tmp_choix)) nil)
									(setq liste_choix (cons (car (nth tmp liste_pre_fen)) liste_choix))

								  	; on retire de choix la valeur tmp
								  	(cond
									  	((vl-string-search (strcat (itoa tmp) " ") tmp_choix)
								  			(setq tmp_choix (vl-string-subst "" (strcat (itoa tmp) " ") tmp_choix))
										)
										((vl-string-search (strcat (itoa tmp) "") tmp_choix)
								  			(setq tmp_choix (vl-string-subst "" (strcat (itoa tmp) "") tmp_choix))
										)
									) ; cond
								) ; while

							 	; on met l'échelle
							 	(mapcar '(lambda (elem)
									   	(vla-put-CustomScale elem scale)
									)
									liste_choix
								) ; mapcar

							 	; on gère le verrouillage
							 	(cond
								  	; si ne pas changer est cocher on ne fait rien
								  	((= (get_tile "k_before") "1")
									 	(princ (strcat "\nRien a changer!"))
									 	(princ)
									)

									(t
									 	(applique_verrouillage choix)
									)
								) ; cond
							)
						) ; cond
					) ; applique_verrouillage
				 	
				 	; on définit les fonctions utiles sur la dcl
				 	(defun fill_liste_pre()
					  	(start_list "k_liste_fen")
					 	(mapcar '(lambda (elem) (add_list (en_chaine elem)))
							liste_pre_fen
						) ; mapcar
					 	(end_list)
					) ; fill_liste_pre

				 	(defun k_apply_clic( / )
					  	(cond
						  	; on teste la valeur de l'échelle saisie
							((or (= (type (setq cus_scale (read (get_tile "k_ech_perso")))) 'INT)
							     (= (type cus_scale) 'REAL))
							 	(applique_echelle cus_scale)
							)

							; si cus_scale vaut nil, c'est que l'utilisateur n'a pas saisie d'échelle
							((= cus_scale nil)
							 	(cond
								  	; si ne pas changer est cocher on ne fait rien
								  	((= (get_tile "k_before") "1")
									 	(princ (strcat "\nRien a changer!"))
									 	(princ)
									)
									
								  	; on teste s'il y a des éléments cochés dans la liste
								  	((= (setq choix (get_tile "k_liste_fen")) "")
									 	(princ (strcat "\nAucun élément de sélectionné dans la liste!"))
									 	(princ)
									)
									
									(t
									 	(applique_verrouillage choix)
									)									
								) ; cond
							)
							
							; la valeur saisie n'est pas bonne
							(t
							 	(princ "\nValeur saisie incorrecte")
							 	(princ)
							)
						) ; cond
					) ; k_apply_clic
				 
				 	; on définit les actions sur la dcl
			  		(action_tile "k_ok" "(setq ok t)(done_dialog)")
					(action_tile "k_apply" "(k_apply_clic)")				 	

				 	; on remplit la liste des présentations
				 	(fill_liste_pre)

				 	; par défaut on coche "ne pas changer"
				 	(set_tile "k_before" "1")
				 
					; on lance la dcl
				  	(start_dialog)
					(unload_dialog dcl_id)

				 	; on a quitter la dcl
				  	(cond
					  	((= ok t)
						)
					) ; cond
				)
			) ; cond
		)
	) ; cond

	; on supprime le fichier temporaire
	(vl-file-delete tmp_dcl)

  	(princ "\n")

  	res
) ; choisir_echelle_fenetre_presentation
(defun c:cefp()
  	(choisir_echelle_fenetre_presentation)
) ; c:cefp

(princ)


(entget (vlax-vla-object->ename (car (nth 5 liste_pre_fen))))
(entget (cdr (assoc 330 (entget (vlax-vla-object->ename (car (nth 6 liste_pre_fen)))))))