initget et getpoint

[zebulon_]

Bonjour,

 

j'aimerai utiliser la fonction getpoint pour entrer, soit un point, soit des mots clés, soit un nombre entier positif non nul, soit rien (entrée par défaut)

 

Pour la saisie du point ou d'un nul, pas de problème, c'est le job de base de la fonction getpoint. Pour les mots clés, pas de problème non plus avec (initget "Clé Key").

 

Par contre, getpoint n'est pas sensible aux bits de contrôle 2 et 4 de initget qui permettent respectivement d'interdire la saisie de zéro et de négatif, j'en conclue qu'il faut faire un contrôle a posteriori.

 

Le problème est que si je saisis un chiffre à l'invite de getpoint, cela me renvoie un point.

Commande: (getpoint)

1

(0.948636 0.31637 0.0)

 

Je ne sais pas d'où sort ce point...

 

 

Si on fait précéder le getpoint par un (initget 128), la fonction renvoie une chaine de caractères qu'on peut analyser.

 

Commande: (initget 128 "Milieu Répartis")

nil

Commande: (getpoint)

1

"1"

 

J'ai pensé que c'était un fonctionnement qui méritait d'être signalé.

 

Par ailleurs, si les bits de contrôle 1 (pas de nul) et 128 (entrée arbitraire) sont activés, une entrée nulle renvoie une chaine de caractères vide.

 

Commande: (initget 129)

nil

Commande: (getpoint)

 

""

 

et pas "Point ou option nécessaire" avec un retour à l'invite comme on aurait pu s'y attendre. Mais l'aide indique que le binaire 128 et prioritaire sur le binaire 1, ce qui explique ce fonctionnement.

 

Amicalement

Vincent

[bonuscad]

Bonjour,

 

Le problème est que si je saisis un chiffre à l'invite de getpoint, cela me renvoie un point.

Commande: (getpoint)

1

(0.948636 0.31637 0.0)

 

Je ne sais pas d'où sort ce point...

 

Je pense que c'est un point calulé depuis LASTPOINT avec une distance de 1 et un angle fourni par la position de ton curseur lors de ta saisie. Il me semble que ça fonctionne comme cela.

 

j'aimerai utiliser la fonction getpoint pour entrer, soit un point, soit des mots clés, soit un nombre entier positif non nul, soit rien (entrée par défaut)

 

Mixer les entrées entre (getpoint) et (getint), je m'étais essayé à cela. La seule solution que j'avais trouvé satisfaisante était d'analyser les retours de (grread), sachant que le gros problème de cette fonction est que les accroches objets ne sont pas évalués.

Donc grosse artillerie pour émuler un petit besoin...

Je te livre ce que j'avais pondu, mais je pense pas que ce soit vraiment un chemin à suivre. De souvenir je crois que la fonction dessinait des accroches bizzare dans des SCU 3D.

 

Honnêtement une saisie supplémentaire par l'utilisateur serait souhaitable pour orienté le code sur la bonne fonction. (Je sais on souhaite toujours le moins de saisie possible...)

 

(defun gr-osmode (pt-i str-md / n pt md rap pt1 pt2 pt3 pt4 pt5 pt6 pt7 pt8 pt56 pt67 pt78 pt85 one_o)
(setq n (/ (cadr (getvar "screensize")) 5.0))
(setq pt (osnap pt-i str-md))
(while (and (eq (strlen (setq md (substr str-md 1 4))) 4) (not one_o))
	(repeat 2
		(setq
			rap (/ (getvar "viewsize") n)
			pt1 (list (- (car pt) rap) (- (cadr pt) rap) (caddr pt))
			pt2 (list (+ (car pt) rap) (- (cadr pt) rap) (caddr pt))
			pt3 (list (+ (car pt) rap) (+ (cadr pt) rap) (caddr pt))
			pt4 (list (- (car pt) rap) (+ (cadr pt) rap) (caddr pt))
			pt5 (list (car pt) (- (cadr pt) rap) (caddr pt))
			pt6 (list (+ (car pt) rap) (cadr pt) (caddr pt))
			pt7 (list (car pt) (+ (cadr pt) rap) (caddr pt))
			pt8 (list (- (car pt) rap) (cadr pt) (caddr pt))
			pt56 (polar pt (- (/ pi 4.0)) rap)
			pt67 (polar pt (/ pi 4.0) rap)
			pt78 (polar pt (- pi (/ pi 4.0)) rap)
			pt85 (polar pt (+ pi (/ pi 4.0)) rap)
			n (- n 16)
		)
		(if (equal (osnap pt-i md) pt) (setq one_o T))
		(cond
			((and (eq "_end" md) one_o)
				(grdraw pt1 pt2 1) (grdraw pt2 pt3 1) (grdraw pt3 pt4 1) (grdraw pt4 pt1 1)
			)
			((and (eq "_mid" md) one_o)
				(grdraw pt1 pt2 1) (grdraw pt2 pt7 1) (grdraw pt7 pt1 1)
			)
			((and (eq "_cen" md) one_o)
				(grdraw pt5 pt56 1) (grdraw pt56 pt6 1) (grdraw pt6 pt67 1) (grdraw pt67 pt7 1) (grdraw pt7 pt78 1) (grdraw pt78 pt8 1) (grdraw pt8 pt85 1) (grdraw pt85 pt5 1)
				(grdraw pt5 pt7 7) (grdraw pt6 pt8 7)
			)
			((and (eq "_nod" md) one_o)
				(grdraw pt5 pt56 1) (grdraw pt56 pt6 1) (grdraw pt6 pt67 1) (grdraw pt67 pt7 1) (grdraw pt7 pt78 1) (grdraw pt78 pt8 1) (grdraw pt8 pt85 1) (grdraw pt85 pt5 1)
				(grdraw pt1 pt3 1) (grdraw pt2 pt4 1)
			)
			((and (eq "_qua" md) one_o)
				(grdraw pt5 pt6 1) (grdraw pt6 pt7 1) (grdraw pt7 pt8 1) (grdraw pt8 pt5 1)
			)
			((and (eq "_int" md) one_o)
				(grdraw pt1 pt3 1) (grdraw pt2 pt4 1)
			)
			((and (eq "_ins" md) one_o)
				(grdraw pt5 pt2 1) (grdraw pt2 pt6 1) (grdraw pt6 pt8 1) (grdraw pt8 pt4 1) (grdraw pt4 pt7 1) (grdraw pt7 pt5 1)
			)
			((and (eq "_per" md) one_o)
				(grdraw pt1 pt2 1) (grdraw pt1 pt4 1) (grdraw pt8 pt 1) (grdraw pt pt5 1)
			)
			((and (eq "_tan" md) one_o)
				(grdraw pt5 pt56 1) (grdraw pt56 pt6 1) (grdraw pt6 pt67 1) (grdraw pt67 pt7 1) (grdraw pt7 pt78 1) (grdraw pt78 pt8 1) (grdraw pt8 pt85 1) (grdraw pt85 pt5 1)
				(grdraw pt3 pt4 1)
			)
			((and (eq "_nea" md) one_o)
				(grdraw pt1 pt2 1) (grdraw pt2 pt4 1) (grdraw pt4 pt3 1) (grdraw pt3 pt1 1)
			)
		)
	)
	(setq str-md (substr str-md 6) n (/ (cadr (getvar "screensize")) 5.0))
)
)
(defun get-int_point ( / o loop value mod key pt)
(setq o (getvar "osmode") loop T value "")
(if (or (zerop o) (eq (boole 1 o 16384) 16384))
	(setq mod "_none")
	(progn
		(setq mod "")
		(mapcar
			'(lambda (xi xs)
				(if (not (zerop (boole 1 o xi)))
					(if (zerop (strlen mod))
						(setq mod (strcat mod xs))
						(setq mod (strcat mod "," xs))
					)
				)
			)
			'(1 2 4 8 16 32 64 128 256 512)
			'("_end" "_mid" "_cen" "_nod" "_qua" "_int" "_ins" "_per" "_tan" "_nea")
		)
	)
)
(princ "\nGive a point or integer: ")
(while (and (setq key (grread T 4 0)) (/= (car key) 3) loop)
	(cond
		((eq (car key) 5)
			(redraw)
			(if (and (/= mod "_none") (osnap (cadr key) mod))
				(progn
					(gr-osmode (cadr key) mod)
					(setq pt (osnap (cadr key) mod))
				)
				(setq pt (list (caadr key) (cadadr key) 0.0))
			)
		)
		((or (member key '((2 13) (2 32))) (eq (car key) 25))
			(if (and (not (zerop (strlen value))) (eq (type (read value)) 'INT))
				(setq pt (read value))
				(setq pt nil)
			)
			(setq loop nil)
			(princ "\n")
		)
		(T
			(if (eq (cadr key) 8)
				(progn
					(setq value (substr value 1 (1- (strlen value))))
					(princ (chr 8)) (princ (chr 32))
				)
				(setq value (strcat value (chr (cadr key))) pt nil)
			)
			(princ (chr (cadr key)))
		)
	)
)
(redraw)
(princ pt)
(prin1)
)

[zebulon_]

Je pense que c'est un point calulé depuis LASTPOINT avec une distance de 1 et un angle fourni par la position de ton curseur lors de ta saisie. Il me semble que ça fonctionne comme cela.

Cela doit être la bonne explication. Par ailleurs, si on lance une commande ligne et qu'à la saisie du premier point on tape juste un chiffre puis entrée, ça fonctionne de la même manière.

 

 

Pour le lisp, c'est de la grosse artillerie, effectivement, pour un besoin minime.

 

J'avais fait tout d'abord un getpoint précédé d'un (initget "Milieu Répartis"). Quand l'utilisateur choisit "Répartis", il suit un getint qu'on arrive facilement à brider pour éviter les négatifs et les nuls.

 

Mais comme l'utilisateur (moi...), ça l'ennuie de taper R puis un chiffre et voudrait taper le chiffre tout de suite, j'ai cherché une autre voie pour cela.

 

Ce que j'ai retenu, c'est de faire un getpoint avec un (initget 128 "Milieu Répartis"). Soit c'est un point, soit c'est un mot clé ou un texte (qui peut être un nombre alphanumérique), soit c'est rien (-> option par défaut).

 

Si le retour est un texte qui représente un chiffre positif et non nul, je sais continuer en sautant une étape. Si l'utilisateur a tapé autre chose que les mots clés permis par initget ou un chiffre positif non nul, j'aiguille vers l'option par défaut. L'utilisateur n'a qu'à faire attention, aussi !

 

 

Merci pour le retour d'expérience.

 

Par ailleurs, je me sers toujours du bouquin lisp qui était fourni avec la version 12... Faudrait que je me mette à la page, car dans cette version, les bits de contrôle s'arrêtaient à 128 alors que dans les versions actuelles, cela va jusqu'à 1024 et je crois que je devrais m'intéresser au bit 256, mais je n'ai pas encore bien compris ce qu'il faisait

[Tramber]

Vite fait (avant la naissance de mon second garçon, je déconne pas c'est pour bientôt)(et avant de bosser car je dois y retourner, urgence pour demain).

Je confirme sans doute l'histoire du LASTPOINT mais je puis dire surtout que donne le chiffre zéro comme possible quand il y a élastique (point de référence dans le getpoint) de sorte que zéro fonctionne très bien comme si je donnais une direction puis la valeur du vecteur, nul alors.

J'ai des routines qui fonctionne avec cette astuce mais toi, tu voulais peut-être l'inverse.

 

C'était aussi pour faire un petit coucou, je repars dans le boulot, les couches et la mécanique automobile, rdv dans plusieurs semaines B)