Fenêtre de sélection parallèle au SCU

[(gile)]

Suite à ce sujet, je poste ici une routine qui permet, pour les commandes copier, déplacer, échelle, effacer, miroir, rotation et 3drotation, de sélectionner les objets avec une fenêtre parallèle au SCU courant.

 

Ça fonctionne un peu comme une variable sysrème dont la valeur est conservée dans le dessin.

 

Taper GILESELSCU et entrer 1 pour activer le réacteur 0 pour le désactiver.

 

NOTA 1 : si le réacteur est actif la fenêtre de sélection reste "standard" quand, dans la vue courante :

- la vue est une vue en plan du SCU courant

- le plan du SCU est perpendiculaire au plan de la vue (icone SCU 2D en "crayon cassé").

 

NOTA 2 : Ne fonctionne que si PICKFIRST est à 1.

 

NOTA 3 : Pour réactiver automatiquement la "variable" à la réouverture d'un dessin dans lequel elle a été activée, il faut coller l'expression suivante dans le fichier MNL courant ou dans un fichier acaddoc.lsp (à créer dans un dossier du chemein de recherche s'il n'existe pas)

 

 

Edit 1 : Prise en compte des remarques de Patrick_35. Le LISP et l'expression suivantes on été modifiées.

 

(if (vlax-ldata-get "gileselscu" "active")
 (if (and C:GILESELSCU GILESELSCUREA)
   (if	(not *gileSelScu*)
     (setq *gileSelScu*
     (vlr-command-reactor
       nil
       '((:vlr-commandWillStart . gileSelScuRea))
     )
     )
   )
   (alert "\nGILESELSCU n'est pas chargé.")
 )
)

 

 

Le LISP :

 

 ;;********************************************************************;;
;; GILESELSCU 02/04/07 -Gilles Chanteau- version 1.3
;;
;; Fonctionne comme une variable système
;;
;; Le paramètre est stocké dans le dessin sous forme d'un entier.
;;
;; 0 : Désactivé.
;;
;; 1 : Active la fenêtre de sélection parallèle au SCU courant pour les
;; commandes : copier, déplacer, échelle, effacer, miroir, rotation et
;; 3drotation.
;;
;;********************************************************************;;

(defun c:gileSelScu (/ ac)
 (vl-load-com)
 (if (vlax-ldata-get "gileselscu" "active")
   (setq *gileselscuval* 1)
   (setq *gileselscuval* 0)
 )
 (while (not (or (= ac 1) (= ac 0)))
   (setq
     ac (getint
   (strcat "\nEntrez une nouvelle valeur pour GILESELSCU 		   (itoa *gileselscuval*)
	   ">: "
   )
 )
   )
   (if	(not ac)
     (setq ac *gileselscuval*)
     (if (or (	(princ "\nNécessite seulement 0 ou 1.")
(setq *gileselscuval* ac)
     )
   )
 )
 (if (= 1 ac)
   (progn
     (vlax-ldata-put "gileselscu" "active" T)
     (if (not *gileSelScu*)
(setq *gileSelScu*
       (vlr-command-reactor
	 nil
	 '((:vlr-commandWillStart . gileSelScuRea))
       )
)
     )
   )
   (progn
     (if *gileSelScu*
(progn
  (vlr-remove *gileSelScu*)
  (setq *gileSelScu* nil)
  (vlax-ldata-delete "gileselscu" "active")
)
     )
   )
 )
 (princ)
)

;;********************************************************************;;

(defun gileSelScuRea
      (rea cde / sscu_err sel vd sst p1 p2 p3 p4 gr po ss n ent)
 (if
   (and
     (member (car cde)
      '("COPY" "ERASE" "MIRROR"	"MOVE" "ROTATE"	"ROTATE3D"
	"SCALE")
     )
     (= 1 (getvar "PICKFIRST"))
     (setq vd (vunit (getvar "VIEWDIR")))
     (setq zd (trans '(0 0 1) 1 0 T))
     (not
(or
  (cadr (ssgetfirst))
  (equal
    (abs
      (rem (+ (angle '(0 0 0) (trans (getvar "ucsxdir") 0 zd))
	      (getvar "viewtwist")
	   )
	   (/ pi 2)
      )
    )
    (/ pi 2)
    1e-9
  )
  (equal
    (abs
      (rem (- (angle '(0 0 0) (trans (getvar "ucsxdir") 0 zd))
	      (getvar "viewtwist")
	   )
	   (/ pi 2)
      )
    )
    0
    1e-9
  )
  (equal (caddr vd) 0 0.01)
)
     )
   )
    (progn

      ;; Gestion des erreurs
      (defun sscu_err (msg)
 (if (= msg "Fonction annulée")
   (princ)
   (princ (strcat "\nErreur: " msg))
 )
 (if sst
   (repeat (setq n (sslength sst))
     (redraw (ssname ss (setq n (1- n))) 4)
   )
 )
 (sssetfirst nil nil)
 (redraw)
 (setq *error* m:err
       m:err nil
 )
 (princ)
      )

      ;; Retourne un jeu de sélection, un point ou nil
      (defun sel (/ loop gr pt)
 (setq loop T)
 (while	(and (setq gr (grread T 12 2)) (/= (car gr) 3) loop)
   (cond
     ((= (car gr) 5)
      (setq pt (cadr gr))
     )
     ((or (member gr '((2 13) (2 32)))
	  (or (= (car gr) 11) (= (car gr) 25))
      )
      (setq loop nil
	    pt	 nil
      )
     )
   )
 )
 (if pt
   (cond
     ((ssget pt))
     (pt)
   )
 )
      )
      
      ;; Fonction principale
      (setq m:err   *error*
     *error* sscu_err
      )
      (setq sst (ssadd))
      (while (and
	(princ "\nChoix des objets: ")
	(setq p1 (sel))
      )
 (if (listp p1)
   (progn
     (princ "\nSpécifiez le coin opposé: ")
     (setq p1 (list (car p1) (cadr p1)))
     (while (and (setq gr (grread T 12 0)) (/= (car gr) 3))
       (if (= 5 (car gr))
	 (progn
	   (redraw)
	   (setq p2 (list (caadr gr) (cadr p1))
		 p3 (list (caadr gr) (cadadr gr))
		 p4 (list (car p1) (cadadr gr))
	   )
	   (if (		     (progn
	       (setq po "_WP")
	       (grvecs
		 (list 255 p1 p2 255 p2 p3 255 p3 p4 255 p4 p1)
	       )
	     )
	     (progn
	       (setq po "_CP")
	       (grvecs
		 (list -255 p1 p2 -255 p2 p3 -255 p3 p4	-255 p4
		       p1)
	       )
	     )
	   )
	 )
       )
     )
     (redraw)
     (if (setq ss (ssget po (list p1 p2 p3 p4)))
       (repeat (setq n (sslength ss))
	 (setq ent (ssname ss (setq n (1- n))))
	 (if (not (ssmemb ent sst))
	   (ssadd ent sst)
	 )
	 (redraw ent 3)
       )
     )
   )
   (progn
     (ssadd (ssname p1 0) sst)
     (redraw (ssname p1 0) 3)
   )
 )
      )
      (sssetfirst nil sst)
      (setq *error* m:err
     m:err nil
      )
    )
 )
 (princ)
)

;;********************************************************************;;

;;; VUNIT Retourne le vecteur unitaire d'un vecteur
(defun vunit (v)
 ((lambda (l)
    (if (/= 0 l)
      (mapcar '(lambda (x) (/ x l)) v)
    )
  )
   (sqrt (apply '+ (mapcar '* v v)))
 )
)

;;********************************************************************;;

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

 

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

[Bred]

Salut (gile), merci.

petit oubli de sous routine :

erreur: no function definition: ANG<2PI

[(gile)]

Oups ...

 

... réparé.

[Patrick_35]

Génial

(gile) commence à tâter du réacteur :)

Juste une remarque pour savoir si ton réacteur est déjà actif et d'éviter de rechercher dans atoms-family (ce qui est un peu lourd à mon sens) , utilise la fonction vlr-reactors et dans le cas présent (vlr-reactors :vlr-command-reactor). Tu auras ainsi les réacteurs command qui pointent sur tes routines et donc de les retrouver afin de savoir si elles sont chargées ou pas

Et une autre, si ton réacteur est désactivé, pourquoi ne pas simplement effacer le vlax-ldata plutôt que le le mettre à 0 ?. A mon sens, ce serait plus propre, car si on n'en a pas besoin, inutile de "polluer" le dessin.

 

Et une dernière chose, tu as oublié les grips --> "GRIP_MOVE" "GRIP_MIRROR" "GRIP_SCALE" "GRIP_ROTATE" "GRIP_STRETCH" dans ton réacteur

 

ps : pour te guider, il faut aussi utiliser vlr-reactions avec le vlr-reactors

 

@+

 

[Edité le 2/4/2007 par Patrick_35]

[(gile)]

Je viens de re-modifier un peu le code (toujours les tests pour faire basculer en mode "standard"). Plus besoin de ang

 

Patrick_35,

 

Merci pour les encouragements, je vais regarder de plus près tous tes conseils.

[(gile)]

Patrick_35,

 

Juste une remarque pour savoir si ton réacteur est déjà actif et d'éviter de rechercher dans atoms-family

L'expression étant dans le MNL ou acadoc.lsp, je ne cherche pas si le réacteur est actif, mais si les fonctions sont chargées pour la (ré)ouverture d'un dessin

 

Et une autre, si ton réacteur est désactivé, pourquoi ne pas simplement effacer le vlax-ldata plutôt que le le mettre à 0 ?

J'avis besoin de garder une valeur dans le dessin pour la retourner dans l'invite :

 

(strcat "\nEntrez une nouvelle valeur pour GILESELSCU

(itoa (vlax-ldata-get "gileselscu" "active"))

">: "

)

 

Tu as raison, une variable globale peut suffire et ne sera pas conservée dans le dessin après fermeture.

Je modifie le code en conséquence.

 

Et une dernière chose, tu as oublié les grips

Et non, la routine sert à changer la forme de la fenêtre de sélection après le lancement d'une commande.

Pour les grips (présélection) il y a la routine SSD.

 

Je suis entrain d'essayer d'utiliser un réacteur sur le double-clic pour la sélection suivant le SCU si aucune commande n'est active, mais j'ai un soucis : une fois la sélection faite, quand je la valide par entrée, espace ou clic-droit, au lieu de sortir, je reviens en mode sélection "standard" avec une fenêtre dont le premier coin est sur le point du double clic.

 

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

[jalna]

S-U-P-E-R-B-E (Merci pour ce lisp très appréciable) :exclam:

[Patrick_35]

L'expression étant dans le MNL ou acadoc.lsp, je ne cherche pas si le réacteur est actif, mais

mmmm, je pense comprendre.

Pour tester si une fonction est disponible, tu peux faire

(if c:une_fonction (alert"Chargé")(alert"Inconnu"))

ou encore

(if une_fonction (alert"Chargé")(alert"Inconnu"))

Maintenant, si on ouvre un autre dessin (via différentes méthodes) avec la variable SDI autre que zéro, on a un message d'erreur car le réacteur est toujours actif, mais comme c'est un nouveau dessin, le lisp n'est plus présent (normal) et en plus, on perd la variable qui nous a servi pour pointer sur le réacteur.

Dans ce cas, j'efface tout simplement le/les réacteurs en utilisant le réacteur vlr-beginclose du vlr-editor.

Et comme j'utilise aussi des vlr-command, alors dans ce cas, je passe mes vlr-command en vlr-editor, qui a plus de fonctionnalités afin de ne travailler plus qu'avec un type de réacteur.

(d’ailleurs, je n’ai pas encore bien compris l’avantage d’un vlr-command par rapport à un vlr-editor)

 

Le problème du réacteur double-clic ou de celui du clic droit, et qu’il continue la commande en cours.

En clair, il vient s’immiscer dans la commande sans l’interrompre et je n’ai pas encore réussi à l’heure actuel à exploiter le double clic ou le clic droit en tant qu’action individuel. Peut-être avec les activex, mais je n’ai pas fait de recherches de ce coté.

 

@+

[(gile)]

(if c:une_fonction (alert"Chargé")(alert"Inconnu"))

 

Ben, bien sûr ! tout simplement !

 

Je vais regarder vers vlr-beginclose et vlr-editor, merci ;)

[yusukens82]

Fantastique..

j'ai eu du mal à comprendre l'utilité de ce lisp au début, on dirait un vrai variable du logiciel.

Vraiment bravo Gile.

 

par contre j'ai remarqué qu'on pouvait pas soustraire les objets après avoir sélectioner les objet. mais bon, la selection est déja plus simple ainsi, plus besoin de soustraire.

 

encore bravo