Drive AutoCAD with Code

Saturday, August 11, 2012

Creating Linked Entities with DrawJig

In AutoCAD discussion group's .NET forum, an user asked how to create linked objects (see here). I suggested that Jig, TransientGraphics and/or Overrule could be considered as the solution. I was thinking then to give it a try myself, but did not have time to actually write some code. However, this topic kept hanging on somewhere in my mind: what would I do if I were facing this task? So, I finally squeeze some time to sit down doing something with it, hence this post.

Let assume some requirement of this task, which may not be the same as the question raised in the AutoCAD discussion group. Say, user wants to use AutoCAD to draw a simple diagram, a kind of flow chart, which includes circles and lines. Let's also assume that a circle can be linked to one or more other circles by lines.

Drawing circles and lines would be very simple with AutoCAD. But what if user wants to move a drawn circle in the flow chart that is linked to other circles? It would be ideal that all lines that link to this moving circle from other circles and all lines that link to other circles from this moving circle would follow the move. So to user, it looks like the lines and circles are physically linked.

Now we can see that the only thing we need to deal with is when user want to change the existing flow chart by moving a node, represented by a circle, around, but still keep the links between nodes, represented by lines. To me, it sounds a lot like a jig. So, I decided to give jig a try.

Now I saw these tasks ahead of me:

Make a circle be aware of which line is connected to it from other circle and which line is connected to other circle from itself;
A line is used to connect only 2 circles, and knows which 2 circles it is connected.
Create a custom "MOVE" command for user to move circles in the flow chart
To make things simple, if user wants to change link between circles, he/she simply remove the link and recreate the link between any 2 circles

I decided to attach XData to the circles and linking lines to let the circles and lines be aware of which circles/lines it is linked to/from. Therefore my coding begins with an XData manipulation utility class. Here is it:

Code Snippet

using System;
using System.Collections.Generic;
using System.Text;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
 
namespace LinkedObjects
{
    public class LinkInfoXDataUtil
    {
        private const string OBJECT_LINK_APP = "MyNameSpace.LinkObjects";
 
        public static void SetLink(Database db, 
            ObjectId fromCircleId, ObjectId toCircleId, ObjectId linkLineId)
        {
            ObjectLinkAppExists(db, true);
 
            using (Transaction tran = 
                db.TransactionManager.StartTransaction())
            {
                Entity fromCircle = (Entity)tran.GetObject(
                    fromCircleId, OpenMode.ForWrite);
                Entity toCircle = (Entity)tran.GetObject(
                    toCircleId, OpenMode.ForWrite);
                Entity line = (Entity)tran.GetObject(
                    linkLineId, OpenMode.ForWrite);
 
                AddFromLinkToCircle(fromCircle, line.Handle.ToString());
                AddToLinkToCircle(toCircle, line.Handle.ToString());
                AddLinksToLine(line, 
                    fromCircle.Handle.ToString(), 
                    toCircle.Handle.ToString());
 
                tran.Commit();
            }
        }
 
        public static void RemoveLink(Database db, ObjectId linkLineId)
        {
            using (Transaction tran = 
                db.TransactionManager.StartTransaction())
            {
                Entity line = (Entity)tran.GetObject(
                    linkLineId, OpenMode.ForWrite);
 
                ObjectId fromCircleId;
                ObjectId toCircleId;
                GetLinkedCirclesFromLine(
                    db, tran, line, out fromCircleId, out toCircleId);
 
                Entity fromCircle = (Entity)tran.GetObject(
                    fromCircleId, OpenMode.ForWrite);
                Entity toCircle = (Entity)tran.GetObject(
                    toCircleId, OpenMode.ForWrite);
 
                //Remove line's handle from XData in circles
                RemoveFromLinkFromCircle(fromCircle, line.Handle.ToString());
                RemoveToLinkFromCircle(toCircle, line.Handle.ToString());
 
                //Clear Xdata from the line
                TypedValue[] vals = new TypedValue[] 
                { 
                    new TypedValue(
                        (Int16)DxfCode.ExtendedDataRegAppName, OBJECT_LINK_APP) 
                };
                ResultBuffer buffer = new ResultBuffer(vals);
                line.XData = buffer;
 
                tran.Commit();
            }
        }
 
        public static void GetCirleLink(Database db, ObjectId circleId, 
            out List<ObjectId> fromLineIds, out List<ObjectId> toLineIds)
        {
            fromLineIds = new List<ObjectId>();
            toLineIds = new List<ObjectId>();
 
            if (circleId.ObjectClass.DxfName.ToUpper() == "CIRCLE")
            {
                using (Transaction tran = 
                    circleId.Database.TransactionManager.StartTransaction())
                {
                    Entity ent = (Entity)tran.GetObject(
                        circleId, OpenMode.ForRead);
 
                    ResultBuffer buffer = 
                        ent.GetXDataForApplication(OBJECT_LINK_APP);
                    if (buffer == null) return;
 
                    TypedValue[] vals = buffer.AsArray();
                    if (vals.Length == 3)
                    {
                        string handles;
 
                        //Get lines started from this circle
                        handles = vals[1].Value.ToString();
                        if (handles.Length > 0)
                        {
                            string[] hs = handles.Split('|');
                            foreach (string h in hs)
                            {
                                fromLineIds.Add(HandleToObjectId(db, h));
                            }
                        }
 
                        //Get lines pointing to this circle
                        handles = vals[2].Value.ToString();
                        if (handles.Length > 0)
                        {
                            string[] hs = handles.Split('|');
                            foreach (string h in hs)
                            {
                                toLineIds.Add(HandleToObjectId(db, h));
                            }
                        }
                    }
                    else
                    {
                        //Clear inavlid XData
                        TypedValue[] vs = new TypedValue[]
                        {
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataRegAppName,
                                OBJECT_LINK_APP)
                        };
                        ent.UpgradeOpen();
                        ent.XData = new ResultBuffer(vs);
                    }
 
                    tran.Commit();
                }
            }
        }
 
        public static void GetLineLink(Database db, ObjectId lineId, 
            out ObjectId fromCircleId, out ObjectId toCircleId)
        {
            fromCircleId = ObjectId.Null;
            toCircleId = ObjectId.Null;
 
            if (lineId.ObjectClass.DxfName.ToUpper() == "LINE")
            {
                using (Transaction tran = 
                    lineId.Database.TransactionManager.StartTransaction())
                {
                    Entity ent = (Entity)tran.GetObject(
                        lineId, OpenMode.ForRead);
                    ResultBuffer buffer = 
                        ent.GetXDataForApplication(OBJECT_LINK_APP);
                    if (buffer == null) return;
 
                    TypedValue[] vals = buffer.AsArray();
                    if (vals.Length == 3)
                    {
                        string handle;
 
                        //FROM circle
                        handle = vals[1].Value.ToString();
                        if (handle.Length > 0) 
                            fromCircleId = HandleToObjectId(db, handle);
 
                        //TO circle
                        handle = vals[2].Value.ToString();
                        if (handle.Length > 0) 
                            toCircleId = HandleToObjectId(db, handle);
                    }
 
                    tran.Commit();
                }
            }
        }
 
        public static void GetLinkedCircleCentres(Database db, ObjectId linkLineId, 
            out Point3d fromCircleCentre, out Point3d toCircleCentre)
        {
            ObjectId fromCircleId;
            ObjectId toCircleId;
 
            GetLineLink(db, linkLineId, out fromCircleId, out toCircleId);
 
            fromCircleCentre = CommonUtil.GetCircleCentre(db, fromCircleId);
            toCircleCentre = CommonUtil.GetCircleCentre(db, toCircleId);
        }
 
        #region private methoids
 
        private static bool ObjectLinkAppExists(Database db, bool create)
        {
            bool exists = false;
            using (Transaction tran = 
                db.TransactionManager.StartTransaction())
            {
                RegAppTable appTable = (RegAppTable)tran.GetObject(
                    db.RegAppTableId, OpenMode.ForRead);
 
                if (appTable.Has(OBJECT_LINK_APP))
                    exists = true;
                else
                {
                    if (create)
                    {
                        RegAppTableRecord appRec = new RegAppTableRecord();
                        appRec.Name = OBJECT_LINK_APP;
                        appTable.UpgradeOpen();
                        appTable.Add(appRec);
                        tran.AddNewlyCreatedDBObject(appRec, true);
                        exists = true;
                    }
                }
 
                tran.Commit();
            }
 
                return exists;
        }
 
        private static ObjectId HandleToObjectId(
            Database db, string handleString)
        {
            ObjectId id = ObjectId.Null;
 
            id = db.GetObjectId(false, 
                new Handle(Int64.Parse(handleString, 
                    System.Globalization.NumberStyles.AllowHexSpecifier)), 0);
 
            return id;
        }
 
        private static void AddFromLinkToCircle(Entity fromEnt, string handle)
        {
            ResultBuffer buffer = 
                fromEnt.GetXDataForApplication(OBJECT_LINK_APP);
            TypedValue[] vals;
 
            string newHandles = "";
            string existingHandles = "";
            string toHandles = "";
 
            if (buffer != null)
            {
                vals = buffer.AsArray();
                existingHandles = vals[1].Value.ToString();
                toHandles = vals[2].Value.ToString();
            }
 
            bool exists = false;
            if (existingHandles.Length > 0)
            {
                string[] hs = existingHandles.Split('|');
                foreach (string h in hs)
                {
                    if (h.ToUpper() == handle.ToUpper())
                    {
                        exists = true;
                        break;
                    }
                }
 
                if (!exists)
                    newHandles = existingHandles + "|" + handle;
                else
                    newHandles = existingHandles;
            }
            else
            {
                newHandles = handle;
            }
 
            vals = new TypedValue[] 
            { 
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataRegAppName, OBJECT_LINK_APP),
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataAsciiString, newHandles),
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataAsciiString, toHandles)
            };
 
            fromEnt.XData = new ResultBuffer(vals);
        }
 
        private static void AddToLinkToCircle(Entity toEnt, string handle)
        {
            ResultBuffer buffer = 
                toEnt.GetXDataForApplication(OBJECT_LINK_APP);
            TypedValue[] vals;
 
            string newHandles = "";
            string existingHandles = "";
            string fromHandles = "";
 
            if (buffer != null)
            {
                vals = buffer.AsArray();
 
                existingHandles = vals[2].Value.ToString();
                fromHandles = vals[1].Value.ToString();
            }
 
            bool exists = false;
            if (existingHandles.Length > 0)
            {
                string[] hs = existingHandles.Split('|');
                foreach (string h in hs)
                {
                    if (h.ToUpper() == handle.ToUpper())
                    {
                        exists = true;
                        break;
                    }
                }
 
                if (!exists)
                    newHandles = existingHandles + "|" + handle;
                else
                    newHandles = existingHandles;
            }
            else
            {
                newHandles = handle;
            }
 
            vals = new TypedValue[] 
            { 
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataRegAppName, OBJECT_LINK_APP),
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataAsciiString, fromHandles),
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataAsciiString, newHandles)
            };
 
            toEnt.XData = new ResultBuffer(vals);
        }
 
        private static void AddLinksToLine(
            Entity line, string fromHandle, string toHandle)
        {
            TypedValue[] vals = new TypedValue[] 
            { 
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataRegAppName, OBJECT_LINK_APP),
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataAsciiString, fromHandle),
                new TypedValue(
                    (Int16)DxfCode.ExtendedDataAsciiString, toHandle)
            };
 
            line.XData = new ResultBuffer(vals);
        }
 
        private static void GetLinkedCirclesFromLine(
            Database db, Transaction tran, Entity line,
            out ObjectId fromCircleId, out ObjectId toCircleId)
        {
            fromCircleId = ObjectId.Null;
            toCircleId = ObjectId.Null;
 
            ResultBuffer buffer = 
                line.GetXDataForApplication(OBJECT_LINK_APP);
            if (buffer != null)
            {
                TypedValue[] vals = buffer.AsArray();
 
                string handleString;
 
                handleString = vals[1].Value.ToString();
                fromCircleId = HandleToObjectId(db, handleString);
 
                handleString = vals[2].Value.ToString();
                toCircleId = HandleToObjectId(db, handleString);
            }
        }
 
        private static void RemoveFromLinkFromCircle(
            Entity fromCircle, string lineHandle)
        {
            ResultBuffer buffer = 
                fromCircle.GetXDataForApplication(OBJECT_LINK_APP);
            if (buffer == null) return;
 
            TypedValue[] vals = buffer.AsArray();
            string fromHandles = vals[1].Value.ToString();
            string toHandles = vals[2].Value.ToString();
            if (fromHandles.Length > 0)
            {
                StringBuilder newHandles = new StringBuilder();
                bool removed = false;
 
                //rebuild the handles string with 
                //targeted handle striing being excluded
                string[] hs = fromHandles.Split('|');
                foreach (string h in hs)
                {
                    if (h.ToUpper() != lineHandle.ToUpper())
                    {
                        newHandles.Append(h + "|");
                    }
                    else
                    {
                        removed = true;
                    }
                }
 
                if (removed)
                {
                    //remove the trailing "|"
                    if (newHandles.ToString().EndsWith("|"))
                    {
                        newHandles.Length = newHandles.Length - 1;
                    }
 
                    //recreate XData
                    if (newHandles.Length == 0 && toHandles.Length == 0)
                    {
                        vals = new TypedValue[] 
                            { 
                                new TypedValue(
                                (Int16)DxfCode.ExtendedDataRegAppName,
                                OBJECT_LINK_APP) 
                            };
                    }
                    else
                    {
                        vals = new TypedValue[] 
                        { 
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataRegAppName, 
                                OBJECT_LINK_APP),
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataAsciiString, 
                                newHandles.ToString()),
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataAsciiString, 
                                toHandles)
                        };
                    }
 
                    fromCircle.XData = new ResultBuffer(vals);
                }
            }
        }
 
        private static void RemoveToLinkFromCircle(
            Entity toCircle, string lineHandle)
        {
            ResultBuffer buffer = 
                toCircle.GetXDataForApplication(OBJECT_LINK_APP);
            if (buffer == null) return;
 
            TypedValue[] vals = buffer.AsArray();
            string fromHandles = vals[1].Value.ToString();
            string toHandles = vals[2].Value.ToString();
            if (toHandles.Length > 0)
            {
                StringBuilder newHandles = new StringBuilder();
                bool removed = false;
 
                //rebuild the handles string with 
                //targeted handle striing being excluded
                string[] hs = toHandles.Split('|');
                foreach (string h in hs)
                {
                    if (h.ToUpper() != lineHandle.ToUpper())
                    {
                        newHandles.Append(h + "|");
                    }
                    else
                    {
                        removed = true;
                    }
                }
 
                if (removed)
                {
                    //remove the trailing "|"
                    if (newHandles.ToString().EndsWith("|"))
                    {
                        newHandles.Length = newHandles.Length - 1;
                    }
 
                    //recreate XData
                    if (newHandles.Length == 0 && fromHandles.Length == 0)
                    {
                        vals = new TypedValue[] 
                            { 
                                new TypedValue(
                                (Int16)DxfCode.ExtendedDataRegAppName,
                                OBJECT_LINK_APP) 
                            };
                    }
                    else
                    {
                        vals = new TypedValue[] 
                        { 
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataRegAppName, 
                                OBJECT_LINK_APP),
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataAsciiString, 
                                fromHandles),
                            new TypedValue(
                                (Int16)DxfCode.ExtendedDataAsciiString, 
                                newHandles.ToString())
                        };
                    }
 
                    toCircle.XData = new ResultBuffer(vals);
                }
            }
        }
 
        #endregion
    }
}

In order to organize my code in a bit cleaner structure, I place most generic AutoCAD operation used in this project in an AutoCAD utility class CommonUtil:

Code Snippet

using System;
using System.Collections.Generic;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
 
namespace LinkedObjects
{
    public class CommonUtil
    {
        public static void PrintCancelMessage(string message = "")
        {
            Editor ed = 
                Application.DocumentManager.MdiActiveDocument.Editor;
 
            if (!string.IsNullOrEmpty(message))
            {
                ed.WriteMessage("\n" + message);
            }
            ed.WriteMessage("\n*Cancel*");
            Autodesk.AutoCAD.Internal.Utils.PostCommandPrompt();
        }
 
        public static bool PickEntity(Editor ed, Type entType, 
            string optionMessage, string rejectMessage, out ObjectId entId)
        {
            entId = ObjectId.Null;
 
            PromptEntityOptions opt = new PromptEntityOptions(optionMessage);
            opt.SetRejectMessage(rejectMessage);
            opt.AddAllowedClass(entType, true);
 
            PromptEntityResult res = ed.GetEntity(opt);
            if (res.Status == PromptStatus.OK)
            {
                entId = res.ObjectId;
                return true;
            }
 
            return false;
        }
 
        public static ObjectId DrawLineBetweenCircles(
            Database db, ObjectId fromCircleId, ObjectId toCircleId)
        {
            ObjectId lineId = ObjectId.Null;
 
            using (Transaction tran = 
                db.TransactionManager.StartTransaction())
            {
                Circle fromCircle = (Circle)tran.GetObject(
                    fromCircleId, OpenMode.ForRead);
                Circle toCircle = (Circle)tran.GetObject(
                    toCircleId, OpenMode.ForRead);
 
                ObjectId modelId = 
                    SymbolUtilityServices.GetBlockModelSpaceId(db);
                BlockTableRecord model = (BlockTableRecord)tran.GetObject(
                    modelId, OpenMode.ForWrite);
 
                using (Line line = 
                    new Line(fromCircle.Center, toCircle.Center))
                {
                    //Change startpoint/endpoint from 
                    //circle's center to circle's perimeter
                    Point3d pt;
 
                    pt = line.GetPointAtDist(fromCircle.Radius);
                    line.StartPoint = pt;
 
                    double dist=line.Length-toCircle.Radius;
                    pt = line.GetPointAtDist(dist);
                    line.EndPoint = pt;
 
                    line.SetDatabaseDefaults(db);
 
                    lineId = model.AppendEntity(line);
                    tran.AddNewlyCreatedDBObject(line, true);
 
                    tran.Commit();
                }
            }
 
            return lineId;
        }
 
        public static void EraseEntity(Database db, ObjectId entId)
        {
            using (Transaction tran = db.TransactionManager.StartTransaction())
            {
                Entity ent = (Entity)tran.GetObject(entId, OpenMode.ForWrite);
                ent.Erase(true);
 
                tran.Commit();
            }
        }
 
        public static Point3d GetCircleCentre(Database db, ObjectId circleId)
        {
            Point3d pt = new Point3d();
 
            using (Transaction tran = db.TransactionManager.StartTransaction())
            {
                Circle c = tran.GetObject(circleId, OpenMode.ForRead) as Circle;
                if (c != null)
                    pt = c.Center;
                else
                    throw new ArgumentException("Entity is not a circle.");
 
                tran.Commit();
            }
 
            return pt;
        }
 
        public static void HighlightEntities(
            Database db, List<ObjectId> entIds, bool highlight)
        {
            using (Transaction tran = 
                db.TransactionManager.StartTransaction())
            {
                foreach (var id in entIds)
                {
                    Entity ent = (Entity)tran.GetObject(id, OpenMode.ForWrite);
 
                    if (highlight)
                        ent.Highlight();
                    else
                        ent.Unhighlight();
                }
 
                tran.Commit();
            }
        }
    }
}

With all required Xdata and AutoCAD manipulation tool available, I was ready to create the Jig. Here are what I wanted to achieve:

When user picks the circle to move, the circle and all lines linking from/to it would be highlighted
When user moves mouse cursor, a set of ghost circle and the lines move with the mouse cursor
After user picks the moving destination point, the select circle is moved to user selected point, and all lines that link from/to this circle will be modified of their start/end points, so that they would start/end properly with the moved circle and still linked to/from other circles

Here is the Jig class:

Code Snippet

using System.Collections.Generic;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsInterface;
 
namespace LinkedObjects
{
    public class LinkedCircleJig : DrawJig
    {
        private Document _dwg;
        private Editor _ed;
        private Database _db;
        private ObjectId _circleId;
        private List<ObjectId> _fromLineIds;
        private List<ObjectId> _toLineIds;
        private Point3d _basePoint;
        private Point3d _currentPoint;
        private Point3d _prevPoint;
        private bool _cancelled = false;
 
        private Circle _visualCircle = null;
        private List<Line> _fromVisualLines = new List<Line>();
        private List<Line> _toVisualLines = new List<Line>();
        private int _visualColorIndex = 1;
 
        public LinkedCircleJig(Document dwg, ObjectId circleId)
        {
            _dwg = dwg;
            _ed = dwg.Editor;
            _db = dwg.Database;
 
            _circleId = circleId;
            LinkInfoXDataUtil.GetCirleLink(
                _db, _circleId, out _fromLineIds, out _toLineIds);
 
            _basePoint = CommonUtil.GetCircleCentre(_db, circleId);
        }
 
        public void DragLinkedCircle()
        {
            _cancelled = false;
 
            try
            {
                CreateVisualEntities();
 
                _currentPoint = _basePoint;
                _prevPoint = _basePoint;
 
                HighlightEntities(true);
 
                _ed.Drag(this);
 
                if (!_cancelled)
                {
                    using (Transaction tran = 
                        _db.TransactionManager.StartTransaction())
                    {
                        //Move circle
                        Vector3d displacement =
                        _basePoint.GetVectorTo(_currentPoint);
 
                        Circle c = (Circle)tran.GetObject(
                            _circleId, OpenMode.ForWrite);
                        c.TransformBy(
                            Matrix3d.Displacement(displacement));
 
                        ObjectId fCircleId;
                        ObjectId tCircleId;
                        
                        Point3d pt;
                        double dist;
 
                        //update FROM lines
                        foreach (var id in _fromLineIds)
                        {
                            Line l = (Line)tran.GetObject(
                                id, OpenMode.ForWrite);
 
                            //get its TO circle
                            LinkInfoXDataUtil.GetLineLink(
                                _db, id, out fCircleId, out tCircleId);
 
                            Circle tCircle = (Circle)tran.GetObject(
                                tCircleId, OpenMode.ForRead);
 
                            l.StartPoint = c.Center;
                            l.EndPoint = tCircle.Center;
 
                            //Shrink line's length
                            pt = l.GetPointAtDist(c.Radius);
                            l.StartPoint = pt;
 
                            dist = l.Length - tCircle.Radius;
                            pt = l.GetPointAtDist(dist);
                            l.EndPoint = pt;
                        }
 
                        //Update TO lines
                        foreach (var id in _toLineIds)
                        {
                            Line l = (Line)tran.GetObject(
                                id, OpenMode.ForWrite);
 
                            //get its TO circle
                            LinkInfoXDataUtil.GetLineLink(
                                _db, id, out fCircleId, out tCircleId);
 
                            Circle fCircle = (Circle)tran.GetObject(
                                fCircleId, OpenMode.ForRead);
 
                            l.StartPoint = fCircle.Center;
                            l.EndPoint = c.Center;
 
                            //Shrink line's length
                            pt = l.GetPointAtDist(fCircle.Radius);
                            l.StartPoint = pt;
 
                            dist = l.Length - c.Radius;
                            pt = l.GetPointAtDist(dist);
                            l.EndPoint = pt;
                        }
 
                        tran.Commit();
                    }
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                HighlightEntities(false);
                DisposeVisualEntities();
            }
        }
 
        #region Jig method overrides
        
        protected override bool WorldDraw(WorldDraw draw)
        {
            draw.Geometry.Draw(_visualCircle);
 
            foreach (var e in _fromVisualLines)
                draw.Geometry.Draw(e);
 
            foreach (var e in _toVisualLines)
                draw.Geometry.Draw(e);
 
            return true;
        }
 
        protected override SamplerStatus Sampler(JigPrompts prompts)
        {
            JigPromptPointOptions jigOpt =
                new JigPromptPointOptions();
 
            jigOpt.UserInputControls = 
                UserInputControls.Accept3dCoordinates |
                UserInputControls.NoZeroResponseAccepted | 
                UserInputControls.NoDwgLimitsChecking;
            jigOpt.BasePoint = _basePoint;
            jigOpt.UseBasePoint = true;
            jigOpt.Cursor = CursorType.RubberBand;
            jigOpt.Message = "\nMove the linked circle to picked point: ";
 
            PromptPointResult res = prompts.AcquirePoint(jigOpt);
 
            if (res.Status == PromptStatus.Cancel)
            {
                return SamplerStatus.Cancel;
            }
            else
            {
                _currentPoint = res.Value;
 
                if (_currentPoint == _prevPoint)
                    return SamplerStatus.NoChange;
                else
                {
                    //Update location of visual circle
                    Vector3d displacement = 
                        _prevPoint.GetVectorTo(_currentPoint);
 
                    _visualCircle.TransformBy(
                        Matrix3d.Displacement(displacement));
 
                    //Update each FROM visual line
                    foreach (var l in _fromVisualLines)
                    {
                        l.StartPoint = _currentPoint;
                    }
 
                    //Update each TO visual line
                    foreach (var l in _toVisualLines)
                    {
                        l.EndPoint = _currentPoint;
                    }
 
                    _prevPoint = _currentPoint;
                    return SamplerStatus.OK;
                }
            }
        }
 
        #endregion
 
        #region private methods
 
        private void CreateVisualEntities()
        {
            using (Transaction tran = 
                _db.TransactionManager.StartTransaction())
            {
                //Create visual Circle
                Circle c = (Circle)tran.GetObject(
                    _circleId, OpenMode.ForRead);
                _visualCircle = c.Clone() as Circle;
                _visualCircle.SetDatabaseDefaults(_db);
                _visualCircle.ColorIndex = _visualColorIndex;
 
                Point3d fromPt;
                Point3d toPt;
 
                //Create FROM lines
                foreach (var id in _fromLineIds)
                {
                    Line l = (Line)tran.GetObject(id, OpenMode.ForRead);
 
                    Line vLine = l.Clone() as Line;
                    vLine.SetDatabaseDefaults(_db);
                    vLine.ColorIndex = _visualColorIndex;
 
                    //Stretch the line to FROM/TO circles' centre points
                    LinkInfoXDataUtil.GetLinkedCircleCentres(
                        _db, id, out fromPt, out toPt);
 
                    vLine.StartPoint = fromPt;
                    vLine.EndPoint = toPt;
 
                    _fromVisualLines.Add(vLine);
                }
 
                //Create TO lines
                foreach (var id in _toLineIds)
                {
                    Line l = (Line)tran.GetObject(id, OpenMode.ForRead);
 
                    Line vLine = l.Clone() as Line;
                    vLine.SetDatabaseDefaults(_db);
                    vLine.ColorIndex = _visualColorIndex;
 
                    //Stretch the line to FROM/TO circles' centre points
                    LinkInfoXDataUtil.GetLinkedCircleCentres(
                        _db, id, out fromPt, out toPt);
 
                    vLine.StartPoint = fromPt;
                    vLine.EndPoint = toPt;
 
                    _toVisualLines.Add(vLine);
                }
            }
        }
 
        private void HighlightEntities(bool highlight)
        {
            List<ObjectId> ents = new List<ObjectId>();
            ents.Add(_circleId);
            ents.AddRange(_fromLineIds);
            ents.AddRange(_toLineIds);
 
            CommonUtil.HighlightEntities(_db, ents, highlight);
        }
 
        private void DisposeVisualEntities()
        {
            if (_visualCircle != null)
            {
                _visualCircle.Dispose();
                _visualCircle = null;
            }
 
            foreach (var ent in _fromVisualLines)
                ent.Dispose();
 
            _fromVisualLines.Clear();
 
            foreach (var ent in _toVisualLines)
                ent.Dispose();
 
            _toVisualLines.Clear();
        } 
 
        #endregion
    }
}

Finally, with all the required functionality available in the classes, it is time to put them together, which leads to another class ObjectLinker:

Code Snippet

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
 
namespace LinkedObjects
{
    public class ObjectLinker
    {
        private Document _dwg;
        private Database _db;
        private Editor _ed;
 
        public ObjectLinker(Document dwg)
        {
            _dwg = dwg;
            _db = dwg.Database;
            _ed = _dwg.Editor;
        }
 
        //The method does not check whether there is already
        //an existing linking line between the two circles
        public bool AddLinkBetweenCircles()
        {
            //Pick linking circle
            ObjectId fromCircleId;
            if (!CommonUtil.PickEntity(_ed, typeof(Circle),
                "\nPick a circle (or press any key to exit): ", 
                "Not a circle!", out fromCircleId))
            {
                CommonUtil.PrintCancelMessage();
                return false;
            }
 
            //pick circle to be linked
            ObjectId toCircleId;
            if (!CommonUtil.PickEntity(_ed, typeof(Circle), 
                "\nPick a circle (or press any key to exit): ", 
                "Not a circle!", out toCircleId))
            {
                CommonUtil.PrintCancelMessage();
                return false;
            }
 
            //Draw line between the circles
            ObjectId lineId = CommonUtil.DrawLineBetweenCircles(
                _db, fromCircleId, toCircleId);
 
            //Set link XData
            LinkInfoXDataUtil.SetLink(_db, fromCircleId, toCircleId, lineId);
 
            _ed.WriteMessage(
                "\nLink between the 2 picked circles has been established.");
 
            return true;
        }
 
        public void RemoveLinkBetweenCircles(bool eraseLineEntity)
        {
            //Pick line
            ObjectId lineId;
            if (!CommonUtil.PickEntity(_ed, typeof(Line),
                "\nPick linking line: ", "Not a line!", out lineId))
            {
                CommonUtil.PrintCancelMessage();
                return;
            }
 
            LinkInfoXDataUtil.RemoveLink(_db, lineId);
 
            if (eraseLineEntity)
            {
                CommonUtil.EraseEntity(_db, lineId);
            }
        }
 
        public void MoveCircle()
        {
            //Pick a linked circle
            PromptEntityOptions opt = new 
                PromptEntityOptions("\nPick a linked circle:");
            opt.SetRejectMessage("Invalid pick: must be a circle.");
            opt.AddAllowedClass(typeof(Circle), true);
            PromptEntityResult res = _ed.GetEntity(opt);
            if (res.Status == PromptStatus.OK)
            {
                LinkedCircleJig jig = new LinkedCircleJig(_dwg, res.ObjectId);
                jig.DragLinkedCircle();
            }
        }
    }
}

By now, the only thing left is to create commands for users to do what they want:

Code Snippet

using System;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
 
[assembly: CommandClass(typeof(LinkedObjects.MyCommands))]
 
namespace LinkedObjects
{
    public class MyCommands
    {
        private ObjectLinker linker = null;
 
        [CommandMethod("LinkMyCircles")]
        public void LinkCircles()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
 
            if (linker == null) linker = new ObjectLinker(dwg);
 
            try
            {
                while (true)
                {
                    if (!linker.AddLinkBetweenCircles())
                        break;
                }
            }
            catch (System.Exception ex)
            {
                CommonUtil.PrintCancelMessage(ex.Message);
            }
        }
 
        [CommandMethod("MoveMyCircle")]
        public void MoveLinkedCircle()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
 
            if (linker == null) linker = new ObjectLinker(dwg);
 
            try
            {
                linker.MoveCircle();
            }
            catch (System.Exception ex)
            {
                CommonUtil.PrintCancelMessage(ex.Message);
            }
        }
 
        [CommandMethod("DelinkMyCircle")]
        public void DelinkCircles()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
 
            if (linker == null) linker = new ObjectLinker(dwg);
 
            try
            {
                linker.RemoveLinkBetweenCircles(true);
            }
            catch (System.Exception ex)
            {
                CommonUtil.PrintCancelMessage(ex.Message);
            }
        }
    }
}

This a quite long post with a lot of code in order to demonstrate a workable operation. I did not try my best effort to make the code more as concise as it could be. As usual, I created a video clip here to show the code in action.
Some points of interest:

I could have used a polyline to link 2 circles, so that I can make a segment of the polyline to look like an arrow to indicate the direction of the link. I could have also used DrawableOverrule to make the linking like to show an arrow
As I commented in the code, I did not check a link between 2 circles has already existed before adding link
It is obvious that standard AutoCAD editing commands, such as MOVE/RORATE/STRETCH...could easily destroy the links visually. Here is when ObjectOverrule could help. One of my previous post here can be used to prevent linked circles/lines from being changed. I might post an update to this post to incorporate the ObjectOverrule into this project later, if I can manage some time available.

Bug Fix Update:

There is a bug in class LinkedCircleJig: following code should be added between line 173 and 174:

_cancel=true;

Wednesday, June 6, 2012

Conditionally Replace a Command with a Custom One

Very often we create our own custom command via macro script, lisp, VBA, ... to let AutoCAD do things in the way we desire. Sometimes, we even want to redefine an existing command, so that the same command would do thing differently. For example, we may want the "SAVE" command always zoom the current view to its extents before saving. It is quite easy to redefine an existing command with a lisp routine (defun C:cmdName()...). If "cmdName" in the lisp routine is the same as any AutoCAD built-in command name, once the lisp routine is loaded, the AutoCAD built-in command would be replaced by the one defined in the lisp routine. There may also be cases that we only want to run an alternative command instead of AutoCAD build-in command under certain condition. That is, when a standard command is issued, we want a process starts to check if certain condition is met. If yes, currently issued command is stopped and an alternative command runs; otherwise, the standard command continues.

In this post, I demonstrate a way to run an alternative command in the place of standard command under certain condition(s), using .NET API.

The ApplicationServices.DocumentCollection class exposes 2 events that can be used for this purpose: DocumentLockModeChanged and DocumentLockModeChangeVetoed. That is, whenever a command is issued in AutoCAD, DocumentLockModeChanged event is fired. The DocumentLockModeChanged event handler also allows the command that causes the DocumentLockModeChanged event to be vetoed. Subsequently, if the command being vetoed (more precisely speaking, the DocumentLockModeChange being vetoed), DocumentLockModeChangeVetoed event fires, which provides us an opportunity to do something else by handling this event.

In order to generalize the way to deal with using multiple custom commands that would replace standard commands under different conditions, I define an interface like this:

Code Snippet

namespace RunAlternativeCommand
{
    public enum CommandComparisonOption
    {
        CommandNameEquals=0,
        CommandNameContains=1,
    }
 
    public interface IAlternativeCommandOption
    {
        string[] TargetCommand { get; }
        CommandComparisonOption ComparisonOption { get; }
        string AlternativeCommand { get; }
        bool PickFirstRequired { get; }
        bool AlternativeCommandApplied();
    }
}

Following are 2 classes that implement the interface.

Class "AlternativeSaveCommandOption". It vetoes command "SAVE" and "QSAVE" in certain condition, and run a custom command. The condition can be anything as user needs. For example, if a specific title block exists in a drawing (assuming the title block is only inserted when the drafting work has been completed) and/or a particular attribute of the title block has been set, we want the title block to be updated with data from external data source whenever the drawing is saved. Here is the code:

Code Snippet

namespace RunAlternativeCommand
{  
    public class AlternativeSaveCommandOption 
        : IAlternativeCommandOption
    {
        private string[] _tagetCommand;
        private string _alternativeCommand;
 
        public AlternativeSaveCommandOption(string altCmd)
        {
            _tagetCommand = new string[]
            {
                "SAVE", "QSAVE"
            };
            _alternativeCommand = altCmd;
        }
 
        #region IAlternativeCommandOption Members
 
        public string[] TargetCommand
        {
            get { return _tagetCommand; }
        }
 
        public CommandComparisonOption ComparisonOption
        {
            get { return CommandComparisonOption.CommandNameContains; }
        }
 
        public string AlternativeCommand
        {
            get { return _alternativeCommand; }
        }
 
        public bool AlternativeCommandApplied()
        {
            //Check the drawing to see if we want to run alternative saving.
            //For example, we can check if a particular title block has been
            //inserted or its particular attribute has been set. If yes, 
            //we want to use alternative saving process to
            // 1. update the title block with data from external data source
            // 2. save the drawing.
 
            return true;
        }
 
        public bool PickFirstRequired
        {
            get { return true; }
        }
 
        #endregion
    }  
}

Class "AlternativeRorateLineCommandOption". The condition for it to veto the built-in "ROTATE" command is when "ROTATE" command is issued against a pre-selected LINE entity (i.e. PickFirst mode is enabled). Here is the code:

Code Snippet

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.DatabaseServices;
 
namespace RunAlternativeCommand
{
    public class AlternativeRotateLineCommandOption 
        : IAlternativeCommandOption 
    {
        private string[] _tagetCommand;
        private string _alternativeCommand;
 
        public AlternativeRotateLineCommandOption(string altCmd)
        {
            _tagetCommand = new string[] { "ROTATE" };
            _alternativeCommand = altCmd;
        }
 
        #region IAlternativeCommandOption Members
 
        public string[] TargetCommand
        {
            get { return _tagetCommand; }
        }
 
        public CommandComparisonOption ComparisonOption
        {
            get { return CommandComparisonOption.CommandNameEquals; }
        }
 
        public string AlternativeCommand
        {
            get { return _alternativeCommand; }
        }
 
        public bool AlternativeCommandApplied()
        {
            //Since PickFirst is required, 
            //test if there is implied SelectionSet
            ObjectIdCollection selectedIds = GetImpliedSelectionSet();
 
            if (selectedIds.Count > 0)
            {
                foreach (ObjectId id in selectedIds)
                {
                    //If the selected entities include LINE
                    //then the alternative command applies
                    if (id.ObjectClass.DxfName.ToUpper() == "LINE")
                    {
                        return true;
                    }
                }
            }
            return false;
        }
 
        public bool PickFirstRequired
        {
            get { return true; }
        }
 
        #endregion
 
        #region private methods
 
        private ObjectIdCollection GetImpliedSelectionSet()
        {
            Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
 
            PromptSelectionResult res = ed.SelectImplied();
 
            if (res.Status == PromptStatus.OK)
            {
                return new ObjectIdCollection(res.Value.GetObjectIds());
            }
 
            return new ObjectIdCollection();
        }
 
        #endregion
    }
}

We can have define as many classes that implement the interface "IAlternativeCommandOption" as we need to target different existing/built-in commands. The implementation of AlternativeCommandApplied() method allows us to set condition(s) so that the method would return true/false as desired.

Here are 2 custom commands that would be used in place when built-in commands being vetoed:

Code Snippet

using System;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
 
[assembly: CommandClass(typeof(RunAlternativeCommand.AlternativeCommands))]
 
namespace RunAlternativeCommand
{
    public class AlternativeCommands
    {
        #region RotateLine alternative command
        
        [CommandMethod("RotateLine",CommandFlags.UsePickSet)]
        public static void MyRotateLineCommand()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
 
            PromptSelectionResult res = ed.SelectImplied();
            if (res.Status != PromptStatus.OK) return;
 
            ObjectId[] ids = res.Value.GetObjectIds();
 
            using (Transaction tran = 
                dwg.Database.TransactionManager.StartTransaction())
            {
                RotateLines(ids, tran);
 
                tran.Commit();
            }
        }
 
        private static void RotateLines(ObjectId[] entIds, Transaction tran)
        {
            foreach (ObjectId id in entIds)
            {
                Line line = tran.GetObject(id, OpenMode.ForWrite) as Line;
                if (line != null)
                {
                    RotateLine(line);
                }
            }
        }
 
        private static void RotateLine(Line line)
        {
            //Do whatever we want. For example, we rotate line 90 degree 
            //with its start point as rotating base point
            Point3d pt = line.StartPoint;
            Matrix3d mt = Matrix3d.Rotation(Math.PI / 2, Vector3d.ZAxis, pt);
            line.TransformBy(mt);
        }
 
        #endregion
 
        #region Save alternative command
 
        [CommandMethod("SaveTB")]
        public static void DoMySave()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
 
            ed.WriteMessage(
                "\nSearching for title block...");
            ed.WriteMessage(
                "\nRetrieving title block information from database...");
            ed.WriteMessage("\nUpdate title block...");
            ed.WriteMessage("\nSaving current drawing...");
 
            //Finally, save the drawing
            dwg.Database.SaveAs(dwg.Name, DwgVersion.Current);
 
            ed.WriteMessage("\nDrawing is saved by custom saving process!\n");
        }
 
        #endregion
    }
}

Finally I implement the IExtensionApplication interface to put everything together into work:

Code Snippet

using System.Collections.Generic;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
 
[assembly: ExtensionApplication(typeof(
    RunAlternativeCommand.AlternativeCommandInitializer))]
 
namespace RunAlternativeCommand
{
    public class AlternativeCommandInitializer : 
        IExtensionApplication 
    {
        private static DocumentCollection docs;
        private List<IAlternativeCommandOption> _altCmds;
        private bool _runAltCmd = false;
        private string _altCmdName = "";
        private string _dwgName = "";
 
        public void Initialize()
        {
            //Initialize alternative commands
            InitializeAltCmds();
 
            //Add event handlers to intercept commands 
            //so that particular command can be vetoed
            //and alternative command can be run, instead.
            docs = Application.DocumentManager;
 
            docs.DocumentLockModeChanged += 
                new DocumentLockModeChangedEventHandler(
                docs_DocumentLockModeChanged);
 
            docs.DocumentLockModeChangeVetoed += 
                new DocumentLockModeChangeVetoedEventHandler(
                    docs_DocumentLockModeChangeVetoed);
 
            docs.MdiActiveDocument.Editor.WriteMessage(
                "\nAlternative commands loaded\n");
        }
 
        public void Terminate()
        {
            
        }
 
        #region initialize alternative commands
        
        private void InitializeAltCmds()
        {
            _altCmds = new List<IAlternativeCommandOption>();
 
            AddAltRotateLineCommand();
            AddAltSaveCommand();
        }
 
        private void AddAltRotateLineCommand()
        {
            AlternativeRotateLineCommandOption opt =
                new AlternativeRotateLineCommandOption("RotateLine");
 
            _altCmds.Add(opt);
        }
 
        private void AddAltSaveCommand()
        {
            AlternativeSaveCommandOption opt =
                new AlternativeSaveCommandOption("SaveTB");
 
            _altCmds.Add(opt);
        }
 
        #endregion
 
        #region Handle DocumentLockModeChanged/DocumentLockModeChangeVetoed
 
        private void docs_DocumentLockModeChangeVetoed(object sender,
            DocumentLockModeChangeVetoedEventArgs e)
        {
            if (!_runAltCmd || !_dwgName.Equals(
                e.Document.Name,
                System.StringComparison.InvariantCultureIgnoreCase))
                return;
 
            //run alternative command
            Document doc = Application.DocumentManager.MdiActiveDocument;
 
            if (!string.IsNullOrEmpty(_altCmdName))
            {
                doc.SendStringToExecute(
                    _altCmdName + " ", true, false, true);
            }
 
            _runAltCmd = false;
        }
 
        private void docs_DocumentLockModeChanged(object sender,
            DocumentLockModeChangedEventArgs e)
        {
            //Check lock mode first
            if (e.CurrentMode != DocumentLockMode.Write &&
                e.CurrentMode!=DocumentLockMode.ExclusiveWrite) return;
 
            _runAltCmd = false;
            _dwgName = e.Document.Name;
 
            //Loop through alternative command options
            //to see if any alternative command is set to 
            //replace current command
            foreach (var cmdOpt in _altCmds)
            {
                bool match = false;
 
                CommandComparisonOption comp = cmdOpt.ComparisonOption;
                
                foreach (var opt in cmdOpt.TargetCommand)
                {
                    switch (comp)
                    {
                        case CommandComparisonOption.CommandNameContains:
                            if (e.GlobalCommandName.ToUpper().
                                Contains(opt.ToUpper()) && 
                                e.GlobalCommandName.ToUpper()!=
                                cmdOpt.AlternativeCommand.ToUpper())
                            {
                                match = true;
                            }
                            break;
                        default:
                            if (e.GlobalCommandName.ToUpper() 
                                == opt.ToUpper() &&
                                e.GlobalCommandName.ToUpper()!=
                                cmdOpt.AlternativeCommand.ToUpper())
                            {
                                match = true;
                            }
                            break;
                    }
 
                    if (match) break;
                }
 
                //When the current command is a targeted command
                if (match)
                {
                    //If the condition is met
                    if (cmdOpt.AlternativeCommandApplied())
                    {
                        //Veto to current command and set 
                        //the alternative command to be run
                        _altCmdName = cmdOpt.AlternativeCommand;
                        _runAltCmd = true;
 
                        e.Veto();
                        return;
                    }
                }
            }
        }
 
        #endregion
    }
}

Compile the code the load it into AutoCAD. let's try out the ROTATE command against one or more LINE entity or entities. If the ROTATE command is issued with LINE entity or entities being pre-selected, we can see the custom command "RotateLine" runs instead of standard ROTATE command. However, if no LINE entity is pre-selected, ROTATE command proceeds as usual.

Try SAVE/QSAVE command would always trigger custom SAVETB command, because I did not have code to check condition(s) in AlternativeCommandApplied(0 method and it always return "true".

With the code structure showing here, it would be very easy to add more custom commands as conditional alternatives to existing commands: simply create new class that implements IAlternativeCommandOption and corresponding command methods, and then add them into the List collection of the class AlternativeCommandInitializer.

Monday, March 19, 2012

Using ObjectOverrule To Prevent Entity Being Changed

Kean Walmsley has a post on using ObjectOverrule to prevent entity being erased. The solution is surprisingly simple: simply throw an Exception in the overridden Erase() method of the ObjectOverrule. Well, it simple only someone (Kean Walmsley and Stephen Preston) let you know that you can do this.
Well, it turns out that we can do the same thing in ObjectOverrule.Open() method to prevent entity being changed.
Here I show some code first and then discuss some interesting issues with this approach.

Let's assume some scenario: a drawing has a particular block inserted, say, a title block with certain attribute. Once the block is inserted and its attribute value is set, we do not want user to change it at all; or it should only be changed programmatically so the attribute value would be kept in sync with data in CAD data source, such as enterprise production database. In my code, the ObjectOverrule will be only applicable to a BlockReference entity if the block reference has an attribute tagged as "ABC".

Here is the code of the ObjectOverrule:

Code Snippet

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
 
namespace EntityModifiedOverrule
{
    public class EntChangeVetoOverrule : ObjectOverrule
    {
        private static EntChangeVetoOverrule _instance = null;
        private bool _overruling;
 
        private EntChangeVetoOverrule()
        {
            _overruling = Overrule.Overruling;
        }
 
        public static EntChangeVetoOverrule Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new EntChangeVetoOverrule();
 
                return _instance;
            }
        }
 
        public void StartOverrule()
        {
            Overrule.AddOverrule(RXClass.GetClass(
                typeof(BlockReference)), this, false);
            Overrule.Overruling = true;
 
            //This is required in order for
            //overridden IsApplicable() being used
            //as custom overrule filter
            this.SetCustomFilter();
        }
 
        public void StopOverrule()
        {
            Overrule.RemoveOverrule(
                RXClass.GetClass(typeof(BlockReference)), this);
            Overrule.Overruling = _overruling;
        }
 
        #region override virtue methods
 
        public override bool IsApplicable(RXObject overruledSubject)
        {
            BlockReference bref = overruledSubject as BlockReference;
 
            if (bref == null)
                return false;
            else
            {
                bool isTarget = false;
                using (Transaction tran = bref.Database.
                    TransactionManager.StartOpenCloseTransaction())
                {
                    foreach (ObjectId id in bref.AttributeCollection)
                    {
                        var attr = (AttributeReference)tran.GetObject(
                            id, OpenMode.ForRead);
                        if (attr.Tag.ToUpper() == "ABC")
                        {
                            isTarget = true;
                            break;
                        }
                    }
 
                    tran.Commit();
                }
 
                return isTarget;
            }
        }
 
        public override void Open(DBObject dbObject, OpenMode mode)
        {
            Editor ed = 
                Application.DocumentManager.MdiActiveDocument.Editor;
 
            if (mode == OpenMode.ForWrite)
            {
                ed.WriteMessage("\nEntity open for writing: {0}. Denied!", 
                    dbObject.GetType().Name);
                throw new Autodesk.AutoCAD.Runtime.Exception(
                    ErrorStatus.NotApplicable);
            }
            else
            {
                base.Open(dbObject, mode);
            }
        }
 
        #endregion
    }
}

Here is the code to turn the ObjectOverrule on or off:

Code Snippet

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
 
[assembly: CommandClass(typeof(EntityModifiedOverrule.MyCommands))]
 
namespace EntityModifiedOverrule
{
    class MyCommands 
    {
        private static bool _myOverruleOn = false;
 
        [CommandMethod("MyOV")]
        public static void MyCmd()
        {
            Document doc = Autodesk.AutoCAD.ApplicationServices.
                Application.DocumentManager.MdiActiveDocument;
            Editor ed = doc.Editor;
 
            if (!_myOverruleOn)
            {
                EntChangeVetoOverrule.Instance.StartOverrule();
                ed.WriteMessage("\nVeto Entity Modifying Overrule is on\n");
                _myOverruleOn = true;
            }
            else
            {
                EntChangeVetoOverrule.Instance.StopOverrule();
                ed.WriteMessage("\nVeto Entity Modifying Overrule is off\n");
                _myOverruleOn = false;
            }
        }
    }
}

The IsApplicable() method is used as custom filter for this ObjectOverrule. In my code, it makes sure the Overrule only applies to a block reference that has an attribute with tag being "ABC". Obviously, one can override IsApplicable method with whatever suitable logic to filter out desirable targeting entities to apply custom Overrule.
As one would notice, in the overridden Open() method, I test the OpenMode parameter, and only when the Open method is called in "ForWrite" mode, an Exception is thrown, which effectively aborted the call to Open(), thus, prevent the entity being modified. The the Exception's construction, I use ErrorStatus.NotApplicable as the constructor's argument, but it can be any other ErrorStatus enum value.

When running the code, I can see, the block can be selected/highlighted, its information shows correctly in the property window. Trying to change something with the block, such attribute value in either attribute editing window, or in property window, nothing would happen. I also cannot erase/move/rotate... the block.

However, there is one thing that is annoying me: if I try to move the block, the block is simply disappeared on the screen. Although I can tel it is still there, but not visible, until I issue "REGEN" command. Of course, the block is still there, not moved, thanks to the Overrule.

Another interesting thing I tried is place nothing in Open method but the "throw...." statement. That is, the Overrule simply prevents any sort of opening regardless the "OpenMode". In this case, the filtered entity (the block with attribute tagged with "ABC" in my case) is simply not selectable, thus, no change can be made to it. Obviously, in this case, the applicable entity will not shown up in property window (since it is not selectable), nor the usual AutoCAD tooltip and/or Quick Properties window would also not shown when the cursor hovers on the entity.

Since my code set custom filter to apply the Overrule only to BlockReference entity, there is a side-effect that may crash AutoCAD: when start AutoCAD's built-in command "INSERT". The reason of the crash, I guess, is due to the the fact that the block has attribute and the command does the process in 2 steps: first a block reference is created and added into current space; then the block reference is opened to in order to add attribute reference. It is the second steps causes the crash because the overrule prevent the block reference object from being opened. So, if you wants to use ObjectOverrule to prevent entity being modified, you need to very carefully consider all possible situations that your Overrule could result in something unintentionally. In my case, I could write my own code to insert the specific block that the Overrule applies to.

Lastly, using ObjectOverrule to prevent entity from being change could be very confusing to untrained CAD user. So, targeted users should be very well informed on this behaviour of your custom CAD tool. Also, the CAD tool with such Overrule should be very well planned as how and when the Overrule is loaded/turned on/off.

There is one thing to be aware of with this "throw an exception" in overriden Open() method approach: you cannot test if your Overrule works or not in Visual Studio's' debugging mode. When the line of code that throws the exception runs, Visual Studio treats the exception as unhandled (as it should), thus the debuggung process stops. One can only test this type of Overrule in normal AutoCAD session without Visual Studio's debugging process attached..