Through the Interface

Jigging an AutoCAD solid using IronRuby and .NET (yes, finally)

Back in April I posted an IronRuby sample that I had hoped would cause AutoCAD to jig a box in 3D, just like its IronPython counterpart.

The sample didn’t work with IronRuby 0.3, but recently David Blackmon got in touch to let me know he had a version of the code working with IronRuby 0.9. Now that I’ve started preparing for my upcoming AU class, AutoCAD® .NET: Developing for AutoCAD® Using IronPython and IronRuby, I decided to take a closer look at the update to IronRuby and more specifically at the changes to the code David made to get it to work.

David has been having some real fun with IronRuby and AutoCAD: for those interested, I strongly recommend checking out the work he’s posted on github. David claims to have been inspired by my previous IronRuby posts to develop some helper classes for AutoCAD development and the results are really interesting: having someone passionate about Ruby take a look at this is great, as it demonstrates to the rest of us some of the possibilities.

I haven’t used these helpers in the below code – which only borrows the tricks David used to get the jig to work – but that’s more for consistency with my previous post than for any other reason.

Here’s the updated IronRuby code, with the modified/additional lines marked in red (and the full source file can be downloaded from here):

    1 require 'acmgd.dll'

    2 require 'acdbmgd.dll'

    3 

    4 Ai =  Autodesk::AutoCAD::Internal

    5 Aiu = Autodesk::AutoCAD::Internal::Utils

    6 Aas = Autodesk::AutoCAD::ApplicationServices

    7 Ads = Autodesk::AutoCAD::DatabaseServices

    8 Aei = Autodesk::AutoCAD::EditorInput

    9 Ag =  Autodesk::AutoCAD::Geometry

   10 Ar =  Autodesk::AutoCAD::Runtime

   11 

   12 def print_message(msg)

   13   app = Aas::Application

   14   doc = app.DocumentManager.MdiActiveDocument

   15   ed = doc.Editor

   16   ed.WriteMessage(msg)

   17 end

   18 

   19 # Function to register AutoCAD commands

   20 

   21 def autocad_command(cmd) 

   22   cc = Ai::CommandCallback.new method(cmd)

   23   Aiu.AddCommand(

   24     'rbcmds', cmd, cmd, Ar::CommandFlags.Modal, cc)

   25 

   26   # Let's now write a message to the command-line

   27 

   28   print_message("\nRegistered Ruby command: " + cmd)

   29 end

   30 

   31 def add_commands(names)

   32   names.each { |n| autocad_command n }

   33 end

   34 

   35 # Let's do something a little more complex...

   36 

   37 class SolidJig < Aei::EntityJig

   38 

   39   # Constructor

   40 

   41   def SolidJig.new(ent)

   42     super

   43   end

   44 

   45   # The function called to run the jig

   46 

   47   def start_jig(ed, pt)

   48 

   49     # The start point is specified outside the jig

   50 

   51     @start = pt

   52     @end = pt

   53     @sol = self.Entity

   54 

   55     return ed.Drag(self)

   56   end

   57 

   58   # The sampler function

   59 

   60   def sampler(prompts)

   61 

   62     # Set up our selection options

   63 

   64     jo = Aei::JigPromptPointOptions.new

   65     jo.UserInputControls = (

   66    Aei::UserInputControls.Accept3dCoordinates |

   67    Aei::UserInputControls.NoZeroResponseAccepted |

   68    Aei::UserInputControls.NoNegativeResponseAccepted)

   69     jo.Message = "\nSelect end point: "  

   70 

   71     # Get the end point of our box

   72 

   73     res = prompts.AcquirePoint(jo)

   74 

   75     if @end == res.Value

   76    return Aei::SamplerStatus.NoChange

   77     else

   78    @end = res.Value

   79     end

   80 

   81     return Aei::SamplerStatus.OK

   82   end

   83 

   84   # The update function

   85 

   86   def update()

   87 

   88     # Recreate our Solid3d box

   89 

   90     begin

   91 

   92    # Get the width (x) and depth (y)

   93 

   94    x = @end.X - @start.X

   95    y = @end.Y - @start.Y

   96 

   97    # We need a non-zero Z value, so we copy Y

   98 

   99    z = y

  100 

  101    # Create our box and move it to the right place

  102 

  103    if x.abs > 0 and y.abs > 0

  104      @sol.CreateBox(x.abs,y.abs,z.abs)    

  105      @sol.TransformBy(

  106    Ag::Matrix3d.Displacement(

  107      Ag::Vector3d.new(

  108    @start.X + x/2,

  109    @start.Y + y/2,

  110    @start.Z + z/2)))

  111    end

  112     rescue

  113    return false

  114     end 

  115     return true

  116   end

  117 end

  118 

  119 # Create a box using a jig

  120 

  121 def boxjig

  122 

  123   app = Aas::Application

  124   doc = app.DocumentManager.MdiActiveDocument

  125   db = doc.Database

  126   ed = doc.Editor

  127 

  128   # Select the start point before entering the jig

  129 

  130   ppr = ed.GetPoint("\nSelect start point: ")

  131 

  132   if ppr.Status == Aei::PromptStatus.OK

  133 

  134     # We'll add our solid to the modelspace

  135 

  136     tr = doc.TransactionManager.StartTransaction

  137     bt =

  138    tr.GetObject(

  139      db.BlockTableId,

  140      Ads::OpenMode.ForRead)

  141     btr =

  142    tr.GetObject(db.CurrentSpaceId,Ads::OpenMode.ForWrite)

  143 

  144     # Make sure we're recording history to allow grip editing

  145 

  146     sol = Ads::Solid3d.new

  147     sol.RecordHistory = true

  148 

  149     # Now we add our solid

  150 

  151     btr.AppendEntity(sol)

  152     tr.AddNewlyCreatedDBObject(sol, true)

  153 

  154     # And call the jig before finishing

  155 

  156     begin

  157 

  158    sj = SolidJig.new sol

  159 

  160    ppr2 = sj.start_jig(ed, ppr.Value)

  161 

  162    # Only commit if all completed well

  163 

  164    if ppr2.Status == Aei::PromptStatus.OK

  165      tr.Commit

  166    end

  167 

  168     rescue

  169 

  170    print_message("\nProblem found: " + $! + "\n")

  171 

  172     end

  173 

  174     tr.Dispose

  175   end

  176 end

  177 

  178 add_commands ["boxjig"]

Let’s look at the specific changes:

• Lines 1-2 just removes the paths, to make the code more portable. I've also removed the load of acmgdinternal.dll, as this is no longer a separate assembly with AutoCAD 2010.
• Lines 39 and 41 turn my prior initialization attempt into a constructor. Line 53 sets our "@sol" member to be the entity passed into the constructor, although this code has to be in start_jig to work properly, for some reason – it can’t be in the constructor itself.
• Lines 47, 60, 86 & 160 are make the code more Rubyesque (as mentioned in my last IronRuby post, Ruby functions should  really be named with the lowercase_and_delimited convention).
• Lines 103-4 and 111 allow a box to be created even when the cursor crosses the start point (either to its left or below it, which would previously have thrown an exception as we create a box with zero/negative height/width/depth).

To load the .rb file, I simply used the RBLOAD command implemented by the C# loader application shown in previous IronRuby posts.

Now let’s run the BOXJIG command. After selecting a start point, we drag off to the top-right and see our box changing size (displayed using the 3D hidden visual style, in this case):

As we drag to the bottom left of our original point and select a point, we see our box created in that direction:

In my next post I plan on taking the lid off some of David’s AutoCAD helper classes, as well as showing some of IronPython’s debugging capabilities when integrated with Visual Studio 2008.

Overruling AutoCAD 2010’s entity display and explode using IronRuby

As mentioned in this previous post, where I gave the same treatment to IronPython, I’ve been trying to get display and explode overrules defined in IronRuby working properly in AutoCAD. IronRuby is still at version 0.3, so this effort has been hindered by a number of CLR interop bugs (it turns out).

I finally managed to work around these issues thanks to Ivan Porto Carrero, who is just finishing up his book, Iron Ruby in Action, and has been working with IronRuby since pre-Alpha 1 (brave fellow). Ivan’s help was invaluable: he ended up downloading and installing AutoCAD 2010 to work through the issues on my behalf, uncover the various problems and submitting bugs against IronRuby, where appropriate. There was a small measure of self-interest involved, as I’ve been working on some content Ivan will be including in his book – I just hope the material proves usable for him. Oh, and hopefully I’ll be getting a few copies of Ivan’s book to give away at my proposed AU 2009 class on “Developing for AutoCAD with IronPython and IronRuby”.

Incidentally, in spite of the workarounds implemented with Ivan’s help, I wasn’t able to get the previous IronRuby sample to jig a solid working. Hopefully the underlying IronRuby bug that’s stopping it from working will be addressed in an upcoming release.

The C# code defining the RBLOAD command has been update slightly:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.EditorInput;

using IronRuby.Hosting;

using IronRuby;

using Microsoft.Scripting.Hosting;

using System.Reflection;

using System;

 

namespace RubyLoader

{

  public class Commands

  {

    [CommandMethod("-RBLOAD")]

    public static void RubyLoadCmdLine()

    {

      RubyLoad(true);

    }

 

    [CommandMethod("RBLOAD")]

    public static void RubyLoadUI()

    {

      RubyLoad(false);

    }

 

    public static void RubyLoad(bool useCmdLine)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      short fd =

        (short)Application.GetSystemVariable("FILEDIA");

 

      // As the user to select a .rb file

 

      PromptOpenFileOptions pfo =

          new PromptOpenFileOptions(

            "Select Ruby script to load"

          );

      pfo.Filter = "Ruby script (*.rb)|*.rb";

      pfo.PreferCommandLine =

        (useCmdLine || fd == 0);

      PromptFileNameResult pr =

        ed.GetFileNameForOpen(pfo);

 

      // And then try to load and execute it

 

      if (pr.Status == PromptStatus.OK)

        ExecuteRubyScript(pr.StringResult);

    }

 

    [LispFunction("RBLOAD")]

    public ResultBuffer RubyLoadLISP(ResultBuffer rb)

    {

      const int RTSTR = 5005;

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      if (rb == null)

      {

        ed.WriteMessage("\nError: too few arguments\n");

      }

      else

      {

        // We're only really interested in the first argument

 

        Array args = rb.AsArray();

        TypedValue tv = (TypedValue)args.GetValue(0);

 

        // Which should be the filename of our script

 

        if (tv != null && tv.TypeCode == RTSTR)

        {

          // If we manage to execute it, let's return the

          // filename as the result of the function

          // (just as (arxload) does)

 

          bool success =

            ExecuteRubyScript(Convert.ToString(tv.Value));

          return

            (success ?

              new ResultBuffer(

                new TypedValue(RTSTR, tv.Value)

              )

              : null);

        }

      }

      return null;

    }

 

    private static bool ExecuteRubyScript(string file)

    {

      // If the file exists, let's load and execute it

 

      bool ret = System.IO.File.Exists(file);

      if (ret)

      {

        try

        {

          LanguageSetup ls = Ruby.CreateRubySetup();

          ScriptRuntimeSetup rs =

            new ScriptRuntimeSetup();

          rs.LanguageSetups.Add(ls);

          rs.DebugMode = true;

 

          ScriptRuntime runtime =

            Ruby.CreateRuntime(rs);

          runtime.LoadAssembly(

            Assembly.GetAssembly(typeof(Commands))

          );

 

          ScriptEngine engine = Ruby.GetEngine(runtime);

          engine.ExecuteFile(file);

        }

        catch (System.Exception ex)

        {

          Document doc =

            Application.DocumentManager.MdiActiveDocument;

          Editor ed = doc.Editor;

 

          ed.WriteMessage(

            "\nProblem executing script: {0}", ex

          );

        }

      }

      return ret;

    }

  }

}

Inside the ExecuteRubyScript() function we’re now creating a runtime environment within which we load our C# assembly, as it defines some classes to workaround some derivation problems. Here is the additional C# source that needed to be added to our project:

namespace ConcreteClasses

{

  public class DrawableOverrule :

    Autodesk.AutoCAD.GraphicsInterface.DrawableOverrule

  {

    public int ParentSetAttributes(

      Autodesk.AutoCAD.GraphicsInterface.Drawable drawable,

      Autodesk.AutoCAD.GraphicsInterface.DrawableTraits traits

    )

    {

      return base.SetAttributes(drawable, traits);

    }

    public bool ParentWorldDraw(

      Autodesk.AutoCAD.GraphicsInterface.Drawable drawable,

      Autodesk.AutoCAD.GraphicsInterface.WorldDraw wd

    )

    {

      return base.WorldDraw(drawable, wd);

    }

  }

  public class TransformOverrule :

    Autodesk.AutoCAD.DatabaseServices.TransformOverrule

  {}

}

This code works around two issues:

1. IronRuby 0.3 has issues implementing abstract classes and our Overrule classes are abstract. So we derive “concrete” classes from these abstract classes – empty implementations would be enough, as neither DrawableOverrule no TransformOverrule include abstract function definitions that require overriding – and in our Ruby script we derive from these concrete classes.
2. Our concrete DrawableOverrule is not empty as we need to work around another issue: super-messaging to our parent classes proved problematic, so we now expose methods (ParentSetAttributes() and ParentWorldDraw()) that do so explicitly.

I also hit a number of subtle issues related to Ruby’s naming conventions… Here’s what the IronRuby documentation says about naming conventions when using CLR types (which our types are, as they’re imported using .NET):

In an effort to make consuming .NET APIs in IronRuby more Rubyesque, IronRuby allows calling .NET code with Ruby idioms:

1. CLR namespaces and interfaces must be capitalized as they are mapped onto Ruby modules
2. CLR classes must be capitalized as they are mapped onto Ruby classes
3. CLR methods that you call may either retain their original spelling (ie "WriteLine") or they may be used in a more Rubyesque form which is obtained by translating CamelCase to lowercase_and_delimited (ie "write_line").
4. CLR virtual methods which you override from IronRuby must be in their lowercase_and_delimited form.

I was fine with item 1 (I’d hit this in my first attempt to write an IronRuby application, and found that I had to capitalicise even the variables I’d created as shortcuts to namespaces) and with item 2.

It was item 4 that caught me unawares: my WorldDraw() and SetAttributes() overides were simply not getting called: they had to be renamed to world_draw() and set_attributes(). That took some time to work out (and is no doubt one of the issues with the solid jigging code).

Item 3 proved to be quite fun: I ended up going back through the entire code sample, changing the CamelCase method calls to lowercase_and_delimited, even if this sometimes ended up looking a little strange (my personal favourite being Transaction.add_newly_created_d_b_object() :-).

Here’s the code from our .rb file:

require 'acmgd.dll'

require 'acdbmgd.dll'

 

Ai =  Autodesk::AutoCAD::Internal

Aiu = Autodesk::AutoCAD::Internal::Utils

Aas = Autodesk::AutoCAD::ApplicationServices

Ads = Autodesk::AutoCAD::DatabaseServices

Aei = Autodesk::AutoCAD::EditorInput

Agi = Autodesk::AutoCAD::GraphicsInterface

Ag =  Autodesk::AutoCAD::Geometry

Ac =  Autodesk::AutoCAD::Colors

Ar =  Autodesk::AutoCAD::Runtime

 

def print_message(msg)

  app = Aas::Application

  doc = app.document_manager.mdi_active_document

  ed = doc.editor

  ed.write_message(msg)

end

 

# Function to register AutoCAD commands

 

def autocad_command(cmd) 

  cc = Ai::CommandCallback.new method(cmd)

  Aiu.add_command('rbcmds', cmd, cmd, Ar::CommandFlags.Modal, cc)

 

  # Let's now write a message to the command-line

 

  print_message("\nRegistered Ruby command: " + cmd)

end

 

def add_commands(names)

  names.each { |n| autocad_command n }

end

 

APP_NAME = "TTIF_PIPE"

APP_CODE = 1001

RAD_CODE = 1040

 

def pipe_radius_for_object(obj)

 

  # Get the XData for a particular object

  # and return the "pipe radius" if it exists

 

  res = 0.0

 

  begin

 

    rb = obj.XData

    if rb.nil?

      return res

    end

 

    foundStart = false

 

    for tv in rb do

      if (tv.type_code == APP_CODE and tv.value == APP_NAME)

        foundStart = true

      else

        if foundStart

          if (tv.type_code == RAD_CODE)

            res = tv.value

            break

          end

        end

      end

    end     

  rescue

    return 0.0

  end

  return res

end

 

def set_pipe_radius_for_object(tr, obj, radius)

 

  # Set the pipe radius as XData on a particular object

 

  db = obj.Database

 

  # Make sure the application is registered

  # (we could separate this out to be called

  # only once for a set of operations)

 

  rat =

    tr.get_object(db.reg_app_table_id, Ads::OpenMode.for_read)

 

  if (not rat.Has(APP_NAME))

    rat.UpgradeOpen()

    ratr = Ads::RegAppTableRecord.new

    ratr.Name = APP_NAME

    rat.Add(ratr)

    tr.add_newly_created_d_b_object(ratr, true)

  end

 

  # Create the XData and set it on the object

 

  rb = Ads::ResultBuffer.new(

      Ads::TypedValue.new(APP_CODE, APP_NAME),

      Ads::TypedValue.new(RAD_CODE, radius))

  obj.XData = rb

  rb.Dispose()

 

end

 

class PipeDrawOverrule < ConcreteClasses::DrawableOverrule

 

  # The base class for our draw overrules specifying the

  # registered application name for the XData upon which

  # to filter

 

  def initialize

 

    # Tell AutoCAD to filter on our application name

    # (this means our overrule will only be called

    # on objects possessing XData with this name)

 

    set_x_data_filter(APP_NAME)

  end

end

 

class LinePipeDrawOverrule < PipeDrawOverrule

 

  # An overrule to make a pipe out of a line

 

  def initialize

    @sweep_opts = Ads::SweepOptions.new

    super

  end

 

  def world_draw(d, wd)

 

    radius = pipe_radius_for_object(d)

 

    if radius > 0.0

      # Draw the line as is, with overruled attributes

 

      # Should just be able to call super

      parent_world_draw(d, wd)

 

      if not d.id.is_null and d.length > 0.0

        # Draw a pipe around the line

 

        c = wd.sub_entity_traits.true_color

        wd.sub_entity_traits.true_color =

          Ac::EntityColor.new 0x00AFAFFF

        wd.sub_entity_traits.line_weight =

          Ads::LineWeight.line_weight_000

        start = d.start_point

        endpt = d.end_point

        norm = Ag::Vector3d.new(

          endpt.X - start.X,

          endpt.Y - start.Y,

          endpt.Z - start.Z)

        clr = Ads::Circle.new start, norm, radius

        pipe = Ads::ExtrudedSurface.new

        begin

          pipe.create_extruded_surface(clr, norm, @sweep_opts)

        rescue

          print_message "\nFailed with CreateExtrudedSurface."

        end

        clr.dispose()

        pipe.world_draw(wd)

        pipe.dispose()

        wd.sub_entity_traits.true_color = c

      end

      return true

    end

    return super

  end

 

  def set_attributes(d, t)

 

    # Should just be able to call super

    i = parent_set_attributes(d, t)

 

    radius = pipe_radius_for_object(d)

 

    if radius > 0.0

      # Set color to magenta

      t.color = 6

      # and lineweight to .40 mm

      t.line_weight = Ads::LineWeight.line_weight_040

    end

    return i

  end

end

 

class CirclePipeDrawOverrule < PipeDrawOverrule

 

  # An overrule to make a pipe out of a circle

 

  def initialize

    @sweep_opts = Ads::SweepOptions.new

    super

  end

 

  def world_draw(d, wd)

 

    radius = pipe_radius_for_object(d)

 

    if radius > 0.0

      # Draw the circle as is, with overruled attributes

 

      parent_world_draw(d, wd)

 

      # Needed to avoid ill-formed swept surface

 

      if d.radius > radius

        # Draw a pipe around the circle

 

        c = wd.sub_entity_traits.true_color

        wd.sub_entity_traits.true_color =

          Ac::EntityColor.new 0x3FFFE0E0

        wd.sub_entity_traits.line_weight =

          Ads::LineWeight.LineWeight000

        start = d.StartPoint

        cen = d.Center

        norm = Ag::Vector3d.new(

          cen.X - start.X,

          cen.Y - start.Y,

          cen.Z - start.Z)

        clr =

          Ads::Circle.new start, norm.cross_product(d.normal), radius

        pipe = Ads::SweptSurface.new

        pipe.create_swept_surface(clr, d, @sweep_opts)

        clr.dispose()

        pipe.world_draw(wd)

        pipe.dispose()

        wd.sub_entity_traits.true_color = c

      end

      return true

    end

    return parent_world_draw(d, wd)

  end

 

  def set_attributes(d, t)

 

    # Should just be able to call super

    i = parent_set_attributes(d, t)

 

    radius = pipe_radius_for_object(d)

 

    if radius > 0.0

      # Set color to yellow

      t.color = 2

      # and lineweight to .60 mm

      t.line_weight = Ads::LineWeight.line_weight_060

    end

    return i

  end

end

 

class LinePipeTransformOverrule < ConcreteClasses::TransformOverrule

 

  # An overrule to explode a linear pipe into Solid3d objects

 

  def initialize

    @sweep_opts = Ads::SweepOptions.new

  end

 

  def explode(e, objs)

    radius = pipe_radius_for_object(e)

 

    if radius > 0.0

      if not e.Id.IsNull and e.Length > 0.0

        # Draw a pipe around the line

 

        start = e.start_point

        endpt = e.end_point

        norm = Ag::Vector3d.new(

          endpt.X - start.X,

          endpt.Y - start.Y,

          endpt.Z - start.Z)

        clr = Ads::Circle.new start, norm, radius

        pipe = Ads::ExtrudedSurface.new

        begin

          pipe.create_extruded_surface clr, norm, @sweep_opts

        rescue

          print_message "\nFailed with CreateExtrudedSurface."

        end

        clr.dispose()

        objs.add(pipe)

      end

      return

    end

    super

  end

end

 

class CirclePipeTransformOverrule < ConcreteClasses::TransformOverrule

 

  # An overrule to explode a circular pipe into Solid3d objects

 

  def initialize

    @sweep_opts = Ads::SweepOptions.new

  end

 

  def explode(e, objs)

    radius = pipe_radius_for_object(e)

 

    if radius > 0.0

      if e.radius > radius

 

        start = e.start_point

        cen = e.center

        norm = Ag::Vector3d.new(

          cen.X - start.X,

          cen.Y - start.Y,

          cen.Z - start.Z)

        clr =

          Ads::Circle.new start, norm.cross_product(e.normal), radius

        pipe = Ads::SweptSurface.new

        pipe.create_swept_surface(clr, e, @sweep_opts)

        clr.dispose()

        objs.add(pipe)

      end

      return

    end

    super

  end

end

 

def overrule(enable)

 

  # Regen to see the effect

  # (turn on/off Overruling and LWDISPLAY)

 

  Ar::Overrule.Overruling = enable

  if enable

    Aas::Application.set_system_variable("LWDISPLAY", 1)

  else

    Aas::Application.set_system_variable("LWDISPLAY", 0)

  end

 

  doc = Aas::Application.document_manager.mdi_active_document

  doc.send_string_to_execute("REGEN3\n", true, false, false)

  doc.editor.regen()

 

end

 

$overruling = false

$radius = 0.0

 

def overrule1

 

  begin

    if !$overruling

      $lpdo = LinePipeDrawOverrule.new     

      $cpdo = CirclePipeDrawOverrule.new     

      $lpto = LinePipeTransformOverrule.new

      $cpto = CirclePipeTransformOverrule.new

 

      Ads::ObjectOverrule.add_overrule(

        Ar::RXClass::get_class(Ads::Line.to_clr_type),

        $lpdo,

        true)

      Ads::ObjectOverrule.add_overrule(

        Ar::RXClass::get_class(Ads::Line.to_clr_type),

        $lpto,

        true)

      Ads::ObjectOverrule.add_overrule(

        Ar::RXClass::get_class(Ads::Circle.to_clr_type),

        $cpdo,

        true)

      Ads::ObjectOverrule.add_overrule(

        Ar::RXClass::get_class(Ads::Circle.to_clr_type),

        $cpto,

        true)

 

      $overruling = true

      overrule(true)

    end

  rescue

    print_message("\nProblem found: " + $! + "\n")

  end

end

 

def overrule0

 

  begin

    if $overruling

 

      Ads::ObjectOverrule.remove_overrule(

        Ar::RXClass::get_class(Ads::Line.to_clr_type),

        $lpdo)

      Ads::ObjectOverrule.remove_overrule(

        Ar::RXClass::get_class(Ads::Line.to_clr_type),

        $lpto)

      Ads::ObjectOverrule.remove_overrule(

        Ar::RXClass::get_class(Ads::Circle.to_clr_type),

        $cpdo)

      Ads::ObjectOverrule.remove_overrule(

        Ar::RXClass::get_class(Ads::Circle.to_clr_type),

        $cpto)

 

      $overruling = false

      overrule(false)

    end

  rescue

    print_message("\nProblem found: " + $! + "\n")

  end

end

 

def makePipe()

 

  begin

    doc = Aas::Application.document_manager.mdi_active_document

    db = doc.Database

    ed = doc.Editor

 

    # Ask the user to select the entities to make into pipes

 

    pso = Aei::PromptSelectionOptions.new

    pso.allow_duplicates = false

    pso.message_for_adding =

      "\nSelect objects to turn into pipes: "

 

    sel_res = ed.GetSelection(pso)

 

    # If the user didn't make valid selection, we return

 

    if sel_res.Status != Aei::PromptStatus.OK

      return

    end

 

    ss = sel_res.Value

 

    # Ask the user for the pipe radius to set

 

    pdo = Aei::PromptDoubleOptions.new "\nSpecify pipe radius:"

 

    # Use the previous value, if if already called

 

    if $radius > 0.0

      pdo.default_value = $radius

      pdo.use_default_value = true

    end

 

    pdo.allow_negative = false

    pdo.allow_zero = false

 

    pdr = ed.get_double(pdo)

 

    # Return if something went wrong

 

    if pdr.Status != Aei::PromptStatus.OK

      return

    end

 

    # Set the "last radius" value for when

    # the command is called next

 

    $radius = pdr.value

 

    # Use a transaction to edit our various objects

 

    tr = db.transaction_manager.start_transaction()

 

    # Loop through the selected objects

 

    for o in ss do

 

      # We could choose only to add XData to the objects

      # we know will use it (Lines and Circles, for now)

 

      obj = tr.get_object(o.object_id, Ads::OpenMode.for_write)

 

      set_pipe_radius_for_object(tr, obj, $radius)

 

    end

 

    tr.Commit()

    tr.Dispose()

  rescue

    print_message("\nProblem found: " + $! + "\n")

  end

end

 

add_commands ["overrule1", "overrule0", "makePipe"]

When we build and load our C# module via NETLOAD, we can then use RBLOAD to load our .rb file:

Registered Ruby command: overrule1

Registered Ruby command: overrule0

Registered Ruby command: makePipe

As in the previous examples, we create some geometry to which we attach data using the MAKEPIPE command:

Which we then use as a pipe radius for our geometry by turning on our overrules using the OVERRULE1 command:

Here is the same geometry in a conceptual 3D view:

And finally we call EXPLODE to try out our TransformOverrule and see the resultant Solid3d objects:

Jigging an AutoCAD solid using IronRuby and .NET (well, almost)

In the last post I introduced a very simple “Hello World!” IronRuby application working with AutoCAD, just as I’d previously done with IronPython. My idea for this post was to take the code from my second IronPython post – which showed how to jig an AutoCAD solid from IronPython – and get it working with IronRuby, forcing me to learn a little more Ruby in the process.

All started out well: to convert the basic syntax from Python to Ruby was straightforward, and I have a definite liking for the syntax of the Ruby language. Especially when working with object orientation: the code for implementing classes feels cleaner than Python and it’s really OO from top to bottom (everything’s an object). I even found a way to avoid all those namespaces everywhere in the code – you just assign them to symbols and use those intead.

So what didn’t work? Well, it turns out there’s a problem with the definition of the EntityJig class, which is the parent of our SolidJig: IronRuby tells me it doesn’t have a default constructor defined. It’s very similar in nature to the problem I had deriving the IronPython version of my SolidJig class, but in this case I had to make sure my code very specifically implemented an __init__ function taking an entity (IronRuby uses initialize() instead of __init__ and is really clean in the way it allows you to super-message to your parent class, but right now it seems there’s something getting in the way – IronRuby is at version 0.3, after all).

Here’s my IronRuby script – for the RBLOAD command look at the C# code in the last post.

require 'C:\Program Files\Autodesk\AutoCAD 2009\acmgd.dll'

require 'C:\Program Files\Autodesk\AutoCAD 2009\acdbmgd.dll'

require 'C:\Program Files\Autodesk\AutoCAD 2009\acmgdinternal.dll'

 

Ai =  Autodesk::AutoCAD::Internal

Aiu = Autodesk::AutoCAD::Internal::Utils

Aas = Autodesk::AutoCAD::ApplicationServices

Ads = Autodesk::AutoCAD::DatabaseServices

Aei = Autodesk::AutoCAD::EditorInput

Ag =  Autodesk::AutoCAD::Geometry

Ar =  Autodesk::AutoCAD::Runtime

 

def print_message(msg)

  app = Aas::Application

  doc = app.DocumentManager.MdiActiveDocument

  ed = doc.Editor

  ed.WriteMessage(msg)

end

 

# Function to register AutoCAD commands

 

def autocad_command(cmd) 

  cc = Ai::CommandCallback.new method(cmd)

  Aiu.AddCommand('rbcmds', cmd, cmd, Ar::CommandFlags.Modal, cc)

 

  # Let's now write a message to the command-line

 

  print_message("\nRegistered Ruby command: " + cmd)

end

 

def add_commands(names)

  names.each { |n| autocad_command n }

end

 

# Let's do something a little more complex...

 

class SolidJig < Aei::EntityJig

 

  # Initialization function

 

  def initialize(ent)

 

    # Call the base class and store the object

 

    super

    @sol = ent

 

  end

 

  # The function called to run the jig

 

  def StartJig(ed, pt)

 

    # The start point is specified outside the jig

 

    @start = pt

    @end = pt

 

    return ed.Drag(self)

  end

 

  # The sampler function

 

  def Sampler(prompts)

 

    # Set up our selection options

 

    jo = Aei::JigPromptPointOptions.new

    jo.UserInputControls = (

      Aei::UserInputControls.Accept3dCoordinates |

      Aei::UserInputControls.NoZeroResponseAccepted |

      Aei::UserInputControls.NoNegativeResponseAccepted)

    jo.Message = "\nSelect end point: "     

 

    # Get the end point of our box

 

    res = prompts.AcquirePoint(jo)

 

    if @end == res.Value

      return Aei::SamplerStatus.NoChange

    else

      @end = res.Value

    end

 

    return Aei::SamplerStatus.OK

  end

 

  # The update function

 

  def Update()

 

    # Recreate our Solid3d box

 

    begin

 

      # Get the width (x) and depth (y)

 

      x = @end.X - @start.X

      y = @end.Y - @start.Y

 

      # We need a non-zero Z value, so we copy Y

 

      z = y

 

      # Create our box and move it to the right place

 

      @sol.CreateBox(x,y,z)

      @sol.TransformBy(

        Ag::Matrix3d.Displacement(

          Ag::Vector3d.new(

            @start.X + x/2,

            @start.Y + y/2,

            @start.Z + z/2)))

    rescue

      return false

    end 

    return true

  end

end

 

# Create a box using a jig

 

def boxjig

 

  app = Aas::Application

  doc = app.DocumentManager.MdiActiveDocument

  db = doc.Database

  ed = doc.Editor

 

  # Select the start point before entering the jig

 

  ppr = ed.GetPoint("\nSelect start point: ")

 

  if ppr.Status == Aei::PromptStatus.OK

 

    # We'll add our solid to the modelspace

 

    tr = doc.TransactionManager.StartTransaction

    bt =

      tr.GetObject(

        db.BlockTableId,

        Ads::OpenMode.ForRead)

    btr =

      tr.GetObject(db.CurrentSpaceId,Ads::OpenMode.ForWrite)

 

    # Make sure we're recording history to allow grip editing

 

    sol = Ads::Solid3d.new

    sol.RecordHistory = true

 

    # Now we add our solid

 

    btr.AppendEntity(sol)

    tr.AddNewlyCreatedDBObject(sol, true)

 

    # And call the jig before finishing

 

    begin

 

      sj = SolidJig.new sol

 

      ppr2 = sj.StartJig(ed, ppr.Value)

 

      # Only commit if all completed well

 

      if ppr2.Status == Aei::PromptStatus.OK

        tr.Commit

      end

 

    rescue

 

      print_message("\nProblem found: " + $! + "\n")

 

    end

 

    tr.Dispose

  end

end

 

add_commands ["boxjig"]

When we run the RBLOAD command and select this script, our BOXJIG command gets defined.

Registered Ruby command: boxjig

When this is run, our Begin-Rescue block (equivalent to Try-Catch in most other modern programming languages :-) catches the exception and prints an error statement at the command-line:

Command: BOXJIG

Select start point:

Problem found: Parent does not have a default constructor. The default constructor must be explicitly defined.

I’m hoping the root cause of the issue is obvious to someone familiar with IronRuby, whether in the above calling code, the design of the API exposed by AutoCAD or the implementation of IronRuby itself.

I do prefer not to post code that doesn’t actually work, but I feel there’s still value in seeing the comparison between the Python and Ruby scripts, for people to get a feel for how the languages differ. And - apart from anything else – I’ve hit my head against this for long enough that I at least want to get a post out of it. :-)

Update:

Ivan Porto Carrero – who’s working on the book IronRuby in Action – is able to reproduce the issue outside of AutoCAD and has offered to log a bug. Hopefully it’ll get addressed in a future build of IronRuby (or someone will spell out how I can handle it cleanly from my side).

Using IronRuby with AutoCAD

[I’ve now started pushing links to my posts out through Twitter, even if I haven’t gone quite so far as to abandon TypePad (yes, it was an April Fools’ joke, in case anyone missed the closing comment :-)].

Having spent some time looking into Python, I decided to give Ruby – another popular scripting language and one with an “Iron” implementation allowing you to work with .NET – the same treatment.

From what I can tell – and I’m really a newbie in both these languages – there is relatively little to separate the two: both Ruby and Python have their devotees but they ultimately to belong to different sects of the same faith (it’s hard to escape religious analogies when talking about programming languages, for some reason :-). That said, the fiercest arguments often seem to occur between people who very nearly agree. This is not something I know enough about to get involved in – even if I wished to – so I’m going to steer well clear of it, and simply show some simple Ruby code that does the same as in the equivalent post for IronPython. If you Google “python ruby comparison” you should find plenty of opinions out there.

To get started I installed the most recently released version of IronRuby at the time of writing, version 0.3.

As with IronPython, we’re going to use a C# loader inside AutoCAD to host the IronRuby runtime and use it to interpret a Ruby script. The code to do this is very similar to that needed for IronPython, and it should, in fact, be simple enough to templatize the code in some way and combine the two into a single implementation (something I expect Tim Riley will be doing with PyAcad.NET, when he gets the chance). I’m leaving the implementations separate, for now, to make it easier for people to work with the languages independently.

Here is the C# code defining our RBLOAD command. You’ll need to add project references to IronRuby.dll, IronRuby.Libraries.dll, Microsoft.Scripting.dll and Microsoft.Scripting.Core.dll, all of which can be found in IronRuby’s bin folder. You’ll clearly also need to reference the usual acmgd.dll and acdbmgd.dll.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.EditorInput;

using IronRuby.Hosting;

using IronRuby;

using Microsoft.Scripting.Hosting;

using System;

 

namespace RubyLoader

{

  public class CommandsAndFunctions

  {

    [CommandMethod("-RBLOAD")]

    public static void RubyLoadCmdLine()

    {

      RubyLoad(true);

    }

 

    [CommandMethod("RBLOAD")]

    public static void RubyLoadUI()

    {

      RubyLoad(false);

    }

 

    public static void RubyLoad(bool useCmdLine)

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      short fd =

        (short)Application.GetSystemVariable("FILEDIA");

 

      // As the user to select a .rb file

 

      PromptOpenFileOptions pfo =

          new PromptOpenFileOptions(

            "Select Ruby script to load"

          );

      pfo.Filter = "Ruby script (*.rb)|*.rb";

      pfo.PreferCommandLine =

        (useCmdLine || fd == 0);

      PromptFileNameResult pr =

        ed.GetFileNameForOpen(pfo);

 

      // And then try to load and execute it

 

      if (pr.Status == PromptStatus.OK)

        ExecuteRubyScript(pr.StringResult);

    }

 

    [LispFunction("RBLOAD")]

    public ResultBuffer RubyLoadLISP(ResultBuffer rb)

    {

      const int RTSTR = 5005;

 

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      if (rb == null)

      {

        ed.WriteMessage("\nError: too few arguments\n");

      }

      else

      {

        // We're only really interested in the first argument

 

        Array args = rb.AsArray();

        TypedValue tv = (TypedValue)args.GetValue(0);

 

        // Which should be the filename of our script

 

        if (tv != null && tv.TypeCode == RTSTR)

        {

          // If we manage to execute it, let's return the

          // filename as the result of the function

          // (just as (arxload) does)

 

          bool success =

            ExecuteRubyScript(Convert.ToString(tv.Value));

          return

            (success ?

              new ResultBuffer(

                new TypedValue(RTSTR, tv.Value)

              )

              : null);

        }

      }

      return null;

    }

 

    private static bool ExecuteRubyScript(string file)

    {

      // If the file exists, let's load and execute it

 

      bool ret = System.IO.File.Exists(file);

      if (ret)

      {

        try

        {

          ScriptEngine engine = Ruby.CreateEngine();

          engine.ExecuteFile(file);

        }

        catch (System.Exception ex)

        {

          Document doc =

            Application.DocumentManager.MdiActiveDocument;

          Editor ed = doc.Editor;

 

          ed.WriteMessage(

            "\nProblem executing script: {0}", ex.Message

          );

        }

      }

      return ret;

    }

  }

}

Here’s my first attempt at a Ruby script which does basically the same as my original attempt for IronPython. I did find that not every .rb file was loadable by the RBLOAD command - presumably it only accepts certain text encoding standards – so I ended up pasting the code into a copy of one of the standard .rb files shipping in the IronRuby lib folder.

require 'C:\Program Files\Autodesk\AutoCAD 2009\acmgd.dll'

require 'C:\Program Files\Autodesk\AutoCAD 2009\acdbmgd.dll'

require 'C:\Program Files\Autodesk\AutoCAD 2009\acmgdinternal.dll'

 

# Function to register AutoCAD commands

 

def autocad_command(name) 

  cc =

    Autodesk::AutoCAD::Internal::CommandCallback.new method(name)

  Autodesk::AutoCAD::Internal::Utils.AddCommand(

    'rbcmds', name, name,

    Autodesk::AutoCAD::Runtime::CommandFlags.Modal, cc)

 

  # Let's now write a message to the command-line

 

  app = Autodesk::AutoCAD::ApplicationServices::Application

  doc = app.DocumentManager.MdiActiveDocument

  ed = doc.Editor

  ed.WriteMessage("\nRegistered Ruby command: {0}", name)

end

 

def add_commands(names)

  names.each { |n| autocad_command n }

end

 

# A simple "Hello World!" command

 

def msg

  app = Autodesk::AutoCAD::ApplicationServices::Application

  doc = app.DocumentManager.MdiActiveDocument

  ed = doc.Editor

  ed.WriteMessage "\nOur test command works!"

end

 

# And one to do something a little more complex...

# Adds a circle to the current space

 

def mycir

  app = Autodesk::AutoCAD::ApplicationServices::Application

  doc = app.DocumentManager.MdiActiveDocument

  db = doc.Database

 

  tr = doc.TransactionManager.StartTransaction

  bt =

    tr.GetObject(

      db.BlockTableId,

      Autodesk::AutoCAD::DatabaseServices::OpenMode.ForRead)

  btr =

    tr.GetObject(

      db.CurrentSpaceId,

      Autodesk::AutoCAD::DatabaseServices::OpenMode.ForWrite)

  cir =

    Autodesk::AutoCAD::DatabaseServices::Circle.new(

      Autodesk::AutoCAD::Geometry::Point3d.new(10, 10, 0),

      Autodesk::AutoCAD::Geometry::Vector3d.ZAxis, 2)

 

  btr.AppendEntity(cir)

  tr.AddNewlyCreatedDBObject(cir, true)

 

  tr.Commit

  tr.Dispose

end

 

add_commands ["msg", "mycir"]

The code differs slightly in approach than the corresponding Python script: I wasn’t aware of an equivalent method for Python decorators and so used a more explicit approach for adding AutoCAD commands. The code uses the same internal (and unsupported) assembly, acmgdinternal.dll, to register the commands dynamically with AutoCAD – that piece is basically the same – it’s just the method of choosing the functions to register that differs (see the call to add_commands() at the bottom of the script).

Otherwise the code is very similar, aside from the use of namespace aliases in IronPython (something that may very well exist in IronRuby – I just haven’t come across it yet).

The execution is analogous to the Python version. When we build and NETLOAD our RubyLoader C# application and execute the RBLOAD command, we can select our Ruby script:

Command: RBLOAD

Once selected, the script gets loaded and should register a couple of commands:

Registered Ruby command: msg

Registered Ruby command: mycir

Running the MSG command will execute a simple “Hello World!”-like function, just printing a message to the command-line:

Command: MSG

Our test command works!

And running the MYCIR command should just add a simple circle to the current space in the active drawing.

Command: MYCIR