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

1. using Autodesk.AutoCAD.ApplicationServices;
2. using Autodesk.AutoCAD.DatabaseServices;
3. using Autodesk.AutoCAD.Runtime;
4. using Autodesk.AutoCAD.EditorInput;
5.  
6. namespace EntityModifiedOverrule
7. {
8.     public class EntChangeVetoOverrule : ObjectOverrule
9.     {
10.         private static EntChangeVetoOverrule _instance = null;
11.         private bool _overruling;
12.  
13.         private EntChangeVetoOverrule()
14.         {
15.             _overruling = Overrule.Overruling;
16.         }
17.  
18.         public static EntChangeVetoOverrule Instance
19.         {
20.             get
21.             {
22.                 if (_instance == null)
23.                     _instance = new EntChangeVetoOverrule();
24.  
25.                 return _instance;
26.             }
27.         }
28.  
29.         public void StartOverrule()
30.         {
31.             Overrule.AddOverrule(RXClass.GetClass(
32.                 typeof(BlockReference)), this, false);
33.             Overrule.Overruling = true;
34.  
35.             //This is required in order for
36.             //overridden IsApplicable() being used
37.             //as custom overrule filter
38.             this.SetCustomFilter();
39.         }
40.  
41.         public void StopOverrule()
42.         {
43.             Overrule.RemoveOverrule(
44.                 RXClass.GetClass(typeof(BlockReference)), this);
45.             Overrule.Overruling = _overruling;
46.         }
47.  
48.         #region override virtue methods
49.  
50.         public override bool IsApplicable(RXObject overruledSubject)
51.         {
52.             BlockReference bref = overruledSubject as BlockReference;
53.  
54.             if (bref == null)
55.                 return false;
56.             else
57.             {
58.                 bool isTarget = false;
59.                 using (Transaction tran = bref.Database.
60.                     TransactionManager.StartOpenCloseTransaction())
61.                 {
62.                     foreach (ObjectId id in bref.AttributeCollection)
63.                     {
64.                         var attr = (AttributeReference)tran.GetObject(
65.                             id, OpenMode.ForRead);
66.                         if (attr.Tag.ToUpper() == "ABC")
67.                         {
68.                             isTarget = true;
69.                             break;
70.                         }
71.                     }
72.  
73.                     tran.Commit();
74.                 }
75.  
76.                 return isTarget;
77.             }
78.         }
79.  
80.         public override void Open(DBObject dbObject, OpenMode mode)
81.         {
82.             Editor ed =
83.                 Application.DocumentManager.MdiActiveDocument.Editor;
84.  
85.             if (mode == OpenMode.ForWrite)
86.             {
87.                 ed.WriteMessage("\nEntity open for writing: {0}. Denied!",
88.                     dbObject.GetType().Name);
89.                 throw new Autodesk.AutoCAD.Runtime.Exception(
90.                     ErrorStatus.NotApplicable);
91.             }
92.             else
93.             {
94.                 base.Open(dbObject, mode);
95.             }
96.         }
97.  
98.         #endregion
99.     }
100. }

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

Code Snippet

1. using Autodesk.AutoCAD.ApplicationServices;
2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.EditorInput;
4.  
5. [assembly: CommandClass(typeof(EntityModifiedOverrule.MyCommands))]
6.  
7. namespace EntityModifiedOverrule
8. {
9.     class MyCommands
10.     {
11.         private static bool _myOverruleOn = false;
12.  
13.         [CommandMethod("MyOV")]
14.         public static void MyCmd()
15.         {
16.             Document doc = Autodesk.AutoCAD.ApplicationServices.
17.                 Application.DocumentManager.MdiActiveDocument;
18.             Editor ed = doc.Editor;
19.  
20.             if (!_myOverruleOn)
21.             {
22.                 EntChangeVetoOverrule.Instance.StartOverrule();
23.                 ed.WriteMessage("\nVeto Entity Modifying Overrule is on\n");
24.                 _myOverruleOn = true;
25.             }
26.             else
27.             {
28.                 EntChangeVetoOverrule.Instance.StopOverrule();
29.                 ed.WriteMessage("\nVeto Entity Modifying Overrule is off\n");
30.                 _myOverruleOn = false;
31.             }
32.         }
33.     }
34. }

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

Moving Entity Along A Curve

I have been working much less on AutoCAD these days, thus have not posted something for quite a while.

A while ago, I was asked by one of the users of the CAD tools I developed before that if it is possible to write some code so that CAD user can drag an entity along a given path. "It surely can be done", I said to the user immediately, " but I have not tried it yet" I added. I was thinking that it can be done with a DrawJig. I did not find time write some code to materialize it until now.

The idea of doing it is fairly simple: just implementing a DrawJig, and in the Jig's Sampler() method, instead of letting the entity follow the a cursor's path during dragging, we can find a point for the entity to move to in such way that the point must be on a curve (moving path). Therefore, we need a Curve entity as our moving path.

Also, since the goal is to give user visual feedback while entity is dragged and the entity moving is only to occur after the drag (should user not cancel the dragging), I use a cloned, non-database-residing entity as the visually moving part, which is disposed when the dragging is done.

Here is the class GuidedMovingJig:

Code Snippet

1. using Autodesk.AutoCAD.ApplicationServices;
2. using Autodesk.AutoCAD.DatabaseServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Geometry;
5.  
6. namespace NormJigs
7. {
8.     public class GuidedMovingJig : DrawJig
9.     {
10.         private Entity _entity=null;
11.         private Curve _curve=null;
12.         private Entity _offsetEntity = null;
13.         private Document _dwg;
14.         private Editor _ed;
15.         private Transaction _tran = null;
16.  
17.         private Point3d _originalPoint;
18.         private Point3d _previousPoint;
19.         private Point3d _currentPoint;
20.         private Point3d _finalPoint;
21.  
22.         private bool _dragCancelled = false;
23.  
24.         public GuidedMovingJig()
25.         {
26.             _dwg = Application.DocumentManager.MdiActiveDocument;
27.             _ed = _dwg.Editor;
28.         }
29.  
30.         public void DoDrag()
31.         {
32.             _dragCancelled = false;
33.  
34.             using (_tran =
35.                 _dwg.Database.TransactionManager.StartTransaction())
36.             {
37.                 if (GetEntities())
38.                 {
39.                     _entity.UpgradeOpen();
40.  
41.                     try
42.                     {
43.                         _entity.Highlight();
44.  
45.                         //Generate a clone entity as moving target
46.                         using (_offsetEntity = _entity.Clone() as Entity)
47.                         {
48.                             _offsetEntity.SetDatabaseDefaults();
49.  
50.                             //Place the moving target on guiding curve
51.                             Vector3d displacement =
52.                                 _originalPoint.GetVectorTo(_currentPoint);
53.                             _offsetEntity.TransformBy(
54.                                 Matrix3d.Displacement(displacement));
55.  
56.                             //Start drag
57.                             _ed.Drag(this);
58.                         }
59.  
60.                         //Move the entity to picked location after dragging
61.                         if (!_dragCancelled)
62.                         {
63.                             if (_finalPoint != _originalPoint)
64.                             {
65.                                 MoveEntity();
66.                             }
67.                         }
68.                     }
69.                     finally
70.                     {
71.                         //Make sure the entity is unhighlighted
72.                         _entity.Unhighlight();
73.                     }
74.                 }
75.  
76.                 _tran.Commit();
77.             }
78.         }
79.  
80.         protected override SamplerStatus Sampler(JigPrompts prompts)
81.         {
82.             JigPromptPointOptions jigOpt = new JigPromptPointOptions();
83.             jigOpt.UserInputControls =
84.                 UserInputControls.Accept3dCoordinates |
85.                 UserInputControls.NoZeroResponseAccepted |
86.                 UserInputControls.NoNegativeResponseAccepted;
87.  
88.             jigOpt.Message =
89.                 "\nMove to (pick a point or press Esc to cancel): ";
90.  
91.             PromptPointResult movePt = prompts.AcquirePoint(jigOpt);
92.  
93.             if (movePt.Status == PromptStatus.Cancel)
94.             {
95.                 _dragCancelled = true;
96.                 return SamplerStatus.Cancel;
97.             }
98.             else
99.             {
100.                 if (_previousPoint == movePt.Value)
101.                     return SamplerStatus.NoChange;
102.  
103.                 _currentPoint =
104.                     _curve.GetClosestPointTo(movePt.Value, false);
105.  
106.                 //Move the entity along the guiding curve
107.                 Vector3d displacement =
108.                     _previousPoint.GetVectorTo(_currentPoint);
109.                 _offsetEntity.TransformBy(
110.                     Matrix3d.Displacement(displacement));
111.  
112.                 _previousPoint = _currentPoint;
113.                 _finalPoint = _currentPoint;
114.  
115.                 return SamplerStatus.OK;
116.             }
117.         }
118.  
119.         protected override bool WorldDraw(
120.             Autodesk.AutoCAD.GraphicsInterface.WorldDraw draw)
121.         {
122.             draw.Geometry.Draw(_offsetEntity);
123.             return true;
124.         }
125.  
126.         #region private methods
127.  
128.         private bool GetEntities()
129.         {
130.             //Pick entity to be moved
131.             PromptEntityOptions entOpt =
132.                 new PromptEntityOptions("\nPick a moving entity: ");
133.             entOpt.SetRejectMessage(
134.                 "Invalid pick: must be AutoCAD entity.");
135.             entOpt.AddAllowedClass(typeof(Entity), false);
136.             PromptEntityResult entRes = _ed.GetEntity(entOpt);
137.             if (entRes.Status == PromptStatus.OK)
138.             {
139.                 _entity = (Entity)_tran.GetObject(
140.                     entRes.ObjectId, OpenMode.ForRead);
141.  
142.                 //Use picked point as default moving base point
143.                 Point3d pickedPt = entRes.PickedPoint;
144.  
145.                 PromptPointOptions ptOpt = new PromptPointOptions(
146.                     "\nPick moving entity's base point: <" +
147.                     pickedPt.X.ToString() + "," +
148.                     pickedPt.Y.ToString() + ">:");
149.                 ptOpt.AllowNone = true;
150.  
151.                 PromptPointResult ptRes = _ed.GetPoint(ptOpt);
152.                 if (ptRes.Status == PromptStatus.OK)
153.                 {
154.                     pickedPt = ptRes.Value;
155.                 }
156.                 else if (ptRes.Status == PromptStatus.None)
157.                 {
158.                     //Do nothing
159.                 }
160.                 else
161.                 {
162.                     return false;
163.                 }
164.  
165.                 _originalPoint = pickedPt;
166.                 
167.             }
168.             else
169.             {
170.                 return false;
171.             }
172.  
173.             //Pick guiding curve
174.             PromptEntityOptions curOpt = new PromptEntityOptions(
175.                 "\nPick a line/polyline/arc/circle as moving path: ");
176.             curOpt.SetRejectMessage(
177.                 "Invalid pick: must be a line, polyline, arc or circle.");
178.             curOpt.AddAllowedClass(typeof(Curve), false);
179.             PromptEntityResult curRes = _ed.GetEntity(curOpt);
180.             if (curRes.Status == PromptStatus.OK)
181.             {
182.                 _curve = (Curve)_tran.GetObject(
183.                     curRes.ObjectId, OpenMode.ForRead);
184.             }
185.             else
186.             {
187.                 return false;
188.             }
189.  
190.             _currentPoint =
191.                 _curve.GetClosestPointTo(_originalPoint, false);
192.             _previousPoint = _currentPoint;
193.             _finalPoint = _currentPoint;
194.  
195.             return true;
196.         }
197.  
198.         private void MoveEntity()
199.         {
200.             Vector3d displacement =
201.                 _originalPoint.GetVectorTo(_finalPoint);
202.             _entity.TransformBy(
203.                 Matrix3d.Displacement(displacement));
204.         }
205.  
206.         #endregion
207.     }
208. }

Since the code wraps all user input actions (picking moving entity and its moving base point, picking moving path), it is really simple to use GuidedMovingJig class. Here the command method to use it:

Code Snippet

1. using Autodesk.AutoCAD.ApplicationServices;
2. using Autodesk.AutoCAD.Runtime;
3. using Autodesk.AutoCAD.EditorInput;
4.  
5. [assembly: CommandClass(typeof(NormJigs.MyCommands))]
6.  
7. namespace NormJigs
8. {
9.     class MyCommands
10.     {
11.         [CommandMethod("MyMove")]
12.         public void UseMovingJig()
13.         {
14.             Document doc = Autodesk.AutoCAD.ApplicationServices.
15.                 Application.DocumentManager.MdiActiveDocument;
16.             Editor ed = doc.Editor;
17.  
18.             try
19.             {
20.                 GuidedMovingJig jig = new GuidedMovingJig();
21.                 jig.DoDrag();
22.             }
23.             catch(System.Exception ex)
24.             {
25.                 ed.WriteMessage("\nError: {0}\n", ex.Message);
26.             }
27.         }
28.     }
29. }

This video clip shows the GuidedMovingJig class in action.

Update on 20115-03-25

Recently, I saw a question in the discussion forum, asking how to do the same thing with a bit variation: the moving track is an arc (or circle, for that matter), and moving entity being dragged is also rotating when moving along the arc/circle, similar to how the moon moves around the earth. So, I thought I can fairly easy to update the code to make this Jig do that.

Here is the updated code.

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
 
namespace NormJigs
{
    public class GuidedMovingJig : DrawJig
    {
        private Entity _entity = null;
        private Curve _curve = null;
        private Entity _offsetEntity = null;
        private Document _dwg;
        private Editor _ed;
        private Transaction _tran = null;
 
        private Point3d _originalPoint;
        private Point3d _previousPoint;
        private Point3d _currentPoint;
        private double _currentAngle = 0;
        private Point3d _finalPoint;
 
        private bool _doRotation = false;
 
        private bool _dragCancelled = false;
 
        public GuidedMovingJig()
        {
            _dwg = Application.DocumentManager.MdiActiveDocument;
            _ed = _dwg.Editor;
        }
 
        public void DoDrag(bool rotateAlonhgArc = false)
        {
            _dragCancelled = false;
            
            using (_tran =
                _dwg.Database.TransactionManager.StartTransaction())
            {
                if (GetEntities())
                {
                    if ((_curve is Circle || _curve is Arc) && rotateAlonhgArc)
                    {
                        _doRotation=true;
                    }
 
                    _entity.UpgradeOpen();
 
                    try
                    {
                        _entity.Highlight();
 
                        //Generate a clone entity as moving target
                        using (_offsetEntity = _entity.Clone() as Entity)
                        {
                            _offsetEntity.SetDatabaseDefaults();
 
                            //Place the moving target on guiding curve
                            Vector3d displacement =
                                _originalPoint.GetVectorTo(_currentPoint);
                            _offsetEntity.TransformBy(
                                Matrix3d.Displacement(displacement));
 
                            //Start drag
                            _ed.Drag(this);
                        }
 
                        //Move the entity to picked location after dragging
                        if (!_dragCancelled)
                        {
                            if (_finalPoint != _originalPoint)
                            {
                                MoveEntity();
                            }
                        }
                    }
                    finally
                    {
                        //Make sure the entity is unhighlighted
                        _entity.Unhighlight();
                    }
                }
 
                _tran.Commit();
            }
        }
 
        protected override SamplerStatus Sampler(JigPrompts prompts)
        {
            JigPromptPointOptions jigOpt = new JigPromptPointOptions();
            jigOpt.UserInputControls =
                UserInputControls.Accept3dCoordinates |
                UserInputControls.NoZeroResponseAccepted |
                UserInputControls.NoNegativeResponseAccepted;
 
            jigOpt.Message =
                "\nMove to (pick a point or press Esc to cancel): ";
 
            PromptPointResult movePt = prompts.AcquirePoint(jigOpt);
 
            if (movePt.Status == PromptStatus.Cancel)
            {
                _dragCancelled = true;
                return SamplerStatus.Cancel;
            }
            else
            {
                if (_previousPoint == movePt.Value)
                    return SamplerStatus.NoChange;
 
                _currentPoint =
                    _curve.GetClosestPointTo(movePt.Value, false);
 
                //Move the entity along the guiding curve
                Vector3d displacement =
                    _previousPoint.GetVectorTo(_currentPoint);
                _offsetEntity.TransformBy(
                    Matrix3d.Displacement(displacement));
 
                //Rotate the entity, if necessary
                if (_doRotation)
                {
                    //Rotate back to original angle
                    _offsetEntity.TransformBy(
                       Matrix3d.Rotation(0.0 - _currentAngle, Vector3d.ZAxis, _currentPoint));
 
                    //Calculate rotation angle
                    double angle = GetRotationAngle();
 
                    _offsetEntity.TransformBy(
                        Matrix3d.Rotation(angle, Vector3d.ZAxis, _currentPoint));
                    _currentAngle = angle;
                }
 
                _previousPoint = _currentPoint;
                _finalPoint = _currentPoint;
 
                return SamplerStatus.OK;
            }
        }
 
        protected override bool WorldDraw(
            Autodesk.AutoCAD.GraphicsInterface.WorldDraw draw)
        {
            draw.Geometry.Draw(_offsetEntity);
            return true;
        }
 
        #region private methods
 
        private bool GetEntities()
        {
            //Pick entity to be moved
            PromptEntityOptions entOpt =
                new PromptEntityOptions("\nPick an entity to move: ");
            entOpt.SetRejectMessage(
                "Invalid pick: must be AutoCAD entity.");
            entOpt.AddAllowedClass(typeof(Entity), false);
            PromptEntityResult entRes = _ed.GetEntity(entOpt);
            if (entRes.Status == PromptStatus.OK)
            {
                _entity = (Entity)_tran.GetObject(
                    entRes.ObjectId, OpenMode.ForRead);
 
                if (_entity is BlockReference)
                {
                    _originalPoint = ((BlockReference)_entity).Position;
                }
                else
                {
                    //Use picked point as default moving base point
                    Point3d pickedPt = entRes.PickedPoint;
 
                    PromptPointOptions ptOpt = new PromptPointOptions(
                        "\nPick moving entity's base point: <" +
                        pickedPt.X.ToString() + "," +
                        pickedPt.Y.ToString() + ">:");
                    ptOpt.AllowNone = true;
 
                    PromptPointResult ptRes = _ed.GetPoint(ptOpt);
                    if (ptRes.Status == PromptStatus.OK)
                    {
                        pickedPt = ptRes.Value;
                    }
                    else if (ptRes.Status == PromptStatus.None)
                    {
                        //Do nothing
                    }
                    else
                    {
                        return false;
                    }
 
                    _originalPoint = pickedPt;
                }
            }
            else
            {
                return false;
            }
 
            //Pick guiding curve
            PromptEntityOptions curOpt = new PromptEntityOptions(
                "\nPick a line/polyline/arc/circle as moving path: ");
            curOpt.SetRejectMessage(
                "Invalid pick: must be a line, polyline, arc or circle.");
            curOpt.AddAllowedClass(typeof(Curve), false);
            PromptEntityResult curRes = _ed.GetEntity(curOpt);
            if (curRes.Status == PromptStatus.OK)
            {
                _curve = (Curve)_tran.GetObject(
                    curRes.ObjectId, OpenMode.ForRead);
            }
            else
            {
                return false;
            }
 
            _currentPoint =
                _curve.GetClosestPointTo(_originalPoint, false);
            _previousPoint = _currentPoint;
            _finalPoint = _currentPoint;
 
            return true;
        }
 
        private double GetRotationAngle()
        {
            double ang = 0.0;
 
            //Find circle/arc centre
            Point3d center = (_curve is Arc) ? ((Arc)_curve).Center : ((Circle)_curve).Center;
 
            //Calculate angle. Because of my laziness, I took this shortcut
            using (var line = new Line(center, _currentPoint))
            {
                ang = line.Angle;
            }
 
            return ang;
        }
 
        private void MoveEntity()
        {
            Vector3d displacement =
                _originalPoint.GetVectorTo(_finalPoint);
            _entity.TransformBy(
                Matrix3d.Displacement(displacement));
 
            if (_doRotation)
            {
                double angle = GetRotationAngle();
 
                _entity.TransformBy(
                    Matrix3d.Rotation(angle, Vector3d.ZAxis, _finalPoint));
            }
        }
 
        #endregion
    }
}

In the updated code, a class level member _currentAngle is added and an optional argument in the public method DoDrag() is added to indicate whether the dragged entity rotates or not when the track is an arc or a circle. Then the code in the overridden Sampler() is updated accordingly, so that the dragged entity rotates as needed.

Here is the updated command class:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.EditorInput;
 
[assembly: CommandClass(typeof(NormJigs.MyCommands))]
 
namespace NormJigs
{
    class MyCommands
    {
        [CommandMethod("MyMove")]
        public void UseMovingJig()
        {
            Document doc = Autodesk.AutoCAD.ApplicationServices.
                Application.DocumentManager.MdiActiveDocument;
            Editor ed = doc.Editor;
 
            try
            {
                GuidedMovingJig jig = new GuidedMovingJig();
                jig.DoDrag(true);
            }
            catch (System.Exception ex)
            {
                ed.WriteMessage("\nError: {0}\n", ex.Message);
            }
        }
    }
}

See this video clip for the action of the updated code.