Lisp d\'aide a l\'insertion de bloc en serie.

[Invité vinc3nz0o]

Bonjour,

Tout d'abord je vous pries de bien vouloir excuser mon orthographe.

Je suis un débutant en lisp et j'ai pour projet de créer plusieurs petits applicatifs.

(Je viens de finir mon premier (=implantation automatique de point NGF en fonction d'un point de ref))

Je souhaiterai donc créer un programme qui faciliterai l'implantation électrique, voila la maniere dont je le vois :

L'utilisateur choisirai son élément d'implantation dans une boite dcl (sauf si il y a plus simple)

Ensuite appuyant sur une touche le bloc ferait une rotation de 90° ( le bloc ne doit pas etre implanter ms tjr en sélection libre) un second appuis sur cette touche permettrai de passer a 180° ect ... une fois l'orientation choisit l'utilisateur clique et le bloc s'insert avec la bonne orientation a l'endroit cliquer)

 

En gros c'est cette partie la qui me pose problème fin mon premier problème ^^ .

 

Autre question : est il possible de comptabiliser le nombre de bloc du même nom de mon dessin sous lisp ?

 

Je vous remercie d'avance pour votre aide et vos conseils.

 

Vincent

[Tramber]

Sois bienvenu,

 

 (command "_insert" "NOM_DE_TON_BLOC" (getpoint "\nPoint d'insertion") 1 1 0)
(setq insb (entlast))
(setq dxinsb(entget insb))
(setq boucle T
     incr (/ pi 4)); ICI, tu peux mettre la valeur d'incrément que tu veux !
(while (and boucle (setq gr (grread T 12 0)))
 (redraw)
 (cond
   ;; Curseur à l'écran
   ((= (car gr) 5)
    (setq angcentregr (angle (cdr(assoc 10 dxinsb)) (cadr gr))
   angcentregr
    (if (/= incr 0.0)
      (- (+ angcentregr(/ incr 2)) (rem (+ angcentregr(/ incr 2)) incr))	      angcentregr)
   )
    (setq dxinsb (subst (cons 50 angcentregr) (assoc 50 dxinsb) dxinsb ))
    (entmod dxinsb)     
    )
   ;; Clic gauche souris
   ((= (car gr) 3)
    (setq boucle nil)
    )
    ;; Gestion des entrées clavier
    (T (redraw) (setq boucle nil))
    )
   )

 

Salut, avec ce petit code de base, tu vas déjà pouvoir t'amuser.

 

est il possible de comptabiliser le nombre de bloc du même nom de mon dessin sous lisp ?

(setq sel (ssget "X"(list '(0 . "INSERT")(cons 2 "NOM_DE_TON_BLOC")))) 

Te renvoie une sélection. (sslength sel) donnera la longueur.

 

 

 

[Edité le 28/3/2011 par Tramber]

[bryce]

Bonjour,

 

Si j'ai bien compris, il s'agit de pouvoir faire pivoter le bloc avec les flèches au clavier AVANT de choisir le point d'insertion... :exclam:

 

 

 

[Edité le 28/3/2011 par bryce]

[Tramber]

 (command "_insert" "NOM_DE_TON_BLOC" (getpoint "\nPoint d'insertion") 1 1 0)
(setq insb (entlast)
     dxinsb(entget insb)
     boucle T
     incr (/ pi 4)); ICI, tu peux mettre la valeur d'incrément que tu veux !
(princ"\nChoisissez une rotation ou tapez 6, 8, 4 ou 2 :")
(while (and boucle (setq gr (grread T 12 0)))
 (redraw)
 (cond
   ;; Curseur à l'écran
   ((= (car gr) 5)
    (setq angcentregr (angle (cdr(assoc 10 dxinsb)) (cadr gr))
   angcentregr
    (if (/= incr 0.0)
      (- (+ angcentregr(/ incr 2)) (rem (+ angcentregr(/ incr 2)) incr))
      angcentregr)
   )
    (setq dxinsb (subst (cons 50 angcentregr) (assoc 50 dxinsb) dxinsb ))
    (entmod dxinsb)
    )
   ;; Clic gauche souris
   ((= (car gr) 3)
    (setq boucle nil)
    )
   ;; Gestion des entrées clavier
   ((= (car gr) 2)
    (cond
      ((= (cadr gr) 54)(setq dxinsb (subst (cons 50 0) (assoc 50 dxinsb) dxinsb )))
      ((= (cadr gr) 52)(setq dxinsb (subst (cons 50 pi) (assoc 50 dxinsb) dxinsb )))
      ((= (cadr gr) 56)(setq dxinsb (subst (cons 50 (/ pi 2)) (assoc 50 dxinsb) dxinsb )))
      ((= (cadr gr) 50)(setq dxinsb (subst (cons 50 (/ pi -2)) (assoc 50 dxinsb) dxinsb )))
      )
    (entmod dxinsb)
    (setq boucle nil)
    )
   (T (setq boucle nil))    
   )
 )

 

J'ai proposé le même code, nettoyé et additionné de la possiblité d'orienter avec 4 touches du clavier numérique (pas toujours dispo sur un PC portable) : 2, 4, 6 et 8.

[Invité vinc3nz0o]

Efficasse messieurs!

 

Merci beaucoup je regarde tout ca dès que j'ai un peu de temps et je vous tiens au courant de l'évolution.

 

En tout cas merci beaucoup pour votre efficassité !

 

:)

[(gile)]

Salut,

 

Ma proposition

 

Commande INS : répétitive, le bloc est inséré en fonction du SCU courant.

Choisir un bloc avec la boite de dialogue, puis :

- clic droit pour faire pivoter le bloc de 90°

- clic gauche pour insérer le bloc

- Entrée ou Espace pour quitter la commande.

 

EDIT : ajout d'une émulation des accrochages aux objets courants

 

(defun c:ins (/ *error* insblk blk zdir pt ref ang gr loop)
 (defun *error* (msg)
   (and msg
 (/= msg "Fonction annulée")
 (princ (strcat "\nErreur: " msg))
   )
   (and ref (entdel ref) (setq ref nil))
   (and *GrOsnapMarker* (mapcar 'entdel *GrOsnapMarker*) (setq *GrOsnapMarker* nil))
   (princ)
 )

 (defun insblk	(bname ins ang zdir)
   (entmakex
     (list
'(0 . "INSERT")
(cons 2 bname)
(cons 10 ins)
(cons 50 ang)
(cons 210 zdir)
     )
   )
 )
 (if (setq blk (gc:GetBlock nil))
   (progn
     (if (vl-filename-directory blk)
(progn
  (command "_insert" blk)
  (command)
  (setq blk (vl-filename-base blk))
)
     )
     (setq zdir (trans '(0. 0. 1.) 1 0 T)
    ang	(angle '(0. 0. 0.) (trans (getvar 'ucsxdir) 0 zdir))
    loop T
     )
     (while (and (setq gr (grread T 12 0)) loop)
(cond
  ((= 5 (car gr))
   (and ref (entdel ref) (setq ref nil))
   (setq pt  (cond
	       ((grosmode (cadr gr)))
	       ((cadr gr))
	       )
	 ref (insblk blk (trans pt 1 zdir) ang zdir)
   )
  )
  ((member(car gr) '(12 25))
   (and ref (entdel ref) (setq ref nil))
   (setq ang (+ ang (/ pi 2)))
   (setq ref (insblk blk (trans pt 1 0) ang zdir))
  )
  ((= 3 (car gr))
   (setq ang (angle '(0. 0. 0.) (trans (getvar 'ucsxdir) 0 zdir))
	 ref (insblk blk (trans pt 1 0) ang zdir)
	 )
  )
  ((or (equal gr '(2 13)) (equal gr '(2 32)))
   (setq loop nil)
   )
)
     )
   )
 )
 (*error* nil)
)

;; GrOsmode
;; Emuler les accrochages aux objets courants avec grread
;; *GrOsnapMarker* = variable globale contenant une liste des noms d'entités des
;; polylignes figurant le marqueur AutoSnap à supprimer dans la fonction d'appel :
;; (and *GrOsnapMarker* (mapcar 'entdel *GrOsnapMarker*) (setq *GrOsnapMarker* nil))
;;
;; Argument le point retouné par grread (coordonnées SCU du pointeur)
;;
;; Retour : le point retourné par osnap ou nil

(defun grosmode	(pt	/      _end   _mid   _cen   _nod   _qua
	 _int	_ins   _per   _tan   _nea   osmode scl
	 norm	loop   mlst   mstr _mod   result marker
	)

 (defun _end (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 4)
  '(70 . 1)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 1.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.75 pi) (* (sqrt 2) scl)))
  (cons 210 norm)
)
     )
   )
 )

 (defun _mid (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 3)
  '(70 . 1)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 1.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.5 pi) scl))
  (cons 210 norm)
)
     )
   )
 )

 (defun _cen (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 2)
  '(70 . 1)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt pi scl))
  '(42 . 1.0)
  (cons 10 (polar pt 0.0 scl))
  '(42 . 1.0)
  (cons 210 norm)
)
     )
   )
 )

 (defun _nod (pt scl norm)
   (cons (car (_cen pt scl norm)) (_int pt scl norm))
 )

 (defun _qua (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 4)
  '(70 . 1)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.5 pi) scl))
  (cons 10 (polar pt 0.0 scl))
  (cons 10 (polar pt (* 0.5 pi) scl))
  (cons 10 (polar pt pi scl))
  (cons 210 norm)
)
     )
   )
 )

 (defun _int (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 2)
  '(70 . 0)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.25 pi) (* (sqrt 2) scl)))
  (cons 210 norm)
)
     )
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 2)
  '(70 . 0)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.75 pi) (* (sqrt 2) scl)))
  (cons 210 norm)
)
     )
   )
 )

 (defun _ins (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 6)
  '(70 . 1)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.5 pi) scl))
  (cons 10 (polar pt (* 1.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt 0.0 scl))
  (cons 10 (polar pt pi scl))
  (cons 10 (polar pt (* 0.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.5 pi) scl))
  (cons 210 norm)
)
     )
   )
 )

 (defun _per (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 3)
  '(70 . 0)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 0.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 1.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 1.75 pi) (* (sqrt 2) scl)))
  (cons 210 norm)
)
     )
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 3)
  '(70 . 0)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.5 pi) scl))
  (cons 10 pt)
  (cons 10 (polar pt pi scl))
  (cons 210 norm)
)
     )
   )
 )

 (defun _tan (pt scl norm)
   (cons
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 2)
  '(70 . 0)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 0.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.75 pi) (* (sqrt 2) scl)))
  (cons 210 norm)
)
     )
     (_cen pt scl norm)
   )
 )

 (defun _nea (pt scl norm)
   (list
     (entmakex
(list
  '(0 . "LWPOLYLINE")
  '(100 . "AcDbEntity")
  '(100 . "AcDbPolyline")
  '(8 . "0")
  '(62 . 1)
  '(90 . 4)
  '(70 . 1)
  (cons 43 (* scl 0.2))
  (cons 10 (polar pt (* 1.25 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 1.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.75 pi) (* (sqrt 2) scl)))
  (cons 10 (polar pt (* 0.25 pi) (* (sqrt 2) scl)))
  (cons 210 norm)
)
     )
   )
 )

 (and *GrOsnapMarker*
      (mapcar 'entdel *GrOsnapMarker*)
      (setq *GrOsnapMarker* nil)
 )
 (setq	osmode (getvar "OSMODE")
scl    (/ (* 1.25 (atoi (getenv "AutoSnapSize")) (getvar "VIEWSIZE"))
	  (cadr (getvar "SCREENSIZE"))
       )
norm   (trans '(0 0 1) 2 0 T)
loop   T
 )
 (if (zerop (logand osmode 16384))
   (mapcar '(lambda (b s)
       (or (zerop (logand b osmode))
	   (setq mlst (cons s mlst))
       )
     )
    '(1 2 4 8 16 32 64 512)
    '("_end" "_mid" "_cen" "_nod" "_qua" "_int" "_ins" "_nea")
   )
 )
 (setq	mstr   (lst2str mlst ",")
result (osnap pt mstr)
 )
 (if result
   (while (and loop mlst)
     (if (equal result (osnap pt (car mlst)))
(setq *GrOsnapMarker*
       (apply (read (car mlst))
	      (list (trans result 1 norm) scl norm)
       )
      loop nil
)
(setq mlst (cdr mlst))
     )
   )
 )
 result
)

;; lst2str
;; Concatène une liste et un séparateur en une chaine
;;
;; Arguments
;; lst : la liste à transformer en chaine
;; sep : le séparateur
;;
;; Exemples
;; (lst2str '(1 2 3) ",") -> "1,2,3"
;; (lst2str '("a" "b" "c") " ") -> "a b c"

(defun lst2str (lst sep)
 (if (cadr lst)
   (strcat (vl-princ-to-string (car lst))
    sep
    (lst2str (cdr lst) sep)
   )
   (vl-princ-to-string (car lst))
 )
)

;;; gc:GetBlock (gile) 03/11/07
;;; Retourne le nom du bloc entré ou choisi par l'utilisateur 
;;; dans une liste déroulante de la boite de dialogue ou depuis la boite
;;; de dialogue standard d'AutoCAD
;;; Argument : le titre (string) ou nil (défaut : "Choisir un bloc")

(defun gc:GetBlock (titre / bloc n lst tmp file status dcl_id nom)
 (while (setq bloc (tblnext "BLOCK" (not bloc)))
   (setq lst (cons (cdr (assoc 2 bloc)) lst)
   )
 )
 (setq	lst  (acad_strlsort
       (vl-remove-if
	 (function (lambda (n) (= (substr n 1 1) "*")))
	 lst
       )
     )
tmp  (vl-filename-mktemp "Tmp.dcl")
file (open tmp "w")
 )
 (write-line
   (strcat
     "getblock:dialog{label="
     (cond (titre (vl-prin1-to-string titre))
    ("\"Choisir un bloc\"")
     )
     ";initial_focus=\"bl\";:boxed_column{
     :row{:text{label=\"Sélectionner\";alignment=left;}
     :button{label=\">>\";key=\"sel\";alignment=right;fixed_width=true;}}
     spacer;
     :column{:button{label=\"Parcourir...\";key=\"wbl\";alignment=right;fixed_width=true;}}
     :column{:text{label=\"Nom :\";alignment=left;}}
     :edit_box{key=\"tp\";edit_width=25;}
     :popup_list{key=\"bl\";edit_width=25;}spacer;}
     spacer;
     ok_cancel;}"
   )
   file
 )
 (close file)
 (setq dcl_id (load_dialog tmp))
 (setq status 2)
 (while (>= status 2)
   (if	(not (new_dialog "getblock" dcl_id))
     (exit)
   )
   (start_list "bl")
   (mapcar 'add_list lst)
   (end_list)
   (if	(setq n	(vl-position
	  (strcase (getvar "INSNAME"))
	  (mapcar 'strcase lst)
	)
)
     (setq nom (nth n lst))
     (setq nom	(car lst)
    n	0
     )
   )
   (set_tile "bl" (itoa n))
   (action_tile "sel" "(done_dialog 5)")
   (action_tile "bl" "(setq nom (nth (atoi $value) lst))")
   (action_tile "wbl" "(done_dialog 3)")
   (action_tile "tp" "(setq nom $value) (done_dialog 4)")
   (action_tile
     "accept"
     "(setq nom (nth (atoi (get_tile \"bl\")) lst)) (done_dialog 1)"
   )
   (setq status (start_dialog))
   (cond
     ((= status 3)
      (if (setq nom (getfiled "Sélectionner un fichier" "" "dwg" 0))
 (setq status 1)
 (setq status 2)
      )
     )
     ((= status 4)
      (cond
 ((not (read nom))
  (setq status 2)
 )
 ((tblsearch "BLOCK" nom)
  (setq status 1)
 )
 ((findfile (setq nom (strcat nom ".dwg")))
  (setq status 1)
 )
 (T
  (alert (strcat "Le fichier \"" nom "\" est introuvable."))
  (setq	nom nil
	status 2
  )
 )
      )
     )
     ((= status 5)
      (if (and	(setq ent (car (entsel)))
	(= "INSERT" (cdr (assoc 0 (entget ent))))
   )
 (setq nom	 (cdr (assoc 2 (entget ent)))
       status 1
 )
 (setq status 2)
      )
     )
     ((= status 0)
      (setq nom nil)
     )
   )
 )
 (unload_dialog dcl_id)
 (vl-file-delete tmp)
 nom
)

[bryce]

Ouah ! :o

Ce n'est pas possible d'utiliser les accrochages standards avec grread, il faut s'amuser à dessiner les marqueurs soi-même ?! :exclam:

 

En tout cas ça fonctionne bien, sauf quand on utilise le bouton Parcourir pour insérer un bloc qui n'est pas défini dans le dessin.

Merci pour la démo !

 

Edit: à quoi correspond le code de retour 25 de grread ? La liste des codes dans l'aide s'arrête à 12... :casstet:

 

[Edité le 28/3/2011 par bryce]

[(gile)]

Ce n'est pas possible d'utiliser les accrochages standards avec grread, il faut s'amuser à dessiner les marqueurs soi-même ?!

Eh oui !... voir ce sujet

 

En tout cas ça fonctionne bien, sauf quand on utilise le bouton Parcourir pour insérer un bloc qui n'est pas défini dans le dessin.

Ah oui, je n'avais pas remarqué, je corrige.

 

à quoi correspond le code de retour 25 de grread ?

(car (grread)) égale 12 ou 25 pour un clic droit suivant la valeur de SHORTCUTMENU.

[bryce]

Merci ! :)

 

Je viens de bidouiller un peu avec ce code pour voir ce que retourne grread...

 

(while (setq gr (grread T 2 0))
(princ (strcat "\n" (itoa (car gr)) " "))
(princ (type (cadr gr)))
(if (= (car gr) 2)
	(princ (strcat " touche: "(itoa(cadr gr))))
)
)

 

... et je constate que certaines touches du clavier ne renvoient pas de valeur particulière (Suppr, les flèches, etc.).

On ne peut pas les détecter avec grread ?

 

[Tramber]

Coucou,

ah ouais, même question, j'avais essayé pour répondre rapidement à la demande mais j'ai dû me contenter de chiffres du pavé num....

?

 

vinc3nz0o, j'espère que ca ne devient pas trop compliqué !?

 

Pourrais-tu choisir un autre avatar (photo) que le mien ou aucun. Merci.

 

 

[Invité vinc3nz0o]

Heum pour moi qui n'ai que des base ca me parait compliquer!

 

Mais c'est justement le moment d'étudiez tout ça pas a pas =)

 

Pour l'avatar je le change de suite ( il a été mis automatiquement )

 

Merci pour tout !

[(gile)]

Salut,

 

Vous avez certainement raison, j'ai dû me laisser emporter.

Dans tous les cas, l'utilisation de la fonction grread n'est pas très simple et demande, à mon avis, quelques bases.

 

Donc, voici une version 'épurée' et un peu commentée de la routine donnée plus haut, elle n'appelle plus ni gc:GetBlock pour le choix du bloc, ni grosmode pour émuler les accrochages aux objets.

 

(defun c:ins (/ *error* insblk blk zdir pt ref ang gr loop)
 
 ;; redéfinition locale de *error*
 (defun *error* (msg)
   (and msg
 (/= msg "Fonction annulée")
 (princ (strcat "\nErreur: " msg))
   )
   (and ref (entdel ref) (setq ref nil))
   (princ)
 )

 ;; insertion du bloc (retourne le ENAME)
 (defun insblk	(bname ins ang zdir)
   (entmakex
     (list
'(0 . "INSERT")
(cons 2 bname)
(cons 10 ins)
(cons 50 ang)
(cons 210 zdir)
     )
   )
 )
 
 (if
   (and
     (setq blk (getstring "\nNom du bloc: "))
     (tblsearch "BLOCK" blk)
   )
    (progn
      (setq zdir (trans '(0. 0. 1.) 1 0 T)
     ang  (angle '(0. 0. 0.) (trans (getvar 'ucsxdir) 0 zdir))
     loop T
      )
      (while (and (setq gr (grread T 12 0)) loop)
 (cond
   ;; suppression et reinsertion du bloc quan le curseur se déplace
   ((= 5 (car gr))
    (and ref (entdel ref) (setq ref nil))
    (setq pt  (trans (cadr gr) 1 zdir)
	  ref (insblk blk pt ang zdir)
    )
   )
   ;; rotation du bloc (clic droit)
   ((member (car gr) '(12 25))
    (and ref (entdel ref) (setq ref nil))
    (setq ang (+ ang (/ pi 2)))
    (setq ref (insblk blk pt ang zdir))
   )
   ;; insertion du bloc et création d'un nouveu (clic gauche)
   ((= 3 (car gr))
    (setq ang (angle '(0. 0. 0.) (trans (getvar 'ucsxdir) 0 zdir))
	  ref (insblk blk pt ang zdir)
    )
   )
   ;; sortie de la boucle (Entrée ou Echap)
   ((or (equal gr '(2 13)) (equal gr '(2 32)))
    (setq loop nil)
   )
 )
      )
    )
    (princ (strcat "\nLe bloc '" blk "' est introuvable"))
 )
 (*error* nil)
)

[(gile)]

Ou encore, sans utiliser grread dans une boucle (plus 'débutant') :

 

(defun c:ins (/ blk zdir pt ref gr)
 (if (and
(setq blk (getstring "\nNom du bloc: "))
(tblsearch "BLOCK" blk)
     )
   (progn

     ;; insertion du bloc sous le curseur
     (setq pt (cadr (grread T 1))) ;_ point à la position du curseur
     (command "_.insert" blk pt)
     (while (/= 0 (getvar 'cmdactive)) (command ""))
     (setq ref (entlast))

     ;; rotation du bloc de 90° à chaque 'Espace',
     ;; clic droit ou gauche ou n'importe quelle autre touche pour valider
     (while (equal '(2 32) (grread nil 2))
(command "_.rotate" ref "" pt "90")
     )

     ;; déplacement du bloc
     (command "_.move" ref "" pt pause)
   )
   (princ (strcat "\nLe bloc '" blk "' est introuvable"))
 )
 (princ)
)

 

PS : si tu veux une boite de dialogue pour sélectionner le bloc, tu peux utiliser la routine gc:GetBlock en remplaçant :

  (if (and
(setq blk (getstring "\nNom du bloc: "))
(tblsearch "BLOCK" blk)
     )

par :

(if (setq blk (gc:GetBlock nil)) 

[Tramber]

Oui mais alors, (gile), et merci pour le rappel avec le cas d'un SCU quelconque (les TRANS), mais, quid de la question de bryce ?

 

J'ai déjà voulu utiliser les touches flèches en entrée clavier, sans succès.

[(gile)]

mais, quid de la question de bryce ?

 

J'ai déjà voulu utiliser les touches flèches en entrée clavier, sans succès.

 

Je ne me suis jamais penché sur la question, mais il semble bien que ces touches n'ont aucun effet sur grread...

[Patrick_35]

Salut

 

Je te propose une commande simple, à toi de développer autour.

 

(command "_.insert" "NOM_DU_BLOC" (getpoint) "1" "" (pause))

 

ps : pour le choix de l'angle, tu peux te mettre en mode ortho

 

Je ne me suis jamais penché sur la question, mais il semble bien que ces touches n'ont aucun effet sur grread...

Même réponse :(

 

@+

[Tramber]

Ok, erci messieurs.

[bonuscad]

Je ne me suis jamais penché sur la question, mais il semble bien que ces touches n'ont aucun effet sur grread...

 

Tant qu'elles n'affectent pas le curseur graphique.

Si tu utilise les touches Ctrl + flèche, tu obtiens les coordonnées de déplacement de ton curseur graphique en mode sans souris.

[Invité vinc3nz0o]

Merci pour vos réponse je me suis donc servi de la réponse de gile (le coup du clique droit qui tourne mon bloc ma séduit ^^ ) , je n'ai pas tout compris mais je pense avoir saisit les grandes lignes.

Je vais donc continuer a potasser tout ça.

Me reste une question sans doute bête : a quoi sert d'affecter T a certaine variable ?

 

Ensuite est il possible de créer une boite dcl qui afficherai un groupe de bloc(une sorte d'aperçu) ?

 

Et enfin existe t-il une routine permettant de compter les bloc d'un même nom ?

 

Donc pour recap l'utilité du programme que je souhaiterai créer ;

 

1-lancement de la fonction

2-boite dcl de sélection du bloc

3-insertion des blocs en série grâce a votre programme

4-quantitatif des différents blocs

 

Encore un fois merci pour votre aide.

 

Vincent :)

[Invité vinc3nz0o]

Se serait le T pour True ?

[bryce]

Bonjour,

 

Oui, en Lisp T équivaut à True dans d'autres langages, et nil à False (entre autres). :)

[Patrick_35]

Salut

 

2-boite dcl de sélection du bloc

Par exemple avec bibles

3-insertion des blocs en série grâce a votre programme

Fonction bins intégré au lisp

4-quantitatif des différents blocs

Lstatt sur ma page ou une recherche dans Cadxp

 

@+

[Invité vinc3nz0o]

Lstatt ! :) :) :) Gé-ni-al !

Bon la par contre je suis total dépasser c sur ^^

Ce serai possible de lui faire faire le décompte dans un seul calque ?

 

 

"Merciiii"(je pense que je devrai le mettre en signature) ^^

[Patrick_35]

Ce serai possible de lui faire faire le décompte dans un seul calque ?

Oui, en utilisant la commande '_filter

 

--> Lstatt

--> Ok

--> Choix des objets: '_filter

--> Choix du calque + Ajouter à la liste (vierge) + Appliquer

--> Application du filtre à la sélection.

--> >>Choix des objets: >>Spécifiez le coin opposé: nn trouvé(s)

--> >>Choix des objets:

--> Fermeture de la sélection filtrée.

 

ps : Les dernières versions se trouvent sur le lien dans ma signature

 

@+

 

[Edité le 1/4/2011 par Patrick_35]

[Invité vinc3nz0o]

Ok merci beaucoup !

 

Pour ce qui est de bible c'est "trop" poussé.

Je m'explique je voudrai vraiment que l'application soit simple c-à-d qu'en cliquant sur mon icône menu une boite dcl s'ouvre et propose directement les blocs contenue dans un fichier, ensuite clique sur le bloc choisi un autre clic sur ok et la le programme proposé par gile intervient pour insérer mon bloc.

 

Je pense que je vais me penchez sur les boite dcl a mes heures perdu pour essayer de faire ça, vous pensez que c'est possible pour le novice que je suis ? un petit tuto sur les boite dcl qui traine?