The Building Coder

Revit 2011 Web Update 2

I am currently attending an Autodesk-specific non-technical training in a pretty posh old English manor house, The Elvetham. Apparently, Queen Elizabeth I planted an oak tree here which is still standing, and King Henry VIII met one of his wives here, back in the sixteenth century.

In more recent news, a colleague just pointed out the Revit OpEd blog featuring a concise and clear overview of the newly released Revit 2011 web update 2, which is build 20100903_2115, and its relationship to other upcoming updates.

The web update of Revit 2011 can be downloaded from the public Revit product pages:

• Revit Architecture > Product Download
• Revit MEP > Product Download
• Revit Structure > Product Download

The first update in June, Revit 2011 Web Update 1 (WU1) is included in Web Update 2 (WU2), so it is not necessary to install WU1 first.

Here is the list of the WU2 API enhancements which extend the WU1 ones and are also applicable across all three flavours for Architecture, MEP and Structure, copied out of the enhancements list documents Enhancements_List_RAC_2011_UR2.pdf and the same for RME and RST:

• Setting formula for Manufacturer/Type Comments as string no longer throws an exception.
• Improves consistency between User Interface and API when using Family Type count.
• Improves the consistency of maintaining the preview image when Save/SaveAs.
• Improves the consistency of creating the detail curve when the view‟s detail sketch plane is not located where expected within the database.
• Improves detail curve creation when the view does not have an implicit sketch plane.

The RME enhancement list mentions the following two additional MEP specific API enhancements:

• Cabletray Connector Angle property no longer throws an exception when rotating a cabletray.
• MEP API: The following Electrical Parameter Types have been exposed to DB.ParameterType:
  • CABLETRAY_SIZE
  • LOADCLASSIFICATION
  • ELECTRICAL_TEMPERATURE
  • ELECTRICAL_DEMAND_FACTOR
  • CONDUIT_SIZE

Extract Part Atom Revisited

We briefly discussed the use of the ExtractPartAtomFromFamilyFile method in Revit 2010. Now the question on using this method arose again in the context of the Revit 2011 API:

Question: I invoked the Autodesk.Revit.ApplicationServices.Application ExtractPartAtomFromFamilyFile method of on an RFA file, using the following code:

private void createPartAtomFile(
  Application app,
  string rfaFilePath,
  string partAtomFilePath )
{
  app.ExtractPartAtomFromFamilyFile(
    rfaFilePath,
    partAtomFilePath );
}

This threw an AccessViolationException with the following stack trace:

AccessViolationException: Attempted to read or write protected memory. This is often an indication that other memory is corrupt. 
at extractPartAtomFromFamilyFile(AString* , AString* ) 
at Autodesk.Revit.ApplicationServices.Application.ExtractPartAtomFromFamilyFile(String familyFilePath, String xmlFilePath) 
... 
... 

How can I avoid this exception and successfully generate the part atom XML for the RFA file?

Answer: Based on an answer to this question by my colleague Saikat Bhattacharya, I wrote a new Building Coder sample command CmdPartAtom to test run this method. The command implementation is achieved in the following few lines of code and successfully generates the part atom XML file:

[Transaction( TransactionMode.Manual )]
[Regeneration( RegenerationOption.Manual )]
class CmdPartAtom : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication uiapp = commandData.Application;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Application app = uiapp.Application;
    Document doc = uidoc.Document;
 
    Transaction trans = new Transaction( doc, 
      "Extract Part Atom" );
 
    trans.Start();
 
    string familyFilePath 
      = "C:/Documents and Settings/All Users"
      + "/Application Data/Autodesk/RAC 2011"
      + "/Metric Library/Doors/M_Double-Flush.rfa";
 
    string xmlPath = "C:/tmp/ExtractPartAtom.xml";
 
    app.ExtractPartAtomFromFamilyFile( 
      familyFilePath, xmlPath );
 
    trans.Commit();
 
    return Result.Succeeded;
  }
}

Here is a screen snapshot of the resulting XML file displayed in the browser, with all except one of the A:part nodes collapsed:

In Saikat's words: Looking at the exception you have received, I am not sure if it is related to the TransactionMode and RegenerationOption attributes used in your plug-in. In my case, I used the Manual mode for both the attributes. Please try using my code snippet and steps to see if it works well at your end too.

Many thanks to Saikat for this exploration!

Here is version 2011.0.75.0 of The Building Coder samples including the complete source code and Visual Studio solution with the new command.

More recently, we have heard that there is currently a problem with this API call on 64 bit systems, so right now this will only work in the 32 bit version. As Steve points out below, the issue might be occurring only on certain platforms, e.g. on 64 bit Windows 7 OS running 64-bit Revit Architecture 2011. It has been resolved internally, though, so the next update should have the issue fixed.

DoorSwing Fix

I am spending this week in the UK. We are having a long-awaited EMEA DevTech team meeting today. We finally succeeded in creating a possibility for all ADN engineers working in the European region to get together face to face. I met some of my colleagues for the first time, for instance Marat, who is based in Moscow, and Kristine from Toronto (not really part of Europe). The rest of the week I will be attending an internal training course, so expect a bit less blogging activity than usual. I do hope to be able to present at least something anyway, though, beginning with the following little item that cropped up a week or two ago:

Eric Wigren of CAD Specialisten brought a little problem with the DoorSwing SDK sample to my attention.

Since the fix is simple, I will publish my version of it here, in case anyone needs it urgently, like Eric did. The public SDK will also be fixed, of course, the next time an update becomes available.

It started out with Eric's raising the following issue:

Question: I am trying to use the Revit 2011 SDK DoorSwing sample. If I flip a door in the user interface without clicking 'Update Door Properties' and then save the project, I get the following error message:

"Attempt to modify the model outside of transaction."

Do you have a solution for this?

I need the DoorSwing add-in because in Sweden when ordering doors for a new building, the factory needs to know for every door whether its leaf is on the left or right. This swing direction feature is available in AutoCAD Architecture, but not in Revit.

Answer: I looked at this sample and discovered two unrelated problems with it:

• The external application is missing from the add-in manifest file.
• The external application call-back event handlers lack the required transactions.

Put differently, with a little more detail:

• The add-in manifest file lists the three commands, but not the external application implemented by this sample.
• The external application implements event handlers for the DocumentSaving and DocumentSavingAs, and these do not set up the transactions that they require.

The latter issue is causing the problem you describe.

Adding the external application to the add-in manifest can be achieved by including the following lines to DoorSwing.addin immediately before the final line with the closing RevitAddIns tag (copy to a text editor to see the truncated lines):

  <AddIn Type="Application">
    <Name>DoorSwing</Name>
    <Assembly>C:\...\DoorSwing.dll</Assembly>
    <ClientId>ad10ff26-34a5-4186-8142-3619264e0833</ClientId>
    <FullClassName>Revit.SDK.Samples.DoorSwing.CS.ExternalApplication</FullClassName>
  </AddIn>

To add the transaction required to the event handlers, I implemented a common helper function 'f' called by both of them in the module ExternalApplication.cs. The resulting code looks like this:

/// <summary>
/// This event is fired whenever a document 
/// is saved. Update door's information 
/// according to door's current geometry.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="args">An DocumentSavingEventArgs 
/// that contains the DocumentSaving event data.</param>
private void DocumentSavingHandler( 
  Object sender, 
  DocumentSavingEventArgs args )
{
  f( args.Document );
}
 
/// <summary>
/// This event is fired whenever a document 
/// is saved as. Update door's information 
/// according to door's current geometry.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="args">An DocumentSavingAsEventArgs 
/// that contains the DocumentSavingAs event data.</param>
private void DocumentSavingAsHandler( 
  Object sender, 
  DocumentSavingAsEventArgs args )
{
  f( args.Document );
}
 
void f( Document doc )
{
  string message = "";
 
  Transaction t = new Transaction( doc, 
    "Door Swing" );
 
  t.Start();
 
  try
  {
    DoorSwingData.UpdateDoorsInfo( 
      doc, false, false, ref message );
 
    t.Commit();
  }
  catch( Exception ex )
  {
    t.RollBack();
 
    message = ex.Message;
  }
  if( 0 < message.Length )
  {
    MessageBox.Show( message, "Door Swing" );
  }
}

Here is DoorSwingUpdateJeremy.zip containing the two modified files DoorSwing.addin and ExternalApplication.cs.

Filter for View and Phase

Here is yet another entry in our endlessly growing collection of filtering examples, highlighting yet another hitherto unexplored aspect, combining a view filter with a parameter filter for a specific phase.

Question: I need to retrieve all elements in a specific view that have same phase, created but not demolished. How can I achieve that, please?

Answer: To get all elements in a specified view, you can use the overload of the FilteredElementCollector constructor taking a view element id as a second argument. Quoting the Revit API help file RevitAPI.chm, it 'constructs a new FilteredElementCollector that will search and filter the visible elements in a view'.

Since 'Phase Created' is a parameter, you can then use the ElementParameterFilter class to filter out elements having the specific phase. Combining the two filters will provide your target element set.

Here is some sample code demonstrating this:

[TransactionAttribute( TransactionMode.Manual )]
[RegenerationAttribute( RegenerationOption.Manual )]
public class RevitCommand : IExternalCommand
{
  public Result Execute( 
    ExternalCommandData commandData, 
    ref string messages, 
    ElementSet elements )
  {
    UIApplication app = commandData.Application;
    Document doc = app.ActiveUIDocument.Document;
 
    Transaction trans = new Transaction( doc, "Test" );
    trans.Start();
 
    // use the view filter
 
    FilteredElementCollector collector 
      = new FilteredElementCollector( 
        doc, doc.ActiveView.Id );
 
    // use the parameter filter.
    // get the phase id "New construction"                                        
 
    ElementId idPhase = GetPhaseId( 
      "New Construction", doc );
 
    ParameterValueProvider provider 
      = new ParameterValueProvider( 
        new ElementId( ( int ) 
          BuiltInParameter.PHASE_CREATED ) );
 
    FilterNumericRuleEvaluator evaluator 
      = new FilterNumericEquals();
 
    FilterElementIdRule rule 
      = new FilterElementIdRule( 
        provider, evaluator, idPhase );
 
    ElementParameterFilter parafilter 
      = new ElementParameterFilter( rule );
 
    collector.WherePasses( parafilter );
 
    TaskDialog.Show( "Element Count", 
      "There are " + collector.Count().ToString() 
      + " elements in the current view created"
      + " with phase New Construction" );
 
    trans.Commit();
 
    return Result.Succeeded;
  }
 
  public ElementId GetPhaseId( 
    string phaseName, 
    Document doc )
  {
    ElementId id = null;
 
    FilteredElementCollector collector 
      = new FilteredElementCollector( doc );
 
    collector.OfClass( typeof( Phase ) );
 
    var phases = from Phase phase in collector
                 where phase.Name.Equals( phaseName )
                 select phase;
 
    id = phases.First().Id;
 
    return id;
  }
}

View Location on Sheet

I returned from a beautiful little mountain hike to the lake, pass and mountain of Piz Lunghin.

One very special aspect of this place is that it is Europe's one and only triple watershed, with rivers flowing all the way to the North Sea, Black Sea and Mediterranean. Another special aspect of my hike was spending the night outside on the mountain, with a wonderful clear sky and the almost full moon in sub-zero temperatures (Celsius).

Returning once again to the Revit API, the SDK sample AllViews collects all views in the model, asks the user to interactively select some of them, and places those on a sheet.

Even so, the exact definition and calculation of the view coordinates and location of the view on the sheet remains somewhat obscure. Here are some furhter helful results in this area. They do not answer every possible question in full completeness, so we still have some work to do exploring this area, but hopefully they will be useful already in this incomplete form.

We recently had one question from Thomas Fink of SOFiSTiK on this, and here is another recent question on that topic with some interesting research performed by my colleague Joe Ye. I am reproducing the rather long discussion in full, to show that the issue is not trivial and the solution is not yet completely perfect:

Question: Given a certain view placed on a sheet, I am trying to retrieve the location of the view on the sheet using:

  Location loc = Element.Location;

This is not giving me what I need, which is the UV or XYZ location of the view placed on the sheet.

Answer: You can use the Element BoundingBox property to retrieve the Max and Min points of a viewport in the sheet. From these, you can calculate the middle point of the Max and Min point. The middle point is the viewport's centre point in sheet.

Here is some code showing to determine the centre point of a view in a sheet view. To quickly test the solution, it currently uses a hardcoded element id 157165 for the viewport in the sheet view; please change that to suit your model and needs. In addition, please pass in the sheet object as an argument in the call to Element.get_BoundingBox. In this sample, we just set the sheet view to be the active view:

[TransactionAttribute( TransactionMode.Manual )]
[RegenerationAttribute( RegenerationOption.Manual )]
public class GetViewPosition : IExternalCommand
{
  public Result Execute( 
    ExternalCommandData commandData, 
    ref string messages, 
    ElementSet elements )
  {
    UIApplication app = commandData.Application;
    Document doc = app.ActiveUIDocument.Document;
 
    ElementId id = new ElementId( 157165 );
    Element elem = doc.get_Element( id );
 
    BoundingBoxXYZ bounding 
      = elem.get_BoundingBox( doc.ActiveView );
 
    string sMsg = "The Max and Min points are: \n";
 
    sMsg += bounding.Max.X.ToString() 
      + ", " + bounding.Max.Y.ToString() 
      + ", " + bounding.Max.Z.ToString() + "\n";
 
    sMsg += bounding.Min.X.ToString() 
      + ", " + bounding.Min.Y.ToString() 
      + ", " + bounding.Min.Z.ToString() + "\n";
 
    XYZ xyzPosition 
      = ( bounding.Max + bounding.Min ) / 2.0;
 
    sMsg += "view position in current sheet is:\n" 
      + xyzPosition.X.ToString() 
      + "," + xyzPosition.Y.ToString() 
      + "," + xyzPosition.Z.ToString();
 
    MessageBox.Show( sMsg );
 
    return Result.Succeeded;
  }
}

Response: I need to programmatically copy a legend view from one sheet to another. For this, I need to get the location of the view from the original sheet and reuse this location when adding new views to the other sheets.

For this purpose, I am using the following code:

  foreach( ViewSheet chosenSheet in SelectedSheets )
  {
    BoundingBoxXYZ xyzLocation 
      = selectedView.get_BoundingBox( 
        m_Doc.ActiveView );
 
    XYZ xyzPosition = ( xyzLocation.Max 
      + xyzLocation.Min ) / 2.0;
 
    int scale = correspondingView.Scale;
 
    chosenSheet.AddView( correspondingView, 
      new UV( xyzPosition.X, xyzPosition.Y ) );
  }

Here I am using the following variables:

• chosenSheet is the sheet where the legend will be copied.
• selectedView is the selected Viewport to be copied.
• correspondingView is the view to be copied.

Unfortunately, the views are not copied to the same location.

Answer: I created a simple project and added several view sheets. I picked the Level 1 viewport and tried to run this code, but this caused an error message saying 'Added view is already on another sheet and cannot be displayed on two sheets'.

Response: This is because you are trying to copy a "plan" view that is already placed on a sheet and place it on another sheet. Try running this code on a legend view placed on a sheet.

Answer: The point used to insert the view on the view sheet is mapping the (0,0,0) point of the source view. When you retrieve the centre point coordinates of the viewport, they do not match the (0,0,0) point of the source view. So you need to calculate the source view's original point coordinates in the view sheet from the viewpoint's centre point coordinates.

Response: I understand that I need to get the centre of the view in the ViewSheet in order to be able to calculate the shift. How can I obtain the coordinates of the centre of the view relative to the view sheet?

Answer: The View class has a very important property Outline. The Outline property will return the Max and Min point of the closest bounding box, which includes all elements in this view. The value in this Max and Min the result of the legend view's real Max and Min coordinates subdivided by the view scale. For more information about Outline property, please refer to the Revit SDK developer guide 'Revit 2011 API Developer Guide.pdf'.

Approximately, the outline Max point is mapping the same Max point of the viewport in view sheet. So we can calculate the source view's origin coordinates in the host view sheet using the following code:

  BoundingBoxXYZ xyzLocation 
    = SelectedView.get_BoundingBox( 
      m_Doc.ActiveView );
 
  // get the outline max and min 
 
  XYZ ptMaxOutline = new XYZ( 
    CorrespondingView.Outline.Max.U, 
    CorrespondingView.Outline.Max.V, 
    0 );
 
  // get the view's origin point's 
  // coordinates in current view sheet. 
 
  UV ptSourceViewOriginInSheet = new UV( 
    xyzLocation.Max.X - ptMaxOutline.X,
    xyzLocation.Max.Y - ptMaxOutline.Y ); 

Here is the complete code of the Execute method:

public Result Execute( 
  ExternalCommandData commandData, 
  ref string message, 
  ElementSet elements )
{
  try
  {
    UIApplication uiapp = commandData.Application;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Application app = uiapp.Application;
    Document doc = uidoc.Document;
 
    SelElementSet selection = uidoc.Selection.Elements;
    if( selection.Size == 0 )
    {
      MessageBox.Show( "Please Select a view to be copied.", 
        "View Coordinates", MessageBoxButtons.OK,
      MessageBoxIcon.Error );
      return Result.Failed;
    }
    else
    {
      // Get all Sheets 
      List AllSheets = GetAllSheets( doc );
 
      // Get all Views in the model. 
      // Find all views in the document by using category filter 
 
      ElementCategoryFilter filter 
        = new ElementCategoryFilter( 
          BuiltInCategory.OST_Views );
 
      FilteredElementCollector collector 
        = new FilteredElementCollector( doc );
 
      IList AllViews = collector.WherePasses( filter )
        .ToElements();
 
      foreach( Element SelectedView in selection )
      {
        if( SelectedView.Category.Name == "Viewports" )
        {
          String ViewName = SelectedView.get_Parameter( 
            "View Name" ).AsString();
 
          View CorrespondingView = null;
 
          for( int i = 0; i < AllViews.Count; i++ )
          {
            if( AllViews[i].Name == ViewName )
            {
              CorrespondingView = AllViews[i] as View;
              break;
            }
          }
 
          BoundingBoxXYZ xyzLocation 
            = SelectedView.get_BoundingBox( 
              doc.ActiveView );
 
          // get the outline max and min 
 
          XYZ ptMaxOutline = new XYZ( 
            CorrespondingView.Outline.Max.U, 
            CorrespondingView.Outline.Max.V, 0 );
 
          // get the view's origin point's coordinates 
          // in current view sheet. 
 
          UV ptSourceViewOriginInSheet = new UV( 
            xyzLocation.Max.X - ptMaxOutline.X,
            xyzLocation.Max.Y - ptMaxOutline.Y );
 
          // for each chosen to be exported 
          // get the views on it. 
 
          foreach( ViewSheet ChosenSheet in AllSheets )
          {
            ChosenSheet.AddView( CorrespondingView, 
              ptSourceViewOriginInSheet );
          }
        }
      }
      return Result.Succeeded;
    }
  }
  catch( Exception ex )
  {
    MessageBox.Show( ex.Message );
    return Result.Failed;
  }
} 

Response: Using this code, the location of the view on the sheet is still inaccurate. If I use this code to duplicate a view legend placed on a sheet in the same location, the legend view still appears to be shifted while duplicated on the same sheet, as shown in the following figures. Here is a view of the entire sheet:

Here is a more detailed picture of the offset between the original and copied views:

Answer: The reason for this might be that the Revit API returns the Viewport BoundingBox property value with an offset to its original outline property. The BoundingBox property is not completely accurate, so the result to calculate the legend view's origin in the sheet view cannot be so either. As far as I can tell, the offset of the Max point of the viewport's BoundingBox is enlarged 0.01 in both X and Y direction. We can take this scaling into account.

Here is some updated code with an adjustment added. You might need to further adjust the offset value according to different situations. The offset value of 0.01 is not obtained from source code, but from my empirical testing results:

foreach( Element SelectedView in selection )
{
  if( SelectedView.Category.Name == "Viewports" )
  {
    string ViewName = SelectedView.get_Parameter( 
      "View Name" ).AsString();
 
    View CorrespondingView = null;
 
    for( int i = 0; i < AllViews.Count; i++ )
    {
      if( AllViews[i].Name == ViewName )
      {
        CorrespondingView = AllViews[i] as View;
        break;
      }
    }
 
    BoundingBoxXYZ xyzLocation 
      = SelectedView.get_BoundingBox( 
        doc.ActiveView );
 
    // get the outline max and min,
    // offset in each direction of max point of 
    // bounding box than the outline box.
 
    double dMaxOffset = 0.01;  
    XYZ ptMaxOutline = new XYZ( 
      CorrespondingView.Outline.Max.U, 
      CorrespondingView.Outline.Max.V, 0 );
 
    UV ptSourceViewOriginInSheet = new UV( 
      xyzLocation.Max.X - dMaxOffset - ptMaxOutline.X, 
      xyzLocation.Max.Y - dMaxOffset - ptMaxOutline.Y );
 
    // for each chosen to be exported get the views on it
 
    foreach( ViewSheet ChosenSheet in AllSheets )
    {
      ChosenSheet.AddView( CorrespondingView, 
        ptSourceViewOriginInSheet );
    }
  }
}

Thank you very much, Joe, for this thorough exploration!

Here is another quick question and answer that might be of use in this context:

Centre Point of View

Question: I need a way to get the XYZ of the centre of a view and the XYZ of the centre of a sheet. Can I achieve this using one of the Outline, CropBox or BoundingBox properties?

Answer: It depends on what exactly you mean by 'centre of view'. I can imagine that it might be any one of the following:

• The visible centre of a view: If we pan the view, the centre coordinates change. There is currently no API exposed to get the visible centre of a view, and we do have an open wish list item to obtain this information.
• The centre point of the crop box: We can retrieve the BoundingBoxXYZ of the view through the CropBox property. Then the centre can be determined by Max and Min of the crop box.
• The coordinate centre: the coordinate centre point is returned by the View.Origin property.

For an example of defining a completely different set of view coordinates, we also once looked at cropping a 3D view to a specific element.

AutoCAD 2010 DWG Export

Today is a public holiday in Neuchâtel, the jeûne fédéral or Federal Fast holiday. I will use that for a hike in the Swiss mountains, that I so sorely neglected and missed this summer.

Meanwhile, here is a simple question on the AutoCAD file format version used for DWG export.

Question: How can I set the AutoCAD 2010 version as the destination file format for DWG export?

The ACADVersion enumeration only has options for 2000, 2004, and 2007.

In the user interface, it is possible to select 2010 as well.

Answer: Looking at the ACADVersion enumeration, I see the following entries:

• Default: The Autodesk Revit application's default export format.
• R2000: AutoCAD 2000 file format.
• R2004: AutoCAD 2004 file format.
• R2007: AutoCAD 2007 file format.

The AutoCAD 2010 file format was recently added as another format in the DWG export options. It is currently created by specifying the 'Default' value.

Because this is a simple enum wrapper, you can also cause Revit to export the AutoCAD 2010 file format by passing in '4' to the options settings. Using Reflector, you can see that the numerical values of the existing entries are 0-3, which makes it very probable that 4 is the next one. In any case it worked, for example, using the following code:

  DWGExportOptions options = new DWGExportOptions();
 
  options.FileVersion = ( ACADVersion ) ( 4 );
 
  ViewSet views = new ViewSet();
 
  views.Insert( uiDoc.Document.ActiveView );
 
  uiDoc.Document.Export( @"d:\temp", @"junk.dwg", 
    views, options );

This creates a resulting DWG file in AutoCAD 2010 file format with a header of ac1024, equal to the ObjectARX enum value kDHL_1024 = 29, which stands for '2010 final'.

As said, ACADVersion.Default also results in an AutoCAD 2010 file format DWG, but that will obviously change in future releases.

Casting an integer to an enum value to pass into the settings is obviously not an officially supported way of using the Revit API, but it might help you get around this in the short term.

Selection Watcher Using Idling Event

Here is a pretty cool example by Ken Goulding of using the Idling event to work around a little gap in the current Revit API. Ken posted a comment which triggered a pretty interesting conversation and culminated in the SelectionWatcher sample.

Another interesting item that cropped up was the possibility to use PasteBin to share snippets of source code, as Ken did for parts of his initial implementation:

• Class implementation
• Sample usage

The code listed there is now obsolete, though.

Here are some excerpts from our conversation that led up to this sample:

Ken: When you mentioned "Element Level", I was hoping that included element selection events, but that does not seem to be the case. As a work-around, I created a class that subscribes to the application Idling event and checks for selection changes. Given that the Idling event is called very frequently, I tried to be as efficient as possible at figuring out whether a change has happened, but there may be a simpler way?

Jeremy: Thank you for your query with the interesting idea and the source code. Thank you also for the interesting PasteBin URLs. I was not previously aware of this possibility.

Regarding the element selection events, you are correct in your assessment that these are currently not provided by the Revit API.

Your use of the Idling event to implement a work-around sounds like a brilliant idea to me.

Ken: I'm glad you see potential for the selection watcher class. I was using it to link additional data (e.g. photographs) to room objects, but I'm sure your readers can find far more interesting uses for context-sensitive functionality. I added a few comments inline. Please let me know if anything is not clear,

Jeremy: Thank you very much for the illuminating sample. I like it very much! I fixed two details which simplify things:

1. You need to set the 'Copy Local' flag to false on the references to the Revit API DLLs.
2. You can obtain the application object from the Idling event arguments, so there is no need for a global variable and a DocumentOpening event handler to set it.

Ken: Thanks for the suggestions. It is good to know that you don't need to copy the Revit API DLLs locally, since they are big.

Jeremy: Here are some screen snapshots from an example run testing this. The selection watcher is an external application and defines its own ribbon panel. Here it is ripped off the ribbon bar and placed over the graphics area, so that it remains visible through a ribbon context switch:

Here we have selected Room 5, which is displayed immediately by the selection watcher:

In this simple implementation, selection of multiple rooms is simply listed as such with no further details:

For further details including some comments, please look at the source code in the archive file SelectionWatcher.zip. It includes the full source code, complete Visual Studio solution and an add-in manifest file to load the application.

Here are a few implementation details to whet your appetite:

• A standalone SelectionChangedWatcher class implementation which is completely separate from the external application.
• The external application instantiates an instance of the SelectionChangedWatcher class and subscribes to its SelectionChanged event.
• The external application does not need to know how the SelectionChanged event is implemented, or that it is internally triggered by the Idling event.

This allows the following minimalistic implementation of the external application class, which just needs to set up its ribbon panel and text box to display the results, instantiate and subscribe to the selection watcher, and update the text box when changes occur:

[Transaction( TransactionMode.Manual )]
[Regeneration( RegenerationOption.Manual )]
[Journaling( JournalingMode.NoCommandData )]
 
public class SelectionChangedExampleApp
  : IExternalApplication
{
  private SelectionChangedWatcher
    _selectionChangedWatcher;
 
  private TextBox _tb;
 
  public Result OnShutdown(
    UIControlledApplication a )
  {
    return Result.Succeeded;
  }
 
  public Result OnStartup(
    UIControlledApplication a )
  {
    _selectionChangedWatcher
      = new SelectionChangedWatcher( a );
 
    _selectionChangedWatcher.SelectionChanged
      += new EventHandler(
        OnSelectionChanged );
 
    // it does not seem to be possible to add items 
    // to context-sensitive ribbon panels.
    // however the user can detach this panel from 
    // the main ribbon so that it is not hidden by 
    // context-sensitive panels.
 
    RibbonPanel rpSelectionWatcher
      = a.CreateRibbonPanel( "Selection Watcher" );
 
    var t1 = new TextBoxData( "txtInfo" );
 
    _tb = rpSelectionWatcher.AddItem( t1 ) as TextBox;
 
    return Result.Succeeded;
  }
 
  void OnSelectionChanged(
    object sender,
    EventArgs e )
  {
    if( null == _selectionChangedWatcher.Selection )
    {
      ShowInfo( "No selection" );
      return;
    }
 
    // this example just reports the name of the 
    // room that is selected. Obviously any other
    // kind of element can be handled instead.
 
    List<Room> rooms = new List<Room>(
      _selectionChangedWatcher.Selection.OfType<Room>() );
 
    if( 0 == rooms.Count )
    {
      ShowInfo( "No rooms selected" );
    }
    else if( 1 == rooms.Count )
    {
      ShowInfo( "Room " + rooms[0].Number );
    }
    else
    {
      ShowInfo( "Multiple rooms selected" );
    }
  }
 
  private void ShowInfo( string p )
  {
    _tb.PromptText = p;
  }
}

The SelectionChangedExample class is more interesting, of course.

• It takes the UIControlledApplication as an argument, so that it can subscribe to the Idling event.
• It manages the subscription to the Idling event internally, with no need for the client to be aware of that.
• It uses an auto-implemented property to store a list of all currently selected elements.
• Every selection change is registered in the Idling event handler, updates the selection property, and triggers the SelectionChanged event.

Here it is in all its glory:

public class SelectionChangedWatcher
{
  public event EventHandler SelectionChanged;
 
  /// <summary>
  /// Auto-implemented property storing a list 
  /// of all currently selected elements.
  /// </summary>
  public List<Element> Selection
  {
    get;
    set;
  }
 
  private List<int> _lastSelIds;
 
  public SelectionChangedWatcher(
    UIControlledApplication a )
  {
    a.Idling
      += new EventHandler<IdlingEventArgs>(
        OnIdling );
  }
 
  void OnIdling(
    object sender,
    IdlingEventArgs e )
  {
    // Idling events happen when the application has 
    // nothing else to do,
    // They can happen very frequently and the user 
    // will experience a lag if this code takes a 
    // significant amount of time to execute.
 
    Application app = sender as Application;
 
    UIApplication uiApplication
      = new UIApplication( app );
 
    SelElementSet selected = uiApplication
      .ActiveUIDocument.Selection.Elements;
 
    if( 0 == selected.Size )
    {
      if( null != Selection && 0 < Selection.Count )
      {
        // if something was selected previously, and 
        // now the selection is empty, report change
 
        HandleSelectionChange( selected );
      }
    }
    else // elements are selected
    {
      if( null == Selection )
      {
        // previous selection was null, report change
 
        HandleSelectionChange( selected );
      }
      else
      {
        if( Selection.Count != selected.Size )
        {
          // size has changed, no need to check 
          // selection IDs, report the change
 
          HandleSelectionChange( selected );
        }
        else
        {
          // count is the same... 
          // compare IDs to see if selection has changed
          if( SelectionHasChanged( selected ) )
          {
            HandleSelectionChange( selected );
          }
        }
      }
    }
  }
 
  private bool SelectionHasChanged(
    SelElementSet selected )
  {
    // we have already determined that the size of 
    // "selected" is the same as the last selection...
 
    int i = 0;
    foreach( Element e in selected )
    {
      if( _lastSelIds[i] != e.Id.IntegerValue )
      {
        return true;
      }
      ++i;
    }
    return false;
  }
 
  private void HandleSelectionChange(
    SelElementSet selected )
  {
    // store the current list of elements in the 
    // Selection property and populate _lastSelIds 
    // with the current selection's ids
 
    Selection = new List<Element>();
    _lastSelIds = new List<int>();
 
    foreach( Element e in selected )
    {
      Selection.Add( e );
      _lastSelIds.Add( e.Id.IntegerValue );
    }
    Call_SelectionChanged();
  }
 
  private void Call_SelectionChanged()
  {
    if( SelectionChanged != null )
    {
      SelectionChanged( this, new EventArgs() );
    }
  }
}

Very many thanks to Ken for this idea and implementation and the fruitful discussion!

Access to Curtain Grid Panels

Here is some strange behaviour noted by Daren Thomas of the Professur für Gebäudetechnik, Institut für Hochbautechnik at the technical university ETH Zürich and author of the Revit Python shell which led to the discovery and quick fix of a problem in the curtain grid API. Since Daren also provides a workaround for the problem for immediate use, I think it worthwhile to note it here.

Question: I just came by some strange behaviour in Autodesk Revit Architecture 2011: It seems that reading a Wall.CurtainGrid.Panels requires a transaction.

Here is a repro (using RevitPythonShell to avoid having to create a new project etc.):

• Create a new Revit project.
• Add a wall.
• Change the wall type to CurtainGrid.
• Remember the element ID of wall (Manage > Inquiry > IDs of Selection), in my case 127699.
• Go to Add-Ins > Open Python Shell.
• Type following sequence of commands (this can be translated to C# pretty easily, as it is mainly about the API); copy to a text editor to see the truncated lines:

>>>import clr

>>>clr.AddReference('RevitAPI')

>>>from Autodesk.Revit.DB import *

>>>doc = __revit__.ActiveUIDocument.Document

>>>cw = doc.get_Element(ElementId(127699)) # substitute actual ID here

>>>cw

<Autodesk.Revit.DB.Wall object at
  0x000000000000002B [Autodesk.Revit.DB.Wall]>

>>>cw.CurtainGrid

<Autodesk.Revit.DB.CurtainGrid object at
  0x000000000000002C [Autodesk.Revit.DB.CurtainGrid]>

>>>cw.CurtainGrid.Panels

IronTextBoxControl error: Attempt to modify the model outside of transaction.

>>>

By the way, this little script also amply demonstrates how extremely easy and powerfully a Revit model can be accessed programmatically and interactively through the Python shell.

This dialog with RevitPythonShell shows that accessing the wall and its CurtainGrid property is ok, but accessing the Panels property triggers the exception. The RevitPythonShell runs with TransactionMode.Manual. This behaviour is not restricted to RevitPythonShell scripts – this is only for the repro. I came across this behaviour with a C# plug-in that also uses TransactionMode.Manual.

What is the rationale behind this behaviour?

Answer: Several of the CurtainGrid APIs were ensuring that they had write access to the underlying objects, even when only read access was required.

This behaviour has now been reported and corrected.

Response: I'm not sure how fixes are deployed with Revit, but assume they are just included in the annual release – so for your readers, you might want to mention a workaround:

Starting a transaction and then calling the method Transaction.Rollback for tasks that don't need transactions but do read curtain wall panels.

Ideally, you want to place the transaction code as close to the curtain wall code as possible, but not inside an inner loop as that can slow things down considerably (been there, done that, getting t-shirts printed to prove).

Answer: Yes, I would love to mention this in the blog and provide a workaround for those who run into this issue.

Do you happen to have some sample code ready to demonstrate exactly what you mean?

Or even (miraculously?) a reproducible sample project with one external command showing the problem and another one showing the solution?

Response: I went through the trouble to build such a project.

You will find attached a C# solution (Visual Studio 2010) that creates the two external commands requested. Inside the solution is also a sample Revit project file SingleCurtainWall.rvt containing four walls, one of which is a CurtainWall with one panel. A sample add-in file can also be found inside the solution.

Also, here are some screenshots of the output of said external commands; first the exception being thrown when the transaction workaround is not implemented:

With the workaround in place, the panels become accessible:

For completeness sake, here is the source code of the initial command causing the problem for comparison with the workaround listed below:

[Transaction( TransactionMode.Manual )]
[Regeneration( RegenerationOption.Manual )]
public class TriggerCurtainGridPanelsTransactionBug
  : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    var doc = commandData.Application
      .ActiveUIDocument.Document;
 
    var walls = new FilteredElementCollector( doc )
      .OfClass( typeof( Wall ) )
      .Cast<Wall>();
 
    foreach( var wall in walls )
    {
      if( wall.WallType.Kind == WallKind.Curtain )
      {
        TaskDialog.Show(
          "CurtainGridPanelsTransactionBug",
          string.Format(
            "CurtainWall has {0} panels.",
            wall.CurtainGrid.Panels.Size ) );
      }
    }
    return Result.Succeeded;
  }
}

This is the updated code with the added transaction required to access the curtain grid panel data, which can be discarded after use:

[Transaction( TransactionMode.Manual )]
[Regeneration( RegenerationOption.Manual )]
public class WorkAroundCurtainGridPanelsTransactionBug
  : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    var doc = commandData.Application
      .ActiveUIDocument.Document;
 
    var walls = new FilteredElementCollector( doc )
      .OfClass( typeof( Wall ) )
      .Cast<Wall>();
 
    // workaround: create a transaction
 
    var transaction = new Transaction( doc,
      "CurtainGridPanelsTransactionBug" );
 
    transaction.Start();
 
    try
    {
      foreach( var wall in walls )
      {
        if( wall.WallType.Kind == WallKind.Curtain )
        {
          TaskDialog.Show(
            "CurtainGridPanelsTransactionBug",
            string.Format(
              "CurtainWall has {0} panels.",
              wall.CurtainGrid.Panels.Size ) );
        }
      }
    }
    finally
    {
      // we don't really want to change the document!
 
      transaction.RollBack();
    }
    return Result.Succeeded;
  }
}

For yet more completeness sake, here is CurtainGridPanelsTransaction.zip containing the entire source code, Visual Studio 2008 and 2010 solution, and a sample file SingleCurtainWall.rvt to test it on.

I guess I got carried away on this task...

Many thanks to Daren for all his research, workaround, and complete documentation of this issue!

Speed Up Selection

I am now back in Switzerland again after all my various travels, and looking forward to diving into the Revit API in depth again...

Here is a really surprising result on how to speed up programmatic selection of a large number of elements, triggered by a question from Joe Offord of Enclos Corp:

Question: I have a situation where I'd like to select a large number of curtain panels (over 1000) and add them to my UIDocument.Selection set. These curtain panel families have a number of nested, shared components in them, numbers ranging from 5 to 30. I'm using the following code in a loop:

  Selection.Elements.Add(Panel)

  If Panel.SubComponents IsNot Nothing Then

    For Each subComp As FamilyInstance _
      In Panel.SubComponents

      Selection.Elements.Add(subComp)

    Next
  End If

This process is very time-consuming and is taking about 5-10 minutes for just this portion of the code (including looping) to run. Is there a better way to create my selection that would speed up things?

What I want when it's all done is to be able to see what elements I've selected. I would normally select just the panel and not the subcomponents, but for some reason Revit will not highlight the subcomponents when I tried this. When I click on the panel outside the API it will highlight the nested components too but I can't replicate this behaviour using the API.

Answer: Generally, the way to speed up the addition of a large number of elements to a collection consists of trying to add all of them or as many as possible at once.

Unfortunately, the only methods I can see on the SelElementSet class to add elements to the collection just take one element at a time:

• Add to add an element into the selected element set.
• Insert to insert the specified element into the set.

There are no other useful methods that I can see on the ElementSet base class either, unfortunately.

One thing that you might be able to try would be to create your own ElementSet instance, let's say in a variable 'a', and add the desired elements to that one by one using the Add method, but keeping the ElementSet 'a' independent, not associated with the Revit user interface or current selection for the time being.

Once you have populated 'a' with the elements you are interested in, you might be able to say

  app.ActiveUIDocument.Selection.Elements = a;

This may possibly avoid some overhead performed by the Revit application when you manipulate the current selection set directly, element by element. Or it may optimise that overhead by doing whatever it is doing to all of them in one go. Or it may make no difference at all.

I cannot think of anything else to suggest, though.

Response: I tried passing in a new ElementSet into the Selection.Elements as you suggested but it got rejected. However, I found a way to create a new SelElementSet and used that to modify the Selection. The code looks something like this:

  Dim newCollection As Selection.SelElementSet _
    = Selection.SelElementSet.Create

  ' ~ code to add elements to newCollection ~

  m_selection.Elements = newCollection

It is remarkable how much time this saves. My selection of 1000+ panels went from roughly 5 minutes to 15 seconds.

Thanks for the excellent advice, as always.

Answer: A colleague of mine asked a relevant question in this context, although I don't really have an idea of whether his assumption is correct or not:

"I guess this was using AUTO transaction, right? I wonder if in case of manual transaction, placing the update/regenerate at the very end would have the same fast result even when adding the entities to the selection set one by one?"

So, just to clarify, what transaction mode and regeneration options are you actually using?

Did you do any experiments with these settings before asking us for a solution?

Thank you in advance for the clarification!

Response: I used Manual Transactions for both methods I tried. I made a new Transaction specifically for this selection routine and called Document.Regenerate only once, right before the call toTransaction.Commit. This was the same for both the single addition method (using Selection.Elements.Add) and the group selection method (using new SelElementSet).

In my biggest selection experiment I had 15,294 Generic Model elements with 1706 Curtain Panel elements selected. The fast way took about 15 seconds. The slow way (using the code I posted first) was about 15% complete after 3 minutes before I shut it down. I was running both commands in a 3D view of the entire model.

Answer: Thank you very much for the clarification! It does indeed help a lot, since it indicates that the improvement we discovered cannot be achieved by simply optimising the transaction and regeneration approaches.

Very many thanks to Joe for raising this interesting question!

Adding a Rebar inside a Rebar Cover

The Pantagruel arrived safely in Göteborg last night after our week-long tour of Norway, Denmark and the Swedish west coast, and our last day has arrived. Time to clean up, disembark, go to the airport and return home again.

Meanwhile, here is an interesting structural rebar issue raised by my colleagues Katsuaki Takamizawa and Tim Culver:

Question: Here are some rebars that were created using the Revit API NewRebar method:

In the user interface, rebars can only be added inside of a rebar cover represented by the green dotted line. If they are generated using the following code in a column where xVec and yVec fit the width and depth of the column profile, they can extend beyond the rebar cover.

  Rebar createdRebar 
    = doc.Create.NewRebar( barShape, barType, 
      column, origin, xVec, yVec );

Is it possible to automatically ensure the rebar placement inside of a rebar cover when generating it programmatically? Or does one have to adjust the location and scale whenever a rebar is added? For instance, using ScaleToBox:

  createdRebar.ScaleToBox( origin, xVec, yVec );

Answer: Keep in mind that Revit does not enforce the cover when it is generated programmatically. However you create the bars, you need to account for the cover yourself. You can specify the location and scale when generating or adjust by ScaleToBox to place a rebar inside the cover. ScaleToBox is the same algorithm used internally by the UI.

However, Revit does perform one adjustment automatically: if you place the rebar so that the centre line is close to the cover (within a bar radius, I think) and parallel, the next call to the Regenerate method will move it to attach to the cover. You can see this by moving the rebar in the UI.

There are actually three ways to create and scale the rebar: using the origin and vectors, create from curves, and ScaleToBox, where the latter requires you to create the bar in one of the other ways first.

No matter how you create the bars, Revit never enforces cover, except in case the rebar is very close and parallel. I.e., when creating rebars programmatically, the cover cannot be enforced like it is in the user interface, the developer has to take care of that explicitly herself.

Many thanks to Katsu-san and Tim for this explanation!