Saturday, December 24, 2011

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.

Followers

About Me

My photo
After graduating from university, I worked as civil engineer for more than 10 years. It was AutoCAD use that led me to the path of computer programming. Although I now do more generic business software development, such as enterprise system, timesheet, billing, web services..., AutoCAD related programming is always interesting me and I still get AutoCAD programming tasks assigned to me from time to time. So, AutoCAD goes, I go.