Do you make regular use of AutoCAD Architecture (ACA), AutoCAD MEP (AME) or AutoCAD Mechanical (ACM)? If so, I’d be interested in hearing from you.
First, some background. Something I haven’t yet talked about on this blog is an additional role I’ve picked in recent months: I’m now the (software) architect assigned to the three, above-mentioned, AutoCAD-based verticals. These products have a long history – and make quite varied use of AutoCAD’s APIs – so I was excited by the opportunity.
Incidentally, this doesn’t mean the focus of this blog is changing, at all – my role for these products relates to how we use core AutoCAD APIs to implement user-oriented functionality and is less about their own APIs – but I do expect the new role to lead to the occasional blog post (such as this one, in fact).
I used to know ACA fairly well, back in the day: by the turn of the millennium I’d been working with and supporting the APIs for Architectural Desktop for a couple of years, although I stopped soon after when I moved to the US to manage the DevTech Americas team. I’m sure lots has happened with the product since, and I look forward to getting familiar with it, once again.
I know AME less well, although being so closely connected with ACA should make things easier. ACM, on the other hand, is brand new to me: I’ve been aware of its existence since before Autodesk acquired the technology, but this is the first time it has come into my personal area of focus. That said, my first prolonged exposure to AutoCAD was at an engineering firm close to where I grew up, and the work they did was typical of the tasks many of our users perform with ACM.
To help get a better understanding of how these products are used, I thought I’d reach out via this blog to see whether anyone reading would volunteer some time to show me how they use one or more of these three products. This would ideally be an in-person visit – although for logistical reasons it’ll be easier for that to happen with companies based close to my location (i.e. Switzerland and parts of France, Germany, Italy and Austria) – but it may also be possible to find other opportunities to meet and even to use online tools to meet virtually.
Unfortunately it’s highly unlikely I’ll be able to use the opportunity to help solve specific issues you’re facing – my current knowledge of these products means I’m unlikely to be able to provide you with support of any calibre – but I would see it it as one way to make your priorities for the product you care about heard by at least one member of the team who develops it.
So, if you’re interested in talking about – and potentially demonstrating – how you or your company makes use of either AutoCAD Architecture, AutoCAD MEP or AutoCAD Mechanical, please drop me a line.
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 seems an interesting problem to work around using the extensibility framework we’ve built into AutoCAD’s JavaScript API. It’s always nice to have a concrete problem to get your teeth into. :-)
For some background to both the extensibility mechanism and AutoCAD’s JavaScript implementation, I recommend taking a look at Philippe Leefsma’s DevTV recording over on the AutoCAD DevBlog. The provided downloadable archive includes demos that show how to complement the JavaScript API using either ObjectARX or .NET.
So what do we want to do to work around our problem? Well, rather than drawing the transient graphics directly in JavaScript, we’re going to define a couple of methods in .NET that will get called from our JavaScript code via some functions that implement the required data marshaling.
Firstly, we need a drawCircle() function that draws a circle with the provided center and radius. The first time it’s called, this function will create a Circle and keep it in memory for subsequent calls. We also need a clearCircle() function both to remove the transient graphics and to dispose of the Circle object (otherwise there’ll be a crash when the object is disposed of by the .NET finalizer, which works on a background thread).
Let’s start with the C# implementation code. This code needs to be compiled into a DLL and then NETLOADed into AutoCAD for all this to work, of course:
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.Runtime;
using Newtonsoft.Json.Linq;
namespace JavaScriptExtender
{
public class Functions
{
private static Circle _cir = null;
[JavaScriptCallback("NetDrawCircle")]
public string DrawCircle(string jsonArgs)
{
// Unpack our JSON-encoded parameters using Json.NET
var o = JObject.Parse(jsonArgs);
var x = (double)o["functionParams"]["center"]["x"];
var y = (double)o["functionParams"]["center"]["y"];
var z = (double)o["functionParams"]["center"]["z"];
var center = new Point3d(x, y, z);
var radius = (double)o["functionParams"]["radius"];
// Draw our transient circle
var ic = new IntegerCollection();
var tm = TransientManager.CurrentTransientManager;
if (_cir == null)
{
// If the first time, create our circle
var ed =
Application.DocumentManager.MdiActiveDocument.Editor;
var norm =
ed.CurrentUserCoordinateSystem.CoordinateSystem3d.Zaxis;
_cir = new Circle(center, norm, radius);
// And then draw it
tm.AddTransient(_cir, TransientDrawingMode.Main, 0, ic);
}
else
{
// If not the first time, update our circle and
// the transient graphics representation of it
_cir.Center = center;
_cir.Radius = radius;
tm.UpdateTransient(_cir, ic);
}
return "{\"retCode\":0, \"result\":\"OK\"}";
}
[JavaScriptCallback("NetClearCircle")]
public string ClearCircle(string jsonArgs)
{
if (_cir != null)
{
// Clear the transient graphics we've added
var ic = new IntegerCollection();
var tm = TransientManager.CurrentTransientManager;
tm.EraseTransient(_cir, ic);
// Very importantly dispose of our Circle
_cir.Dispose();
_cir = null;
}
return "{\"retCode\":0, \"result\":\"OK\"}";
}
}
}
You’ll notice that the two methods we want to call from JavaScript – DrawCircle() and ClearCircle() – are tagged with the custom JavaScriptCallback attribute.
Something else to note is that the arguments passed into these methods are packaged as JSON (although this will be null for ClearCircle() as it doesn’t take logical arguments – we’ll see that later) that we’ll therefore need to unpack. In the first function, we do this using Newtonsoft’s excellent Json.NET library.
The simple way to add Json.NET to your project is via NuGet. In the Visual Studio interface select Tools –> Library Package Manager –> Manage NuGet Packages for Solution…
Check the beginning of the DrawCircle() method to see how Json.NET helps us unpack the JSON that’s passed into the function.
That’s the .NET side of things: now let’s take a look at what we need to add to our JavaScript code to essentially extend the JavaScript Shaping Layer.
Here’s the updated JavaScript code – the standalone version we saw at the end of last week. We could also update the HTML palette, but that would take more work to marshal across the data set by its various UI elements.
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 =
'<?xml version="1.0" encoding="utf-8"?>' +
'<drawable ' +
'xmlns="http://www.autodesk.com/AutoCAD/drawstream.xsd" ' +
'xmlns:t="http://www.autodesk.com/AutoCAD/transient.xsd" '+
't:onmouseover="onmouseover"' + cursor + '>' +
'<graphics id="id1"><circle center ="' + pointToString(cen) +
'" radius ="' + rad.toString() + '"/>' +
'</graphics></drawable>';
return drawable;
}
function circleJig() {
function onJigUpdate(args) {
var res = JSON.parse(args);
if (res) {
// The value being updated is the distance
radius = res.distance;
// Use it to create the XML for a transient
// circle and ask for it to be displayed
//var x = createCircle(center, radius);
//doc.transientManager.updateTransient(trId, x);
drawCircle(center, radius);
}
return true;
}
function onJigComplete(args) {
// When the jig is over, remove the transient
//doc.transientManager.eraseTransient(trId);
clearCircle();
var res = JSON.parse(args);
if (res && res.dragStatus == Acad.DragStatus.kNormal) {
Acad.Editor.executeCommandAsync(
'_.CIRCLE ' + pointToString(center) + ' ' + radius
);
}
}
function onJigError(args) {
write('\nUnable to create circle: ' + args);
}
function onPointSelected(args) {
var res = JSON.parse(args);
if (res) {
center =
new Acad.Point3d(
res.value.x,
res.value.y,
res.value.z
);
// Now we can create our transient
//var tran = new Acad.Transient();
//trId = tran.getId();
// And ask for it to be drawn
//var x = createCircle(center, 0, true);
//doc.transientManager.addTransient(tran, x);
drawCircle(center, 0);
// Set up our jig options
var opts =
new Acad.JigPromptDistanceOptions('Point on radius');
opts.basePoint = center;
opts.useBasePoint = true;
// Run the jig to select the distance
var jig = new Acad.DrawJig(onJigUpdate, opts);
Acad.Editor.drag(jig).then(onJigComplete, onJigError);
}
}
function onPointError(args) {
write('\nUnable to select point: ' + args);
}
// Ask the user to select the center point before we
// start the jig
var opts = new Acad.PromptPointOptions('Select center');
Acad.Editor.getPoint(opts).then(
onPointSelected, onPointError
);
}
// Our extensions to the AutoCAD Shaping Layer
function drawCircle(cen, rad) {
execAsync(
JSON.stringify({
functionName: 'NetDrawCircle',
invokeAsCommand: false,
functionParams: {
center: cen,
radius: rad
}
}),
onInvokeSuccess,
onInvokeError
);
}
function clearCircle() {
execAsync(
JSON.stringify({
functionName: 'NetClearCircle',
invokeAsCommand: false,
functionParams: undefined
}),
onInvokeSuccess,
onInvokeError
);
}
function onInvokeSuccess(result) {
write("\n");
}
function onInvokeError(result) {
write("\nOnInvokeError: " + result);
}
Acad.Editor.addCommand(
"JIG_CMDS",
"CJ",
"CJ",
Acad.CommandFlag.MODAL,
circleJig
);
I’ve commented out the various uses of transient graphics (although I’ve left in the now-unused createCircle() function) so you can contrast the calls with the new ones to drawCircle() and clearCircle().
It should be fairly obvious how we’ve implemented our drawCircle() and clearCircle() functions to simply call through to .NET using execAsync() (I suppose exec() might also have been called, but I tend to prefer to use asynchronous calls unless it’s absolutely required to use synchronous ones).
If you’d like to give this version a try – and it seems to work very well for me, at least – copy & paste the following into the command-line of AutoCAD 2014:
(command "_.WEBLOAD" "http://through-the-interface.typepad.com/files/CircleJigNet.js")
As mentioned earlier, you’ll need to have built the post’s C# code into a DLL that you NETLOAD into AutoCAD before the JavaScript code will function correctly. This will clearly impact the portability of your JavaScript code – unless you add the same capability across the other (future) platforms – but hopefully you can see how it’s possible to extend our JavaScript API implementation when you really need to.
After talking about the architecture of our JavaScript API in this recent post – and mentioning the approach we expect developers to take when creating geometry in one of the comments – I thought it would be worth spending the time to write my first JavaScript jig in AutoCAD.
For those of you who haven’t come across jigs in either ObjectARX or AutoCAD .NET, jigs are the primary way applications request users to dynamically specify geometric parameters while providing them with graphical feedback. As users select points or specify distances, the object or objects they’re creating are updated in real-time to reflect these choices. Much as you’d use a standard AutoCAD command to create geometry.
If you want to define a jig for a single object using .NET, you’ll probably use an EntityJig. The other main type of jig – a DrawJig – is not bound to a single object, although it can be used to create one. It basically allows the application to decide what gets drawn, rather than calling a particular object’s drawing methods.
Given the fact the JavaScript API doesn’t provide access to AutoCAD drawing objects – and there are currently no plans to provide this access – it made sense to expose the DrawJig capability to JavaScript. This allows applications to display custom, transient graphics during the jig’s operation, and then fire one or more AutoCAD commands to generate the drawing object(s) once done. Given there’s some IPC needed to communicated between the process hosting JavaScript and AutoCAD, you clearly don’t want to be marshaling huge objects (such as we saw in this recent post): not only would the XML generated to communicate the transient graphics to be displayed be large, so would the command-string you’d need to compose and send to generate the final database-resident representation.
So with that in mind, I set about creating what’s probably the simplest of jigs: to create a circle at a given point, asking the user to select the radius.
Here’s the JavaScript code I created, embedded into an HTML page to be loaded into a palette, based on the one we saw in this previous post:
<html>
<head>
<title>Jig a circle</title>
<script
type="text/javascript"
src="http://www.autocadws.com/jsapi/v1/Autodesk.AutoCAD.js">
</script>
<script type="text/javascript">
var doc = Acad.Application.activedocument;
var center = new Acad.Point3d(0, 0, 0);
var radius = 0;
var trId;
var colors = new Array();
colors['Red'] = "#ff0000";
colors['Yellow'] = "#ffff00";
colors['Green'] = "#00ff00";
colors['Cyan'] = "#00ffff";
colors['Blue'] = "#0000ff";
colors['Magenta'] = "#ff00ff";
colors['White'] = "#ffffff";
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 props = '';
var cursor = '';
if (first != true) {
var color = document.getElementById('ColCB').value;
var linetype = document.getElementById('LTCB').value;
var lineweight = document.getElementById('LWCB').value;
var filled = document.getElementById('Filled').checked;
props =
'color="' + colors[color] +
'" lineweight="' + lineweight +
'" linetype="' + linetype +
'" filled="' + filled + '"';
var cursorType = document.getElementById('Cursor').value;
if (cursorType == 'None')
cursor = '';
else
cursor = ' cursor="' + cursorType + '"';
}
var drawable =
'<?xml version="1.0" encoding="utf-8"?>' +
'<drawable ' +
'xmlns="http://www.autodesk.com/AutoCAD/drawstream.xsd" ' +
'xmlns:t="http://www.autodesk.com/AutoCAD/transient.xsd" '+
't:onmouseover="onmouseover"' + cursor + '>' +
'<graphics id="id1" ' + props + '>' +
'<circle center ="' + pointToString(cen) +
'" radius ="' + rad.toString() + '"/>' +
'</graphics></drawable>';
return drawable;
}
function circleJig() {
function onJigUpdate(args) {
var res = JSON.parse(args);
if (res) {
// The value being updated is the distance
radius = res.distance;
// Use it to create the XML for a transient
// circle and ask for it to be displayed
var x = createCircle(center, radius);
doc.transientManager.updateTransient(trId, x);
}
return true;
}
function onJigComplete(args) {
// When the jig is over, remove the transient
doc.transientManager.eraseTransient(trId);
var res = JSON.parse(args);
if (res && res.dragStatus == Acad.DragStatus.kNormal) {
Acad.Editor.executeCommandAsync(
'_.CIRCLE ' + pointToString(center) + ' ' + radius
);
}
}
function onJigError(args) {
write('\nUnable to create circle: ' + args);
}
function onPointSelected(args) {
var res = JSON.parse(args);
if (res) {
center =
new Acad.Point3d(
res.value.x,
res.value.y,
res.value.z
);
// Now we can create our transient
var tran = new Acad.Transient();
trId = tran.getId();
// And ask for it to be drawn
var x = createCircle(center, 0, true);
doc.transientManager.addTransient(tran, x);
// Set up our jig options
var opts =
new Acad.JigPromptDistanceOptions('Point on radius');
opts.basePoint = center;
opts.useBasePoint = true;
// Run the jig to select the distance
var jig = new Acad.DrawJig(onJigUpdate, opts);
Acad.Editor.drag(jig).then(onJigComplete, onJigError);
}
}
function onPointError(args) {
write('\nUnable to select point: ' + args);
}
// Ask the user to select the center point before we
// start the jig
var opts = new Acad.PromptPointOptions('Select center');
Acad.Editor.getPoint(opts).then(
onPointSelected, onPointError
);
}
</script>
<style type="text/css">
td, body
{ font-family: sans-serif; font-size: 10pt; }
body
{ background-color: #686868;
padding:0;
margin:5px 5px 5px 5px;
color:#FFF; }
textarea
{ font-family: Consolas; font-size: 8pt; }
</style>
</head>
<body>
<div id="canvas" class="shadow_box">
<h3>Jig a circle</h3>
<table border="0">
<tr>
<td align='right'>Color</td>
<td>
<select id='ColCB'>
<option selected="selected">Red</option>
<option>Yellow</option>
<option>Green</option>
<option>Cyan</option>
<option>Blue</option>
<option>Magenta</option>
<option>White</option>
</select>
</td>
</tr>
<tr>
<td align='right'>LineType</td>
<td>
<select id='LTCB'>
<option selected="selected">LineTypeSolid</option>
<option>Dashed</option>
<option>Dotted</option>
<option>Dash_Dot</option>
<option>Short_Dash</option>
<option>Medium_Dash</option>
<option>Long_Dash</option>
<option>Short_Dash_X2</option>
<option>Medium_Dash_X2</option>
<option>Long_Dash_X2</option>
<option>Medium_Long_Dash</option>
<option>Medium_Dash_Short_Dash_Short_Dash</option>
<option>Long_Dash_Short_Dash</option>
<option>Long_Dash_Dot_Dot</option>
<option>Long_Dash_Dot</option>
<option>Medium_Dash_Dot_Short_Dash_Dot</option>
<option>Sparse_Dot</option>
<option>Solid_6_Pixels_Blank_6_Pixels</option>
</select>
</td>
</tr>
<tr>
<td align='right'>LineWeight</td>
<td>
<select id='LWCB'>
<option>0</option>
<option>5</option>
<option>9</option>
<option>13</option>
<option>15</option>
<option>18</option>
<option>20</option>
<option>25</option>
<option selected="selected">30</option>
<option>35</option>
<option>40</option>
<option>50</option>
<option>53</option>
<option>60</option>
<option>70</option>
<option>80</option>
<option>90</option>
<option>100</option>
<option>106</option>
<option>120</option>
<option>140</option>
<option>158</option>
<option>200</option>
<option>211</option>
</select>
</td>
</tr>
<tr>
<td align='right'>Filled</td>
<td>
<input type='checkbox' id='Filled'/>
</td>
</tr>
<tr>
<td align='right'>Cursor</td>
<td>
<select
id='Cursor'
title='Cursor to be displayed on hover'>
<option selected="selected">None</option>
<option>None</option>
<option>Arrow</option>
<option>Ibeam</option>
<option>Wait</option>
<option>Cross</option>
<option>UpArrow</option>
<option>SizeNWSE</option>
<option>SizeNESW</option>
<option>SizeWE</option>
<option>SizeNS</option>
<option>SizeAll</option>
<option>No</option>
<option>Hand</option>
<option>AppStarting</option>
<option>Help</option>
</select>
</td>
</tr>
<tr>
<th> </th>
<td>
<input
type='button'
onclick='circleJig()'
value='Jig Circle' />
</td>
</tr>
</table>
</div>
</body>
</html>
When we load and run the palette – using the same .NET loader we saw in the post that first showed how to implement a palette using JavaScript – we see we can use it to launch our jig and create circles. Bear in mind that the settings in the palette are only respected during the jig: the CIRCLE command will simply pick up the current layer, linetype etc. when it creates the final circle.
The jig doesn’t operate as smoothly as you’d expect it to from ObjectARX or .NET, but then there is some marshaling overhead involved, after all. You’ll have to weigh the trade-offs between (future) portability, development effort and performance. (It’s also not clear it’s easier to develop using JavaScript than .NET… it’s probably easier than C++ but the tools available to debug your JavaScript code are still not that great).
Also, I found some trickiness when selecting the point to terminate the jig which then causes the command to be launched inside AutoCAD. If we comment out the code to display transient graphics it works perfectly, but otherwise you may have to click a few times to make it work. This is something that requires some further research – it feels as though some messages are getting swallowed, but it could be due to something else entirely.
Anyway, this is to say that there are still some rough edges around this API, which is natural given its relative age. My recommendation is to play around with it, but not to over-invest just yet: use the opportunity to get familiar with the tools and technology, and you’ll hopefully see us make the experience smoother over the next few releases.
I arrived back safely in Switzerland on Saturday night. It was a pretty good trip to the Bay Area, this time: most surprisingly this is the first time ever I’ve managed to sleep through until 6am (or thereabouts) on every single day of a trip to California.
But then I – like many people – do find going west to be easier than going east, jetlag-wise. I certainly found that I couldn’t get back to sleep when I woke up at home on Sunday morning at 3am, which made for a very long day (especially as we participated in the “Slow Up” event around a local lake, which – for me – meant pedaling along, pulling my youngest two children in a bicycle trailer for 30+ km). At least that meant I slept very soundly through the second night back, for which I’m thankful. Let’s see how I suffer when I head eastwards to Singapore in a couple of short weeks.
As many of you will now be aware, the call for proposals for AU 2013 is now open and will remain so until May 19th. It’s always great to have people presenting fresh ideas at the conference, so think about whether you have something to share with fellow Autodesk customers/partners/developers and submit a proposal or two!
I have another deadline, around the time the call for proposals closes, to provide presentation material on integrating both Leap Motion and Kinect Fusion into AutoCAD – to be presented in early June at our annual, internal Technical Summit in Boston (the third of my long-haul flights in the coming weeks) – so these are very likely to be the topics I submit for consideration for this year’s AU. At least that hopefully means – assuming the sessions are accepted and I get to attend – my lead-up to AU 2013 will not be as frantic as it sometimes is.
All this now means I’m back looking at both of these technologies, downloading the latest Leap Motion SDK and seeing whether I can tweak a little more performance out of the Kinect Fusion runtime to make it run more smoothly. I’ll certainly present whatever I manage to uncover (that I consider to be of interest) during the coming days.
Being here in San Rafael, it seemed like a good opportunity to put pen to paper on the internals of the JavaScript API introduced in AutoCAD 2014. It’s a topic I’ve been meaning to get to for some time, and sitting in the cube next to Albert Szilvasy helps me get information straight from the horse’s mouth, as it were (no offence, Albert ;-).
For those of you who don’t know Albert, he’s someone who has had an incredible impact on the AutoCAD product, over the years, particularly from a platform perspective. Albert was the person to architect and introduce AutoCAD’s .NET API, and is now doing the same for JavaScript.
Albert and I go back a looong way. I first met Albert in 1996 (I think), when I was in the “Developer Consulting Group” (a former incarnation of “Developer Technical Services” – or DevTech – the technical arm of the ADN team). I was presenting at the first Eastern European developer conference we’d held, in Brno in the Czech Republic. I was presenting on AutoCAD’s APIs with a particular focus on ARX (before it was known as ObjectARX), and there was one extremely sharp guy – Albert, of course – in the audience asking very pointed questions. He was still at university in Hungary, at the time, and was sharing his experience of implementing a robotics-related project inside AutoCAD using ARX. We shared more than a few drinks after the event, and I was delighted when Albert eventually ended up joining the ADN team in San Rafael. Albert later transitioned into the AutoCAD Engineering team, and the rest is history (and trust me when I say that the AutoCAD product is far better for it).
But I digress: let’s get back to talking about JavaScript inside AutoCAD…
To get JavaScript working inside AutoCAD, we’ve integrated the open source Chromium component into the product. This gives us the all-important V8 environment for executing JavaScript as well as a WebKit-based browser for rendering HTML content. You may have heard that Google is forking WebKit to continue development on their Blink rendering engine. This shouldn’t change anything for us, moving forwards: we may well choose to – at some point – move to a newer version of Chromium, and it’ll happen to be based on Blink.
One of the main reasons for going with Chromium rather than WebKit is that its JavaScript engine – V8 – is extensible. This allows us to add our AutoCAD-specific JavaScript APIs into the engine, making them available to code being executed by it.
Chromium is hosted in a separate process to AutoCAD: AcWebBrowser.exe. This process communicates back to AutoCAD via IPC – which should be just fine even for interactive processes such as jigs (where we have to pass a point from AutoCAD to our JavaScript code for each mouse movement). That’s not to say there isn’t some marshalling overhead associated with this communication – there is – but the benefits of having a separate process executing the code – particular around fault isolation – led to us making this trade-off.
The browser component loads what’s known as the JavaScript Shaping Layer when it starts. This is a generic API implementation layer that communicates with the host environment – in our case AutoCAD – via a small number of entry/exit points: exec(), execAsync() and registerCallback(). Any arguments that are needed for these functions – such as the options provided to the getInteger() method – will be encoded in JSON to be communicated via the IPC mechanism.
The beauty of limiting the implementation to make use of these few functions is that it becomes much more easy to translate across to other platforms – the layer itself is portable and having fewer connection points will reduce the amount of native development needed on each platform. At least that’s our expectation. That doesn’t mean, of course, that no work is needed to actually fill out the implementation behind these entry/exit points – that is work that clearly needs to happen – but we’re keeping the number of core connection points down to a small number and designing them to be as streamlined as possible, which should also help minimise the impact felt by the IPC marshalling overhead.
This marshalling happens between a native proxy inside AcWebBrowser.exe process and a native stub inside AutoCAD. With – as mentioned earlier – the marshalling of data happening via JSON.
Something that’s interesting for developers – and I know Philippe Leefsma has been looking into this and will no doubt post something soon on the AutoCAD DevBlog – is the ability to use acjsDefun() to register your own stub functions that can be recipients of the calls coming in via IPC. You’ll presumably need to essentially extend the Shaping Layer with your complementary JavaScript code that makes use of exec(), execAsync() and/or registerCallback() calls, but you won’t need to implement native code to extend the proxy implementation inside the browser process.
One thing that’s worth mentioning about the JavaScript Shaping Layer we’ve created: it’s being written in TypeScript, which gives us the ability to work in a more object-oriented fashion than JavaScript inherently provides, before compiling it to JavaScript and publishing the output. This is certainly something that people using the JavaScript API will want to look at doing themselves, depending on the complexity of the application they’re working on.
I think that’s probably enough information for today (I wonder if anyone actually made it down this far – please post a comment if you did! :-). I’ll follow up on more information about this new API capability as I discover (or uncover) it.
photo credit: cking via photopin ccI’m back in San Rafael after a tiring – but very rewarding – two days down in Santa Cruz. I’ve decided to rattle out a quick post – inspired by this recent comment – before heading out for dinner, so I hope my brain isn’t playing tricks on me when it says the code’s good enough to post. Please do let me know if you see anything wrong with it.
Here’s the question:
Kean, I am wondering how to do this on table objects. When importing a table from excel as pasting special ACAD objects, you can reset the table overrides, but this does not reset the cell content. You manually have to go through each cell to reset the formatting of the content. I have written an app that iterates through the selected table's rows/columns and gets the content in an attempt to use the text editor to reset the content of each cell. However, the texteditor.create only allows for MTEXT in which the table content is not MTEXT. I've looked on your other blog posts on tables and don't see a way to do this. Please help if you can. Thanks. Steve
When we run the PASTESPEC command – with some Excel data in the clipboard – and choose to insert “AutoCAD entities”, we get an AutoCAD table containing formatted text that shows up as black:
If we look at the contents of a particular cell, we see it has embedded formatting codes, such as this: "{\\fCalibri|b0|i0|c0;\\c0;A"
To remove this formatting, I adopted the technique suggested by Tony Tanzillo in an earlier comment on that post – and that I’ve looked at in some depth in this other post – to get at each cell’s unformatted contents. The code uses an MText object to strip off the formatting rather than the MText editor.
Here’s the C# code:
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
namespace TableFormatting
{
public class Commands
{
[CommandMethod("STF")]
public static void StripTableFormatting()
{
Document doc =
Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
// Ask the user to select a table
var peo = new PromptEntityOptions("\nSelect table");
peo.SetRejectMessage("\nMust be a table.");
peo.AddAllowedClass(typeof(Table), false);
peo.AllowNone = false;
var per = ed.GetEntity(peo);
if (per.Status != PromptStatus.OK)
return;
var tabId = per.ObjectId;
using (var tr = doc.TransactionManager.StartTransaction())
{
// Open the table for write
var tab = tr.GetObject(tabId, OpenMode.ForWrite) as Table;
if (tab == null)
return;
// Start by clearing any style overrides
tab.Cells.ClearStyleOverrides();
// We'll use an MText object to strip embedded formatting
using (var mt = new MText())
{
for (int r = 0; r < tab.Rows.Count; r++)
{
for (int c = 0; c < tab.Columns.Count; c++)
{
// Get the cell and its contents
var cell = tab.Cells[r, c];
mt.Contents = cell.TextString;
// Explode the text fragments
mt.ExplodeFragments(
(a, b) =>
{
if (a != null)
{
// Assuming we have a fragment, use its text
// to set the cell contents
cell.TextString = a.Text;
}
return MTextFragmentCallbackStatus.Continue;
}
);
}
}
}
tr.Commit();
}
}
}
}
Sure enough, we can run the STF command and select our table to strip away its formatting:
Subscribe via RSS
Recent Comments
Archives
More...