Un LISP pour forcer le LTSCALE d\'un facteur prédéfini

[brunomu]

Bonjour Forum !

 

Il m’arrive souvent de jouer sur l’échelle du type de ligne d’une entité AutoCad par-ci par-là.

Le problème, c’est que parfois, ça demande des tâtonnements et donc du temps de trouver le bon LTSCALE, surtout pour des types de lignes dont je ne me sers pas souvent (traits mixtes, DOTS,…)

 

Je me suis donc imaginé écrire un LISP qui permette, par exemple, de multiplier le LTSCALE d’un facteur 2 à chaque utilisation de la commande. Dans cette perspective, je devrai aussi en écrire un qui divise par 2.

 

Problème : je saurais bidouiller un LISP pour attribuer une valeur donnée à LTSCALE, mais ce qu’il me faudrait, c’est pouvoir récupérer la valeur actuelle du LTSCALE, avant de la multiplier ou de la diviser.

 

Et ça, je ne sais pas le faire.

 

Quelqu’un pourrait-il m’aider ?

(je suis prêt à affronter les réponses du genre : il ne faut jamais forcer les LTSCALE, mais bien définir les paramètres initiaux, etc…

Pour l’instant, dans l’environnement de travail qui est le mien, avec les compétences des gens d’un bout à l’autre de la chaîne de production de dessin, ça m’est difficile de faire autrement).

 

Merci !

 

 

PS : le rêve serait un truc du genre : je sélectionne une entité, et AutoCad me propose un curseur qui permet de faire varier le LTSCALE en temps réel, de 0,00001 à 10000, mais je rêve…

 

[Carboleum]

 

Hello,

 

Essayes ceci:

 

(setvar "ltscale" (* 2 (getvar "ltscale")))

 

 

[brunomu]

Merci pour ta réponse.

Malheureusement, ce n’est pas tout à fait ça.

En fait, je ne veux pas agir sur le LTSCALE du dessin tout entier, mais sur le LTSCALE d’une entité particulière…

 

 

[lili2006]

Bonjour à toutes et tous,

 

_zebulon à trouvé un truc pas mal,...Mais je n'ai pas le tp de retrouver le post,...

[(gile)]

Salut,

 

lili2006, si tu veux parler de ça, il ne s'agit pas de la même chose.

 

gloub,

 

Il faut agir sur le groupe DXF 48 de l'entité.

Si l'échelle de type de ligne est à 1.0 ce groupe peut-être absent, il faut donc l'ajouter.

 

Deux petites routines qui multiplie ou divise par 2 l'échelle de type de ligne.

Ces routines requièrent un nom d'entité comme argument.

(defun LtScaleX2 (ent / elst grp48)
 (if (setq grp48 (assoc 48 (setq elst (entget ent))))
   (entmod (subst (cons 48 (* 2 (cdr grp48))) grp48 elst))
   (entmod (append elst (list '(48 . 2.0))))
 )
)

(defun LtScale/2 (ent / elst grp48)
 (if (setq grp48 (assoc 48 (setq elst (entget ent))))
   (entmod (subst (cons 48 (/ (cdr grp48) 2)) grp48 elst))
   (entmod (append elst (list '(48 . 0.5))))
 )

 

Exemples pour tester :

(defun c:ltx2 (/ ent)
 (if (setq ent (car (entsel)))
   (LtScaleX2 ent)
 )
 (princ)
)

(defun c:lt/2 (/ ent)
 (if (setq ent (car (entsel)))
   (LtScale/2 ent)
 )
 (princ)
)

 

 

[lili2006]

Re,

 

si tu veux parler de ça

 

Oui !

 

il ne s'agit pas de la même chose.

 

En effet,... :cool:

[vincentp010]

Salut,

 

c'est pas un curseur, mais ça s'en rapproche:

 

(defun c:lts (/ ent ltScale loop query)
  (setvar "cmdecho" 0)
  (command "annuler" "m")
  (setq loop 1)

(setq ent (car (entsel "Choisissez une entitee:")))
(if (/= ent nil) (progn
 (setq ent (entget ent))
 (setq ltScale (assoc 48 ent))
 (if (= ltScale nil) (setq ltScale 1) (setq ltScale (cdr ltScale)))
 
 (while (= loop 1)
    (setq ltScale (getreal (strcat "Nouvelle echelle de ligne (Echelle courante = " (rtos ltScale 2) ") : ")))
    (if (= (assoc 48 ent) nil)
      (setq ent (append ent (list (cons 48 ltScale))))
      (setq ent (subst (cons 48 ltScale) (assoc 48 ent) ent))
    )
    (entmod ent)
    (command "redess")
    (initget 1 "Oui Yes No Non")
    (setq query (getkword "L'echelle vous convient elle [Oui/Non] ? "))
    (setq loop 
       (cond
         ((= query "Y") 0)
         ((= query "Yes") 0)
         ((= query "O") 0)
         ((= query "Oui") 0)
         ((= query "N") 1)
         ((= query "No") 1)
         ((= query "Non") 1)
       )
    )
 )

))

)

[brunomu]

Merci pour vos réponses.

 

@vincentp010 :

 

Ton LISP marche bien, mais je le trouve un peu lourd dans la pratique : il faut saisir au clavier chacune des valeurs qu'on veut tester.

 

J'imaginais plutôt (à défaut de curseur) une procédure où on choisit une entité, et où, par exemple, à chaque fois qu'on tape sur "ENTER", la valeur du LTSCALE (ou de ECHLTP) double.

 

Mais je ne saurais pas bidouiller ton LISP pour faire ça....

 

 

 

@gile :

 

Je n'arrive pas à faire marcher ta proposition (il me semble qu'il s'agit de morceaux d'un LISP qu'il faut compléter, mais je ne sais pas non plus le faire).

 

 

En tous cas, merci à tous les 2.

[vincentp010]

Un autre bout de code:

Entrée pour multiplier par 2

Retour pour diviser par 2

Espace pour quitter

 

(defun c:lts (/ ent ltScale loop code)
  (setvar "cmdecho" 0)
  (setq loop 1)

(setq ent (car (entsel "Choisissez une entitee:")))
(if (/= ent nil) (progn
 (setq ent (entget ent))
 (setq ltScale (assoc 48 ent))
 (if (= ltScale nil) (setq ltScale 1.0) (setq ltScale (cdr ltScale)))
 
 (while (= loop 1)
    (print (strcat "Echelle courante : " (rtos ltScale 2)))
    (print "Touche Entree pour x2 - Retour pour /2 - Espace pour quitter")
    (setq code (grread))
    (cond
       ((= (cadr code) 13) (setq ltScale (* ltScale 2)))
       ((= (cadr code) 8) (setq ltScale (/ ltScale 2)))
       ((= (cadr code) 32) (setq loop 0))
    )
    (if (/= loop 0) (progn
       (if (= ltScale 0) (setq ltScale 1.0))
       (if (= (assoc 48 ent) nil)
         (setq ent (append ent (list (cons 48 ltScale))))
         (setq ent (subst (cons 48 ltScale) (assoc 48 ent) ent))
       )
       (entmod ent)
       (command "redess")
    ))
 )

))

)

[brunomu]

Ça marche, c'est cool !

 

Bravo et merci pour ce coup de main !

 

(et le code me confirme que je n'aurais pas su faire ce genre de trucs tout seul).