Les dictionnaires

[(gile)]

Généralités

 

Les dictionnaires fournissent un moyen de lier des données au dessin ou à des objets de la base de donnée (entités graphiques ou objets non-graphiques).

Ils peuvent contenir des données arbitraires et des objets non graphiques. De plus, contrairement aux objets Xdata, leur taille n'est pas limitée.

Les données dans un dictionnaire sont stockées dans des objets Xrecord.

Chaque dictionnaire peut contenir d'autres dictionnaires ainsi que plusieurs entrées Xrecord.

Les dictionnaires se répartissent en deux types : les dictionnaires nommés et les dictionnaires d'extension.

 

Les dictionnaires nommés

Tout fichier DWG possède un "dictionnaire des objets nommés" Named Object Dictionary (NOD) qui est la racine de tous les dictionnaires nommés. AutoCAD (et plus encore les applications verticales) utilise ces dictionnaires pour stocker des données et des objets non graphiques (présentations, groupes, styles de multiligne, styles visuels, etc.).

Chaque dictionnaire peut être considéré comme une entrée de son dictionnaire parent que ce soit le NOD ou un autre dictionnaire où son nom sert de clé pour le retrouver.

 

Les dictionnaires d'extension

Tout objet AutoCAD, graphique ou non, peut avoir un et un seul dictionnaire d'extension. Les dictionnaires d'extension n'ont pas de nom, c'est l'objet auquel ils sont lié qui sert de clé pour les retrouver.

On retrouve le nom d'entité d'un dictionnaire d'extension dans la liste de données DXF de l'objet auquel il appartient, c'est la donnée du groupe 360 suivant le groupe (102 . "{ACAD_XDICTIONARY"). AutoCAD utilise aussi les dictionnaires d'extension, comme dans l'exemple ci-dessous, pour les objets annotatifs.

((-1 . <Nom d'entité: 7ffff706280>)
(0 . "TEXT") 
(5 . "1D78") 
(102 . "{ACAD_XDICTIONARY") 
(360 . <Nom d'entité: 7ffff706290>) ; dictionnaire d'extension
(102 . "}") 
(330 . <Nom d'entité: 7ffff7039f0>) 
(100 . "AcDbEntity") 
...)

 

 

Les objets XRecord

Ce sont les conteneurs dans les quels sont stockées les données. Ce sont aussi des entrées nommées dans le dictionnaire parent, et là encore, leur nom qui sert de clé pour les retrouver dans l'arborescence.

En LISP, les données dans un XRecord apparaissent sous forme de liste d'association dont les paires pointées utilisent les mêmes codes de groupe que les données DXF.

 

Ce système offre une très grande souplesse et sa structure en arborescence avec un système de clés permet un accès très rapide aux données.

En résumé, chaque dictionnaire (d'extension ou nommé) peut avoir plusieurs entrées de type Dictionary ou XRecord et chaque XRecord contenir plusieurs données.

 

Les fonctions AutoLISP dédiées

AutoLISP fournit des fonctions qui permettent d'accéder à ces dictionnaires et à leurs données, mais aussi d'en créer de nouveaux.

 

namedobjdict

Ne requiert aucun argument et retourne le nom d'entité du NOD du dessin courant.

 

dictadd (dictadd dictkey entry)

Ajoute une entrée de type Dictionary ou Xrecord à un dictionnaire.

dict : le nom d'entité du dictionnaire auquel est ajouté l'objet.

key : le nom de l'entée du nouvel objet, ce nom doit être unique.

entry : le nom d'entité de l'objet ajouté.

 

;; Créer un objet dictionnaire
(setq xname (entmakex '((0 . "DICTIONARY") (100 . "AcDbDictionary"))))

;; Ajouter le dictonnaire au dictionnaire des objets nommés
(dictadd (namedobjdict) "MON_SUPER_DICO" xname)

;; créer un objet XRECORD avec des données
(setq xrec (entmakex '((0 . "XRECORD")
	       (100 . "AcDbXrecord")
	       (1 . "Ceci est un test")
	       (40 . 3.14159)
	      )
   )
)

;; ajouter l'objet XRecord au dictionnaire
(dictadd xname "SUPER_DATA_1" xrec)

 

 

dictsearch (dictsearch dict key [setnext])

Cherche l'entrée spécifiée dans le dictionnaire, et retourne sa liste DXF s'il existe (sinon nil).

dict : le nom d'entité du dictionnaire

key : le nom de l'entrée

setnext : (optionnel) si spécifié et non nil, initialise dictnext avec cette entrée.

 

;; retrouver le dictionnaire
(setq dict  (dictsearch (namedobjdict) "MON_SUPER_DICO"))

;; retrouver les données
(setq data (dictsearch (cdr (assoc -1 dict)) "SUPER_DATA_1"))

 

 

(cdr (assoc 1 data))

 

retourne : "Ceci est un test"

 

(cdr (assoc 40 data))

 

retourne : 3.14159

 

dictnext (dictnext dict[first])

Retourne la liste DXF de l'entrée suivante du dictionnaire si elle existe, sinon nil.

dict : le nom d'entité du dictionnaire propriétaire.

Si l'argument first est spécifié et non nil, dictnext retourne la première entrée.

 

Ajoutons une nouvelle entrée XRecord à notre dictionnaire.

 

(setq xname (cdr (assoc -1 (dictsearch (namedobjdict) "MON_SUPER_DICO")))
     xrec  (entmakex '((0 . "XRECORD")
	           (100 . "AcDbXrecord")
	           (70 . 256)
	          )
     )
)
(dictadd xname "SUPER_DATA_2" xrec)

 

 

(cdr (member '(280 . 1) (dictnext xname T)))

 

retourne : ((70 . 256))

 

(cdr (member '(280 . 1) (dictnext xname)))

 

retourne : ((1 . "Ceci est un test") (40 . 3.14159))

 

dictrmove (dictremove dict key)

Supprime l'entrée key du dictionnaire et retourne le nom d'entité de l'objet supprimé ou nil si un des arguments n'est pas valide.

dict : nom d'entité du dictionnaire parent

key : nom de la clé de lentrée à supprimer

 

dictrename (dictrename dict oldKey newKey)

Renomme une entrée d'un dictionnaire. Si tous les arguments sont valides, l'entrée oldKey est renommée newKey,et newKey est retourné, sinon nil est retourné.

dict : nom d'entité du dictionnaire parent

oldKey : clé à renommer

newKey : nouvelle clé pour l'entrée

 

Avec les dictionnaires d'extension

Comme vu ci-dessus, on retrouve le dictionnaire d'extension d'un objet en interrogeant sa liste de données DXF et on ajoute un dictionnaire d'extension à un objet en modifiant sa liste de données DXF avec entmod :

Deux petites routines pour illustrer ça (une petite bibliothèque de routines : Dictionaries.lsp au bas de cette page) :

 

;; gc:GetExtDict (gile)
;; Retourne le dictionnaire d'extension de l'entité (ou nil)
;;
;; Argument : ent (ENAME)

(defun gc:GetExtDict (ent)
 (cdadr (member '(102 . "{ACAD_XDICTIONARY") (entget ent)))
)

;; gc:GetOrCreateExtDict (gile)
;; Retourne le dictionnaire d'extension de l'entité
;; Le dictionnaire est créé s'il n'existe pas
;;
;; Argument : ent (ENAME)

(defun gc:GetOrCreateExtDict (ent / dict)
 (cond
   ((cdadr (member '(102 . "{ACAD_XDICTIONARY") (entget ent))))
   ((setq dict	(entmakex
	  '((0 . "DICTIONARY") (100 . "AcDbDictionary"))
	)
    )
    (entmod
      (vl-list*
        (assoc -1 elst)
        (assoc 0 elst)
        (assoc 5 elst)
        (cons 102 "{ACAD_XDICTIONARY")
        (cons 360 dict)
        (cons 102 "}")
        (vl-remove-if (function (lambda (x) (member (car x) '(-1 0 5)))) elst)
      )
    )
    dict
   )
 )
)

 

 

 

Pour clore cette première partie, une autre petite routine pour lister toutes les entrées dans un dictionnaire :

 

;; gc:GetDictEntries
;; Retourne la liste des entrées du dictionnaire
;; sous forme de paires pointées (key . ename)
;;
;; Argument : dict le dictionnaire (ENAME ou liste DXF)

(defun gc:GetDictEntries (dict / result)
 (and (= (type dict) 'ENAME) (setq dict (entget dict)))
 (while
   (setq dict (vl-member-if (function (lambda (x) (= (car x) 3))) (cdr dict)))
    (setq result (cons (cons (cdar dict) (cdadr dict)) result))
 )
 (reverse result)
)

 

 

Exemple d'utilisation :

(gc:GetDictEntries (dictsearch (namedobjdict) "ACAD_LAYOUT"))

 

 

À suivre...

[bryce]

Très intéressant, merci beaucoup !

 

Par contre je n'ai pas vraiment compris le rôle de la paire (280 . 1) dans la liste DXF d'une entrée de dictionnaire... :huh:

A priori tu considères que les données sont forcément après cette paire, mais peut-on être sûr qu'elle existe toujours, et qu'elle aura toujours cette valeur ?

 

L'aide indique pour le code 280 :

Drapeau de propriétés matérielles. S'il a pour valeur 1, indique que les éléments du dictionnaire doivent être traités comme des propriétés matérielles

Tu saurais traduire ? :unsure:

Ça voudrait dire que si ce code existe et qu'il a pour valeur 1, tout ce qui suit dans la liste doit être considéré comme des données stockées dans l'entrée ?

[(gile)]

C'est exactement ça (si l'entrée est de type Xrecord).

Essaye de créer un dictionnaire et un ou deux Xrecord (en utilisant les codes donnés si tu veux) et fait un dictnext sur ce dictionnaire, tu verras la liste DXF complète.

[(gile)]

Les données LISP ou ldata

 

Avec Visual LISP ce nouveau type de dictionnaire a été implémenté.

On a reproché et on reproche encore deux choses aux ldata.

La première était un problème de compatibilité entre les différentes version d'AutoCAD, mais ce défaut de jeunesse semble complètement corrigé depuis la version 2002.

La seconde est que les ldatas ne sont accessibles qu'en LISP (et ObjectARX/C++ bien sûr), contrairement aux dictionnaires classiques et aux Xrecords qui sont accessibles pour tous les langages de programmation supportés par AutoCAD.

 

Le principal avantage des ldatas par rapport aux dictionnaires classiques est leur plus grande facilité de mise en œuvre.

Comme les dictionnaires classiques, les ldatas peuvent être nommées ou attachées à une entité AutoCAD.

Une donnée LISP correspond à une paire clé/donnée où la clé est une chaîne et la donnée peut être tout type d'expression LISP.

 

Là encore, des fonctions sont fournies pour attribuer, retrouver, supprimer ces ldatas.

 

vlax-ldata-put (vlax-ldata-put dict key data [private])

Stocke une donnée LISP dans un dictionnaire ou une entité. Le dictionnaire est créé s'il n'existe pas.

Retourne la valeur de data ou nil.

dict : une entité AutoCAD (ename ou vla-object) ou un nom (clé primaire)

key : la clé (secondaire) pour récupérer la donnée.

data : tout type de donnée LISP

private : (optionnel) si vlax-ldata-put est exécuté depuis un VLX dans un espace de nom séparé et que cet argument est spécifié et non nil, la donnée ne sera récupérable que par ce VLX.

 

;; créer une donnée LISP
(vlax-ldata-put "VL_DICO" "data1" "test")
(vlax-ldata-put "VL_DICO" "data2" '(1 2 3))

 

vlax-ldata-get (vlax-ldata-get dict key [default-data] [private])

Récupère une donnée LISP dans un dictionnaire ou une entité.

Retourne la donnée si elle est existe sinon la valeur de default-data si elle a été spécifiée, sinon nil.

dict : une entité AutoCAD (ename ou vla-object) ou un nom (clé primaire)

key : la clé (secondaire) pour récupérer la donnée.

default-data : (optionnel) la donnée à retourner si la clé n'est pas trouvée

private : (optionnel, default-data doit être spécifié) si vlax-ldata-get est exécuté depuis un VLX dans un espace de nom séparé et que cet argument est spécifié et non nil, vlax-ldata-get récupère la donnée.

 

(vlax-ldata-get "VL_DICO" "data1")

retourne "test"

(vlax-ldata-get "VL_DICO" "data2")

retourne (1 2 3)

 

vlax-ldata-list (vlax-ldata-list dict [private])

Liste les données LISP pour le dictionnaire ou l'entité.

Retourne une liste paire pointées (key . data) pour toutes les entrées.

dict : une entité AutoCAD (ename ou vla-object) ou un nom

private : (optionnel) si vlax-ldata-list est exécuté depuis un VLX dans un espace de nom séparé et que cet argument est spécifié et non nil, vlax-ldata-list ne récupère que les données de cet espace de nom.

 

(vlax-ldata-list "VL_DICO")

retourne (("data2" 1 2 3) ("data1" . "test"))

 

vlax-ldata-delete (vlax-ldata-delete dict key [private])

Supprime une donnée LISP dans un dictionnaire.

Retourne T si l'opération a réussi, sinon nil.

dict : une entité AutoCAD (ename ou vla-object) ou un nom (clé primaire)

key : la clé (secondaire) pour récupérer la donnée.

data : n'importe quelle donnée LISP (y compris une liste)

private : (optionnel) si vlax-ldata-delete est exécuté depuis un VLX dans un espace de nom séparé et que cet argument est spécifié et non nil, la donnée sera supprimée.

 

(vlax-ldata-delete "VL_DICO" "data1")

retourne T

(vlax-ldata-get "VL_DICO" "data1")

retourne nil

[(gile)]

On trouvera ici, un outil écrit en C# qui permet de visualiser et de modifier les dictionnaires.

[(gile)]

Aller encore plus loin avec les ldatas

 

La fonctionnalité décrite ici est issue d'un procédé montré par Luis Esquivel (LE) sur TheSwamp.

 

Le propos est de lier un VLX avec un dessin de façon à ce qu'il se charge automatiquement à chaque ouverture de ce dessin. Comportement que l'utilisation des ldatas permet de faire assez facilement.

 

Il suffit de définir une ldata dans le fichier LISP avec l'argument private à T (la donnée peut être nil). Puis de compiler le LISP en un VLX en cochant l'option "Espace de nom différent".

Ensuite, charger le VLX dans un fichier et enregistrer ce fichier dans le même répertoire que le VLX.

À chaque ouverture du dessin, si le VLX est bien dans le même répertoire, il sera automatiquement chargé.

 

Petit exemple avec un LISP inoffensif.

 

Le code du LISP

(vl-load-com)

(vlax-ldata-put "SelfLoadDict" "test" nil T)

(alert "La commande 'Hello' est chargée.")

(defun c:hello ()
 (alert "Salut le monde")
 (princ)
)

 

Extraire le fichier SelfLoad.vlx (compilation du LISP ci dessus dans un espace de nom séparé) du ZIP.

Ouvrir un nouveau dessin.

Charger le VLX.

Enregistrer le dessin dans le même répertoire que le VLX et le fermer.

Ré ouvrir le dessin, le VLX est automatiquement chargé.

SelfLoad.zip

[Tramber]

Magnifique résumé francophone ! (comme d'hab.)

En plus c'est déjà épinglé :)

 

Toutes ces possibilités d'attacher à un dessin ou à ses objets des données sont bien passées en revue on dirait.(et j'encourage l'usage d'XDEDIT.)

 

Pardonne la question qui n'est pas forcement la suite ou l'extension de ce sujet mais, si l'on veut attacher des données cette fois-ci à un profil AutoCAD, un menu (?) ou encore un profil Windows, alors là on passe par les registres ? Et ca devient un autre sujet ou il reste des possibilités type dictionnaire ?

 

J'espère qu'il n'y a pas de question idiote... puisque on ne parlerait plus de dessin DWG proprement dit ;)

[azer]

bonjour

je suis un primate.

[(gile)]

bonjour

je suis un primate.

 

???

[Invité Patrick]

bonjour

je suis un primate.

 

Un primaire? Un débutant? :unsure:

Bienvenue quand même! :huh:

[azer]

je n est pas atteins votre stade évolution.

[(gile)]

je n est pas atteins votre stade évolution.

 

Il ne tiens qu'à toi.

Mais commence par faire un effort avec l'orthographe. À mon sens, on peut pas envisager d'écrire du code si on n'est pas extrêmement rigoureux à ce niveau.

[VDH-Bruno]

+1 (à voté) :D

(gile)merci pour les explications, grâce à toi ce soir j’ai comblé des lacunes :)

[sbosarl]

boujour,

merci "gile" pour ces renseignements ,dans ton post #5 tu te réfère à une cde (en c++)

windows :charger et renommer en DictionaryEditor.dll

autocad 2012 je l'ai charger en netload et la : mesage d'erreur

Impossible de charger l'assemblage. Détails de l'erreur: 
System.BadImageFormatException: Impossible de charger le fichier ou l'assembly 
'file:///C:\plansl\stok-zip-plt\DictionaryEditor.dll' ou une de ses 
dépendances. Le module était censé contenir un manifeste de l'assembly.
Nom de fichier : 'file:///C:\plansl\stok-zip-plt\DictionaryEditor.dll'
  à System.Reflection.RuntimeAssembly._nLoad(AssemblyName fileName, String 
codeBase, Evidence assemblySecurity, RuntimeAssembly locationHint, 
StackCrawlMark& stackMark, Boolean throwOnFileNotFound, Boolean 
forIntrospection, Boolean suppressSecurityChecks)
  à System.Reflection.RuntimeAssembly.nLoad(AssemblyName fileName, String 
codeBase, Evidence assemblySecurity, RuntimeAssembly locationHint, 
StackCrawlMark& stackMark, Boolean throwOnFileNotFound, Boolean 
forIntrospection, Boolean suppressSecurityChecks)
  à System.Reflection.RuntimeAssembly.InternalLoadAssemblyName(AssemblyName 
assemblyRef, Evidence assemblySecurity, StackCrawlMark& stackMark, Boolean 
forIntrospection, Boolean suppressSecurityChecks)
  à System.Reflection.RuntimeAssembly.InternalLoadFrom(String assemblyFile, 
Evidence securityEvidence, Byte[] hashValue, AssemblyHashAlgorithm 
hashAlgorithm, Boolean forIntrospection, Boolean suppressSecurityChecks, 
StackCrawlMark& stackMark)
  à System.Reflection.Assembly.LoadFrom(String assemblyFile)
  à Autodesk.AutoCAD.Runtime.ExtensionLoader.Load(String fileName)
  à loadmgd()

AVT : la journalisation de liaison d'assembly est désactivée.
Pour activer la journalisation des échecs de liaison d'assembly, attribuez la 
valeur 1 à la valeur de Registre [HKLM\Software\Microsoft\Fusion!EnableLog] 
(DWORD).
Remarque : une certaine perte de performance est associée à l'enregistrement 
dans le journal des échecs de liaison d'assembly.
Pour désactiver cette fonctionnalité, supprimez la valeur de Registre 
[HKLM\Software\Microsoft\Fusion!EnableLog]

J'ai recherché sur le registe sans rien trouvé , serait il possible de savoir ce que je n'est pas fait correctement.

[(gile)]

Salut,

 

charger et renommer en DictionaryEditor.dll

 

Il faut extraire le fichier DictionaryEditor.dll qui est dans le fichier DictionaryEditor.zip.

Comme dit dans le sujet en lien, si tu as des problèmes avec l'explorateur Windows pour extraire le fichier utilise 7zip.

 

PS : c'est écrit en C#, pas C++.

[sbosarl]

bonjour,

pour info j'ai télécharger le zip , puis je l'ai extrait du fichier zip , puis renommer en dll,

ouvert autocad sur les "cde" taper "netload" , suivant même "cde" netload j'ai ouvert le fichier sur la racine C:\plansl\stok-zip-plt\DictionaryEditor.dll .

(répertoire stok-zip-plt qui me sert de zone d'essai ou de transfere )

j'ai même copie le fichier DictionaryEditor.dll dans un répertoire lu par défaut dans les options (C:\Program Files\Autodesk\AutoCAD 2012 – French\)

et relance netload avec comme chemin C:\Program Files\Autodesk\AutoCAD 2012 – French\ DictionaryEditor.dll

 

et la même message d'erreur avec autre chemin . Bon t'en pis je doit avoir un fichier manquant ou une limitation sur se poste

merci quand même

[(gile)]

renommer en dll

C'est ça que je ne comprends pas.

Le ZIP contient la DLL (DictionaryEditor.dll) et un dossier "en" qui sert uniquement pour avoir l'interface en anglais sur un Windows anglais.

Il n'y a rien à renommer.

[sbosarl]

vu avec gile en direct :

probleme de dezipper sur mon pc

[Bortch59]

Bonjour,

 

est t'on obligé de passer par un objet Xrecord pour ajouter des données au dictionnaire??

 

 

Cela parait moins compliqué en Vlisp, est ce une impression?

[(gile)]

est t'on obligé de passer par un objet Xrecord pour ajouter des données au dictionnaire??

Oui.

Cela parait moins compliqué en Vlisp, est ce une impression?

Si tu parles des ldatas, je suis d'accord.

Si tu parles des dictionnaires et xrecords standards, je ne suis pas d'accord, j'ai toujours préféré utiliser les listes DXF.

[Bortch59]

Je parlais en effet des ldatas.

 

Pour ce qui est des Xrecords, comment se fait le choix des codes DXF?

Y a t'il des paires à éviter ou fait on un peu ce que l'on veut (hormis je pense 0 et 100)?

[(gile)]

Si les xrecords sont plus souples que les xdatas, on ne peut pas non plus faire ce que l'on veut. De plus, une certaine rigueur dans l'utilisation des codes facilite l'utilisation, la lecture et le maintien du code.

Voir, dans l'aide aux développeurs : Manuel d'utilisation DXF > Format DXF > Types de valeur des codes de groupe.

[krunch]

Juste une correction d'après mes essais ..

 

(defun gc:GetOrCreateExtDict (ent / dict)
     ....
     (entmod
       (append
         (entget ent)
         (list '(102 . "{ACAD_XDICTIONARY")
               (cons 360 dict)
               '(102 . "}")
         )
       )
     )
     ....
)

 

Les entités TEXT sont souples avec entmod et entmake, mais les MTEXT sont plus capricieux.

Avec ceux là le code ci-dessus n'ajoute pas le dictionnaire, apparemment il faut le placer juste après le groupe de code 0 ou 5 :

(entmod (append
           (mapcar '(lambda(u) (assoc u (entget dum))) '(-1 0))
           (list '(102 . "{ACAD_XDICTIONARY") (cons 360 dict) '(102 . "}"))
           (member (assoc 5 (entget dum)) (entget dum))
))

 

Pareil avec entmakex :

(entmakex (append
    '((0 . "MTEXT"))
    (list '(102 . "{ACAD_XDICTIONARY") (cons 360 dict) '(102 . "}"))
    '((100 . "AcDbEntity")(100 . "AcDbMText"))
    ...
))

[(gile)]

Une petite bibliothèque de fonctions pour manipuler les dictionnaires et XRecords.

 

;;;======================== Dictionnaires d'extension ========================;;;

;; gc:GetExtDict (gile)
;; Retourne le dictionnaire d'extension de l'entité (ou nil)
;;
;; Argument : ent (ENAME)

(defun gc:GetExtDict (ent)
 (cdadr (member '(102 . "{ACAD_XDICTIONARY") (entget ent)))
)

;; gc:GetOrCreateExtDict (gile)
;; Retourne le dictionnaire d'extension de l'entité
;; Le dictionnaire est créé s'il n'existe pas
;;
;; Argument : ent (ENAME)

(defun gc:GetOrCreateExtDict (ent / dict)
 (cond
   ((cdadr (member '(102 . "{ACAD_XDICTIONARY") (entget ent))))
   ((setq dict	(entmakex
	  '((0 . "DICTIONARY") (100 . "AcDbDictionary"))
	)
    )
    (entmod
      (vl-list*
        (assoc -1 elst)
        (assoc 0 elst)
        (assoc 5 elst)
        (cons 102 "{ACAD_XDICTIONARY")
        (cons 360 dict)
        (cons 102 "}")
        (vl-remove-if (function (lambda (x) (member (car x) '(-1 0 5)))) elst)
      )
    )
    dict
   )
 )
)


;;;========================== Dictionnaires nommés ===========================;;;

;; gc:GetNamedDict
;; Retourne le ENAME du dictionnaire nommé (ou nil)
;;
;; Arguments
;; dict : ENAME du dictionnaire parent
;; name : nom du dictionnaire à chercher
(defun gc:GetNamedDict (dict name)
 (cdr (assoc -1 (dictsearch dict name)))
)

;; gc:GetOrCreateNamedDict
;; Retourne le ENAME du dictionnaire nommé
;; Le dictionnaire est créé s'il n'existe pas
;;
;; Arguments
;; dict : ENAME du dictionnaire parent
;; name : nom du dictionnaire à chercher ou créer

(defun gc:GetOrCreateNamedDict (dict name)
 (if (snvalid name)
   (cond
     ((gc:GetNamedDict dict name))
     ((dictadd	dict
	name
	(entmakex '((0 . "DICTIONARY") (100 . "AcDbDictionary")))
      )
     )
   )
 )
)


;;;========================= Entrées du dictionnaire =========================;;;

;; gc:GetDictEntries
;; Retourne la liste des entrées du dictionnaire
;; sous forme de paires pointées (Nom . ENAME)
;;
;; Argument : dict le dictionnaire (ENAME ou liste DXF)

(defun gc:GetDictEntries (dict / result)
 (and (= (type dict) 'ENAME) (setq dict (entget dict)))
 (while
   (setq dict (vl-member-if (function (lambda (x) (= (car x) 3))) (cdr dict)))
    (setq result (cons (cons (cdar dict) (cdadr dict)) result))
 )
 (reverse result)
)


;;;=========================== Données du XRecord ============================;;;

;; gc:SetXrecData
;; Retourne le ENAME du XRecord auquel sont affectées mes données
;;
;; Arguments
;; dict : ENAME du dictionnaire parent
;; key : nom du XRecord
;; data : liste de paires pointées contenant les données

(defun gc:SetXrecData (dict key data / xrec)
 (if (snvalid key)
   (progn
     (and (setq xrec (dictsearch dict key))
   (entdel (cdr (assoc -1 xrec)))
     )
     (dictadd
dict
key
(entmakex
  (vl-list*
    '(0 . "XRecord")
    '(100 . "AcDbXRecord")
    data
  )
)
     )
   )
 )
)

;; gc:GetXrecData
;; Retourne la liste des données affectées au XRecord (liste de paires pointées)
;;
;; Arguments
;; dict : ENAME du dictionnaire parent
;; key : nom du XRecord

(defun gc:GetXrecData (dict key / xrec)
 (if (and
(setq xrec (dictsearch dict key))
(= (cdr (assoc 0 xrec)) "XRecord")
     )
   (cdr (member (assoc 280 xrec) xrec))
 )
)

[PHILPHIL]

bonjour Gile

 

je cherche le nom du dictionnaire pour les "noms de filtre de calques"

et des XREFs implantés dans le fichier

car ce lisp ne semble pas fonctionner, alors que j'ai bien des filtres de calques existants deja

(defun c:test_dictionnaire ()
(setq test301 ( gc:dictdatalist  "ACAD_MLEADERSTYLE"  ))
(setq test300 ( gc:dictdatalist  "ACAD_LAYERFILTERS"  ))
)

grace a ton appli "inspector"  je trouve les noms des dictionnaires existant dans le fichier

ACAD_MLEADERSTYLE : existe bien et ca marche

ACAD_LAYERFILTERS : celui ci n existe pas ( normale ou pas ) ou alors il a changé de nom depuis, car sur le net il existe dans des lisp en 2011 ( notamment chez LEE-MAC )

;; gc:DictDataList
;;
;; Liste les données des entrées d'un dictionnaire
;; Arguments :
;; dict : le nom du dictionnaire (chaine) ou de l'object (ename)

(defun gc:dictdatalist (name / dict elst lst)
  (if (or (and (= (type name) 'str)
               (dictsearch (namedobjdict) name)
               (setq dict (dictsearch (namedobjdict) name))
          )
          (and (or (= (type name) 'ename)
                   (and (= (type name) 'vla-object) (setq name (vlax-vla-object->ename name)))
               )
               (setq dict (entget (cdr (assoc 360 (member '(102 . "{ACAD_XDICTIONARY") (entget name))))))
          )
      )
    (progn (setq elst (vl-member-if (function (lambda (x) (= (car x) 3))) dict))
           (while elst
             (setq lst  (cons (cons (cdar elst)
                                    (mapcar 'cdr (cdr (vl-member-if (function (lambda (x) (= (car x) 280))) (entget (cdadr elst)))))
                              )
                              lst
                        )
                   elst (cddr elst)
             )
           )
           (reverse lst)
    )
  )
)

merci

Phil