The Building Coder

Product Support Subscription Videos

I mentioned the Revit 2010 Subscription Pack last week, and Matt Mason highlighted the model review add-in included with it and its little API, which is just one example of all the good stuff in there. Autodesk Product Support has now published a series of  'deeper dive' subscription pack videos which cover the subscription pack features and functionality and provide you with a deeper understanding of their use as well as anticipating and answering potential questions.

Model Review

We recently mentioned the subscription pack for Revit 2010. In addition to the product update itself, the subscription page for Autodesk Revit Architecture 2010 includes some new applications to complement Revit workflows to:

• Validate the accuracy of building information models against pre-determined standards.
• Import and export data between a Revit project and an external database.
• Facilitate the creation of 3D models from 2D digital photographs.

These areas are obviously of great interest for developers as well. The first of these points is addressed by the model review plug-in, which includes a small API for developers or customers to hook into to specify their own rules and standards to be checked. Matt Mason of Avatech Solutions, who is one of the original Model Review developers, now kindly wrote a summary of its functionality:

Introduction

Autodesk Revit^® Model Review is a new add-in product available to Autodesk subscription customers via the Revit 2010 Subscription Advantage Pack. Model Review provides the capability to configure and run checks against Revit projects or families and provide a report of whether the checks have passed or failed. Model Review provides 35 different kinds of checks, within the areas of:

• Modelling for Energy Analysis
• Revit Family consistency and standards
• Firm or Project-based Revit Standards
• GSA Spatial Program Validation

Here is a sample screen snapshot:

The Checking Platform

Model Review is not just a configurable set of checks provided by Autodesk – it is also a platform for developers to write their own checks and plug them in to the checking process. This could be desirable if BIM administrators want to check for issues which are not possible to check with the "out-of-the-box" Model Review checks, either because the check has not yet been implemented, or because it is too specialized to ever exist in the base product.

Creating a plug-in enables a developer who understands the Revit API to write a simple extension which leverages the Model Review platform for configuring, running, and reporting check results. These "plug-in" checks can be added to built-in checks to create the complete set of checks required by a particular firm or project.

Developers implement a few methods defining how the check should be configured, executed, reported – and optionally corrected. The check is then made available and can be run by Revit users as any other check in Model Review.

For your convenience, here is a direct link to a copy of the plug-in developer guide.

An Example

For example, one firm inquired about checking for whether a door’s Fire Rating was less than its host wall’s Fire Rating. This was made even more challenging because the Fire Rating field is text-based rather than a number, so the value might contain a string like "2 hours" instead of just numbers. Still, it is a fairly simple function to write within C# or VB.NET and the Revit API. A variation of this check is provided as a sample in the Model Review installation folder along with the developer guide.

Note: While Model Review is available for either Revit 2009 or 2010 products, the plug-in capability is only available in the 2010 version.

Adding a Column to RDBLink Export

Probably the most complex Revit SDK sample of all is the RDBLink one. We mentioned it briefly in Anthony Hauck's note on integration with a database or ERP system, but provided no additional details. Like all the SDK samples, RDBLink comes with its own readme document, which is actually a lot more extensive than most others due to the size and complexity of this sample. In brief, RDBLink demonstrates how to export Revit model data into an ODBC database and how to import data back from a database into Revit, possibly modifying or creating new Revit elements. Here is a simple question on that topic, answered by my colleague Joe Ye:

Question: I am using RDBLink to export Revit data to a database. I would like to add a few custom columns to the generated tables. How can I do that?

Also, when I dump the data, it overwrites all the previous data. Can I append data to existing tables?

Answer: First the short answer to your second question:

Unfortunately, RDBLink cannot append to existing tables. It always synchronises the Revit document with the exported database.

It is however possible to add custom columns to the exported database. Which table do you want to add columns to? Would you please tell me the table name?

Question: I would like to add a column "Facility Id" to the tables:

• CurtainSystems
• DistributionSystems
• DuctSystems
• FurnitureSystems
• PipingSystems
• [dbo].[ElectricalEquipment]

Answer: To add the columns you require, you can add shared parameters to the respective elements. Then RDBLink will automatically generate new columns populated by the values of these shared parameters. The readme file ReadMe_RDBLink.rtf provides more information on this:

Create shared parameters: In the database editing form, user can add shared parameters to current document, and after that new fields in the related tables for the elements will be created, user can give values to these new fields. After importing, these new parameters will be updated.

Question: I am quite new to this. Can you please give me some more details? Is there some other documentation available for it?

Answer: I just tested adding a shared parameter named 'test' to all doors in a project document and then called the RDBLink external command to export the model data to an access database file. The database contains a new column 'test' generated by this shared parameter, and populates it with the shared parameter values. Here is the parameter that I added to the Revit BIM:

Here is the exported data displayed in the database table:

The shared parameter can be created using the Revit user interface. The command is described in the Revit product help file HelpArchitectureENU.chm in the Program subfolder, where you can find it through Revit Architecture 2010 User's Guide > Customizing Project Settings > Custom Parameters.

Thank you, Joe, for these answers!

Shared parameters can also be created programmatically, and here are some pointers to previous posts on related topics:

• Adding a shared parameter to a DWG file.
• Adding a shared parameter to a family.
• Adding a shared parameter to almost any BIM element, including a model group.
• Deleting a shared parameter.
• Shared parameter visibility.

Dismiss Dialogue using Windows API

I am often confronted with unwanted dialogues popping up when I am trying to drive some application programmatically. In Revit, many dialogues raise an event when they are displayed and allow us to implement an add-in application to handle them automatically. Unfortunately, as noted in the discussion on using the DialogBoxShowing event, some of the Revit dialogues do not raise such an event when displayed, so we cannot use the standard Revit API to handle or dismiss them.

Also, there are many other applications besides Revit that I am trying to drive programmatically, and they often do not provide any API at all, let alone a possibility to disable or automatically handle any of their user interface message boxes.

Furthermore, there may be situations within Revit where the DialogBoxShowing event is raised and the dialogue can be handled, but this causes problems within Revit. For instance, one developer reports that the DialogBoxShowing event handler crashes when trying to hide the dialog using an override result after the dialogue has been triggered due to closing a transaction using EndTransaction. In that case, Revit says that the document was modified outside the transaction and generates an exception.

Question: What can I do to automatically handle or dismiss dialogues in these situations?

Answer: As said, most Revit messages can be caught and responded to programmatically by a plug-in application by handling the Revit dialogue box DialogBoxShowing event, and source code and a description for exploring this kind of situation is provided in the discussion mentioned above.

The easiest way to find out whether you can use this event to handle your specific dialogue is to:

• Implement and install the dialogue box handler.
• Set a breakpoint in the event handler.
• Reproduce the situation in which the dialogue is displayed by Revit.
• Check whether the event was fired or not.

Inside the event handler, the debugger will show you what data is being passed in and thus how you can identify this dialogue in your code for automatic processing.

On the other hand, if the specific dialogue you are confronted with is not accessible in the Revit call-back, or you are dealing with some completely different application lacking the DialogBoxShowing event, I will explain below how you can use the .NET framework in C# and VB or the native Windows API to handle it automatically instead. In short:

• In the .NET framework, you can use methods from the WinApi.User32 namespace like FindWindow, EnumWindows, and GetWindowText from inside a System.Timers.Timer instance to determine that a certain window is being displayed by the Windows OS and close it using WinApi.User32.SendMessage.
• In the native Windows API, similar functionality can be achieved by creating a hook in the main Revit window with SetWindowsHookEx and sending a WM_CLOSE or some other message to a dialogue when it is displayed.

.NET Dialogue Clicker in C#

Here is the C# source code and entire Visual Studio solution for a little utility named JtClicker that I have used many times in the past and is very near and dear to me. It was especially useful during my time in Autodesk Consulting, when we were always automating a large number of different applications which unfortunately were equipped with user interfaces as well as APIs. The user interfaces would often insist on popping up various irritating dialogue boxes which could not be suppressed programmatically.

The solution that I developed for this is a Windows API based stand-alone command-line utility that simply sits and waits for a dialogue with certain characteristics to appear. If and when such a dialogue is displayed, the utility immediately dismisses it in a certain predefined way.

This solution I implemented is thus a generic dialogue clicker in C# using the .NET framework to access the underlying Windows API. In fact, it has nothing at all to do with the Revit API.

Since every dialogue is different, we need a lot of flexibility in the details of identifying and handling various specific dialogues. The two main requirements for a high degree of flexibility are:

• How to identify that the dialogue we are interested in has been displayed.
• How the dialogue should be dismissed, once it has been identified.

Therefore, this utility will always require some tweaking before use and is only useful in source code format for that reason. Check out the source code and the following discussion I had on that topic with my colleague Greg Wesner of Autodesk Consulting for details:

.NET Dialogue Clicker in VB

I was prompted to dive into this subject again recently by Greg Wesner of Autodesk Consulting. Here is an example of my interaction with him when he made use of JtClicker, in which Greg also provides a VB version of the original C# implementation:

[Q] I heard you might have a sample of code for how to 'spoof' a click of the OK button in a windows dialog. Specifically, I need to launch the options dialog in AutoCAD and then close it immediately with an OK click, i.e. I cannot cancel it. Closing the dialog with OK results in AutoCAD refreshing all the paths. Launching is obviously no problem but the OK click is tougher. I'm working in VB.NET, so a .NET sample is really what I'm after.

[A] Yes, I am appending my little dialogue clicker to this mail. There are comments inside form1 explaining its function and usage. It searches for a dialogue using certain characteristics. Once the dialogue appears, it sends windows messages to it in EnumChildProc. You will need to tweak those messages to hit the button you need.

[Q] Thanks Jeremy. That was exactly what I needed. Hooked it all up and it is working great.

[A] Very glad to hear that it works for you! Have you changed or improved anything in it? If so, could you show me what you fixed or improved?

[Q] Well, I wish I could say that I improved on it, but you pretty much had all the parts I needed. I was actually able to 'dumb' it down some because I could hard code the dialog name "Options" and the button "OK". I also tested that "Options" and "OK" would dismiss the Options dialog in AutoCAD as expected with the original project files you sent.

I was hoping that I wouldn't need to use the timer and would be able to just make the call straight to EnumWindows. But that didn't work because the Options dialog doesn't actually come up until my function returns. So I had to use the timer as well to delay the call to EnumWindows. I found dropping the interval to 300ms was better though, because you barely see the dialog come up. I call Timer.Stop() as soon as I find the button I'm looking for, because I will only need it to happen once every time the dialog comes up. I am thinking about adding some defensive code that counts how many times we call EnumWindows in the Timer, and if we go above a certain number of times (maybe 500), we stop trying. That way if anything happens and the Options dialog never comes up, we don't chew up CPU cycles forever.

One thing I did do was translate WinApi.vb and the EnumWindowsProc() and EnumChildProc() methods to VB. So I could pass that on to you in case you get requests for this in VB. First, here is the module WinApi.vb providing access to the Windows API calls:

Imports System
Imports System.Runtime.InteropServices
Imports System.Text
 
Module User32
  Delegate Function EnumWindowsProc(ByVal hWnd As Integer, ByVal lParam As Integer) As Boolean

  <DllImport("user32.dll", CharSet:=CharSet.Unicode)> _
  Function FindWindow(ByVal className As String, ByVal windowName As String) As Integer
  End Function

  <DllImport("user32.dll", CharSet:=CharSet.Unicode)> _
  Function EnumWindows(ByVal callbackFunc As EnumWindowsProc, ByVal lParam As Integer) As Integer
  End Function

  <DllImport("user32.dll", CharSet:=CharSet.Unicode)> _
  Function EnumChildWindows(ByVal hwnd As Integer, ByVal callbackFunc As EnumWindowsProc, ByVal lParam As Integer) As Integer
  End Function

  <DllImport("user32.dll", CharSet:=CharSet.Unicode)> _
  Function GetWindowText(ByVal hwnd As Integer, ByVal buff As StringBuilder, ByVal maxCount As Integer) As Integer
  End Function

  <DllImport("user32.dll", CharSet:=CharSet.Unicode)> _
  Function GetLastActivePopup(ByVal hwnd As Integer) As Integer
  End Function

  <DllImport("user32.dll", CharSet:=CharSet.Unicode)> _
  Function SendMessage(ByVal hwnd As Integer, ByVal Msg As Integer, ByVal wParam As Integer, ByVal lParam As Integer) As Integer
  End Function

  Public BM_SETSTATE As Integer = 243
  Public WM_LBUTTONDOWN As Integer = 513
  Public WM_LBUTTONUP As Integer = 514
End Module

Here is the main application:

Private timer1 As Timer
Private timer_interval As Integer = 300  ' in milliseconds so 1000 = 1 second
Private timer_attempts As Integer

Public Function EnumWindowsProc(ByVal hwnd As Integer, ByVal lParam As Integer) As Boolean
  Dim sbTitle As New StringBuilder(256)
  Dim test As Integer = User32.GetWindowText(hwnd, sbTitle, sbTitle.Capacity)
  Dim title As String = sbTitle.ToString()
  If title.Length = 0 Then
    Return True
  End If
  If title = "Options" Then
  Else
    Return True
  End If
  User32.EnumChildWindows(hwnd, New User32.EnumWindowsProc(AddressOf EnumChildProc), 0)
  Return False
End Function

Public Function EnumChildProc(ByVal hwnd As Integer, ByVal lParam As Integer) As Boolean
  Dim sbTitle As New StringBuilder(256)
  User32.GetWindowText(hwnd, sbTitle, sbTitle.Capacity)
  Dim title As String = sbTitle.ToString()
  If title.Length = 0 Then
    Return True
  End If
  If title = "OK" Then
  Else
    Return True
  End If
  User32.SendMessage(hwnd, User32.BM_SETSTATE, 1, 0)
  User32.SendMessage(hwnd, User32.WM_LBUTTONDOWN, 0, 0)
  User32.SendMessage(hwnd, User32.WM_LBUTTONUP, 0, 0)
  User32.SendMessage(hwnd, User32.BM_SETSTATE, 1, 0)
  timer1.Stop()
  timer1 = Nothing
  Return False
End Function

Public Sub timer1_Tick(ByVal sender As Object, ByVal e As EventArgs)
  'timer_attempts is a failsafe to make sure that if for some reason the Options dialog
  ' never comes up, we don't keep looking for it forever. We usually find the dialog on the
  ' first few tries, so if it doesn't come up in about the first minute, we give up
  If timer_attempts < 300 Then
    User32.EnumWindows(New User32.EnumWindowsProc(AddressOf EnumWindowsProc), 0)
  Else
    timer1.Stop()
  End If
  timer_attempts += 1
  Debug.Print(timer_attempts.ToString())
End Sub

' The options dialog will not come up until our function returns, so we setup a timer
' that will check every 300 milliseconds to see if it can find the dialog. Once it finds
' the dialog and clicks OK, it stops.
Public Sub closeOptionsDialog()
  timer_attempts = 0
  If timer1 Is Nothing Then
    timer1 = New Timer()
  End If
  timer1.Interval = timer_interval
  AddHandler timer1.Tick, New EventHandler(AddressOf timer1_Tick)
  timer1.Start()
End Sub

If the source code lines are truncated by your browser, you can copy and paste the text to a text editor.

Using a native Windows API Hook

The JtClicker dialogue clicker application described above is using the .NET framework to identify the dialogue and send messages to dismiss it. Since the Win32 portion of the .NET framework is just a wrapper around native Windows API calls, the same functionality can also be implemented more directly using the native API.

Here is a report on using a Windows hook to dismiss a dialogue triggered by closing a Revit transaction.

I investigated using a hook, and this is the solution :-) I created a hook in the main Revit window with SetWindowsHookEx and send messages to the dialogue when it is detected. Initially I sent a WM_CLOSE message to close it, later I changed it to click the OK button instead. This works really well, even if the dialog is shown when ending a transaction, in which case the DialogBoxShowing event generates an exception if I try to hide the dialog with OverrideResult.

My hook function is:

private static void ProcessWindow(
  IntPtr hwnd )
{
  if (App.OcultarMensajesRevit)
  {
    // Buscamos el botón de aceptar y lo pulsamos.
    int ID_OK = 1;
    IntPtr hwndOk = Win32.Functions.GetDlgItem(
      hwnd, ID_OK );

    if (hwndOk != IntPtr.Zero)
    {
      Win32.Functions.SendMessage(
        hwndOk, (uint)Win32.Messages.WM_LBUTTONDOWN, 
        (int)Win32.KeyStates.MK_LBUTTON, 0 );

      Win32.Functions.SendMessage(
        hwndOk, (uint)Win32.Messages.WM_LBUTTONUP, 
        (int)Win32.KeyStates.MK_LBUTTON, 0 );
    }
    //Win32.Functions.SendMessage(
    //  hwnd, (uint)Win32.Messages.WM_CLOSE, 0, 0 );
  }
}

App.OcultarMensajesRevit is a variable I created to enable dialogue auto closing. Instead of sending a WM_CLOSE message to the window to cancel it, I observed I needed to push the OK button for all things to work, so I search for that button and send it a button down and a button up message to simulate a mouse click.

To connect the hook function, I used the WindowInterceptor class I found at CodeProject.

Then I add the following in the Startup event of my application:

Process process = Process.GetCurrentProcess();

IntPtr hwnd = process.MainWindowHandle;

App._windowsInterceptor = new WindowInterceptor(
  hwnd, ProcessWindow );

To clean up at the end, I add the following on shutdown:

App._windowsInterceptor.Stop();

Revit Install Location

Quite a while back, we discussed the Revit install path and product GUIDs. Last week, Jim Bish of Inlet Technology wrote me a nice message making use of that and including VB code demonstrating how to use the install path and also how to determine the product GUID from the registry without having to manually type it in or copy and paste it from a table.

Jim says: It has always been my policy to give back to others as they have given to me. Here are two functions that will retrieve the ProductCode and subsequently, the InstallLocation of Revit Structure 2010. It can be modified for any install of Revit, and is primarily used to get a path to the revit.ini file for Appends, and Repairs, and Uninstalls of my External Commands and External Applications.

Public Function GetRevitProductCode()

  Dim key As String _
    = "SOFTWARE\Autodesk\Revit\Autodesk Revit Structure 2010"

  Using rgk1 As RegistryKey _
    = Registry.LocalMachine.OpenSubKey(key)

    For Each sSubkeyName As String In _
      rgk1.GetSubKeyNames()

      Using rgk2 As RegistryKey _
        = rgk1.OpenSubKey(sSubkeyName)

        Try
          Return rgk2.GetValue("ProductCode")
        Catch generatedExceptionName As Exception
          Console.WriteLine("Error Occured")
        End Try

      End Using
    Next
  End Using
End Function

Public Function GetRevitInstallLocation( _
  ByVal sProdCode As String)

  Dim key As String _
    = "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"

  Using rgk1 As RegistryKey _
    = Registry.LocalMachine.OpenSubKey(key)

    Using rgk2 As RegistryKey _
      = rgk1.OpenSubKey(sProdCode)

      Try
        Return rgk2.GetValue("InstallLocation")
      Catch generatedExceptionName As Exception
        Console.WriteLine("Error Occured")
      End Try

    End Using
  End Using
End Function

I used these two functions as a basis for implementing a new Building Coder sample command CmdInstallLocation to ensure that this useful functionality is easily found and available. It determines and lists the product code and the install location for the currently executing Revit application and also tries to do so for all three flavours, Architecture, MEP and Structure. On my system, the result of running it looks like this:

I factored out various useful bits of functionality from Jim's code as follows:

Define the Revit product and Windows uninstall registry paths:

const string _reg_path_uninstall
  = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall";
 
const string _reg_path_for_flavour
  = @"SOFTWARE\Autodesk\Revit\Autodesk Revit {0} 2010";

Note that the registry path for the Revit product is actually a format string which still needs to be populated with the Revit product flavour. The correct string to specify the flavour can be obtained directly from the ProductType enumeration. We use it in the following function which returns the final Revit product registry path:

string RegPathForFlavour( ProductType flavour )
{
  return string.Format( _reg_path_for_flavour, flavour );
}

We also need methods to extract data from the registry. In one case, we use the Revit product registry path to determine the product key, which is located in the value named ProductCode in the subkey named Components. In the other case, we determine the Revit install location from the value named InstallLocation in the subkey specified by the product code in the Windows uninstall key. Both of these values' data type is string. Due to these two similar access paths, I can implement one single function to read the data:

string GetSubkeyValue(
  string reg_path_key,
  string subkey_name,
  string value_name )
{
  using( RegistryKey key
    = Registry.LocalMachine.OpenSubKey( reg_path_key ) )
  {
    using( RegistryKey subkey
      = key.OpenSubKey( subkey_name ) )
    {
      return subkey.GetValue( value_name ) as string;
    }
  }
}

Defined like this, making use of the method for the two cases described above is extremely simple:

string GetRevitProductCode( string reg_path_product )
{
  return GetSubkeyValue( reg_path_product,
    "Components", "ProductCode" );
}
 
string GetRevitInstallLocation( string product_code )
{
  return GetSubkeyValue( _reg_path_uninstall,
    product_code, "InstallLocation" );
}

We define a little helper method to format the data obtained for presentation in the message box:

string FormatData(
  string description,
  string version_name,
  string product_code,
  string install_location )
{
  return string.Format
    ( "{0}: {1}"
    + "\nProduct code: {2}"
    + "\nInstall location: {3}",
    description,
    version_name,
    product_code,
    install_location );
}

Finally we can put it all together into the mainline code of our external command's Execute function. First, we look at the currently executing Revit application. The application Product property provides the ProductType, which can be used to obtain the registry path for this flavour of Revit, determine its product code and from that the install location. Next we loop through all three ProductType enumeration values and check for other installed flavours of Revit as well. The final result is displayed in the message box shown above:

Application app = commandData.Application;
 
string reg_path_product
  = RegPathForFlavour( app.Product );
 
string product_code
  = GetRevitProductCode( reg_path_product );
 
string install_location
  = GetRevitInstallLocation( product_code );
 
string msg = FormatData(
  "Running application",
  app.VersionName,
  product_code,
  install_location );
 
foreach( ProductType p in
  Enum.GetValues( typeof( ProductType ) ) )
{
  try
  {
    reg_path_product = RegPathForFlavour( p );
 
    product_code = GetRevitProductCode(
      reg_path_product );
 
    install_location = GetRevitInstallLocation(
      product_code );
 
    msg += FormatData(
      "\n\nInstalled product",
      p.ToString(),
      product_code,
      install_location );
  }
  catch( Exception ex )
  {
  }
}
 
Util.InfoMsg( msg );
 
return CmdResult.Failed;

Here is version 1.1.0.48 of the complete Building Coder sample source code and Visual Studio solution including the new command.

Many thanks to Jim for providing the original VB code snippets and the idea for this post!

Obfuscation Tools

We already explained the need for and basics of obfuscation, and yet developers I meet are often still surprised to discover how easy it is to decompile their .NET application and obtain the original source code back from the released .NET assembly DLL. We can add new information on this topic and present details on some available tools now, because Greg Wesner of Autodesk kindly agreed to share his personal experience and research results using obfuscation with Revit applications:

First of all, here is a list of most of the available obfuscators with some additional background information and further links.

I gave up on Dotfuscator because I was having problems obfuscating things for Revit and their interface was not very good. You have to exclude from obfuscation any methods that external apps call into or access. This would include entry points like IExternalCommand and IExternalApplication methods. Virtually any DLL can be obfuscated to the point where it will not run.

I now use {smartassembly} which is working quite well for me. It’s in the medium price range of the tools out there. It does a fairly good job of drilling into the dependencies itself and determining what can and cannot be obfuscated. Setting up the various options in these tools will make all the difference.

To be honest, what really sold me on {smartassembly} was the fact that their trial software was a fully functional installation of their product. You just can’t ship what you obfuscate until you pay for it. Dotfuscator and another one I tried from Rustemsoft called Skater were both limited versions of their software, so it was very difficult to determine how effective they would be. Skater in particular did not do a very good job of string mangling and the result was barely different from the code. If you are going to provide an evaluation copy, is it really a good idea to limit it to the point that it is unimpressive?

Here are some cool features in {smartassembly} beyond obfuscation:

1. It can merge in dependent DLLs or embed them. Merging them will improve performance, embedding them just makes it more convenient, because your deliverable can be just one file.
2. It will prune code that will never get executed. Actually, I find this to be a nice analysis tool for applications that are developed over long periods of time – I’m amazed at how much code I write that I eventually end up abandoning.
3. It will add confusing metadata to the DLL so that .NET Reflector and MS IL Disassembler cannot view it. This is a huge advantage because now you need hacking tools even to see what methods are exposed, and this provides a level of protection for even those methods that you could not obfuscate.
4. It will sign your assembly with a strong name after obfuscation.
5. It has some memory optimizations that can improve memory usage, which I have not tested.

My approach in setting up my projects was to enable all the security features I could to make it as safe as possible. Then obfuscate the DLL and load and test it. As I mentioned, {smartassembly} does a fairly good job of realizing that some methods are entry points for the DLL and it cannot mangle those signatures. A couple of times I ended up with an obfuscated DLL that would not run. So from there I went back in and began disabling features. I start by excluding whole classes from obfuscation. Once I find the class or classes that cannot be mangled, I try drilling down to see if there are just some particular methods that need to be excluded. This is all I have really needed to do to get it working for me.

I also considered .NET Reactor. The price is really competitive and it has the added feature of creating time bombed versions of your software. But a review I read said it had difficulty with complex applications.

I would have liked more time to evaluate this to determine if it would have worked for me. I highly recommend trying out more than one of these tools before making a decision.

Obviously, these are just unofficial personal opinions, like everything else stated in this blog.

Autodesk Search Beta

We recently mentioned two new online search possibilities, the availability of online help for the Revit product and Rod Howarth's customised global Revit API search. Here is another note in the same vein:

Autodesk Search Beta is now available and provides a number of new capabilities including:

• Type-ahead.
• “Did you mean...”
• Filter by publish date, site source, etc.
• Expanded search scope covering discussion forums, blogs, online product documentation, community sites and the Autodesk channel on YouTube.

Please check it out and provide feedback to help validate and fine tune the technology, and possibly justify using it to replace the current search functionality.

I tested the search with the keywords "newsweep revit" and it returned exactly two hits, i.e. not too few nor too many, both of which were perfectly relevant, i.e. no junk.

Library Paths

Here is a question posted by Edgar on how to modify the application options library paths:

Question: I'm having trouble updating the Revit options for library paths. I'm not sure what I'm missing to update back to the database.

Answer: Since the library paths managed by the LibraryPaths property on the Autodesk.Revit.Options.Application class is a StringStringMap, this question is mostly on how to extract, add and modify data in such a collection.

A StringStringMap is simply a dictionary mapping a set of keys to a corresponding set of values. In this case, both the key and the value data type is string.

To begin with, here is a little utility method to list the contents of a StringStringMap and print out an explanatory header beforehand:

 
void PrintMap( StringStringMap map, string description )
{
  Debug.Print( "\n{0}:\n", description );
 
  StringStringMapIterator it = map.ForwardIterator();
 
  while( it.MoveNext() )
  {
    Debug.Print( "{0} -> {1}", it.Key, it.Current );
  }
}

We use a forward iterator to iterate over the contents, consisting of key-value pairs. The keys and values are printed out one by one. Their data is read from the iterator Key and Current properties, respectively.

To add a new key and value pair to the string map, you can use the Insert method. Modification of an existing value can be accomplished using set_Item.

I implemented a new Building Coder sample external command CmdLibraryPaths to test and demonstrate this. Here is the code of its Execute method:

Application app = commandData.Application;
 
StringStringMap map = app.Options.LibraryPaths;
 
PrintMap( map, "Initial application options library paths" );
 
string key = "ImperialTestCreate";
string value = @"C:\Documents and Settings\All Users\Application Data\Autodesk\RAC 2010\Imperial Library\Detail Components";
 
map.Insert( key, value );
 
PrintMap( map, "After adding 'ImperialTestCreate' key" );
 
map.set_Item( key, @"C:\Temp" );
 
PrintMap( map, "After modifying 'ImperialTestCreate' key" );
 
return CmdResult.Succeeded;

Launching this command will produce the following output in the Visual Studio debug output window:

Initial application options library paths:

Metric Library -> C:\Program Files\Autodesk Revit Architecture 2010\Program\Metric Library
Metric Detail Library -> C:\Program Files\Autodesk Revit Architecture 2010\Program\Metric Library\Detail Components

After adding 'ImperialTestCreate' key:

ImperialTestCreate -> C:\Documents and Settings\All Users\Application Data\Autodesk\RAC 2010\Imperial Library\Detail Components
Metric Library -> C:\Program Files\Autodesk Revit Architecture 2010\Program\Metric Library
Metric Detail Library -> C:\Program Files\Autodesk Revit Architecture 2010\Program\Metric Library\Detail Components

After modifying 'ImperialTestCreate' key:

ImperialTestCreate -> C:\Temp
Metric Library -> C:\Program Files\Autodesk Revit Architecture 2010\Program\Metric Library
Metric Detail Library -> C:\Program Files\Autodesk Revit Architecture 2010\Program\Metric Library\Detail Components

Truncated lines can be seen in full by copy and pasting into an editor.

Once I got this far, I started trying to see the results of my changes in the Revit user interface. The library paths are displayed by clicking on the big R button, the main menu button on the upper left of the Revit application window, and then selecting Options > File Locations > Places...

To my surprise, I saw no changes. I first thought that we added and modified a new key 'ImperialTestCreate' which is ignored by Revit. So I added a modification to one of the pre-existing Revit keys, and set the value of 'Metric Detail Library' to 'C:\Temp' as well. I still saw no changes.

It then dawned upon me that the statement 'map = app.Options.LibraryPaths' copies the current application options library paths into my own private StringStringMap instance stored in my local variable 'map'. All the changes I made are in my own local copy. To have any effect in Revit, I need to write back the changes into the Revit application object data, for instance using a statement such as 'app.Options.LibraryPaths = map'. After doing so, both the updated existing key as well as the new one added by me is displayed as expected in the user interface:

The updated code of the Execute method now looks like this:

Application app = commandData.Application;
 
StringStringMap map = app.Options.LibraryPaths;
 
PrintMap( map, "Initial application options library paths" );
 
string key = "ImperialTestCreate";
string value = @"C:\Documents and Settings\All Users\Application Data\Autodesk\RAC 2010\Imperial Library\Detail Components";
 
map.Insert( key, value );
 
PrintMap( map, "After adding 'ImperialTestCreate' key" );
 
map.set_Item( key, @"C:\Temp" );
 
PrintMap( map, "After modifying 'ImperialTestCreate' key" );
 
map.set_Item( "Metric Detail Library", @"C:\Temp" );
 
PrintMap( map, "After modifying 'Metric Detail Library' key" );
 
app.Options.LibraryPaths = map;
 
return CmdResult.Succeeded;

Here is version 1.1.0.45 of the complete Building Coder sample source code and Visual Studio solution including the new command.

Response: This works perfectly, thank you for the thorough explanation. Also, Thank you for the goodies!

MEP Sample Ribbon Panel

I am preparing our upcoming Revit MEP API webcast to be held on Thursday August 27^th. To register, you can go to the Autodesk Developer Network (ADN) DevTech API training schedule and filter for Revit MEP API.

One thing I did today was to update our MEP sample external application from the Revit 2009 menu-based user interface to a 2010-style custom ribbon panel.

Here is the code for the AddMenu method that was being used in Revit 2009 to create a custom menu:

private static void AddMenu( ControlledApplication app )
{
  const string m = "mep.Cmd"; // namespace and command prefix
  string path = System.Reflection.Assembly.GetExecutingAssembly().Location;
  Autodesk.Revit.MenuItem rootMenu = app.CreateTopMenu( "ME&P API Samples" );
  MenuItem.MenuType mt = MenuItem.MenuType.BasicMenu;
  rootMenu.Append( mt, "&Assign flow to terminals", path, m + "AssignFlowToTerminals" );
  rootMenu.Append( mt, "&Change size", path, m + "ChangeSize" );
  rootMenu.Append( mt, "&Populate CFM per SF on spaces", path, m + "PopulateCfmPerSf" );
  rootMenu.Append( mt, "&Reset demo", path, m + "ResetDemo" );
  rootMenu.Append( MenuItem.MenuType.SeparatorMenu );
  rootMenu.Append( mt, "Electrical &System Browser", path, m + "ElectricalSystemBrowser" );
  rootMenu.Append( mt, "Electrical &Hierarchy", path, m + "ElectricalHierarchy" );
  rootMenu.Append( mt, "Electrical Hierarchy &2", path, m + "ElectricalHierarchy2" );
  rootMenu.Append( mt, "&Unhosted elements", path, m + "UnhostedElements" );
  rootMenu.Append( MenuItem.MenuType.SeparatorMenu );
  rootMenu.Append( mt, "A&bout...", path, m + "About" );
}

To see the overly long lines, you can copy and paste to an editor.

AddMenu is called from the external application OnStartup method.

How can this be easily converted to a ribbon panel?

Well, note a couple of basic things here:

• All the command implementation classes reside in the namespace mep and have the prefix "Cmd". Therefore, the variable 'm' is defined as "mep.Cmd" and used to prefix each command class name stem.
• All commands reside in the same assembly as the external application, so they all have the same assembly path as the currently executing assembly.
• A new top level menu with the text 'MEP API Samples' is created.
• The menu items for the individual commands are added one by one, grouped by separators into HVAC, electrical, and the about groups.

Converting this to a ribbon panel is pretty straightforward. The basics and all possibilities provided by the Revit API for creating your own ribbon panels are demonstrated by the Revit SDK sample Ribbon.

Here is the code for the new AddRibbonPanel method, also called from the external application OnStartup method, which creates an equivalent custom ribbon panel:

static void AddRibbonPanel(
  ControlledApplication a )
{
  const string m = "mep.Cmd"; // namespace and command prefix
  string path = Assembly.GetExecutingAssembly().Location;
 
  string[] text = new string[] {
    "Assign flow to terminals",
    "Change size",
    "Populate CFM per SF on spaces",
    "Reset demo",
    "Electrical System Browser",
    "Electrical Hierarchy",
    "Electrical Hierarchy 2",
    "Unhosted elements",
    "About..."
  };
 
  string[] classNameStem = new string[] {
    "AssignFlowToTerminals",
    "ChangeSize",
    "PopulateCfmPerSf",
    "ResetDemo",
    "ElectricalSystemBrowser",
    "ElectricalHierarchy",
    "ElectricalHierarchy2",
    "UnhostedElements",
    "About"
  };
  //
  // create three stacked buttons for the 
  // HVAC, electrical and about commands respectively:
  //
  RibbonPanel panel = a.CreateRibbonPanel(
    "MEP Sample" );
 
  PulldownButtonData d1 = new PulldownButtonData(
    "Hvac", "HVAC" );
 
  d1.ToolTip = "HVAC Commands";
 
  PulldownButtonData d2 = new PulldownButtonData(
    "Electrical", "Electrical" );
 
  d2.ToolTip = "Electrical Commands";
 
  PushButtonData d3 = new PushButtonData(
    classNameStem[8], text[8], path, m + classNameStem[8] );
 
  d3.ToolTip = "About the HVAC and Electrical MEP Sample.";
 
  List<RibbonItem> ribbonItems = panel.AddStackedButtons(
    d1, d2, d3 );
  //
  // add subitems to the HVAC and electrical pulldown buttons:
  //
  PulldownButton pulldown;
  PushButton pb;
  int j;
 
  for( int i = 0; i < 8; ++i )
  {
    j = i < 4 ? 0 : 1;
    pulldown = ribbonItems[j] as PulldownButton;
 
    pb = pulldown.AddItem( text[i], path,
      m + classNameStem[i] );
 
    pb.ToolTip = text[i];
  }
}

The procedure to create and populate the panel is straightforward:

• We define the external command name prefix and assembly path like before.
• The command name stems and menu item texts are stored in two string arrays.
• A new ribbon panel is created.
• Two pulldown buttons to group the HVAC and electrical commands are added to the panel.
• One push button for the about box command is added.
• The string arrays of menu item texts and class name stems are iterated.
• A ribbon item is created for each command.

Here is the panel as it appears when dragged out of the ribbon to float freely:

Here is the complete source code and Visual Studio solution for the MEP sample application in its current state. We will be discussing more details of its implementation in the coming weeks.

Here is a related question that just came up:

Ribbon Panel Image Resources

Question: I want to populate my Revit add-in ribbon panel with images which I obtain from the resources with a method like this:

internal static System.Drawing.Bitmap door_button {
  get {
    object obj = ResourceManager.GetObject(
      "door_button", resourceCulture);

    return ((System.Drawing.Bitmap)(obj));
  }
}

The object type of the image to assign to a button for the ribbon toolbar is System.Windows.Media.ImageSource. I tried the same approach as above, to provide a method that returns an object of this type and cast to it to the required type before returning. This does not work, even though the compiler does not complain. How can I cast between these types, or how else can I retrieve an image of the type System.Windows.Media.ImageSource from the resources, so that I do not have to have the actual image file (png or bitmap) to be distributed with the application?

I see that the method "ResourceManager.GetObject()" returns an object of type "System.Drawing.Bitmap", but the data type to be assigned to a ribbon-button is "BitmapImage". I do not see any common base types or a constructor for this class that allows an object of type "System.Drawing.Bitmap" or any derived class from it, so I do not see how to convert between the types. However, investigating the classes in the class browser I have found a method "FromResource" for the Bitmap class, but I have not seen an example on how to use it.

Answer: When I look at the Revit SDK sample Ribbon, I see it using the class System.Windows.Media.Imaging.BitmapImage to define the external application ribbon images.

I do agree that retrieving the bitmap image from the resources is a much cleaner solution than the one used in the Ribbon sample.

System.Windows.Media.ImageSource is an abstract class, so you will never be able to obtain an instance of that from anywhere.

You can open the PresentationCore assembly in the Visual Studio Object Browser, navigate to the class System.Windows.Media.Imaging.BitmapImage, and open its 'Base Types' sub node. That will show you that it is derived from BitmapSource, which is derived from ImageSource.

The Ribbon sample simply uses the BitmapImage constructor to create a BitmapImage which also constitutes an ImageSource.

Now back to your main question, how to convert from the Bitmap returned from the resource manager to the BitmapImage required by the Revit ribbon API.

I googled for "cast Bitmap BitmapImage" and found various useful hits. Based on these, this is the solution that I ended up with, which I tested in a simple console application:

static void Main( string[] args )
{
  Bitmap a = Resource1.Image1;
 
  MemoryStream ms = new MemoryStream();
  a.Save( ms, ImageFormat.Png );
 
  BitmapImage b = new BitmapImage();
  b.BeginInit();
  b.StreamSource = ms;
  b.EndInit();
}

By the way, another example of using resources and utilising the .NET framework ResourceManager class to manage them is provided by the PowerCircuit Revit SDK sample.

DWG Export Filename

Here is a question handled by Joe Ye that I thought might be of general interest.

It makes use of the Revit SDK sample ImportExport converted to VB.NET. We mentioned the issue of converting Revit SDK samples from C# to VB in one post, and Adam Nagy later presented a more complete port.

Question: I am making an application to export Revit views to DWG files. I used the ImportExport sample converted to VB.NET as a basis. I am having trouble defining filenames other than the built-in solution. The syntax for defining the DWG filename for a given view seems to be:

[FileName] & " - " & [ViewType] & " - " & [ViewName] 

The filename can be changed, but the other substrings seem to be hardcoded, or at least I can't find where they are defined. I would like the FileName and ViewType substrings to be optional and maybe replaced by some other project defined prefix. Is this possible through the API?

If not, a workaround could be to rename the DWG files afterwards, but I hope to avoid that.

Answer: In this case, you are using one of the overloads of the Export method taking four arguments, the fourth of which specifies the type of export required. The first three are folder, name, and views:

• folder: the output folder into which the files will be exported.
• name: either the name of a single file or a prefix for a set of files. If null or empty, automatic naming will be used.
• views: a selection of views to be exported. If null or empty, only the active view will be exported.

As the documentation says, the exported DWG file name is in fact generated using a hardcoded algorithm inside Revit if the view set contains more than one single element.

If only one view is specified, then the filename string constructed from three substrings provided by specific variables is used. It is defined in the module ExportData.vb, in the Initialize function:

Private Sub Initialize()
  ' The directory into which the file will be exported 
  Dim dllFilePath As String _
    = Assembly.GetExecutingAssembly().Location
 
  m_exportFolder = Path.GetDirectoryName(dllFilePath)
 
  ' The file name to be used by export 
  Dim docTitle As String = m_activeDoc.Title
 
  Dim v As View = m_activeDoc.ActiveView
 
  Dim viewName As String = v.Name
  Dim viewType As String = v.ViewType.ToString()
 
  m_exportFileName = docTitle _
    + "-" + viewType _
    + "-" + viewName _
    + "." + getExtension().ToString()
 
  ' Whether current active view is 3D view 
 
  If v.ViewType = Enums.ViewType.ThreeD Then
    m_is3DView = True
  Else
    m_is3DView = False
  End If
End Sub

Therefore, you can easily make FileName and ViewType optional or replace them by some other prefix. Simply change the string values in the definition of m_exportFileName as you please, for instance like this:

m_exportFileName = docTitle + "-" + “aaaa” + “.” + getExtension().ToString

Note that changes to the specified filename have no effect if more than one view is given in the third argument to the Export method. If the third argument includes more than one view, Revit will automatically name each exported DWG file using a hard-coded rule including the second argument to the Export method as a prefix. If the third argument includes just one single view, then the file name passed in is used. So the workaround to use your own naming rule is to export only one view at a time. In case of multiple views, you can export them one by one in a loop.

This information obviously also applies to the other overloads of the Export method taking a ViewSet argument, including export to:

• DGN
• DWF2D
• DWF3D
• DWFX2D
• DWFX3D
• DWG
• FBX

Thank you very much Joe for this answer!