Les caractères joker (wildcards) dans AutoCAD

Sélectionner d'un coup tous les objets dont le calque commence par MUR, n'afficher que les calques de cotation, ne garder que les blocs dont le nom finit par _2D… Ce genre de tâche revient sans cesse dans AutoCAD. Bonne nouvelle : nul besoin d'écrire du code pour cela. AutoCAD intègre un moteur de caractères joker (ou wildcards), proche des expressions régulières mais bien plus simple, disponible directement dans l'interface.

Dans cet article, nous partons de l'usage quotidien d'un utilisateur standard, puis nous montons progressivement en puissance jusqu'à l'usage développeur (AutoLISP et .NET). Le point important : c'est exactement le même moteur à tous les niveaux. Les motifs que vous apprenez à la souris se réutilisent tels quels dans vos scripts.

À quoi ressemble un motif ?

Un motif (ou filtre) est une chaîne où certains caractères ont un sens spécial. Les plus courants :

• * remplace n'importe quelle séquence de caractères (y compris vide) ;
• ? remplace un caractère quelconque ;
• # remplace un chiffre.

Ainsi MUR* désigne « tout ce qui commence par MUR », *_2D « tout ce qui finit par _2D », et PLAN-### « PLAN- suivi de trois chiffres ». Nous verrons la liste complète plus loin ; commençons par les mettre en pratique.

La sélection rapide (SELECTIONRAPIDE)

La sélection rapide (commande SELECTIONRAPIDE, anciennement QSELECT, aussi accessible par un clic droit dans le dessin) permet de sélectionner des objets selon leurs propriétés. Lorsqu'on filtre sur une propriété texte — le nom de calque, le nom de bloc, un texte… — l'opérateur Correspond au caractère générique (« Matches wildcard ») active les jokers.

Par exemple, pour sélectionner tous les objets posés sur un calque commençant par MUR :

1. lancez SELECTIONRAPIDE ;
2. dans Propriété, choisissez Calque ;
3. dans Opérateur, choisissez Correspond au caractère générique ;
4. dans Valeur, saisissez MUR* ;
5. validez : tous les objets concernés sont sélectionnés d'un seul coup.

Grâce à la virgule, on peut même viser plusieurs familles à la fois : MUR*,CLOISON*,POTEAU*.

La recherche dans le gestionnaire des calques

Le gestionnaire des propriétés des calques (commande CALQUE) possède, en haut à droite, une zone de recherche qui comprend les caractères joker. Tapez-y un motif pour n'afficher que les calques correspondants.

C'est parfait pour retrouver rapidement un calque dans un gabarit qui en compte des centaines.

Les filtres de calque par propriétés

Un cran au-dessus de la simple recherche : les filtres de calque par propriétés. Ils permettent de créer, dans le gestionnaire des calques, des groupes qui se remplissent automatiquement selon un motif. Tous les calques dont le nom correspond apparaissent dans le filtre, y compris ceux que vous créerez plus tard.

Ainsi, un filtre nommé « Cotation » basé sur COTATION* regroupera d'office COTATION, COTATION-TEXTE, COTATION_2D… Vous gérez alors la visibilité ou le verrouillage de tout le groupe d'un seul geste.

Le même principe (un champ acceptant les jokers) se retrouve dans beaucoup d'autres boîtes de dialogue : gestion des types de ligne, des styles, purge d'éléments nommés, etc.

La liste complète des caractères joker

Maintenant que le principe est clair, voici tous les caractères spéciaux reconnus par AutoCAD dans un motif :

Caractère	Signification
# (dièse)	Un seul chiffre
@ (arobase)	Un seul caractère alphabétique
. (point)	Un seul caractère non alphanumérique
* (astérisque)	N'importe quelle séquence de caractères (y compris vide), au début, au milieu ou à la fin
? (point d'interrogation)	Un seul caractère quelconque
~ (tilde)	En premier caractère du motif : correspond à tout sauf au motif
[...]	Un des caractères entre crochets
[~...]	Un caractère qui n'est pas entre crochets
- (trait d'union)	Dans des crochets : définit une plage de caractères
, (virgule)	Sépare deux motifs (un OU logique)
` (accent grave)	Échappe le caractère suivant (le prend au sens littéral)

Ces caractères fonctionnent partout : dans les champs de l'interface vus ci-dessus comme dans le code que nous abordons à présent.

Pour les développeurs : la fonction (wcmatch) en AutoLISP

Passons côté programmation. En AutoLISP, ce moteur est exposé par la fonction (wcmatch chaîne motif). Elle renvoie T si la chaîne correspond au motif, et nil sinon.

(wcmatch "PLAN-001" "PLAN*")        ; => T
(wcmatch "PLAN-001" "*001")         ; => T
(wcmatch "COUPE-002" "PLAN*")       ; => nil

C'est l'outil idéal pour tester une saisie utilisateur, filtrer une liste de noms, valider un code… Passons en revue chaque caractère.

* — n'importe quelle séquence

Le joker le plus utilisé. Il remplace zéro, un ou plusieurs caractères, à n'importe quelle position :

(wcmatch "MUR_EXT_01" "MUR*")       ; => T   (commence par MUR)
(wcmatch "MUR_EXT_01" "*01")        ; => T   (finit par 01)
(wcmatch "MUR_EXT_01" "*EXT*")      ; => T   (contient EXT)
(wcmatch "MUR" "MUR*")              ; => T   (la séquence peut être vide)

? — un caractère quelconque

Contrairement à *, le ? correspond à exactement un caractère :

(wcmatch "A1" "A?")                 ; => T
(wcmatch "A12" "A?")                ; => nil (deux caractères après A)
(wcmatch "COTE" "CO??")             ; => T

# — un chiffre

Le # n'accepte qu'un chiffre (0 à 9). Très pratique pour valider des codes numérotés :

(wcmatch "PLAN-007" "PLAN-###")     ; => T
(wcmatch "PLAN-XYZ" "PLAN-###")     ; => nil
(wcmatch "R12" "@##")               ; => T   (une lettre suivie de deux chiffres)

@ — une lettre

Le @ n'accepte qu'un caractère alphabétique. Combiné à #, il décrit des formats précis, comme une immatriculation ou une référence :

(wcmatch "A320" "@###")             ; => T
(wcmatch "2320" "@###")             ; => nil (commence par un chiffre)

. — un caractère non alphanumérique

Le point correspond à un caractère qui n'est ni une lettre ni un chiffre (espace, tiret, underscore, ponctuation…) :

(wcmatch "A-1" "@.#")               ; => T   (lettre, séparateur, chiffre)
(wcmatch "A_1" "@.#")               ; => T
(wcmatch "AB1" "@.#")               ; => nil (B est alphanumérique)

[...] — une liste de caractères

Les crochets définissent un jeu de caractères : la chaîne doit contenir, à cet emplacement, un des caractères listés :

(wcmatch "PLAN" "[PC]LAN")          ; => T   (P ou C)
(wcmatch "CLAN" "[PC]LAN")          ; => T
(wcmatch "VLAN" "[PC]LAN")          ; => nil

- — une plage dans les crochets

À l'intérieur des crochets, le trait d'union définit une plage :

(wcmatch "C" "[A-F]")               ; => T
(wcmatch "M" "[A-F]")               ; => nil
(wcmatch "PIECE-5" "PIECE-[0-9]")   ; => T
(wcmatch "REV_C" "REV_[A-Z]")       ; => T

[~...] — un caractère exclu

Un tilde en tête de crochets inverse le jeu : le caractère doit être différent de ceux listés :

(wcmatch "PLANB" "PLAN[~A]")        ; => T   (le dernier caractère n'est pas A)
(wcmatch "PLANA" "PLAN[~A]")        ; => nil
(wcmatch "X" "[~0-9]")              ; => T   (tout sauf un chiffre)

~ — la négation globale

Placé tout au début du motif, le tilde inverse le résultat complet : la chaîne correspond si elle ne correspond pas au reste du motif :

(wcmatch "COUPE-01" "~PLAN*")       ; => T   (ne commence pas par PLAN)
(wcmatch "PLAN-01" "~PLAN*")        ; => nil

, — plusieurs motifs (OU)

La virgule permet de tester plusieurs motifs d'un coup. La fonction renvoie T si au moins un d'entre eux correspond :

(wcmatch "COUPE-02" "PLAN*,COUPE*,DETAIL*")   ; => T
(wcmatch "FACADE" "PLAN*,COUPE*,DETAIL*")     ; => nil

C'est idéal pour filtrer sur une famille de préfixes.

` — échapper un caractère spécial

Que faire quand on veut chercher un caractère qui est lui-même un joker ? On l'échappe avec un accent grave (`). Le caractère qui suit est alors pris au sens littéral.

L'exemple classique est celui des blocs anonymes d'AutoCAD, dont le nom commence par * (comme *U2). Pour cibler exactement le bloc *U2 sans que l'astérisque ne soit interprété comme un joker :

(wcmatch "*U2" "`*U2")              ; => T
(wcmatch "XU2" "`*U2")              ; => nil (l'astérisque littéral est exigé)

De la même façon, pour chercher une chaîne contenant réellement un #, un ? ou une virgule, on préfixe chacun de ces caractères par `.

Les wildcards dans ssget

L'usage le plus fréquent de (wcmatch) est en réalité indirect : il est intégré aux filtres de sélection de ssget. Dans une liste de filtre, tout code DXF qui porte une valeur texte accepte directement les caractères joker : nom de calque (code 8), nom de bloc (code 2), type de ligne (code 6), etc.

Ici, pas besoin d'appeler (wcmatch) : AutoCAD applique le moteur automatiquement. C'est, en somme, la version scriptée de la sélection rapide vue plus haut.

Sélectionner tous les objets dont le calque commence par MUR :

(ssget "X" '((8 . "MUR*")))

Sélectionner sur plusieurs préfixes de calque à la fois grâce à la virgule :

(ssget "X" '((8 . "MUR*,CLOISON*,POTEAU*")))

Sélectionner toutes les références de bloc (INSERT) dont le nom finit par _2D :

(ssget "X" '((0 . "INSERT") (2 . "*_2D")))

Exclure un calque grâce au tilde (tous les objets sauf ceux du calque COTATION) :

(ssget "X" '((8 . "~COTATION")))

Le "X" demande à ssget de balayer toute la base de données du dessin. On peut aussi retirer le "X" pour combiner ces filtres avec une sélection interactive : on ne retient alors, parmi ce que l'utilisateur choisit, que les objets correspondant au motif.

L'équivalent .NET : WcMatchEx

Côté API .NET, le même moteur est exposé — mais dans un espace de noms interne, ce qui signale qu'il n'est pas officiellement supporté et pourrait évoluer. La signature est :

Autodesk.AutoCAD.Internal.Utils.WcMatchEx(string str, string pattern, bool ignoreCase);

Elle renvoie un bool et ajoute un argument bien utile : ignoreCase, pour comparer sans tenir compte de la casse.

using Autodesk.AutoCAD.Internal;

bool m1 = Utils.WcMatchEx("PLAN-007", "PLAN-###", ignoreCase: true);   // true
bool m2 = Utils.WcMatchEx("mur_ext", "MUR*", ignoreCase: true);        // true
bool m3 = Utils.WcMatchEx("mur_ext", "MUR*", ignoreCase: false);       // false

On peut par exemple s'en servir pour lister les calques d'un dessin qui correspondent à un motif :

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Internal;
using Autodesk.AutoCAD.Runtime;

[CommandMethod("LISTMURS")]
public void ListWallLayers()
{
    Document document = Application.DocumentManager.MdiActiveDocument;
    Database database = document.Database;
    Editor editor = document.Editor;

    const string PATTERN = "MUR*,CLOISON*";

    using (Transaction transaction = database.TransactionManager.StartTransaction())
    {
        LayerTable layerTable = (LayerTable)transaction.GetObject(database.LayerTableId, OpenMode.ForRead);

        foreach (ObjectId layerId in layerTable)
        {
            LayerTableRecord layer = (LayerTableRecord)transaction.GetObject(layerId, OpenMode.ForRead);
            if (Utils.WcMatchEx(layer.Name, PATTERN, ignoreCase: true))
                editor.WriteMessage("\n{0}", layer.Name);
        }

        transaction.Commit();
    }
}

Attention : WcMatchEx vit dans Autodesk.AutoCAD.Internal. Comme son nom l'indique, cette API est interne et n'est pas garantie d'une version à l'autre d'AutoCAD. Pour un filtrage de sélection, préférez les motifs directement dans les filtres ssget / SelectionFilter, qui restent la voie officielle. Réservez WcMatchEx aux cas où vous avez déjà la chaîne en main (nom de calque, nom de bloc, saisie utilisateur) et où vous voulez exactement la même sémantique de joker que le reste d'AutoCAD.

En résumé

Le moteur de caractères joker d'AutoCAD est un fil rouge qui relie l'usage quotidien et le développement :

• côté utilisateur, il est là dès la sélection rapide, la recherche de calques et les filtres de calque — aucun code requis ;
• côté développeur, on le retrouve à l'identique dans (wcmatch), dans les filtres ssget et dans WcMatchEx en .NET.

Les caractères clés : *, ?, #, @ et . couvrent l'essentiel ; [...], [~...] et - affinent lettre par lettre ; ~ et , composent des filtres complets ; et ` échappe les jokers eux-mêmes (pensez aux blocs anonymes *U…). Apprenez ces motifs une fois, réutilisez-les partout.

---

Besoin d'un développement AutoCAD (AutoLISP, ObjectARX, .NET, VBA) ? Contactez-moi pour un devis gratuit.