Rod Howarth

[Revit]– HTML Version of the Silverlight Revit Server Administrator Tool

2011-10-03T12:36:00.001+10:00

If you’ve used Revit Server Before, you might recognize this:

It’s the Revit Server Administrator Tool which you access by going to http://servername/revitserveradmin it lets you see what Revit Server projects you have present, what files are stored in them, and their version history. It also lets you create, move, copy, delete or lock files and folders.

It’s a vital tool for anyone who runs a Revit Server, and it generally works well, but it has one problem – it’s written in Silverlight. Whatever your opinion on Silverlight may be, it requires an extra installation and won’t run on any mobile devices. This is where the Revit Server API comes in. Using this REST API, I was able to recreate this website in HTML and Javascript. The result looks like this:

As my main motivation for this was to give the Revit Server REST API a run through, I’ve not made it absolutely the same, there are some minor visual and functional differences, but for the most part, it behaves in the same way. All of the action buttons are functional, you can see a submission history and folder structure.

For the moment, the main limitations are:

When you create or paste a folder, the treeview on the left gets recreated and starts collapsed again. This is fixable, and if there is interest, I’ll polish this up (probably by replacing the treeview library with a new one)
The submission history isn’t paged or sortable, its just a table with all the information in it. This should be fixable as well.

I’m interested to hear if anyone is genuinely interested in using this tool in their environment, if so, I’ll keep improving it, if not, then it will serve as a demonstration of the Revit Server API’s capabilities, and will form a part of my AU Virtual session this year.

The website is available on Github, to install it on your server simply download the zip file from that site, and create a folder called ‘html’ in ‘C:\Program Files\Autodesk\Revit Server 2012\Sites\RevitServerAdmin’ on the machine you have Revit Server installed. Put all the files in there, and you should be able to navigate to http://localhost/RevitServeradmin/html/ to access it.

For those interested in the technical details, the page is simple HTML (it’s named Default.aspx even though it isn’t an ASP.NET web page, it’s named this way because this allows us to access it by going to /html/ instead of /html/default.htm), with a CSS stylesheet and some images to replicate the interface of the Silverlight tool. The real work happens in the RevitServer.js file, which, with the help of Jquery, calls the REST web service for each of the various actions that the user performs, and updates the DOM with the results. There is no server side ASP.NET code involved, it’s all Javascript with the Revit Server REST API doing the heavy lifting.

Of course, if you want to use the Revit Server API, you don’t need to use Javascript, you could write a similar thing in C# or VB code and service up in an ASP.NET web page, or just about any language you like as long as they can make HTTP Requests.

If you want to know more about how it all works, or more about the Revit Server API, I’ll be going into more detail in my AU 2011 Virtual session.

[Revit Server]– How to get a listing of all Revit Server projects through the REST interface

2011-09-30T01:04:00.001+10:00

I’ve been writing some code that utilizes the Revit Server REST API, and in particular, I’m working on a HTML replacement for the Revit Server Admin page, which is currently written in Silverlight. More details on that will come (and will be included in my AU virtual class), but for now I ran into a bit of a stumbling block that others may encounter.

The REST API has an endpoint that lets you list the contents of a certain folder. This endpoint requires a GET request to the path ‘/{folderpath}/contents’ with folderpath being the path of your folder, for example a request to ‘/My_Project/contents’ would list the contents of the My_Project folder. But how do you find out that there is a My_Project folder in the first place? You need to get a listing of all of the folders underneath the parent folder on the server, but how would you do that? You can’t send you request to ‘/contents’, as you are missing the folder path section, and thus it’s not a valid endpoint according to the API. I tried a number of different combinations of URL’s before I finally found one that seems to work.

To get a listing of all the folders underneath the parent folder, send your GET request to:

‘/ /contents’

That is, use a space instead of a folder path, like so:

“http://localhost/RevitServerAdminRESTService/AdminRESTService.svc/ /contents”

This will be treated as if it is the root folder, and will list the folders underneath that.

[Revit]– Autodesk University 2011 Virtual Class: Automating Autodesk Revit Server

2011-09-30T00:56:00.001+10:00

The Autodesk University conference in Las Vegas is approaching us once again. I’ve had the great privilege of presenting at this event for the past two years on topics concerning the Revit API. At this stage it doesn’t look like I’ll be making the trip from Australia this year to attend the physical conference, but that hasn’t stopped me from being involved virtually! I’ve been accepted to present a class on “Automating Autodesk Revit Server”. Here is the class description:

Class Description

The latest version of Revit Server offers a number of automation capabilities, from locking files and creating directories to generating a new local file for a Revit central model. This class will explore these options and consider some scenarios where they can be leveraged along with existing Microsoft® Windows® and Revit APIs to perform time-saving tasks. A number of examples will be showcased, including how to create a HTML replacement for the Silverlight® admin tool, how to create a Revit Server folder from an existing system, and how it is possible to have a scheduled task that runs once a day, creates a local file, opens it, and exports the model to a DWF™ without user interaction.

Key Learning

Explain how Revit server automation can be integrated into existing software processes
Describe the REST interface to Revit Server
Combine the Revit Server command line and the Revit API to perform a task in a Revit model on a schedule
Use the supplied command line utilities to automate Revit Server

The idea for this class came about when I was playing around with Revit Server and noticed that there is a document on the REST API in the Revit SDK. I had a few ideas for interesting things to do with this API, and Revit Server in general, and what better motivation to put them into action than the pressure of presenting an AU class on the topic :)

Virtual classes only go for 45 minutes, so the code will mostly be read through and explained rather than written live, but I’ll have a bunch of code available for download and in the handout.

If you are interested in Revit Server, be sure to check it out! If you aren’t, but are interested in Revit API development, check out the various other Revit API classes that will be a part of the event, the Revit API team have once again put together a great curriculum to help you get as much API knowledge as you can out of AU.

[Revit API]–How to create an installer for your Revit Addins

2011-08-22T15:37:00.002+10:00

Often I see Revit API utilities distributed with instructions to copy manifest files around and put the files in a certain directory (I’ve done it myself in the past), which works fine, but there is a more user friendly way of setting up your addins. You can use Visual Studios ‘Setup Project’ functions to create an installer, which isn’t the pretties installer going around, but it gets the job done.
Doing this is a little harder than you’d think, there’s a few gotchas, so this post aims to step you through it.
Add a new project to your solution, under ‘Other Project Types’, ‘Setup and Deployment’ choose ‘Setup Project’.

You’ll see a view like this, delete ‘Users Desktop’, ‘User Programs Menu’

Right click on Application folder and go to add > project output. Choose the Addin project.

Right click on application folder again, go to properties and change the DefaultLocation to be:
[ProgramFiles64Folder][Manufacturer]\[ProductName]
This is so that it will always be in a consistent install location, rather than program files (x86).
Now, we don’t want to distribute RevitAPI and RevitAPIUI dlls, so in the solution explorer, expand detected dependencies and right click on those and click exclude.

Click on the installer project, then click the properties tab, and set the ‘Manufacturer’ and ‘ProductName’ to match your company/addin name. Also, while you are here, change the ‘TargetPlatform’ to X64. Unfortunately with these types of installers you need a separate install for X86 and X64, but I think most of you will be building API addins for X64 systems, as Revit generally needs at least 4gb of RAM, and if you are enough of a power user to be installing add-ins, you are going to be running a 64bit operating system I’m sure. But keep in mind that it may vary for you.
We need to create a .addin manifest file that points to the program files folder as follows, make sure you generate a new GUID.
<RevitAddIns>
<AddIn Type="Command">
    <Text>My Revit Util</Text>
    <Assembly>C:\Program Files\COMPANY NAME\PRODUCT NAME\Addin.dll</Assembly>
    <AddInId>18520534-3ee1-473e-ae97-a68dfbda3754</AddInId>
      <FullClassName>MyRevitUtil.Command</FullClassName>
  <VendorId>COMP </VendorId>
   <VendorDescription>MY COMPANY </VendorDescription>
</AddIn>
</RevitAddIns>

In The primary output screen, add a new custom folder, called Autodesk Addins. Right click on it and go to properties and set the DefaultLocation to
[CommonAppDataFolder]\Autodesk\Revit\Addins\2012
and Property to AUTODESKADDINS
This will install it for all users. Right click in the middle panel and go to add file, and choose your manifest.

At this point you’re almost done, there’s just a couple of .NET settings to tweak. First of all, we don’t need to bundle an installer for .NET framework as Revit installs it by default, so right click on your installer project, go to properties and hit prerequisites

Then untick the first checkbox

Finally, right click on your project, click View > Launch Conditions, click .NET framework and change it to .NET Framework 4 (or lower if you are in Revit 2011 mode still).

Now you are done, you can right click your project and go to Build and your .msi installer will be output.

[Revit API]–API Wishlists

2011-05-17T07:35:00.000+10:00

The yearly Autodesk API wish list surveys are available online now, I encourage you to fill them out to help shape future releases of the API.

AutoCAD
http://www.zoomerang.com/Survey/WEB22C9QA2TDYR

Autodesk Inventor
http://www.zoomerang.com/Survey/WEB22C9QBPTEZ5

Autodesk Revit
http://www.zoomerang.com/Survey/WEB22C9QACTE6V

AutoCAD Civil 3D
http://www.zoomerang.com/Survey/WEB22C9Q8JTD3G

Autodesk Navisworks
http://www.zoomerang.com/Survey/WEB22C9QBRTF2C

[Revit] Running a local Revit Server on Windows 7 safely–free utility

2011-05-08T00:05:00.001+10:00

Autodesk Revit Server is a product that comes bundled with Revit 2011 and 2012. It provides a way for you to better coordinate Revit access over a wide area network by hosting your central model in Revit Server and connecting your Revit to that instead of opening a .rvt file on a network drive. This is particularly useful for companies with multiple offices, as Revit Server allows you to setup a ‘central’ server and ‘local’ servers are different locations. Saves to the Local servers are done over a LAN, and the local server then synchronizes the model back to the central server in an optimized fashion. Thus providing an alternative to expensive WAN optimization devices such as those provided by Riverbed.

One usage instance that many people are interested in, is having a local Revit server instance installed on their laptop for when they work remotely. That way saves to central over a VPN are done quickly, and Revit Server will synchronize the model back to the office in the background. The problem is, Revit Server only supports Windows Server 2008 R2, which is very expensive. However there is a way around this, you can, unofficially install Revit Server on your Windows 7 computer. I’ve had success in getting this setup, and so has Dave Baldacchino from the blog Do U Revit. Check out his post on the topic and read the ‘setup’ section for instructions on how you can get it running. There is some danger in this approach, as Robert from the blog ‘Don’t think: Do Revit’ warns, that shutting the server down while it is still trying to synchronize back to the central server can cause some issues.

This is a problem, as Revit Server has no inbuilt way to tell when it is synchronizing. To solve this issue, I’ve created a small utility that sits in your system tray, and tells you when Revit Server is communicating with anyone. I call it ‘Revit Server Monitor’

You run the program, and minimize it to your computers tray. You will then see a green arrow to indicate that the Revit Server is not currently communicating with anyone.

Or if any sort of communication is in progress, you will see a red arrow.

So if there is a red arrow, don’t shut your computer down. Wait for a green arrow to be safe.

This works by reading port 808, which is the primary port that Revit Server uses to communicate. Using the WinPCap utility, my code can monitor traffic on this port, if it detects any, it will show the red signal. If there has been no traffic on that port for 5 seconds, the signal will turn green. You can download the tool from here. To set it up, you must first install WinPCap, which is included in the zip, and then just run the RevitServerMonitor exe (perhaps add it to your computers startup folder as well so you don’t forget to run it). The program itself requires .NET 3.5 to run, but if you have Revit installed you will have that installed as well. If you are a little worried about having software that monitors packets running on your PC, feel free to browse the source code here, it’s fairly simple!

If you are running a Revit Server on your Windows PC, do try it and let me know how it goes, I’m not guaranteeing it will prevent model corruption but I’d love to hear your feedback on how well it worked.

Download the software here.

View the source code here.

[Revit API]– Running your add-ins from a network drive in Revit 2012

2011-04-20T13:18:00.002+10:00

In previous years our office has run our add-ins directly off a network drive. I’ve placed the DLL files in a network directory, and then installed the .addin manifest file on each users computer that points to these DLL’s. This way when I update the add-ins I only need to update one location and the users simply need to reboot Revit.

To get this to work, I just had to run caspol.exe on each machine to make their machines trust that certain location, for example:

echo y|C:\WINDOWS\Microsoft.NET\Framework\v3.5\caspol.exe -cg LocalIntranet_Zone FullTrust

echo y|C:\WINDOWS\Microsoft.NET\Framework\v3.5\caspol.exe -m -ag 1.2 -url file://L:\* FullTrust

However in upgrading the add-ins to Revit 2012, this method did not work. The add-ins simply would not load, and in the journal file I was seeing this error:

Jrn.RibbonEvent "Execute external command:35015:Plotting.PLT"

' 0:< DBG_WARN: Could not load file or assembly 'file:///L:\Plotting.dll' or one of its dependencies. Operation is not supported. (Exception from HRESULT: 0x80131515): line 171 of AddIn\AddInItem.cpp.

This was when my assemblies were compiled in .NET 4 and the same error occurred after I recompiled them in .NET 3.5. I had a feeling that it might have something to do with the changes in security that were introduced with .NET 4, but the fact that it happened to .NET 3.5 dll’s as well was odd.
Turns out there’s a fix for it, which is a little bit of a pain, your user needs to update their revit.exe.config file in the Revit program directory (C:\Program Files\Autodesk\Revit Structure 2012\Program) and make the following change:

look for the <runtime> tag, and just after it’s opening, put:

<loadFromRemoteSources enabled="true" />

making it:

<runtime>

  <loadFromRemoteSources enabled="true" />

  <generatePublisherEvidence enabled="false"/>

</runtime>

The add-ins should then run correctly. This is however a bit of a pain, I’ll have to incorporate this into an installation tool. I’d love to hear of a better solution to this problem if anyone knows of one, however for now, this will work around it.

Thanks to this post for helping to point me in the right direction.

[Revit]–Where have the journal files gone in Revit 2012?

2011-04-19T17:35:00.001+10:00

If you’ve made the jump to Revit 2012, you may have noticed that there is a new directory structure in the program files dir.

There is no longer a journals folder. So where has it gone? The answer is that It appears to have been moved to the AppData directory.

C:\Users\USERNAME\AppData\Local\Autodesk\Revit\Autodesk Revit Structure 2012\Journals

Replace the uername with your username, and also enter the correct Revit vertical you are using.

[Revit]–Journal File Analyzer–Free Utility to identify Keyboard Shortcut candidates

2011-03-25T07:58:00.000+10:00

Luke Johnson runs a great Revit blog called ‘What Revit Wants’, which is updated frequently with lots of good general Revit information. He recently issued a challenge in regards to Journal file analyzing which I have (somewhat) answered.

The result is a utility that I’ve developed that will take a look through your journal files and identify your most commonly used menu items, along with your most commonly used keyboard shortcuts. The idea is that you can run this utility and assess what commands you should add a keyboard shortcut to, in order to make your Revit usage more efficient.

To run the utility, you simply open it, enter the correct location of your Journal files and (optionally) your keyboard shortcuts.xml location (it tries to auto detect this for you, but you may need to change Structure to Architecture in the path).

Click Analyze and it will look through the journal files and tally up your 20 most commonly used commands with and without shortcuts..

An example output for Top Shortcuts used is as follows:

Create a straight detail line or a detail arc , DL - 120 times
Control visibility and appearance of objects (applied only in the active view) , VG - 116 times
Trim/Extend two lines or walls to make a corner. , TR - 88 times
Create a line , XD - 82 times
Create Aligned Dimensions , DD#DA - 75 times
Create a text object , T3 - 69 times
Create a detail component , DC - 65 times
Redraw everything as large as fits into window , ZF#ZE - 56 times
Align references. , AL - 39 times
Draw all lines as thin lines. This does not affect printing. , TL - 36 times
Trim/Extend multiple lines or walls to the same bounding reference. , EX - 34 times
Create a default 3D orthographic view. , 3D - 34 times
Split walls and lines , ES#SPL - 26 times
Manage Links , ML - 24 times
Change style of selected lines , LW - 22 times
Copy the type of one object to other objects , MT#MA - 21 times

What this is saying, is the general name of the command, followed by the keyboard shortcut for that command (as long as you have linked in your shortcuts file) followed by how many times you used that command.

On the right is the display of the top commands used that weren’t started from a keyboard shortcut:

"Undo the last action , ID_BUTTON_UNDO" - 37 times
"Move selected objects or their copies , ID_EDIT_MOVE" - 23 times
"Show or hide recent files , ID_STARTUP_PAGE" - 20 times
"Move copies of selected objects , ID_EDIT_MOVE_COPY" - 8 times
"Finish the family , ID_END_INPLACE_FAMILY" - 8 times
"Prevent change of element position , ID_LOCK_ELEMENTS" - 8 times
"Save the active project back to the Central File , ID_FILE_SAVE_TO_MASTER_SHORTCUT" - 6 times
"Save the active project with a new name , ID_REVIT_FILE_SAVE_AS" - 5 times
"Open an existing project , ID_REVIT_FILE_OPEN" - 5 times
" , ID_FILE_CADFORMAT_LINK" - 5 times
"Finish Sketch , ID_FINISH_SKETCH" - 4 times
"Redo the next action , ID_BUTTON_REDO" - 4 times
"Save the active project , ID_REVIT_FILE_SAVE" - 3 times
" , ID_REVIT_SAVE_AS_FAMILY" - 2 times
"Pick Lines , IDC_RADIO_COPY_CURVE" - 2 times
"Review previously posted warnings , ID_REVIEW_WARNINGS" - 1 times
"Purge (delete) unused families and types , ID_PURGE_UNUSED" - 1 times
"Create a rectangle , ID_OBJECTS_CURVE_RECT" - 1 times
"Modify predefined types for this family , ID_FAMILY_TYPE" - 1 times
"Quit in place family , ID_QUIT_INPLACE_FAMILY" - 1 times

You can see here the name of the command, it’s ID and how many times you’ve used it.

The ‘Include Context Menu Entries’ checkbox is used for if you want to include commands that were fired from menus like the right click menu – which often you can’t create a keyboard shortcut for, but sometimes you can (Save To Central shows up in this listing).

To download the tool and run it on your own download it from HERE. Let me know how it goes for you!

Also, if you are interested in the source code, it’s available on GitHub. If you don’t have Git (you should check it out!) you can download the source code as a Zip. If you want to modify the code feel free to send me a Push request!

[Revit] Tic Tac Toe for Revit with online play

2011-03-07T00:19:00.001+10:00

This is a ‘for fun’ project that I have been working on this week. It started out as something interesting to code while I was up late due to having too many coffees, but then I decided to add a few more features to it throughout the week.

The game is a version of Tic Tac Toe (naughts and crosses) using rooms in Revit as the squares.

The game can be played either locally, or online via sever connection.

The local game is intended to be played by two people sitting at the same computer, swapping the mouse between each other in between turns. When the game starts, the user must click inside the room that they wish to place their X or O in:

Then it is the other players turn, and so on until the game is won, or all rooms are filled. When the game is won, the text notes on the view are updated to add to the score:

After getting this working, I decided I could try and take it one step further, by adding online play. To play this the user selects online play when starting the game, and then they must either create or join a new session:

Clicking Create New Session will get a new session ID from the server.

That session ID must be then passed to the opponent who enters it in the textbox on the same screen. Once both people are ready, click ‘Start Game’.

The game then plays out in a similar way to the local game, but after each turn you’ll see the ‘waiting on other player’ screen:

When the other player takes their turn, your view will be updated with their input.

This continues until the game is won or board is filled.

To install the game, download it from HERE and unzip the files to C:\RevitTicTacToe\. Then move the TicTacToe-Manifest.addin file to your Revit Addins directory, which will be one of the following:

Vista/7 Users:
C:\ProgramData\Autodesk\Revit\Addins\2011

XP Users:
C:\Documents and Settings\All Users\Application Data\Autodesk\Revit\Addins\2011\

Then simply open GameBoard.rvt from C:\RevitTicTacToe\ and run the the addin from Add-Ins tab, External Tools menu:

While this is a bit of a silly project, it was a bit of fun, and I got to use a few cool techniques which will form the base of some blog posts to come, including manual transactions in Revit, RESTful web services in ASP.NET MVC, interacting with rooms via the API, making web requests from Revit and more.

When showing an early version of this game to some Revit users it was mentioned that they believed some of this functionality could be implemented in a Revit family, I mentioned to Jason Grant on Twitter that I’d love to see if any expert Revit Family makers can rise to the challenge and give a working version of Tic Tac Toe in a family!

Feel free to give the game a go, let me know if you find any bugs in it. If you want to take a look at the source code, it’s available on GitHub. You can download it all using the Git verison control system, or you can click on files online to view them in browser.

[Housekeeping]– New Revit only RSS blog feed available

2011-02-13T12:37:00.001+10:00

Many of you may be reading this post via an RSS feed reader from the blogs main feed. If you are reading the blog purely for the Revit API content, and don’t want to see my posts on other programming topics, I’ve created a custom RSS feed that will only display blog posts that are labelled ‘Revit’.

You will now see to the right of my blog:

Subscribe to all posts
Subscribe only to Revit related posts

Feel free to update your reader to the Revit only post if you wish. I am planning on adding more and more posts on other development topics, including ASP.NET MVC and mobile application development (Android initially, but perhaps IOS later on). If you aren’t interested in these topics, register to the Revit only feed!

[Revit API]–Introduction to VSTA as a rapid prototyping tool

2011-02-13T10:19:00.000+10:00

At Autodesk University in December some of the Autodesk Revit API team were mentioning that they thought VSTA was a little underappreciated by Revit API developers, and that it is a very useful too, particularly for working things out before turning them into fully fledged applications.

I must say that I’ve always steered clear of VSTA, for a number of reasons, firstly it used to lack a few features, and secondly that I’ve always preferred the full Visual Studio professional as I can use plugins like the wonderful Resharper plugin. However, there are disadvantages to this, namely that you generally have to reboot Revit after each code change. I’ve purchased a good quality Solid State Drive in order to make Revit boot quickly, which has made this disadvantage bearable, and there are some techniques to try and avoid restarting Revit all the time but it’s still not ideal.

Enter VSTA. I recently decided to give it a try to quickly answer a question someone asked me via email. To get started using it, you need to install it from the Revit disk. After this, you should be able to open a document and go to the Manage ribbon tab and go to ‘Macro Manager’. This is somewhat confusing, as all non VSTA addins go in the ‘addins’ tab.

You will then see the Macro Manager, which lets you create either an Application level macro, or a Document level (ie the code is included in the actual Revit file you have open). To do some rapid prototyping we’ll create a document level macro by clicking on the tab that is named the same as your Revit file.

Here you’ll see a couple of tools I’ve made, to create a new one click ‘Create Module’ which opens a dialog box asking you to name your new Module.

This create a new module in the list.

Click on it, then Click Create ‘Macro’.

This will create a new instance of VSTA, which is a cut down version of Visual Studio 2008.

You can see here it has created a HelloWorld method which represents your macro, in addition to that there’s the usual Attributes you’d see on an External Command, and also the AddInID GUID is created – no need for you to set this up. There’s also Module_Startup and Shutdown methods which let you run some code which happens before or after every macro in the module. For now, we’ll just concentrate on the HelloWorld method.
To show a simple dialog box, first we need to import the Autodesk.Revit.UI namespace at the top, and then we can add in our Task Dialog code:

public void HelloWorld()

    TaskDialog.Show("Hello World","Hello World");

Now, to run this code first we need to build it, go to Build > Build Example. Then swap back to the Macro Manager and you’ll see the Example module can be expanded out to see all the macros underneath it.

We can select that macro and click ‘Run’ to run it, or Step Into if we want to debug it.

As you can see it works fine. Now lets create one that does something a little different. Say we have a detail line on our document, like one from my previous post that creates a detail line:

And we want to know how to access the length of it in millimetres through the API. Here’s a workflow we can use to do that.
First, create a new macro under the Example module called GetLength

You should see it creates another public void for that macro. (You can create macros just by creating the methods yourself if you like)

Now, we want to figure out how to access the length. If you have two monitors (if you don’t, you should!) put the VSTA code on one window and on the other, select your detail line. To work out how to access this value, we can use RevitLookup, if you haven’t installed it, grab it from the SDK and install it – it’s essential for Revit API development.
Go to the add-ins tab, go to Revit Lookup and snoop the current selection. You’ll see the API’s view of this element

Click on the ParameterSet and you’ll see there is a parameter called Length.

This is what we want to access. Swap to the other window, and lets access it via code. First off, we’ll have to reference the Autodesk.Revit.DB namespace. Then, we need to get at both the Document and UIApplication objects. To do this in a VSTA macro, you can use this.Document and this.Application. However rather than writing this each time in the code, I like to extract these to a variable. That way if the code I’m prototyping here ends up as a full API tool I can easily move it to a Visual Studio solution.

public void GetLength()

    Document doc = this.Document;

    UIApplication app = this.Application;

We’ll use the currently selected element as a way of getting to the detail line, then we’ll read through its parameters looking for the length, and display it in a TaskDialog.

public void GetLength()

            Document doc = this.Document;

            UIApplication app = this.Application;

            foreach (Element selectedElement in app.ActiveUIDocument.Selection.Elements)

                if (selectedElement is DetailLine)

                    //the selected element is a detail line, so cast it to one.

                    DetailLine line = (DetailLine)selectedElement;

                    //loop through all the parameters

                    foreach (Parameter parameter in line.Parameters)

                        if (parameter.Definition.Name.ToLower().Equals("length"))

                            //found the length parameter

                            TaskDialog.Show("Length", parameter.AsValueString());

To run this, go to Build > Build Example and then swap back to Revit, head into the Macro Manager and run your macro. As long as you have the line selected you should see the result flash up

Now you know how to access the length, you’ve experimented in VSTA, and you can convert this code over to your full blown Revit add-in that you have been working on, or planning to work on.

This has saved us a fair bit of time, instead of creating a new Visual Studio project, setting up our entry class, referencing the API, adding the transaction and regeneration attributes (and probably forgetting to do that once, starting Revit, having an error and then having to exit again), setting the references to not copy, setting up an addin manifest file, creating an addinID GUID etc we’ve just opened VSTA, and with the document still live in front of us we’ve written our code and tested it.
While it may not be so convenient when creating a comprehensive Revit addin, I believe VSTA is certainly very handy when just doing some trial and error coding to work out how to access things through the API. For more examples on how to use VSTA, see the VSTA samples folder in the Revit SDK.

[Revit API] – How to draw a detail line on a view

2011-02-12T13:29:00.000+10:00

I got asked a question similar to this so thought I’d post it up. To draw a detail line on a view, from one point to another, you first need to create a ‘Line’ and then a ‘DetailCurve’.
This may be a little confusing, but a ‘Line’ is not the actual end result, it’s a geometry object that represents where the line will go. To actually draw the line you need to create a DetailCurve, which is the actual Detail Line.
Here’s the code that I’m talking about:

//Create the Points

double x1 = 5.0;

double y1 = 5.0;

double z = 0.0;

double x2 = 117.0;

double y2 = 115.0;

XYZ point1 = app.Application.Create.NewXYZ(x1, y1, z);

XYZ point2 = app.Application.Create.NewXYZ(x2, y2, z);

//Create line

Line line = app.Application.Create.NewLineBound(point1, point2);

DetailCurve detailCurve = doc.Create.NewDetailCurve(doc.ActiveView, line);

TaskDialog.Show("Done", "Line Created");

First off, we are setting up the XYZ for each point that we are going to draw between. These are points in the model. Then we use the NewLineBound method to create a bound line in space between point1 and point2. If you just stopped here, you would see nothing in your model. To actually draw the Detail Line you use the NewDetailCurve method to specify which view you want to draw the line on, and the line that represents it’s geometry.
To run the code you’ll need to be in a transaction (or use Automatic transaction mode), and need to initialize the app and doc variables as you normally would. When you run the tool, the final result is this:

A simple line drawn on the page.

[Revit API]–Hide Warnings in Revit using the API

2011-02-07T10:05:00.000+10:00

The general rule ever since the Revit API was released, is that whatever you can do in the API, you can also do through the normal user interface.

In recent versions I’ve come across a few different examples of where the API is starting to let you do some things you can’t do through the interface (as far as I know – there may be a way I am missing!). One such example is interacting with warnings.

Revit 2011 introduced the new Failures API. This API lets you do two things:

1. Create new warnings within Revit

2. Respond to warnings reported by Revit.

I’m going to discuss option 2 today through a quick example. Lets say that you have a burning desire to place two walls in exactly the same position. Normally when you do this in Revit, you’ll get a warning that looks like the following:

Which you can ignore. This is a bit of a silly example, but in many offices there may be warnings in Revit which you ALWAYS accept, and therefore having them in the warnings menu simple messes up the signal to noise ratio, and could mean that real warnings get lost in the crowd.

To stop this warning from displaying, we can make use of the new failures API. To do this, we use an event called the FailuresProcessing event, so as per usual with events we need to make a new ExternalApplication and subscribe to that event:

public Result OnStartup(UIControlledApplication application)

    application.ControlledApplication.FailuresProcessing += ControlledApplication_FailuresProcessing;

    return Result.Succeeded;

public Result OnShutdown(UIControlledApplication application)

    application.ControlledApplication.FailuresProcessing -= ControlledApplication_FailuresProcessing;

    return Result.Succeeded;

Whenever Revit does its failures checks, which is at a number of points in time, including after making our wall, or when opening the warnings menu, our ControlledApplication_FailuresProcessing method will get called.

void ControlledApplication_FailuresProcessing(object sender, Autodesk.Revit.DB.Events.FailuresProcessingEventArgs e)

       FailuresAccessor accessor = e.GetFailuresAccessor();

       IList<FailureMessageAccessor> messages = accessor.GetFailureMessages();

       foreach (FailureMessageAccessor failure in messages)

           FailureDefinitionId failId = failure.GetFailureDefinitionId();

           if (failId == BuiltInFailures.OverlapFailures.WallsOverlap)

               TaskDialog.Show("Deleting Failure", failure.GetDescriptionText());

               accessor.DeleteWarning(failure);

In the code above, you get an object of type ‘FailuresAccessor’ which, funnily enough, lets you access the failures.

Then you can get all of the failure messages and loop through them, then I use the BuiltInFailures listings to match the unique ID of each failure with the one that I’m looking for, that is BuiltInFailures.OverlapFailures.WallsOverlap. The WallsOverlap property simply returns a FailureDefintionId which is used when a WallsOverlap failure is added, so by comparing this with our ID we can find the failures we are after.

If they match, I’m showing a task dialog (you may like to remove this, it’s just there for demonstration purposes) and deletes the warning.

If you load Revit and try to create walls again you’ll see:

and you won’t get the Revit warning. Take out the call to task dialog and you’ll always have the warning deleted silently – meaning it’s never displayed to the user. Fairly quickly and easily you can remove a certain failure from the list, and as long as your ExternalApplication is running in the background it will never show up.

This can only be used for warnings, so errors can’t be simply deleted, however the Failures API has some neat options to do with automatically resolving errors, but that’s a topic for another day.

[Revit]–Free API addin–Revit Save Reminder, alerts you when your save to central is complete.

2011-02-04T21:12:00.003+10:00

A fair while ago, during AU 2009 I believe, I saw on Twitter that someone suggested it would be a great if someone could make a dialog box that flashes to let you know that your save to central has completed, so that if you start doing other things whilst large projects are synchronizing, you will know when it’s done.
I thought this was a good idea, and made a mental note to make an add-in for it, and at long last, I’ve created it. You can download the add-in from HERE or HERE. If you are interested in the very basic source code, it’s on GitHub HERE.
To install it, simply extract the files into C:\Program Files\RevitSaveReminder\ and then move the RevitSaveReminder-Manifest.addin file to your addins directory which is C:\ProgramData\Autodesk\Revit\Addins\2011\ if you are on Vista/7 or C:\Documents and Settings\All Users\Application Data\Autodesk\Revit\Addins\2011\ if you are on XP.
After installing it, simply open your project, when your next synchronization with central is complete, you’ll see a window like this pop up:

And in your taskbar it’s icon will be flashing:

Additionally, you’ll be greeted with a generous round of applause playing from your speakers, to congratulate you on successfully completing some more work. So even if you are doing some paper work on your desk, you’ll be alerted when it’s time to get back into Revit. I’ve made the sounds configurable, there’s a couple more sounds, one is a chime, and another is the cocking of a shotgun (as in, reloading and getting ready to kick Revit’s ass some more!), or if you wish, you can configure your own .wav file to play. To do this, simply edit the RevitSaveReminder.dll.config file in your program files directory. If you want no sound, edit it and make the WavFile value empty.
I hope someone gets some use out of this (perhaps the person that Tweeted it a couple of years ago and has no doubt been frantically searching the internet for it ever since)! Let me know your thoughts, bugs or suggestions.

[Revit API]–Common Mistakes: DocumentSaved and DocumentSavedAs events

2011-02-03T22:08:00.001+10:00

The Revit API has many useful events, including:

DocumentChanged
DocumentSaving
DocumentSavedAs
DocumentClosing
DocumentClosed
DocumentOpened
DocumentCreating
DocumentCreated
DocumentSynchronizingWithCentral
FileExported

And more. These let you run some code when certain events occur in Revit. You can make some powerful things with these events, so if you haven’t used them before, I recommend that you check them out.

A bit of a ‘duh’ moment that you may run into, is when you want to make a tool that runs whenever the user saves the document. Seems simple enough, you subscribe to the DocumentSaved event with code similar to this:

      public Result OnStartup(UIControlledApplication application)
        {
            application.ControlledApplication.DocumentSaved += ControlledApplication_DocumentSaved;
            return Result.Succeeded;
        }

However there’s a problem with this code – it won’t run the first time a user saves the document. This is because the DocumentSaved event is for when the user does a ‘Save’. If the document is new, when they click the save button, what Revit is actually doing in the background is a ‘Save As’, which prompts the user for a location and filename.

So, to get that event included as well you need to do something like this:

   public Result OnStartup(UIControlledApplication application)
        {
            application.ControlledApplication.DocumentSaved += ControlledApplication_DocumentSaved;
            application.ControlledApplication.DocumentSavedAs += ControlledApplication_DocumentSaved;

            return Result.Succeeded;
        }

This is registering the ControlledApplication_DocumentSaved method as a method to call when either of those events are called. To allow your save method to be the same method for each event, you need to set its parameters to be the following:

        void ControlledApplication_DocumentSaved(object sender, Autodesk.Revit.DB.Events.PostDocEventArgs e)
        {
          //my code goes here 
        }

Notice here that we are accepting event arguments of ‘PostDocEventArgs’ as opposed to ‘DocumentSavedAsEventArgs’ or ‘DocumentSavedEventArgs’, as PostDocEventArgs is a base class of these two.

Just something to keep in mind if you plan to use Revit’s powerful events API.

[Revit API]–Document.PathName will be empty when unsaved or detached from central

2011-02-02T12:10:00.002+10:00

This may seem a bit obvious but I thought I’d post it up anyway. If you are planning on relying on Document.PathName to show you where the current Revit file is located (for instance, if you are making an export tool that puts the file in the same location as the .rvt file), keep in mind that if the user has just created a new file, this value will be empty. The same also goes for Document.Title.
Perhaps a bit more trickier is that these values will also be empty if the user opens a central file and selects ‘detach from central’

If the user runs your tool before manually saving it somewhere, they will not have a PathName or Title. If your application relies on this value make sure you check it for null and have a contingency plan, such as asking the user to save the file first, or prompting them for a location.

[Revit API]–A couple more Revit API Blogs to follow

2010-11-18T10:44:00.003+10:00

Just a quick note to let you know about a couple of blogs I’ve recently discovered that have a large amount of Revit API content.
First off, check out ‘Daren@Work’ which is the blog of Daren Thomas, creator of RevitPythonShell.

Secondly, Don Rudder has a blog ‘Revit .NET Development’. Don wrote the Revit API chapter in Mastering Autodesk Revit Architecture 2011 which I recently purchased a copy of. He is also presenting at this years AU.

I’ve added these two sites to the index for RevitAPISearch.com, so their content will be easily searchable along with the other Revit API blogs and forums that I’ve got listed there.

If anyone else is writing a Revit API blog and would like to be included in the links on the right hand side of this page, and in the Revit API Search engine, please let me know.

[Revit API] Autodesk University 2010–Introduction to the Revit API

2010-09-01T23:00:00.001+10:00

The Autodesk University class listings for both physical and virtual classes are now available on the AU website. Head over there and take a look, there are lots of great looking classes. It is also available in a handy spread sheet format.

This year they have tried to mix things up by changing the class selection a little bit, instead of having the same speakers present the same classes (even though they have been doing a great job of it) they have decided to try and get some fresh new content. Whilst new content is great, there are some classic ‘must have’ classes, and for those they have tried wherever they can to give a new speaker a chance to present on those to get a different perspective.

One such ‘must have’ class is the ‘Introduction to the Revit API’ class, which as a part of the changeup, I have the privilege of presenting. I have a high standard to live up to, as in previous years Danny Polkinhorn has done a stellar job of presenting this class, and helping many people to take their first steps in Revit API development (including me!).

The class description is this:

From Hello World and beyond, this class will take you through the steps of creating a Revit add-in from scratch and registering it to run inside Revit using the Revit application programming interface. You will learn how to get input from the user, access their currently selected elements, and read and write to and from the project database. Learn how the RevitLookup tool can help you to get familiar with the Revit file structure and debug your application, and learn how filters can help you speed up your database searches. With a little Microsoft® .NET programming knowledge, you can create great add-ins for Revit. This class shows you the basics that you can then build on. Some .NET programming (C# or Visual Basic®) experience is recommended.

It is a 60 minute lecture, on the first day of AU in November.

I would love to hear from anyone who is attending this class as to anything they would like to see included that isn’t listed in the description above, its not a huge timeslot so I won’t be going into great detail (there is a great range of Revit API classes this year that will cover more in depth topics), but I would like to hear from people who have maybe just started learning the API as to what certain things you found difficult or what gotchas you had so I can make sure I touch on those.

From my talks with people locally who have been trying to learn the API the first challenge is that of learning C# (or VB.NET), as a result I have been contemplating doing a sort of ‘C# for Revit Users’ webcast/blog post series in the lead up to AU. Stay tuned for information on that.

[Revit API] Document.PrintManager returns a new instance every time

2010-07-04T22:06:00.002+10:00

A gotcha that you may run into if you use the Print API in Revit is that the PrintManager property of a Document always returns a NEW PrintManager.
So if you make a change (say to the print range) of Document.PrintManager directly, it will be pointless.

Document.PrintManager.PrintRange = PrintRange.Select;
//then submit print
Document.PrintManager.SubmitPrint(view);

both will act on a NEW PrintManager each time, which isn’t what you want. What you need to do is maintain a reference to PrintManager yourself, only calling Document.PrintManager once.

PrintManager manager = Document.PrintManager;
manager.PrintRange = PrintRange.Select;
manager.SubmitPrint(view);

If you have a look using Red Gate’s .NET Reflector to disassemble that method in the RevitAPI.dll, you can see why:

public unsafe PrintManager get_PrintManager()
{
    PrintManager manager;
    REVIT_MAINTAIN_STATE revit_maintain_state;
    REVIT_MAINTAIN_STATE.{ctor}(&revit_maintain_state);
    try
    {
        manager = new PrintManager(this);
    }
    fault
    {
        ___CxxCallUnwindDtor(REVIT_MAINTAIN_STATE.{dtor}, (void*) &revit_maintain_state);
    }
    REVIT_MAINTAIN_STATE.{dtor}(&revit_maintain_state);
    return manager;
}

As convenient as only passing around the Document object is, it’s not going to work! Changes made to one instance are not likely to apply to any others.

[Revit API] Dynamic Model Update in the 2011 API

2010-06-02T21:54:00.001+10:00

After completing the larger than normal task of converting my suite of Revit add-ins over to the new 2011 API, I’ve recently had the chance to sit down and start having a good play with the new features.

One feature which I have been particularly excited about is the new Element Level Events, also known as Dynamic Model Update. Basically, this lets you attach an event to a particular type of element, and when that element is changed, your code gets called, and can do various things. This is a feature which the team has clearly put a lot of thought into, and it opens Revit up to a whole new level of automation. Page 283 of the developers guide has a good introduction to this, and the example they use is changing all new walls to a certain type.

My first idea for using this tool is to solve a problem that some of the drafters at the company I work for have been complaining about, which is detail lines in Revit. When they want to insert a detail line they hit the keyboard shortcut, and select from a long list of different line styles, then draw the line. If they are doing lots of lines, they will scroll through that list many times – which is annoying. My idea was that they could tell my add-in what line style they want to insert, and then just draw detail lines without scrolling through the list each time.

The process would be this:

User runs the tool which registers an updater, and sets the line style.
When a new line is entered, that updater will be triggered
The updater will then convert the newly inserted line to the line style selected.

It was actually quite easy to get this working, which is a testament to how well this API is written.

First you need to create a class that implements IUpdater. Mine was called DetailLineUpdater. You then need to implement each of the members of that interface. These include:

Execute(UpdaterData data) – this is the actual method thats called when the updater is triggered, here is where I would change my line style.
GetAdditionalInformation() – just returns a description
GetChangePriority() – tells Revit the nature of what you will be doing in the Execute method. Revit uses this to determine in which order it should run each of the updaters.
GetUpdaterId() – returns an ID for the updater, which includes the AddInId and a GUID
GetUpdaterName() – a name for your updater. Make this something meaningful as it may get displayed to the user.

As you can see, these have some similarities to the kinds of things you need to tell Revit about your external commands.

Once you have your updater class, you need to do two things:

Register it, using the UpdaterRegistry.RegisterUpdater(updater) method.
Tell Revit when to trigger it.

For the second point, you need to use the UpdaterRegistry.AddTrigger method, which accepts three parameters.

The id of the Updater
A filter, which tells Revit which elements to attach to.
A change type. This defines what actions on the filtered elements will trigger your updater. This could be insertion, deletion, parameter changes or geometry changes.

For my tool, I got the change type by using Element.GetChangeTypeElementAddition().

So now I have some code that will be run, whenever a certain type of element (in my case, elements with the category OST_Lines) is added. Here is a snapshot of the registration code:

DetailLineUpdater updater = new DetailLineUpdater(commandData.Application.ActiveAddInId);
                UpdaterRegistry.RegisterUpdater(updater);
                ElementCategoryFilter filter = new ElementCategoryFilter(BuiltInCategory.OST_Lines);
                UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), filter,Element.GetChangeTypeElementAddition());

Most of the IUpdater methods are trivial, but here is my Execute method:

        public void Execute(UpdaterData data)
        {
            foreach (ElementId addedElement in data.GetAddedElementIds())
            {
                DetailLine line = data.GetDocument().get_Element(addedElement) as DetailLine;

                foreach (Element style in line.LineStyles)
                {
                    if (style.Name.Equals("A_Certain_line_style"))
                        line.LineStyle = style;

                }
            }
            
        }

As you can see, its all fairly simple, and works well! However, there is a catch.

Once you use an updater on a model, it permanently stains it.

What do I mean by stain? It leaves a mark. Its not a huge deal, and doesn’t affect the model, but from a software developers point of view, its not ideal. If you run a tool, such as my line styling tool, and then someone else opens your model, or even links it into their project, they get a warning saying “the file … was modified by the third-party updater …… which is not currently installed”.

If you continue to edit the file, data maintained by …. will not be updated properly. This may create problems when … is later opened when …. is present.

The user can easily just click the second option ‘Do not warn about this updater again and continue working with the file’. But I believe every user will have to do this (have not confirmed this though, would love to hear if this is not the case), and I’d imagine, if you send your model to other firms to link in, they will all get it. This is not a good user experience, and would scare or confuse some users.

The intentions behind the warning are good, the Revit team obviously doesn’t want problems seen in AutoCAD where third party add-ins are so intertwined with projects that they cause a troubleshooting nightmare. But for simple time saving add-ins like my line styling tool, this is inconvenient. I’d love for there to be an option where developers can say that honestly if the updater is removed it will not cause any problems, and then that error will not show, hopefully next release!

All in all, this addition is great, and makes a range of great new add-ins to be made, but when your tool is not installed, users get this dialog, which could be confusing. If this doesn’t affect you, then I encourage you to get in there and have a play around, its easier than you’d think it would be, and I’m sure you’ll come up with some great ideas of how you could utilize it.

Revit: 2010 API Developer Guide

2009-04-27T14:09:00.001+10:00

I stumbled across this document today whilst setting up my SDK Samples menus in Revit.

It’s located in the Revit 2010 SDK folder (there’s an extractable on the Revit disc to get this folder) and spotted the ‘Revit 2010 API Developer Guide’.

It’s a 315 page PDF with a whole heap of tutorials, code samples and tips for using the Revit API. It’s pretty much the user manual and seems to be exactly where a new Revit API user should start. This document is exactly what I dreamed of when I started developing with the Revit API a couple of years ago!

The section headings include:

Getting Started
Add-in Integration
Application and Document
Elements Essentials
Parameters
Collections
Editing Elements
Walls, Floors, Roofs and Openings
Family Instances
Family Creation
Datum and Information Elements
Annotation Elements
Sketching
Views
Material
Geometry
Place and Locations
Shared Parameters
Transactions
Events
Revit Architecture
Revit Structure
Revit MEP

If there isn’t anything there that interests you, you obviously aren’t interested in the Revit API. Props to Autodesk for putting this together!

Revit: How to print sheets in order.

2009-03-23T17:08:00.002+10:00

I’ve had a bit of fun lately working with the Revit 2009/2010 API for printing views. There is a useful SDK sample, ‘ViewPrinter’ which shows you how to replicate the print menu in revit, but using the API.

I’ve created a customized version of this that links in with our companies document management systems, and does things like prints, renames, and copies PDFs to the correct directory all with the press of a button.

This has been working well for our drafters, and has sped things up, however there have been a few issues that I’ve run into whilst following the methods set out in ViewPrinter and in the SDK documentation. Most of them relate to selecting certain views (in this case, sheets) and printing them in the correct order, and with the correct amount of copies.

The way the SDK sample does this, is it gathers a list of the sheet names the user selected, compares their names with those in the PrintMan.ViewSheetSetting.AvailableViews list and selects ones that match. It then adds these into a ViewSet, and supplies that to PrintMan and calls SubmitPrint().

        1: //create Viewset store those you need to print

       2: ViewSet viewsToPrint = new ViewSet();

       3:  

       4: //Compare your list of sheets, to those in AvailableViews

       5: foreach (string name in selectedSheetNames) 

       6: {

       7:     foreach (View view in _printMan.ViewSheetSetting.AvailableViews)

       8:      {

       9:         if (view.ViewType == ViewType.DrawingSheet)

        {

            //cast to viewsheet

            ViewSheet vs = view as ViewSheet;

  

            if (vs != null && name.Contains(vs.SheetNumber + " - " + vs.Name))

            {

                viewsToPrint.Insert(vs);

            }

        }

     }

}

  

ViewSheetSet viewSheetSet = m_viewSheetSetting.CurrentViewSheetSet;

viewSheetSet.Views = selectedViews;

m_viewSheetSetting.Save();

  

//set copies

_printMan.CopyNumber = numCopies;

  

//submit print

_printMan.SubmitPrint(v); 

  



This works great ok normally, however there is a significant problem. The problem lies in how the views are stored. The views are placed into a ViewSet, which is an implementation of the Set collection type, ie, an unordered set of items. Unfortunately, this means that us coders have no say in how the prints get ordered.

My experimentation shows that revit seems to order them by ElementID, or, in the order they were created. So lets say you create Sheet 1, Sheet 2, Sheet 4, Sheet 3, in that order. That is exactly how they will come out of the printer, even though the user would assume otherwise.

My workaround for this, after much trial and error, is this:

       1: //create a list of view tp store those you need to print

       2: List<View> viewsToPrint = new List<View>();

       3:  

       4: //Compare your list of sheets, to those in AvailableViews

       5: foreach (string name in selectedSheetNames) 

       6: {

       7:     foreach (View view in _printMan.ViewSheetSetting.AvailableViews)

       8:      {

       9:         if (view.ViewType == ViewType.DrawingSheet)

        {

            //cast to viewsheet

            ViewSheet vs = view as ViewSheet;

  

            if (vs != null && name.Contains(vs.SheetNumber + " - " + vs.Name))

            {

                viewsToPrint.Add(vs);

            }

        }

     }

}

//loop through copies 

for (int i = 1; i <= numCopies; i++) 

{ 

 //loop through each view 

 foreach (View v in viewsToPrint) 

 { 

  //submit print of just 1 view 

   _printMan.SubmitPrint(v); 

  } 

}

There are a number of steps behind the scenes (such as setting up _printMan aka my PrintManager to have the correct settings) but instead of supplying PrintManager with a ViewSet of views I want to print, and changing the CopyNumber to how many times I wish to print them, I’m printing one view at a time using the overload for SubmitPrint. This allows me to order my list of selectedSheetNames in the way I wish it to come out, including sorting and reversing it. I’ve also done a for loop to replicate the CopyNumber property.

Now, at long last, my prints are coming out in the correct order!

Note: This code was created for Revit 2010, not fully tested in 2009, though most of it should work the same.

Revit 2010 - More feedback on external commands errors

2009-03-11T14:06:00.006+10:00

While Matt Mason has been blogging away furiously at the Revit 2010 platform/API enhancements, I've got a smaller feature to talk about.

If you're anything like me, you would have run into the situation where you create an external command, link it up in the ini file, and go to run it.. and get nothing, no error, no warnings, just nothing. While the journal file can sometimes offer a little bit of assistance, you really have very little to go on.

This has changed in 2010, with increased reporting of errors in API commands. One I noticed today is that if you link to a DLL file in the revit.ini that doesn't exist, you will get a popup warning alerting you that your dll doesn't exist and thus the command has been disabled. This is great, as often typos are made in the revit.ini, and this points you straight to it.

Another one is that when an unhandled exception occurs, a friendlier dialog box is now shown, alerting the user to the error, and allows them to view technical detail if they wish. Previously it was a standard .net dialog box which didn't mean much to the end user.

It's the little things that count, and this little thing is a worthy inclusion in Revit 2010!

Parameter.Set - Unexpected Behaviour

2009-02-23T15:59:00.002+10:00

This is something I ran into today working on a Revit API External Command. The program I was trying to make, involves changing the 'Mark' parameter on beams/columns. I was using the Parameter.Set(string) boolean, which returns true if the parameter was set successfully to the new value, otherwise false. I decided to use the T/F value to determine if it had been successful or not, before incrementing a certain value. It turns out however, that the Set method only returns True if it has been set to a new value. So if you assign the same value that was already in the mark, it returns false! So my program was thinking that the method had failed, when really, it just had set the same value as was already there. So keep in mind that if you are going to use the T/F value of this method, make sure you also compare the value which you are setting, with the current value of the parameter.