question sur grread

[krunch]

Bonjour à tous

J'ai une question sur (grread) pour laquelle je ne trouve pas de réponse dans les posts.

Cette commande est particulièrement alambiquée et je ne parviens pas à lui faire cracher ce que je veux, à savoir simplement un retour sur une action clic de l'utilisateur, ou pas..

Il s'agit de savoir si un retour nil de (entsel) est du à une sélection vide, un clic-droit, ou Entrée/Espace (même en cas de sélection vide (entsel) renvoie nil sans les coordonnées du pointage)

 

Donc y a t il un moyen pour obtenir avec (grread) : code 3 si clic ; code 12 si db-click ; code 2 si keyboard, et éventuellement code 5 si rien (déplacement sur l'écran graphique)... le tout en mode "tracking", car je ne cherche pas à remplacer la commande (entsel), qui va très bien...

Dans ce mode la fonction renvoie les dble-clic, mais pas moyen de savoir si l'utilisateur a cliqué ou pas.

 

Et sinon, question subsidiaire : il n'y a pas moyen de détecter les touches Ctrl, Alt et Shift ?? Dans les réacteurs je ne vois pas non plus..

 

Voilà je pense ne pas être le 1er à chercher ces trucs.. merci pour réponses éventuelles et a++

[(gile)]

Salut,

 

C'est BonusCAD qui m'a fait découvrir grread, il l'utilise beaucoup, il t'en dira peut-être plus s'il passe par là.

 

Sinon, quelques lignes de code qui récapiltulent à peu près comment j'utilise grread.

 

(defun c:test (/ loop str gr pt)
 (setq	loop T
str ""
 )
 (while
   (and (setq gr (grread T 4 0)) loop)
    (cond
      ((= (car gr) 5)
(setq pt (cadr gr))
      )
      ((= 3 (car gr))
(alert
  (strcat "Clic gauche sur le point: " (vl-princ-to-string pt))
)
(setq loop nil)
      )
      ((equal gr '(2 13))
(alert (strcat "\"" str "\" validé par Entrée"))
(setq loop nil)
      )
      ((equal gr '(2 32))
(alert (strcat "\"" str "\" validé par Espace"))
(setq loop nil)
      )
      ((= (car gr) 25)
(alert (strcat "\"" str "\" validé par Clic droit"))
(setq loop nil)
      )

      ;; récupérer les entrés au clavier
      (T
(if (= (cadr gr) 8) ;_ 8 = retour/effacer
  (progn
    (setq str (substr str 1 (1- (strlen str))))
    (princ (chr 8))
    (princ (chr 32))
  )
  (setq str (strcat str (chr (cadr gr))))
)
(princ (chr (cadr gr))) ;_ affichage sur la ligne de commande
      )
    )
 )
 (princ)
) 

 

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

[Bred]

Salut, et encore une fois merci !

 

il y a une erreur pour le clic droit,

j'ai rajouté ça :

 

((= [b]12[/b] (car gr))
(alert
  (strcat "Clic droit sur le point: "
	  (vl-princ-to-string pt)
  )
)
(setq loop nil)
      )

[bonuscad]

Je ne sais pas si (ggread) est vraiment adapté à ce que tu veux faire.

 

Si j'ai bien compris la question, je me tournerais plutôt vers l'usage de (nentselp)

 

Ex:

((lambda (/ pt_sel obj_sel)
(initget 8)
(while (not (null (setq pt_sel (getpoint "\nChoix de l'objet: "))))
	(setq obj_sel (nentselp pt_sel))
	(cond
		(obj_sel
			(print (entget (car obj_sel)))
		)
		(T
			(print pt_sel)
		)
	)
	(initget 8)
)
(prin1)
))

 

[Edité le 18/4/2007 par bonuscad]

[(gile)]

Bred,

 

Je ne pense pas que ce soit une "erreur" à proprement parler.

Tout dépend, pour le clic droit, de comment il est paramétré.

 

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

[bonuscad]

Rappel:

 

La variable "SHORTCUTMENU" influe sur le code de retour de (grread) pour un click-droit.

[Bred]

Je ne pense pas que ce soit une "erreur" à proprement parler.

Tout dépend, pour le clic droit, de comment il est paramétré.

 

Ah oui! c'est vrais, on avais eu le problème il n'y a pas longtemps.

[(gile)]

J'ai un peu peaufiné la saisie au clavier, avec le code donné plus haut, on pouvait effacer l'invite au delà de ce qu'on avait entré.

 

J'ai aussi supprimé l'évaluation du clic droit, il faudrait tester avec les différentes valeurs possibles de SHORTCUTMENU ...

 

(defun c:grtest (/ loop gr pt str)
 (prompt "\nEntrée: ")
 (setq loop T)
 (while
   (and (setq gr (grread T 4 0)) loop)
    (cond
      
      ((= (car gr) 5)
(setq pt (cadr gr))
      )
      
      ((= 3 (car gr))
(alert
  (strcat "Point sélectionné (clic gauche): "
	  (vl-princ-to-string pt)
  )
)
(setq loop nil)
      )

      ((member(car gr) '(12 25))
(alert
  (strcat "Point sélectionné (clic droit): "
	  (vl-princ-to-string pt)
  )
)
(setq loop nil)
      )
      
      ((equal gr '(2 13))
(alert (strcat "\"" str "\" validé par Entrée"))
(setq loop nil)
      )
      
      ((equal gr '(2 32))
(alert (strcat "\"" str "\" validé par Espace"))
(setq loop nil)
      )
      
      ;; récupérer les entrées au clavier
      (T
(if (= (cadr gr) 8) ;_ 8 = retour/effacer
  (or
    (and str
	 (/= str "")
	 (setq str (substr str 1 (1- (strlen str))))
	 (princ (chr 8))
	 (princ (chr 32))
    )
    (setq str nil)
  )
  (or
    (and str (setq str (strcat str (chr (cadr gr)))))
    (setq str (chr (cadr gr)))
  )
)
(and str (princ (chr (cadr gr)))) ;_ affichage sur la ligne de commande
      )
    )
 )
 (princ)
) 

[krunch]

Merci pour vos réponses qui permettent de voir un peu comment ça marche, sauf que..

 

- le code de (gile) utilise la commande (grread) en "non track" apparemment (en référence à la dénomination de l'aide) : cad que la commande génère une pause pour entrée utilisateur.

Avec les parametres je la mettais sans arrêt d'exécution, après une invite (entsel) : dans ce cas la commande renvoie juste le contenu du buffer au moment de l'appel. C'est juste qu'avec (grread) en pause-invite, on ne peut pas mettre de message, en particulier avec option (ceux qui viennent à côté du curseur au moment de la sélection).

- le code de Bonuscad avec (nentselp) est très pratique aussi et il pourrait être utilisé avec (grread) à la place de (getpoint), ce qui permettrait toutes les entrées possibles (pas seulement un pointage), sauf que pareil, pas de message d'invite.

 

Bref merci, vous cassez pas la tête non plus

[bonuscad]

Pour ta culture avec (grread), tu peux regarder ce sujet

 

on ne peut pas mettre de message

grread n'a pas d'option de message, mais en placant jusdicieusement des (princ "message") dans une boucle, tu peux arriver à en placer.

 

Analyser les retour de grread pour des actions appropriés augmente vite la taille du code pour pas grand chose. Regarde l'exemple sur lequel je te renvoie, rien que pour simuler un fonctionnement d'accroche objet ce qu'il a fallu faire et ça pour un résultat loin d'être parfait.

 

Un autre exemple d'utilisation!

(defun c:choice_quad ( / js dxf_ent pt_mid x_alpha omega lg_line ss_tmp n lst_ename)
(princ "\nSélectionner une ligne.")
(while (null (setq js (ssget "_:S" '((0 . "LINE"))))))
(setq
	dxf_ent (entget (ssname js 0))
	pt_mid (mapcar '/ (mapcar '+ (trans (cdr (assoc 10 dxf_ent)) 0 1) (trans (cdr (assoc 11 dxf_ent)) 0 1)) '(2.0 2.0 2.0))
	x_alpha (angle (trans (cdr (assoc 10 dxf_ent)) 0 1) (trans (cdr (assoc 11 dxf_ent)) 0 1))
	omega (/ (* 15 pi) 180)
	lg_line (/ (distance (cdr (assoc 10 dxf_ent)) (cdr (assoc 11 dxf_ent))) 4)
	ss_tmp (ssadd)
	n -2
	lst_ename '()
)
(repeat 4
	(if (zerop n) (setq x_alpha (+ pi x_alpha)))
	(command "_.line" "_none" pt_mid "_none" (polar pt_mid (+ x_alpha omega) lg_line) "")
	(setq
		omega (- pi omega)
		lst_ename (cons (entlast) lst_ename)
		n (1+ n)
	)
)
(foreach sx (cdr lst_ename) (setq ss_tmp (ssadd sx ss_tmp)))
(sssetfirst nil ss_tmp)
(princ "\n< Espace > or [Click-Gauche] pour sélectionner quadrant suivant/< Entrer > ou [Click-Droit] pour quitter!.")
(while (and (not (member (setq key (grread nil 4 0)) '((2 13)))) (/= (car key) 25))
	(sssetfirst nil nil)
	(setq lst_ename (append (cdr lst_ename) (list (car lst_ename))) ss_tmp (ssadd))
	(foreach sx (cdr lst_ename) (setq ss_tmp (ssadd sx ss_tmp)))
	(sssetfirst nil ss_tmp)
)
(command "_.erase" ss_tmp "")
(prin1)
)

 

Voilà ces exemples vont peut être t'aider ?!