Renseigner un attribut dans de nombreux blocs

Du texte brut, rien de caché. Copiez-le dans un fichier nommé cxattfill.lsp ou téléchargez-le.

;;; ============================================================================
;;; CXATTFILL - Fill an attribute in many blocks
;;; Version 1.0.0
;;; CADXChange LISP tools - https://cadxchange.net/resources/lisp/cxattfill
;;; Tested in: AutoCAD (full version). Other programs that run AutoLISP may work but are not tested.
;;; Copyright (c) CADXChange. Free for personal and commercial use; do not resell or
;;; republish it as a collection. Terms: https://cadxchange.net/legal/lisp-terms
;;; ============================================================================

;; Set the attribute TAG to VALUE in every block reference in NAMES that has it.
;; ONLYEMPTY = T leaves attributes that already hold a value alone. Returns how many blocks were changed.
(defun cx:attfill-run (names tag value onlyempty / n a)
  (setq n 0)
  (foreach e names
    (if (setq a (cx:att-find e tag))
      (if (or (not onlyempty) (= (cx:trim (cx:dxf 1 (entget a))) ""))
        (progn
          (cx:att-set e tag value)
          (setq n (1+ n))))))
  n)

(defun c:CXATTFILL ( / *error* cx:sv ss names tags tag value only n)
  (setq *error* cx:err)
  (if (setq ss (cx:pick "\nSelect blocks with attributes: " '((0 . "INSERT") (66 . 1))))
    (progn
      (setq names (cx:ss->list ss)
            tags  (cx:tags names))
      (if (null tags)
        (princ "\nThe selected blocks have no attributes.")
        (progn
          (princ (strcat "\nAttributes in the selection: " (cx:join tags ", ")))
          (setq tag (cx:ask-str "Attribute tag" (car tags)))
          (if (not (member (strcase tag) (mapcar 'strcase tags)))
            (princ (strcat "\nNo selected block has an attribute named " tag "."))
            (progn
              (setq value (cx:ask-str "New value (- for empty)" "")
                    only  (= (cx:ask-kw "Only where the attribute is empty" "Yes No" "No") "Yes"))
              (cx:start '(("CMDECHO" . 0)))
              (setq n (cx:attfill-run names tag value only))
              (princ (strcat "\n" (itoa n) " block(s) changed."))
              (cx:end)))))))
  (princ))


;;; ---- Shared helpers (used by the command above; identical in every CADXChange tool) ----

(defun cx:dxf (code ed)
  (cdr (assoc code ed)))

;; The ATTRIB entities of a block reference, in order.
(defun cx:attribs (ins / e out)
  (setq e (entnext ins))
  (while (and e (= (cx:dxf 0 (entget e)) "ATTRIB"))
    (setq out (cons e out) e (entnext e)))
  (reverse out))

;; The ATTRIB of a block reference with the tag TAG (any case), or nil.
(defun cx:att-find (ins tag / r)
  (foreach a (cx:attribs ins)
    (if (and (not r) (= (strcase (cx:dxf 2 (entget a))) (strcase tag))) (setq r a)))
  r)

;; Remove spaces and tabs at both ends.
(defun cx:trim (s / a b)
  (setq a 1 b (strlen s))
  (while (and (<= a b) (member (substr s a 1) '(" " "\t"))) (setq a (1+ a)))
  (while (and (>= b a) (member (substr s b 1) '(" " "\t"))) (setq b (1- b)))
  (substr s a (max 0 (1+ (- b a)))))

;; Replace the text of a TEXT, ATTRIB, ATTDEF or MTEXT.
(defun cx:text-set (ename str / ed out)
  (setq ed (entget ename))
  (if (= (cx:dxf 0 ed) "MTEXT")
    (progn
      ;; MTEXT stores text in 250-character pieces: 3 groups for the first pieces, 1 for the last
      (foreach p ed (if (not (member (car p) '(1 3))) (setq out (cons p out))))
      (setq out (reverse out))
      (while (> (strlen str) 250)
        (setq out (append out (list (cons 3 (substr str 1 250)))) str (substr str 251)))
      (setq ed (append out (list (cons 1 str)))))
    (setq ed (subst (cons 1 str) (assoc 1 ed) ed)))
  (entmod ed)
  (entupd ename)
  T)

;; Set the attribute TAG of a block reference to VALUE; returns T when the block has that attribute.
(defun cx:att-set (ins tag value / a)
  (if (setq a (cx:att-find ins tag))
    (progn (cx:text-set a value) (entupd ins) T)))

;; Close the undo step and put the system variables back.
(defun cx:end ()
  (foreach v cx:sv (setvar (car v) (cdr v)))
  (command "_.UNDO" "_End")
  (setq cx:sv nil)
  (princ))

;; Error handler: restores everything, stays quiet on Esc.
(defun cx:err (msg)
  (if (> (getvar "CMDACTIVE") 0) (command))
  (cx:end)
  (if (and msg (not (wcmatch (strcase msg) "*BREAK*,*CANCEL*,*EXIT*")))
    (princ (strcat "\nError: " msg)))
  (princ))

;; Use the objects already selected, or ask the user to select; FILTER is an ssget filter list or nil.
(defun cx:pick (msg filter / ss)
  (setq ss (if filter (ssget "_I" filter) (ssget "_I")))
  (if (null ss)
    (progn
      (princ msg)
      (setq ss (if filter (ssget filter) (ssget)))))
  ss)

;; Selection set to a list of entity names.
(defun cx:ss->list (ss / i out)
  (setq i 0)
  (if ss
    (repeat (sslength ss)
      (setq out (cons (ssname ss i) out)
            i   (1+ i))))
  (reverse out))

;; The attribute tags found in a list of block references, each once, in order of appearance.
(defun cx:tags (names / out)
  (foreach e names
    (foreach a (cx:attribs e)
      (if (not (member (strcase (cx:dxf 2 (entget a))) (mapcar 'strcase out)))
        (setq out (append out (list (cx:dxf 2 (entget a))))))))
  out)

(defun cx:join (lst delim / out)
  (setq out "")
  (foreach s lst
    (setq out (if (= out "") s (strcat out delim s))))
  (if lst out ""))

;; Ask for a string (spaces allowed) with a default; "-" means an empty string.
(defun cx:ask-str (msg def / v)
  (setq v (getstring T (strcat "\n" msg " <" def ">: ")))
  (cond ((= v "") def) ((= v "-") "") (T v)))

;; Replace every OLD in STR by NEW (case sensitive).
(defun cx:replace (str old new / n out pos)
  (setq n (strlen old) out "" pos 1)
  (if (= n 0)
    str
    (progn
      (while (<= pos (1+ (- (strlen str) n)))
        (if (= (substr str pos n) old)
          (setq out (strcat out new) pos (+ pos n))
          (setq out (strcat out (substr str pos 1)) pos (1+ pos))))
      (strcat out (substr str pos)))))

;; Ask for one of the keywords in BITS ("Yes No"), default DEF; returns the keyword.
(defun cx:ask-kw (msg bits def / v)
  (initget 0 bits)
  (setq v (getkword (strcat "\n" msg " [" (cx:replace bits " " "/") "] <" def ">: ")))
  (if v v def))

;; Save the system variables in VARS ((name . value) ...), set them, and open one undo step.
;; The caller declares cx:sv as a local so the saved values live exactly as long as the command.
(defun cx:start (vars)
  (setq cx:sv (mapcar (function (lambda (v) (cons (car v) (getvar (car v))))) vars))
  (command "_.UNDO" "_Begin")
  (foreach v vars (setvar (car v) (cdr v)))
  (princ))

(princ "\nCXATTFILL loaded. Type CXATTFILL to start.")
(princ)

Autres commandes : Blocs et attributs

• CXATTNUMNuméroter un attribut de bloc à la suite
• CXATTCOPYCopier les valeurs d'attributs d'un bloc vers d'autres
• CXATTVISAfficher ou masquer les attributs de blocs
• CXBLKCOUNTCompter les blocs par nom
• CXBLKREPLRemplacer des blocs par un autre bloc
• CXBLKRENRenommer des blocs en série
• CXBLKXPÉclater des blocs en gardant le texte des attributs
• CXBLKSELSélectionner des blocs par nom ou par valeur d'attribut
• CXBLKATInsérer un bloc à de nombreux endroits d'un coup