Through the Interface

Show me the money!

Or otherwise named “Creating an AutoCAD jig to dynamically display a guilloché pattern using F#”. But then why pass up the chance for a Jerry Maguire reference? :-)

Anyway, to continue on from last week’s post, Doug – who had presented the original challenge – went on to suggest that I give it the same treatment as Spiro. Basically to implement a jig to display the guilloche pattern dynamically as you input the various options.

I understand the difficulty in understanding the nature of the geometry being created in the previous version… the fact that I’d named the original variables R, r, p, Q, m and n (as per the equation in the post that inspired this app) probably didn’t help with the understandability of the app, all things considered. It was certainly easier to name the various parameters in that way rather than work out more human-friendly labels.

This time around, though, I found additional help from this site, which includes a very cool Flash-based guilloché configurator. And as it also provided source code, I was able to connect some of the exposed UI elements with the underlying formula.

Which has given rise to this version of the app, with an additional GUIJIG command to complement GUILLOCHE. We’re also now storing the previous selections – whether via the jig- or the prompt-based version – so there’s an accompanying GUIDEF command to reset these default values should they become confused or confusing (and that’s quite easy to do with this app).

So here’s the updated F# code. Bear in mind this is still very much in the experimental stage, so expect quirks. If you have some ideas on how to improve it (such as an alternative name for the “Wiggle” parameter :-) then please let me know.

module Guillocher.Commands

 

open Autodesk.AutoCAD.ApplicationServices.Core

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// Save our various default values in mutable state

 

let mutable _R = 50.0

let mutable _r = -0.2

let mutable _p = 25.0

let mutable _Q = 3.0

let mutable _m = 1.0

let mutable _n = 6.0

let mutable _segs = 300

let mutable _perfSegs = 1000

 

// User prompting helper functions

 

let getIntegerWithDefault (ed : Editor) msg min max def =

  let pio = new PromptIntegerOptions(msg)

  pio.LowerLimit <- min

  pio.UpperLimit <- max

  pio.DefaultValue <- def

  pio.UseDefaultValue <- true

 

  let pir = ed.GetInteger(pio)

  if pir.Status = PromptStatus.OK then

    Some(pir.Value)

  else

    None

 

let getDoubleWithDefault (ed : Editor) msg neg zero def =

  let pdo = new PromptDoubleOptions(msg)

  pdo.AllowNegative <- neg

  pdo.AllowZero <- zero

  pdo.DefaultValue <- def

  pdo.UseDefaultValue <- true

 

  let pdr = ed.GetDouble(pdo)

  if pdr.Status = PromptStatus.OK then

    Some(pdr.Value)

  else

    None

 

// Get the various values we need from the user for this command

 

let getGuillocheInput ed =

  let R = getDoubleWithDefault ed "\nR" true false _R

  if R = None then

    None

  else

    let r = getDoubleWithDefault ed "\nr" true false _r

    if r = None then

      None

    else

      let p = getDoubleWithDefault ed "\np" true false _p

      if p = None then

        None

      else

        let Q = getDoubleWithDefault ed "\nQ" true true _Q

        if Q = None then

          None

        else

          let m = getDoubleWithDefault ed "\nm" true false _m

          if m = None then

            None

          else

            let n = getDoubleWithDefault ed "\nn" true false _n

            if n = None then

              None

            else

              let segs =

                getIntegerWithDefault

                  ed "\nNumber of control points" 500 32767 _segs

              if segs = None then

                None

              else

                let ppr = ed.GetPoint("\nSelect center point")

                if ppr.Status = PromptStatus.OK then

 

                  // Set the selected values as our new defaults

                  // (stored in mutable global state)

 

                  _R <- R.Value

                  _r <- r.Value

                  _p <- p.Value

                  _Q <- Q.Value

                  _m <- m.Value

                  _n <- n.Value

                  _segs <- segs.Value

 

                  // Return these to the calling function for it to

                  // create the guilloche

 

                  Some(R, r, p, Q, m, n, segs, ppr.Value)

                else

                  None

 

let pointsOnGuilloche (cen : Point3d)  R r p Q m n segs =

  [|

    let period = Math.PI * 2.0;

    for theta in 0.0..period/(float segs)..period do

 

      let rr = R + r

      let rp = r + p

      let rror = rr / r

      let mth = m * theta

      let nth = n * theta

      let k = rror * mth

      let x =

        rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth)

      let y =

        rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth)

 

      yield cen + new Vector3d(x, y, 0.0)

  |]

 

// Different modes of acquisition for our jig

 

type AcquireMode =

  | RADIUS

  | MAJOR

  | MINOR

  | MULTIPLIER

  | WIGGLE

 

type GuillocheJig() as this = class

  inherit DrawJig()

 

  // Our mutable member state

 

  let mutable (_sp : Spline) = new Spline()

  let mutable _cen = Point3d.Origin

  let mutable _norm = Vector3d.ZAxis

  let mutable _locp = _p

  let mutable _locR = _R

  let mutable _locr = _r

  let mutable _locQ = _Q

  let mutable _locm = _m

  let mutable _mode = RADIUS

 

  // Calculate some ratios, so that we keep proportions

  // as we jig the initial values

 

  let _rOverP = _r / _p

  let _ROverP = _R / _p

  let _rOverR = _r / _R

 

  member x.StartJig(ed : Editor, pt) =

 

    // Set our center and start with the radius

 

    _cen <- pt

    _mode <- RADIUS

    _norm <- ed.CurrentUserCoordinateSystem.CoordinateSystem3d.Zaxis

 

    let stat = ed.Drag(this)

    if stat.Status = PromptStatus.OK then

 

      // Next we get the major ripple

 

      _mode <- MAJOR

      let stat = ed.Drag(this)

      if stat.Status = PromptStatus.OK then

 

        // Next the minor ripple

 

        _mode <- MINOR

        let stat = ed.Drag(this)       

        if stat.Status = PromptStatus.OK then

 

          // Next the angle multiplier

 

          _mode <- MULTIPLIER

          let stat = ed.Drag(this)       

          if stat.Status = PromptStatus.OK then

 

            // Next the wiggle

 

            _mode <- WIGGLE

            ed.Drag(this)

          else

            stat

        else

          stat

      else

        stat

    else

      stat

 

  // Helper function to acquire a distance and return

  // the appropriate status

 

  member private x.GetDist (prompts : JigPrompts)

    (opts : JigPromptDistanceOptions) oldVal =

 

    opts.DefaultValue <- oldVal

    let res = prompts.AcquireDistance(opts)

    if res.Status <> PromptStatus.OK then

      (SamplerStatus.Cancel, 0.0)

    else

      if oldVal = res.Value then

        (SamplerStatus.NoChange, 0.0)

      else

        (SamplerStatus.OK, res.Value)

 

  // Our Sampler function to acquire the various distances

 

  override x.Sampler prompts =

 

    // We're just acquiring distances

 

    let jo = new JigPromptDistanceOptions()

    jo.BasePoint <- _cen

    jo.Cursor <- CursorType.RubberBand

    jo.UseBasePoint <- true

    jo.UserInputControls <-

      UserInputControls.NoZeroResponseAccepted

 

    // Then we have slightly different behavior depending

    // on the info we're acquiring

 

    match _mode with

 

    // p...

 

    | RADIUS ->

      jo.Message <- "\nRadius"

      let (stat, res) = x.GetDist prompts jo _locp

      if stat = SamplerStatus.OK then

        _locp <- res

      stat

 

    // R...

 

    | MAJOR ->

      jo.Message <- "\nMajor ripple"

      let (stat, res) = x.GetDist prompts jo _locR

      if stat = SamplerStatus.OK then

        _locR <- res

      stat

 

    // r...

 

    | MINOR ->

      jo.Message <- "\nMinor ripple"

      let (stat, res) = x.GetDist prompts jo _locr

      if stat = SamplerStatus.OK then

        _locr <- res

      stat

 

    // m...

 

    | MULTIPLIER ->

      jo.Message <- "\nAngle multiplier"

      let (stat, res) = x.GetDist prompts jo _locm

      if stat = SamplerStatus.OK then

        _locm <- res

      stat

 

    // Q...

 

    | WIGGLE ->

      jo.Message <- "\nWiggle"

      let (stat, res) = x.GetDist prompts jo _locQ

      if stat = SamplerStatus.OK then

        _locQ <- res

      stat

 

  // Our WorldDraw function to display the guilloche and

  // the related temporary graphics

 

  override x.WorldDraw

    (draw : Autodesk.AutoCAD.GraphicsInterface.WorldDraw) =

 

    // We'll actually only draw a green circle for our radius

 

    if _mode = RADIUS then

      let col = draw.SubEntityTraits.Color

      draw.SubEntityTraits.Color <- (int16 3)

      draw.Geometry.Circle(_cen, _locp, _norm) |> ignore

      draw.SubEntityTraits.Color <- col

 

    // Check the RegenAbort flag...

    // If it's set then we drop out of the function

 

    if not draw.RegenAbort then   

 

      // Generate the spline with low accuracy

      // (fewer control points == quicker)

 

      match _mode with

 

      | RADIUS ->

 

        // Make sure we don't have a p of 0

 

        if _locp = 0.0 then _locp <- 0.001

 

        x.Generate

          (_locp * _ROverP, _locp * _rOverP, _locp,

            _locQ, _locm, _n, _segs)

 

      | MAJOR ->

 

        x.Generate

          (_locR, _locR * _rOverR, _locp, _locQ, _locm, _n, _segs)

 

      | _ ->

 

        x.Generate(_locR, _locr, _locp, _locQ, _locm, _n, _segs)

 

      if not draw.RegenAbort then

        draw.Geometry.Draw(_sp) |> ignore

 

    true

 

  // Set the global defaults based on the last set of successful

  // input values

 

  member x.SetDefaults() =

    _R <- _locR

    _p <- _locp

    _r <- _locr

    _Q <- _locQ

    _m <- _locm

 

  // Generate a more accurate spline

 

  member x.Perfect() =

 

    x.Generate(_R, _r, _p, _Q, _m, _n, _perfSegs)

 

  // Generate a spline

 

  member x.Generate(R, r, p, Q, m, n, num) =

 

    // Generate control points based on the accuracy

 

    let pts = pointsOnGuilloche _cen R r p Q m n num

 

    if _sp <> null then

      _sp.Dispose()

 

    _sp <- new Spline(new Point3dCollection(pts), 1, 0.)

 

  // Accessor for the entity

 

  member x.GetEntity() = _sp

 

  // Let the caller clean-up when cancelling

 

  member x.CleanUp() = _sp.Dispose()

 

end

 

// Our jig-based command

 

[<CommandMethod("GUIJIG")>]

let guillochejig() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc = Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Prompt the user for the center of the spiro

 

  let cenRes = ed.GetPoint("\nSelect center point: ")

 

  if cenRes.Status = PromptStatus.OK then

 

    let cen = cenRes.Value

 

    // Create the spline and run the jig

 

    let jig = new GuillocheJig()

    let res = jig.StartJig(ed, cen)

 

    if res.Status = PromptStatus.OK then

 

      // Perfect the spline created, smoothing it up

 

      jig.SetDefaults()

      jig.Perfect()

 

      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.ForWrite)

            :?> BlockTableRecord

 

      // Add our spline to the modelspace

 

      let sp = jig.GetEntity()

      let id = ms.AppendEntity(sp)

      tr.AddNewlyCreatedDBObject(sp, true)

 

      tr.Commit()

 

    else

 

      jig.CleanUp()

 

// Set the values back to the program defaults

 

[<CommandMethod("GUIDEFS")>]

let resetGuillocheDefaults() =

  _R <- 50.0

  _r <- -0.2

  _p <- 25.0

  _Q <- 3.0

  _m <- 1.0

  _n <- 6.0

 

[<CommandMethod("GUILLOCHE")>]

let guilloche() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc = Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // First we need some user input

 

  match getGuillocheInput ed with

  | None -> ()

  | Some(R, r, p, Q, m, n, segs, cen) ->

 

    // Next we get a sampling of points along the Guilloche geometry

 

    let pts =

      pointsOnGuilloche

        Point3d.Origin

        R.Value r.Value p.Value Q.Value m.Value n.Value segs.Value

 

    // Use the points as control points on a spline

 

    let sp = new Spline(new Point3dCollection(pts), 1, 0.)

 

    // Move the geometry to the selected point

 

    sp.TransformBy(Matrix3d.Displacement(cen.GetAsVector()))

 

    // Use a transaction to add our spline to the model-space

 

    use tr = db.TransactionManager.StartTransaction()

 

    // Get appropriately-typed BlockTableRecord

 

    let btr =

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

        :?> BlockTableRecord

 

    // Add our curve to the model-space

 

    let id = btr.AppendEntity(sp)

    tr.AddNewlyCreatedDBObject(sp, true)

 

    // Commit the transaction

 

    tr.Commit()

Here’s an example guilloché pattern being created via GUIJIG. You’re going to have a tough time creating a specific pattern that you’re aiming for, but it’s worth persevering – every so often you strike gold. :-)

Doug also mentioned filling a certain area with a pattern. In this case, I just drew a rectangular polyline using RECTANG and then used TRIM to remove the parts of the spline outside of it. It took a few crossing window selections, but it got there eventually.

Inaugural Zurich .NET Developer meet-up

I headed cross to the Zurich area on Tuesday afternoon – which is quite a trek from where I live, around ~2.5 hours by train – to attend the first Zurich .NET Developer meet-up. The event was held in the Microsoft office in Wallisellen: they kindly provided beer and the meeting room, while the session itself was organised by members of the local .NET community. Considering the weather – a pretty serious snowstorm hit the country that day – the event was surprisingly well attended.

The main topic of the session was MVVM Light, a lightweight framework developed by Laurent Bugnion that makes it easier to implement the Model View ViewModel architectural pattern. Laurent spent some time introducing Windows 8 development and then went on to talk about how MVVM Light can be used to develop for both Windows 8 and prior releases of the OS (and Windows Phone, for that matter):

It was an interesting session: I’d made use of MVC before, but not MVVM. I admittedly tend not to do very much with UI frameworks – I dabble with WPF from time to time, but it’s a rare thing – but I’ll certainly consider using MVVM Light for UI-centric projects in future.

After this session I stayed around to chat with other attendees, the organisers and some Microsoft employees I’d met at previous events. It was a fun evening, and has certainly sparked my interest in going to other such events. I may even offer to present some of the work I’ve been doing to integrate Kinect with AutoCAD, which some members of the local .NET community may find of interest..

After checking out the other groups of interest on meetup.com, I’ve signed up for Zurich FSharp Users, 3D Printing Zurich and ARCH-Swiss Augmented Reality, although I know I’ll end up having to pick and choose between the various physical meetings, if nothing else because of the distance involved. I see there are also meetups in Basel and Geneva – both of which are a bit nearer to my home town – so perhaps I’ll look for interesting groups to join there, too.

Displaying a dialog on AutoCAD startup using .NET

This post is based on some information provided by Peter Muigg, a developer in Germany Austria who has long been a friend of Autodesk. In fact, if memory serves me well – and do step in if I’m mis-remembering, Peter – back in 1995 when I first joined the company, Peter delivered German-language ObjectARX training on behalf of Autodesk.

Peter reached out with this tip just before the holiday break: he needed to display a dialog on AutoCAD startup, but found that it was too soon to do so on IExtentionApplication.Initialize() (it’s assumed this module is either demand- or auto-loaded, by the way – manual loading doesn’t tend to exhibit this issue).

I typically use the approach of posting a command/queueing up a LISP expression to execute on startup to do this, but Peter has successfully used the Application.Idle event, instead.

Here’s Peter’s C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.Runtime;

using System;

 

public class App : IExtensionApplication

{

  static MyPalette _palette;

 

  public void Initialize()

  {

    // ... other stuff

 

    // Create a hook on the "Idle" event of the application class

 

    Application.Idle += new EventHandler(Application_Idle);

 

  }

 

  void Application_Idle(object sender, EventArgs e)

  {

    // Remove the event handler as it is no longer needed

 

    Application.Idle -= Application_Idle;

    _palette = new MyPalette();

    _palette.Visible = true;

  }

 

  // ...

}

The code itself shouldn't need any explanation – it's both simple and elegant. Thanks for sharing it, Peter!

Update:

Peter has since clarified he’s based in Innsbruck, so I’ve updated the post accordingly. My apologies for getting that wrong, especially being based in neighbouring Switzerland! :-(

Hooking into AutoCAD copy & paste via Ctrl-C and -V

This was a fun question that came in from James Meading. I genuinely didn’t think I’d manage to look into it before the break, but it tweaked my interest during my trip back from the UK:

I thought this might be a topic you would be interested in. I do not use ctrl-v for pasting entities, only text to command line.

I already tried removing the keyboard shortcuts to ctrl-v via the cui, and that just makes ctrl-v not do anything when command line does not have focus.

So I think I need to write a transparent function, make a command in the CUI that runs the function, and assign ctrl-v to it. Its the transparent part I have never done.

I would want the “enhanced paste” routine to be able to run inside any other command gracefully. Maybe this is just running a little function that runs before paste.

This really sounded like an interesting little problem but also a very useful bit of functionality: basically you could have AutoCAD change its “paste” behaviour based on the type of data in the clipboard. For instance, if the clipboard contains drawing data, let the PASTECLIP command have at it. If it contains text, send it to the command-line.

I decided to generalise the request (and ultimately the solution) to encompass copy operations, too. At  a basic level, we can just hook into Ctrl-C and then look at the selection set chosen by the user: in our case we’re just going to write a message to the command-line mentioning the number of objects selected, but we might choose only to call COPYCLIP under certain circumstances. We might also use this opportunity to add certain objects into the operation (although there are other ways this might be achieved inside AutoCAD).

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace InterceptCopyPaste

{

  public class Commands

  {

    // For our command to intercept PASTECLIP, we don't care

    // about the pickfirst set: it just needs to be transparent

 

    [CommandMethod("PCINT", CommandFlags.Transparent)]

    static public void PasteClipIntercept()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      // Get the contents of the clipboard

 

      var obj =

        (System.Windows.Forms.DataObject)

          System.Windows.Forms.Clipboard.GetDataObject();

 

      if (obj != null)

      {

        // Find out whether the clipboard contains AutoCAD data

 

        var formats = obj.GetFormats();

        bool foundDwg = false;

        foreach (var name in formats)

        {

          if (name.Contains("AutoCAD.r"))

          {

            foundDwg = true;

            break;

          }

        }

        if (foundDwg)

        {

          // If so, start the PASTECIP command, cancelling any

          // active commands (we may have been called transparently)

 

          doc.SendStringToExecute(

            "\x1B\x1B_.PASTECLIP ", true, false, true

          );

        }

        else

        {

          // If not, try to get text data from the clipboard

 

          var text = (string)obj.GetData("Text");

          if (!string.IsNullOrEmpty(text))

          {

            // If there is some, send it to the command-line

 

            doc.SendStringToExecute(text, true, false, true);

          }

        }

      }

    }

 

    // For the command that intercepts COPYCLIP, we need not only

    // a transparent command, but one with pickfirst support

 

    [CommandMethod(

      "CCINT",

      CommandFlags.Transparent |

      CommandFlags.Redraw |

      CommandFlags.UsePickSet

      )]

    static public void CopyClipIntercept()

    {

      var doc =

        Application.DocumentManager.MdiActiveDocument;

      var ed = doc.Editor;

 

      // Start by getting the pickfirst set or object selection

 

      var psr = ed.GetSelection();

      if (psr.Status == PromptStatus.OK && psr.Value != null)

      {

        // In case the selection is not from the pickfirst set,

        // we need to set it from the selection for COPYCLIP

        // to pick up

 

        ed.SetImpliedSelection(psr.Value.GetObjectIds());

 

        // Report how many objects have been selected

 

        ed.WriteMessage(

          "\n{0} entities selected.\n", psr.Value.Count

        );

 

        // Pass the control on to COPYCLIP

 

        doc.SendStringToExecute("_.COPYCLIP ", true, false, true);

      }

    }

  }

}

To really make this work properly from Ctrl-C and -V, we need to use the CUI command to reassign the macro for Copy and Paste to “^C^C_ccint” and “’_pcint”, respectively:

We’ve removed the "”^C^C” prefix from the Ctrl-V call – replacing it with an apostrophe – because we want our new command to be transparently callable, something that is really only useful if we’re sending text data from the clipboard to the command-line. If the normal PASTECLIP command is to be called, we anyway prefix the command-string with escape characters to cancel any active commands.

Now when we use Ctrl-C and -V to copy or paste in AutoCAD, we have our custom behaviour kick in. You may find these commands more verbose on the command-line, as we’re selecting once before passing through to COPYCLIP, for instance, but we could streamline then somewhat to not echo the command-strings, at least. That’s really left as an exercise for the reader, depending on the specific needs.

Right then... that's me nearly done for the year. In the next few days I'll be heading up to the mountains for Autodesk's annual "week of rest" closure, but I'll almost certainly have the odd tidbit to share while I'm there.

In the meantime, I wish you all the very best for this festive season, whether you celebrate Christmas and the New Year or not.

Creating reactive, transient AutoCAD geometry using .NET

This is a really interesting topic. At least I think it is – hopefully at least some of you will agree. :-)

The requirement was to create selectable – or at least manipulatable – transient graphics inside AutoCAD’s drawing canvas. As many of you are probably aware, transient graphics are not hooked into AutoCAD’s selection mechanism. This is mostly fine, but if you want to implement a ViewCube-like gizmo that manipulates the view or drawing settings in some way, it’s hard to do so without the ability to react to the current cursor position is and what’s happening with the mouse.

When my esteemed colleague, Christer Janson, first pointed me at the internal C++ protocol extension that allows you to receive Windows messages and point input inside your application, I assumed there was no chance I’d be able to get this working in .NET (as it’s not exposed through the public ObjectARX API). But after some digging and head-scratching, I managed to find how it had been exposed via the .NET API and create a sample that makes use of it.

Here’s the C# code, showing how to use this very interesting mechanism:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.GraphicsInterface;

 

namespace TransientSelection

{

  public class SelectableTransient : Transient

  {

    // Windows messages we care about

 

    const int WM_LBUTTONDOWN = 513;

    const int WM_LBUTTONUP = 514;

 

    // Internal state

 

    Entity _ent = null;

    bool _picked = false, _clicked = false;

 

    public SelectableTransient(Entity ent)

    {

      _ent = ent;

    }

 

    protected override int SubSetAttributes(DrawableTraits traits)

    {

      // If the cursor is over the entity, make it colored

      // (whether it's red or yellow will depend on whether

      // there's a mouse-button click, too)

 

      traits.Color = (short)(_picked ? (_clicked ? 1 : 2) : 0);

 

      return (int)DrawableAttributes.None;

    }

 

    protected override void SubViewportDraw(ViewportDraw vd)

    {

      _ent.ViewportDraw(vd);

    }

 

    protected override bool SubWorldDraw(WorldDraw wd)

    {

      _ent.WorldDraw(wd);

 

      return true;

    }

 

    protected override void OnDeviceInput(DeviceInputEventArgs e)

    {

      bool redraw = false;

 

      if (e.Message == WM_LBUTTONDOWN)

      {

        _clicked = true;

 

        // If we're over the entity, absorb the click

        // (stops the window selection from happening)

 

        if (_picked)

        {

          e.Handled = true;

        }

        redraw = true;

      }

      else if (e.Message == WM_LBUTTONUP)

      {

        _clicked = false;

        redraw = true;

      }

 

      // Only update the graphics if things have changed

 

      if (redraw)

      {

        TransientManager.CurrentTransientManager.UpdateTransient(

          this, new IntegerCollection()

        );

 

        // Force a Windows message, as we may have absorbed the

        // click event (and this also helps when unclicking)

 

        ForceMessage();

      }

 

      base.OnDeviceInput(e);

    }

 

    private void ForceMessage()

    {

      // Set the cursor without ectually moving it - enough to

      // generate a Windows message

 

      System.Drawing.Point pt =

        System.Windows.Forms.Cursor.Position;

      System.Windows.Forms.Cursor.Position =

        new System.Drawing.Point(pt.X, pt.Y);

    }

 

    protected override void OnPointInput(PointInputEventArgs e)

    {

      bool wasPicked = _picked;

 

      _picked = false;

 

      Curve cv = _ent as Curve;

      if (cv != null)

      {

        Point3d pt =

          cv.GetClosestPointTo(e.Context.ComputedPoint, false);

        if (

          pt.DistanceTo(e.Context.ComputedPoint) <= 0.1

          // Tolerance.Global.EqualPoint is too small

        )

        {

          _picked = true;

        }

      }

 

      // Only update the graphics if things have changed

 

      if (_picked != wasPicked)

      {

        TransientManager.CurrentTransientManager.UpdateTransient(

          this, new IntegerCollection()

        );

      }

      base.OnPointInput(e);

    }

  }

 

  public class Commands

  {

    Line _ln = null;

    SelectableTransient _st = null;

 

    [CommandMethod("TRS")]

    public void TransientSelection()

    {

      // Create a line and pass it to the SelectableTransient

      // This makes cleaning up much more straightforward

 

      _ln = new Line(Point3d.Origin, new Point3d(10, 10, 0));

      _st = new SelectableTransient(_ln);

 

      // Tell AutoCAD to call into this transient's extended

      // protocol when appropriate

 

      Transient.CapturedDrawable = _st;

 

      // Go ahead and draw the transient

 

      TransientManager.CurrentTransientManager.AddTransient(

        _st, TransientDrawingMode.DirectShortTerm,

        128, new IntegerCollection()

      );

    }

 

    [CommandMethod("TRU")]

    public void RemoveTransientSelection()

    {

      // Removal is performed by setting to null

 

      Transient.CapturedDrawable = null;

 

      // Erase the transient graphics and dispose of the transient

 

      if (_st != null)

      {

        TransientManager.CurrentTransientManager.EraseTransient(

          _st,

          new IntegerCollection()

        );

        _st.Dispose();

        _st = null;

      }

 

      // And dispose of our line

 

      if (_ln != null)

      {

        _ln.Dispose();

        _ln = null;

      }

    }

  }

}

When you run the TRS command, you’ll see a line between the origin and the point 10,10. This is transient geometry, although not as we know it. ;-)

When you move your cursor across the line (to within 0.1 of a drawing unit, which I chose as the standard geometric tolerance was way too small to be usable when dealing with point input in this way) it should turn yellow:

And when you click the left-button of the mouse, it should turn red:

In itself this isn’t anything very impressive, but it provides the underpinnings to create something much more so. You’re essentially now able to create a transient gizmo that can react to mouse movement and button clicking, and in turn manipulate state in your AutoCAD session, in some way.

I’ve provided a TRU command to remove graphics and dispose of everything properly. You would probably want to take care of all this in your own application initialization and termination code, of course.

Incidentally there are optimisations that are probably worth making to this particular implementation: for instance, as this mechanism could end up being used by users throughout their typical drawing session – much in the way the ViewCube is – I’d suggest checking the cursor position against an area of the drawing that you hold in memory, to stop always checking it against the geometry itself (as I’ve done in this sample). I’m sure you’ll find out other ways to optimise the use of this mechanism as you work through the specifics of your own implementation.

A handy jig for creating AutoCAD text using .NET – Part 4

After the first three parts of this series covered the basic jig that makes use of the standard keywords mechanism to adjust text’s style and rotation as it’s being placed, it eventually made sense to implement the remaining requirement initially provided for the jig: this post looks at different approaches for having the jig respond to single keystrokes rather than full keyword inputs.

Dave Osborne very helpfully got me started on this by providing an initial implementation that makes use of an IMessageFilter – something he’d apparently gleaned from this previous post. Thanks, Dave! :-)

All the approaches I’ll outline in this post make use of this core technique, but do so in slightly different ways. Basically we want our jig to now respond to the Tab key to rotate our text by 90 degrees – it would be simple enough to extend the technique to cover different properties, too, but that’s left as an exercise for the reader.

The trick is that we have three separate classes between which we will need to communicate, primarily to adjust the angle: our Commands class, our Jig class and our IMessageFilter class.

The first thing you might try when getting them to share information between such classes is to have a static member of the Commands class that gets accessed by the other two. This is dangerous, mainly because shared data is tricky to manage. If you have a second document, for instance, which also has the same command running, you may well hit a problem if they both access and adjust the same “angle” value. They won’t be able to do so at exactly the same time – as AutoCAD isn’t multi-threaded – but the results are likely to be unpredictable. See this previous post for more on this topic.

You could also keep the data in the Commands class, but this time expose it in a different way to the other classes. For instance, you might choose to have a public property exposed and then pass a reference to the Commands class when creating the Jig and the IMessageFilter, so that their implementations might access the data.

Or you might decouple the implementations even further and define delegates for the rotate action and a method to access the angle property’s current value. You could then pass lambda functions in from the Commands class, and the bodies of these lambdas could very validly access a local variable in the Commands class, so you wouldn’t even need object-level state exposed.

In any of these three approaches you end up with an IMessageFilter object that modifies the angle directly, rather than passing through the jig. They work well enough when the Jig is processing messages – such as when you hit Tab as you’re dragging the mouse – but work less well when the mouse is stationary. It’s only when the mouse moves that you’ll see the effects of hitting the Tab key catch up with the object’s on-screen rotation.

Which has led me to my preferred implementation: simply using the IMessageFilter as a “keyboard accelerator” class that sends the assigned keyword through to the Jig for processing. This has the benefit of consistency – you can keep the keyword implementation intact, and the user can also use that rather than the Tab key – and also of responsiveness – there are no discrepancies between the object state and the on-screen representation.

Here’s the C# implementation, with the new lines in red, although I’ve made a few other largely cosmetic but unhighlighted changes such as adding a namespace (and here’s the source file for you to download).

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.DatabaseServices;

    3 using Autodesk.AutoCAD.EditorInput;

    4 using Autodesk.AutoCAD.Geometry;

    5 using Autodesk.AutoCAD.GraphicsInterface;

    6 using Autodesk.AutoCAD.Runtime;

    7 using System.Runtime.InteropServices;

    8 using WinForms = System.Windows.Forms;

    9 using System;

   10 

   11 namespace QuickText

   12 {

   13   public class Commands

   14   {

   15     [CommandMethod("QT")]

   16     static public void QuickText()

   17     {

   18       Document doc =

   19         Application.DocumentManager.MdiActiveDocument;

   20       Database db = doc.Database;

   21       Editor ed = doc.Editor;

   22 

   23       PromptStringOptions pso =

   24         new PromptStringOptions("\nEnter text string");

   25       pso.AllowSpaces = true;

   26       PromptResult pr = ed.GetString(pso);

   27 

   28       if (pr.Status != PromptStatus.OK)

   29         return;

   30 

   31       Transaction tr =

   32         doc.TransactionManager.StartTransaction();

   33       using (tr)

   34       {

   35         BlockTableRecord btr =

   36           (BlockTableRecord)tr.GetObject(

   37             db.CurrentSpaceId, OpenMode.ForWrite

   38           );

   39 

   40         // Create the text object, set its normal and contents

   41 

   42         DBText txt = new DBText();

   43         txt.Normal =

   44           ed.CurrentUserCoordinateSystem.

   45             CoordinateSystem3d.Zaxis;

   46         txt.TextString = pr.StringResult;

   47 

   48         // We'll add the text to the database before jigging

   49         // it - this allows alignment adjustments to be

   50         // reflected

   51 

   52         btr.AppendEntity(txt);

   53         tr.AddNewlyCreatedDBObject(txt, true);

   54 

   55         // Create our jig

   56 

   57         TextPlacementJig pj =

   58           new TextPlacementJig(tr, db, txt);

   59 

   60         // Loop as we run our jig, as we may have keywords

   61 

   62         PromptStatus stat = PromptStatus.Keyword;

   63         while (stat == PromptStatus.Keyword)

   64         {

   65           var filt = new TxtRotMsgFilter(doc);

   66 

   67           WinForms.Application.AddMessageFilter(filt);

   68           PromptResult res = ed.Drag(pj);

   69           WinForms.Application.RemoveMessageFilter(filt);

   70 

   71           stat = res.Status;

   72           if (

   73             stat != PromptStatus.OK &&

   74             stat != PromptStatus.Keyword

   75           )

   76             return;

   77         }

   78 

   79         tr.Commit();

   80       }

   81     }

   82 

   83     private class TextPlacementJig : EntityJig

   84     {

   85       // Declare some internal state

   86 

   87       private Database _db;

   88       private Transaction _tr;

   89       private Point3d _position;

   90       private double _angle, _txtSize;

   91       private bool _toggleBold, _toggleItalic;

   92       private TextHorizontalMode _align;

   93 

   94       // Constructor

   95 

   96       public TextPlacementJig(

   97         Transaction tr, Database db, Entity ent

   98       ) : base(ent)

   99       {

  100         _db = db;

  101         _tr = tr;

  102         _angle = 0;

  103         _txtSize = 1;

  104       }

  105 

  106       protected override SamplerStatus Sampler(

  107         JigPrompts jp

  108       )

  109       {

  110         // We acquire a point but with keywords

  111 

  112         JigPromptPointOptions po =

  113           new JigPromptPointOptions(

  114             "\nPosition of text"

  115           );

  116 

  117         po.UserInputControls =

  118           (UserInputControls.Accept3dCoordinates |

  119             UserInputControls.NullResponseAccepted |

  120             UserInputControls.NoNegativeResponseAccepted |

  121             UserInputControls.GovernedByOrthoMode);

  122 

  123         po.SetMessageAndKeywords(

  124           "\nSpecify position of text or " +

  125           "[Bold/Italic/LArger/Smaller/" +

  126             "ROtate90/LEft/Middle/RIght]: ",

  127           "Bold Italic LArger Smaller " +

  128           "ROtate90 LEft Middle RIght"

  129         );

  130 

  131         PromptPointResult ppr = jp.AcquirePoint(po);

  132 

  133         if (ppr.Status == PromptStatus.Keyword)

  134         {

  135           switch (ppr.StringResult)

  136           {

  137             case "Bold":

  138               {

  139                 _toggleBold = true;

  140                 break;

  141               }

  142             case "Italic":

  143               {

  144                 _toggleItalic = true;

  145                 break;

  146               }

  147             case "LArger":

  148               {

  149                 // Multiple the text size by two

  150 

  151                 _txtSize *= 2;

  152                 break;

  153               }

  154             case "Smaller":

  155               {

  156                 // Divide the text size by two

  157 

  158                 _txtSize /= 2;

  159                 break;

  160               }

  161             case "ROtate90":

  162               {

  163                 // To rotate clockwise we subtract 90 degrees &

  164                 // then normalise the angle between 0 and 360

  165 

  166                 _angle -= Math.PI / 2;

  167                 while (_angle < Math.PI * 2)

  168                 {

  169                   _angle += Math.PI * 2;

  170                 }

  171                 break;

  172               }

  173             case "LEft":

  174               {

  175                 _align = TextHorizontalMode.TextLeft;

  176                 break;

  177               }

  178             case "RIght":

  179               {

  180                 _align = TextHorizontalMode.TextRight;

  181                 break;

  182               }

  183             case "Middle":

  184               {

  185                 _align = TextHorizontalMode.TextMid;

  186                 break;

  187               }

  188           }

  189 

  190           return SamplerStatus.OK;

  191         }

  192         else if (ppr.Status == PromptStatus.OK)

  193         {

  194           // Check if it has changed or not (reduces flicker)

  195 

  196           if (

  197             _position.DistanceTo(ppr.Value) <

  198               Tolerance.Global.EqualPoint

  199           )

  200             return SamplerStatus.NoChange;

  201 

  202           _position = ppr.Value;

  203           return SamplerStatus.OK;

  204         }

  205 

  206         return SamplerStatus.Cancel;

  207       }

  208 

  209       protected override bool Update()

  210       {

  211         // Set properties on our text object

  212 

  213         DBText txt = (DBText)Entity;

  214 

  215         txt.Position = _position;

  216         txt.Height = _txtSize;

  217         txt.Rotation = _angle;

  218         txt.HorizontalMode = _align;

  219         if (_align != TextHorizontalMode.TextLeft)

  220         {

  221           txt.AlignmentPoint = _position;

  222           txt.AdjustAlignment(_db);

  223         }

  224 

  225         // Set the bold and/or italic properties on the style

  226 

  227         if (_toggleBold || _toggleItalic)

  228         {

  229           TextStyleTable tab =

  230             (TextStyleTable)_tr.GetObject(

  231               _db.TextStyleTableId, OpenMode.ForRead

  232             );

  233 

  234           TextStyleTableRecord style =

  235             (TextStyleTableRecord)_tr.GetObject(

  236               txt.TextStyleId, OpenMode.ForRead

  237             );

  238 

  239           // A bit convoluted, but this check will tell us

  240           // whether the new style is bold/italic

  241 

  242           bool bold = !(style.Font.Bold == _toggleBold);

  243           bool italic = !(style.Font.Italic == _toggleItalic);

  244           _toggleBold = false;

  245           _toggleItalic = false;

  246 

  247           // Get the new style name based on the old name and

  248           // a suffix ("_BOLD", "_ITALIC" or "_BOLDITALIC")

  249 

  250           var oldName = style.Name.Split(new[] { '_' });

  251           string newName =

  252             oldName[0] +

  253             (bold || italic ? "_" +

  254               (bold ? "BOLD" : "") +

  255               (italic ? "ITALIC" : "")

  256               : "");

  257 

  258           // We only create a duplicate style if one doesn't

  259           // already exist

  260 

  261           if (tab.Has(newName))

  262           {

  263             txt.TextStyleId = tab[newName];

  264           }

  265           else

  266           {

  267             // We have to create a new style - clone it

  268 

  269             TextStyleTableRecord newStyle =

  270               (TextStyleTableRecord)style.Clone();

  271 

  272             // Set a new name to avoid duplicate keys

  273 

  274             newStyle.Name = newName;

  275 

  276             // Create a new font based on the old one, but with

  277             // our values for bold & italic

  278 

  279             FontDescriptor oldFont = style.Font;

  280             FontDescriptor newFont =

  281               new FontDescriptor(

  282                 oldFont.TypeFace, bold, italic,

  283                 oldFont.CharacterSet, oldFont.PitchAndFamily

  284               );

  285 

  286             // Set it on the style

  287 

  288             newStyle.Font = newFont;

  289 

  290             // Add the new style to the text style table and

  291             // the transaction

  292 

  293             tab.UpgradeOpen();

  294             ObjectId styleId = tab.Add(newStyle);

  295             _tr.AddNewlyCreatedDBObject(newStyle, true);

  296 

  297             // And finally set the new style on our text object

  298 

  299             txt.TextStyleId = styleId;

  300           }

  301         }

  302 

  303         return true;

  304       }

  305     }

  306   }

  307 

  308   public class TxtRotMsgFilter : WinForms.IMessageFilter

  309   {

  310     [DllImport(

  311       "user32.dll",

  312       CharSet = CharSet.Auto,

  313       ExactSpelling = true

  314       )]

  315     public static extern short GetKeyState(int keyCode);

  316 

  317     const int WM_KEYDOWN = 256;

  318     const int VK_CONTROL = 17;

  319 

  320     private Document _doc = null;

  321 

  322     public TxtRotMsgFilter(Document doc)

  323     {

  324       _doc = doc;

  325     }

  326 

  327     public bool PreFilterMessage(ref WinForms.Message m)

  328     {

  329       if (

  330         m.Msg == WM_KEYDOWN &&

  331         m.WParam == (IntPtr)WinForms.Keys.Tab &&

  332         GetKeyState(VK_CONTROL) >= 0

  333       )

  334       {

  335         _doc.SendStringToExecute("_RO ", true, false, false);

  336         return true;

  337       }

  338       return false;

  339     }

  340   }

  341 }

Something to note from this implementation… to avoid responding to Control-Tab – which should switch between open drawings, of course – the code detects whether the Control key has been pressed at the same time as Tab. It only sends the _RO keyword to the command-line in the cases where the Control key is not pressed. It seems Alt-Tab is intercepted before it gets to AutoCAD – which makes sense, as it’s used to switch between applications – so that’s not something we need to check for.

To test it all works well, it’s interesting to have two new drawings open – with the application loaded – and launch the QT command in each, entering a different text string. You can then Control-Tab between the drawings, using the Tab key to rotate them independently.

Update:

Thanks to Heinz Dober for reminding me that at additional assembly reference to “System.Windows.Forms” will be needed in your project for the IMessageFilter-related code to compile.

A handy jig for creating AutoCAD text using .NET – Part 1

Back in March, I received an email from Thomas Fitou suggesting an interesting blog topic:

I was thinking about a cool feature in jigs:

• You invoke a command to enter an Mtext or text
• The editor is asking for some text
• You enter the text
• Then a jig is dragged asking for position
• But in the editor appear some options:[R]egular [B]old [I]talic [R]otate 90
• If the user hits "B" the text becomes bold
• If the user hits "R" the text is rotated 90 degrees
• If the user hits "R" again, another 90 degrees and so on...

It struck me as an interesting idea, but wasn’t something I managed to get to until now. It turned out to be a pretty interesting mini-project, too – so much so that I decided to split it across 3 separate posts:

1. A basic jig to position, rotate and size a DBText object
2. An extended version that supports font-level formatting (bold, italic, etc.)
3. For extra points: interactive alignment adjustment (left, middle, right)

In today’s post, then, we’re going to see a basic jig implementation that allows the user to position, rotate and adjust the size of the created text.

A few notes on design decisions related to this code:

• I decided to stick with DBText rather than including MText
• A few previous implementations on this blog have made sure geometry is database-resident before jigging it
  • While not needed for this initial post, it is needed later on, so I’ve adopted that same approach, here
• The proposed implementation suggested the use of single keystrokes to enable different modes (at least that’s how I read it)
  • The code uses the standard keyword mechanism, which means Enter is needed to submit the mode change
• I’ve placed the UI paths (i.e. the keywords) in the code for the latter parts – for now they don’t do anything, though
  • I dropped the “Regular” keyword, with the idea that “Bold” and “Italic” should really be toggles (and “R” is already fairly busy between “ROtate90” and “RIght”, for that matter)

Here’s the C# code for this initial version:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

using System;

 

public class Commands

{

  [CommandMethod("QT")]

  static public void QuickText()

  {

    Document doc =

      Application.DocumentManager.MdiActiveDocument;

    Database db = doc.Database;

    Editor ed = doc.Editor;

 

    PromptStringOptions pso =

      new PromptStringOptions("\nEnter text string");

    pso.AllowSpaces = true;

    PromptResult pr = ed.GetString(pso);

 

    if (pr.Status != PromptStatus.OK)

      return;

 

    Transaction tr =

      doc.TransactionManager.StartTransaction();

    using (tr)

    {

      BlockTableRecord btr =

        (BlockTableRecord)tr.GetObject(

          db.CurrentSpaceId, OpenMode.ForWrite

        );

 

      // Create the text object, set its normal and contents

 

      DBText txt = new DBText();

      txt.Normal =

        ed.CurrentUserCoordinateSystem.

          CoordinateSystem3d.Zaxis;

      txt.TextString = pr.StringResult;

 

      // We'll add the text to the database before jigging

      // it - this allows alignment adjustments to be

      // reflected

 

      btr.AppendEntity(txt);

      tr.AddNewlyCreatedDBObject(txt, true);

 

      // Create our jig

 

      TextPlacementJig pj = new TextPlacementJig(tr, db, txt);

 

      // Loop as we run our jig, as we may have keywords

 

      PromptStatus stat = PromptStatus.Keyword;

      while (stat == PromptStatus.Keyword)

      {

        PromptResult res = ed.Drag(pj);

        stat = res.Status;

        if (

          stat != PromptStatus.OK &&

          stat != PromptStatus.Keyword

        )

          return;

      }

 

      tr.Commit();

    }

  }

 

  class TextPlacementJig : EntityJig

  {

    // Declare some internal state

 

    Database _db;

    Transaction _tr;

    Point3d _position;

    double _angle, _txtSize;

 

    // Constructor

 

    public TextPlacementJig(

      Transaction tr, Database db, Entity ent

    ) : base(ent)

    {

      _db = db;

      _tr = tr;

      _angle = 0;

      _txtSize = 1;

    }

 

    protected override SamplerStatus Sampler(

      JigPrompts jp

    )

    {

      // We acquire a point but with keywords

 

      JigPromptPointOptions po =

        new JigPromptPointOptions(

          "\nPosition of text"

        );

 

      po.UserInputControls =

        (UserInputControls.Accept3dCoordinates |

          UserInputControls.NullResponseAccepted |

          UserInputControls.NoNegativeResponseAccepted |

          UserInputControls.GovernedByOrthoMode);

 

      po.SetMessageAndKeywords(

        "\nSpecify position of text or " +

        "[Bold/Italic/LArger/Smaller/" +

         "ROtate90/LEft/Middle/RIght]: ",

        "Bold Italic LArger Smaller " +

        "ROtate90 LEft Middle RIght"

      );

 

      PromptPointResult ppr = jp.AcquirePoint(po);

 

      if (ppr.Status == PromptStatus.Keyword)

      {

        switch (ppr.StringResult)

        {

          case "Bold":

            {

              // TODO

 

              break;

            }

          case "Italic":

            {

              // TODO

 

              break;

            }

          case "LArger":

            {

              // Multiple the text size by two

 

              _txtSize *= 2;

              break;

            }

          case "Smaller":

            {

              // Divide the text size by two

 

              _txtSize /= 2;

              break;

            }

          case "ROtate90":

            {

              // To rotate clockwise we subtract 90 degrees and

              // then normalise the angle between 0 and 360

 

              _angle -= Math.PI / 2;

              while (_angle < Math.PI * 2)

              {

                _angle += Math.PI * 2;

              }

              break;

            }

          case "LEft":

            {

              // TODO

 

              break;

            }

          case "RIght":

            {

              // TODO

 

              break;

            }

          case "Middle":

            {

              // TODO

 

              break;

            }

        }

 

        return SamplerStatus.OK;

      }

      else if (ppr.Status == PromptStatus.OK)

      {

        // Check if it has changed or not (reduces flicker)

 

        if (

          _position.DistanceTo(ppr.Value) <

            Tolerance.Global.EqualPoint

        )

          return SamplerStatus.NoChange;

 

        _position = ppr.Value;

        return SamplerStatus.OK;

      }

 

      return SamplerStatus.Cancel;

    }

 

    protected override bool Update()

    {

      // Set properties on our text object

 

      DBText txt = (DBText)Entity;

 

      txt.Position = _position;

      txt.Height = _txtSize;

      txt.Rotation = _angle;

 

      return true;

    }

  }

}

When we run our QT (which stands for QuickText) command, we can use it to quickly enter, preview and place a text object:

Command: QT

Enter text string: Some text

Specify position of text or

[Bold/Italic/LArger/Smaller/ROtate90/LEft/Middle/RIght]: LA

Specify position of text or

[Bold/Italic/LArger/Smaller/ROtate90/LEft/Middle/RIght]: RO

Specify position of text or

[Bold/Italic/LArger/Smaller/ROtate90/LEft/Middle/RIght]:

In the next post, we’ll implement the font-formatting options for bold, italic and bold-italic text (which, as it requires modification to the associated text style, is harder than it sounds).

Using AutoCAD’s Bindable Object Layer to change the current view using .NET

After looking at how the Bindable Object Layer (BOL) in AutoCAD might be used to get information about the current drawing, in today’s post we’re going to see how it can also be used to manipulate that data (in a fairly limited, albeit useful, way).

But first, let’s talk a bit about the origins of the BOL. It was first introduced as an architectural feature of AutoCAD when we were looking at delivering AutoCAD for Mac. It’s common, these days, for programming frameworks to provide some kind of data-binding facility to simplify the creation of UIs: both WPF and Cocoa have data-binding capabilities, for instance, that allow programmers to point collection-friendly UI widgets – such as list- and combo-boxes – at core data collections containing the information they wish to present to the user.

The BOL was our (primarily internal) effort to create a cross-platform, abstract information layer that could be bound via WPF on Windows and Cocoa on OS X to present the UI most appropriate to the respective platforms. Some work was needed to expose the core layer on each platform, but the underlying C++ implementation – contained within AcCore – is shared across platforms.

For instance, much of the information regarding the state of the current drawing – such as the current layer, linetype, dimension/table/text/visual (etc.) style – is providing to AutoCAD’s ribbon by the BOL. The BOL provides the most recent information – it gets updated as the drawing changes and even as the active drawing changes – so that the UI can simply update whenever changes propagate through the BOL.

Which actually makes the BOL quite a powerful abstraction for use programmatically, too. While it’s not directly possible to add items to the BOL and have them appear in the drawing, it is possible to use the BOL to change the “current” item in a collection, and also to use the BOL to find out when modifications have been made to its various collections.

The BOL can therefore be used to change the current Visual Style, the current layer, or – as we show in the post – the current named view.

And here’s the C# code that does so:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows.Data;

using System.Collections.Generic;

 

public class BolAccess

{

  [CommandMethod("CHGVW")]

  static public void ChangeViewViaBol()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

 

    // Get our set of named views

 

    var views = Application.UIBindings.Collections.NamedViews;

    if (views.Count == 0)

    {

      ed.WriteMessage("\nNo named views available.");

    }

    else

    {

      ed.WriteMessage("\nNamed views available:");

 

      // Create a list in which to store the names of our views

 

      List<string> viewNames = new List<string>(views.Count);

 

      // Loop through the view list, populating our list of names

      // and printing each one for later selection

 

      for(int i=0; i < views.Count; i++)

      {

        // Add a dummy item - will be replaced via the index later

 

        viewNames.Add("");

 

        var desc = views[i];

 

        // Get the collection's property descriptors

 

        var props = desc.GetProperties();

 

        // Set our view name as the value of each "Name" property

        // (do so by index, just to make sure we're keeping in sync

        // with the values in the views collection)

 

        viewNames[i] = (string)props["Name"].GetValue(desc);

 

        // Print the name along with the 1-based index

 

        ed.WriteMessage("\n {0} {1}", i+1, viewNames[i]);

      }

 

      // Ask the user to select the view based on the index

 

      PromptIntegerOptions opts =

        new PromptIntegerOptions("\nEnter number of view: ");

 

      opts.LowerLimit = 1;

      opts.UpperLimit = views.Count;

 

      PromptIntegerResult pir = ed.GetInteger(opts);

      if (pir.Status == PromptStatus.OK)

      {

        // Simply set our current item to the one selected

 

        views.CurrentItem = views[pir.Value - 1];

      }

    }

  }

}

When we run the CHGVW command inside the “visualization_-_condominium_with_skylight.dwg” sample drawing, we see we can use it to navigate easily between the various named views:

Dumping data from AutoCAD’s Bindable Object Layer using .NET

Some time ago, I posted code that used the Autodesk.AutoCAD.Windows.Data namespace to list the hatch patterns in the current drawing.

Fenton Webb posted a follow-up on the AutoCAD DevBlog that took this further, extracting additional data from AutoCAD and using it to populate an Excel spreadsheet. Within that post, Fenton showed the technique required to access and iterate across other data collections – something I hadn’t managed to do when creating my original post.

Rather than repeat exactly what Fenton has put together – which is really nice, do take a look at it – I’m just taking a small amount of Fenton’s code and replicating it here – along with some code using reflection, to keep the code succinct – to dump some data to the command-line:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows.Data;

 

public class DataStuff

{

  [CommandMethod("HPS")]

  static public void GetHatchPatterns()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

    foreach (

      string str in HatchPatterns.Instance.AllPatterns)

      ed.WriteMessage("\n" + str);

  }

 

  [CommandMethod("DUMPBOL")]

  static public void DumpBindableObjects()

  {

    Editor ed =

      Application.DocumentManager.MdiActiveDocument.Editor;

 

    // Get our set of collections

 

    var cols = Application.UIBindings.Collections;

 

    // Use reflection to determine the properties of type

    // DataItemCollection (could extend to support others, too)

 

    var t = cols.GetType();

    var tprops = t.GetProperties();

    foreach (var tprop in tprops)

    {

      // Make sure we only deal with DataItemCollection properties

      // that do not take any parameters

 

      if (

        tprop.PropertyType == typeof(DataItemCollection) &&

        tprop.GetGetMethod().GetParameters().Length == 0

      )

      {

        // Dump our the property name first

 

        ed.WriteMessage("\n{0}:", tprop.Name);

 

        // Get the collection itself and iterate through it

 

        var col = (DataItemCollection)tprop.GetValue(cols, null);

        foreach (var desc in col)

        {

          // Get the collection's property descriptors

 

          var props = desc.GetProperties();

          try

          {

            // Dump the value of each "Name" property

 

            ed.WriteMessage(

              " \"{0}\"", props["Name"].GetValue(desc)

            );

          }

          catch

          {

            // Just in case no "Name" property exists, we try-catch

          }

        }

      }

    }

  }

}

The main trick is actually to get data from the BOL – AutoCAD’s Bindable Object Layer – via the various properties inside Application.UIBindings.Collections.

We’re using reflection to avoid hardcoding the various properties we want to access: we just loop through the main collection set’s properties, looking for any of type DataItemCollection. We might also extend the code to support other property types – such as EnumItemCollection – but that’s left as an exercise for the reader.

Here’s the command-line output we see in a blank drawing when we run the DUMPBOL command:

Command: DUMPBOL

UcsPlanes:

PlotStyles:

RenderPresets: "" "" "" "" ""

TableCellStyles:

NamedViews:

Linetypes: "ByBlock" "ByLayer" "Continuous" "PHANTOM2"

LayerFilters: "All" "All Used Layers" "Unreconciled New Layers" "Viewport Overrides"

LayerStates:

Layers: "0"

VisualStyles: "2D Wireframe" "Conceptual" "Hidden" "Realistic" "Shaded" "Shaded with edges" "Shades of Gray" "Sketchy" "Wireframe" "X-Ray"

TextStyles: "Standard" "Annotative"

DimensionStyles: "Standard" "Annotative"

DetailViewStyles: "Imperial24"

SectionViewStyles: "Imperial24"

MleaderStyles: "Annotative" "Standard"

TableStyles: "Standard"

Adding snapping to the AutoCAD MRU browser using WinRT

I visited another Windows 8-related conference in Zürich, yesterday. Despite much of the content being repeated from the last one I attended, I actually found it really useful: having spent time working with Windows 8 and WinRT over the last few weeks, I found I got more out of the demos and could also ask more intelligent questions of the Microsoft personnel in attendance (thanks for all your help, Ronnie :-). And there was some new content I hadn’t seen, previously: I managed to sit in briefly on an Azure session (which was admittedly a bit too IT-centric for my personal tastes) and a couple of “WinRT via HTML5 & Javascript” sessions, too.

During the breaks, I also took the opportunity to finish off a half-completed feature in the MetroCAD app: snapping. Snapping allows you – on screens with a minimum resolution of 1366 x 768, something you could circumvent with the Windows 8 Developer Preview but not with the Consumer preview, it seems – to dock one application to one side of the screen while you have another application (even your traditional Windows desktop) available on the other side. This mode is the way Windows 8 enables users to “multi-task” (meant at the user-level rather than the process level), making use of multiple applications at the same time (as otherwise Metro-style applications run in full screen).

I won’t go into the specific code changes, as most of the code was there, just needed tidying up (as I simply hadn’t tested that mode of operation before yesterday).

Here’s the updated source project, and here’s snapping in action:

I’m now fairly happy with implementation of the snapping feature and the overall capabilities of the app, which means I can crack on with the series on moving application functionality to the cloud.