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.

Creating My Own "Scale" Command

In certain situation when we develop our AutoCAD add-ins, using a custom command, instead of AutoCAD built-in command, might be preferred and allow our add-in to have more control to specific drafting procedures/steps.

Using DrawJig class we can quite easily to create our own commands that behave similar to, or the same way as, AutoCAD built-in commands, like Move, Copy, Scale, Stretch...

Here I show some code to create a custom "Scale" command that behaves very similar to AutoCAD built-in "Scale" command: user selects an entity, picks a base point, then moves/drags the mouse cursor until the mouse is clicked or a scale number is entered. During mouse dragging, a ghost image of the selected entity dynamically scales in or out, depending on the distance between the cursor's location and the base point.

Here is the class MyScaleJig:

Code Snippet

1. using System;
2. using Autodesk.AutoCAD.ApplicationServices;
3. using Autodesk.AutoCAD.DatabaseServices;
4. using Autodesk.AutoCAD.EditorInput;
5. using Autodesk.AutoCAD.Geometry;
6.  
7. namespace ScaleJig
8. {
9.     public class MyScaleJig : DrawJig
10.     {
11.         private Document _dwg;
12.         private Editor _ed;
13.         private Database _db;
14.  
15.         private ObjectId _entID;
16.  
17.         private Entity _entity=null;
18.         private int _colorIndex = 0;
19.         private Point3d _basePoint;
20.  
21.         private double _scale = 1.0;
22.         private bool _picked = false;
23.  
24.         public MyScaleJig(Document dwg):base()
25.         {
26.             _dwg = dwg;
27.             _ed = _dwg.Editor;
28.             _db = _dwg.Database;
29.         }
30.  
31.         public void ScaleEntity(ObjectId entID, int ghostLineColorIndex)
32.         {
33.             _entID = entID;
34.             _colorIndex = ghostLineColorIndex;
35.  
36.             //Highlight entity
37.             HighlightEntity(true);
38.  
39.             //Pick base point
40.             if (PickBasePoint())
41.             {
42.                 //Use a non-database residing
43.                 //entity for showing jig ghost line
44.                 using (_entity = GetEntityClone(_entID))
45.                 {
46.                     _ed.Drag(this);
47.                 }
48.  
49.                 //Unhighlight
50.                 HighlightEntity(false);
51.  
52.                 //Tramsform(scale) entity
53.                 //if user did not cancel the jig
54.                 if (_picked) ScaleEntity();
55.             }
56.         }
57.  
58.         #region override Jig methods
59.         
60.         protected override SamplerStatus Sampler(JigPrompts prompts)
61.         {
62.             JigPromptDistanceOptions opt = new JigPromptDistanceOptions(
63.                 "\nMove cursor to scale entity or enter scale:");
64.             opt.DefaultValue = _scale;
65.             opt.UseBasePoint = true;
66.             opt.BasePoint = _basePoint;
67.             opt.UserInputControls =
68.                 UserInputControls.Accept3dCoordinates |
69.                 UserInputControls.AcceptOtherInputString |
70.                 UserInputControls.NoNegativeResponseAccepted |
71.                 UserInputControls.NoZeroResponseAccepted |
72.                 UserInputControls.NullResponseAccepted;
73.             opt.Cursor = CursorType.RubberBand;
74.  
75.             PromptDoubleResult res = prompts.AcquireDistance(opt);
76.  
77.             SamplerStatus status;
78.  
79.             if (res.Status == PromptStatus.OK)
80.             {
81.                 double newScale = res.Value;
82.  
83.                 if (Math.Abs(_scale-newScale)<0.0001)
84.                 {
85.                     status = SamplerStatus.NoChange;
86.                 }
87.                 else
88.                 {
89.                     Matrix3d mt;
90.  
91.                     //Restore to previous scale
92.                     mt = Matrix3d.Scaling(1 / _scale, _basePoint);
93.                     _entity.TransformBy(mt);
94.  
95.                     //Transform to new scale
96.                     _scale = newScale;
97.                     mt = Matrix3d.Scaling(_scale, _basePoint);
98.                     _entity.TransformBy(mt);
99.  
100.                     status = SamplerStatus.OK;
101.                 }
102.  
103.                 _picked = true;
104.             }
105.             else
106.             {
107.                 _picked = false;
108.                 status = SamplerStatus.Cancel;
109.             }
110.  
111.             return status;
112.         }
113.  
114.         protected override bool WorldDraw(
115.             Autodesk.AutoCAD.GraphicsInterface.WorldDraw draw)
116.         {
117.             
118.             draw.Geometry.Draw(_entity);
119.             return true;
120.         }
121.  
122.         #endregion
123.  
124.         #region private methods
125.  
126.         private Entity GetEntityClone(ObjectId entID)
127.         {
128.             Entity ent = null;
129.             using (Transaction tran =
130.                 _db.TransactionManager.StartTransaction())
131.             {
132.                 Entity e = (Entity)tran.GetObject(entID, OpenMode.ForRead);
133.                 ent = e.Clone() as Entity;
134.                 ent.ColorIndex = _colorIndex;
135.  
136.                 tran.Commit();
137.             }
138.  
139.             return ent;
140.         }
141.  
142.         private void HighlightEntity(bool highlight)
143.         {
144.             using (Transaction tran =
145.                 _db.TransactionManager.StartTransaction())
146.             {
147.                 Entity ent = (Entity)tran.GetObject(
148.                     _entID, OpenMode.ForWrite);
149.                 SubentityId subEntId =
150.                     new SubentityId(SubentityType.Null, IntPtr.Zero);
151.                 ObjectId[] ids = new ObjectId[1];
152.                 ids[0] = ent.ObjectId;
153.                 FullSubentityPath path =
154.                     new FullSubentityPath(ids, subEntId);
155.  
156.                 if (highlight)
157.                     ent.Highlight(path, true);
158.                 else
159.                     ent.Unhighlight(path, true);
160.             }
161.         }
162.  
163.         private bool PickBasePoint()
164.         {
165.             PromptPointOptions opt = new PromptPointOptions(
166.                 "\nPick scale base point:");
167.             opt.AllowNone = false;
168.             PromptPointResult res = _ed.GetPoint(opt);
169.  
170.             if (res.Status == PromptStatus.OK)
171.             {
172.                 _basePoint = res.Value;
173.                 return true;
174.             }
175.             else
176.             {
177.                 return false;
178.             }
179.         }
180.  
181.         private void ScaleEntity()
182.         {
183.             using (Transaction tran =
184.                 _db.TransactionManager.StartTransaction())
185.             {
186.                 Entity e = (Entity)tran.GetObject(_entID, OpenMode.ForWrite);
187.  
188.                 Matrix3d mt = Matrix3d.Scaling(_scale, _basePoint);
189.                 e.TransformBy(mt);
190.  
191.                 tran.Commit();
192.             }
193.         }
194.  
195.         #endregion
196.     }
197. }

Here is a command class that uses MyScaleJig to scale selected entity:

Code Snippet

1. using Autodesk.AutoCAD.ApplicationServices;
2. using Autodesk.AutoCAD.DatabaseServices;
3. using Autodesk.AutoCAD.EditorInput;
4. using Autodesk.AutoCAD.Runtime;
5.  
6. [assembly: CommandClass(typeof(ScaleJig.MyCommands))]
7.  
8. namespace ScaleJig
9. {
10.     public class MyCommands
11.     {
12.         [CommandMethod("MyScale")]
13.         public static void RunMyScaleJig()
14.         {
15.             Document doc = Application.DocumentManager.MdiActiveDocument;
16.             Editor ed = doc.Editor;
17.  
18.             //Pick an entity
19.             ObjectId entID = GetEntity(ed);
20.             if (entID == ObjectId.Null)
21.             {
22.                 ed.WriteMessage("\n*Cancel*");
23.                 return;
24.             }
25.  
26.             //Use MyScaleJig to scale entity
27.             //With red jib ghost line
28.             MyScaleJig jig = new MyScaleJig(doc);
29.             jig.ScaleEntity(entID, 1);
30.         }
31.  
32.         private static ObjectId GetEntity(Editor ed)
33.         {
34.             PromptEntityOptions opt =
35.                 new PromptEntityOptions("\nPick an entity: ");
36.             PromptEntityResult res = ed.GetEntity(opt);
37.  
38.             if (res.Status == PromptStatus.OK)
39.             {
40.                 return res.ObjectId;
41.             }
42.             else
43.             {
44.                 return ObjectId.Null;
45.             }
46.         }
47.     }
48. }

The key part of the code lies in the 2 overridden methods Sampler() and WorldDraw() and it is quite simple and straightforward.

I uses a non-database residing, cloned entity for generating ghost image of the entity to be scaled. This way, the real entity to scaled is not changed if user cancels dragging, and only be changed when the dragging is ended with a distance (scale) is picked or entered.

As we can see, the whole purpose to use jig here is to get a scale input from user with very user-friendly visual hint help.

With some easy code modification, we can pass a collection/array of selected entities (ObjectIds, actually), and scale them together.

However, comparing to AutoCAD built-in Scale command, one thing is missing: there is no rubber-band line from the base point to the mouse cursor. That is because I have use JigPromptDistanceOptions to acquire user input as scale. In spite I set its UseBasePoint property to True and set its BasePoint property to a Point3d value, the rubber-band line still does not show. I guess this is by design: rubber-band line only shows with JigPromptPointOptions class.
I do not know how to overcome this problem with Jig class. Maybe I can implement another custom Scale command with TransientGraphics in conjunction with Editor.PointMonitor event handler later.

Update: Thanks to Maxence's comment, it turned out showing the rubber-band line is simple. I added one line code, showing in red. Thank you, Maxence.