Through the Interface: March 2008

Sun	Mon	Tue	Wed	Thu	Fri	Sat
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

« February 2008 | Main | April 2008 »

March 2008

March 28, 2008

Using a jig to rotate an AutoCAD entity via .NET

An interesting request came in via a previous post followed up by a similar question came in via another post. The original problem was to rotate a rectangular polyline entity around its centre, and be able to continue rotating it afterwards. A few things were interesting to me:

Rectangles are simply polylines between four points, so have no inherent concept of either a centre point or a rotation angle
- The obvious answer (to me, at least) being to calculate the centre and store the rotation as XData on the polyline
To modify an entity graphically it makes sense to use a jig
- Most examples show how to use jigs to create new entities, not modify existing ones

So with that in mind, I created the below C# code to solve this problem:

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.Geometry;
 
namespace RotatingRectangles
{
  public class Commands
  {
    // Define some constants we'll use to
    // store our XData
 
    // AppName is our RDS (TTIF, for
    // "Through The InterFace") plus an indicator
    // what it's for (ROTation)
 
    const string kRegAppName = "TTIF_ROT";
    const int kAppCode = 1001;
    const int kRotCode = 1040;
 
    class RotateJig : EntityJig
    {
      // Declare some internal state
 
      double m_baseAngle, m_deltaAngle;
      Point3d m_rotationPoint;
      Matrix3d m_ucs;
 
      // Constructor sets the state and clones
      // the entity passed in
      // (adequate for simple entities)
 
      public RotateJig(
        Entity ent,
        Point3d rotationPoint,
        double baseAngle,
        Matrix3d ucs)
        : base(ent.Clone() as Entity)
      {
        m_rotationPoint = rotationPoint;
        m_baseAngle = baseAngle;
        m_ucs = ucs;
      }
 
      protected override SamplerStatus Sampler(
        JigPrompts jp
      )
      {
        // We acquire a single angular value
 
        JigPromptAngleOptions jo =
          new JigPromptAngleOptions(
            "\nAngle of rotation: "
          );
        jo.BasePoint = m_rotationPoint;
        jo.UseBasePoint = true;
 
        PromptDoubleResult pdr =
          jp.AcquireAngle(jo);
 
        if (pdr.Status == PromptStatus.OK)
        {
          // Check if it has changed or not
          // (reduces flicker)
 
          if (m_baseAngle == pdr.Value)
          {
            return SamplerStatus.NoChange;
          }
          else
          {
            // Set the change in angle to
            // the new value
 
            m_deltaAngle = pdr.Value;
            return SamplerStatus.OK;
          }
        }
        return SamplerStatus.Cancel;
      }
 
      protected override bool Update()
      {
        // Filter out the case where a zero delta is provided
 
        if (m_deltaAngle > Tolerance.Global.EqualPoint)
        {
          // We rotate the polyline by the change
          // minus the base angle
 
          Matrix3d trans =
            Matrix3d.Rotation(
              m_deltaAngle - m_baseAngle,
              m_ucs.CoordinateSystem3d.Zaxis, 
              m_rotationPoint);
          Entity.TransformBy(trans);
 
          // The base becomes the previous delta
          // and the delta gets set to zero
 
          m_baseAngle = m_deltaAngle;
          m_deltaAngle = 0.0;
        }
 
        return true;
      }
 
      public Entity GetEntity()
      {
        return Entity;
      }
 
      public double GetRotation()
      {
        // The overall rotation is the
        // base plus the delta
 
        return m_baseAngle + m_deltaAngle;
      }
    }
 
    [CommandMethod("ROT")]
    public void RotateEntity()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      Database db = doc.Database;
 
      // First we prompt for the entity to rotate
 
      PromptEntityOptions peo =
        new PromptEntityOptions(
          "\nSelect entity to rotate: "
        );
      PromptEntityResult per =
        ed.GetEntity(peo);
 
      if (per.Status == PromptStatus.OK)
      {
        Transaction tr =
          db.TransactionManager.StartTransaction();
        using (tr)
        {
          DBObject obj =
            tr.GetObject(per.ObjectId, OpenMode.ForRead);
          Entity ent = obj as Entity;
 
          // Use the origin as the default center
 
          Point3d rotationPoint = Point3d.Origin;
 
          // If the entity is a polyline,
          // assume it is rectangular and then
          // set the rotation point as its center
 
          Polyline pl = obj as Polyline;
          if (pl != null)
          {
            LineSegment3d ps0 =
              pl.GetLineSegmentAt(0);
            LineSegment3d ps1 =
              pl.GetLineSegmentAt(1);
            Vector3d vec =
              ((ps0.EndPoint - ps0.StartPoint) / 2.0) +
              ((ps1.EndPoint - ps1.StartPoint) / 2.0);
            rotationPoint = pl.StartPoint + vec;
          }
 
          // Get the base rotation angle stored with the
          // entity, if there was one (default is 0.0)
 
          double baseAngle = GetStoredRotation(obj);
 
          if (ent != null)
          {
            // Get the current UCS, to pass to the Jig
 
            Matrix3d ucs =
              ed.CurrentUserCoordinateSystem;
 
            // Create our jig object
 
            RotateJig jig =
              new RotateJig(
                ent,
                rotationPoint,
                baseAngle, 
                ucs
              );
 
            PromptResult res = ed.Drag(jig);
            if (res.Status == PromptStatus.OK)
            {
              // Get the overall rotation angle
              // and dispose of the temp clone
 
              double newAngle = jig.GetRotation();
              jig.GetEntity().Dispose();
 
              // Rotate the original entity
 
              Matrix3d trans =
                Matrix3d.Rotation(
                  newAngle - baseAngle,
                  ucs.CoordinateSystem3d.Zaxis,
                  rotationPoint);
 
              ent.UpgradeOpen();
              ent.TransformBy(trans);
 
              // Store the new rotation as XData
 
              SetStoredRotation(ent, newAngle);
            }
          }
          tr.Commit();
        }
      }
    }
 
    // Helper function to create a RegApp
 
    static void AddRegAppTableRecord(string regAppName)
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      Editor ed = doc.Editor;
      Database db = doc.Database;
 
      Transaction tr =
        doc.TransactionManager.StartTransaction();
      using (tr)
      {
        RegAppTable rat =
          (RegAppTable)tr.GetObject(
            db.RegAppTableId,
            OpenMode.ForRead,
            false
          );
        if (!rat.Has(regAppName))
        {
          rat.UpgradeOpen();
          RegAppTableRecord ratr =
            new RegAppTableRecord();
          ratr.Name = regAppName;
          rat.Add(ratr);
          tr.AddNewlyCreatedDBObject(ratr, true);
        }
        tr.Commit();
      }
    }
 
    // Store our rotation angle as XData
 
    private void SetStoredRotation(
      DBObject obj, double rotation)
    {
      AddRegAppTableRecord(kRegAppName);
      ResultBuffer rb = obj.XData;
      if (rb == null)
      {
        rb =
          new ResultBuffer(
            new TypedValue(kAppCode, kRegAppName),
            new TypedValue(kRotCode, rotation)
          );
      }
      else
      {
        // We can simply add our values - no need
        // to remove the previous ones, the new ones
        // are the ones that get stored
 
        rb.Add(new TypedValue(kAppCode, kRegAppName));
        rb.Add(new TypedValue(kRotCode, rotation));
      }
      obj.XData = rb;
      rb.Dispose();
    }
 
    // Retrieve the existing rotation angle from XData
 
    private double GetStoredRotation(DBObject obj)
    {
      double ret = 0.0;
 
      ResultBuffer rb = obj.XData;
      if (rb != null)
      {
        // If we find our group code, it means that on
        // the next iteration, we'll get our rotation
 
        bool bReadyForRot = false;
        foreach (TypedValue tv in rb)
        {
          if (bReadyForRot)
          {
            if (tv.TypeCode == kRotCode)
              ret = (double)tv.Value;
            bReadyForRot = false;
          }
          if (tv.TypeCode == kAppCode)
            bReadyForRot = true;
        }
        rb.Dispose();
      }
      return ret;
    }
  }
}

To try this out, we can use the RECTANG command, to create a horizontal rectangle, and then use our custom ROT command to rotate it:

Calling the ROT command subsequently works fine, as it "remembers" the angle it was rotated at. If other tools are used to rotate the rectangle, all bets are off. One alternative would be to determine the "rotation" by performing slightly deeper analysis on the rectangle: determining the longer side and getting its angle should do it. It would also be trivial to implement a command to set the rotation to one input by the user (whether by selecting two points or entering it).

Update:

For some reason the Update() function gets called with a zero angle - something I've only noticed in AutoCAD 2011, so far. To protect against this, I've adjusted the above code to check m_deltaAngle against the standard tolerance: if it's less than that we ignore the call. This seems to solve the problem reported in the comments (thanks, Guillermo!).

Posted at 03:30 PM in AutoCAD, AutoCAD .NET, Jigs | Permalink | Comments (25) | TrackBack (0)

March 27, 2008

Embedding AutoCAD 2009 in a standalone dialog

This post takes a look at another topic outlined in this overview of the new API features in AutoCAD 2009.

AutoCAD 2009 introduces the ability to embed the application in a standalone dialog or form via an ActiveX control. This capability has been around for a number of releases of AutoCAD OEM, but this feature has now been made available in the main AutoCAD product.

The way the control works is to launch an instance of AutoCAD in the background (it should go without saying that AutoCAD needs to be installed on the system, but I've said it, anyway :-) and it then pipes the graphics generated by AutoCAD into the area specified by the bounds of the control. It also then pipes back any mouse movements or keystrokes, to allow the embedded AutoCAD to be controlled. It's pretty neat: you'll see the standard cursor, be able to enter commands via dynamic input, and more-or-less do whatever can be done inside the full product.

The control is especially handy if you want to present a reduced user-interface to the people using the product (which is really what AutoCAD OEM is for, in a nutshell, although the development effort involved in creating a full AutoCAD OEM application makes it inappropriate for quick & easy UI streamlining).

Let's start our look at this control by creating a new C# Windows Application project in Visual Studio 2005 (you can use whatever ActiveX container you like, though - it should even work from a web-page or an Office document):

Once Visual Studio has created the new project, we need to add our control to the toolbox. If you right-click on the toolbox, you'll be able to select "Choose Items...".

From here, there should be an item "AcCtrl" in the list of COM Components. Otherwise you can browse to it in c:\Program Files\Common Files\Autodesk Shared\AcCtrl.dll.

Then you simply need to place the control on your form.

Once we've done that, we're going to add a few more controls - for the drawing path, and a text string for commands we want to try "posting" to the embedded AutoCAD application.

Here's the C# code we'll use to drive the embedded control from the form. You should be able to work out what the various controls have been called in the project by looking at the code.

using System;
using System.Windows.Forms;

namespace EmbedAutoCAD
{
  public partial class MainForm : Form
  {
    public MainForm()
    {
      InitializeComponent();
    }

    private void browseButton_Click(
      object sender, EventArgs e)
    {
      OpenFileDialog dlg =
        new OpenFileDialog();
      dlg.InitialDirectory =
        System.Environment.CurrentDirectory;

      dlg.Filter = 
        "DWG files (*.dwg)|*.dwg|All files (*.*)|*.*";

      Cursor oc = Cursor;

      String fn = "";

      if (dlg.ShowDialog() ==
        DialogResult.OK)
      {
        Cursor = Cursors.WaitCursor;
        fn = dlg.FileName;
        Refresh();
      }
      if (fn != "")
        this.drawingPath.Text = fn;

      Cursor = oc;
    }
    private void loadButton_Click(
      object sender, EventArgs e)
    {
      if (System.IO.File.Exists(drawingPath.Text))
        axAcCtrl1.Src = drawingPath.Text;
      else
        MessageBox.Show("File does not exist");
    }

    private void postButton_Click(
      object sender, EventArgs e)
    {
      axAcCtrl1.PostCommand(cmdString.Text);
    }
  }
}

Finally, when we run the application and load a drawing via the browse/load buttons, the real fun starts. :-)

Try entering commands via dynamic input, or via the "Post a command" textbox. You might feel a little disorientated due to the lack of a command-line (I do love my command-line ;-), but dynamic input allows you to at least see what you're typing.

Here's the C# project for you to download.

Posted at 04:35 PM in AutoCAD, AutoCAD .NET, User interface | Permalink | Comments (20) | TrackBack (0)

March 25, 2008

Initialization code in your F# AutoCAD application

Back from a nice long weekend, although I spent most of it sick with a cold. I find this increasingly the way with me: I fend off illness for months at a time (probably through stress, truth be told) but then I get a few days off and wham. A shame, as we had a huge dump of snow over the weekend... we get white Christmases here every five years or so, but it's really uncommon to get a white Easter.

I had a very interesting question come in by email from 冷血儿, who wanted to get the technique shown in this post working in his F# application.

Here's the F# code I managed to put together after consulting hubFS, in particular:

#light

namespace MyNamespace

open Autodesk.AutoCAD.Runtime
open Autodesk.AutoCAD.ApplicationServices

type InitTest() =
  class
    let ed =
      Application.DocumentManager.MdiActiveDocument.Editor
    interface IExtensionApplication with
      member x.Initialize() =
        ed.WriteMessage
          ("\nInitializing - do something useful.")
      member x.Terminate() =
        printfn "\nCleaning up..."
  end
end

module MyApplication =
  let ed =
    Application.DocumentManager.MdiActiveDocument.Editor
  [<CommandMethod("TST")>]
  let f () =
    ed.WriteMessage("\nThis is the TST command.")
  [<assembly: ExtensionApplication(type InitTest)>]
  do
    ed.WriteMessage("\nModule do")

Here's what happens when we load our module and run the TST command:

Command: NETLOAD
Module do
Initializing - do something useful.
Command: TST
This is the TST command.

Posted at 11:26 AM in AutoCAD, AutoCAD .NET, F#, Notification / Events | Permalink | Comments (0) | TrackBack (1)

March 20, 2008

Implementing your own AutoCAD color combobox control using .NET

A big thanks to Scott McFarlane, from Geotropix, Inc., for sharing the code in this post. Here's an email I received from Scott:

I was reading this blog entry on “Through the Interface” and some folks were asking about how to implement .NET combo box versions of the color and linetype ActiveX controls that are available. I just wanted to share a simple .NET implementation of a color combo box. The color combo is quite easy, really. The linetype one would be more difficult.

Attached is the source code. This is just a generic color combo, that loads up with the 255 ACI colors. It has no dependency on AutoCAD – I was actually using this in an external program. It would be easy, however, to modify this to provide a list item to launch the built-in AutoCAD color dialog if used inside AutoCAD.

Here is the C# code Scott provided (which was in a source file named AcColorComboBox.cs):

using System;
using System.Collections;
using System.Drawing;
using System.Windows.Forms;

public class AcColorComboBox : ComboBox
{
  public class ColorItem
  {
    private short _colorIndex;
    private Color _color;

    public ColorItem(short colorIndex, Color color)
    {
      _colorIndex = colorIndex;
      _color = color;
    }

    public short ColorIndex
    {
      get { return _colorIndex; }
    }

    public Color Color
    {
      get { return _color; }
    }

    public override string ToString()
    {
      return AcColorComboBox.ColorNameOf(_colorIndex);
    }

  }

  public class ColorItemSorter : IComparer
  {
    public int Compare(object x, object y)
    {
      return ((ColorItem)x).ColorIndex - ((ColorItem)y).ColorIndex;
    }
  }

  private short _colorIndex;

  #region " Windows Form Designer generated code "

  public AcColorComboBox()
    : base()
  {
    // This call is required by the Windows Form Designer. 
    InitializeComponent();

    // Add any initialization after the InitializeComponent() call 
    DrawMode = DrawMode.OwnerDrawFixed;
    DropDownStyle = ComboBoxStyle.DropDownList;
  }

  // Override dispose to clean up the component list. 
  protected override void Dispose(bool disposing)
  {
    if (disposing)
    {
      if ((components != null))
      {
        components.Dispose();
      }
    }
    base.Dispose(disposing);
  }

  // Required by the Windows Form Designer 
  private System.ComponentModel.IContainer components;

  // NOTE: The following procedure is required by the Windows Form Designer 
  // It can be modified using the Windows Form Designer. 
  // Do not modify it using the code editor. 
  [System.Diagnostics.DebuggerStepThrough()]
  private void InitializeComponent()
  {
    components = new System.ComponentModel.Container();
  }

  #endregion

  protected override void OnDrawItem(System.Windows.Forms.DrawItemEventArgs e)
  {
    if (e.Index >= 0)
    {
      e.DrawBackground();
      e.DrawFocusRectangle();
      Rectangle r = e.Bounds;
      r.Inflate(-1, -1);
      r.Width = 20;
      r.Offset(1, 0);
      ColorItem objColor = (ColorItem)Items[e.Index];
      e.Graphics.FillRectangle(new System.Drawing.SolidBrush(objColor.Color), r);
      e.Graphics.DrawRectangle(new System.Drawing.Pen(Color.Black), r);
      e.Graphics.DrawString(objColor.ToString(), e.Font, new SolidBrush(e.ForeColor), e.Bounds.X + r.Width + 4, e.Bounds.Y);
    }
  }

  protected override void OnCreateControl()
  {
    Items.Clear();
    for (short i = 1; i < 256; i++)
      Items.Add(new ColorItem(i, ColorOf(i)));

    base.OnCreateControl();
  }

  // ColorValue represents colorId 
  public short ColorIndex
  {
    get { return _colorIndex; }
    set
    {
      _colorIndex = value;
      foreach (ColorItem objColor in Items)
      {
        if (objColor.ColorIndex == value)
        {
          SelectedItem = objColor;
          break;
        }
      }
    }
  }

  protected override void OnSelectedIndexChanged(System.EventArgs e)
  {
    _colorIndex = ((ColorItem)Items[SelectedIndex]).ColorIndex;
    base.OnSelectedIndexChanged(e);
  }

  public static string ColorNameOf(short colorIndex)
  {
    switch (colorIndex)
    {
      case 1:
        return "1 - Red";
      case 2:
        return "2 - Yellow";
      case 3:
        return "3 - Green";
      case 4:
        return "4 - Cyan";
      case 5:
        return "5 - Blue";
      case 6:
        return "6 - Magenta";
      case 7:
        return "7 - White";
      case 8:
        return "8 - Grey";
      default:
        return colorIndex.ToString();
    }
  }

  public static Color ColorOf(short colorIndex)
  {
    switch (colorIndex)
    {
      case 1:
        return Color.FromArgb(255, 0, 0);
      case 2:
        return Color.FromArgb(255, 255, 0);
      case 3:
        return Color.FromArgb(0, 255, 0);
      case 4:
        return Color.FromArgb(0, 255, 255);
      case 5:
        return Color.FromArgb(0, 0, 255);
      case 6:
        return Color.FromArgb(255, 0, 255);
      case 7:
        return Color.FromArgb(255, 255, 255);
      case 8:
        return Color.FromArgb(128, 128, 128);
      case 9:
        return Color.FromArgb(192, 192, 192);
      case 10:
        return Color.FromArgb(255, 0, 0);
      case 11:
        return Color.FromArgb(255, 127, 127);
      case 12:
        return Color.FromArgb(204, 0, 0);
      case 13:
        return Color.FromArgb(204, 102, 102);
      case 14:
        return Color.FromArgb(153, 0, 0);
      case 15:
        return Color.FromArgb(153, 76, 76);
      case 16:
        return Color.FromArgb(127, 0, 0);
      case 17:
        return Color.FromArgb(127, 63, 63);
      case 18:
        return Color.FromArgb(76, 0, 0);
      case 19:
        return Color.FromArgb(76, 38, 38);
      case 20:
        return Color.FromArgb(255, 63, 0);
      case 21:
        return Color.FromArgb(255, 159, 127);
      case 22:
        return Color.FromArgb(204, 51, 0);
      case 23:
        return Color.FromArgb(204, 127, 102);
      case 24:
        return Color.FromArgb(153, 38, 0);
      case 25:
        return Color.FromArgb(153, 95, 76);
      case 26:
        return Color.FromArgb(127, 31, 0);
      case 27:
        return Color.FromArgb(127, 79, 63);
      case 28:
        return Color.FromArgb(76, 19, 0);
      case 29:
        return Color.FromArgb(76, 47, 38);
      case 30:
        return Color.FromArgb(255, 127, 0);
      case 31:
        return Color.FromArgb(255, 191, 127);
      case 32:
        return Color.FromArgb(204, 102, 0);
      case 33:
        return Color.FromArgb(204, 153, 102);
      case 34:
        return Color.FromArgb(153, 76, 0);
      case 35:
        return Color.FromArgb(153, 114, 76);
      case 36:
        return Color.FromArgb(127, 63, 0);
      case 37:
        return Color.FromArgb(127, 95, 63);
      case 38:
        return Color.FromArgb(76, 38, 0);
      case 39:
        return Color.FromArgb(76, 57, 38);
      case 40:
        return Color.FromArgb(255, 191, 0);
      case 41:
        return Color.FromArgb(255, 223, 127);
      case 42:
        return Color.FromArgb(204, 153, 0);
      case 43:
        return Color.FromArgb(204, 178, 102);
      case 44:
        return Color.FromArgb(153, 114, 0);
      case 45:
        return Color.FromArgb(153, 133, 76);
      case 46:
        return Color.FromArgb(127, 95, 0);
      case 47:
        return Color.FromArgb(127, 111, 63);
      case 48:
        return Color.FromArgb(76, 57, 0);
      case 49:
        return Color.FromArgb(76, 66, 38);
      case 50:
        return Color.FromArgb(255, 255, 0);
      case 51:
        return Color.FromArgb(255, 255, 127);
      case 52:
        return Color.FromArgb(204, 204, 0);
      case 53:
        return Color.FromArgb(204, 204, 102);
      case 54:
        return Color.FromArgb(153, 153, 0);
      case 55:
        return Color.FromArgb(153, 153, 76);
      case 56:
        return Color.FromArgb(127, 127, 0);
      case 57:
        return Color.FromArgb(127, 127, 63);
      case 58:
        return Color.FromArgb(76, 76, 0);
      case 59:
        return Color.FromArgb(76, 76, 38);
      case 60:
        return Color.FromArgb(191, 255, 0);
      case 61:
        return Color.FromArgb(223, 255, 127);
      case 62:
        return Color.FromArgb(153, 204, 0);
      case 63:
        return Color.FromArgb(178, 204, 102);
      case 64:
        return Color.FromArgb(114, 153, 0);
      case 65:
        return Color.FromArgb(133, 153, 76);
      case 66:
        return Color.FromArgb(95, 127, 0);
      case 67:
        return Color.FromArgb(111, 127, 63);
      case 68:
        return Color.FromArgb(57, 76, 0);
      case 69:
        return Color.FromArgb(66, 76, 38);
      case 70:
        return Color.FromArgb(127, 255, 0);
      case 71:
        return Color.FromArgb(191, 255, 127);
      case 72:
        return Color.FromArgb(102, 204, 0);
      case 73:
        return Color.FromArgb(153, 204, 102);
      case 74:
        return Color.FromArgb(76, 153, 0);
      case 75:
        return Color.FromArgb(114, 153, 76);
      case 76:
        return Color.FromArgb(63, 127, 0);
      case 77:
        return Color.FromArgb(95, 127, 63);
      case 78:
        return Color.FromArgb(38, 76, 0);
      case 79:
        return Color.FromArgb(57, 76, 38);
      case 80:
        return Color.FromArgb(63, 255, 0);
      case 81:
        return Color.FromArgb(159, 255, 127);
      case 82:
        return Color.FromArgb(51, 204, 0);
      case 83:
        return Color.FromArgb(127, 204, 102);
      case 84:
        return Color.FromArgb(38, 153, 0);
      case 85:
        return Color.FromArgb(95, 153, 76);
      case 86:
        return Color.FromArgb(31, 127, 0);
      case 87:
        return Color.FromArgb(79, 127, 63);
      case 88:
        return Color.FromArgb(19, 76, 0);
      case 89:
        return Color.FromArgb(47, 76, 38);
      case 90:
        return Color.FromArgb(0, 255, 0);
      case 91:
        return Color.FromArgb(127, 255, 127);
      case 92:
        return Color.FromArgb(0, 204, 0);
      case 93:
        return Color.FromArgb(102, 204, 102);
      case 94:
        return Color.FromArgb(0, 153, 0);
      case 95:
        return Color.FromArgb(76, 153, 76);
      case 96:
        return Color.FromArgb(0, 127, 0);
      case 97:
        return Color.FromArgb(63, 127, 63);
      case 98:
        return Color.FromArgb(0, 76, 0);
      case 99:
        return Color.FromArgb(38, 76, 38);
      case 100:
        return Color.FromArgb(0, 255, 63);
      case 101:
        return Color.FromArgb(127, 255, 159);
      case 102:
        return Color.FromArgb(0, 204, 51);
      case 103:
        return Color.FromArgb(102, 204, 127);
      case 104:
        return Color.FromArgb(0, 153, 38);
      case 105:
        return Color.FromArgb(76, 153, 95);
      case 106:
        return Color.FromArgb(0, 127, 31);
      case 107:
        return Color.FromArgb(63, 127, 79);
      case 108:
        return Color.FromArgb(0, 76, 19);
      case 109:
        return Color.FromArgb(38, 76, 47);
      case 110:
        return Color.FromArgb(0, 255, 127);
      case 111:
        return Color.FromArgb(127, 255, 191);
      case 112:
        return Color.FromArgb(0, 204, 102);
      case 113:
        return Color.FromArgb(102, 204, 153);
      case 114:
        return Color.FromArgb(0, 153, 76);
      case 115:
        return Color.FromArgb(76, 153, 114);
      case 116:
        return Color.FromArgb(0, 127, 63);
      case 117:
        return Color.FromArgb(63, 127, 95);
      case 118:
        return Color.FromArgb(0, 76, 38);
      case 119:
        return Color.FromArgb(38, 76, 57);
      case 120:
        return Color.FromArgb(0, 255, 191);
      case 121:
        return Color.FromArgb(127, 255, 223);
      case 122:
        return Color.FromArgb(0, 204, 153);
      case 123:
        return Color.FromArgb(102, 204, 178);
      case 124:
        return Color.FromArgb(0, 153, 114);
      case 125:
        return Color.FromArgb(76, 153, 133);
      case 126:
        return Color.FromArgb(0, 127, 95);
      case 127:
        return Color.FromArgb(63, 127, 111);
      case 128:
        return Color.FromArgb(0, 76, 57);
      case 129:
        return Color.FromArgb(38, 76, 66);
      case 130:
        return Color.FromArgb(0, 255, 255);
      case 131:
        return Color.FromArgb(127, 255, 255);
      case 132:
        return Color.FromArgb(0, 204, 204);
      case 133:
        return Color.FromArgb(102, 204, 204);
      case 134:
        return Color.FromArgb(0, 153, 153);
      case 135:
        return Color.FromArgb(76, 153, 153);
      case 136:
        return Color.FromArgb(0, 127, 127);
      case 137:
        return Color.FromArgb(63, 127, 127);
      case 138:
        return Color.FromArgb(0, 76, 76);
      case 139:
        return Color.FromArgb(38, 76, 76);
      case 140:
        return Color.FromArgb(0, 191, 255);
      case 141:
        return Color.FromArgb(127, 223, 255);
      case 142:
        return Color.FromArgb(0, 153, 204);
      case 143:
        return Color.FromArgb(102, 178, 204);
      case 144:
        return Color.FromArgb(0, 114, 153);
      case 145:
        return Color.FromArgb(76, 133, 153);
      case 146:
        return Color.FromArgb(0, 95, 127);
      case 147:
        return Color.FromArgb(63, 111, 127);
      case 148:
        return Color.FromArgb(0, 57, 76);
      case 149:
        return Color.FromArgb(38, 66, 76);
      case 150:
        return Color.FromArgb(0, 127, 255);
      case 151:
        return Color.FromArgb(127, 191, 255);
      case 152:
        return Color.FromArgb(0, 102, 204);
      case 153:
        return Color.FromArgb(102, 153, 204);
      case 154:
        return Color.FromArgb(0, 76, 153);
      case 155:
        return Color.FromArgb(76, 114, 153);
      case 156:
        return Color.FromArgb(0, 63, 127);
      case 157:
        return Color.FromArgb(63, 95, 127);
      case 158:
        return Color.FromArgb(0, 38, 76);
      case 159:
        return Color.FromArgb(38, 57, 76);
      case 160:
        return Color.FromArgb(0, 63, 255);
      case 161:
        return Color.FromArgb(127, 159, 255);
      case 162:
        return Color.FromArgb(0, 51, 204);
      case 163:
        return Color.FromArgb(102, 127, 204);
      case 164:
        return Color.FromArgb(0, 38, 153);
      case 165:
        return Color.FromArgb(76, 95, 153);
      case 166:
        return Color.FromArgb(0, 31, 127);
      case 167:
        return Color.FromArgb(63, 79, 127);
      case 168:
        return Color.FromArgb(0, 19, 76);
      case 169:
        return Color.FromArgb(38, 47, 76);
      case 170:
        return Color.FromArgb(0, 0, 255);
      case 171:
        return Color.FromArgb(127, 127, 255);
      case 172:
        return Color.FromArgb(0, 0, 204);
      case 173:
        return Color.FromArgb(102, 102, 204);
      case 174:
        return Color.FromArgb(0, 0, 153);
      case 175:
        return Color.FromArgb(76, 76, 153);
      case 176:
        return Color.FromArgb(0, 0, 127);
      case 177:
        return Color.FromArgb(63, 63, 127);
      case 178:
        return Color.FromArgb(0, 0, 76);
      case 179:
        return Color.FromArgb(38, 38, 76);
      case 180:
        return Color.FromArgb(63, 0, 255);
      case 181:
        return Color.FromArgb(159, 127, 255);
      case 182:
        return Color.FromArgb(51, 0, 204);
      case 183:
        return Color.FromArgb(127, 102, 204);
      case 184:
        return Color.FromArgb(38, 0, 153);
      case 185:
        return Color.FromArgb(95, 76, 153);
      case 186:
        return Color.FromArgb(31, 0, 127);
      case 187:
        return Color.FromArgb(79, 63, 127);
      case 188:
        return Color.FromArgb(19, 0, 76);
      case 189:
        return Color.FromArgb(47, 38, 76);
      case 190:
        return Color.FromArgb(127, 0, 255);
      case 191:
        return Color.FromArgb(191, 127, 255);
      case 192:
        return Color.FromArgb(102, 0, 204);
      case 193:
        return Color.FromArgb(153, 102, 204);
      case 194:
        return Color.FromArgb(76, 0, 153);
      case 195:
        return Color.FromArgb(114, 76, 153);
      case 196:
        return Color.FromArgb(63, 0, 127);
      case 197:
        return Color.FromArgb(95, 63, 127);
      case 198:
        return Color.FromArgb(38, 0, 76);
      case 199:
        return Color.FromArgb(57, 38, 76);
      case 200:
        return Color.FromArgb(191, 0, 255);
      case 201:
        return Color.FromArgb(223, 127, 255);
      case 202:
        return Color.FromArgb(153, 0, 204);
      case 203:
        return Color.FromArgb(178, 102, 204);
      case 204:
        return Color.FromArgb(114, 0, 153);
      case 205:
        return Color.FromArgb(133, 76, 153);
      case 206:
        return Color.FromArgb(95, 0, 127);
      case 207:
        return Color.FromArgb(111, 63, 127);
      case 208:
        return Color.FromArgb(57, 0, 76);
      case 209:
        return Color.FromArgb(66, 38, 76);
      case 210:
        return Color.FromArgb(255, 0, 255);
      case 211:
        return Color.FromArgb(255, 127, 255);
      case 212:
        return Color.FromArgb(204, 0, 204);
      case 213:
        return Color.FromArgb(204, 102, 204);
      case 214:
        return Color.FromArgb(153, 0, 153);
      case 215:
        return Color.FromArgb(153, 76, 153);
      case 216:
        return Color.FromArgb(127, 0, 127);
      case 217:
        return Color.FromArgb(127, 63, 127);
      case 218:
        return Color.FromArgb(76, 0, 76);
      case 219:
        return Color.FromArgb(76, 38, 76);
      case 220:
        return Color.FromArgb(255, 0, 191);
      case 221:
        return Color.FromArgb(255, 127, 223);
      case 222:
        return Color.FromArgb(204, 0, 153);
      case 223:
        return Color.FromArgb(204, 102, 178);
      case 224:
        return Color.FromArgb(153, 0, 114);
      case 225:
        return Color.FromArgb(153, 76, 133);
      case 226:
        return Color.FromArgb(127, 0, 95);
      case 227:
        return Color.FromArgb(127, 63, 111);
      case 228:
        return Color.FromArgb(76, 0, 57);
      case 229:
        return Color.FromArgb(76, 38, 66);
      case 230:
        return Color.FromArgb(255, 0, 127);
      case 231:
        return Color.FromArgb(255, 127, 191);
      case 232:
        return Color.FromArgb(204, 0, 102);
      case 233:
        return Color.FromArgb(204, 102, 153);
      case 234:
        return Color.FromArgb(153, 0, 76);
      case 235:
        return Color.FromArgb(153, 76, 114);
      case 236:
        return Color.FromArgb(127, 0, 63);
      case 237:
        return Color.FromArgb(127, 63, 95);
      case 238:
        return Color.FromArgb(76, 0, 38);
      case 239:
        return Color.FromArgb(76, 38, 57);
      case 240:
        return Color.FromArgb(255, 0, 63);
      case 241:
        return Color.FromArgb(255, 127, 159);
      case 242:
        return Color.FromArgb(204, 0, 51);
      case 243:
        return Color.FromArgb(204, 102, 127);
      case 244:
        return Color.FromArgb(153, 0, 38);
      case 245:
        return Color.FromArgb(153, 76, 95);
      case 246:
        return Color.FromArgb(127, 0, 31);
      case 247:
        return Color.FromArgb(127, 63, 79);
      case 248:
        return Color.FromArgb(76, 0, 19);
      case 249:
        return Color.FromArgb(76, 38, 47);
      case 250:
        return Color.FromArgb(51, 51, 51);
      case 251:
        return Color.FromArgb(91, 91, 91);
      case 252:
        return Color.FromArgb(132, 132, 132);
      case 253:
        return Color.FromArgb(173, 173, 173);
      case 254:
        return Color.FromArgb(214, 214, 214);
      case 255:
        return Color.FromArgb(255, 255, 255);
      default:
        throw new ArgumentOutOfRangeException();
    }
  }
}

Thanks again, Scott. I'll be back with a post of my own after the long Easter weekend here in Switzerland.

Posted at 07:58 PM in AutoCAD, AutoCAD .NET, User interface | Permalink | Comments (1) | TrackBack (0)

March 17, 2008

A simple taxonomy of programming languages

Someone asked me recently how I categorize different programming paradigms. I thought it was a very interesting question, so here's what I responded. Please bear in mind that this is very much the way I see things, and is neither an exhaustive nor a formally-ratified taxonomy.

One way to look at languages is whether they're declarative or imperative:

Declarative programming languages map the way things are by building up “truths”: this category includes functional programming languages (such as Miranda, Haskell and Erlang) which tend to be mathematical in nature (you define equations) and start with lambda calculus as a foundation. The other main set of declarative languages are logic programming languages (such as Prolog), which start with propositional calculus as a foundation (you declare axioms that build up to a system against which you can run queries). Declarative languages tend to focus on describing the problem to solve, rather than how to solve it.

Imperative programming languages, on the other hand, are lists of instructions of what to do: I tend to consider procedural programming languages (such as C, COBOL, Fortran and Pascal) as a sub-category which focus on the definition and execution of sub-routines, while some people treat the terms imperative and procedural as synonyms.

Considering these definitions, object-oriented programming languages (such as Smalltalk and Eiffel) should probably be considered declarative, as conceptually they map real-world objects, but the truth is that the most popular OO languages (such as C++) are impure, and so most OO systems combine big chunks of procedural (i.e. imperative) code. Many people who think they’re doing OOP are actually packaging up procedures.

Note that I've tried not to list multi-paradigm languages such as Ada, C++ and F# in the above categorisation. It's possible that some of the languages I've listed are also multi-paradigm, but anyway.

One other way to think about languages is whether they’re top-down or bottom-up:

Bottom-up languages are ultimately layered on how a processor works (from machine code to assembly language to C & C++), while top-down languages start from the world of mathematics and logic and add language features that allow them to be used for programming (i.e. declarative languages are therefore top-down). This latter set of languages are starting to see increased adoption, as they assume much less (even nothing) about the underlying machinery, in which big changes are occurring with multiple processing cores being introduced (which essentially invalidate the assumptions of previous generations of programmers, who have been conditioned to think in terms of the processor's ability to store and access state).

Many popular - or soon to be popular - programming environments are pragmatic in nature: C++ allows OOP but can also be used for procedural programming, VB.NET now allows you to define and access objects while coming from a long line of procedural languages, F# is multi-paradigm, combining OO with functional and imperative programming.

There are bound to be people with differing views on this subject (and many of them are no doubt more intelligent and experienced in these matters than I), but this is how I would answer the question of how to categorise programming languages.

For those of you with an interest in the future of programming languages, I can strongly recommend the following Channel 9 episodes. If you're not aware of Channel 9, then prepare to be impressed: Microsoft has given a fantastic gift to the development community with this resource.

Burton Smith: On General Purpose Super Computing and the History and Future of Parallelism
Erik Meijer: Functional Programming
Anders Hejlsberg, Herb Sutter, Erik Meijer, Brian Beckman: Software Composability and the Future of Languages
Brian Beckman: Don't fear the Monads
Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 1
Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 2

Enjoy! :-)

Posted at 01:44 AM in Concurrent programming, F# | Permalink | Comments (2) | TrackBack (0)

March 13, 2008

Getting the full path of the active drawing in AutoCAD using .NET

I had a question come in by email about how to find out the full path of a drawing open inside AutoCAD. Here's some C# code that does just this:

using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;

namespace PathTest
{
  public class Commands
  {
    [CommandMethod("PTH")]
    public void DrawingPath()
    {
      Document doc =
        Application.DocumentManager.MdiActiveDocument;
      HostApplicationServices hs =
        HostApplicationServices.Current;
      string path =
        hs.FindFile(
          doc.Name,
          doc.Database,
          FindFileHint.Default
        );
      doc.Editor.WriteMessage(
        "\nFile was found in: " + path
      );
    }
  }
}

Here's what happens when you run the PTH command, with a file opened from an obscure location, just to be sure:

Command: pth
File was found in: C:\Temp\test.dwg

Update:

Tony Tanzillo wrote in a comment:

I think you could also read the Filename property of the Database to get the full path to the drawing, keeping in mind that if the drawing is a new, unsaved document, the Filename property returns the .DWT file used to create the new drawing.

Thanks, Tony - shame on me for missing the obvious. In my defence, I wrote the post in between meetings in Las Vegas, if that's any excuse. :-)

Posted at 08:50 PM in AutoCAD, AutoCAD .NET | Permalink | Comments (17) | TrackBack (0)

March 10, 2008

Using AutoCAD 2009's new transient graphics API to show point clouds from F#

To start off my series of more in-depth looks at the new APIs provided in AutoCAD 2009, I decided to extend some recently posted F# code to generate and draw transient point clouds to be slightly less transient: we'll see how to use the new transient graphics API in AutoCAD to display a cache of transient graphics, even after the view has been changed.

Some of you may be wondering about the amount of code I'm posting in F#. I find the technology extremely interesting and am also increasingly productive with it, so I've found myself gravitating towards using it more for my blog samples. I understand it's not for everyone, and I will definitely continue to post C# on a regular basis, but as I'm currently spending quite a lot of time on F# I'm somewhat selfishly posting what I'm doing, rather than duplicating effort.

A few people have asked me by email "so should I be learning F# now, rather than C#?". I generally recommend to people to carry on learning how to program in C# (or VB.NET, for that matter, although I personally prefer the syntax in C#), as this skill is currently more relevant in the industry than F# programming. I really like F#, but for me it's another (for now, secondary) tool for solving certain classes of problem. I will say, however, that learning functional programming makes you a better programmer overall, and FP techniques are making their way into more mainstream languages, such as VB.NET and C#. For instance, today we're going to be using a lambda expression to register an event-handler: anonymous functions or lambda expressions are now part of C#.

Why does FP make you a better programmer? Because it leads you away from relying on shared state and side-effects. I won't get into the details of that now, but reducing your reliance on shared state is a good thing for your code: at some point in the future it will more easily harness parallel processing capabilities such as multicore chips. So even if you don't use F# on a daily basis, the way that you look at problems after you've understood its fundamental approach could - one day - have significant implications on your code's performance.

I digress, although this has reminded me that I've been meaning to post a comparative piece on programming technologies, sometime soon.

Here's the F# code from this previous post, modified to make use of the transient graphics API in AutoCAD 2009 to draw its points (rather than using Editor.DrawVector() with a zero-length vector, which is how we did it last time).

// Use lightweight F# syntax

#light

// Declare a specific namespace and module name

module MyNamespaceRecursive.MyApplication

// Import managed assemblies

#I @"C:\Program Files\Autodesk\AutoCAD 2009"
#r "acdbmgd.dll"
#r "acmgd.dll"

open Autodesk.AutoCAD.Runtime
open Autodesk.AutoCAD.ApplicationServices
open Autodesk.AutoCAD.DatabaseServices
open Autodesk.AutoCAD.Geometry
open Autodesk.AutoCAD.GraphicsInterface

// Get a random vector on a plane

let randomVectorOnPlane pl =

  // Create our random number generator
  let ran = new System.Random()

  // First we get the absolute value
  // of our x, y and z coordinates

  let absx = ran.NextDouble()
  let absy = ran.NextDouble()

  // Then we negate them, half of the time

  let x = if (ran.NextDouble() < 0.5) then -absx else absx
  let y = if (ran.NextDouble() < 0.5) then -absy else absy

  let v2 = new Vector2d(x,y)
  new Vector3d(pl,v2)

// Get a random vector in 3D space

let randomVector3d() =

  // Create our random number generator
  let ran = new System.Random()

  // First we get the absolute value
  // of our x, y and z coordinates

  let absx = ran.NextDouble()
  let absy = ran.NextDouble()
  let absz = ran.NextDouble()

  // Then we negate them, half of the time

  let x = if (ran.NextDouble() < 0.5) then -absx else absx
  let y = if (ran.NextDouble() < 0.5) then -absy else absy
  let z = if (ran.NextDouble() < 0.5) then -absz else absz

  new Vector3d(x, y, z)

// Create some state to store information about
// the current view. We use this to determine
// when we need to update our transient
// graphics.

let mutable vd = new Vector3d(0.0,0.0,0.0)
let mutable vt = 0.0
let mutable vh = 0.0

// Check the view against our stored info:
// if anything has changed, update the
// cache and return true.

let viewChanged (vtr : ViewTableRecord) =
  if (vd <> vtr.ViewDirection ||
      vt <> vtr.ViewTwist ||
      vh <> vtr.Height) then
    vd <- vtr.ViewDirection
    vt <- vtr.ViewTwist
    vh <- vtr.Height
    true
  else
    false

// Here's where we'll store our list of DBPoint objects
// to be redrawn

let mutable savedpts = []

// Now we declare our command

[<CommandMethod("pts")>]
let createPoints () =

  // Let's get the usual helpful AutoCAD objects

  let doc =
    Application.DocumentManager.MdiActiveDocument
  let ed = doc.Editor
  let db = doc.Database

  // "use" has the same effect as "using" in C#

  use tr =
    db.TransactionManager.StartTransaction();

  // Get appropriately-typed BlockTable and BTRs

  let bt =
    tr.GetObject
      (db.BlockTableId,OpenMode.ForRead)
    :?> BlockTable

  let ms =
    tr.GetObject
      (bt.[BlockTableRecord.ModelSpace],
      OpenMode.ForRead)
    :?> BlockTableRecord

  // A function that accepts an ObjectId and returns
  // a list of random points on its surface

  let rec getNPoints n (sol:Solid3d) ptlist =
    if n <= 0 then
      ptlist
    else
      let mp = sol.MassProperties

      let pl = new Plane()

      pl.Set(mp.Centroid,randomVector3d())
      let reg = sol.GetSection(pl)
      let ray = new Ray()
      ray.BasePoint <- mp.Centroid
      ray.UnitDir <- randomVectorOnPlane pl

      let pts = new Point3dCollection()
      reg.IntersectWith
        (ray,
        Intersect.OnBothOperands,
        pts,
        0, 0)

      pl.Dispose()
      reg.Dispose()
      ray.Dispose()

      getNPoints
        (n - pts.Count) sol
        (ptlist @ Seq.untyped_to_list pts)

  let generatePoints numPoints (x : ObjectId) =
    let obj = tr.GetObject(x,OpenMode.ForRead)
    match obj with
    | :? Solid3d ->
      let sol = (obj :?> Solid3d)
      getNPoints numPoints sol []
    | _ -> []

  // Create a DBPoint from a Point3d

  let to_db_point pt =
    let dbp = new DBPoint(pt)
    dbp.ColorIndex <- 1
    dbp

  // Add a single point (or any "drawable" object, for that
  // matter) to the transient graphics manager.

  let drawTransient x =
    let tm = TransientManager.CurrentTransientManager
    let ic = new IntegerCollection()
    tm.AddTransient
      (x, TransientDrawingMode.DirectShortTerm, 0, ic)
        |> ignore

  // We'll generate 100K points per solid
  // (the below line simply defined a new function
  // by currying (fixing one argument for) another
  // function)

  let points = generatePoints 100000

  // Save the points we generate in our mutable state

  savedpts <-
    Seq.untyped_to_list ms |>  // ObjectIds from modelspace
      List.map points |>       // Get points for each object
        List.concat |>         // No need for the outer list
          List.map to_db_point // Get DBPoints

  // And then add each point to the transient graphics system

  List.iter drawTransient savedpts

  // As usual, committing is cheaper than aborting

  tr.Commit()

  // Add an event handler to respond to the doc-lock changed
  // event. This happens after every doc-centric command
  // (for instance), so we check whether the view has changed
  // before starting a potentially time-consuming operation.

  Application.DocumentManager.DocumentLockModeChanged.Add
    (fun _ -> 
      if viewChanged (ed.GetCurrentView()) then
        for pt in savedpts do
          let tm = TransientManager.CurrentTransientManager
          let ic = new IntegerCollection()
          tm.UpdateTransient(pt, ic) |> ignore)

Some interesting points about this code:

We now store a list (potentially a very big list) of points in memory, in the savedpts variable
- These are DBPoints, as they need to be "drawable" to be managed by the transient graphics subsystem
The use of the new transient graphics API is in the drawTransient function, which does the equivalent of this C# call:
- Autodesk.AutoCAD.GraphicsInterface. TransientManager.CurrentTransientManager.AddTransient(pt, TransientDrawingMode.DirectShortTerm, 0, new IntegerCollection());
- This API can be used to draw any "drawable" object - it doesn't have to be one that would typically be stored in the DWG file. It can be used to display custom glyphs and tooltips, for instance
  - Check out the ObjectARX (C++) sample under ObjectARX 2009\samples\graphics\AsdkTransientGraphicsSampFolder for more details
We register an event handler to update the display of these points when the view has changed
- We do not currently have a viewChanged event exposed through the managed API, so we check for DocumentLockChanged and then see whether the view has changed there
  - We store some state about the previous view, so we know when it has changed
- This event handler calls the equivalent of this C# code:
  - Autodesk.AutoCAD.GraphicsInterface. TransientManager.CurrentTransientManager.UpdateTransient(pt, new IntegerCollection());
- See how easy it is to register an event handler in F#: the use of lambda expressions makes this really trivial (no need to define a function that we specify as a delegate). We also use the underscore ("_") to state we don't care about the arguments passed to the event handler, in this particular situation. Very neat.

Here's what happens when we run the PTS command on a set of 6 solids:

We can see the points disappear when we perform a 3DORBIT:

When we exit the orbit, our old point graphics are displayed...

Until the event handler kicks in and updates the display of our points:

Posted at 02:05 PM in AutoCAD, AutoCAD .NET, F#, ObjectARX, Point clouds | Permalink | Comments (7) | TrackBack (0)

March 05, 2008

New APIs in AutoCAD 2009

I've been taking some time this week to dive into some of the new APIs available in AutoCAD 2009. I'm going to post a very quick overview of the APIs available in this post, following up with a more in-depth look at some of the individual APIs in posts over the coming weeks.

I've used material presented at our most recent ADN Developer Days tour as a source of information (a big thanks to Fenton Webb, from DevTech Americas, who was largely responsible for developing this content).

Before talking about the new APIs, the first thing to note is that AutoCAD 2009 is a binary application compatible release with AutoCAD 2007 and 2008. Check out this previous post for information on our typical application compatibility schedule for AutoCAD. So while you will need to modify the demand-loading information to be stored under the correct Registry key (17.2), no changes should be needed to your application's modules.

AutoCAD 2009 has been built with Visual Studio 2005 SP1, but if you require compatibility with AutoCAD 2007 or 2008 for your ObjectARX application, you should continue to build it with Visual Studio 2005 RTM. If you use the .NET API for AutoCAD (or COM, for that matter) you will not need to worry about the version of the compiler.

Here are the major new APIs available via .NET and ObjectARX for AutoCAD 2009. I've listed the .NET namespace, where one exists, or have otherwise listed the API as "ObjectARX-only".

User Interface enhancements
- Ribbon Bar, Menu Browser, Task Dialog, Tooltips
- Implemented using the Windows Presentation Foundation (WPF)
- Autodesk.Windows
Quick Properties
- The feature uses existing static and dynamic COM properties for objects
- New COM interfaces for more control
  - IFilterableProperty, IFilterablePropertySource, IFilterableMultiplePropertySource, IFilterableSubtypePropertySource
Transient Graphics
- More flexible handling of all kinds of transient graphics
- Autodesk.AutoCAD.GraphicsInterface.TransientManager
3D Navigation
- Control over the new 3D navigation controls in AutoCAD
- ViewCube / Steering Wheel / ShowMotion
- ObjectARX-only
Data Extraction
- Easily extract AutoCAD object properties
- Autodesk.AutoCAD.DataExtraction
In-Place ActiveX Control
- Embed AutoCAD 2009 inside an ActiveX container
  - Web-page, Office document, WinForms application, etc.
InfoCenter
- Enhanced InfoCenter API
- Autodesk.AutoCAD.Windows.InfoCenter
Geo-Location
- Allows mapping of AutoCAD drawing units to real-world geography
- Autodesk.AutoCAD.DatabaseServices.GeoLocationData
Material Map
- Opt out of using texture filtering during render
- Autodesk.AutoCAD.GraphicsInterface.MaterialMap
Boundary Representation
- .NET wrapper for the ObjectARX API
- Autodesk.AutoCAD.BoundaryRepresentation
Associative Dimensioning
- New API for an existing feature
- ObjectARX-only
Permanent object deletion
- Allows actual deletion of erased objects
- ObjectARX-only
New ObjectARX smart pointer
- Avoids open conflicts
  - Allows optimized opening, returns existing opened objects
  - Including open for write!
  - Allows opening for write on Locked Layers
- AcDbSmartObjectPointer protocol-compatible with AcDbObjectPointer
- ObjectARX-only
New events & reactors
- Many new notifications, including:
  - Annotation Scale, Regen, ViewCube, Steering Wheel, Ribbon events...

Last but by no means least, the ObjectARX SDK for AutoCAD 2009 includes a brand-new AutoCAD .NET Reference. It's really nice!

By the way, this is my first post created using Windows Live Writer. It seems like quite a handy tool, so far.

Posted at 11:38 PM in AutoCAD, AutoCAD .NET, ObjectARX | Permalink | Comments (11) | TrackBack (0)

Through the Interface

Kean Walmsley

May 2012

Post Index

Reverse Index

Twitter Updates

Autodesk Blogs