Polyligne AutoCAD : fixer une largeur via palette d’outils sans changer la largeur globale (PLINEWID)

Tout est parti d’une question simple sur le forum Autodesk : “Je veux des polylignes avec largeur, via une palette, sans modifier la largeur globale des polylignes.”

Et comme souvent, le cerveau d’un utilisateur part trop vite sur une fausse solution : “Ok… je vais faire 50 boutons / 50 macros, une par largeur.”
Ça “fonctionne”… jusqu’au jour où tu dois maintenir, adapter, versionner, ou juste expliquer à quelqu’un d’autre.

Le vrai sujet n’est pas la polyligne.
Le vrai sujet, c’est : comment tu encapsules un paramètre sans polluer l’environnement utilisateur.

Le piège : confondre macro et automatisation

Une macro “en dur” dans une palette, c’est une interface figée :

• tu dupliques la logique (50 fois)
• tu crées une dette (maintenance, cohérence, mises à jour)
• tu rends l’évolution dangereuse (tu touches un bouton, tu casses un autre)

Une automatisation propre, c’est l’inverse :

• 1 commande
• N paramètres
• une interface (palette) qui ne fait que déclencher la logique

La contrainte AutoCAD : PLINEWID est global

PLINEWID est une variable système qui stocke la largeur par défaut des nouvelles polylignes. Elle est enregistrée dans le dessin.

Donc si tu la modifies “à la volée” sans la restaurer, tu changes le comportement futur du dessin. C’est exactement le type d’effet de bord qui rend une palette “magique”… jusqu’au jour où tout devient incohérent.

La solution Autodesk : principe officiel

Le principe est simple (et officiellement recommandé) :

1. sauvegarder PLINEWID
2. appliquer temporairement la largeur voulue
3. lancer PLINE en interactif
4. attendre la fin de commande
5. restaurer PLINEWID

Implémentation AutoLISP : version pédagogique

Voici une version claire et lisible, parfaite pour comprendre le mécanisme (sauvegarde → largeur temporaire → commande interactive → restauration) :

;;; Source Autodesk :
;;; https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Drawing-polyline-of-
specified-width-without-changing-global-PLINEWID-value.html
;;;
;;; Principe générique Autodesk :
;;; ^C^C
;;; (setq pwid (getvar "plinewid"))
;;; (setvar "plinewid" <largeur_souhaitee>)
;;; _pline
;;; (while (> (getvar "cmdactive") 0) (command pause))
;;; (setvar "plinewid" pwid)
;;;
;;; ------------------------------------------------------------------------
;;; Commande : EDPS_POLYLIGNE
;;;
;;; Objectif :
;;;   Dessiner une polyligne avec une largeur spécifique
;;;   sans modifier durablement la variable système PLINEWID.
;;;
;;; Principe de fonctionnement :
;;;   - Sauvegarder la valeur courante de la variable système PLINEWID
;;;   - Appliquer temporairement une largeur définie par l’utilisateur
;;;   - Lancer la commande PLINE en mode interactif
;;;   - Attendre la fin complète de la commande utilisateur
;;;   - Restaurer la valeur initiale de PLINEWID
;;;
;;; Avantage :
;;;   - Aucun effet de bord sur les futures polylignes
;;;   - Respect de l’environnement utilisateur
;;; ------------------------------------------------------------------------

(defun c:edps_polyligne (/ pwid Epaisseur)

  ;;; Sauvegarde de la largeur globale actuelle des polylignes
  ;;; PLINEWID est une variable système AutoCAD (largeur par défaut)
  (setq pwid (getvar "plinewid"))

  ;;; Demande à l’utilisateur de saisir l’épaisseur souhaitée
  ;;; La valeur est exprimée dans l’unité du dessin courant
  (setq Epaisseur (getreal "\nChoisissez l'épaisseur de la polyligne : "))

  ;;; Application temporaire de la largeur saisie
  (setvar "plinewid" Epaisseur)

  ;;; Lancement de la commande PLINE
  ;;; Utilisation du préfixe "_" pour garantir l’internationalisation
  (command "_.pline")

  ;;; Boucle d’attente :
  ;;; Tant qu’une commande est active (cmdactive > 0),
  ;;; AutoCAD attend les entrées utilisateur (clics, Entrée, ESC, etc.)
  (while (> (getvar "cmdactive") 0)
    (command pause)
  )

  ;;; Restauration de la largeur initiale des polylignes
  ;;; Garantit l’absence d’impact sur les commandes PLINE ultérieures
  (setvar "plinewid" pwid)

  ;;; Fin silencieuse de la commande
  (princ)
)

Aller plus loin : vers un code réellement robuste

Le code présenté ici illustre un principe fondamental : encapsuler une modification temporaire d’une variable système, exécuter une commande interactive, puis restaurer l’état initial.

Dans un contexte réel (outil partagé, déploiement en entreprise, automatisation réutilisable), ce principe peut – et doit – être renforcé.

Parmi les pistes d’amélioration courantes :

• garantir la restauration de PLINEWID même en cas d’annulation utilisateur (ESC) ou d’erreur inattendue
• sécuriser la saisie utilisateur (valeurs nulles, négatives ou incohérentes)
• permettre un appel non interactif (paramètre passé depuis une macro ou une palette)
• centraliser la logique dans une fonction générique réutilisable
• gérer la coexistence avec d’autres commandes ou scripts exécutés en parallèle

L’objectif n’est pas de produire le code parfait, mais de poser une architecture saine : une commande stable, indépendante de l’interface qui l’appelle.

C’est précisément ce découplage qui permet d’étendre le comportement sans casser l’existant : ajouter des options, changer une règle métier, ou adapter l’outil à d’autres contextes (calques, styles, blocs, textes…).

Autrement dit : la macro est un déclencheur. La commande AutoLISP est le socle.

Palette d’outils : oui, “magique”… mais garde sa place

La palette peut créer des calques, appliquer des propriétés, donner l’impression d’un outil “intelligent”.

Mais ne lui confie pas la logique : la palette doit appeler une commande, pas porter l’algorithme.

Quand tu te surprends à créer 50 variantes, tu es en train de masquer un besoin de paramétrage.
Tu n’as pas besoin de 50 outils. Tu as besoin d’1 commande stable + une interface qui passe des paramètres.

Exemples de boutons (macros) qui appellent une seule commande avec un paramètre :

^C^CEDPS_POLYLIGNE;Largeur
^C^CEDPS_POLYLIGNE;10
^C^CEDPS_POLYLIGNE;30

Exemple d’outil créé dans une palette d’outils

Ce qu’il faut retenir : la palette ne doit pas porter la norme

• Le calque est explicitement défini (ex. Cable Info) : c’est lui qui garantit la cohérence graphique.
• Toutes les autres propriétés restent sur “utiliser la valeur courante” (couleur, type de ligne, épaisseur, transparence, styles…).

Ce choix est délibéré :

• Changer un calque (couleur, type de ligne, épaisseur) met à jour instantanément tous les outils qui l’utilisent.
• Changer 50 outils qui forcent chacun leurs propriétés est long, fragile et source d’erreurs.

Le calque porte la norme. L’outil ne doit pas répliquer la norme.

Quand forcer des propriétés dans l’outil ?

• Quand tu veux déroger volontairement au standard (cas métier spécifique).
• Dans des scénarios d’import / reprise où tu dois imposer temporairement un rendu.
• Pour des outils très spécialisés ou “jetables” (POC, scripts ponctuels).

Dans la majorité des cas, laisser “utiliser la valeur courante” rend la palette plus rapide à maintenir : tu standardises via les calques, pas via 50 définitions d’outils.

Ce cas est un excellent prétexte pour passer de “macro” à “outil”, et poser une base réutilisable pour d’autres commandes paramétrables (calques, textes, styles, blocs…).

---

FAQ

Pourquoi éviter de modifier PLINEWID dans une macro ?
Parce que PLINEWID change la largeur par défaut des futures polylignes dans le dessin. Si tu ne la restaures pas, tu introduis un effet de bord.

Comment fixer une largeur de polyligne sans toucher aux réglages globaux ?
En sauvegardant la valeur de PLINEWID, en la modifiant temporairement, puis en la restaurant après la commande PLINE.

La palette d’outils peut-elle gérer ça sans AutoLISP ?
Elle peut lancer des commandes, mais si tu veux un comportement propre et maintenable (paramètre + restauration), AutoLISP est le bon niveau d’abstraction.