krunch

Rebonjour Comme souvent en faisant des essais plus poussés on trouve des problèmes ... On peut faire marcher nenthl/nentuhl avec le Lisp ci-dessous en activant la partie 'Version simple' et en désactivant le reste, nenthl/nentuhl sont dans le dernier .dll posté par (gile): - Polys old style (Vertex) : ça marche pas, c'est pas prévu dans le C# - Tableaux : le highlight fait apparaître des entités temporaires autour du tableau (idem sélection : pochages, indications de lignes et colonnes etc..), si on passe un de ces trucs (<Nom d'entité : 0>) à nenthl ça fait une erreur fatale - Entités des bloc annotatifs : une espèce de fantôme apparait avec le highlight (idem sélection : avec les entités à plusieurs échelles d'annotation je crois) - RefAttributs des blocs annotatifs : pas de highlight (mais le "fantôme" est là) - RefAttributs avec Champ : le champ n'est pas highlité Alors j'ai fait une nouvelle version qui les corrige en Lisp (sauf le dernier point). Pour les 2 premiers je gère la liste d'imbrication en Lisp à la place du C# (ce n'était pas nécessaire mais ça m'arrange), j'ai adapté (artisanalement) le C# principalement en enlevant du code. Pour les blocs annotatifs c'est plus compliqué, j'ai trouvé la parade en désactivant la propriété annotative le temps du highlight et en la réactivant ensuite, par contre ça oblige à stocker la propriété annotative. Le Lisp marche avec les nouvelles fonctions high1/high0 qui se trouvent en dessous. ; Boucle (grread) avec Highlight des entités survolées, imbriquées ou non (.Net) ; Filtrage des XRefs ; Réserves : ; - Tableaux : nentselp ne détecte pas le texte normal (sans Champ) contenu dans les tableaux ; - RefAttss : le highlight ne marche pas sur les Champs (defun c:go (/ *ERROR* out grr cod obj rol ctx) (defun *ERROR* (msg) (if rol (High rol nil)) (print msg) ) (while (not out) (setq grr (grread t 15 2) cod (car grr)) (cond ; Enter/Espace/Clic-droit ((or (= cod 25) (member grr '((2 13)(2 32)))) (*ERROR* "sortie") (setq out T) ) ; Rollover ((= cod 5) (setq cod (nentselp (cadr grr)) ctx (cadddr cod) ) ;;; ; Version simple ;;; (setq obj cod) ;;; (or (equal obj rol) ;;; (progn ;;; (if rol (nentuhl rol)) ;;; (setq rol obj) ;;; (if rol (nenthl rol)) ;;; ) ;;; ) ; Liste d'imbrication +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ (if (and ctx (setq obj (vl-some '(lambda(u) (if (assoc 1 (tblsearch "BLOCK" (cdr (assoc 2 (entget u))))) u)) (reverse ctx)))) ; Filtrage des entités de XRef : obj = dernière XRef (setq obj (member obj ctx)) (if (setq obj (car cod)) (setq cod (entget obj) obj (cond ; Filtrage des entités temporaires de Tableaux ((not cod) nil) ; RefAttributs Vertex + autres ((= (cdr (assoc 0 cod)) "ATTRIB") (cons obj (cons (cdr (assoc 330 cod)) ctx))) ((= (cdr (assoc 0 cod)) "VERTEX") (cons (cdr (assoc 330 cod)) ctx)) (T (cons obj ctx)) ) ) ) ) ; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ; obj : liste d'imbrication (ent [ref0 .. refN]) ; rol : liste d'imbrication du highlight courant + ann (ann ent [ref0 .. refN]) ; ann : liste (entget blc '("AcadAnnotative")) avec la XData du bloc si ent imbriquée dans un bloc annotatif / nil sinon (or (equal obj (cdr rol)) (progn (if rol (setq rol (High rol nil))) (if obj (setq rol (High obj T))) ) ) ) ) ) (princ) ) (defun High (obj on / ann) ; Pré-traitement Bloc annotatif (if (setq ann (if on (if (cdr obj) (Get_Annot (cdr (assoc 330 (entget (tblobjname "block" (cdr (assoc 2 (entget (last obj)))))))))) (car obj) )) (entmod (subst (list -3 (list "AcadAnnotative" '(1000 . "AnnotativeData") '(1002 . "{") '(1070 . 1) (cons 1070 (if on 0 1)) '(1002 . "}"))) (assoc -3 ann) ann)) ) ; Highlight (if on (High1 obj) (High0 (cdr obj)) ) ; Renvoi (if on (cons ann obj)) ) (defun Get_Annot (obj / out) (if (= 1 (cdr (assoc 1070 (reverse (cadr (assoc -3 (setq out (entget obj '("AcadAnnotative"))))))))) out ) ) using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.Runtime; using System.Collections.Generic; namespace HighLightNested { public class Functions { ///----------------------------------------------------- /// Fonctions high1 + high0 /// Argument: Liste d'imbrication (ent [ref0 .. refN]) /// Returns: Ename if successful, otherwise nil. /// Exemples: /// (high1 (cons (car (setq in (nentsel))) (cadddr in))) /// (high1 (list (car (entsel)))) /// ou (high1 (car (entsel))) /// ou (high1 (entsel)) /// (high0 ...) ///---------------------------------------------------- /// James Allen - 10Jun09 /// Malicoat-Winslow Engineers, P.C. ///------------------------------------------------------ [LispFunction("high1")] public static object nenthl(ResultBuffer LspArgs) { return Highlight(LspArgs, true); } [LispFunction("high0")] public static object nentuhl(ResultBuffer LspArgs) { return Highlight(LspArgs, false); } public static object Highlight(ResultBuffer LspArgs, bool hl) { //Initialize if (LspArgs == null) return null; int an = 0, ld = 0;//argument number, list depth //ObjectId id = new ObjectId(); List<ObjectId> path = new List<ObjectId>(); //Process Arguments foreach (TypedValue tv in LspArgs) { switch (an) { //// Géré en Lisp .. //case 0: //Get ObjectId // if (tv.TypeCode == (int)LispDataType.ListBegin) // break; // else if (tv.TypeCode == (int)LispDataType.ObjectId) // id = (ObjectId)tv.Value; // else return null; // an++; break; //case 1: //Ignore Pick Point // an++; break; //case 2: //Ignore Matrix // if (tv.TypeCode == (int)LispDataType.ListBegin) // ld++; // else if (tv.TypeCode == (int)LispDataType.ListEnd) // { ld--; if (ld == 0) an++; } // break; case 0: //Get Nest Path if (tv.TypeCode == (int)LispDataType.ListBegin) ld++; else if (tv.TypeCode == (int)LispDataType.ListEnd) { ld--; if (ld == 0) an++; } else if (tv.TypeCode == (int)LispDataType.ObjectId) path.Add((ObjectId)tv.Value); break; default: break; } } //Highlight Database db = path[0].Database; using (Transaction t = db.TransactionManager.StartTransaction()) { //// Géré en Lisp .. //Entity e = (Entity)id.GetObject(OpenMode.ForRead); //if (e.GetType() == typeof(AttributeReference) && (path.Count == 0 || !e.OwnerId.Equals(path[0]))) // path.Insert(0, e.OwnerId); if (path.Count > 0) { //Highlight Nested //Credit: Kean Walmsley and Others //http://through-the-interface.typepad.com/through_the_interface/2006/12/highlighting_a_.html //------------------------------------------------------- path.Reverse(); //// Géré en Lisp .. //path.Add(id); Entity e = (Entity)path[0].GetObject(OpenMode.ForRead); //SubentityId si = new SubentityId(SubentityType.Null, 0); SubentityId si = new SubentityId(); FullSubentityPath fsp = new FullSubentityPath(path.ToArray(), si); if (hl) e.Highlight(fsp, true); else e.Unhighlight(fsp, true); //------------------------------------------------------- } else { Entity e = (Entity)path[0].GetObject(OpenMode.ForRead); if (hl) e.Highlight(); else e.Unhighlight(); } t.Commit(); } //Return ObjectId return new TypedValue((int)LispDataType.ObjectId, path[0]); } } } Juste un truc à propos de ce code : on peut enlever le foreach, switch .. dans ce cas où il n'y a plus qu'1 seul argument ?

Ok, justement je me demandais où se trouvait la doc pour tout ça. C'est aussi ce que j'ai fait, j'ai suivi scrupuleusement ton tuto .. En tout cas ça marche, merci beaucoup pour ton aide

Ça marche avec ta version ! Par contre je n'ai pas téléchargé ObjectARX 2010, et je ne vois pas ce que tu as changé dans HighLightNestedEntity.sln, y a t-il des modifs ? Sinon pour comprendre : - le code de Kean n'est pas nécessaire si je refais la dll depuis HighLightNestedEntity.sln (il est dans 'commands.cs') ? - dans ce cas si je supprime ta .dll (de ce jour à 15h25) de bin/Debug et que je la régénère ... la nouvelle .dll m'indique toujours 15h25 en propriété de fichier (alors qu'il est plus !), comment ça se fait ? Merci pour ton envoi

Si tu veux, je peux te faire parvenir la solution que j'ai faite et/ou ObjectARX 2010. C'est vrai que pour le moment je ne sais plus trop quoi essayer, et la solution de l'argument point serait en fait assez limitative .. Alors oui volontiers (il suffit peut être de mettre à jour les ObjectARX 2010 ?)

on peut passer aussi bien la liste retournée par entsel que celle retournée par nentsel Oui tu as raison, c'était juste parce que les arguments point et matrice ne servent à rien .. .. ajouter le point comme argument à la méthode InternalHighlightNested et changer le mode sélection .. Alors au pire si la 1ère solution ne marche pas je pourrais peut être passer par là ? En tout cas pas d'amélioration en changeant le SubentityId

Mais tu l'exécutes dans un AutoCAD 32 bits Non c'est bien un 64 bits Par contre, pour en revenir à ces .dll j'ai un répertoire "C:\Autodesk\AutoCAD_2010_French_SLD_WIN_64bit" (en plus de "C:\Program Files\AutoCAD 2010") qui contient aussi les 2 dll (mais pas de répertoire "inc-win32"/64).. Il faut prendre ceux là ?

Salut J'ai remplacé la ligne du SubEntityId par SubentityId si = new SubentityId(); mais j'ai toujours la même erreur... Sinon oui, le code de Kean marche correctement (malgré que j'aie les mêmes avertissements). Et pour ce que tu précises dans ton tutorial à propos de la provenance de AcDbMgd.dll et AcMgd.dll ("ou, mieux, dans le dossier ObjectARX20##\inc.."), je ne vois pas les dossiers mentionnés dans le répertoire d'installation, j'ai donc pris ceux du répertoire racine. Je les aurais bien téléchargé mais ils ne sont pas fournis sur la page Autodesk... Mais bon puisque c'est pas grave .. Donc non, ça ne marche pas .. ACac 2010 serait-il déjà trop vieux ?

Autre piste : pourquoi ne pas fournir directement à la nouvelle fonction Lisp la liste d'imbrication au format requis ? Ca donnerait un appel comme ça : (setq ent (nentsel)) (setq ent (cons (car ent) (reverse (cadddr ent))) (nenthl ent) Autre hypothèse : Peut on fournir un argument point à la méthode editor.GetNestedEntity qu'utilise KW, de la même façon qu'avec nentselp (quand on lui fournit un point on zappe l'entrée utilisateur) ?? Ca donnerait un appel comme ça : (setq ent (cadr (nensel)) (nenthl ent)

Bonjour J'ai mis un orteil dans le .Net à l'occasion d'un projet apriori simple : un highlight-nested. J'avais tenté en Lisp mais la solution qui consiste à reproduire l'entité est décidemment trop poussive, pas très satisfaisante, et vite limitée (par exemple si je veux maintenant highliter une sous-entité depuis une sélection entsel il faut calculer sa matrice à partir de son niveau d'imbrication en multipliant des matrices (mxm) ... ce qui est particulièrement lourd). Bref, le .Net semble bien être la solution pour ça, c'est pourquoi j'ai jeté un oeil sur 2 codes trouvés sur le net : - le 1er que j'avais indiqué de James Allen (que je reproduis ci dessous) mais qui ne marche pas chez moi (ACad 2010) - un 2è de Kean Walmsley, qui marche .. J'ai donc installé Visual Studio 2012, suivi le tutoriel de (gile) en lien sur ce forum, et réussi à générer un dll avec les 2 codes (malgré quelques messages d'erreur). Mon problème c'est que j'ai besoin de la structure du code de JA qui marche pas, à savoir une fonction Lisp à laquelle transmettre l'entité + sa liste d'imbrication (le dernier élément du renvoi nentsel) en argument... Alors que le code de KW inclut l'entrée utilisateur (sélection) qui est faite en C#. Voilà le message d'erreur que j'obtiens avec le dll de JA (ou avec mon dll compilé c'est pareil) : System.MissingMethodException: Méthode introuvable : 'Void Autodesk.AutoCAD.DatabaseServices.SubentityId..ctor(Autodesk.AutoCAD.DatabaseServices.SubentityType, Int32)'. à HighlightNested.LispFuncClass.Highlight(ResultBuffer LspArgs, Boolean hl) à Autodesk.AutoCAD.Runtime.CommandClass.InvokeWorker(MethodInfo mi, Object commandObject, Boolean bLispFunction) à Autodesk.AutoCAD.Runtime.CommandClass.InvokeWorkerWithExceptionFilter(MethodInfo mi, Object commandObject, Boolean bLispFunction) à Autodesk.AutoCAD.Runtime.CommandClass.CommandThunk.InvokeLisp(); erreur: Demande ADS erronée Je remarque que le code de JA 'cite' celui de KW, mais qu'il n'utilise pas du tout les mêmes données ni les mêmes méthodes (pour inverser la liste par exemple), ni le même ordre dans la séquence 'Using (Transaction ..)' Je ne connais pas le C#, c'était donc une approche intuitive qui s'arrète là .. Autre chose, j'ai aussi 2 avertissements comme ça sur acdbmgd et acmgd au moment de la génération : C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Common.targets(1578,5): warning MSB3270: Il existe une différence entre l'architecture de processeur du projet en cours de génération "MSIL" et l'architecture de processeur de référence "acmgd", "AMD64"... Apparemment il compile avec Framework\v4.0 alors que j'ai bien spécifié Framework\v3.5 dans les propriétés (cf tutoriel) .. Le code de JA : //Tested on 2007-2010 using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.Runtime; using System.Collections.Generic; namespace HighlightNested { public static class LispFuncClass { ///------------------------------------------------------ /// Arguments: Output from entsel, nentsel, or nentselp. /// Returns: Ename if successful, otherwise nil. /// Examples: /// (apply 'nenthl (nentsel)) /// (nenthl (nentsel)) /// (nentuhl (nentsel)) /// /// James Allen - 10Jun09 /// Malicoat-Winslow Engineers, P.C. ///------------------------------------------------------ [LispFunction("nenthl")] public static object nenthl(ResultBuffer LspArgs) { return Highlight(LspArgs, true); } [LispFunction("nentuhl")] public static object nentuhl(ResultBuffer LspArgs) { return Highlight(LspArgs, false); } public static object Highlight(ResultBuffer LspArgs, bool hl) { //Initialize if (LspArgs == null) return null; int an = 0, ld = 0;//argument number, list depth ObjectId id = new ObjectId(); List<ObjectId> path = new List<ObjectId>(); //Process Arguments foreach (TypedValue tv in LspArgs) { switch (an) { case 0: //Get ObjectId if (tv.TypeCode == (int)LispDataType.ListBegin) break; else if (tv.TypeCode == (int)LispDataType.ObjectId) id = (ObjectId)tv.Value; else return null; an++; break; case 1: //Ignore Pick Point an++; break; case 2: //Ignore Matrix if (tv.TypeCode == (int)LispDataType.ListBegin) ld++; else if (tv.TypeCode == (int)LispDataType.ListEnd) { ld--; if (ld == 0) an++; } break; case 3: //Get Nest Path if (tv.TypeCode == (int)LispDataType.ListBegin) ld++; else if (tv.TypeCode == (int)LispDataType.ListEnd) { ld--; if (ld == 0) an++; } else if (tv.TypeCode == (int)LispDataType.ObjectId) path.Add((ObjectId)tv.Value); break; default: break; } } //Highlight Database db = id.Database; using (Transaction t = db.TransactionManager.StartTransaction()) { Entity e = (Entity)id.GetObject(OpenMode.ForRead); if (e.GetType() == typeof(AttributeReference) && (path.Count == 0 || !e.OwnerId.Equals(path[0]))) path.Insert(0, e.OwnerId); if (path.Count > 0) { //Highlight Nested //Credit: Kean Walmsley and Others //http://through-the-interface.typepad.com/through_the_interface/2006/12/highlighting_a_.html //------------------------------------------------------- path.Reverse(); path.Add(id); e = (Entity)path[0].GetObject(OpenMode.ForRead); SubentityId si = new SubentityId(SubentityType.Null, 0); FullSubentityPath fsp = new FullSubentityPath(path.ToArray(), si); if (hl) e.Highlight(fsp, true); else e.Unhighlight(fsp, true); //------------------------------------------------------- } else { if (hl) e.Highlight(); else e.Unhighlight(); } t.Commit(); } //Return ObjectId return new TypedValue((int)LispDataType.ObjectId, id); } } }

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")) ... ))

Je lâche pas l'affaire .. Il y avait des erreurs avec les ATTRIB imbriquées dans des blocs (on ne peut pas copier un Attrib dans l'espace Objet) et avec les TEXT/MTEXT Annotatifs imbriqués. Alors j'ai ajouté une fonction pour ces entités, qui refabrique un TEXT/MTEXT à partir d'un ATTRIB ou d'un TEXT/MTEXT. C'est un peu poussive mais ça marche correctement y compris avec les comportements annotatifs. Ici les entités imbriquées sont highlitées en rouge .. ; Boucle grread avec Highlight des entités survolées : ; - Highlight des entités de l'espace Objet ; - Highlight après refabrication dans l'espace courant des Attribs/Text/MText imbriqués dans un bloc ; - Highlight après copie dans l'espace courant des autres entités imbriquées dans un bloc ; les entités de XRef renvoient la Référence de bloc (defun c:go (/ *ERROR* High acdoc out grr cod obj rol dum mat ctx) (defun *ERROR* (msg) (if rol (High rol nil)) (print msg) ) (defun High (rol on) (if on (redraw rol 3) (if dum (progn (entdel dum) (setq dum nil) ) (redraw rol 4) ) ) ) ; Refabrique un TEXT/MTEXT dans l'espace Objet à partir d'un ATTRIB ou d'un TEXT/MTEXT (defun Make_TextObject (get / att ort mlt new) (setq get (entget obj) att (= (cdr (assoc 0 get)) "ATTRIB") ort (or (Get_MatchOrient obj) (and att (Get_MatchOrient (cdr (assoc 330 (entget (tblobjname "block" (cdr (assoc 2 (entget (cdr (assoc 330 get)))))))))))) mlt (if att (cdr (member '(101 . "Embedded Object") get)) (= (cdr (assoc 0 get)) "MTEXT") ) new (append (if att '(-1 0 100 102 330 360 5 51 2 280 67 74 70) '(-1 0 100 102 330 360 5) ) (if ort '(210 50 11) ) ) new (append (if mlt '((0 . "MTEXT")(100 . "AcDbEntity")(100 . "AcDbMText")) '((0 . "TEXT")(100 . "AcDbEntity")(100 . "AcDbText")) ) (if att (if mlt (list (cons 8 (cdr (assoc 8 get)))) (append (list (cons 73 (cdr (assoc 74 get)))) (if (and ort (member (cdr (assoc 72 get)) '(3 5))) (list (cons 11 (mapcar '+ (list (distance (cdr (assoc 10 get)) (cdr (assoc 11 get))) 0 0) (cdr (assoc 10 get))))) ) ) ) ) (vl-remove-if '(lambda(u) (member (car u) new)) (if (and att mlt) mlt get)) ) new (vlax-ename->vla-object (entmakex new)) ) (and ort (not mlt) (vla-move new (vla-get-Insertionpoint new) (vla-get-Insertionpoint (vlax-ename->vla-object (cdr (assoc -1 get))))) ) new ) (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object))) (while (not out) (setq grr (grread t 15 2) cod (car grr)) (cond ; Enter/Espace/Clic-droit ((or (= cod 25) (member grr '((2 13)(2 32)))) (*ERROR* "sortie") (setq out T) ) ; Rollover ((= cod 5) (setq obj (nentselp (cadr grr)) mat (caddr obj) ctx (cadddr obj) ) (if (and ctx (vl-some '(lambda(u) (< 3 (cdr (assoc 70 (tblsearch "BLOCK" (cdr (assoc 2 (entget u)))))))) ctx)) (setq obj (last ctx) ctx nil) (if (and (setq obj (car obj)) (= (cdr (assoc 0 (entget obj))) "VERTEX")) (setq obj (cdr (assoc 330 (entget obj)))) ) ) (or (eq obj rol) (progn (if rol (High rol nil)) (if obj (if ctx (progn (entupd (last ctx)) (setq dum (if (member (cdr (assoc 0 (entget obj))) '("ATTRIB" "TEXT" "MTEXT")) (Make_TextObject (entget obj)) (progn (setq dum (vla-CopyObjects acdoc (vlax-make-variant (vlax-safearray-fill (vlax-make-safearray vlax-vbobject '(0 . 0)) (list (vlax-ename->vla-object obj)))) (vla-get-ModelSpace acdoc))) (car (vlax-safearray->list (vlax-variant-value dum))) ) )) (vlax-put dum 'color 1) (vla-TransformBy dum (vlax-tmatrix mat)) (setq dum (vlax-vla-object->ename dum) obj dum) ) ) ) (setq rol obj) (if rol (High rol T)) ) ) ) ) ) (defun Get_MatchOrient (obj) (if (= 1 (cdr (assoc 1070 (reverse (cadr (assoc -3 (entget obj '("AcadAnnotative")))))))) (assoc -3 (entget obj '("AcadAnnoPO"))) ) ) (princ) )

Je reviens sur ce que j'ai écrit parce que c'est faux .. Quand on récupère le code 330 d'une entité renvoyée par nentsel on obtient : - si c'est un ATTRIB : la Référence de bloc de l'attrib - si c'est un VERTEX (de Poly3D etc ..) : le Poly3D etc .. - sinon : un BLOCK_RECORD (du bloc contenant, ou de l'espace Objet/Papier) C'est pourtant simple :)

Oui c'est bien la RefBloc qui est testée par EDICT J'ai compris : le pb venait en fait de mon (cdr (assoc 330 (entget obj))) où obj est donné par nentsel .. - si obj est un Attrib il renvoie bien l'INSERT - sinon il renvoie un BLOCK_RECORD

Pourtant si : on le voit avec ton EDICT si le bloc est annotatif .. En effet, le test marche bien comme ça y compris avec les textes, c'est donc une meilleure formule. Merci de nouveau

Bon, alors je ne dis plus qu'il y a un manque de cohérence mais il y a parfois de quoi s'arracher les cheveux .. (gile) tu m'as donné la solution pour la propriété MatchOrient d'un bloc, je cherche maintenant sa propriété Annotative (sachant que pour que la 1ère soit effective il faut les deux). Pour un texte j'obtiens ces propriétés avec les fonctions ci-dessous, ça marche très bien (Get_MatchOrient obj) (Get_Annot obj) Pour un bloc je récupère maintenant MatchOrient depuis le BlockTableRecord (dans la ligne suivante obj est obtenu avec nentsel).. alors pourquoi la 2è ligne ne marche pas ? (Get_MatchOrient (cdr (assoc 330 (entget (tblobjname "block" (cdr (assoc 2 (entget (cdr (assoc 330 (entget obj))))))))))) (Get_Annot (cdr (assoc 330 (entget (tblobjname "block" (cdr (assoc 2 (entget (cdr (assoc 330 (entget obj))))))))))) Où est stocké ce dictionnaire ? Il n'est pas dans l'objet imbriqué (sauf si c'est un Attrib je crois), il n'est pas dans la RefBloc, il n'est pas dans le bloc, il n'est pas dans l'objet BlockTableRecord ??? ; Renvoie l'entrée du dictionnaire si la propriété annotative de obj est activée / nil sinon (defun Get_Annot (obj) (if (and (setq obj (cdr (assoc 360 (entget obj)))) (setq obj (dictsearch obj "AcDbContextDataManager")) (setq obj (dictsearch (cdr (assoc -1 obj)) "AcDb_AnnotationScales")) ) (cdr (assoc 350 obj)) ) ) ; Renvoie la XData si la propriété MatchOrient de obj est activée / nil sinon (defun Get_MatchOrient (obj) (assoc -3 (entget obj '("AcadAnnoPO"))) )

Le 'pourquoi' c'est toujours la nécessité : il faut coder les infos pour pouvoir les retrouver. Mais le 'comment' n'a pas l'air d'obéir à une logique prédéfinie : il évolue au gré des améliorations.. Par exemple le passage des polys 'old style' aux LW, les champs et les comportements annotatifs, les blocs dynamiques ... je dis pas que c'est nul, mais au final il vaut mieux pas chercher la cohérence dans le codage de tout ça ! Au final le dxf est un ensemble de cas particuliers, il faut juste faire avec et regarder dans l'aide...

Justement j'ai la tête dans les champs ... (and (member (cdr (assoc 0 (entget ent))) '("ATTRIB" "MTEXT" "TEXT")) (setq get (cdr (assoc 360 (entget ent)))) (setq get (dictsearch get "ACAD_FIELD")) (setq get (cdr (assoc 360 get))) (setq get (cdr (assoc 360 get))) (setq get (assoc 330 (reverse get))) ; ou code 331 ) D'ailleurs c'est justement un contre-exemple de ce que je disais, puisque le code 330 n'est pas un "propriétaire" dans ce cas !

Je sèche sur autre chose : finalement j'ai besoin de vérifier la propriété Annotative du bloc, et je n'arrive pas à trouver le dictionnaire "AcDbContextDataManager" .. Normalement le test est le suivant (pour ent = texte) mais dans le cas d'un bloc je ne trouve pas non plus sur quoi le brancher .. (if (and (setq tmp (cdr (assoc 360 (entget ent)))) (setq tmp (dictsearch tmp "AcDbContextDataManager")) (setq tmp (dictsearch (cdr (assoc -1 tmp)) "AcDb_AnnotationScales")) ) (assoc 350 tmp) )

Je comprends pas très bien ton bloc de citation car tu insères les appels 'exploredxf' dans les listes entget .. Le principe général est qu'en interrogeant le code 330 tu récupères l'objet propriétaire (le conteneur) et qu'en interrogeant le code 360 tu interroge un contenu (dictionnaire), donc 330 tu montes et 360 tu descends. Par exemple avec une entité imbriquée (sélectionnée avec nentsel) le code 330 renvoie la RefBloc, dont le code 330 est la RefBloc de niveau supérieur si elle est elle même imbriquée .. ainsi de suite jusqu'à l'espace Objet/Papier. Pour le reste il faut voir la signification des codes au cas par cas dans l'aide. Autre chose : le VLisp me semble plus facile pour "explorer" en sachant où on est, en se référant à l'Object Model de l'aide (par exemple on 'monte' de façon plus continue jusqu'à l'objet Application avec la propriété OwnerID)

D'accord, je connaissais pas tblobjname vs tblsearch .. J'arrive maintenant à la lire. Merci un coup de plus.

Un bon outil Mais j'ai une erreur 'eNotFromThisDocument'(avec AutoCad2010) à partir du moment où j'essaie de le faire marcher sur un 2è fichier ouvert dans la même session : d'abord quand je sélectionne une entrée du NOD ou de l'un de ses dictionnaires, ensuite immédiatement au lancement EDICT .. Veux-tu le rapport ?

Alors j'ai raté quelque chose .. Je disais qu'il n'y a pas d'entité parce qu'il n'y a pas de code -1 dans la définition de bloc obtenue par (tblsearch "BLOCK" "nom") Et la propriété en question se cherche avec : (assoc -3 (entget ent '("AcadAnnoPO"))) D'autre part je n'ai pas de code -3 dans la définition d'un bloc (même annotatif) renvoyé par tblsearch, donc je n'obtiens rien avec : (assoc -3 (tblsearch "BLOCK" "nom")) Comment l'obtiens tu ?

Bonjour Savez vous où se planque cette propriété de bloc ?? Pour les textes c'est une Xdata (ce post) mais pour les blocs il n'y a pas d'entité, donc pas de Xdata .. La Xdata n'est pas dans l'Insert, ni dans les objets de l'Insert, ni dans les objets du bloc. Par contre dans l'Insert il y a bien la propriété Annotative (dictionnaire du code 360) comme pour les textes .. :angry:

Nouvelle version : - filtre les objets des Xrefs avec nouveau test (dans ce cas il highlighte la Xref) - corrige les cercles/arcs baveux : il suffit d'updater la refbloc - intègre les objets 'old style' que j'avais oubliés Ne détecte pas le texte normal contenu dans les tableaux .. ; Boucle grread avec highlight des entités survolées ; et substitution de celles imbriquées dans les références de blocs (defun c:go (/ *ERROR* High acdoc out grr cod obj rol dum mat ctx) (defun *ERROR* (msg) (if rol (High rol nil)) (print msg) ) (defun High (rol on) (if on (redraw rol 3) (if dum (progn (entdel dum) (setq dum nil) ) (redraw rol 4) ) ) ) (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object))) (while (not out) (setq grr (grread t 15 2) cod (car grr)) (cond ; Enter/Espace/Clic-droit ((or (= cod 25) (member grr '((2 13)(2 32)))) (*ERROR* "sortie") (setq out T) ) ; Rollover ((= cod 5) (setq obj (nentselp (cadr grr)) mat (caddr obj) ctx (cadddr obj) ) (if (and ctx (vl-some '(lambda(u) (< 3 (cdr (assoc 70 (tblsearch "BLOCK" (cdr (assoc 2 (entget u)))))))) ctx)) (setq obj (last ctx) ctx nil) (if (and (setq obj (car obj)) (= (cdr (assoc 0 (entget obj))) "VERTEX")) (setq obj (cdr(assoc 330 (entget obj)))) ) ) (or (eq obj rol) (progn (if rol (High rol nil)) (if obj (if ctx (progn (entupd (last ctx)) (setq dum (vla-CopyObjects acdoc (vlax-make-variant (vlax-safearray-fill (vlax-make-safearray vlax-vbobject '(0 . 0)) (list (vlax-ename->vla-object obj)))) (vla-get-ModelSpace acdoc)) dum (car (vlax-safearray->list (vlax-variant-value dum)))) (vla-TransformBy dum (vlax-tmatrix mat)) (setq dum (vlax-vla-object->ename dum)) (setq obj dum) ) ) ) (setq rol obj) (if rol (High rol T)) ) ) ) ) ) (princ) )

Merci pour ces précisions, je n'avais pas remarqué que les fonctions locales restaient accessibles si non déclarées.