Through the Interface

Displaying different entities in AutoCAD viewports using .NET

This is a problem that developers have been struggling with for some time, and it came up again at the recent Cloud Accelerator: how to control the display of AutoCAD geometry at a per-viewport level, perhaps to implement your own “isolate in a viewport” command. It’s certainly possible to control layer visibility at the viewport level, of course, but this is sometimes at odds with how users wish to use layers for their own purposes. An application may want to isolate geometry in a certain location from a number of layers, for instance, and it becomes cumbersome to hijack... Read more →

Changing the border colour of an AutoCAD raster image using .NET

This is a question that came up at the recent Cloud Accelerator in Prague: how can you change the border colour for all raster image objects in the drawing? We could do this by placing the raster image on a particular layer, but the developer was looking for a global override. The answer ended up being really simple with a DrawableOverrule. Here’s some C# code that does this: using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.GraphicsInterface; using Autodesk.AutoCAD.Runtime; namespace RasterImageOverrule { public class RasterImageDisplayOverrule : DrawableOverrule { public short Color { get; set; } public override void ViewportDraw(Drawable d,... 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 →

Overriding the grips of an AutoCAD polyline to maintain fillet segments using .NET

Many, many thanks to Massimo Cicognani for contributing the code in today’s post. Massimo contacted me as he was working through some issues with his implementation and then kindly offered to share it with this blog’s readers. We’ve looked at a few different types of overrule on this blog, in the past, and even taken a look at a grip overrule or two. Massimo’s much more advanced grip overrule works with a very particular type of polyline: those that alternate between straight and arc segments (with the first and last segments being straight). This might sound a touch specific,... Read more →

My First AutoCAD Plug-In

Hot on the heels of the Revit and Inventor installments in this series of guides (OK, OK – perhaps not exactly hot, but then “warm on the heels” doesn’t have quite the same ring to it ;-), I’m happy to announce that the previously mentioned “My First AutoCAD Plug-in” guide is now available. Stephen Preston, the author of this excellent guide, has done a great job of creating a compelling sample – which keeps your block attributes horizontal, irrespective of the block rotation – and a series of straightforward explanations to help power-users and programming “newbies” take the plunge... Read more →

Adding an ObjectOverrule to stop AutoCAD objects from being erased using .NET

As a follow-on from the last post, today we’re going to see how to actually stop the erase operation from happening for a certain type of object (in this case we’re going to focus on Lines). Thanks for Stephen Preston for showing us the way in his comment on that post: inspired by his suggestion I ended up coding this before breakfast (although I do recommend taking care when throwing exceptions on an empty stomach ;-). Here’s the C# code implementing the PER (Prevent Erasure) command: using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; namespace WeLikeToBlock { public class... Read more →

Adding an ObjectOverrule to watch for erasure of AutoCAD objects using .NET

I started looking into the ObjectOverrule class, this week, to see if I could use it to prevent erasure of certain objects. My thinking was that overruling Erase() would allow me to control whether an object was erased or not, simply by my decision whether or not to super-message to the base implementation. That doesn’t appear to be the case, as whether I call the base implementation or not the object gets erased. I’ll have to confirm that this is expected behaviour, but in the meantime I thought I’d share a version of my code which adds a simple... Read more →

September’s Plugin of the Month: DigSigStamp

Yesterday Scott Sheppard announced the availability of this plugin over on It’s Alive in the Lab. We originally received a request for this Plugin of the Month some time ago. Fenton Webb, from our DevTech Americas team, developed the initial version using an ObjectARX custom entity – as the requester required support for versions of AutoCAD prior to 2010 – but for this public release, Stephen Preston went ahead and re-implemented the mechanism in a .NET application using the Overrules API introduced in AutoCAD 2010. This plugin basically allows you to see graphically when an AutoCAD drawing is digitally... Read more →

June’s Plugin of the Month: Dimension Patrol

Thanks again to Stephen Preston, our DevTech Americas Manager, for developing this very useful little utility. You can find an earlier version of this code – which I’d converted to C# and extended to cover text entities – in this previous post. June’s Plugin of the Month is now live: Dimension Patrol for AutoCAD. This one was kicked off by a suggestion from Shaan Hurley: a tool for designers and CAD Managers to quickly check drawings for dimensions with overridden text (which, logically enough, could mean the dimensions no longer accurately reflect their associated distance or value). Sometimes the... Read more →

Using overrules to highlight AutoCAD dimensions and text using .NET

Thanks to Stephen Preston for providing the prototype that I extended for this post. He put it together in response to a suggestion for a new Plugin of the Month from Shaan Hurley, who thought a “dimension finder” tool for locating overridden dimension text would be useful for people. This code may well develop into that tool, but for now it’s being posted in its current, admittedly still somewhat rough, state. The below code implements a couple of overrules using the mechanism introduced in AutoCAD 2010: one to highlight dimensions in a drawing which have had their text manually... Read more →

Gluing a point to an AutoCAD curve using overrules from .NET – Part 3

In the most recent part of this series, we looked at one possible mechanism to allow points to be moved along a network of curves, extending the first part in this series, which focused on the case of a point on a single curve. This post is going to focus on something slightly different: it’s going to look at making the points added to a particular curve be associative to that curve – i.e. travel along with it as the curve is moved – and in the process we’re going to adjust the way we link between our objects,... Read more →

Gluing a point to an AutoCAD curve using overrules from .NET – Part 2

In the last post we looked at some code to create a point on a curve, and make sure it stays on that curve when edited. In this post we’re extending that code (albeit slightly) to work with a network of curves: the idea is that any curve which has a point created on it becomes a candidate for any point to snap onto as it moves around. This could clearly be extended to provided a better way of specifying the curves forming the network, of course. Here’s the updated C# code, with the modified/new lines in red (the... Read more →

Gluing a point to an AutoCAD curve using overrules from .NET – Part 1

Over the weekend I put together a little prototype to prove a concept for an internal project I’m working on. The idea was to force a point onto a curve (meaning anything inheriting from Curve in AutoCAD, such as Arc, Circle, Ellipse, Leader, Line, Polyline, Polyline2d, Polyline3d, Ray, Spline, Xline…), so that when the point is moved it snaps onto the curve to which it’s assigned. The solution I’ve put together is far from being complete – which is partly why I’m planning on making this a series, so I can flesh it out a little further in further... Read more →

A simple overrule to change the way AutoCAD lines are displayed using .NET

Thanks to Stephen Preston, who manages our DevTech Americas team, for donating the samples from his upcoming AU class for posting on this blog. Let’s start the week with a nice simple sample: the first from Stephen’s AU class. Looking back even to the first C# overrule sample I posted here, I can see that most have been quite complex, mainly because they’ve performed complicated things. Today’s code implements a very simple DrawableOverrule which changes the way lines are displayed in AutoCAD: Here’s Stephen’s C# code, reformatted to fit the blog: using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.GraphicsInterface;... Read more →

Knowing when an AutoCAD object is grip-edited using overrules in .NET

This week I will mostly be posting about Overrules. [For those of you who haven’t seen The Fast Show (called Brilliant in the US), this is an obscure reference to a character named Jesse. :-)] Aside from this post, Stephen Preston has sent me the samples he’s put together for his AU class on this topic, so expect some serious plagiarism (although now that I’ve given him credit I suppose it’s not really plagiarism :-). Here’s a question I received recently by email: Is there some posibility to write something in some of your next blogs about how to... Read more →

Highlighting named blocks using AutoCAD 2010’s overrule API from .NET

This is a nice sample provided by Stephen Preston, who manages DevTech’s Americas team. Stephen has put this together in anticipation of his upcoming AU class on the overrule API introduced in AutoCAD 2010. [I know the final class list has not yet been announced, but Stephen is co-owner of the Customization & Programming track at this year’s AU and presumably has the inside skinny on the selected classes. Which means he has a head-start on preparing his material, lucky fellow. :-)] The sample allows the user to enter a text string that it uses to highlight any block... Read more →

Using Boo with AutoCAD

I might also have called this post “Overruling AutoCAD 2010’s entity display and explode using Boo”, as it complements the equivalent posts for C#, F#, IronPython and IronRuby, but I felt it appropriate to combine the post with an introduction to what Boo is all about. What is Boo and how did I come to look into it? Knowing of my recent interest in the various scripting technologies being made available for .NET, a colleague at Autodesk recently pointed me at the Boo programming language (and here is the official page for the language, including its various downloads). First,... Read more →

Overruling AutoCAD 2010’s entity display and explode using IronRuby

As mentioned in this previous post, where I gave the same treatment to IronPython, I’ve been trying to get display and explode overrules defined in IronRuby working properly in AutoCAD. IronRuby is still at version 0.3, so this effort has been hindered by a number of CLR interop bugs (it turns out). I finally managed to work around these issues thanks to Ivan Porto Carrero, who is just finishing up his book, Iron Ruby in Action, and has been working with IronRuby since pre-Alpha 1 (brave fellow). Ivan’s help was invaluable: he ended up downloading and installing AutoCAD 2010... Read more →

Modifying an AutoCAD object’s state via a dynamic property defined using .NET

I’ve been meaning to get to this one for a while. This post takes the OPM .NET implementation and shows how to use it to allow modification of data persisted with an object: in this case we’re going to use the XData in which we store the “pipe radius” for the AutoCAD 2010 overrule sample we’ve recently been developing. To start with, I needed to migrate the OPM .NET module to work with AutoCAD 2010, which meant installing Visual Studio 2008 SP1. Other than that the code migrated very easily, and the project (with the built asdkOPMNetExt.dll assembly) can... Read more →