Offset spécial initget

[Invité samuelM]

Bonjour,

 

A partir du lisp _Offset je veux créer un lisp en utilisant une addition pour la distance à la place d'un nombre entier. je n'arrive pas à le programmer avec initget(+ 1 1)

Pouvez vous m'aider

 

Je souhaite l'insérer à la place de off_dist (getreal"/")

 

 

(defun c:Extoss ()

(setq userecho (getvar "cmdecho"))

(setvar "cmdecho" 0)

(setq ent_select (entsel "\nSélectionner l'objet à décaler: ")

ent_pickpt (cadr ent_select)

ent_orig (car ent_select)

);setq

(redraw ent_orig 3)

(setq off_pt (getpoint "\nIndiquer la direction : ")

off_angle (angle ent_pickpt off_pt)

);setq

(setq last_entity ent_orig last_pt ent_pickpt)

(while (setq off_dist (getreal "\nSécipier la distance à décaler par addition: "))

(setq newoff_pt (polar last_pt off_angle 10))

(command "._offset" off_dist last_entity newoff_pt "")

(setq last_entity (entlast)

last_pt (cdr (assoc 10 (entget last_entity)))

);setq

(redraw last_entity 3)

);while

(redraw last_entity 4)

(setvar "cmdecho" userecho)

(princ)

);defun

(princ "\nDébuter avec Extoss ")

(princ)

 

Merci à vous

[(gile)]

Salut,

 

Pour rendre tes messages plus lisibles quand tu publies du code, utilise les bbcodes :

[surligneur][[/surligneur][surligneur]code[/surligneur][surligneur]][/surligneur] ici le code [surligneur][[/surligneur][surligneur]/code[/surligneur][surligneur]][/surligneur]

 

donne :

 ici  le code 

 

Accessible via l'icône [#] :

http://img94.imageshack.us/img94/8380/bbcode.png

 

 

À part ça, je ne comprends pas bien ce que tu veux faire.

Si tu veux récupérer une expression LISP comme (+ 1 1) entrée par l'utilisateur, il faut utiliser getstring, puis eval et read :

(setq exp (getstring "\nSpécifiez la distance à décaler par addition: "))
(setq off_dist (eval (read exp)))

 

Le problème est que si la chaîne entée n'est pas une expression LISP valide, ça va générer une erreur qui n'est pas traitée par ton code (cmdecho restera à 0 et l'entité en surbrillance).

 

 

[Invité samuelM]

(defun c:Extoss () 
(setq userecho (getvar "cmdecho")) 
(setvar "cmdecho" 0) 
(setq ent_select (entsel "\nSélectionner l'objet à décaler: ") 
ent_pickpt (cadr ent_select) 
ent_orig (car ent_select) 
);setq 
(redraw ent_orig 3) 
(setq off_pt (getpoint "\nIndiquer la direction : ") 
off_angle (angle ent_pickpt off_pt) 
);setq 
(setq last_entity ent_orig last_pt ent_pickpt) 
(while (setq off_dist (getreal "\nSécipier la distance à décaler par addition: ")) 
(setq newoff_pt (polar last_pt off_angle 10)) 
(command "._offset" off_dist last_entity newoff_pt "") 
(setq last_entity (entlast) 
);setq 
);while  
(setvar "cmdecho" userecho) 
(princ) 
);defun 
(princ "\nDébuter avec Extoss ") 
(princ)

[Invité samuelM]

Ce que je veux faire c'est remplacer la distance (nombre entier donné par l'utilisateur) par une addition (rentré par l'utilisateur)

[Invité samuelM]

Merci ça fonctionne. mais le problème que tu me dis est bien là. comment je peux le résoudre?

 

que faut il faire pour que cela soit une expression lisp valide?

 

Merci à toi

[(gile)]

que faut il faire pour que cela soit une expression lisp valide?

 

Le programme ne peut que constater/vérifier que l'expression est valide, c'est à l'utilisateur d'entrer une expression LISP valide.

 

Le programme peut tester pour chaque entrée, si l'expression est valide avec les fonctions vl-catch-all* :

 

(defun c:Extoss		(/	      userecho	   ent_select	ent_pickpt   ent_orig	  off_pt
	 off_angle    last_entity  last_pt	expr	     off_dist	  newoff_pt
	)
 (setq userecho (getvar "cmdecho"))
 (setvar "cmdecho" 0)
 (setq	ent_select (entsel "\nSélectionner l'objet à décaler: ")
ent_pickpt (cadr ent_select)
ent_orig   (car ent_select)
 ) ;_ setq 
 (redraw ent_orig 3)
 (setq	off_pt	  (getpoint "\nIndiquer la direction : ")
off_angle (angle ent_pickpt off_pt)
 ) ;_ setq 
 (setq	last_entity ent_orig
last_pt	    ent_pickpt
 )
 (while (/= (setq expr (getstring "\nSpécifiez la distance à décaler par expression LISP: ")) "")
   (setq off_dist (vl-catch-all-apply 'eval (list (read expr))))
   (if	(vl-catch-all-error-p off_dist)
     (alert "Expression LISP non valide")
     (progn
(setq newoff_pt (polar last_pt off_angle 10))
(command "._offset" off_dist last_entity newoff_pt "")
(setq last_entity
       (entlast)
) ;_ setq
     ) ;_ progn
   ) ;_ if
 ) ;_ while
 (setvar "cmdecho" userecho)
 (princ)
) ;_ defun
(princ "\nDébuter avec Extoss ") 
(princ)

[(gile)]

Une autre façon de faire, peut-être plu 'propre'.

 

Définir une fonction 'addition' qui requiert une chaîne de caractère comme argument et retourne le résultat de l'addition exprimé par la chaîne ou nil si l'expression n'est pas valide :

(addition "1+5+9") retourne 15.0

(addition "3*15") retourne nil

 

(defun c:Extoss	(/	      userecho	   ent_select	ent_pickpt   ent_orig	  off_pt
	 off_angle    last_entity  last_pt	expr	     off_dist	  newoff_pt
	)
 (or (member "geomcal.arx" (arx)) (arxload "geomcal"))
 (setq userecho (getvar "cmdecho"))
 (setvar "cmdecho" 0)
 (setq	ent_select (entsel "\nSélectionner l'objet à décaler: ")
ent_pickpt (cadr ent_select)
ent_orig   (car ent_select)
 ) ;_ setq 
 (redraw ent_orig 3)
 (setq	off_pt	  (getpoint "\nIndiquer la direction : ")
off_angle (angle ent_pickpt off_pt)
 ) ;_ setq 
 (setq	last_entity ent_orig
last_pt	    ent_pickpt
 )
 (while (/= (setq expr (getstring "\nSpécifiez la distance à décaler par addition: ")) "")
   (if	(setq off_dist (addition expr))
     (progn
(setq newoff_pt (polar last_pt off_angle 10))
(command "._offset" off_dist last_entity newoff_pt "")
(setq last_entity
       (entlast)
) ;_ setq
     ) ;_ progn
     (alert "Expression non valide")
   ) ;_ if
 ) ;_ while
 (setvar "cmdecho" userecho)
 (princ)
) ;_ defun
(princ "\nDébuter avec Extoss ") 
(princ)

;; addition
;; retourne le résultat d'une addition (ou nil)
;;
;; Argument
;; expr : une chaîne de caractère exprimant une addition
(defun addition (expr)
 ((lambda (l)
    (if (vl-every 'numberp l)
      (apply '+ l)
    )
  )
   (mapcar 'distof (str2lst expr "+"))
 )
)

;; str2lst
;; Transforme un chaine avec séparateur en liste de chaines
;;
;; Arguments
;; str : la chaine à transformer en liste
;; sep : le séparateur
(defun str2lst (str sep / pos)
 (if (setq pos (vl-string-search sep str))
   (cons (substr str 1 pos)
  (str2lst (substr str (+ (strlen sep) pos 1)) sep)
   )
   (list str)
 )
) 

 

Mais je ne suis pas sûr d'avoir compris ce que tu cherches à faire, parce que je ne vois pas bien l'utilité d'une telle routine.

[Bred]

Re,

Ah, ben mon message a dû se croiser avec ton MP....

La conclusion de (gile) rejoint la mienne.

 

pour les calculs, j'ai poster une routine dernièrement qui y répond aussi...

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

[Invité samuelM]

merci pour vos réponses.

ce que je dois faire : un programme Décaler mais au lieu de rentrer un nombre entier comme avec la fonction Décaler il faut que je puisse rentrer un addition

 

Merci

[Invité samuelM]

Je viens d'essayer le deuxième programme et il m'a l'air de fonctionner comme je veux.

 

Merci bien