Update to the AutoCAD .NET entity jig framework

csharp

Update to the AutoCAD .NET entity jig framework

http://through-the-interface.typepad.com/through_the_interface/2012/12/update-to-the-autocad-net-entity-jig-framework.html

Update to the AutoCAD .NET entity jig framework
In the last post I introduced a simple framework to make the definition of multi-input entity jigs more straightforward. A big thanks to Chuck Wilbur, who provided some feedback that has resulted in a nicer base implementation, which we’ll take for a spin in today’s post.
Here’s the updated C# framework code that makes use of a simple class hierarchy for our phase definitions:

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using System.Collections.Generic;

using System;

namespace JigFrameworks

{

  // Two abstract base classes: one for all phases...

  public abstract class Phase

  {

    // Our member data (could add real properties, as needed)

    public string Message;

    public object Value;

    public Phase(string msg)

    {

      Message = msg;

    }

  }

  // And another for geometric classes...

  public abstract class GeometryPhase : Phase

  {

    // Geometric classes can also have an offset for the basepoint

    public Func<List<Phase>, Point3d, Vector3d> Offset;

    public GeometryPhase(

      string msg,

      Func<List<Phase>, Point3d, Vector3d> offset = null

    ) : base(msg)

    {

      Offset = offset;

    }

  }

  // A phase for distance input

  public class DistancePhase : GeometryPhase

  {

    public DistancePhase(

      string msg,

      object defval = null,

      Func<List<Phase>, Point3d, Vector3d> offset = null

    ) : base(msg, offset)

    {

      Value = (defval == null ? 0 : defval);

    }

  }

  // A phase for distance input related to Autodesk Shape Manager

  // (whose internal tolerance if 1e-06, so we need a larger

  // default value to allow Solid3d creation to succeed)

  public class SolidDistancePhase : DistancePhase

  {

    public SolidDistancePhase(

      string msg,

      object defval = null,

      Func<List<Phase>, Point3d, Vector3d> offset = null

    ) : base(msg, defval, offset)

    {

      Value = (defval == null ? 1e-05 : defval);

    }

  }

  // A phase for point input

  public class PointPhase : GeometryPhase

  {

    public PointPhase(

      string msg,

      object defval = null,

      Func<List<Phase>, Point3d, Vector3d> offset = null

    ) : base(msg, offset)

    {

      Value =

        (defval == null ? Point3d.Origin : defval);

    }

  }

  // A phase for angle input

  public class AnglePhase : GeometryPhase

  {

    public AnglePhase(

      string msg,

      object defval = null,

      Func<List<Phase>, Point3d, Vector3d> offset = null

    ) : base(msg, offset)

    {

      Value = (defval == null ? 0 : defval);

    }

  }

  // And a non-geometric phase for string input

  public class StringPhase : Phase

  {

    public StringPhase(

      string msg,

      string defval = null

    ) : base(msg)

    {

      Value = (defval == null ? "" : defval);

    }

  }

  // Our jig framework class

  public class EntityJigFramework : EntityJig

  {

    // Member data

    Matrix3d _ucs;

    Point3d _pt;

    Entity _ent;

    List<Phase> _phases;

    int _phase;

    Func<Entity, List<Phase>, Point3d, Matrix3d, bool> _update;

    // Constructor

    public EntityJigFramework(

      Matrix3d ucs, Entity ent, Point3d pt, List<Phase> phases,

      Func<Entity, List<Phase>, Point3d, Matrix3d, bool> update

    ) : base(ent)

    {

      _ucs = ucs;

      _ent = ent;

      _pt = pt;

      _phases = phases;

      _phase = 0;

      _update = update;

    }

    // Move on to the next phase

    internal void NextPhase()

    {

      _phase++;

    }

    // Check whether we're at the last phase

    internal bool IsLastPhase()

    {

      return (_phase == _phases.Count - 1);

    }

    // EntityJig protocol

    protected override SamplerStatus Sampler(JigPrompts prompts)

    {

      // Get the current phase

      var p = _phases[_phase];

      // If we're dealing with a geometry-typed phase (distance,

      // point ot angle input) we can use some common code

      var gp = p as GeometryPhase;

      if (gp != null)

      {

        JigPromptGeometryOptions opts;

        if (gp is DistancePhase)

          opts = new JigPromptDistanceOptions();

        else if (gp is AnglePhase)

          opts = new JigPromptAngleOptions();

        else if (gp is PointPhase)

          opts = new JigPromptPointOptions();

        else // Should never happen

          opts = null;

        // Set up the user controls

        opts.UserInputControls =

          (UserInputControls.Accept3dCoordinates

          | UserInputControls.NoZeroResponseAccepted

          | UserInputControls.NoNegativeResponseAccepted);

        // All our distance inputs will be with a base point

        // (which means the initial base point or an offset from

        // that)

        opts.UseBasePoint = true;

        opts.Cursor = CursorType.RubberBand;

        opts.Message = p.Message;

        opts.BasePoint =

          (gp.Offset == null ?

            _pt.TransformBy(_ucs) :

            (_pt + gp.Offset.Invoke(_phases, _pt)).TransformBy(_ucs)

          );

        // The acquisition method varies on the phase type

        if (gp is DistancePhase)

        {

          var phase = (DistancePhase)gp;

          var pdr =

            prompts.AcquireDistance(

              (JigPromptDistanceOptions)opts

            );

          if (pdr.Status == PromptStatus.OK)

          {

            // If the difference between the new value and its

            // previous value is negligible, return "no change"

            if (

              Math.Abs((double)phase.Value - pdr.Value) <

              Tolerance.Global.EqualPoint

            )

              return SamplerStatus.NoChange;

            // Otherwise we update the appropriate variable

            // based on the phase

            phase.Value = pdr.Value;

            _phases[_phase] = phase;

            return SamplerStatus.OK;

          }

        }

        else if (gp is PointPhase)

        {

          var phase = (PointPhase)gp;

          var ppr =

            prompts.AcquirePoint((JigPromptPointOptions)opts);

          if (ppr.Status == PromptStatus.OK)

          {

            // If the difference between the new value and its

            // previous value is negligible, return "no change"

            var tmp = ppr.Value.TransformBy(_ucs.Inverse());

            if (

              tmp.DistanceTo((Point3d)phase.Value) <

              Tolerance.Global.EqualPoint

            )

              return SamplerStatus.NoChange;

            // Otherwise we update the appropriate variable

            // based on the phase

            phase.Value = tmp;

            _phases[_phase] = phase;

            return SamplerStatus.OK;

          }

        }

        else if (gp is AnglePhase)

        {

          var phase = (AnglePhase)gp;

          var par =

            prompts.AcquireAngle((JigPromptAngleOptions)opts);

          if (par.Status == PromptStatus.OK)

          {

            // If the difference between the new value and its

            // previous value is negligible, return "no change"

            if (

              (double)phase.Value - par.Value <

              Tolerance.Global.EqualPoint

            )

              return SamplerStatus.NoChange;

            // Otherwise we update the appropriate variable

            // based on the phase

            phase.Value = par.Value;

            _phases[_phase] = phase;

            return SamplerStatus.OK;

          }

        }

      }

      else

      {

        // p is StringPhase

        var phase = (StringPhase)p;

        var psr = prompts.AcquireString(p.Message);

        if (psr.Status == PromptStatus.OK)

        {

          phase.Value = psr.StringResult;

          _phases[_phase] = phase;

          return SamplerStatus.OK;

        }

      }

      return SamplerStatus.Cancel;

    }

    protected override bool Update()

    {

      // Right now we have an indiscriminate catch around our

      // entity update callback: this could be modified to be

      // more selective and/or to provide information on exceptions

      try

      {

        return _update.Invoke(_ent, _phases, _pt, _ucs);

      }

      catch

      {

        return false;

      }

    }

    public Entity GetEntity()

    {

      return Entity;

    }

    // Our method to perform the jig and step through the

    // phases until done

    internal void RunTillComplete(Editor ed, Transaction tr)

    {

      // Perform the jig operation in a loop

      while (true)

      {

        var res = ed.Drag(this);

        if (res.Status == PromptStatus.OK)

        {

          if (!IsLastPhase())

          {

            // Progress the phase

            NextPhase();

          }

          else

          {

            // Only commit when all phases have been accepted

            tr.Commit();

            return;

          }

        }

        else

        {

          // The user has cancelled: returning aborts the

          // transaction

          return;

        }

      }

    }

  }

}

Now let’s take it for a spin. Here’s some C# code that uses the framework to define jigs (and their respective commands) for frustums (FJ), cylinders (CYJ), cones (COJ) and tori (TJ):

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using System.Collections.Generic;

using System;

using JigFrameworks;

namespace EntityJigs

{

  public class Commands

  {

    [CommandMethod("FJ")]

    public void FrustumJig()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

      // First let's get the start position of the frustum

      var ppr = ed.GetPoint("\nSpecify frustum location: ");

      if (ppr.Status == PromptStatus.OK)

      {

        // In order for the visual style to be respected,

        // we'll add the to-be-jigged solid to the database

        var tr = doc.TransactionManager.StartTransaction();

        using (tr)

        {

          var btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId, OpenMode.ForWrite

            );

          var sol = new Solid3d();

          btr.AppendEntity(sol);

          tr.AddNewlyCreatedDBObject(sol, true);

          // Create our jig object passing in the selected point

          var jf =

            new EntityJigFramework(

              ed.CurrentUserCoordinateSystem, sol, ppr.Value,

              new List<Phase>()

              {

                // Three phases, one of which has a custom

                // offset for the base point

                new SolidDistancePhase("\nSpecify bottom radius: "),

                new SolidDistancePhase("\nSpecify height: "),

                new SolidDistancePhase(

                  "\nSpecify top radius: ",

                  1e-05,

                  (vals, pt) =>

                  {

                    return

                      new Vector3d(0, 0, (double)vals[1].Value);

                  }

                )

              },

              (e, vals, cen, ucs) =>

              {

                // Our entity update function

                var s = (Solid3d)e;

                s.CreateFrustum(

                  (double)vals[1].Value,

                  (double)vals[0].Value,

                  (double)vals[0].Value,

                  (double)vals[2].Value

                );

                s.TransformBy(

                  Matrix3d.Displacement(

                    cen.GetAsVector() +

                    new Vector3d(0, 0, (double)vals[1].Value / 2)

                  ).PreMultiplyBy(ucs)

                );

                return true;

              }

            );

          jf.RunTillComplete(ed, tr);

        }

      }

    }

    [CommandMethod("CYJ")]

    public void CylinderJig()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

      // First let's get the start position of the cylinder

      var ppr = ed.GetPoint("\nSpecify cylinder location: ");

      if (ppr.Status == PromptStatus.OK)

      {

        // In order for the visual style to be respected,

        // we'll add the to-be-jigged solid to the database

        var tr = doc.TransactionManager.StartTransaction();

        using (tr)

        {

          var btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId, OpenMode.ForWrite

            );

          var sol = new Solid3d();

          btr.AppendEntity(sol);

          tr.AddNewlyCreatedDBObject(sol, true);

          // Create our jig object passing in the selected point

          var jf =

            new EntityJigFramework(

              ed.CurrentUserCoordinateSystem, sol, ppr.Value,

              new List<Phase>()

              {

                // Three phases, one of which has a custom

                // offset for the base point

                new SolidDistancePhase("\nSpecify radius: "),

                new SolidDistancePhase("\nSpecify height: "),

              },

              (e, vals, cen, ucs) =>

              {

                // Our entity update function

                var s = (Solid3d)e;

                s.CreateFrustum(

                  (double)vals[1].Value,

                  (double)vals[0].Value,

                  (double)vals[0].Value,

                  (double)vals[0].Value

                );

                s.TransformBy(

                  Matrix3d.Displacement(

                    cen.GetAsVector() +

                    new Vector3d(0, 0, (double)vals[1].Value / 2)

                  ).PreMultiplyBy(ucs)

                );

                return true;

              }

            );

          jf.RunTillComplete(ed, tr);

        }

      }

    }

    [CommandMethod("COJ")]

    public void ConeJig()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

      // First let's get the start position of the cylinder

      var ppr = ed.GetPoint("\nSpecify cone location: ");

      if (ppr.Status == PromptStatus.OK)

      {

        // In order for the visual style to be respected,

        // we'll add the to-be-jigged solid to the database

        var tr = doc.TransactionManager.StartTransaction();

        using (tr)

        {

          var btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId, OpenMode.ForWrite

            );

          var sol = new Solid3d();

          btr.AppendEntity(sol);

          tr.AddNewlyCreatedDBObject(sol, true);

          // Create our jig object passing in the selected point

          var jf =

            new EntityJigFramework(

              ed.CurrentUserCoordinateSystem, sol, ppr.Value,

              new List<Phase>()

              {

                // Three phases, one of which has a custom

                // offset for the base point

                new SolidDistancePhase("\nSpecify radius: "),

                new SolidDistancePhase("\nSpecify height: "),

              },

              (e, vals, cen, ucs) =>

              {

                // Our entity update function

                var s = (Solid3d)e;

                s.CreateFrustum(

                  (double)vals[1].Value,

                  (double)vals[0].Value,

                  (double)vals[0].Value,

                  0

                );

                s.TransformBy(

                  Matrix3d.Displacement(

                    cen.GetAsVector() +

                    new Vector3d(0, 0, (double)vals[1].Value / 2)

                  ).PreMultiplyBy(ucs)

                );

                return true;

              }

            );

          jf.RunTillComplete(ed, tr);

        }

      }

    }

    [CommandMethod("TJ")]

    public void TorusJig()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var db = doc.Database;

      var ed = doc.Editor;

      // First let's get the start position of the frustum

      var ppr = ed.GetPoint("\nSpecify torus location: ");

      if (ppr.Status == PromptStatus.OK)

      {

        // In order for the visual style to be respected,

        // we'll add the to-be-jigged solid to the database

        var tr = doc.TransactionManager.StartTransaction();

        using (tr)

        {

          var btr =

            (BlockTableRecord)tr.GetObject(

              db.CurrentSpaceId, OpenMode.ForWrite

            );

          var sol = new Solid3d();

          btr.AppendEntity(sol);

          tr.AddNewlyCreatedDBObject(sol, true);

          // Create our jig object passing in the selected point

          var jf =

            new EntityJigFramework(

              ed.CurrentUserCoordinateSystem, sol, ppr.Value,

              new List<Phase>()

              {

                // Three phases, one of which has a custom

                // offset for the base point

                new SolidDistancePhase("\nSpecify outer radius: "),

                new SolidDistancePhase(

                  "\nSpecify inner radius: ",

                  1e-05,

                  (vals, pt) =>

                  {

                    return

                      new Vector3d(0, 0, (double)vals[0].Value);

                  }

                )

              },

              (e, vals, cen, ucs) =>

              {

                // Our entity update function

                var s = (Solid3d)e;

                s.CreateTorus(

                  (double)vals[0].Value,

                  (double)vals[1].Value

                );

                s.TransformBy(

                  Matrix3d.Displacement(

                    cen.GetAsVector() +

                    new Vector3d(0, 0, (double)vals[1].Value)

                  ).PreMultiplyBy(ucs)

                );

                return true;

              }

            );

          jf.RunTillComplete(ed, tr);

        }

      }

    }

  }

}

Let’s see these commands in action:

In the next post we’ll see a slightly more complicated example, where we jig a square (at least in X and Y) box between diagonal corners.