Through the Interface

Forcing AutoCAD object snapping using .NET

I was up in Adelboden, this weekend, for the Men’s FIS World Cup Slalom and Giant Slalom events. Yes, just watching – not participating :-) – although I did get the chance to catch a few much gentler slopes on my snowboard during the course of the weekend. On the Saturday – during the Giant Slalom – there was a pretty amazing incident: a young Norwegian competitor, Henrik Kristofferson, very nearly hit a television worker during his first run down. Thankfully no-one was hurt, and Henrik was very understanding about the whole thing (he was given a restart but,... Read more →

Disabling snapping to specific AutoCAD objects using .NET – Part 2

In the last post, we introduced the idea of preventing object snapping on certain objects by tagging them with XData and then attaching an overrule within AutoCAD to stop it from getting osnap information for them. This worked very well for standard, single-object snap modes – such as center, quad, mid, end, etc. – but didn’t work for intersection points. Intersection points are determined by calling an object’s intersectsWith() method, which can thankfully also be overruled using a GeometryOverrule. Overruling this behaviour comes with a few important caveats, though: intersectsWith() can be called in a number of different scenarios,... Read more →

Disabling snapping to specific AutoCAD objects using .NET – Part 1

Here’s a fun one that came up as a question during the recently “AutoCAD APIs: Meet the Experts” session at Autodesk University. I promised during the session that I’d address it in a blog post this week, so here we are. But I’m splitting the post into two parts, so the more complete solution will only be available next week. The problem is as follows: we want to be able to disable osnap on specific AutoCAD objects by tagging them in some way. The solution proposed by the panel during the session (I forget by whom: it could have... Read more →

Jigging AutoCAD geometry in an arbitrary UCS using JavaScript

I’ve learned a few things since the last post, where we complemented AutoCAD’s new JavaScript API with some additional .NET functionality to work around an issue that existed in the code we’d developed in the previous two posts. Firstly, I found out there’s a better way for your jig to display transient graphics than via “manual” calls to addTransient(), updateTransient() and eraseTransient(). Acad.Jig exposes an update() function you can call, passing in the xml fragment representing your geometry. The jig will manage the display of the transient and clear it at the end. (Thanks to Sherry Tan for pointing... Read more →

Complementing AutoCAD’s JavaScript API using .NET

After having some fun writing our first jig inside AutoCAD, last week, and calling it either from an HTML page or an AutoCAD command defined in a .js file, in today’s post we’re going to see how we can use AutoCAD’s .NET API to extend its new JavaScript layer. We’re going to take a concrete problem we had in last week’s implementation: it turns out that when you draw a transient circle beneath the cursor using JavaScript – as we do during our jig – it absorbs mouse clicks. This is something we’ve logged as an issue, but it... Read more →

Jigging an AutoCAD circle from a JavaScript-defined command

Just to complement yesterday’s post showing how to define a simple jig using JavaScript, here’s the same code from a separate .js file: var doc = Acad.Application.activedocument; var center = new Acad.Point3d(0, 0, 0); var radius = 0; var trId; function pointToString(pt) { var ret = pt.x.toString() + "," + pt.y.toString() + "," + pt.z.toString(); return ret; } function createCircle(cen, rad, first) { // Build an XML string containing data to create // an AcGiTransient that represents the circle var cursor = ''; var drawable = '' + 'Read more →

Measuring time elapsed during custom AutoCAD command execution using .NET

As a follow-on from the last post, in today’s we’re going to look at a crude approach for collecting execution information about functions of your choosing from a .NET app inside AutoCAD. We’re going to extend the implementation shown last time to record the time taken for the various “instrumented” commands to execute and make it easy to copy and paste this “performance” data into a tool such as Excel. We could also dump out a file directly that can be imported into Excel, but this way is simpler and only slightly more manual. It’s important to note the... Read more →

Querying AutoCAD objects of a particular type using .NET

Late last week I received an interesting email from Bruno Saboia, who’s been experiencing some performance issues with code he’d written to return all the objects of a particular type – in his case, Lines – from the model-space of the active drawing. We exchanged a few emails on the topic, and Bruno kindly allowed me to post his code and my suggestions for changes. In today’s post, we’re going to look at both the code and my suggestions, while in the next post (in this mini-series, at least) we’ll look at a simple execution framework that can allows... Read more →

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... Read more →

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... Read more →

Examples of calling Dispose() on AutoCAD objects

To accompany the last post – which raised some questions around when and where to call Dispose() on objects created or accessed via AutoCAD’s .NET API – today we’re going to look at a few concrete examples. Thanks to Danny P for not only requesting some examples but also presenting some concrete areas he wasn’t fully clear on. Let’s start by looking at those (and feel free to compare the responses I’ve put below with the ones I made in direct response to Danny’s original comment): Within a transaction where something is added to the database, some new objects... Read more →

Calling Dispose() on AutoCAD objects

This is a follow-on to this previous post, prompted by a thread over on The Swamp discussing a recent blog post by Fenton Webb on the AutoCAD DevBlog. Fenton’s assertion is that you really need to call Dispose() on all AutoCAD objects that you create yourself, unless they are managed by AutoCAD’s transaction system (i.e. you’ve passed responsibility across to AutoCAD by calling Transaction.AddNewlyCreatedDBObject()). Which means that while you don’t need to call Dispose() on objects such as the AutoCAD Editor or the active Document (and you really shouldn’t), you really should call Dispose() on various objects you’ve been... Read more →

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... Read more →

More API features in AutoCAD 2013

Following on from our look at the Core Console, Dynamic .NET and .NET migration for AutoCAD 2013, today we’re going to look briefly at the remaining API features in the AutoCAD 2013 release. Model Documentation The model documentation feature was introduced in AutoCAD 2012 – simplifying creation of 2D sections and details of 3D drawing content – and this initial API provides (primarily read-only) access to this information. It comprises the following classes SectionSymbol SectionViewstyle ViewBorder ViewRepBlockReference DetailViewStyle DetailSymbol The writeable aspects of the API are mostly related to the “style” objects – these can be created and edited... Read more →

A simplified .NET API for accessing AutoCAD parameters and constraints

In the 2010 release, we introduced 2D geometric constraints to AutoCAD. The feature was implemented using AutoCAD’s low-level – and very powerful – Associative Framework, which has subsequently been used to implement features such as parametric surfaces in AutoCAD 2011 (more information on that here). Our initial API implementation for creating and accessing geometric constraints (which you can find out more about via the DevTV session linked to from this previous post) in many ways reflects the low-level nature of the underlying framework: it was unfortunately just a bit too complicated for most mortals to get to grips with.... Read more →

Preventing AutoCAD objects from being selected using .NET

In the last post, we looked at how to stop entities from being highlighted during selection. This post looks at how to stop entities from being selected at all. Thanks again to Balaji Ramamoorthy for providing the underlying technique shown in today’s code. The basic scenario we’re using is similar to the last post – we maintain a list of DXF names for the classes we want to stop from being selected – but it could easily be adapted to using different criteria for removing objects from the selection: an example being the use of a similar (although admittedly... Read more →

Preventing AutoCAD objects from being highlighted using .NET

Thanks to Balaji Ramamoorthy, from DevTech India, for the basis of this post (some code he provided in a recent reply to an ADN member). The original question came from someone who wanted to stop text objects from being highlighted when selected. I’ve extended the mechanism to make it a little more flexible: it now maintains a list of object types (their DXF names) of objects that should not be highlighted, when selected. Balaji implemented a HighlightOverrule to control the highlighting. This doesn’t stop the objects from actually being selected, however: in the next post I’ll add some additional... Read more →

Dynamic use of P/Invoke on 32- and 64-bit systems

I’m now back from a nice, long weekend celebrating the Swiss National Day (August 1st) and our 10th wedding anniversary (which isn’t until November, but who wants to hold a party then? ;-). So, getting back into the saddle, here’s a question that came in recently by email: I'm using P/Invoke to call a function which is different on x86 and x64. How to code such entry point addresses dynamically, so one does not have to compile two separate versions, one for x86, and one for x64? While the answer can be found a previous post, it seemed worth... Read more →

AutoCAD .NET Training DevTV Session 8: User Interface elements

Another Friday, another installment of Wayne Brill’s AutoCAD .NET training DevTV series (to complement those sessions from previous weeks). Today’s session is focused user-interface elements such as the .NET attributes for exposing commands and optimizing loading, adding your own tab to the options dialog and implementing drag & drop. This series of DevTV sessions is a companion for the new AutoCAD .NET training material available from the AutoCAD .NET Developer Center. Enjoy! :-) Read more →

ADN DevCast Episode 7 – Creating an installer to deploy apps via the Autoloader

As a follow-up to their session on the Autoloader, AutoCAD 2012’s simplified deployment mechanism, Stephen and Fenton have recorded another DevCast focused on creating an installer to deploy apps via the Autoloader. These two DevCasts are likely to be of relevance to anyone wishing to deploy their plugin via the “Apps” tab in Autodesk Exchange. There’s also a new Developer Center focused on this very task, providing the guidelines and requirements for publishing apps along with a couple of helpful DevTV sessions to get you started. Read more →