ADN Open CIS
Сообщество программистов Autodesk в СНГ

04/02/2015

Управляемая альтернатива ExplodeAllProxy

Андрей Бушман у себя на сайте опубликовал код, решающий те же задачи, что и знаменитый ExplodeAllProxy от Александра Ривилиса. Пользуясь выцыганенным у Андрея разрешением, публикую мои изменения его кода.

Прежде всего, хочу предупредить о следующем:
  1. Я не автор кода. Я не знаю и не понимаю, как он работает. Я не в силах его повторить. Все, что я могу сказать - это "обращайтесь на сайт Андрея"
  2. Ниже показан исправленный мною код. Я поменял код так, чтобы хоть что-то в нем понять (Андрей, прости!)
  3. После этого указаны ссылки со скомпилированными .NET-сборками для AutoCAD 2009-2015. Компилировалось в условиях 64-разрядной ОС. На 32-битных Windows / ACAD работу библиотек не проверял. Загрузка и работа проверены на ACAD2009, 2013, 2015


Если читать все лень, то: библиотека прописывает в AutoCAD
Команда Выводит в командную строку сообщение об обнаруженных прокси-объектах
Лисп-функция То же
Команда Разбивает все графические прокси-объекты
Лисп-функция То же
Команда Удаляет неразбитые и неграфические прокси-объекты
Лисп-функция То же
Команда Совмещает разбиение и очистку прокси-объектов
Лисп-функция То же
Собственно архивы:
ACAD 2009 ACAD 2010 ACAD 2011
ACAD 2012 ACAD 2013 ACAD 2014
ACAD 2015
 
Все версии
Итак, собственно класс, выполняющий саму работу:
Код - C#: [Выделить]
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Diagnostics;
  5. using System.IO;
  6. using cad = Autodesk.AutoCAD.ApplicationServices.Application;
  7. using Ap = Autodesk.AutoCAD.ApplicationServices;
  8. using Db = Autodesk.AutoCAD.DatabaseServices;
  9. using Ed = Autodesk.AutoCAD.EditorInput;
  10. using Rt = Autodesk.AutoCAD.Runtime;
  11. using Gm = Autodesk.AutoCAD.Geometry;
  12.  
  13. namespace gunipcProxy
  14. {
  15.   public delegate void WriteMessage(String format, params Object[] args);
  16.  
  17.   public static class ExtensionMethods
  18.   {
  19.  
  20.     static Rt.RXClass proxyObjectRXType = Rt.RXClass.GetClass(typeof(
  21.         Db.ProxyObject));
  22.  
  23.     static Rt.RXClass proxyEntityRXType = Rt.RXClass.GetClass(typeof(
  24.         Db.ProxyEntity));
  25.  
  26.     public static Db.ObjectId[] GetDBObjectIds(this Db.Database db)
  27.     {
  28.       Db.ObjectId[] ids = GetDBObjectIds(db, (n => true));
  29.       return ids;
  30.     }
  31.  
  32.     public static Db.ObjectId[] GetDBObjectIds(this Db.Database db, Func filter)
  33.     {
  34.  
  35.       // Check arguments
  36.       if (null == db)
  37.         throw new ArgumentNullException("null == db");
  38.       if (null == filter)
  39.         throw new ArgumentNullException("null == filter");
  40.       if (db.IsDisposed)
  41.         throw new ArgumentException("true == db.IsDisposed");
  42.  
  43.       // -------------------
  44.       Int32 approxNum = db.ApproxNumObjects;
  45.       List ids = new List();
  46.  
  47.       for (Int64 i = db.BlockTableId.Handle.Value; i < db.Handseed.Value
  48.           && approxNum > 0; ++i)
  49.       {
  50.  
  51.         Db.Handle h = new Db.Handle(i);
  52.         Db.ObjectId id = Db.ObjectId.Null;
  53.  
  54.         Boolean parseResult = db.TryGetObjectId(h, out id);
  55.  
  56.         if (parseResult)
  57.         {
  58.           --approxNum;
  59.           if (filter(id))
  60.           {
  61.             ids.Add(id);
  62.           }
  63.         }
  64.       }
  65.       return ids.ToArray();
  66.     }
  67.  
  68.     public static Db.ObjectId[] GetEntityIds(this Db.Database db)
  69.     {
  70.       Db.ObjectId[] ids = GetEntityIds(db, (n => true));
  71.       return ids;
  72.     }
  73.  
  74.     public static Db.ObjectId[] GetEntityIds(this Db.Database db, Func filter)
  75.     {
  76.  
  77.       // Check arguments
  78.       if (null == db)
  79.         throw new ArgumentNullException("null == db");
  80.       if (null == filter)
  81.         throw new ArgumentNullException("null == filter");
  82.       if (db.IsDisposed)
  83.         throw new ArgumentException("true == db.IsDisposed");
  84.  
  85.       // -------------------
  86.       List ids = new List();
  87.       // Entity items can be located in the BlockTableRecord instances
  88.       // only.
  89.       using (Db.Transaction tr = db.TransactionManager.StartTransaction()
  90.           )
  91.       {
  92.         Db.BlockTable bt = tr.GetObject(db.BlockTableId,
  93.             Db.OpenMode.ForRead) as Db.BlockTable;
  94.  
  95.         // Skip erased BlockTableRecord instances.
  96.         IEnumerable btrIds = bt.Cast()
  97.             .Where(n => !n.IsErased);
  98.  
  99.         foreach (Db.ObjectId btrId in btrIds)
  100.         {
  101.           Db.BlockTableRecord btr = tr.GetObject(btrId,
  102.               Db.OpenMode.ForRead) as Db.BlockTableRecord;
  103.           foreach (Db.ObjectId id in btr)
  104.           {
  105.             if (filter(id))
  106.             {
  107.               ids.Add(id);
  108.             }
  109.           }
  110.         }
  111.         tr.Commit();
  112.       }
  113.       return ids.ToArray();
  114.     }
  115.  
  116.     public static Db.ObjectId[] ExplodeProxyEntity(Db.ObjectId proxyEntityId, out Boolean handOverTo_called, out Int64 explodedCount, WriteMessage writeErrorMessage)
  117.     {
  118.  
  119.       // Check arguments
  120.       if (null == proxyEntityId)
  121.         throw new ArgumentException("null == proxyEntityId");
  122.       if (proxyEntityId.IsErased)
  123.         throw new ArgumentException("true == proxyEntityId.IsErased");
  124.       if (null == proxyEntityId.Database)
  125.         throw new ArgumentException("null == proxyEntityId.Database");
  126.       if (proxyEntityId.Database.IsDisposed)
  127.         throw new ArgumentException(
  128.             "true == proxyEntityId.Database.IsDisposed");
  129.       if (!proxyEntityId.ObjectClass.IsDerivedFrom(proxyEntityRXType))
  130.         throw new ArgumentException("false == proxyEntityId." +
  131.             "ObjectClass.IsDerivedFrom(proxyEntityRXType)");
  132.  
  133.       explodedCount = 0;
  134.       // -------------------
  135.       using (Db.DBObjectCollection newDBObjects =
  136.           new Db.DBObjectCollection())
  137.       {
  138.         Db.Database db = proxyEntityId.Database;
  139.  
  140.         List result = new List();
  141.  
  142.         using (Db.Transaction tr = db.TransactionManager
  143.             .StartOpenCloseTransaction())
  144.         {
  145.           Db.ProxyEntity proxyEntity = tr.GetObject(
  146.               proxyEntityId, Db.OpenMode.ForWrite, false, true)
  147.               as Db.ProxyEntity;
  148.  
  149.           if (proxyEntity.GraphicsMetafileType ==
  150.               Db.GraphicsMetafileType.FullGraphics)
  151.           {
  152.             try
  153.             {
  154.               proxyEntity.Explode(newDBObjects);
  155.               ++explodedCount;
  156.             }
  157.             catch (Exception ex)
  158.             {
  159. #if !DEBUG
  160.               writeErrorMessage(              "ObjectId: {0}. Error message: {1}\n",              proxyEntity.ObjectId, ex.Message);
  161. #endif
  162.             }
  163.           }
  164.           else if (proxyEntity.GraphicsMetafileType == Db.GraphicsMetafileType.BoundingBox)
  165.           {
  166.  
  167.             Db.Extents3d ext = proxyEntity.GeometricExtents;
  168.             Gm.Point3dCollection arr = new Gm.Point3dCollection();
  169.  
  170.             arr.Add(ext.MinPoint);
  171.             arr.Add(new Gm.Point3d(ext.MinPoint.X, ext.MaxPoint.Y, ext.MinPoint.Z));
  172.             arr.Add(new Gm.Point3d(ext.MaxPoint.X, ext.MaxPoint.Y, ext.MinPoint.Z));
  173.             arr.Add(new Gm.Point3d(ext.MaxPoint.X, ext.MinPoint.Y, ext.MinPoint.Z));
  174.  
  175.             Db.Polyline3d pline = new Db.Polyline3d(
  176.                 Db.Poly3dType.SimplePoly, arr, true);
  177.  
  178.             pline.LayerId = proxyEntity.LayerId;
  179.             pline.LinetypeId = proxyEntity.LinetypeId;
  180.             pline.Color = proxyEntity.Color;
  181.  
  182.             newDBObjects.Add(pline);
  183.           }
  184.  
  185.           Db.BlockTableRecord btr = tr.GetObject(
  186.               proxyEntity.BlockId, Db.OpenMode.ForWrite, false)
  187.               as Db.BlockTableRecord;
  188.  
  189.           // ----------------
  190.           Boolean canBeErased = (proxyEntity.ProxyFlags & 0x1) != 0;
  191.  
  192.           if (canBeErased)
  193.           {
  194.             proxyEntity.Erase();
  195.             handOverTo_called = false;
  196.           }
  197.           else
  198.           {
  199.             using (Db.Line tmp = new Db.Line())
  200.             {
  201.               proxyEntity.HandOverTo(tmp, false, false);
  202.               tmp.Erase();
  203.               proxyEntity.Dispose();
  204.               handOverTo_called = true;
  205.             }
  206.           }
  207.  
  208.           if (newDBObjects.Count > 0)
  209.           {
  210.             foreach (Db.DBObject item in newDBObjects)
  211.             {
  212.               if (item is Db.Entity)
  213.               {
  214.                 Db.Entity _ent = item as Db.Entity;
  215.                 btr.AppendEntity(_ent);
  216.                 tr.AddNewlyCreatedDBObject(item, true);
  217.                 result.Add(item.ObjectId);
  218.               }
  219.             }
  220.           }
  221.           Db.ObjectIdCollection idsRef =
  222.               btr.GetBlockReferenceIds(true, true);
  223.           foreach (Db.ObjectId id in idsRef)
  224.           {
  225.             Db.BlockReference br = tr.GetObject(id,
  226.                 Db.OpenMode.ForWrite, false)
  227.                 as Db.BlockReference;
  228.             br.RecordGraphicsModified(true);
  229.           }
  230.           tr.Commit();
  231.         }
  232.         return result.ToArray();
  233.       }
  234.     }
  235.  
  236.     public static void RemoveDBObject(Db.ObjectId id, out Boolean handOverTo_called)
  237.     {
  238.  
  239.       // Check arguments
  240.       if (null == id)
  241.         throw new ArgumentException("null == id");
  242.       if (id.IsErased)
  243.         throw new ArgumentException("true == id.IsErased");
  244.       if (null == id.Database)
  245.         throw new ArgumentException("null == id.Database");
  246.       if (id.Database.IsDisposed)
  247.         throw new ArgumentException("true == id.Database.IsDisposed");
  248.  
  249.       // -------------------
  250.       Db.Database db = id.Database;
  251.  
  252.       using (Db.Transaction tr = db.TransactionManager
  253.           .StartOpenCloseTransaction())
  254.       {
  255.         Db.DBObject obj = tr.GetObject(id, Db.OpenMode.ForWrite, false,
  256.             true);
  257.         EraseDBObject(obj, out handOverTo_called);
  258.         tr.Commit();
  259.       }
  260.     }
  261.  
  262.     private static void EraseDBObject(Db.DBObject obj, out Boolean handOverTo_called)
  263.     {
  264.  
  265.       // Check argument
  266.       if (null == obj)
  267.         throw new ArgumentNullException("null == obj");
  268.       if (obj.IsErased)
  269.         throw new ArgumentException("true == obj.IsErased");
  270.       if (obj.IsDisposed)
  271.         throw new ArgumentException("true == obj.IsDisposed");
  272.       if (null == obj.Database)
  273.         throw new ArgumentException("null == obj.Database");
  274.       if (obj.Database.IsDisposed)
  275.         throw new ArgumentException("true == obj.Database.IsDisposed");
  276.  
  277.       // ----------------
  278.       Boolean canBeErased = true;
  279.  
  280.       // AcDbProxyEntity::kEraseAllowed = 0x1
  281.       if (obj is Db.ProxyObject)
  282.       {
  283.         Db.ProxyObject proxy = obj as Db.ProxyObject;
  284.         canBeErased = (proxy.ProxyFlags & 0x1) != 0;
  285.       }
  286.       else if (obj is Db.ProxyEntity)
  287.       {
  288.         Db.ProxyEntity proxy = obj as Db.ProxyEntity;
  289.         canBeErased = (proxy.ProxyFlags & 0x1) != 0;
  290.       }
  291.  
  292.       if (canBeErased)
  293.       {
  294.         obj.Erase(true);
  295.         handOverTo_called = false;
  296.       }
  297.       else
  298.       {
  299.         using (Db.DBObject tmp = obj is Db.Entity ?
  300.             (Db.DBObject)new Db.Line() : new Db.DBDictionary())
  301.         {
  302.           obj.HandOverTo(tmp, false, false);
  303.           tmp.Erase(true);
  304.           obj.Dispose();
  305.           handOverTo_called = true;
  306.         }
  307.       }
  308.     }
  309.  
  310.     public static Db.ObjectId[] GetFreeAnnotativeScaleIds(this Db.Database db)
  311.     {
  312.       // Check argument
  313.       if (null == db)
  314.         throw new ArgumentNullException("null == db");
  315.       if (db.IsDisposed)
  316.         throw new ArgumentException("true == db.IsDisposed");
  317.       // ----------------
  318.       using (Db.ObjectIdCollection ids = new Db.ObjectIdCollection())
  319.       {
  320.         Db.ObjectContextManager ocMng = db.ObjectContextManager;
  321.         if (null != ocMng)
  322.         {
  323.           Db.ObjectContextCollection ocItems =
  324.           ocMng.GetContextCollection("ACDB_ANNOTATIONSCALES");
  325.           if (null != ocItems)
  326.           {
  327.             foreach (Db.ObjectContext item in ocItems)
  328.             {
  329.               // This check is necessary for BricsCAD older
  330.               // than v15.1.02:
  331.               if (item is Db.AnnotationScale && String.Compare(
  332.                   item.Name, db.Cannoscale.Name) != 0)
  333.               {
  334.  
  335.                 ids.Add(new Db.ObjectId(item.UniqueIdentifier)
  336.                     );
  337.               }
  338.             }
  339.             db.Purge(ids);
  340.           }
  341.         }
  342.         return ids.Cast().Where(n => !n.IsErased
  343.         && !n.IsEffectivelyErased).ToArray();
  344.       }
  345.     }
  346.  
  347.     public static void RemoveFreeAnnotativeScales(this Db.Database db)
  348.     {
  349.  
  350.       // Check argument
  351.       if (null == db)
  352.         throw new ArgumentNullException("null == db");
  353.       if (db.IsDisposed)
  354.         throw new ArgumentException("true == db.IsDisposed");
  355.  
  356.       // -----------------
  357.       Db.ObjectId[] ids = db.GetFreeAnnotativeScaleIds();
  358.  
  359.       using (Db.Transaction tr = db.TransactionManager.StartTransaction()
  360.           )
  361.       {
  362.         foreach (Db.ObjectId id in ids)
  363.         {
  364.           try
  365.           {
  366.             Db.DBObject obj = tr.GetObject(id, Db.OpenMode
  367.                 .ForWrite, false);
  368.             obj.Erase();
  369.           }
  370.           catch { }
  371.         }
  372.         tr.Commit();
  373.       }
  374.     }
  375.   }
  376.  
  377.   public static class ProxyFunctionality
  378.   {
  379.     public static void Proxy_ShowInfo()
  380.     {
  381.  
  382.       Ap.Document doc = cad.DocumentManager.MdiActiveDocument;
  383.       if (null == doc)
  384.         return;
  385.  
  386.       Ed.Editor ed = doc.Editor;
  387.       Db.Database db = doc.Database;
  388.  
  389.       using (doc.LockDocument())
  390.       {
  391.         // Proxy types
  392.         Rt.RXClass proxyObjectRXType = Rt.RXClass.GetClass(typeof(Db.ProxyObject));
  393.         Rt.RXClass proxyEntityRXType = Rt.RXClass.GetClass(typeof(Db.ProxyEntity));
  394.  
  395.         // Filters
  396.         Func proxyEntityFilter = n => !n.IsErased && !n.IsEffectivelyErased && n.ObjectClass.IsDerivedFrom(proxyEntityRXType);
  397.  
  398.         Func proxyObjectFilter = n => !n.IsErased && !n.IsEffectivelyErased && n.ObjectClass.IsDerivedFrom(proxyObjectRXType);
  399.  
  400.         // Filtered ids
  401.         Db.ObjectId[] proxyEntityIds = db.GetEntityIds(proxyEntityFilter);
  402.         Db.ObjectId[] proxyObjectIds = db.GetDBObjectIds(proxyObjectFilter);
  403.         ed.WriteMessage("{0} ProxyEntity and {1} ProxyObject items found.\n", proxyEntityIds.Length.ToString(), proxyObjectIds.Length.ToString());
  404.       }
  405.     }
  406.  
  407.     public static void Proxy_ExplodeAllProxyEntities(Boolean ShowReport)
  408.     {
  409.  
  410.       Ap.Document doc = cad.DocumentManager.MdiActiveDocument;
  411.       if (null == doc)
  412.         return;
  413.  
  414.       Ed.Editor ed = doc.Editor;
  415.       Db.Database db = doc.Database;
  416.  
  417.       using (doc.LockDocument())
  418.       {
  419.         Rt.RXClass proxyEntityRXType = Rt.RXClass.GetClass(typeof(Db.ProxyEntity));
  420.  
  421.         Func proxyEntityFilter = n => !n.IsErased && !n.IsEffectivelyErased && n.ObjectClass.IsDerivedFrom(proxyEntityRXType);
  422.  
  423.         Db.ObjectId[] proxyEntityIds = db.GetEntityIds(proxyEntityFilter);
  424.  
  425.         Int64 newEntityCount = 0;
  426.         Int64 handOverTo_entity_count = 0;
  427.         Int64 explodedCount = 0;
  428.  
  429.         foreach (Db.ObjectId id in proxyEntityIds)
  430.         {
  431.           Boolean handOverTo_called = false;
  432.           Int64 tmp_explodedCount = 0;
  433.           Db.ObjectId[] newEntityIds = gunipcProxy.ExtensionMethods.ExplodeProxyEntity(id, out handOverTo_called, out tmp_explodedCount, ed.WriteMessage);
  434.           newEntityCount += newEntityIds.Length;
  435.           explodedCount += tmp_explodedCount;
  436.  
  437.           if (handOverTo_called)
  438.             ++handOverTo_entity_count;
  439.         }
  440.  
  441.         try
  442.         {
  443.           /* Remove erased objects from memory.
  444.            * An exception occurs if erasedIds contain ids which was
  445.            * removed from memory already. There is no method to check
  446.            * it in advance. */
  447.           Db.ObjectId[] erasedIds = db.GetDBObjectIds(n => n.IsErased
  448.               );
  449.  
  450.           /* This checking is neccessary, bacause if erasedIds
  451.            * .Length == 0 we get an exception in the
  452.            * ObjectIdCollection initialization. */
  453.           if (erasedIds.Length > 0)
  454.           {
  455.             using (Db.ObjectIdCollection ids =
  456.                 new Db.ObjectIdCollection(erasedIds))
  457.             {
  458.               db.ReclaimMemoryFromErasedObjects(ids);
  459.             }
  460.           }
  461.         }
  462.         catch {/* nothing here */ }
  463.         if (ShowReport)
  464.         {
  465.           ed.WriteMessage("{0} ProxyEntity items found.\n", proxyEntityIds.Length.ToString());
  466.           ed.WriteMessage("{0} ProxyEntity items exloded.\n", explodedCount);
  467.           ed.WriteMessage("{0} new DBObjects created.\n", newEntityCount.ToString());
  468.           ed.WriteMessage("Count of 'HandOverTo' operations: {0}.\n", handOverTo_entity_count.ToString());
  469.           ed.WriteMessage("Run the _AUDIT command with the _Y option, " + "please.\n");
  470.         }
  471.       }
  472.     }
  473.  
  474.     public static void Proxy_RemoveAllProxyObjests(Boolean ShowReport)
  475.     {
  476.  
  477.       Ap.Document doc = cad.DocumentManager.MdiActiveDocument;
  478.       if (null == doc)
  479.         return;
  480.  
  481.       Ed.Editor ed = doc.Editor;
  482.       Db.Database db = doc.Database;
  483.  
  484.       using (doc.LockDocument())
  485.       {
  486.         Rt.RXClass proxyObjectRXType = Rt.RXClass.GetClass(typeof(
  487.         Db.ProxyObject));
  488.         Rt.RXClass proxyEntityRXType = Rt.RXClass.GetClass(typeof(
  489.             Db.ProxyEntity));
  490.  
  491.         Func proxyObjectFilter = n => !n.IsErased && !n.IsEffectivelyErased && n.ObjectClass.IsDerivedFrom(proxyObjectRXType);
  492.         Func proxyEntityFilter = n => !n.IsErased && !n.IsEffectivelyErased && n.ObjectClass.IsDerivedFrom(proxyEntityRXType);
  493.  
  494.         Db.ObjectId[] proxyObjectIds = db.GetDBObjectIds(proxyObjectFilter);
  495.         Db.ObjectId[] proxyEntityIds = db.GetEntityIds(proxyEntityFilter);
  496.  
  497.         Int64 handOverTo_object_count = 0;
  498.         Int64 handOverTo_entity_count = 0;
  499.  
  500.         foreach (Db.ObjectId id in proxyObjectIds)
  501.         {
  502.           Boolean handOverTo_called = false;
  503.           gunipcProxy.ExtensionMethods.RemoveDBObject(id, out handOverTo_called);
  504.           if (handOverTo_called)
  505.             ++handOverTo_object_count;
  506.         }
  507.         if (ShowReport)
  508.         {
  509.           ed.WriteMessage("{0} ProxyObject items found and removed.\n", proxyObjectIds.Length.ToString());
  510.           ed.WriteMessage("Count of 'HandOverTo' operations: {0}.\n\n", handOverTo_object_count.ToString());
  511.         }
  512.  
  513.         foreach (Db.ObjectId id in proxyEntityIds)
  514.         {
  515.           Boolean handOverTo_called = false;
  516.           gunipcProxy.ExtensionMethods.RemoveDBObject(id, out handOverTo_called);
  517.           if (handOverTo_called)
  518.             ++handOverTo_entity_count;
  519.         }
  520.  
  521.         try
  522.         {
  523.           /* Remove erased objects from memory.
  524.            * An exception occurs if erasedIds contain ids which was
  525.            * removed from memory already. There is no method to check
  526.            * it in advance. */
  527.           Db.ObjectId[] erasedIds = db.GetDBObjectIds(n => n.IsErased
  528.               );
  529.  
  530.           /* This checking is neccessary, bacause if erasedIds
  531.            * .Length == 0 we get an exception in the
  532.            * ObjectIdCollection initialization. */
  533.           if (erasedIds.Length > 0)
  534.           {
  535.             using (Db.ObjectIdCollection ids = new Db.ObjectIdCollection(erasedIds))
  536.             {
  537.               db.ReclaimMemoryFromErasedObjects(ids);
  538.             }
  539.           }
  540.         }
  541.         catch {/* nothing here */ }
  542.         if (ShowReport)
  543.         {
  544.           ed.WriteMessage("{0} ProxyEntity items found and removed.\n", proxyEntityIds.Length.ToString());
  545.           ed.WriteMessage("Count of 'HandOverTo' operations: {0}.\n\n", handOverTo_entity_count.ToString());
  546.           ed.WriteMessage("Run the _AUDIT command with the _Y option, " + "please.\n");
  547.         }
  548.       }
  549.     }
  550.   }
  551. }
ZIP-архив с кодом ProxyFunctionality можно скачать здесь

Ну и обертки: команды и лисп-функции
Код - C#: [Выделить]
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. using Autodesk.AutoCAD.ApplicationServices;
  7. using Autodesk.AutoCAD.DatabaseServices;
  8. using Autodesk.AutoCAD.EditorInput;
  9. using Autodesk.AutoCAD.Runtime;
  10. using Autodesk.AutoCAD.Geometry;
  11.  
  12. // [assembly: Rt.CommandClass(typeof(gunipcProxy.ProxyCommands))]
  13.  
  14. namespace gunipcProxy
  15. {
  16.  
  17.   public class ProxyCommands
  18.   {
  19.     [CommandMethod("gu_ProxyInfo", CommandFlags.Modal)]
  20.     public static void cmd_ProxyShow()
  21.     { gunipcProxy.ProxyFunctionality.Proxy_ShowInfo(); }
  22.  
  23.     [LispFunction("gunipc_ProxyInfo")]
  24.     public static ResultBuffer lisp_ProxyShow()
  25.     { gunipcProxy.ProxyFunctionality.Proxy_ShowInfo(); return null; }
  26.  
  27.     [CommandMethod("gu_ProxyExplode", CommandFlags.Modal)]
  28.     public static void cmd_ProxyExplode()
  29.     { gunipcProxy.ProxyFunctionality.Proxy_ExplodeAllProxyEntities(true); }
  30.  
  31.     [LispFunction("gunipc_ProxyExplode")]
  32.     public static ResultBuffer lisp_ProxyExplode()
  33.     { gunipcProxy.ProxyFunctionality.Proxy_ExplodeAllProxyEntities(true); return null; }
  34.  
  35.     [CommandMethod("gu_ProxyRemove", CommandFlags.Modal)]
  36.     public static void cmd_ProxyRemove()
  37.     { gunipcProxy.ProxyFunctionality.Proxy_RemoveAllProxyObjests(true); }
  38.  
  39.     [LispFunction("gunipc_ProxyRemove")]
  40.     public static ResultBuffer lisp_ProxyRemove()
  41.     { gunipcProxy.ProxyFunctionality.Proxy_RemoveAllProxyObjests(true); return null; }
  42.  
  43.     [CommandMethod("gu_ProxyClear", CommandFlags.Modal)]
  44.     public static void cmd_ProxyClear()
  45.     {
  46.       gunipcProxy.ProxyFunctionality.Proxy_ExplodeAllProxyEntities(false);
  47.       gunipcProxy.ProxyFunctionality.Proxy_RemoveAllProxyObjests(true);
  48.     }
  49.  
  50.     [LispFunction("gunipc_ProxyClear")]
  51.     public static ResultBuffer lisp_ProxyClear(ResultBuffer buffer)
  52.     {
  53.       gunipcProxy.ProxyFunctionality.Proxy_ExplodeAllProxyEntities(false);
  54.       gunipcProxy.ProxyFunctionality.Proxy_RemoveAllProxyObjests(false); return null;
  55.     }
  56.   }
  57. }
Опять же, ZIP-архив с исходником здесь

Автор: Алексей Кулик. На основе материалов сайта Андрея Бушмана и статьи на autolisp.ru.

Обсуждение: http://adn-cis.org/forum/index.php?topic=1830

Опубликовано 04.02.2015
Отредактировано 04.02.2015 в 09:48:18