Sélection suivant SCU ...

[Bred]

Salut,

 

Ne serait-ce pas une chose fabuleuse que la selection par fenêtre suive le SCU courant (si on le désirs... bien sûr...)

Un peu comme les options SPolygone et CPolygone de select, mais juste une boite ....

 

Exemple (bricolé) : je suis en train de selectionner le rectangle central (et pas par pointage : j'ai d'autre rectangle idem dessous que je veux prendre aussi), et ce, bien sûr, sans "attraper" les traits... à part les options cité ci-dessus, je ne vois pas comment....

 

http://xs313.xs.to/xs313/07135/select_scu.JPG

[BIM G CO]

je fais "_plan" et deux fois [Entrée] la sélection n'est pour l'instant qu'orthogonale à la vue

[Bred]

En effet, c'est une astuce...

moi je selectionne au plus juste, et j'enlève le surplus sélectionné avec shift...

mais je trouve mon souhait logique... non ?

 

et encore plus logique en 3D !!!!

[Tramber]

Bred, je suis d'accord avec toi dans le principe.

 

Mais le principal problème, je pense, est justement en 3D.

 

Comment faire quand la vue est orthogonale au SCU, ca nous est tous arrivé en 3D ! Quand le curseur, au lieu de décrire un rectangle décrit ce qui semble apparaitre comme une ligne. Je pense que les développeurs butteraient sur ce vrai problème qui créerait des selections abérantes.

[Bred]

En effet, Tramber... c'est pour cela que je souhaite une option ...

(si on le désirs... bien sûr...)

voir une manip différente (un shift en sélectionnant par exemple ...)

Donc, en 3D, il serait interressant d'avoir aussi la chose ... (toujour en option...)

Exemple : je ne veux selectionner que la ligne rouge (par un rectangle de selection bien sûr...)

http://xs313.xs.to/xs313/07135/select_scu2.JPG

[Tramber]

Avec la selection SPolygone, tu le fais en 4 clics au lieu de 2, mais tu le fais.

[x_all]

mouai.... l'ergonomie en 3D d'autocad est ce que j'aime le moins...

 

quand on voie la souplesse d'un sketchup, on se demande si les progrmeurs autaodesk ne sont pas des matheux enfermés dans leur matrices...a millle lieux d'imaginer les impératifs de rentabilité d'un dessiinateur...

bien sur, il existe un truc plaqué pour s'en sortir,....

 

mais le logiciel se prend tjs les pieds dans le scu !

je me suis fait avoir les 1ere fois par le fait que l'axe Z n'est pas forcément la verticale... bien sur, quand on vie dans un monde ou chager de repère n'est qu'une formalité mathématique, mais dans le batiment, ça surprend...

 

pour les sélection, je m'en sort avec une politique de calque assés rigoureuse, et je joue avec le verouillage, ça me permet de prendre large...

mais pour les acrochages en 3d, je le trouve pas fort... heureusement covadis fait du bont boulot (travail trés "mathématique" du reste)

 

le fait que les changement de zoom efface la sélection est ce qui a de pire. pour quoi un passage de la vue de face à la vue de dessus réinitialise la sélection???

[(gile)]

Salut,

 

En attendant que Autodesk veuille bien se pencher sur la question, une ébauche en LISP, peut-être à améliorer

 

(defun c:ssu (/ p1 gr p2 p3 p4 po)

 (defun ssu_err (msg)
   (if	(= msg "Fonction annulée")
     (princ)
     (princ (strcat "\nErreur: " msg))
   )
   (redraw)
   (setq *error* m:err
  m:err	nil
   )
   (princ)
 )

 (setq	m:err	*error*
*error*	ssu_err
 )
 (sssetfirst nil nil)
 (prompt "\nChoix des objets: ")
 (if (setq p1 (getpoint))
   (progn
     (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)
     (sssetfirst nil (ssget po (list p1 p2 p3 p4)))
   )
 )
 (setq	*error*	m:err
m:err nil
 )
 (princ)
) 

 

[Edité le 31/3/2007 par (gile)]

[Bred]

Alors là.... moi qui salivait d'avance en pensant que Personne ne pourrait pondre un code pour faire ça....

Super boulot, (gile) ! (ça commence d'ailleur à devenir blessant ta compétence en ce domaine !... snif ! .... ;) )

 

Mais.... et là je sais que tu en es à tes début (et je ne sais pas si c'est vraiment faisable) : Patrick_35 avait proposé un lisp avec réacteur à lancer pendant une commande (une commande avec un !) qui permettait de récupérer la totalité de la sélection venant d'être créer (ex : un miroirs de 10 objets A donne 10 objets B, et grace à la commande de patrick_35, on pouvait récupérer tous les objets B d'un coup....)

D'où, peut-être une idée, de réaliser le même genre de réacteur à lancer qui lancerait ton lisp si on lui demande, mors du choix d'un outils Autodesk (copier, etc....), permettant ainsi e n'avoir que la possibilité d'avoir que la préselection des objets.

 

mmm ???

[(gile)]

Salut,

 

Je vais essayer de regarder si je saurais faire quelque chose, je débute vraiment avec les réacteurs.

 

En attendant, voici une version améliorée avec la possibilité de faire plusieurs fenêtres/captures à la suite la sélection prend fin avec Entrée, Espace ou clic droit.

 

Si tu as PICKFIRST à 1, tu peux toujours faire la sélection avant de lancer la commande.

 

;; SSD (gile) 31/03/07
;; Sélection mutiple par cible, fenêtre ou capture
;; Le cadre de la fenêtre est parallèle au plan du SCU courant
;; La sélection est terminée en faisant Entrée, Espace ou clic droit

(defun c:ssd (/ sel sst loop p1 gr p2 p3 p4 po ss n ent)

 (defun ssd_err (msg)
   (if	(= msg "Fonction annulée")
     (princ)
     (princ (strcat "\nErreur: " msg))
   )
   (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)
     )
   )
 )

 (setq	m:err	*error*
*error*	ssu_err
 )
 (sssetfirst nil nil)
 (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)
    )
    (sssetfirst nil sst)
  )
)
     )
     (progn
(ssadd (ssname p1 0) sst)
(sssetfirst nil sst)
     )
   )
 )
 (sssetfirst nil sst)
 (setq	*error*	m:err
m:err nil
 )
 (princ)
) 

 

[Edité le 31/3/2007 par (gile)]

[Bred]

Encore mieux...

Le seul petit défaut que j'ai déceler pour l'instant est que bizarrement il ne sort pas de la commande lors d'une validation avec clic droit (avec souris paramétrer en entrée avec click droit), Alors que l'on sort si l'on fait un "simple" validation par clavier (space ou entrée).

(Je suis sur 2006 là...)

[(gile)]

il ne sort pas de la commande lors d'une validation avec clic droit

 

:casstet: Curieux

 

Essayes d'entrer (grread) à la ligne de commande et de faire clic droit, il devrait t'être retourné une liste c'est le premier élément de cette liste (25 chez moi) qui est utilisé pour sortir de la commande.

CF : (or (member gr '((2 13) (2 32))) (eq (car gr) 25)).

 

[Edité le 31/3/2007 par (gile)]

[Bred]

Si "Menus Contextuels" décoché :

Commande: (grread)

(11 0)

 

Si coché :

Commande: (grread)

(25 216)

 

[Edité le 31/3/2007 par Bred]

[(gile)]

Merci,

 

Je modifie le code en conséquence.

[Tramber]

Bred,

 

tu as formulé la demande d'un jeune (sur AutoCAD) et ca se voie. Tu peux me croire, j'étais là à l'époque de la 12 quand j'ai compris l'histoire du logiciel. La 3D était nouvelle et peu utilisée. Par ailleurs, on apprenait à selectionner à l'époque. Et si SP et CP était utilisés c'est surtout qu'on ne zoomait pas du tout de la même façon. Or, dans le code de Gile, il n'y a ni plus ni moins que l'utilisation de ces 2 "vieux" modes de saisie. Il fallait les maitriser à l'époque car, entre autre, il n'y avait ni roulette ni PAN interactif !

 

Voilà un code admirable, mais qui ne fonctionnera qu'en préselection !

Sinon, CP ou SP !

 

Historiquement, je me souviens aussi qu'il y avait une certaine culture du multi-fenêtrage 3D ou le problème se pose beaucoup moins dans les vues ortho si on règle bien les différents réglages SCU par fenêtre.

[Bred]

:casstet:

J'ai commencé à la 14 et suis rapidement passé à la 95 sous windows....

En effet Autocad était différent ....

En effet il fallait beaucoup trimer pour réaliser certaine manipulation qu'aujourdhui on fait sans se rendre compte de la vitesse gagné (pour créer un angle.... pour alonger une ligne....)

En effet avant il n'existait que les options Boite, SPolygone, CPolygone de select.... avant....

 

Historiquement, je me souviens aussi qu'il y avait une certaine culture du multi-fenêtrage 3D ou le problème se pose beaucoup moins dans les vues ortho si on règle bien les différents réglages SCU par fenêtre.

En 3D je travail sur des structures type treillis tubulaire en 3D de trés gros volume... le multifenêtrage est utile à un certains niveaux, mais il reste toujours le problème de surcharge visuel... et de taille d'affichage... C'est une méthode que j'utilise pour certaine manipulations, mais cela fait partis de méthode de travaille personnel... heureusement que de outils perso sont là pour faciliter des tâches spécifique. Mais certaine astuces et besoins comme des selections "spécifiques" sont des généralités, d'où mon souhait.

 

Mon post est dans la partie "liste de souhait".... si je ne peux emettre l'idée d'une manipulation qui dans mon idée peux faire gagner du temps, je ne vois pas à quoi sert cet endroit....

 

Donc j'avoue ne vraiment pas comprendre le sens de tes remarques....

 

Voilà un code admirable, mais qui ne fonctionnera qu'en préselection !

Voir mon message 8 ....

 

 

 

 

 

 

 

[(gile)]

Voilà un premier jet, avec reacteurs sur les commandes d'édition les plus courantes (tu pourras en rajouter d'autre dans la liste si tu veux)

 

Ça fonctionne chez moi, il faut que pickfirst soit à 1, taper "s" pour avoir la sélection suivant le SCU, n'importe quoi d'autre ou un clic pour une sélection "normale".

 

En cas d'annulation pendant la sélection en mode SCU on revient en mode normal.

 

Taper gileSelScu_on pour activer, gileSelScu_off pour désactiver.

 

Edit : je retire "STRETCH" de la liste :P

ReEdit : après des test plus poussés je ne laisse dans la liste des commandes que celles qui semblent fonctionner sans surprises.

 

;; gileSelScu 31/03/07 -Gilles Chanteau-
;; active ou désactive une option de sélection suivant le SCU courant.

(defun c:gileSelScu_on ()
 (vl-load-com)
 (if (not *gileSelScu*)
   (setq *gileSelScu*
   (vlr-command-reactor
     nil
     '((:vlr-commandWillStart . gileSelScu))
   )
   )
 )
 (princ "\nSélection selon SCU activée.")
 (princ)
)

(defun c:gileSelScu_off	()
 (if *gileSelScu*
   (vlr-remove *gileSelScu*)
 )
 (setq *gileSelScu* nil)
 (princ "\nSélection selon SCU désactivée.")
 (princ)
)

(defun gileSelScu
      (rea cde / sscu_err sel sst p1 p2 p3 p4 gr po ss n ent)
 (if
   (and
     (member (car cde)
      '("COPY" "ERASE" "MIRROR"	"MOVE" "ROTATE"	"ROTATE3D"
	"SCALE")
     )
     (not (cadr (ssgetfirst)))
     (= 1 (getvar "PICKFIRST"))
     (princ
"\nTaper \"S\" pour une sélection suivant le SCU courant : "
     )
     (member (grread) '((2 115) (2 83)))
   )
    (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)
   )
 )
      )

      (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)
) 

[Edité le 31/3/2007 par (gile)]

 

[Edité le 31/3/2007 par (gile)]

[bonuscad]

Juste pour info.

Le code de retour de (grread) pour les clicks-droit est influencé par la variable SHORTCUTMENU

 

anisi que les associations avec Shift et Control

 

on peut tester comme ceci

 

(setq n 0)(repeat 16

(setvar "SHORTCUTMENU" n)

(print (itoa n))

(princ (grread))

(setq n (1+ n))

)

 

[Edité le 31/3/2007 par bonuscad]

[Bred]

Merci (gile) fabuleux !

 

Je me permet quelques remarques et suggestions :

 

1- L'option "S" n'est pas atteignable si c'est un rappel de commande par click droit (=entrée)

 

2- Je verrais le choix du lancement de cet outils différement : ce n'est pas au moment ou on lance une commande que l'on puisse avoir le choix de le lancer ou pas, mais je le vois comme une variable qui serait enregisré et qui signalerait si l'on veut tout le temps ou non ce type de selection (j'ai créer ce principe pour certaine commande en enregistrant une variable dans le base de registre).

 

3- Il devrait y avoir un test : si le SCU est parrallèle (=) au SCG, l'outil ne se lance pas et la selection et "autocadienne" (ce qui permet de garder le code couleur choisis.) car il est quand même en majorité dans ce cas là (pour moi en tout cas...)

 

Je pense que cet outil est bien partis pour être un indispensable !!!....

[(gile)]

Merci à vous pour les remarques et suggestions.

 

Voici une nouvelle version qui en tient compte, excepté pour la première remarque de Bred que je n'arrive pas à reproduire.

 

L'activation/désactivation du réacteur se fait comme s'il s'agissait d'une variable système. J'ai pensé qu'il était plus cohérent de conserver sa valeur dans le dessin (ldata plutôt qu'inscription dans la base de registre) :

si GILESELSCU est à 0 Mode de sélection AutoCAD normal,

si c'est 1, la fenêtre de sélection est parallèle au SCU courant quand celui-ci est pivoté par rapport au SCG...

 

Edit : ...et quand le plan XY du SCU n'est pas proche de la parallèle à la vue

 

;;********************************************************************;;
;; GILESELSCU 01/04/07 -Gilles Chanteau-
;; Active ou désactive la fenêtre de sélection parallèle au SCU courant
;; pour les commandes : copier, déplacer, échelle, effacer, miroir,
;; rotation et 3drotation.
;; La valeur est enregistrée dans le dessin
;; 1 : Activé
;; 0 : Désactivé
;;********************************************************************;;

(defun c:gileSelScu (/ ac)
 (vl-load-com)
 (if (not (vlax-ldata-get "gileselscu" "active"))
   (vlax-ldata-put "gileselscu" "active" 0)
 )
 (while (not (or (= ac 1) (= ac 0)))
   (setq
     ac (getint
   (strcat "\nEntrez une nouvelle valeur pour GILESELSCU 		   (itoa (vlax-ldata-get "gileselscu" "active"))
	   ">: "
   )
 )
   )
   (if	(not ac)
     (setq ac (vlax-ldata-get "gileselscu" "active"))
     (if (or (	(princ "\nNécessite seulement 0 ou 1.")
     )
   )
 )
 (vlax-ldata-put "gileselscu" "active" ac)
 (if (= 1 (vlax-ldata-get "gileselscu" "active"))
   (if	(not *gileSelScu*)
     (setq *gileSelScu*
     (vlr-command-reactor
       nil
       '((:vlr-commandWillStart . gileSelScuRea))
     )
     )
   )
   (progn
     (if *gileSelScu*
(progn
  (vlr-remove *gileSelScu*)
  (setq *gileSelScu* nil)
)
     )
   )
 )
 (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")
     )
     (not (and
     (equal (getvar "UCSXDIR") '(1 0 0) 1e-6)
     (equal (getvar "UCSYDIR") '(0 1 0) 1e-6)
   )
     )
     (setq vd (vunit (getvar "VIEWDIR")))
     (not
(or (equal (abs (car vd)) 1 0.01)
    (equal (abs (cadr vd)) 1 0.01)
    (equal (abs (caddr vd)) 0 0.01)
)
     )
     (not (cadr (ssgetfirst)))
     (= 1 (getvar "PICKFIRST"))
   )
    (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 1/4/2007 par (gile)]

 

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

[(gile)]

On peut remplacer l'expression à coller dans MNL ou acaddoc.lsp par celle-ci.

Elle envoie un message d'alerte à l'ouverture d'un dessin dans lequel aurait été utilisé GILESELSCU si cas où les LISPs ne sont pas chargés dans ce dessin.

 

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

[Tramber]

Donc j'avoue ne vraiment pas comprendre le sens de tes remarques....

 

Mon cher ami, moi aussi j'ai parfois besoin dans rectangle de selection suivant un SCU orienté.

 

Mais je maintiens qu'en cas de SCU ortho à la vue, les développeurs seraient embêtés.

C'est tout, y a pas vraiment de remarque si ce n'est que les polygones marchent très bien et qu'on ne pourra donc pas attendre d'amélio.

 

Sauf en préselection grâce à (gile) :cool:

(remarque, j'ai lu le lisp, apparemment il pourrait être utilisable en selection normale, c'est cool).

 

Donc, je suis tout à fait partant pour l'amélio des options de selections. Alors en cas de SCU orthogonal à la vue, qu'AutoCAD refuse, tout simplement et propose la fenêtre habituelle.

... et pour LT aussi, bien sûr.

C'est souvent en 2D que j'en ai eu besoin, en tous cas. Si une bonne âme d'Autodesk nous entend ?!

 

 

[Edité le 1/4/2007 par Tramber]

[(gile)]

j'ai lu le lisp, apparemment il pourrait être utilisable en selection normale, c'est cool

 

Oui, oui, si le réacteur est actif, si le SCU est pivoté par rapport au SCG, et si, là j'ai tenu compte de ta remarque, il n'est pas "orthogonal à la vue", la fenêtre de sélection se fait automatiquement suivant le SCU après avoir lancé la commande.

[Tramber]

Une routine à mettre dans le forum Lisp maintenant.

 

Histoire aussi de ne pas trop dégouter les LTsiens :cool:

[Bred]

Ok, (gile) .... comme d'habitude .... ;)

Je suis encore plus épaté que ça fonctionne pour les vues ortho au scu !...

 

Par contre, après quelque test lorsque la "variable" GILESELSCU et sur 1 (active) :

- Quand on est en position SCU "normale", la selection reste bien "autocadienne" (avec couleur...) mais que si l'on fait un "valider" dans le "vide" avant ...

 

et là j'abuse :

- Vu que ça fonctionne pour toutes les commandes que l'on veut, n'y aurait t'il pas moyen de paramétrer le réacteur pour que la selection se fasse Avant la commande aussi ? (qu'il reconnaisse le clic gauche dans le vide en fait...)