The Building Coder

Add-In Wizards for Revit 2014

I updated my Visual Studio Revit add-in wizards and am taking the time to publish them today, which is Ascension Day and a holiday in Neuchâtel.

That also gives me some extra time to prepare for the June 3-4 Tech Summit presentation of my cloud-based round-trip 2D Revit model editing project.

The presentation must be pre-submitted by May 20, and a full recording by May 27, so pressure is rising. I completed the implementation and still want to catch up on documenting it here on the blog as well. You will be happy to hear that the auto-updating functionality using the Idling event now works fine.

Old and New Wizardry

I am starting to create numerous Revit 2014 add-ins now for quick testing purposes. As soon as that stage is reached, I immediately update my Visual Studio Revit C# add-in wizard.

The 2014 version generates the same boiler-plate code as the Revit 2013 one did, which can be simply deleted if not needed.

Last time around, I egoistically did not implement the VB version until later.

This time though, better realising how much appreciated it is, I took care of that as well, right up front.

It is important to understand how easy it is to modify the wizards for your own needs, and make copies with variations to support different requirements.

Here is an overview of previous explanations of various aspects that also show how create your own flavours:

• Original introduction, benefits, and usage example for C# and VB.
• Personalised minimal C# version for Revit 2011.
• A short additional usage note.
• 64-bit versions for C# and VB.
• Support for the Revit 2012 API for C# and VB.
• Updated C# and VB versions placing assembly DLL alongside add-in manifest and including other changes.
• Revit 2013 C# version including more skeleton code.
• Revit 2013 VB version.

Installing to non-x86 Program Files

I had a new issue to struggle with this time around, mentioned in the list above as well, dealing with 64-bit systems.

My Windows 7 virtual machine is a 64-bit system.

The $(ProgramFiles) used in the Visual Studio project template file automatically resolves that to "C:\Program Files (x86)", which is the wrong location.

Revit 2014 is installed in "C:\Program Files" with no x86 suffix.

Researching this, I found a resolution described and explained in this discussion on MSBuild and $(ProgramFiles) issue with 32/64 bits.

Unfortunately, that did not work at all. MSBuildExtensionsPath64 is not recognised in the Visual Studio wizard, at least in my simple use of it.

In the end, I simply checked what system variables are actually set on my system and found ProgramW6432 instead. That works fine.

Now both the C# and the VB versions work perfectly for me.

Revit Add-in Wizard Usage

I can simply install the wizard zip files in the appropriate locations, start up Visual Studio, create a new C# or VB Revit add-in project using the wizard default settings, and immediately hit F5 to start up Revit.exe in the debugger.

Revit is started up, my add-in is automatically loaded, and I am able to click on my new external command in the External Tools menu to test it immediately without having entered even one single byte of code myself.

The new command even executes in zero document state, although the default external command skeleton implementation throws an exception trying to access a property on the current UI document, which is null. It shows you that everything is working correctly right away, though.

Revit 2014 C# and VB Add-in Wizard Download

So, what are the appropriate locations, then? And where are the zip files?

Right here!

To install, simply copy the zip file of your choice to the matching Visual Studio project template folder in your local file system:

• Revit2014AddinWizardCs.zip – copy to
  [My Documents]\Visual Studio 2010\Templates\ProjectTemplates\Visual C#
• Revit2014AddinWizardVb.zip – copy to
  [My Documents]\Visual Studio 2010\Templates\ProjectTemplates\Visual Basic

I hope you find this useful and look forward to your suggestions for improvement.

What's New in the Revit 2014 API

Here is one post that I prepared well for in advance, by publishing the previous 'What's New in the API' sections two months back:

• What's New in the Revit 2010 API
• What's New in the Revit 2011 API
• What's New in the Revit 2012 API
• What's New in the Revit 2013 API

The information provided here is extracted from the document 'Revit Platform API Changes and Additions.docx' provided with the Revit SDK. It is also included in the 'What's New' section in the Revit API help file RevitAPI.chm.

The reason for copying it here on-line as well is to ensure that the valuable information provided is picked up by web searches. More and more people, myself included, perform a web search straight away, first thing, before even looking at the API documentation.

For more detailed information on the pointers provided below, please refer to the complete API documentation and developer's guide.

For a short summary of the main highlights, please refer to the Revit 2014 API overview, which also points to the complete materials from the Revit 2014 DevDays presentations:

• Presentation
• Recording
• Sample code

This document consists of three main sections:

• Major changes and renovations
• Major enhancements to the Revit API
• Small enhancements & interface changes

I hope this proves useful to you and you find the new API features as useful and exciting as I do!

Major Changes and Renovations

Document APIs

Document.Save()

Several modifications have been made to the Document.Save() methods.

• The methods now return void instead of boolean.
• Failures are signaled with specified documented exceptions.
• The new property SaveOptions.Compact allows the caller to specify if the OS should eliminate all dead data from the file on disk.

Document.SaveAs()

Several modifications have been made to the Document.SaveAs() functions.

• The methods now return void instead of boolean.
• Failures are signaled with specified documented exceptions.
• The new property SaveAsOptions.MaximumBackups identifies the maximum number of backups to keep on disk.
• The new property SaveAsOptions.Compact allows the caller to specify if the OS should eliminate all dead data from the file on disk.
• The new property SaveAsOptions.WorksharingOptions offers options specific to workshared files:
• WorksharingSaveAsOptions.SaveAsCentral
• WorksharingSaveAsOptions.OpenWorksetsDefault
• WorksharingSaveAsOptions.ClearTransmitted
• The property SaveAsOptions.Rename has been obsoleted.  The property previously had no effect, use of SaveAs will always modify the document in memory.

In addition, a new version of SaveAs() taking a ModelPath and SaveAsOptions has been introduced.  This offers capabilities similar in behavior to SaveAs(string, SaveAsOptions).

OpenOptions

New options are available in this class:

• OpenOptions.Audit

This Boolean option specifies whether to expand all elements, to check for corruption.  Defaults to false.

• OpenOptions.AllowOpeningLocalByWrongUser

This boolean option specifies whether a local file is allowed to be opened ReadOnly by a user other than its owner.

• OpenOptions.GetOpenWorksetsConfiguration()
• OpenOptions.SetOpenWorksetsConfiguration()

These methods access the WorksetConfiguration.   This class specifies which user-created worksets should be opened/closed when the document is opened.  Once an instance of this class is created, it can be further modified by calling available methods in any order.  It is a specification of a setting for model open; the methods of this class just adjust the specification, and do not themselves open or close worksets.

Only user-created worksets can be specified to be opened or closed.  All system worksets are automatically open.  An open workset allows its elements can be expanded and displayed. For a closed workset, Revit tries to not expand its elements, and to that end, does not display them. This is intended to help with performance by reducing Revit's memory footprint.

An application can determine how to populate this class by looking at workset information from a closed document.  This is done by calling

• WorksharingUtil.GetUserWorksetInfo()

This method returns a collection of WorksetPreview classes containing the workset id, unique id, owner, name and whether or not the workset is default.

Application.OpenDocumentFile(ModelPath, OpenOptions)

This method has been reimplemented.  While the signature has not changed, there are new options available to be set in OpenOptions. 

Failures are now signaled with specific documented exceptions.

Application.OpenDocumentFile(String)

This method has been reimplemented.  While the signature has not changed, failures are now signaled with specific documented exceptions.

UIApplication.OpenAndActivateDocument(ModelPath, OpenOptionsForUI)

The signature and the implementation of this method has changed.

• The class OpenOptionsForUI has been removed.
• The new signature is (ModelPath, OpenOptions, Boolean detachAndPrompt). 

If you wish to let the user answer interactively the prompt of whether to preserve or discard worksets when opening the documented detached from central, set the following values:

• OpenOptions.DetachFromCentralOption = DoNotDetach
• Boolean argument "detachAndPrompt" = true.

Failures are now signaled with specific documented exceptions.

UIApplication.OpenAndActivateDocument(String)

This method has been reimplemented.  Failures are now signaled with specific documented exceptions.

FilteredElementCollector

Iteration and element deletion

When an element is deleted active iterations over the document (via FilteredElementCollector) are now stopped. A new InvalidOperationException is thrown.  The iterator cannot proceed due to changes made to the Element table in Revit's database (typically, this can be the result of an Element deletion). This affects the use of FilteredElementIterator, FilteredElementIdIterator, and foreach loops over a FilteredElementCollector.

The exception can be triggered by direct calls to Document.Delete(), but also by other Revit APIs which change the document resulting in an element being deleted. In general it is best not to make any changes to the document while an iterator is running over the document.

The simplest workaround to fix existing code which encounters this error is to use one of:

• FilteredElementCollector.ToElements()
• FilteredElementCollector.ToElementIds()
• FilteredElementCollector.ToList<Type>() (LINQ method)

to get a standalone collection, then iterate that collection.  Even if elements are deleted from the document, the iteration of the already fetched collection can proceed.

Geometry APIs

Curve creation

New curve creation methods have been added as statics on the associated curve type:

• Curve.CreateTransformed()
• Line.CreateBound()
• Line.CreateUnbound()
• Arc.Create()
• Ellipse.Create()
• NurbSpline.Create()
• HermiteSpline.Create()

The older curve creation properties and methods are now obsolete:

• Curve.Transformed
• Line.Bound
• Line.Unbound
• Autodesk.Revit.Creation.Application.NewLine()
• Autodesk.Revit.Creation.Application.NewLineBound()
• Autodesk.Revit.Creation.Application.NewLineUnbound()
• Autodesk.Revit.Creation.Application.NewArc()
• Autodesk.Revit.Creation.Application.NewEllipse()
• Autodesk.Revit.Creation.Application.NewNurbSpline()
• Autodesk.Revit.Creation.Application.NewHermiteSpline()

Both the old and new curve creation routines are updated to consistently prevent creation of curves smaller than Revit's tolerance. This value is now exposed via:

• Application.ShortCurveTolerance

Some other adjustments have been made to the validation on specific curve creation routines, consult the documentation for details.

Curve utilities

The new methods:

• GetEndPoint()
• GetEndParameter()
• GetEndPointReference()

replace the indexed property utilities on Curve:

• EndPoint
• EndParameter
• EndPointReference

The setter for EndParameter is deprecated and code should be adjusted to call MakeBound(double, double) instead.

Edge utilities

The new methods:

• Edge.GetFace()
• Edge.GetEndPointReference()

replace:

• Edge.Face (property)
• Edge.EndPointReference (property)

Transform initialization

The new methods:

• Transform.CreateTranslation()
• Transform.CreateRotation()
• Transform.CreateRotationAtPoint()
• Transform.CreateReflection()

replace:

• Transform.Translation (property)
• Transform.Rotation (property)
• Transform.Reflection (property)

SketchPlane creation

The SketchPlane creation methods of Autodesk.Revit.Creation.ItemFactoryBase have been replaced.

• SketchPlane.Create(Document, Plane) replaces ItemFactoryBase.NewSketchPlane(Plane)
• SketchPlane.Create(Document, Reference) replaces ItemFactoryBase.NewSketchPlane(Reference)
• Either method may be appropriate to replace calls to ItemFactoryBase.NewSketchPlane(PlanarFace), depending on whether the goal is a sketch plane tied to a Revit geometric reference, or a sketch plane fixed in space to a given plane.

A new SketchPlane creation has been added:

• SketchPlane.Create(ElementId)

This creates a SketchPlane from a grid, reference plane, or level.

SketchPlane also now has two more methods to get related properties of the SketchPlane element.

• SketchPlane.GetPlane() Returns the corresponding Plane.
• SketchPlane.GetPlaneReference()  Returns a reference to this element as a plane.

BeamSystem creation

The BeamSystem creation methods of Autodesk.Revit.Creation.Document have been replaced:

• BeamSystem.Create(Document, IList<Curve>, SketchPlane, int) replaces Document.NewBeamSystem(CurveArray, SketchPlane)
• BeamSystem.Create(Document, IList<Curve>, SketchPlane, XYZ, bool) replaces Document.NewBeamSystem(CurveArray, SketchPlane, XYZ, bool)
• BeamSystem.Create(Document, IList<Curve>, Level, int, bool) replaces Document.NewBeamSystem(CurveArray, Level)
• BeamSystem.Create(Document, IList<Curve>, Level, XYZ, bool) replaces Document.NewBeamSystem(CurveArray, Level, XYZ, bool)

Truss creation

The Truss creation method of Autodesk.Revit.Creation.Document have been replaced.

• Truss.Create(Document, ElementId, ElementId, Curve) replaces Document.NewTruss(TrussType, SketchPlane, Curve)

Family Symbol API

Family symbols that are not used in the document are now inactive until they are used.  A symbol's geometry will be empty and should not be accessed until it is active.  To test if a symbol is active, use

• FamilySymbol.IsActive()

To activate an inactive family symbol, use

• FamilySymbol.Activate()

Units API

The API for Units in Revit has been expanded and changed. The methods

• Document.GetUnits()
• Document.SetUnits()

allow interaction with the units of a document.  The Units class provides access to data such as

• DecimalSymbol
• DigitGroupingAmount
• DigitGroupingSymbol
• FormatOptions

The FormatOptions class provides access to data including:

• Rounding
• Accuracy
• DisplayUnits
• SuppressLeadingZeros
• SuppressTrailingZeros
• SuppressSpaces

LabelUtils.GetLabelFor() has been enhanced so that it can now return the user-visible name for a UnitSymbolType.

Unit Formatting and Parsing

The methods:

• UnitFormatUtils.FormatValueToString()
• UnitFormatUtils.TryParse()

provide the ability to format a value into a string based on formatting options and to parse a formatted string (including units) into a value if possible.

Unit Conversion

The new class UnitUtils contains methods to convert between unit types:

• UnitUtils.Convert() – Converts a value from one unit type to another, such as square feet to square meters.
• UnitUtils.ConvertFromInternalUnits() – Converts a value from Revit's internal unit type.
• UnitUtils.ConvertToInternalUnits() – Converts a value to Revit's internal unit type.

View API changes

Viewport.Create behavioral change

The method

• Viewport.Create()

previously did not consistently align the center of the Viewport with the point supplied.  This has been changed, and now the center will be aligned with the input point.  This should allow easier alignment of multiple viewports on the same sheet.

View.ViewName obsolete

The property

• View.ViewName

is now obsolete.  View.Name can be used.

View.SetVisibility()

The name of this method has now been correctly capitalized.

ViewSchedule changes

ViewSchedule is now a child of TableView.   All previously existing ViewSchedule API is still valid, but TableView also brings in a set of APIs related to:

• Table sections (header and body)
• Table formatting
• The contents of individual table cells

There are methods on TableView (and its constituent TableData and TableSectionData class) that are useful for Electrical Panel Schedules and some varieties of specialized schedules but forbidden for use with standard Revit tabular schedules generated from Revit content (e.g. InsertRow(), RemoveRow()).   Use of these functions on standard Revit schedules will result in an exception.

Some new members were introduced on schedule related classes:

• ScheduleField.SetStyle()
• ScheduleField.GetStyle()
• ScheduleField.IsOverridden
• ScheduleField.ResetOverrides()
• ScheduleField.GetFormatOptions()
• ScheduleField.SetFormatOptions()

relate to the style and formatting applied to schedule columns, and:

• ScheduleField.IsCalculatedField
• ScheduleField.IsCombinedParameterField
• ScheduleField.HasSchedulableField

relate to information about the type of a field.

The new members:

• ViewSchedule.GetFontId()
• ViewSchedule.AddFontId()

provide access to fonts stored in the table and applied to cells.

The new members:

• ViewSchedule.GroupHeaders()
• ViewSchedule.UngroupHeaders()
• ViewSchedule.CanGroupHeaders()
• ViewSchedule.CanUngroupHeaders()

affect header grouping in the schedule.

The new method:

• ViewSchedule.GetTableData()

returns the object which provides access to the sections of the table.

Materials API changes

Applying visual materials

The method

• Material.SetRenderAppearance()

has been deprecated.  The Render appearance properties should be set via the related ApperanceAssetElement. 

Use the new property:

• Material.AppearanceAssetId

to assign the element to the material.

AppearanceAssetElements can be found via element filtering – they expose the following members:

• AppearanceAssetElement.Create() – creates a new asset element for a given rendering Asset and name.
• AppearanceAssetElement.GetAppearanceAssetElementByName() – gets an asset element handle given the name.
• AppearanceAssetElement.SetRenderingAsset() – Sets the rendering Asset to the element

AssetProperty changes

AssetProperty no longer inherits from APIObject. 

New subclasses of AssetProperty are exposed:

• AssetPropertyList – a property consisting of a list of AssetProperty members. 
• AssetPropertyFloatArray – a property consisting of an array of float values.
• AssetPropertyUInt64 – a property of UInt64 value.
• AssetPropertyInt64 – a property of Int64 value.

Some of the return values of AssetProperty.GetTypeName() have been changed as shown here listing input argument, old return and new return:

• APT_Double – "Double1" – "Double"
• APT_DoubleArray2d – "Double2" – "DoubleArray2d"
• APT_DoubleArray3d – "Double3" – "DoubleArray3d"
• APT_DoubleArray4d – "Double4" – "DoubleArray4d"
• APT_Asset – "RenderingAsset" – "Asset"
• APT_FloatArray – "Float3" – "FloatArray"

UI API changes

External commands now supported from Project Browser as active view

API commands and macros are now enabled when the Revit active view is the Project Browser.  

• If there are actively selected elements in the Project Browser, these will be returned from UIDocument.Selection
• However, add-ins cannot prompt for interactive selection when the Project Browser is the active view.
• The enumerated type ViewType now has separate entries for ProjectBrowser and SystemBrowser to allow applications to deal with situations where the Project Browser is active.  These view types used to be returned as ViewType.Internal, so code which keys of off ViewType.Internal may need to be updated to also deal with these new types.

Note that API commands are still disabled when the active view is the MEP system browser. 

Beam and Brace Parameters changes

Revit 2014 includes several changes to control the position of structural framing members like beams and braces.  These changes do not affect the API members but can be accessed via parameters. 

Start/End Extension & Cutback

There are new extension and cutback parameters assigned to Beam and Brace elements.

• BuiltInParameter.START_EXTENSION
• BuiltInParameter.END_EXTENSION
• BuiltInParameter.START_JOIN_CUTBACK
• BuiltInParameter.END_JOIN_CUTBACK

Note: In some families “Start Extension” and “End Extension” family parameters may also exist but it is recommended to use instead new the new built-in parameters.

These parameters work as follows:

• If the Beam or Brace element end doesn’t belong to a join Revit uses the new parameters “Start Extension" or "End Extension”.  Assigning positive values to these parameters lengthens the element).
• If the Beam or Brace element belongs to a join Revit uses the parameters “Start Join Cutback" or "End Join Cutback”.  Assigning positive values to these parameters shortens the element).

In certain cases it may be difficult to detect if an element node belongs to join or not. Therefore, it may be advisable to set both groups of parameters via the API. With both groups of parameters will be set for element, Revit automatically detects which should be applied to the structural element.

Justifications

There are new justification parameters assigned to Beam and Brace elements. The new set of parameters provides more options to manipulate the physical element in relation to its analytical curve.

Here is a list of parameters and the permitted values for each:

• BuiltInParameter.YZ_JUSTIFICATION – YZJustificationOption.Uniform, YZJustificationOption.Independent
• BuiltInParameter.Y_JUSTIFICATION – YJustification.Left, YJustification.Center, YJustification.Origin, YJustification.Right
• BuiltInParameter.Y_OFFSET_VALUE – double
• BuiltInParameter.Z_JUSTIFICATION – ZJustification.Top, ZJustification.Center, ZJustification.Origin, ZJustification.Bottom
• BuiltInParameter.Z_OFFSET_VALUE – double
• BuiltInParameter.START_Y_JUSTIFICATION – YJustification.Left, YJustification.Center, YJustification.Origin, YJustification.Right
• BuiltInParameter.START_Y_OFFSET_VALUE – double
• BuiltInParameter.START_Z_JUSTIFICATION – ZJustification.Top, ZJustification.Center, ZJustification.Origin, ZJustification.Bottom
• BuiltInParameter.START_Z_OFFSET_VALUE – double
• BuiltInParameter.END_Y_JUSTIFICATION – YJustification.Left, YJustification.Center, YJustification.Origin, YJustification.Right
• BuiltInParameter.END_Y_OFFSET_VALUE – double
• BuiltInParameter.END_Z_JUSTIFICATION – ZJustification.Top, ZJustification.Center, ZJustification.Origin, ZJustification.Bottom
• BuiltInParameter.END_Z_OFFSET_VALUE – double

Previously only Beam elements had any justification parameters.

In Revit 2014, Beams as well as Braces share this set of built-in justification parameters.

The following list shows a mapping from old deprecated justification parameters to new ones:

• BEAM_H_JUSTIFICATION – Y_JUSTIFICATION
• BEAM_V_JUSTIFICATION – Z_JUSTIFICATION
• BEAM_V_JUSTIFICATION_OTHER_VALUE (valid only for Other value set to BEAM_V_JUSTIFICATION) – Z_OFFSET_VALUE (valid for all Z_JUSTIFICATION values)

Old beam parameters can still be used.  When set, they will be used to recalculate the new parameters.  It is strongly recommended to use new justification parameters instead of old ones, because in some cases the old parameters may be not sufficient to correctly describe the element position (for example, when justification is set independently on either end of the member).

Divided surface changes

Divided Surface API

The class DividedSurfaceData and the associated method Element.GetDividedSurfaceData() have been replaced.  The new methods to access DividedSurfaces applied to elements are:

• DividedSurface.GetReferencesWithDividedSurface()
• DividedSurface.GetDividedSurfaceForReference()

The method:

• Autodesk.Revit.Creation.Document.NewDividedSurface()

has been replaced by:

• DividedSurface.Create()

Point clouds

Revit 2014 includes a new point cloud engine.  This new engine supports .rcp and .rcs file formats.  The introduction of this new engine has led to several changes in the client API around Point Cloud elements.

PointCloudType.Create()

The method

• PointCloudType.Create()

no longer supports input of .pcg files to directly create a new PointCloudType.  .pcg files can be indexed to create matching .rcs files, but this does not happen automatically when using this method.

This method does support creation of PointCloudTypes from .rcp or .rcs files, or from custom formats supplied by the Point Cloud Engine API.

PointCloudInstance.GetPoints()

The method

• PointCloudInstance.GetPoints(PointCloudFilter filter, int numPoints)

has been deprecated and replaced by

• PointCloudInstance.GetPoints(PointCloudFilter filter, double averageDistance, int numPoints)

The new averageDistance argument is the desired average distance between "adjacent" cloud points (in Revit units of length).  The smaller the averageDistance the larger number of points will be returned up to the numPoints limit.  Specifying this parameter makes the actual number of points returned for a given filter independent of the density of coverage produced by the scanner. This average distance parameter is only used when extracting points from .rcs or .rcp point clouds, and is not used when extracting from .pcg point clouds or custom point clouds from the Point Cloud Engine API.

Point cloud overrides

The classes

• PointCloudOverrides
• PointCloudOverrideSettings
• PointCloudColorSettings

allow read and write access to point cloud override settings assigned to a given view.  Overrides can be applied to an entire point cloud instance, or to specific scans within that instance. Options for the overrides include making the cloud non-visible, setting it to a fixed color, or to color gradients based on elevation, normals, or intensity.

The property

• PointCloudInstance.SupportsOverrides

identifies point clouds which support override settings (clouds which are based on .rcp or .rcs files).

Point cloud scans

The method

• PointCloudInstance.GetScans()

returns a list of scans contained within the .rcp point cloud.  Scan names can be used to set visibility and fixed color overrides independently for each scan in the PointCloudInstance.

IFC API changes

IFC export now External Service

The capability to override IFC export is now managed as an External Service.  As such, the explicit interfaces in ExporterIFCRegistry are no longer needed and have been marked obsolete.  It is now possible to register more than one external IFC export implementation in the same session, and manage the active implementation using the methods of the SingleServerService wrapper to IFC export.

IFC APIs moved to new assembly

Most IFC API classes have been moved from RevitAPI.dll to a new assembly: RevitAPIIFC.dll. The classes moved include all members of the Autodesk.Revit.DB.IFC namespace which enable development of a custom IFC exporter.

Any Add-In using any of the migrated APIs needs to reference the new DLL and rebuild to work in Revit 2014.

Note that the APIs to invoke an IFC export and import:

• Document.Export(String, String, IFCExportOptions)
• Application.OpenIFCDocument(String)

and the related options class have not moved. Applications which export or import IFC files but do not provide custom implementations do not need to make changes.

PrintParameters

The property HideUnreferencedViewTages was renamed to HideUnreferencedViewTags. 

Obsolete API Removal

API classes and methods previously marked Obsolete in Revit 2013 or earlier have been removed from the API.

Classes removed

• CurtainCellSetIterator and CurtainCellSet – Use generic .NET collection classes instead.
• PipeMaterialType – replaced by Material
• Batch creation argument class types – batch creation is not needed with changes to Revit API regeneration
• ProfiledWallCreationData
• RectangularWallCreationData
• RoomCreationData
• TextNoteCreationData
• Subclasses of ConnectorElement have been removed, access these elements through the parent class
• ElectricalConnector
• ElectricalConnector.SystemType – query the parameter RBS_ELEC_CIRCUIT_TYPE on ConnectorElement and cast to ElectricalSystemType
• DuctConnector
• DuctConnector.LinkedConnector – replaced by ConnectorElement.GetLinkedConnectorElement() and ConnectorElement.SetLinkedConnectorElement()
• DuctConnector.SystemType – query the parameter RBS_DUCT_CONNECTOR_SYSTEM_CLASSIFICATION_PARAM on ConnectorElement and cast to DuctSystemType
• PipeConnector
• PipeConnector.LinkedConnector replaced by ConnectorElement.GetLinkedConnectorElement() and ConnectorElement.SetLinkedConnectorElement()
• PipeConnector.SystemType – query the parameter RBS_PIPE_CONNECTOR_SYSTEM_CLASSIFICATION_PARAM on ConnectorElement and cast to PipeSystemType

Methods and Properties removed

Autodesk.Revit.Creation namespace

Application

• NewMaterialSet() – replaced by .net Generic collection classes
• NewElementArray() – replaced by .net Generic collection classes

Document

• NewAnnotationSymbol(XYZ ,AnnotationSymbolType ,View) – replaced by NewFamilyInstance(XYZ, FamilySymbol, View)
• NewAreaViewPlan(String,Level,AreaElemType) – replaced by ViewPlan.CreateAreaPlan()
• NewCurtainSystem(ReferenceArray,CurtainSystemType) – replaced by NewCurtainSystem2(ReferenceArray, CurtainSystemType)
• NewElectricalSystem(ElementSet,ElectricalSystemType) – replaced by NewElectricalSystem(ICollection<ElementId>, ElectricalSystemType)
• NewFamilyInstances(List<FamilyInstanceCreationData>) – replaced by NewFamilyInstances2(List<FamilyInstanceCreationData>)
• NewGroup(ElementSet) – replaced by NewGroup(System.Collections.Generic.ICollection<Autodesk.Revit.DB.ElementId>)
• NewRooms(Phase, Int32) – replaced by NewRooms2(Phase, Int32)
• NewRooms(Level,Phase) – replaced by NewRooms2(Level, Phase)
• NewRooms(Level) – replaced by NewRooms2(Level)
• NewRooms(List<RoomCreationData>) – there is no single equivalent that creates multiple rooms, this is not needed with Revit API control over regeneration
• NewSpaces(Phase,Int32) – replaced by NewSpaces2(Phase, Int32)
• NewSpaces(Level,Phase,View) – replaced by NewSpaces2(Level, Phase, View)
• NewTextNotes(List<TextNoteCreationData>) – replaced by NewTextNote()
• NewViewPlan(String,Level,ViewPlanType) – replaced by ViewPlan.Create(Document, ElementId, ElementId)
• NewView3D(XYZ) – replaced by View3D.CreateIsometric(Document, ElementId)
• NewViewSection(BoundingBoxXYZ) – replaced by ViewSection.CreateDetail()
• All Wall creation methods replaced by equivalent Wall.Create() methods:
• NewWall(CurveArray,WallType,Level,Boolean,XYZ)
• NewWall(CurveArray,WallType,Level,Boolean)
• NewWall(CurveArray,Boolean)
• NewWall(Curve,WallType,Level,Double,Double,Boolean,Boolean)
• NewWall(Curve,Level,Boolean)
• NewWalls(List<ProfiledWallCreationData> dataList) – there is no single equivalent that creates multiple walls, this is not needed with Revit API control over regeneration
• NewWalls(List<RectangularWallCreationData> dataList) – there is no single equivalent that creates multiple walls, this is not needed with Revit API control over regeneration

FamilyItemFactory

• NewDuctConnector(Reference,DuctSystemType) – replaced by ConnectorElement.CreateDuctConnector()
• NewPipeConnector(Reference,PipeSystemType) – replaced by ConnectorElement.CreatePipeConnector()
• NewElectricalConnector(Reference,ElectricalSystemType) – replaced by ConnectorElement.CreateElectricalConnector()

Autodesk.Revit.DB namespace

BaseArray

• CopyMembers – replaced by GetCopiedMemberIds()
• OrigMembers – replaced by GetOriginalMemberIds()

CurtainGrid

• UnlockedMullions – replaced by GetUnlockedMullionIds()
• Mullions – replaced by GetMullionIds()
• Cells – replaced by GetCurtainCells()
• UnlockedPanels – replaced by GetUnlockedPanelIds()
• Panels – replaced by GetPanelIds()
• VGridLines – replaced by GetVGridLineIds()
• UGridLines – replaced by GetUGridLineIds()

CurveElement

• LineStyles – replaced by GetLineStyleIds()

Document

• Delete(ElementSet elements) – replaced by Delete(System.Collections.Generic.ICollection<Autodesk.Revit.DB.ElementId> elementIds)
• WorksharingCentralFilename – replaced by ModelPathUtils.ConvertModelPathToUserVisiblePath(Document.GetWorksharingCentralModelPath())
• PrintSettings – replaced by GetPrintSettingIds()
• Element/get_Element – replaced by GetElement method

Element

• PhaseDemolished – replaced by DemolishedPhaseId
• PhaseCreated – replaced by CreatedPhaseId

FamilyInstance

• GetCopings() – replaced by GetCopingIds()
• SetCopings(ElementSet) – replaced by SetCopingIds(ICollection<ElementId> cutters)
• SubComponents – replaced by GetSubComponentIds()

Floor

• SpanDirectionSymbols – replaced by GetSpanDirectionSymbolIds()

GeometryElement

• Objects – replaced by GetEnumerator()

Group

• Ungroup() – replaced by UngroupMembers()
• Members – replaced by GetMemberIds()

LinearArray

• CopyMembers – replaced by GetCopiedMemberIds()
• OrigMembers – replaced by GetOriginalMemberIds()

Material

• GetMaterialAspectPropertySet(MaterialAspect) – replaced by GetStructuralAssetId() and GetThermalAssetId()
• SetMaterialAspect(MaterialAspect,ElementId,Boolean) – replaced by SetStructuralAssetId() and SetThermalAssetId()
• SetMaterialAspectToIndependent(MaterialAspect) – replaced by SetStructuralAssetId() and SetThermalAssetId()

MEPSystem

• Remove(ElementSet) – replaced by Remove(ICollection<ElementId>)

Part

• ParentDividedElementId – no replacement, concept is removed from Revit
• OriginalDividedElementId – no replacement, concept is removed from Revit
• GetDividedParents() – no replacement, concept is removed from Revit

PartMaker

• IsElementDivided(ElementId elemId) – replaced by IsSourceElement(ElementId)
• GetDividedElementIds() – replaced by GetSourceElementIds()
• SetDividedElementIds(ICollection<ElementId>) – replaced by SetSourceElementIds(ICollection<ElementId>)

PartUtils

• AreElementsValidForDivide(Document, ICollection<ElementId>) – replaced by ArePartsValidForDivide(Document, ICollection<ElementId>)
• AreElementsValidIntersectingReferences(Document, ICollection<ElementId>) – replaced by PartMakerMethodToDivideVolumes.AreElementsValidIntersectingReferences(Document, ICollection<ElementId>)
• IsValidSketchPlane(Document, ElementId) – replaced by PartMakerMethodToDivideVolumes.IsValidSketchPlane(Document, ElementId)
• SetOffsetForIntersectingReference() – replaced by PartMakerMethodToDivideVolumes.SetOffsetForIntersectingReference()
• GetOffsetForIntersectingReference() – replaced by PartMakerMethodToDivideVolumes.GetOffsetForIntersectingReference()
• PartMakerUsesReference() – replaced by PartMakerMethodToDivideVolumes.PartMakerUsesReference()
• IsMaxDivisionDepthReached(Document, ElementId) – no replacement, concept is removed from Revit
• GetDividedParents(Part) – no replacement, concept is removed from Revit
• PlanTopology
• Rooms – replaced by GetRoomIds()

PropertySetElement

• Create(Document, MaterialAspect) – replaced by Create(Document, StructuralAsset)

RadialArray

• CopyMembers – replaced by GetCopiedMemberIds()
• OrigMembers – replaced by GetOriginalMemberIds()

SpatialFieldManager

• UpdateSpatialFieldPrimitive(Int32,FieldDomainPoints,FieldValues) – replaced by UpdateSpatialFieldPrimitive(Int32, FieldDomainPoints, FieldValues, Int32)
• SetUnits(IList<string>, IList<double>) – replaced by AnalysisResultSchema.SetUnits() and SetResultSchema()

View

• ApplyTemplate(View viewTemplate) – replaced by ViewTemplateId/ApplyViewTemplateParameters(View viewTemplate)
• Hide(ElementSet elemSet) – replaced by HideElements(System::Collections::Generic::ICollection<Autodesk::Revit::DB::ElementId^>^ elementIdSet)
• Unhide(ElementSet elemSet) – replaced by UnhideElements(System::Collections::Generic::ICollection<Autodesk::Revit::DB::ElementId^>^ elementIdSet)

View3D

• EyePosition – replaced by ViewOrientation3D.EyePosition/View.Origin
• ViewSheet
• AddView(View,UV) – replaced by Viewport.Create(Document, ElementId, ElementId, XYZ)

Autodesk.Revit.DB.Plumbing namespace

PipeType

• Roughness – replaced by Segment.Roughness
• Material – replaced by PipeSegment.MaterialId

Autodesk.Revit.DB.Structure namespace

AnalyticalModel

• CanDisable() – no replacement, concept removed from Revit
• IsValidAnalyticalProjectionType(AnalyticalDirection,AnalyticalProjectionType) – replaced by IsValidProjectionType(AnalyticalElementSelector, AnalyticalDirection, AnalyticalProjectionType)

AreaReinforcement

• NumBarDescriptions – replaced by GetRebarInSystemIds()
• BarDescription – replaced GetRebarInSystemIds()
• Curves – replaced by GetCurveElementIds()

BeamSystem

• GetAllBeams() – replaced by GetBeamIds()

PathReinforcement

• BarDescription – replaced by GetRebarInSystemIds()
• Curves – replaced by GetCurveElementIds()

Rebar

• GetCenterlineCurves(Boolean) – replaced by GetCenterlineCurves(Boolean,Boolean,Boolean)
• DistributionPath – replaced by GetDistributionPath()
• RebarShape – replaced by RebarShapeId
• Host – replaced by Rebar.GetHostId() and SetHostId(Document, ElementId)
• BarType – replaced by Element.GetTypeId() and Element.ChangeTypeId(ElementId)

Major Enhancements to the Revit API

Worksharing API enhancements

Reload Latest

The method:

• Document.ReloadLatest()

Fetches changes from central (due to one or more synchronizations with central and merges them into the current session. After this call finishes, use

• Document.HasAllChangesFromCentral()

to confirm that there were no Synchronizations with Central performed during execution of ReloadLatest.

Synchronize with Central

The method:

• Document.SynchronizeWithCentral()

performs a reload latest until the model in the current session is up to date and then saves changes back to central.  A save to central is performed even if no changes were made.

Element ownership

The following methods affect element and workset ownership:

• WorksharingUtils.CheckoutElements – Obtains ownership for the current user of as many specified elements as possible.
• WorksharingUtils.CheckoutWorksets – Obtains ownership for the current user of as many specified worksets as possible.
• WorksharingUtils.RelinquishOwnership – Relinquishes ownership by the current user of as many specified elements and worksets as possible, and grants element ownership requested by other users on a first come, first served basis.

Create new local

The new method:

• WorksharingUtil.CreateNewLocal()

takes a path to a central model and copies the model into a new local file for the current user.

Enable Worksharing

The new method Document.EnableWorksharing will enable worksharing in a project.

Enhancements to interactions with links

Several improvements have been made to increase API functionality when working with RVT links.

Identifying links

The property:

• Document.IsLinked

identifies if a document is in session because it is a linked Revit file.

Obtaining linked documents

The method:

• RevitLinkInstance.GetLinkedDocument()

gets the document that corresponds to an Revit Link instance.

Link creation

Two functions have been added to RevitLinkOptions, used to specify options for RevitLinkType.Create. 

• RevitLinkOptions.GetWorksetConfiguration()
• RevitLinkOptions.SetWorksetConfiguration()

This allows the user to specify which worksets should be opened when creating and loading a new Revit link.

Link load and unload

The methods

• RevitLinkType.Load()
• RevitLinkType.LoadFrom()
• RevitLinkType.Unload()

allow a link to be loaded or unloaded, or to be loaded from a new location.   These methods regenerate the document.  The document's Undo history will be cleared by these methods.  As a result, this function and others executed before it cannot be undone.  All transaction phases (e.g. transactions, transaction groups and sub-transactions) that were explicitly started must be finished prior to calling this method.

Link shared coordinates

The methods:

• RevitLinkType.SavePositions()
• RevitLinkType.HasSharedCoordinatesChanges()

support save of shared coordinates changes back to the linked document. While this operation does not clear the document's undo history, you will not be able to undo this specific action, since it saves the link's shared coordinates changes to disk.

Link path type

The property:

• RevitLinkType.PathType

allows read and modification of the path type associated with a link. 

Conversion of geometric references

The new APIs:

• Reference.LinkedElementId
• Reference.CreateLinkReference(RevitLinkInstance)
• Reference.CreateReferenceInLink()

allow conversion between Reference objects which reference only the contents of the link and Reference objects which reference the host. This allows an application, for example, to look at the geometry in the link, find the needed face, and convert the reference to that face into a reference in the host suitable for use to place a face-based instance. Also, they would allow you to obtain a reference in the host (e.g. from a dimension or family) and convert it to a reference in the link, suitable for use in Element.GetGeometryObjectFromReference().

Room tag creation from linked rooms

The new method:

• NewRoomTag(LinkElementId roomId, UV point, ElementId viewId)

can create room tags in Revit Links.

Picking in links

PickObject() and PickObjects() now allow selection of elements in RVT Links.

Views & Display

Graphic Display options

These new members expose read and write of graphic display options:

• View.GetBackground()
• View.SetBackground()
• View.ShadowIntensity
• View.SunlightIntensity
• View.SurfaceTransparency
• View.ShowEdges
• View.ShowSilhouettes
• View.SilhouetteLineStyleId

Category classes override

Display of category classes may be overridden by the user.  The new properties:

• View.AreModelCategoriesHidden
• View.AreAnnotationCategoriesHidden
• View.AreAnalyticalModelCategoriesHidden
• View.AreImportCategoriesHidden

allow an application to determine if a class of categories has been completely hidden.  Note that Category.Visible[View] and View.GetVisibility(Category) does not look to the category classes when it returns the individual visibility status.

Category override

Display of categories can be overridden. This can be done with the new class OverrideGraphicSettings and the new View methods:

• SetCategoryOverrides
• GetCategoryOverrides
• IsOverrideValidForCategory
• IsCategoryOverridable

Element Override

Display of elements can be overridden with the new methods:

• View.GetElementOverrides
• View.SetElementOverrides.

View Filters

A new set of methods on the View class allow getting, setting, adding, and removing filters. Filters can be created using the ParameterFilterElement class and its Create method which existed in previous versions of the Revit API.

Non-rectangular crop region

Views can now be assigned a crop region which is non-rectangular.  The new View members:

• View.GetCropRegionShapeManager()
• View.GetCropRegionShapeManagerForReferenceCallout()
• View.GetReferenceCallouts()

provide access to a ViewCropRegionShapeManager for the view or for a displayed reference callout.

This class allows access and modification of the crop region shape:

• ViewCropRegionShapeManager.GetCropRegionShape()
• ViewCropRegionShapeManager.SetCropRegionShape()
• ViewCropRegionShapeManager.IsCropRegionShapeValid()
• ViewCropRegionShapeManager.RemoveCropRegionShape()
• ViewCropRegionShapeManager.ShapeSet
• ViewCropRegionShapeManager.Valid

The properties:

• View.CropBoxActive
• View.CropBoxVisible

also apply to non-rectangular crop regions which may be assigned to a given view.

Viewport

The new property

• Viewport.Rotation

controls the rotation of the viewport on the sheet.

The new method

• Viewport.MoveCenterTo() 

moves the viewport so that the center of the box outline (excluding the viewport label) is at a given point.

The new method

• Viewport.GetBoxCenter()

returns the center of the outline of the viewport on the sheet, excluding the viewport label.

Exploded Views

The new DisplacementElement class can be used to cause elements to appear displaced from their actual location to create views such as this one where the roof has been moved in the positive Z direction. The DisplacementPath class creates an annotation that depicts the movement of the element from its actual location to its displaced location.

Revisions on sheets

The new methods:

• ViewSheet.GetAllProjectRevisionIds()
• ViewSheet.GetAdditionalProjectRevisionIds()
• ViewSheet.SetAdditionalProjectRevisionIds()

provide access to the ids of project revision elements associated to a particular sheet.  GetAllProjectRevisionIds() returns project revisions ordered from lowest to highest by project revision sequence number.  The results include revisions associated to a revision cloud visible on the sheet and revisions that have been additionally included using the Revisions On Sheet parameter.   GetAdditionalProjectRevisionIds() and SetAdditionalProjectRevisionIds() access specifically the additional revisions added using the Revisions On Sheet parameter.

Note that there is no special class for project revision elements, but that they can be accessed as Elements by filtering on category BuiltInCategory.OST_Revisions.

User interface customization

UIView

Zoom operations

The new methods:

• UIView.ZoomToFit()
• UIView.ZoomSheetSize()
• UIView.Zoom(double zoomFactor)

provide shortcuts to quickly adjust the zoom of the graphical view window.

Close view

The new method:

• UIView.Close()

closes a visible view window. Note that the last open view for a given document cannot be closed by this method.

PreviewControl

The new property:

• PreviewControl.UIView

returns a UIView handle to the preview view. This allows an application to manipulate the zoom and pan settings of the preview view.

The new property:

• PreviewControl.ScrollbarVisibility

accesses the visibility setting for the preview view scrollbars.

Command API

Command event

The event

• AddInCommand.BeforeExecuted

occurs before the command associated with an AddInCommandBinding executes.  This event is read-only, an application can react to this event but cannot make changes to documents, or affect the invocation of the command in any way.

Command posting

The method

• UIApplication.PostCommand()

posts a command to Revit.  Revit will invoke it when control returns from the current API context.   Only certain commands can be posted using this method:

1. Commands listed in the Autodesk.Revit.UI.PostableCommand enumerated type
2. External commands created by any add-in

This restriction prevents posting of contextual commands (because Revit's command framework cannot directly access the accessibility of some contextual commands).

Note that only one command may be posted to Revit at a given time.  If a second command is posted from any API application, the method throws an InvalidOperationException.

The command must be accessible to be executed.  This is determined only at the point where Revit returns from the API context, and therefore a failure to execute the command because the command is not currently accessible will not be reported directly back to the application that posted the command.

To use this API, the application must obtain a RevitCommandId handle for the command.  This can be done using either

• RevitAddInCommand.LookupCommandId(String)
• RevitAddInCommand.LookupPostableCommandId(PostableCommand)

The method

• UIApplication.CanPostCommand

identifies if the given command can ever be posted (that is, it is a member of PostableCommand or an external command).  It does not identify the command can be posted at the given timeframe (that is, it will not attempt to determine if the command is currently accessible). 

Dockable Dialog Panes

Revit now allows addins to register WPF dialogs to dock into the top, left, right, and bottom of the main Revit window, as well as to be added as a tab to an existing system pane, such as the project browser.  Dialogs can be registered with UIApplication.RegisterDockablePane and a user-implementation of the IDockablePaneProvider interface.  Dockable panes can later be retrieved, shown, and hidden through UIApplication.GetDockablePane() and DockablePane.Show() and Hide().

Dimensions & annotations API

Multi-reference annotations for rebar

Revit now supports annotations pointing to more than one reference, consisting of a dimension and associated tag These annotations can be used to label and dimension Rebar elements, and are labeled in the user interface as “Multi-rebar annotations.”

The API exposes this through:

• MultiReferenceAnnotation – the annotation object instance. This class includes a reference to the associated dimension and tag element.
• MultiReferenceAnnotationType – the annotation type.  The type specifies the tag and dimension types to be used in the multi-reference annotation, as well as associated display settings.
• MultiReferenceAnnotationOptions – an options class used to create a new MultiReferenceAnnotation, including specification of the associated elements and options for the dimension and tag placement.
• IndependentTag.MultiReferenceAnnotationId  – returns the ElementId of the MultiReferenceAnnotation that owns a tag.
• Dimension.MultiReferenceAnnotationId – returns the ElementId of the MultiReferenceAnnotation that owns a dimension.

Dimension alternate units

New properties of DimensionStyle provide access to alternate units settings:

• DimensionStyle.AlternateUnits
• DimensionStyle.GetAlternateUnitsFormatOptions()
• DimensionStyle.SetAlternateUnitsFormatOptions()
• DimensionStyle.AlternateUnitsPrefix
• DimensionStyle.AlternateUnitsSuffix

Dimension unit type

The property:

• DimensionStyle.UnitType

returns the type of units supported by this dimension style (length, angle, or slope).

Add-ins and macros

Automatic load of add-ins without restarting Revit

Revit now automatically loads addins from newly added .addin manifest files without restarting Revit.  

After placing a new .addin manifest file into one of the dedicated addins folders, the running Revit session will attempt to load the corresponding addin.  Loaded ExternalCommands will be added to the External Tools pulldown menu.  ExternalApplication and ExternalDBApplication OnStartup methods will be executed upon loading.  An addin's installer may leverage this feature – but it must do so by creating the new .addin file at the end of installation to the dedicated Revit addin folders (the installer must ensure that the addin's assembly is already deployed to the target machine and the assembly path can be resolved in the add-in manifest file). 

Add-ins may decline the ability for Revit to load the .addin in the middle of a session.  To decline this options, add an tag (set to “NO”) in the add-in manifest file. 

Note that when Revit starts an add-in in the middle of the session, some add-in logic may not function identically because of the different interactions with the session.  Specifically:

• If the application's goal is to prevent something from happening, the application may not be able to handle the fact that this activity has already happened in the existing session.
• If the application's goal is to manage external information in synch with documents loaded in the session, the application may not be able to handle documents that were loaded before the application started.
• If the application's logic depends on the ApplicationInitialized event, this event has already been called before the add-in was loaded.

Also, some add-ins may not be able to fully initialize when loading in the middle of the session.  This is because some activities must take place at the start of the Revit session:

• Creation of custom failure definitions
• Establishment of a system-wide IFailureProcessor to handle all failures.
• Registering ExternalServices.

Revit also offers a new UI API method

• UIApplication.LoadAddIn()

to programmatically load the add-in(s) listed in the provided add-in manifest file.   Typically, this API would not be needed because Revit is already loading new .addin files automatically.

MacroManager API

Revit now support an API for listing, creating, removing, editing, debugging, and running macros through several supporting classes and enums

• MacroManager
• Available at the DB.Document or ApplicationServices.Application level; manages the querying, creation, and removal of macro modules
• UIMacroManager
• Available at the UIDocument or UIAppliciation level, manages adding, removing, and editing UI-level modules.
• MacroModule
• Manages the querying, creation, removal, and running of specific macro methods
• ModuleSettings
• A collection of top-level properties of a MacroModule
• Macro
• Represents a single, runnable macro method.
• UIDocumentMacroOptions
• Represents security options for UIDocument-level macros.
• DocumentMacroOptions
• Represents security options for DB.Document-level macros.
• ApplicationMacroOptions
• Represents security options for Application-level macros
• MacroLanguageType
• Represents the language of a given macro, C#, VB.NET, Ruby, or Python
• MacroLevel
• Represents whether a macro is associated with a document the Revit application
• ModuleStatus
• Represents the compiled, loaded, or built status of a MacroModule.

The MacroManager APIs are all in the Autodesk.Revit.DB.Macros namespace and are available in RevitAPIMacros.dll and RevitAPIUIMacros.dll

Macro Attributes

The attributes  

• Autodesk.Revit.UI.Macros.AddinAttribute
• Autodesk.Revit.UI.Macros.VendorIdAttribute

and the interface 

• Autodesk.Revit.UI.Macros.IEntryPoint

have been moved to the namespace Autodesk.Revit.DB.Macros.

Parameters

Shared parameter – create with specified GUID

The new method

• Definitions.Create(String, ParameterType, bool, GUID)

supports creation of new ExternalDefinition objects (shared parameter definitions) which use the designated GUID instead of a random GUID. This allows an application to programmatically create consistent definitions for shared parameters without a shared parameter file or copying elements from one project to another.

Dimension.Label

The property

• Dimension.Label

Has been replaced by a new property

• Dimension.FamilyLabel

As this label applies only to dimension in families and their corresponding family parameter.

Family Parameters

The new property

• FamilyParameter.IsShared

identifies if the family parameter is a shared parameter.

Geometry APIs

JoinGeometryUtils

Revit now supports APIs for joining, unjoining, querying join state, and changing join order of elements in a model through the JoinGeometryUtils class.

Extensible Storage

ExtensibleStorage API changes

The method

• Element.GetEntitySchemaGuids()

returns the Schema Guids of any Entities present on an Element.

The methods

• Schema.GetField()
• Schema.ListFields()

are now restricted based on the read permission defined in the Schema.

ExtensibleStorageFilter

An ExtensibleStorageFilter is a new ElementQuickFilter for finding elements that contain an extensible storage entity of a given Schema Guid.

Translation

Export to Navisworks

The new function:

• Document.Export(String, String, NavisworksExportOptions)

exports a Revit project to the Navisworks .nwc format.  Note that in order to use this function,you must have a compatible Navisworks exporter add-in registered with your session of Revit.  If there is no compatible exporter registered, the function will throw OptionalFunctionalityNotAvailableException.  Use

• OptionalFunctionalityUtils.IsNavisworksExporterAvailable()

to check if there is an exporter registered.

Import/Link SAT

The functions:

• Document.Import(String, SATImportOptions, View)
• Document.Link(String, SATImportOptions, View)

import or link an SAT file into the document.

Import/Link SketchUp

The functions:

• Document.Import(String, SKPImportOptions, View)
• Document.Link(String, SKPImportOptions, View)

import or link an SKP file into the document.

Import DWF Markups

The function:

• Document.Import(String, DWFImportOptions)

imports DWF markups into the document.

Export tables

The new classes

• ExportLayerTable
• ExportLinetypeTable
• ExportPatternTable
• ExportFontTable
• ExportLineweightTable

expose read and write access to the tables used for mapping on export to various formats such as DWG, IFC and DGN.

Site

Editing a TopographySurface

Editing the points in a TopographySurface now requires establishment of an edit scope. The class

• TopographyEditScope

allows an application to create and maintain an editing session for a TopographySurface. Start and end of a TopographyEditScope will also start and end a transaction group. After the TopographyEditScope is started, an application can start transactions and edit the topography surface. Individual transactions the application creates inside TopographyEditScope will not appear in the undo menu.  All transactions committed during the edit mode will be merged into a single one which will bear the given name passed into TopographyEditScope constructor.

The method:

• TopographySurface.AddPoints()

has been modified to operate with the edit scope, and thus cannot be called outside of an edit scope.  The function no longer regenerates the document.

The new methods:

• TopographySurface.DeletePoints()
• TopographySurface.MovePoint()
• TopographySurface.MovePoints()
• TopographySurface.ChangePointElevation()
• TopographySurface.ChangePointsElevation()

provide the ability to modify and delete existing points in the TopographySurface.  Multiple calls to these functions can be included in the same edit scope.

Reading points from a TopographySurface

The new method:

• TopographySurface.ReadPoints()

returns a list of the points stored in the surface.

The method:

• TopographySurface.FindPoints()

filters and returns only the points of the topography surface which lie within the input bounding box.

The method:

• TopographySurface.ContainsPoint()

identifies if the input point is found in points stored in the surface.

The methods:

• TopographySurface.GetBoundaryPoints()
• TopographySurface.IsBoundaryPoint()

identify points which are a part of the boundary of the surface.

Validation

Several new validation methods have been added to the TopographySurface class:

• IsValidRegion() – Identifies whether the points can construct a valid region for a topography surface.
• ArePointsDistinct() – Identifies whether the input points are distinct in XY location.

These methods are newly used in AddPoints() to prevent problematic inputs from causing issues.

SiteSubRegion

The class SiteSubRegion represents a proxy class exposing the interfaces needed to access details of a subregion.   In the Revit database, both TopographySurface elements and subregion elements are represented by the same TopographySurface element subclass, however, in the Revit API, this SiteSubRegion class exists to separate the interfaces for subregions from those of topography surfaces.  The SiteSubRegion class offers these APIs:

• SiteSubRegion.Create() – creates a new subregion given a boundary consisting of one or more curve loops.
• SiteSubRegion.IsValidBoundary() – validates the input boundary for a new subregion
• SiteSubRegion.GetBoundary() – returns the boundary curves
• SiteSubRegion.SetBoundary() – sets the boundary for the subregion
• SiteSubRegion.TopographySurface – the TopographySurface element which this subregion represents
• SiteSubRegion.HostId – the identifier of the topography surface hosting this subregion

BuildingPad

The class BuildingPad represents a building pad element in Revit.  It inherits from CeilingAndFloor and thus offers inherited capabilities from HostObject as well. The API exposes the following specific capabilities around BuildingPads:

• BuildingPad.Create() – Creates a new BuildingPad given a boundary, type and level.
• BuildingPad.GetBoundary() – Returns the sketched boundary curves.
• BuildingPad.SetBoundary() – Assigns a new boundary to the BuildingPad.
• BuildingPad.HostId – The element id of the topography surface hosting this BuildingPad.

The type of the building pad is represented by BuildingPadType.  This inherits from HostObjAttributes and offers inherited capabilities from this parent, including access to the CompoundStructure of the type.  The API exposes these new capabilities for BuildingPadTypes:

• BuildingPadType.CreateDefault() – Creates a new default BuildingPadType in the document.

MEP

Externalized Calculations

Several new interfaces and classes based on external services are supported for pipe and duct calculations.

• Several new interfaces deriving from IExternalServer to support friction, flow, and pressure drop for pipes and ducts have been added.
• IPipePlumbingFixtureFlowServer
• IPipePressureDropServer
• IDuctPressureDropServer
• IDuctFittingAndAccessoryPressureDropServer
• IPipeFittingAndAccessoryPressureDropServer
• IDuctFittingAndAccessoryPressureDropUIServer
• IPipeFittingAndAccessoryPressureDropUIServer
• Several new classes implementing IExternalData to support friction, flow, and pressure drop for pipes and ducts have been added.
• PipePlumbingFixtureFlowData
• PipePressureDropData
• DuctPressureDropData
• DuctFittingAndAccessoryConnectorData
• PipeFittingAndAccessoryConnectorData  
• Several new classes implementing ISingleServerService to support friction, flow, and pressure drop for pipes and ducts have been added.
• PipePlumbingFixtureFlowService
• PipePressureDropService
• DuctPressureDropService
• DuctFittingAndAccessoryPressureDropService
• PipeFittingAndAccessoryPressureDropService
• DuctFittingAndAccessoryPressureDropUIService
• PipeFittingAndAccessoryPressureDropUIService

ElectricalLoadClassificationData

ElectricalLoadClassificationData has several new string properties corresponding to the load classification section of the electrical panel schedule.

• LoadSummaryDemandFactorLabel
• PanelConnectedLabel
• PanelEstimatedLabel
• PanelConnectedCurrentLabel
• PanelEstimatedCurrentLabel
• ActualElecricalLoadNameLabel

CSV Fitting Parameter Removal

Because CSV files are no longer used to drive MEP fitting parameters, Revit supports a new set of APIs to manage fitting parameters through several classes

• FamilySizeTableManager – manages importing and exporting of legacy CSV data and size tables.
• FamilySizeTable – manages specific sizes of fittings.
• FamilySizeTableColumn – manages a specific dimension of a given size in a size table
• FamilySizeTableErrorInfo – reports any errors when importing an file with CSV size table into a FamilySizeTable

Fitting Angle Settings

The members:

• DuctSettings.FittingAngleUsage
• DuctSettings.GetSpecificFittingAngles()
• DuctSettings.GetSpecificFittingAngleStatus()
• DuctSettings.SetSpecificFittingAngleStatus()
• PipeSettings.FittingAngleUsage
• PipeSettings.GetSpecificFittingAngles()
• PipeSettings.GetSpecificFittingAngleStatus()
• PipeSettings.SetSpecificFittingAngleStatus()
• ElectricalSetting.FittingAngleUsage
• ElectricalSetting.GetSpecificFittingAngles()
• ElectricalSetting.GetSpecificFittingAngleStatus()
• ElectricalSetting.SetSpecificFittingAngleStatus()

provide access to fitting angle usage settings for ducts, pipes, cable trays and conduits.

Duct Settings

Duct settings for size prefixes and suffixes, annotations, and  air density and viscosity may now be set through the DuctSettings class.

Curve Creation

Pipes, Ducts,  FlexPipes, and FlexDucts can now be created with a  Pipe, Duct, FlexPipe, or FlexDuct SystemTypeId as a parameter on their respective static Create() methods.

ConnectorElement

The methods

• ConnectorElement.CreatePipeConnector(Document, Document, PipeSystemType, Reference, Edge)
• ConnectorElement.CreateDuctConnector(Document, DuctSystemType, ConnectorProfileType, Reference, Edge)
• ConnectorElement.CreateElectricalConnector(Document, ElectricalSystemType, Reference, Edge)
• ConnectorElement.CreateConduitConnector(Document, Reference, Edge)
• ConnectorElement.CreateCableTrayConnector(Document, Reference, Edge)

allow creation of connector elements in families on centered on internal loops of a given face.

The property

• ConnectorElement.SystemType

accesses the MEPSystemType of the connector

The members:

• ConnectorElement.Direction
• ConnectorElement.FlipDirection()

access the direction of the connector.

Connect Air Terminal to Duct

The new method:

• MechanicalUtils.ConnectAirTerminalOnDuct()

connects an air terminal to a duct directly (without the need for a tee or takeoff). The current location of the air terminal will be projected to the duct centerline, and if the point can be successfully projected, the air terminal will be placed on the most suitable face of the duct. 

General

• CableTray.CurveNormal returns the "up" direction vector of a cable tray segment.
• RoutingPreferenceGroup now supports a new rule type for Cap fittings.
• Caps can be automatically be placed on all open connections of a pipe with PlumbingUtils.PlaceCapOnOpenEnds(Document, ElementId, ElementId)

Reinforcement API 

There are many new reinforcement and rebar-related methods and classes in Revit 2014.

AreaReinforcement

AreaReinforcement has several new methods and properties.

• AreaReinforcement.Create – creates a new AreaReinforcement object from curves.
• AreaReinforcement.IsUnobscuredInView – checks if Area Reinforcement is shown unobscured in a view.
• AreaReinforcement.SetUnobscuredInView – sets Area Reinforcement to be shown unobscured in a view.

PathReinforcement 

PathReinforcement has several new methods and properties.

• PathReinforcement .Create – creates a new PathReinforcement object from curves.
• PathReinforcement .AdditionalOffset - gets and sets length offset.
• PathReinforcement .IsUnobscuredInView – checks if PathReinforcement is shown unobscured in a view.
• PathReinforcement .SetUnobscuredInView – sets PathReinforcement to be shown unobscured in a view.

FabricArea 

FabricArea has several new methods and properties.

• FabricArea.Create – now supports an origin point of direction parameter.
• FabricArea.GetReinforcementRoundingManager – returns an object for managing reinforcement rounding override settings.

FabricSheet 

FabricSheet has several new methods and properties.

• FabricSheet.Create() – new static factory method for creation.
• FabricSheet.GetLocalCoordinateSystem()
• FabricSheet.SetLocalCoordinateSystem()
• FabricSheet.PlaceInHost()
• FabricSheet.GetReinforcementRoundingManager() – returns an object for managing reinforcement rounding override settings.
• FabricSheet.HostId
• FabricSheet.FabricLocation – the FabricSheet location in the host.
• FabricSheet.CoverOffset – the additional cover offset of the FabricSheet.
• FabricSheet.IsCoverOffsetValid() – identifies if the specified value is valid for use as a cover offset.

FabricSheetType 

• FabricSheetType.GetReinforcementRoundingManager() – returns an object for managing reinforcement rounding override settings.

Rebar

Rebar has several new methods and properties.

• Rebar.ComputeDrivingCurves() – compute the driving curves.
• Rebar.GetRebarConstraintsManager() – returns an object for managing the external constraints on the Rebar element.
• Rebar.GetReinforcementRoundingManager() – returns an object for managing reinforcement rounding override settings.
• Rebar.HookAngleMatchesRebarShapeDefinition() – checks that the hook angle of the specified RebarHookType matches the hook angle used in the Rebar's RebarShape at the specified end of the bar.
• Rebar.CanUseHookType – checks if the specified RebarHookType id is of a valid RebarHookType for the Rebar's RebarBarType.
• Rebar.ConstraintsCanBeEdited – returns true, if the Rebar element's external constraints are available for editing.
• Rebar.GetHookOrientation() – returns the orientation of the hook plane at the start or at the end of the rebar with respect to the orientation of the first or the last curve and the plane normal.
• Rebar.SetHookOrientation() – defines the orientation of the hook plane at the start or at the end of the rebar with respect to the orientation of the first or the last curve and the plane normal.

RebarType has several new methods and properties.

• RebarType.SetHookTangentLength() – identifies the hook tangent length for a hook type.
• RebarType.GetReinforcementRoundingManager() – returns an object for managing reinforcement rounding override settings.
• RebarBendData – new constructor to specify hook orientation.

RebarHandleType – a new enum to represent  the various types of handles on a Rebar instance that can be joined to References.

RebarConstrainedHandle – a new class to represent a handle on a Rebar that can be joined to a reference.

RebarConstraintType – a new enum to represent the various types of constraints that can be applied to a RebarConstrainedHandle.

RebarConstraintTargetHostFaceType – a new enum  to identify the individual face on a host element to which a Rebar handle is constrained.

RebarConstraint – a new class representing a constraint on the position of a Rebar Element or one of its handles.

RebarConstraintsManager – a  new class used to obtain information about the constrained shape handles (RebarConstrainedHandles) on a Rebar element.

RebarDeformationType – new enum representing the type of deformation of rebar.

RebarHookType.HookAngleInDegrees – a new property representing the angle of a rebar hook.

RebarInSystem

• RebarInSystem.getReinforcementRoundingManager – returns an object for managing reinforcement rounding override settings.
• RebarInSystem.setUnobscuredInView - sets the element to be shown unobscured in a view.

RebarShape

• RebarShape.GetDefaultHookAngle – get the hook angle, expressed as an integral number of degrees (common values are 0, 90, 135, and 180).
• RebarShape.GetDefaultHookOrientation – gets the default rebar hook orientation.

ReinforcementRoundingSource – a new enum listing the possible sources for reinforcement rounding overrides.

ReinforcementRoundingManager – a new class providing access to reinforcement rounding overrides for structural elements.

RebarRoundingManager – new class providing access to element reinforcement roundings overrides.

FabricRoundingManager – a new class providing access to element reinforcement roundings overrides.

ReinforcementSettings

• ReinforcementSettings.GetRebarRoundingManager – returns an object for managing reinforcement rounding override settings used by RebarBarTypes, Rebar and RebarInSystem elements.
• ReinforcementSettings.GetFabricRoundingManager – returns an object for managing reinforcement rounding override settings used by FabricSheetType and FabricSheet elements. 

Custom Export

The Custom Export API provides access to the rendering output pipeline through which Revit sends a processed model (its graphics 3D representation) to an output device. In the case of Custom Export, the "device" is represented by a context object that could be any kind of a device, even a file (in the most common case, actually.) A client of Custom Export provides a context and invokes rendering of a model, upon which Revit starts processing the model and sends graphic data out via methods of the context. The data describes the model exactly as it would have appeared in Revit when the model is rendered. The data includes all geometry and material properties.

The following classes have been made available so far:

CustomExporter

A class that allows exporting 3D views via a custom export context. The Export method of this class triggers standard rendering process in Revit, but instead of displaying the result on screen or printer, the output is channeled through the given custom context that handles processing the geometric as well as non-geometric information.

IExportContext

An interface of which interface is used in a custom export of a Revit model. The instance of this class is passed in as a parameter of a CustomExporter. The methods are then called by Revit at times of exporting entities of the model.

Render Node Classes

Classes of which instance are sent to an export context during a custom export.

• RenderNode – base class for all output nodes
• ViewNode – represents a View
• GroupNode – base class for family and link instances
• InstanceNode – represents an instance of a family
• LinkNode – represents an external link
• ContentNode – base class from RPC, Light, and Daylight nodes
• RPCNode – represents an RPC object
• DaylightPortalNode – represents a daylight portal
• LightNode – represents a light
• MaterialNode – represents a material change

CameraInfo

A class that describes information about projection mapping of a 3D view to a rendered image. An instance of this class can be obtained via a property of ViewNode.

Paint API

The paint tool is now supported in the API

• Document.Paint
• Document.RemovePaint
• Document.IsPainted
• Document.GetPaintedMaterial

Component repeater API

Component repeaters can be used to replicate (repeat) elements hosted on repeating references. The result of the repeating operation is a collection of slots. Each slot contains one repeated component. The ComponentRepeater class provides the repeating functionality and access to the slots.

Each repeating reference is capable of hosting one point of an adaptive component. An initial pattern can be created by populating one or more repeating references with such points. Component repeaters can then be used to replicate the pattern to fill the rest of the repeating references in the particular repeating reference source.

The repeating references in repeating reference source are arranged in one or two dimensional arrays, allowing for different kinds of repeating:

• One dimensional source allows for repeating along a path.
• Two dimensional source allows for repeating across a grid.
• It is also possible to host a point on a zero dimensional reference (a point). This point will be shared by all slots. A zero dimensional source allows for repeating around a single point. It should not be used alone, but together with at least one other repeating reference source (typically one dimensional.) The point hosted on the zero dimensional source serves as a central point around which other points can be repeated on their respective repeating reference sources.

Multiple adaptive components may be hosted on one repeating reference source, and different points of one adaptive component may be hosted on different repeating reference sources, effectively allowing different points of an adaptive component to be repeated using different patterns.

The following classes provide access to the functionality of Component repeaters:

• Autodesk.Revit.DB.RepeatingReferenceSource
• Autodesk.Revit.DB.RepeaterBounds
• Autodesk.Revit.DB.RepeaterCoordinates
• Autodesk.Revit.DB.ComponentRepeater
• Autodesk.Revit.DB.ComponentRepeaterSlot

Small Enhancements & Interface Changes

API validation

No transactions from outside threads

Calling into the Revit API from outside threads and outside modeless dialogs has never been supported, but it was not strictly prohibited, meaning there would be no immediate exceptions when someone tries to modify model from outside of the supported API workflows. That has been changed. It is no longer possible to start a transaction unless the caller is inside a legitimate API call, such as an external command, event, updater, call-back, etc. An exception will be thrown if such attempt is made.

IsValidObject property

If a Revit native object contained within an API wrapper is destroyed, or creation of the corresponding native object is undone, the managed API object containing it is no longer valid. API methods cannot be called on invalidated wrapper objects. The property IsValidObject (added to many API classes) can be used to identify if the corresponding native object has gone out of scope.

Enumerated type validation

Automatic validation has been introduced for enumerated type inputs to API methods and properties. If an value is improperly cast to an enum and is not a valid member of that enum, an ArgumentOutOfRangeException will be thrown.

Elements

Copy & paste elements

The new methods:

• ElementTransformUtils.CopyElements(Document, ICollection<ElementId>, Document, Transform)
• ElementTransformUtils.CopyElements(View, ICollection<ElementId>, View, Transform)
• Transform ElementTransformUtils.GetTransformFromViewToView(View, View)

support copy and paste of arbitrary elements.  The first overload supports copy within documents, or from document to document.  The second overload also support copying within one document or between two documents, but specifically supports copy and paste of view-specific elements.

Materials

Materials applied with the Paint tool and their areas can be found by specifying "true" for the 'usePaintMaterial' argumement in Element.GetMaterialIds and Element.GetMaterialArea

Geometry

FreeForm element

A FreeFormElement is a form sub-type that contains non-parametric geometry created from an input solid outline. The element can be added to families, and can participate in joins and void cuts with other combinable elements.  Planar faces of the element can be offset interactively and programmatically in the face normal direction.

• FreeFormElement.Create() – creates a new FreeForm element.
• FreeFormElement.SetFaceOffset() – offsets a planar face a certain distance in the face normal direction.

Solid & curve intersection

The new method

• Solid.IntersectWithCurve()

calculates the intersection between a closed volume Solid and a curve. There is an option to return details about the segments inside the volume, or outside. Both the curve segments and the parameters of the segments are available in the results.

Face/Face Intersection

The method

• Face.Intersect()

calculates the intersection of the input face with this face and returns the intersection results.  The method can output the intersection geometry if the intersection consists of a single curve.

ReferenceIntersector & RVT Links

The new option findReferencesInRevitLinks allows ReferenceIntersector to find geometry in RVT links.

Rulings of RuledFace

The new method

• RuledFace.RulingsAreParallel

determines if the rulings of the ruled surface are parallel.

Detail elements

Detail element draw order

The class

• DetailElementOrderUtils

now includes routines to BringToFront, BringForward, SendToBack, SendBackward multiple detail members.  The draw order of the members does not change relative to one another.

Stairs

StairsRunJustification

New values LeftExterior and RightExterior have been added to this enum to support jusitification to the left and right supports.

StairsLanding

The new members:

• CreateAutomaticLanding(Document, ElementId, ElementId)
• CanCreateAutomaticLanding(Document, ElementId, ElementId)

provide automatic landing(s) creation and creation validation between two stairs runs.

StairsRun

The new properties:

• StairsRun.ExtensionBelowRiserBase
• StairsRun.ExtensionBelowTreadBase

represent the extension/trim value for the run, depending upon whether the run begins with a riser or tread.

These replace the deprecated property:

• StairsRun.ExtensionBelowBase

which now accesses whichever property listed above depending on the run's configuration.

StairsComponentConnection

The new methods:

• StairsRun.GetConnections()
• StairsLanding.GetConnections()

provide information about connections among stairs components (run to run, or run to landing).

Parameters & filters

Parameter.AsValueString()

This method previously was implemented for only Integer and Double values. It now can also be used with Enums and ElementIds. Optionally it can accept a FormatOptions object to specify units formatting of the returned string.

Parameter.Definition.UnitType

This new property provides access to the UnitType of a parameter definition.

Parameter variance among group instances

The new members:

• InternalDefinition.VariesAmongGroups
• InternalDefinition.SetVariesAmongGroups(Document)

support read and write to the option that the parameter value can vary across groups.  This can be changed only for non-built-in parameters.

FilterCategoryRule

The new class FilterCategoryRule can be used in the definition of a ParameterFilterElement.   It represents a filter rule that matches elements of a set of categories.

The related method:

• ParameterFilterElement.AllCategoriesFilterable()

has been replaced by

• FilterCategoryRule.AllCategoriesFilterable()

Miscellaneous

ThermalAsset.SpecificHeat

This new property provides the specific heat value of a thermal asset in feet per Kelvin, squared-second.

AreaVolumeSettings

This new class provides access to settings related to volume and area computations. The old VolumeCalculationSetting class is obsolete. 

Document.Delete()

This method previously returned null if the element or elements could not be deleted. It now will throw an exception in this situation.

Document level updaters

The new methods:

• UpdaterRegistry.IsUpdaterRegister(UpdaterId, Document)
• UpdaterRegistry.UnregisterUpdater(UpdaterId, Document)

provide the ability to inquire about and to unregister updaters that are associated to specific documents. 

UIThemeManager

The static properties of UIThemeManager provide access to the current UI theme and the default theme.

Families & content

Family category

The property

• FamilyBase.FamilyCategory

can now be set.  This allows the category of an family being edited to be changed.

SpatialElementCalculationLocation

The class SpatialElementCalculationLocation is used to specify the room or space where an element should be considered as placed.

This is a base class with currently subtypes of calculation location:

• SpatialElementCalculationPoint
• SpatialElementFromToCalculationPoints

A SpatialElementCalculationLocation can be added to the family by turning on the family's ROOM_CALCULATION_POINT parameter.   Once the location has been added, you can access the marker position using the MarkerPosition property. 

Note that the MarkerPosition property is no longer settable – this position is determined automatically.

SpatialElementFromToCalculationPoints

SpatialElementFromToCalculationPoints is a subclass of SpatialElementCalculationLocation used to specify the search points for a family instance that connects two rooms or spaces, such as a door or window. The points determine which room or space is considered the "from" and which is considered the "to".    The properties ToPosition and FromPosition govern the coordinates for these points.

Arc through points

The method

• CurveByPointsUtils.CreateArcThroughPoints()

creates an arc curve through three input ReferencePoints.

Events

DocumentChangedEventArgs

For the methods GetAddedElementIds()/GetModifiedElementIds() – internal Revit element ids that are not visible to UI and API are now excluded from the return set.

GetAddElementIds(ElementFilter)/GetModifiedElementIds(ElementFilter)

The new methods:

• DocumentChangedEventArgs.GetAddedElementIds(ElementFilter)
• DocumentChangedEventArgs.GetModifiedElementIds(ElementFilter)

only return ElementIds that pass the input element filter. This helps applications detect only specific changes of interest.

Reinforcement API

Reinforcement Length Tolerance

The new classes:

• RebarRoundingManager
• FabricRoundingManager

contain settings for rounding tolerance for rebar and fabric reinforcement elements.  They can be assigned at the element instance level (Rebar, RebarInSystem, FabricArea, FabricSheet), at the type level (RebarType, FabricSheetType), or at the ReinforcementSettings level.   Lower level settings override the setting of higher levels. 

I hope this is enough for you :-)

Cool, huh?

Compiling the Revit 2014 SDK

Here are some notes on the small issues I encountered compiling the Revit 2014 SDK:

• Compile and install RevitLookup
• Set up the Revit API assembly paths
• First compilation run causes expected errors
• Set up the RevitAddInUtility assembly path
• PointCurveCreation Office reference
• CancelSave RevitAddInUtility Reference
• Set up the RvtSamples application
• Fix errors in RvtSamples.txt
• Download RvtSamples and RevitLookup

I already described this same process during the Revit 2013 timeframe. Let's see if anything changed, or, better still, improved.

Compile and Install RevitLookup

My first step is always to compile, install and test RevitLookup.

This went completely smoothly, so I have nothing to report on that.

Please see below for a link to the version I compiled.

Set up the Revit API Assembly Paths

Before the introduction of Revit Onebox, I used to make copies of the Revit API assemblies for the different flavours.

With the advent of Onebox, I opted for the simpler solution of using the Revit API DLLs path updater RevitAPIDllsPathUpdater.exe. Simply launch it, enter the sample location and DLL folder, and let it do its job. In my case, I entered the following paths:

• C:\a\lib\revit\2014\SDK\Samples\RevitAPIDllsPathUpdater.exe
• Sample location: C:\a\lib\revit\2014\SDK\Samples
• DLL folder: C:\Program Files\Autodesk\Revit Architecture 2014

It completes and reports that it "Replaced 169 files, skipped 0 files."

First Compilation Run Causes Expected Errors

With the correct assembly paths in place, it is time to open the Visual Studio solution SDKSamples2014.sln and compile the samples.

The first run reports Rebuild All: 166 succeeded, 3 failed, 0 skipped.

This no surprise, because there are some expected errors.

Set up the RevitAddInUtility Assembly Path

The first error is caused by the RevitAddInUtilitySample and says: "The type or namespace name 'Autodesk' could not be found (are you missing a using directive or an assembly reference?)"

The RevitAddInUtilitySample references the RevitAddInUtility assembly. It is also located in the Revit API assembly path, but RevitAPIDllsPathUpdater.exe does not take it into account, so you have to open that project and set the assembly path manually instead:

In my case, the correct reference path to it is C:\Program Files\Autodesk\Revit Architecture 2014\RevitAddInUtility.dll.

PointCurveCreation Office Reference

The Massing PointCurveCreation sample references Microsoft.Office.Interop.Excel in order to interact with spreadsheets.

I have not set up Office on my virtual machine, so that caused an error saying "The type or namespace name 'Office' does not exist in the namespace 'Microsoft' (are you missing an assembly reference?)"

For a quick ad hoc solution to this, I simply unloaded this one project for the time being.

CancelSave RevitAddInUtility Reference

The next problem occurs in the Events CancelSave sample: "The type or namespace name 'RevitAddIns' does not exist in the namespace 'Autodesk' (are you missing an assembly reference?)"

Same resolution as above, set the RevitAddInUtility assembly path.

Wow!

That was it!

No more errors, just 345 warnings saying 'There was a mismatch between the processor architecture of the project being built "MSIL" and the processor architecture of the reference "RevitAPI, Version=2014.0.0.0, Culture=neutral, processorArchitecture=AMD64", "AMD64". This mismatch may cause runtime failures. Please consider changing the targeted processor architecture of your project through the Configuration Manager so as to align the processor architectures between your project and references, or take a dependency on references with a processor architecture that matches the targeted processor architecture of your project'.

I assume you can ignore those.

This was a smoother compilation than ever before.

Set up the RvtSamples Application

I always install RvtSamples to load all the other SDK samples if I ever want to test something in one of them.

It saves you from installing them one by one, which might prove a lengthy process, there being well over a hundred of them.

To do so, I first add two files to the RvtSamples project, its add-in manifest and its text file listing all the samples to load:

In the text file, I replace the samples path by my real installation folder, globally replacing "Z:\SDK2013\Samples\" by "C:\a\lib\revit\2014\SDK\Samples\".

At the end, I add placeholders for my two include files, for the Autodesk Developer Network ADN and The Building Coder sample collections:

##include C:\a\lib\revit\2014\adn\src\AdnSamples.txt
#include C:\a\lib\revit\2014\bc\BcSamples.txt

The ADN samples are commented out, because we have not completed their migration yet.

I already migrated The Building Coder samples to Revit 2014, though, so that include file is already active.

I need to add the RvtSamples assembly path to its add-in manifest and install that in the Revit Add-Ins folder, and we are set to go.

Fix errors in RvtSamples.txt

As usual, the list of samples to load specified by RvtSamples.txt is not perfectly set up. Here are some of the add-ins causing errors on my system:

• RotateFramingObjects
• ProjectUnit (missing)
• GenericModelCreation
• ElementViewer
• PointCurveCreation (my fault)
• TraverseSystem
• CreateShared
• BarDescriptions (missing)
• StructuralLayerFunction

ProjectUnit is missing, presumably because the unit API changed in Revit 2014 and the sample has been removed. It is still listed in RvtSamples.txt, and should be removed there as well.

Most of the others are caused by VB.NET samples listed in their 'bin' subfolder, whereas their assembly DLL really lives in 'bin/Debug', at least on my system, and vice versa, in the case of CreateShared.

After my first clean-up pass, the following still cause problems:

• GenericModelCreation
• PointCurveCreation (my fault)
• TraverseSystem
• CreateShared
• BarDescriptions (missing)
• StructuralLayerFunction

Again, these are almost all VB.NET samples. Something strange going on with those.

There is a testing switch you can set in the RvtSamples source code, actually:

  bool testClassName = true;

Setting it to true turns up more errors:

• DeleteObject
• HelloRevit
• RotateFramingObjects
• MaterialProperties
• SlabProperties
• CreateBeamsColumnsBraces
• StructuralLayerFunction

I fixed some of these, but not all.

Anyway, I'll stop fixing this for today, though, because I have other things to do as well.

RvtSamples loads now and most of the samples are available:

Download RvtSamples and RevitLookup

Here is my current version of RvtSamples, and also of RevitLookup, which was missing from some intermediate versions of the SDK samples.

The RvtSamples package includes both the original and my modified add-in manifest and RvtSamples.txt sample list. You can compere them to see the changes I applied, and add analogous changes of your own for any other samples that you wish to activate.

I hope this is of use to you.

This article was picked for TenLinks Daily by www.caddigest.com.

Actually, taking a closer look at the CAD digest listing, I currently count 53 of The Building Coder articles listed there. I was not aware of that before. Surprise, surprise :-)

Migrating The Building Coder Samples to Revit 2014

I started migrating The Building Coder samples to Revit 2014. Funnily enough, on the exact same date as last year for the previous version.

The changes are very small this time around.

Furthermore, I am well prepared, since I recently intentionally eliminated all compiler warnings and deprecated calls compiling the code for Revit 2013.

First, however, a picture or three from my ski tour last weekend over Il Chapütschin (3386 m) and La Sella (3584 m) in the Swiss Engadin. Here I am on the first summit:

The panorama is grandiose:

We arrive back at the hut tired and happy:

Migrating The Building Coder Samples to Revit 2014

Back at the desk and steeped in the Revit API, Here is what I have done so far to migrate The Building Coder samples from Revit 2013 to Revit 2014:

• Update the Revit API assembly references
• Remove obsolete Collections namespace and RoomCreationData class
• TopographySurface namespace changed
• Some unit API changes
• Initial Revit 2014 version

Update the Revit API Assembly References

Every Revit add-in needs to reference the API assemblies.

They now live in the main Revit installation folder, together with Revit.exe.

In my case, this folder is "C:\Program Files\Autodesk\Revit Architecture 2014", and I am referencing the three assemblies RevitAPI, RevitAPIUI and UIFrameworkServices.

Just updating the references and recompiling generated 5 errors and 3 warnings.

Remove Obsolete Collections Namespace and RoomCreationData Class

Four of the five errors say "The type or namespace name 'Collections' does not exist in the namespace 'Autodesk.Revit' (are you missing an assembly reference?)".

To my surprise, I did indeed have several obsolete statements like this left over from previous versions:

using Autodesk.Revit.Collections;

They were actually not required at all by the Revit 2013 compilation, just left over from still older versions.

The fifth warning is similar, saying "The type or namespace name 'RoomCreationData' does not exist in the namespace 'Autodesk.Revit.Creation' (are you missing an assembly reference?)", and could also be resolved simply by removing this obsolete using statement:

using RoomCreationData
  = Autodesk.Revit.Creation.RoomCreationData;

Removing these erroneous using statements enables the compilation proper to execute and raises the number of problems reported to 3 errors and 108 warnings.

Just three errors! Looking good...

TopographySurface Namespace Changed

Now we hit some real errors caused by slight shifts and redefinitions in the API.

The first error is in CmdLandXml.cs:

  TopographySurface surface
    = doc.Create.NewTopographySurface( pts );

It says "The type or namespace name 'TopographySurface' could not be found (are you missing a using directive or an assembly reference?)".

The TopographySurface class apparently moved from one namespace to another. In Revit 2013, it lived in Autodesk.Revit.DB.

This is easily remedied by placing the cursor over the offending class name and pressing Ctrl + '.', which brings up a menu listing the fully qualified class name and offering to automatically correct the error for you:

Some Unit API Changes

The other two errors refer to units, one of the few areas seriously modified in the Revit 2014 API, and say:

• 'Autodesk.Revit.DB.Document' does not contain a definition for 'ProjectUnit' and no extension method 'ProjectUnit' accepting a first argument of type 'Autodesk.Revit.DB.Document' could be found (are you missing a using directive or an assembly reference?)
• 'Autodesk.Revit.DB.FormatOptions' does not contain a definition for 'Units' and no extension method 'Units' accepting a first argument of type 'Autodesk.Revit.DB.FormatOptions' could be found (are you missing a using directive or an assembly reference?)

They are caused by the following lines in ParameterUnitConverter.cs:

  FormatOptions fo = document.ProjectUnit
    .get_FormatOptions( ut );
 
  DisplayUnitType dut = fo.Units;

They are easily fixed by using the following new methods and properties:

  FormatOptions fo = document.GetUnits()
    .GetFormatOptions( ut );
 
  DisplayUnitType dut = fo.DisplayUnits;

We are left with zero errors and 111 warnings, which we will leave to deal with another day.

Initial Revit 2014 Version

So here is the result, the very first version 2014.0.100.2 of The Building Coder samples for Revit 2014.

To compare with the last version for Revit 2013, look at the version 2013.0.100.2 that I provided after eliminating all compiler warnings and deprecated calls.

Perpetual GUID Algorithm and Revit 2014 Product GUIDs

Every year anew, people ask for the Revit product GUIDs used to identify the Revit installation and stored in the Windows registry under

• HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Uninstall

I already answered several queries from developers lately wishing to update their installers for the new version.

I discussed this topic on a yearly basis in the past for Revit 2010 and previous versions, Revit 2011, Revit 2012, when the 'perpetual GUID algorithm' was introduced, and Revit 2013.

The install path is less of an issue since the introduction of the add-in manifest to inform Revit how to load your add-in, and the add-in manifest path is well known.

It is actually recommended to install .NET add-ins for both AutoCAD and Revit in or under the same directory as acad.exe and revit.exe, respectively: "It's safest to place assemblies at a location beneath the calling executable."

The best way to determine the Revit install location is to use the RevitAddInUtility, which provides an API for an installer to query that and also to generate an add-in manifest file from the relevant properties you specify. The same RevitAddInUtility assembly DLL works transparently on both 32 and 64 bits.

Revit 2014 and Previous Product GUIDs

In spite of all this, the product GUID is still important, so here is a list of the Revit GUIDs up to and including Revit 2014:

2014	64 bit	RAC	7346B4A0-1400-0110-0409-705C0D862004
		RST	7346B4A0-1400-0210-0409-705C0D862004
		RME	7346B4A0-1400-0310-0409-705C0D862004
		LT	7346B4A0-1400-0410-0409-705C0D862004
		One-Box	7346B4A0-1400-0510-0409-705C0D862004
	32 bit	RAC	7346B4A0-1400-0100-0409-705C0D862004
		RST	7346B4A0-1400-0200-0409-705C0D862004
		RME	7346B4A0-1400-0300-0409-705C0D862004
		LT	7346B4A0-1400-0400-0409-705C0D862004
		One-Box	7346B4A0-1400-0500-0409-705C0D862004
2013	64 bit	RAC	7346B4A0-1300-0110-0409-705C0D862004
		RST	7346B4A0-1300-0210-0409-705C0D862004
		RME	7346B4A0-1300-0310-0409-705C0D862004
		One-Box	7346B4A0-1300-0510-0409-705C0D862004
	32 bit	RAC	7346B4A0-1300-0100-0409-705C0D862004
		RST	7346B4A0-1300-0200-0409-705C0D862004
		RME	7346B4A0-1300-0300-0409-705C0D862004
		One-Box	7346B4A0-1300-0500-0409-705C0D862004
2012	64 bit	RAC	7346B4A0-1200-0110-0409-705C0D862004
		RST	7346B4A0-1200-0210-0409-705C0D862004
		RME	7346B4A0-1200-0310-0409-705C0D862004
	32 bit	RAC	7346B4A0-1200-0100-0409-705C0D862004
		RST	7346B4A0-1200-0200-0409-705C0D862004
		RME	7346B4A0-1200-0300-0409-705C0D862004
2011	64 bit	RAC	94D463D0-2B13-4181-9512-B27004B1151A
		RST	23853368-22DD-4817-904B-DB04ADE9B0C8
		RME	C31F3560-0007-4955-9F65-75CB47F82DB5
	32 bit	RAC	4AF99FCA-1D0C-4D5A-9BFE-0D4376A52B23
		RST	0EE1FCA9-7474-4143-8F22-E7AD998FACBF
		RME	CCCB80C8-5CC5-4EB7-89D0-F18E405F18F9
2010	64 bit	RAC	2A8EEE2F-4A9E-43d8-AA07-EC8A316B2DEB
		RST	BC9C0A08-DEA4-4138-A7FB-8F68866DB0C1
		RME	A1BD042B-8A6F-4e37-92A3-78921BB45B05
	32 bit	RAC	572FBF5D-3BAA-42ff-A468-A54C2C0A17C3
		RST	939D29FC-B82D-42a7-BB1E-8E3F121505CC
		RME	5C8281B1-B927-495a-A0FF-AB4BDFAE505C
2009	64 bit	RAC	D2466208-7348-4214-B01E-7BC8729E2BD3
		RST	B354FCF5-CF64-4fa2-AA84-9D9B2A6FA649
		RME	4A98F976-01B5-40e8-A496-AEFD85C3A446
	32 bit	RAC	A3A37DA6-70C0-497C-BCB1-148E9EC1D32E
		RST	C4B3B3C3-2EE9-48D3-9BF5-4443F7ECF759
		RME	E3781DCB-A650-4E66-9B74-67A1B17F052C
2008		RAC	4A11206C-4377-49E8-911E-B11548658FF3
		RST	8D0AE0BB-4FE5-491D-A284-3B363F02E639
		RME	60A2743E-C881-4880-94ED-96445E38616F
9.0		Revit Building	D11DB6CB-0332-4735-B312-B919741D975E
3		RST	3F11CEE0-D30D-41ce-8522-922B5D8BB324
8.1		Revit Building	7EBC0489-5E47-498D-BE31-B094484612E9
2		RST	BE814F63-629D-4fd8-B628-1437AC10F9D4

Perpetual Revit Product GUID Algorithm

As you can see above, all the Revit GUIDs from Revit 2012 onwards have a strong similarity.

They are actually generated according to the following pattern:

    {7346B4At-uuvv-wwxy-zzzz-705C0D862004}

The alphabetical characters above stand for:

20. [0/1]: ProductCode/UpgradeCode
21. [12, 13, 14, ...]: Major release version [12, 13, 14]
22. [00, 01, ...]: Release subversion
23. [01/02/03/04/05/06/07]: RAC/RST/RME/LT/One-Box/Server/Vasari
24. [0/1]: Win32/x64
25. [0/1]: Global/Language Pack
26. [0409...]: Language

The 'ww' item corresponds to the ProductType enumeration provided by the Revit API, with the following members:

• Architecture
• Structure
• MEP
• Revit
• LT
• Unknown

The last item, represented by 'zzzz', identifies the language. It uses the hexadecimal LCID or language code identifier. The ones supported by Revit are listed in the following table:

lang	.NET code	HEX LCID	DEC LCID	Language	Codepage
chs	zh-CN	0804	2052	Chinese Simpl.	936
cht	zh-TW	0404	1028	Chinese Trad.	950
csy	cs-CZ	0405	1029	Czech	1250
deu	de-DE	0407	1031	German	1252
enu	en-US	0409	1033	English	1252
esp	es-ES	040A	1034	Spanish	1252
fra	fr-FR	040C	1036	French	1252
hun	hu-HU	040E	1038	Hungarian	1250
ita	it-IT	0410	1040	Italian	1252
jpn	ja-JP	0411	1041	Japanese	932
kor	ko-KR	0412	1042	Korean	949
plk	pl-PL	0415	1045	Polish	1250
ptb	pt-BR	0416	1046	Portuguese Brazil	1252
rus	ru-RU	0419	1049	Russian	1251

Applying this algorithm to the different flavours of Revit from Revit 2012 onwards produces the values listed in the table above.

Windows Registry Keys

The installer creates the following registry keys:

  HKEY_LOCAL_MACHINE\SOFTWARE\Autodesk\Revit
  \[RELEASEYEAR]\REVIT-[PRODID]:[LANGID]

  HKEY_LOCAL_MACHINE\SOFTWARE\Autodesk\Revit
  \Autodesk Revit [RELEASEYEAR]
  \ServicePack[SERVICEPACK#]

RELEASEYEAR is the major version number, i.e. 2013, 2014, etc., PRODID specifies the flavour, listed as 'ww' above, and LANGID the locale, 'zzzz' above, SERVICEPACK# would be 1 for Update Release 1, etc.

For Revit 2014, the Windows registry key is

  HKEY_LOCAL_MACHINE\SOFTWARE
  \Autodesk\Revit\2014\REVIT-05:0409

MUI: Multiple Language Interface Update

Addendum:

Revit 2014 is using a new Multiple Language Interface, MUI.

Therefore, you may encounter all-zero language codes besides the ones listed above.

For instance, the following GUID refers to the global MSI which is used for the base product in all locales:

• 7346B4A0-1400-0110-0000-705C0D862004

The corresponding ENU Language Pack MSI would be installed by either an ENU base install or installing the ENU Language Pack on top of a non-ENU base install and create this GUID instead:

• 7346B4A0-1400-0110-0409-705C0D862004

Appropriate keys are added as each additional language pack is installed.

The Revit 2014 Pre-release API and SDK

Below, we look at how ADN members can obtain the Revit 2014 pre-release SDK, address migration issues, and one or two interesting new aspects of the API.

First however, a few words on yesterdays post touting the idea of a cloud-based restaurant seating arrangement and cleaning application. As you probably noticed, the main new ideas I discussed there were in honour of April fool's Day.

Many of my colleagues joined in with other similar hoax blog posts. Stephen Preston presents an April fool's Day blog post overview listing them all.

I hope you enjoy them. They might even provide you with a useful real-world idea or two :-)

As always, think outside the box!

Back to more serious business, the Revit API, and the Revit 2014 pre-release.

The Revit 2014 Pre-release SDK

As you can guess, ADN member have already been working with Revit 2014 and its API to get their products ready for the new release.

Here are a couple of questions and interesting observations that came up and are still coming in:

• Where is the Revit 2014 SDK?
• Do we need to rewrite our apps?
• Add to an existing command
• Full circle creation

Where is the Revit 2014 SDK?

Question: Is there an SDK available for Revit MEP 2014?

The Revit Developer Center still only lists the 2013 SDK...

Answer: ADN members can obtain the Revit 2014 SDK from the ADN web site. It is included in the preview version of Revit:

• Autodesk Developer Network > Login
• Downloads by Product Autodesk Revit
• Autodesk Revit Architecture 2014 available in English
• Autodesk Revit Architecture 2014 English Win 32-64bit (exe - 2.59 Gb)

The installer extracts its content to a temporary installation folder, which by default is located in C:\Autodesk.

Within this folder, you can navigate to the Utilities\SDK subfolder, which contains the installer:

• C:\Autodesk
•  \Autodesk_Revit_Architecture_2014_English_Win_32-64bit_dlm
•  \Utilities
•  \SDK
•  > 03/09/2013 12:27 AM 201,066,482 RevitSDK.exe

This executable extracts and installs the Revit SDK, which is identical for all flavours of Revit including MEP.

Please note that this is a pre-release version of the SDK. There definitely will be changes and additions made before the final release, so plan on updating it as soon as we get there. As always, the final version will obviously be posted to the Revit Developer Center as soon as possible.

Do we need to rewrite our apps?

Question: Sorry if my question is stupid, I am not a programmer and it is hard for me by myself to get to the problem details.

Our programmer reports that our apps do not function under the Revit 2014. I understand it happens because many methods were replaced with new calls. Does it mean that we should rewrite our apps and replace old methods with new ones? Is there a way to upgrade apps automatically?

Answer: Thanks for posting this question. Revit does not provide any tools to automatically upgrade lower version code to higher version. However, Revit does provide plenty of information on how to upgrade the code yourself. Here is the procedure:

• Open the lower version code in Visual Studio.
• Add the Revit 2014 API references.
• In the output window, each error includes a detailed instruction on how to change the code to the higher version.
• Follow these steps one by one.
• Compile the project.

That is easy to follow. Actually, the migration of an add-in from Revit 2013 to 2014 is much easier and faster than in the past few releases.

For more information, please look at the numerous examples in The Building Coder migration category.

Good luck!

Add to an Existing Command

Question: I read your post about disabling commands through the API and it’s sort of along the lines of what I’m trying to do. I’m looking to capture a specific CommandId ID_SETTINGS_REVISIONS, run it, and, when the command finishes, run a custom add-in. I don’t want to replace the command, just add some custom background content at the end of it.

Is that possible?

Answer: In 2013, all you can do is replace the existing command completely with your own implementation.

In 2014, you can also launch an existing Revit command.

Combining these two functionalities should enable what you wish.

Full Circle Creation

The Revit 2014 API enables the creation of a real full circle. That was is not possible in Revit 2013. There, we had to resort to creating two separate 180-degree arcs.

That was just a starter. Lots more to come!

Revit 2014 and Supporting Columns

Revit 2014 Announced

As you probably noticed by now, Revit 2014 has been announced. Here are the main product features:

• Design
  • Enhanced Autodesk Exchange
  • Dockable window framework
  • New stairs and railings
  • Temporary view templates to change view properties temporarily
  • Point cloud improvements improve appearance and controls of point clouds
  • Parameter variance for groups to vary the value of parameters assigned to groups
  • New air terminal on duct enables placement of air terminal device on duct face
  • New angle constraints to restrict angles for pipe, duct, and cable tray
  • Cap open ends of pipe or duct content quickly
  • CSV file removal project, embedding the data into families
  • New plumbing template
  • New rebar placement constraints customization
  • Reinforcement enhancements with more rebar options
• Documentation
  • Non-rectangular crop regions
  • Split elevations
  • Alternate dimensions
  • Improved rebar tagging to annotate multiple elements with a single tag
  • Improved positioning of beams and braces
  • Enhanced schedules providing greater control of schedule formatting
• Visualization
  • Displaced views enable creation of displaced or exploded building design views
  • Enhanced visualization
  • New rendering to reduce project costs with cloud-based rendering
• Analysis
  • New building element energy analysis
  • Enhanced structural analytical model
  • New duct and pipe calculations to API

Each and every one of these is really exciting in itself, and almost all include or are even based on enhanced API support. Some of the ones that seem most exciting to me are the non-rectangular crop regions, parameter variance for groups, enhanced schedules, displaced views... well, as said, they are really all very exciting.

And this is not even mentioning some of the new API features, such as the possibility to launch a Revit command and control copy and paste operations. I will get to all that real soon now.

As Harry puts it, the Revit 2014 API is going to blow your faces out :-)

Determining the Columns Supporting a Beam

Still, ignoring all that busy-ness for the moment, I chug along and return to a topic similar to my discussion on retrieving all touching beams.

In that post, I showed how to recursively traverse a collection of beams and detect the neighbouring ones at each end using an ElementIntersectsSolidFilter with a sphere.

Today I explore the task of determining the columns supporting a selected beam using various different methods.

• Columns supporting a selected beam
• Solid and element intersection
• Bounding box filter tolerance
• Moving the beam downwards in a temporary transaction
• GetGeneratingElementIds
• Cylinder Along Location Line Offset Downwards
• Find references via ray casting
• Sweep Along Location Curve Offset Downwards
• Conclusion and source code

Columns Supporting a Selected Beam

Here is a view of a simple sample model:

The task at hand is to pick the indicated beam and report the columns supporting it:

Simple, ain't it?

Solid and Element Intersection

Initially, I made some further attempts and experiments using the ElementIntersectsSolidFilter and ElementIntersectsElementFilter functionality.

The sample provided includes code exercising these tests and also the original bounding box implementation. It is enclosed in 'if' statements checking the setting of the following Boolean variables:

  bool useBoundingBox = false;
  bool useSolid = false;
  bool useElement = false;

That enables them to be switched on and off interactively in the debugger, if the need arises.

Unfortunately, as it turns out, they both do not work.

The beam solid is not quite big enough to intersect the columns, because the beam is cut back so that it does not actually intersect them.

The same problem also prevents use the element intersection filter.

It would be great if there was a possibility to grow the solid just slightly, e.g. offset all its faces outwards by an inch or two or define a tolerance before executing the intersection check, like for the bounding box. Unfortunately, growing or shrinking an arbitrary solid is much harder than a bounding box and therefore not implemented.

Bounding Box Filter Tolerance

The BoundingBoxIsInsideFilter can be instantiated with an optional double tolerance value that allows control over the match criteria by using the given tolerance in the geometry comparison.

By default, the tolerance is set to zero. If the tolerance is positive, the iterated element outline may extend the tolerance distance outside of the given outline in each coordinate to be a match. If the tolerance is negative, the iterated element outline must lie at least the tolerance distance inside the given outline in each coordinate to be a match.

This is exactly what I would need here for the solid and element intersection filters as well. Unfortunately, as said, such a tolerance is not supported by the solid or element intersection filters.

Moving the Beam Downwards in a Temporary Transaction

Lacking the tolerance option, I thought that maybe it would help to move the beam down a bit, and that it would intersect the supporting columns then. Unfortunately, that does not help either.

The problem is not only that the bottom face of the beam solid may be located above the end of the supporting columns, but also that the ends of the beam are cut back to avoid intersecting the columns, so their solids do not intersect even when the beam is moved slightly downwards.

This temporary movement forces a switch from read-only to manual transaction mode, of course, even though the model is not actually modify in any way in the end.

To make sure that the movement really is executed and the model updated before checking for an intersection, I followed the advice given by Arnošt Löbel on enhancing the temporary transaction trick and encapsulated the whole operation in a transaction group. The group is rolled rolled back at the end, but, before doing so, the encapsulated temporary transaction around the movement of the beam can be committed and the updated geometry evaluated.

By the way, these changes temporarily caused an error saying "Attempted to read or write protected memory. This is often an indication that other memory is corrupt." This was probably due to accessing the list of elements generated within the temporary transaction after the transaction group is rolled back. I handled that problem by storing the element ids instead of the live elements themselves inside the transaction, and then opening the elements via their id after rolling back the changes.

As said, the temporary downward translation still did not produce any intersections.

Time for another idea.

GetGeneratingElementIds

A colleague suggested that if the beam is cut back by the columns, you can iterate over the beam geometry faces and call the Element GetGeneratingElementIds method on each one, which might return the column element ids. In this example, you might also get faces generated by joins with other beams.

I tried this, encapsulating the code in the section if( useGeneratingIds ). Unfortunately, all the generating ids belong to the structural framing or floors categories, so that does not help to determine the columns either. No columns at all are returned by this method.

Cylinder Along Location Line Offset Downwards

I then realised that I could create a much simpler independent solid shape to intersect the columns by extruding a cylinder along the beam location line, offset downwards to just below the bottom face of the beam. It might require extending a little at each end. All supporting columns should be intersected by it.

I can use code similar to the sample presented to find 3D elements by intersection.

Yay! This works!

Find References via Ray Casting

A similar approach as the solid intersection with an offset cylinder could obviously also be implemented using the ray casting functionality provided by the FindReferencesByDirection and FindReferencesWithContextByDirection methods and the ReferenceIntersector wrapper class.

I did not implement any sample code demonstrating this, because I wanted to generalise the straight beam cylinder solution to a more general arbitrary curve case.

Sweep Along Location Curve Offset Downwards

Once I had the working solution using a cylinder defined by the straight beam location line offset downwards, I realised that it might be nice to use more generic sweep along curve functionality instead. After all, the beam location curve might not be straight, and a non-linear location curve can quite simply be used to generate a non-linear solid using the CreateSweptGeometry method instead of CreateExtrusionGeometry.

My first attempt caused the CreateSweptGeometry method to throw an exception saying that "The given attachment point don't lie in the plane of the Curve Loop. Parameter name: pathAttachmentCrvIdx & pathAttachmentParam". That was my fault, though, because I was providing zero for the parameter value, which is probably the normalised curve start point parameter. When providing the raw parameter value returned by curve.get_EndParameter( 0 ) instead, all works fine.

Here is a rather unrealistic sample spline beam that I used for testing:

The algorithm reports the following supporting columns for the spline beam:

All is well.

Conclusion and Source Code

Here is the complete source code of this command, including the test branches that are disabled by default. As said, they can be enabled and tested by modifying the Boolean switches interactively in the debugger.

[Transaction( TransactionMode.ReadOnly )]
public class Command : IExternalCommand
{
  const double _eps = 0.1e-9;
 
  double SignedDistanceTo( Plane plane, XYZ p )
  {
    XYZ v = plane.Normal;
    return v.DotProduct( p )
      - v.DotProduct( plane.Origin );
  }
 
  class BeamPickFilter : ISelectionFilter
  {
    public bool AllowElement( Element e )
    {
      return null != e.Category
        && e.Category.Id.IntegerValue.Equals(
          (int) BuiltInCategory.OST_StructuralFraming );
    }
 
    public bool AllowReference( Reference r, XYZ p )
    {
      return true;
    }
  }
 
  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;
    Element beam = null;
 
    try
    {
      Selection sel = uidoc.Selection;
 
      Reference r = sel.PickObject(
        ObjectType.Element,
        new BeamPickFilter(),
        "Please select a beam" );
 
      beam = doc.GetElement( r );
    }
    catch( RvtOperationCanceledException )
    {
      return Result.Cancelled;
    }
 
    List<ElementId> columnIds = null;
 
    // Optionally switch between different tests
    // by modifying these values in the debugger
 
    bool useBoundingBox = false;
    bool useSolid = false;
    bool useElement = false;
    bool useGeneratingIds = false;
    bool useLocation = true;
 
    #region Obsolete previous attempts
    if( useBoundingBox )
    {
      BoundingBoxXYZ box = beam.get_BoundingBox( null );
 
      Outline outline = new Outline( box.Min, box.Max );
 
      ElementFilter bbfilter = new BoundingBoxIntersectsFilter(
        outline, 0.1 );
 
      FilteredElementCollector columns
        = new FilteredElementCollector( doc )
          .WhereElementIsNotElementType()
          .OfCategory( BuiltInCategory.OST_StructuralColumns )
          .WherePasses( bbfilter );
    }
 
    if( useSolid )
    {
      Options opt = app.Create.NewGeometryOptions();
      GeometryElement geo = beam.get_Geometry( opt );
      Solid solid = null;
 
      foreach( GeometryObject obj in geo )
      {
        solid = obj as Solid;
 
        if( null != solid
          && 0 < solid.Faces.Size )
        {
          break;
        }
      }
 
      ElementFilter beamIntersectFilter
        = new ElementIntersectsSolidFilter( solid );
 
      FilteredElementCollector columns
        = new FilteredElementCollector( doc )
          .WhereElementIsNotElementType()
          .OfCategory( BuiltInCategory.OST_StructuralColumns )
          .WherePasses( beamIntersectFilter );
    }
 
    if( useElement )
    {
      // Initially, no columns are found to 
      // intersect the beam. Maybe it will help to
      // move the beam down a bit?
 
      using( TransactionGroup txg = new TransactionGroup( doc ) )
      {
        txg.Start( "Find Columns Intersecting Beam" );
 
        using( Transaction tx = new Transaction( doc ) )
        {
          tx.Start( "Temporarily Move Beam Down a Little" );
 
          ElementTransformUtils.MoveElement(
            doc, beam.Id, -0.1 * XYZ.BasisZ );
 
          tx.Commit();
        }
 
        ElementFilter beamIntersectFilter
          = new ElementIntersectsElementFilter( beam );
 
        FilteredElementCollector columns
          = new FilteredElementCollector( doc )
            .WhereElementIsNotElementType()
            .OfCategory( BuiltInCategory.OST_StructuralColumns )
            .WherePasses( beamIntersectFilter );
 
        columnIds = new List<ElementId>(
          columns.ToElementIds() );
 
        // We do not commit the transaction group, 
        // because no modifications should be saved.
        // The transaction group is only created and 
        // started to encapsulate the transactions 
        // required by the IsolateElementTemporary 
        // method. Since the transaction group is not 
        // committed, the changes are automatically 
        // discarded.
 
        //txg.Commit();
      }
    }
 
    if( useGeneratingIds )
    {
      Options opt = app.Create.NewGeometryOptions();
      GeometryElement geo = beam.get_Geometry( opt );
 
      foreach( GeometryObject obj in geo )
      {
        Solid solid = obj as Solid;
 
        if( null != solid )
        {
          foreach( Face f in solid.Faces )
          {
            ICollection<ElementId> ids
              = beam.GetGeneratingElementIds( f );
 
            foreach( ElementId id in ids )
            {
              Element e = doc.GetElement( id );
              if( null != e.Category
                && e.Category.Id.IntegerValue.Equals(
                  (int) BuiltInCategory.OST_StructuralColumns ) )
              {
                columnIds.Add( id );
              }
            }
          }
        }
      }
    }
    #endregion // Obsolete previous attempts
 
    if( useLocation )
    {
      // Determine beam location curve for 
      // extrusion direction and length
 
      LocationCurve lc = beam.Location as LocationCurve;
 
      Curve curve = lc.Curve;
 
      Solid solid = null;
 
      // Handle generic curve parameters.
      // See below for simplified linear case.
 
      XYZ p = curve.get_EndPoint( 0 );
      double param = curve.get_EndParameter( 0 );
      Transform transform = curve.ComputeDerivatives( param, false );
      Debug.Assert( p.IsAlmostEqualTo( transform.Origin ),
        "expected derivative origin to equal evaluation curve point" );
      XYZ tangent = transform.BasisX;
 
      // Use bounding box to determine elevation of
      // bottom of beam and how far downwards to 
      // offset location line -- one inch below 
      // beam bottom.
 
      BoundingBoxXYZ bb = beam.get_BoundingBox( null );
 
      Debug.Assert( .001 > bb.Min.Z - bb.Max.Z,
        "expected horizontal beam" );
 
      double inch = 1.0 / 12.0;
      double beamBottom = bb.Min.Z;
 
      XYZ arcCenter = new XYZ( p.X, p.Y,
        beamBottom - inch );
 
      Plane plane = new Plane( tangent, arcCenter );
 
      CurveLoop profileLoop = new CurveLoop();
 
      Autodesk.Revit.Creation.Application creapp
        = app.Create;
 
      Arc arc1 = creapp.NewArc(
        plane, inch, 0, Math.PI );
 
      Arc arc2 = creapp.NewArc(
        plane, inch, Math.PI, 2 * Math.PI );
 
      profileLoop.Append( arc1 );
      profileLoop.Append( arc2 );
 
      List<CurveLoop> loops = new List<CurveLoop>( 1 );
      loops.Add( profileLoop );
 
      // Switch this on to handle a straight beam as 
      // a separate simplified case using 
      // CreateExtrusionGeometry instead of the 
      // generic CreateSweptGeometry solution.
 
      bool checkForLine = false;
 
      if( checkForLine && curve is Line )
      {
        XYZ q = curve.get_EndPoint( 1 );
        XYZ v = q - p;
 
        Debug.Assert( 0.01 > v.Z,
          "expected horizontal beam" );
 
        Debug.Assert( v.IsAlmostEqualTo( tangent ),
          "expected straight beam vector to equal start tangent" );
 
        solid = GeometryCreationUtilities
          .CreateExtrusionGeometry( loops, v, v.GetLength() );
      }
      else
      {
        // Offset location curve downward 
        // one inch  below beam bottom face
 
        XYZ offset = arcCenter - p;
 
        transform = Transform.get_Translation(
          offset );
 
        CurveLoop sweepPath = new CurveLoop();
 
        sweepPath.Append( curve.get_Transformed(
          transform ) );
 
        solid = GeometryCreationUtilities
          .CreateSweptGeometry(
            sweepPath, 0, param, loops );
      }
 
      ElementFilter beamIntersectFilter
        = new ElementIntersectsSolidFilter( solid );
 
      columnIds = new List<ElementId>(
        new FilteredElementCollector( doc )
          .WhereElementIsNotElementType()
          .OfCategory( BuiltInCategory.OST_StructuralColumns )
          .WherePasses( beamIntersectFilter )
          .ToElementIds() );
    }
 
    int n = (null == columnIds)
      ? 0
      : columnIds.Count<ElementId>();
 
    string s1 = string.Format(
      "Selected beam is supported by {0} column{1}{2}",
      n,
      ( 1 == n ? "" : "s" ),
      ( 0 == n ? "." : ":" ) );
 
    string s2 = "<None>";
 
    if( 0 < n )
    {
      uidoc.Selection.Elements.Clear();
 
      foreach( ElementId id in columnIds )
      {
        Element e = doc.GetElement( id );
        uidoc.Selection.Elements.Add( e );
      }
 
      s2 = string.Join( ", ",
        columnIds.ConvertAll<string>(
          id => id.IntegerValue.ToString() ) );
    }
 
    TaskDialog.Show( s1, s2 );
 
    return Result.Succeeded;
  }
}

For your convenience, here is GetBeamColumns06.zip containing the complete source code, Visual Studio solution and add-in manifest of the GetBeamColumns external command.

I hope you find this both interesting and useful as a basis for your own variants.

ADN Revit API Training Material Update and Vacation

After cleaning up the usage of deprecated Revit API calls in The Building Coder samples, I decided to clean up the ADN training material as well.

My original plan was to remove all warnings about deprecated API usage, only I quickly discovered there were none to remove :-)

In the MEP sample application AdnRme, I just updated the year listed in the copyright message to 2013 and produced AdnRme version 2013.0.2.0.

I then did the same for the ADN Revit API Training labs and the Revit Structure API samples.

Here is the result of that, adn_src_2013-02-15.zip, containing the following solutions and projects:

• lab
  • 1_Revit_API_Intro
  • 2_Revit_UI_API
  • 3_Revit_Family_API
  • XtraCs
  • XtraVb
• rme
  • AdnRme
• rst
  • labs
  • link
  • NewRstLab
  • RstAvfDmu

Vacation Time

This is the last post before my vacation. Well, actually, this is already during my vacation.

I am hopping on a train in a minute and departing for Italy with unknown itinerary and goals. A possible candidate is Lecce, in the far south.

I'll be back in two and a half week's time, and keep you posted, maybe.

Bye!

Revit 2013 Unit Conversion Utility

Here is a Revit 2013 update of the Revit 2011 unit conversion utility, originally posted and described for Revit 2010, by Harry Mattison.

In his own words:

I was looking at the great unit conversion utility and created a new version upgraded to Revit 2013 that I thought you readers might enjoy.

I ran into one issue that required a code enhancement to catch an exception thrown by many parameters, such as HVAC_Temperature, HVAC_Slope, etc.

The rest of the code handles error conditions nicely, so I was surprised to see these uncaught exceptions.

I solved it by adding a try/catch statement around the existing call to AddParameter in frmUnitConversions.cs:

  if( null == _Parameter )
  {
    // Create a new parameter
 
    try
    {
      _Parameter
        = _DbDocument.FamilyManager.AddParameter(
          parameterTypeToCreate.ToString(),
          BuiltInParameterGroup.INVALID,
          parameterTypeToCreate,
          false );
    }
    catch( Exception ex )
    {
      TaskDialog.Show( "Error",
        "Cannot create parameter '"
        + parameterTypeToCreate.ToString()
        + "' with parameter type '"
        + parameterTypeToCreate
        + "' because of exception\n"
        + ex.Message.ToString() );
 
      return;
    }
  }

I think I figured out what is causing this and thought it would be interesting to share with your blog readers:

I am creating family parameters from a shared parameter file. Some parameters have types that are not supported in the version of Revit that I am currently using, which is Revit Architecture.

I created this function to detect the situation:

  public static bool canGetFormatOptions(
    Document doc,
    FamilyParameter familyParameter )
  {
    try
    {
      UnitType parameterUnitType
        = ConvertParameterTypeToUnitType(
          familyParameter.Definition.ParameterType );
 
      doc.ProjectUnit.get_FormatOptions(
        parameterUnitType );
 
      return true;
    }
    catch
    {
      return false;
    }
  }

I use it like this:

  if( !canGetFormatOptions(
    famDoc, familyParameter ) )
  {
    TaskDialog.Show( "Error",
      "Cannot set parameter value.\nUnit Type "
      + ConvertParameterTypeToUnitType(
        familyParameter.Definition.ParameterType )
      + " is not supported in Revit "
      + famDoc.Application.Product.ToString() );
  }

Take care.

The updated code is provided above.

Many thanks to Harry for this update with his enhancement and analysis!

Revit 2013 Update Release 2

Revit 2013 Update Release 2 is now available.

I found a path to the Revit Architecture update via Autodesk Revit Products > Services & Support > Service Packs & Downloads > Autodesk Revit Architecture > Updates > Revit Architecture 2013 Update Release 2.

Phew. That was rather hard.

A much easier way to reach the exact download I am after is to enter the appropriate string in Google. That takes me directly to the download page with no need to manually traverse any convoluted search paths.

Here is a list of the Google search strings I entered and the resulting URLs:

• autodesk revit 2013 ultimate design suite update 2.
• autodesk revit 2013 architecture update 2
• autodesk revit 2013 mep update 2
• autodesk revit 2013 structure update 2

Here are the enhancements listed for this update. API enhancements are not included this time, unfortunately, but there are some of those in there as well:

Revit Architecture

• Improves stability when upgrading 2012 project which contains analytical walls.
• Improves stability when adjusting multiple sketch lines of a floor at the same moment.
• Improves stability when editing the gutters on a roof object with the Add/Remove Segment tool.
• Improves stability when renaming a Stair run type or landing to ‘none’.
• Improves stability when using the ribbon Cancel Edit Mode button to exit Stair Edit Mode.
• Improves stability when using an open profile for a wall sweep.
• Improves stability when splitting a wall.

Revit Structure

• Enables the Area, Area Boundary and Tag Area ribbon commands.
• Improves stability when using Beam Systems.
• Improves the respect of the Top In-Plane parameter for Analytical Models Walls after wall is modified.
• Improves the joining of Rebar to the host surfaces.
• Improves retention of Rebar Shapes upgraded within Revit 2012 projects.
• Improves stability when editing Rebar Shapes in the Family Editor.
• Improves display of underlay items in non-wireframe Structural Views.

Revit MEP

• Improves stability when sizing Duct.
• Corrects the use of tees when specified in duct routing preferences within projects upgraded from Revit 2012.
• Improves stability when upgrading a pipe fitting connected to multiple systems.
• Improves stability when editing duct fitting size in the active view and then editing the duct fitting type in the Property Palette.

Revit Platform

• Improves stability when Save to Central or Sync with Central.
• Improves stability when utilizing Create Assembly Views from the project browser.
• Improves stability when editing a label within the family editor.
• Improves stability when saving file to a location with low disc space.
• Improves stability when launching Export gbXML Settings dialog.
• Improves stability and memory usage within graphics display.
• Improves stability during IFC data import which contains openings with no usable geometry.
• Improves stability when importing IFC data which imported into Revit 2012 with warnings.
• Improves import of clipped solids during IFC import.
• Improves IFC Export to support buildingSMART International IFC certification.
• Improves stability when linking or attached DWG files.
• Improves stability of printing after Export to DWG or DXF format.
• Improves stability when creating, duplicating or deleting a material in the Material Editor.
• Improves the retention of part parameters within a part upgraded from Revit 2012.
• Corrects ribbon tab population after installing .NET 4.5
• Improves stability while editing calculated values within a schedule after deleting a parameter used in a formula.
• Improves stability with schedules which contains a filter based upon a user defined parameter and elements in linked files do not contain the user defined parameter.
• Improves stability when opening Sun Settings dialog.
• Improves stability when editing Text Notes.
• Improves stability when upgrading Revit 2012 project to Revit 2013.
• Improves stability when moving a Crop Region which utilizes the disjoin option.

The build identifier is 20121003_2115 Update Release 2.

Updating Properties and Announcing Revit LT

Today, exceptionally, a second post, partly to highlight an interesting comment submitted by Jinshou on how to programmatically trigger a refresh of the Revit element properties window, and partly to announce a non-API issue, totally non-API, the imminent arrival of Autodesk Revit LT.

Refreshing Revit Element Properties

If I first invoke the UIApplication OpenAndActivateDocument method, then highlight elements as described in a previous post, the 'properties' window is updated.

The trick is that in order to call OpenAndActivateDocument on the document containing the elements to highlight, you have to first ensure that it is not the active document. To achieve this, I:

• Create an empty RVT file.
• Invoke OpenAndActivateDocument to activate that.
• Invoke OpenAndActivateDocument again on the document of interest.
• Highlight the elements.
• Don't forget to close the empty RVT file when finished.

Many thanks to Jinshou for this interesting hint.

Announcing Autodesk Revit LT

For the nonce, here is an announcement completely unrelated to the Revit API. In fact, the product announced is specifically designed to not be customisable.

Autodesk today announced Autodesk Revit LT software, a new addition to its award winning family of Revit software products. Designed for architects, designers and building industry professionals using 2D workflows who are looking to transition to the Building Information Modeling (BIM) process, Autodesk Revit LT software delivers a focused 3D application to help users create higher-quality and more accurate designs and documentation.

"Autodesk Revit LT reflects our commitment to provide architects, designers and building professionals, particularly those in small firms, the tools they need to ease the transition to get started with – and take advantage of – a BIM workflow," said Amar Hanspal, Autodesk senior vice president, information modeling products. "With Revit LT, customers can deliver higher-quality, more accurate designs and documentation – allowing them to bring projects to market faster and save time and money."

Autodesk Revit LT is built on the Revit platform for BIM and allows users to create designs efficiently with 3D, real-world building objects to produce reliable, coordinated documentation faster. Revit-based applications help deliver better coordination and quality, and can contribute to higher profitability for architects, design professionals and the rest of the building team. Some of the benefits of Revit LT include:

• Work more efficiently with a single, coordinated model that allows users to concurrently design and document building projects. Autodesk Revit LT automatically manages iterative changes to building models throughout the documentation process. As a result, a consistent representation of the building is maintained, helping to improve drawing coordination and reducing errors.
• Design and visualize in 3D. Revit LT allows users to see their designs virtually, improving their understanding of the building and its spaces, and helping them communicate design ideas to clients more clearly and effectively.
• Create photorealistic renderings in the cloud. Users who purchase Autodesk Subscription with Revit LT can render in the cloud directly from the Revit LT interface, enabling them to produce compelling, photorealistic visualizations without tying up their desktop
• Exchange designs in the DWG or RVT file formats. Produce designs in the DWG file format, and experience fluid file exchange with project team members using other Autodesk Revit software applications.

Availability

Autodesk Revit LT 2013 is scheduled to be available within the month in North America and in select countries worldwide. The product is available as a standalone version and as part of the new AutoCAD Revit LT Suite 2013, which includes both Autodesk Revit LT 2013 and AutoCAD LT 2013. Product availability varies by country. Details and purchasing options are available at www.autodesk.com/revitlt

Vacation Time and Various Notes

To tell the truth, today is not a vacation day, but the Swiss national holiday, right in the middle of my vacation.

In my last post, I mentioned various urgent and important issues that I still wanted to take care of.

I am very happy to tell you that these items all felt a lot less urgent and important after immersing myself in a couple of days of vacation in Avignon to visit family and attend some offerings of one of the world's biggest theatre events, the annual Avignon theatre festival, and especially its less official 'OFF' sibling, initiated by independent theatre companies.

The main reason for my visit were my relatives, though, and not the festival, although I did attend a couple of shows and loved the buzzing activity everywhere.

I also went climbing in Collias, paddling on the Gardon, enjoyed the spectacular Pont du Gard, and revelled in the atmosphere and warm summer nights in the city.

As I once mentioned, I also love the trip itself down to Avignon along back roads and desolate river gorges. The main discovery this time around was the beautiful Lac du Bourget, where I was mysteriously and magically lent a gorgeous wooden canoe to go paddling around in between rounds of swimming.

Meanwhile, here are a couple of work and Revit API related thingies that were either pending publication or hanging around my inbox that I would like to share with you:

• Revit API overview
• Presenting colour coded source code
• Preview control with linked document
• Calculating the mass of a building element

Revit API Overview

We regularly hear requests for a Revit API overview.

The first and foremost place to look is in the material provided in the Revit Developer Center and in the developer guide wiki. The Revit Developer Center provides a host of self-learning material as well.

By the way, due to popular demand, a new lesson on debugging has been added to the My First Revit Plug-in tutorial: Lesson 4: Debugging the code.

Both the Revit 2012 API Labs and the Revit API Webcast Archive include various versions of API overviews as well.

The DevDays Online presentation on What's New in Revit 2013 and the follow-up Revit 2013 API webcast complementing it both discuss new features of the Revit 2013 API, and the first half of the latter is completely dedicated to the basics of the Revit API in general and is independent of the current version.

Ritchie Jackson also created a complete Revit API Introduction from a completely different point of view.

Presenting Colour Coded Source Code

Here are some tips on pasting colour coded source code into a PowerPoint slide deck.

a) Simple One-step Approach via HTML

• Use CopyToHTML in Visual Studio to copy the colour coded source code into the clipboard in HTML format.
• In PowerPoint, use Home > Paste > Arrow down > Paste Special... > HTML format to paste.

b) Safer Two-step Approach via Word and RTF

You may have a still better result using Word in an intermediate step. In that case, you don't even need to copy as HTML from VS; you can just use the standard copy. In Word, first paste the code, then select and copy it again from Word. Now, in PowerPoint, use Home > Paste > Arrow down > Paste Special... > RTF format to paste it in.

Colour Coded Source Code for Black Slides

If your slides use a black background, and you are using a white background in VS, your black source code will be invisible. In that case, in VS, you can go to Tools > Options... > Environment > Fonts and Colors > Item background and set that to black, set the item foreground to white, and hit OK.

Another option besides using CopySourceAsHtml is Notepad++, which supports many other languages, including JavaScript.

Preview Control with Linked Document

One if the new Revit 2013 API features is the preview control, supporting enhanced integration between Revit and an add-in.

I presented a minimal sample named PreviewControlSimple making use of it in my DevCamp session on the Revit 2013 UI API enhancements, and a more complete and complex one is given by the UIAPI Revit SDK sample.

Here is a question that was not yet addressed, though:

Question: Is it possible to use the preview control with a linked document? I tried to do so, and it throws an exception saying "Cannot preview a linked document".

Answer: This is by design: a linked document cannot be previewed using this control.

One workaround would be to close the project document, open the linked document and preview it then.

Another would be to create a new view in your project, display the linked instance in it, hide all other instances, and send that view to the preview control.

Calculating the Mass of a Building Element

And finally, another pretty fundamental little BIM question that has been hanging around waiting to be published for a while:

Question: How can I determine the mass of a building element?

I am working with data sets providing certain crucial calculation values based on material mass.

I can see how to calculate volume and area in the Revit API, but I see no API call to calculate mass.

Is there any way to calculate a Revit model element's material mass through the API?

Answer: You can query the material for its density, and ask the building element for its volume.

The volume obviously needs to be provided for several different materials per building element, e.g. for the different layers of the compound structure of a complex wall or floor, so you can use the Category.HasMaterialQuantities property to check which materials contribute volume and the Element.GetMaterialVolume method to determine the volume of a specific material for a given element.

The density can be obtained from the Density property on StructuralAsset, which can be retrieved from Material.StructuralAssetId and PropertySetElement.GetStructuralAsset.

A related issue and a different access to the density in the context of AMEE is discussed by David Laing in his thread on calculating element material mass.

That is all from me for now. I still have to relax a bit more...

UR1 and Line Origin versus Start and End Point

My official vacation time has begun. I still have rather a backlog of important, pending, almost completed projects, unanswered blog comments, and unavoidable meetings, so I will be online now and then in spite of that.

I also want to keep us all updated on important little titbits such as the UR1:

Revit 2013 Update Release 1

The Revit 2013 Update Release 1 is now available for download and installation from the web and within the product through Communication Center. Here are links to the appropriate update pages:

• Revit 2013 UR1
• Revit Architecture 2013 UR1
• Revit MEP 2013 UR1
• Revit Structure 2013 UR1

The build identifier is 20120716_1115.

Here is a list of the API enhancements implemented in this update:

• Allows Document.PostFailure to be used to post multiple errors during a single transaction that do not reference an ElementId.
• Improves stability using UIApplication.DoDragDrop when a Revit command (such as the Wall tool) was active.
• Improves stability by disabling keyboard shortcuts (except view zoom shortcuts) when a PreviewControl is active.
• Improves stability in ReferenceIntersector.FindNearest() when no matching target pick is found.
• Corrects validation logic to allow NewFamilyInstance to place face-based families on transformed family instances.
• Dimension.Above and Dimension.Below now update the dimension after their data is changed without requiring any user action.
• The properties MechanicalSystem.SystemType, ElectricalConnector.SystemType, PipeConnector.SystemType are obsolete in Revit 2013. Instead query the parameter RBS_DUCT_CONNECTOR_SYSTEM_CLASSIFICATION_PARAM on ConnectorElement.
• Corrects data reported with ConnectorManager.UnusedConnectors.
• Fixes a file corruption that could occur when extensible storage data was added to an element in a central file.
• Improves stability when saving a file with extensible storage data that overwrites an existing file that also contains extensible storage.
• RVT Links created with RevitLinkType.Create will remain loaded when the RVT containing the link is reopened.
• Previously, setting 'suppressBendRadius' to true in method Rebar.GetCenterlineCurves() would cause both fillet bends and user-drawn, parameterized arcs to be omitted from the collection of curves returned by the method. The method now omits only the fillet bends; the drawn arcs are included along with the straight edges.
• Updates Rebar.GetCenterlineCurves() method with an additional argument: a MultiplanarOption (enum), which should be set to IncludeAllMultiplanarCurves or IncludeOnlyPlanarCurves. This argument controls whether all curves of a multi-planar Rebar instance are returned, or only those which lie in the primary plane.
• Enables method Rebar.ComputeDrivingCurves(). This method returns a collection of curves that includes the lines and arcs that drive the shape, but excludes fillets and hooks. It is equivalent to calling GetCenterlinCurves(adjustForSelfIntersection=false, suppressHooks=true, suppressBendRadius=true, multiplanarOption=IncludeOnlyPlanarCurves)
• Improvements have been made in RebarShape methods that deal with matching RebarShapes to collections of curves: CreateFromCurvesAndShape(), RebarShapeMatchesCurvesAndHooks().
• Corrects behavior ot RebarShape.Create() method to not ignore the out-of-plane bend diameter specified in the RebarShapeMultiplanarDefinition argument object, and always used an internal default value.

Meanwhile, here is a neat little interesting and basic geometrical Revit API question that arose last week:

Relationship of Line Origin, Start and End Point

Question: When examining the AnalyticalSurface of a floor in my sample model, I noticed that the Origin property of a certain Line instance is not equal to either of its end points returned by the EndPoint property (get_EndPoint method in C#).

Until now, I had assumed that the Origin property of a line is always equal to one of its end points.

Could you please clarify:

1. What exactly is the definition of a line's Origin property?
2. How does the line origin relate to its end points?

Answer: I already presented some basic facts on the Revit API lines, curves and their parameterisations from Scott Conover's AU 2009 class on analysing building geometry, which he has continued updating, most recently for the AEC DevCamp 2012 (finalised material).

To answer your questions directly:

1. The line origin and direction define the location of the infinite unbounded line. The start and end point of the bounded line can lie anywhere along this line.
2. The origin always lies somewhere on the infinite unbounded line. There is no guarantee that it will coincide with either the start or end point of the bounded line, though. The origin of a bounded line may even lie outside the bounded part of the infinite line.

I hope this helps clarify things.

Anyway, now I'm off to the sunny Provence!

Update API Assembly References and Wizards

I finally completed my disk clean-up and managed to install the Autodesk Building Design Suite Ultimate 2013. Phew.

Update API Assembly References

That requires me to update the Revit API references in the projects I am working on accordingly.

In order to easily compile all the SDK samples, I always create copies of the Revit API assemblies in the default installation locations for Revit Architecture, MEP and Structure.

Here is the batch file cprvtapi.bat that I used to achieve this after installing the onebox version of Revit 2013:

@echo off
set a=C:\Program Files\Autodesk
set b=Revit 2013\Program

set c=Revit Architecture 2013\Program

copy "%a%\%b%\RevitAPI.dll" "%a%\%c%"
copy "%a%\%b%\RevitAPIUI.dll" "%a%\%c%"
copy "%a%\%b%\RevitAddInUtility.dll" "%a%\%c%"

set c=Revit MEP 2013\Program

copy "%a%\%b%\RevitAPI.dll" "%a%\%c%"
copy "%a%\%b%\RevitAPIUI.dll" "%a%\%c%"

set c=Revit Structure 2013\Program

copy "%a%\%b%\RevitAPI.dll" "%a%\%c%"
copy "%a%\%b%\RevitAPIUI.dll" "%a%\%c%"

set a=
set b=
set c=

Autodesk University Proposals Confirmed and Requested

I was notified yesterday that my AU proposals were accepted, so now I know where I will be spending my next birthday again.

I will be presenting two lectures and participating in one panel with members of the Revit API development team and ADN DevTech AEC workgroup:

• CP4107 Let's face it: New Autodesk Revit 2013 UI API Functionality
• CP4108 Revit MEP Programming: All Systems Go
• CP4109 Revit API Round Table: Meet the Champions

One advantage of these two lectures is that the AEC DevCamp class material can be reused for preparing them:

• 1-4 Revit 2013 UI API enhancements
• 2-7 Revit MEP API

Another advantage is that they have consecutive numbers, making them easier to remember for me :-)

Whereas the live AU proposals have been submitted and processed by now, the Autodesk University Virtual call for proposals just opened and we are eagerly awaiting your submissions.

Updated Revit Add-in Wizards for C# and VB

After finally installing the official release of Revit, I updated my Revit add-in wizard and also re-implemented the VB one.

Basically, all that needed doing was to replace all occurrences of "Revit Quasar RP" by "Revit 2013" in the *.csproj and *.vbproj project files. They occur in the StartProgram and HintPath tags.

The boiler-place code now creates a 'using' statement around the dummy transaction, and I changed the default version strings in the assembly properties from "1.0.0.0" to "1.0.*" to take advantage of the automatically generated build numbers.

For the full description of the wizards, please refer to these previous posts:

• Original introduction, benefits, and usage example for C# and VB.
• Personalised minimal C# version for Revit 2011.
• A short additional usage note.
• 64 bit versions for C# and VB.
• Revit 2012 C# and VB version.
• Updated C# and VB versions placing assembly DLL alongside add-in manifest and including other changes.
• Revit 2013 wizard for C# only.

To install, simply copy the appropriate zip file to the Visual Studio C# or VB project template folder in your local file system:

• Revit2013AddinWizardCs.zip – copy to
  [My Documents]\Visual Studio 2010\Templates\ProjectTemplates\Visual C#
• Revit2013AddinWizardVb.zip – copy to
  [My Documents]\Visual Studio 2010\Templates\ProjectTemplates\Visual Basic

The Revit 2013 Structure API

I migrated the ADN Revit Structure API training material to Revit 2013, which led me to put together the following summary of the structural API enhancements and some details of the migration steps:

• API enhancements
• RstLabs migration
• NewRstLab migration
• RstAvfDmu migration
• Materials

Revit Structure 2013 API Enhancements

I mentioned a few structure specific enhancements in the Revit 2013 API. They are discussed in somewhat more detail in the DevDays Online presentation on What's New in Revit 2013 and the complementary Revit 2013 API webcast, of which the first half provides an introduction to the Revit API in general, and the second covers some new 2013 specific features in more depth.

Actually, it was the webcast preparation that prompted me to start performing the migration described below, which in turn prompted me to publish the result and summarise the changes.

To recap, the structural enhancements include:

Structural Product Related Enhancements

Before we get to the detailed API changes, here are some notes on the main product goals and features:

Reinforcement detailing to help extend the BIM lifecycle from design to construction through detailing and fabrication:

• Area/path reinforcement to host real rebar and set
• Welded wire mesh
• Reinforcement fillets and hooks
• Additional reinforcement units
• Rebar cover

Structural analysis in BIM moving towards delivering structural analysis in the cloud and supporting partner ecosystem growth by

• Results storage, visualization and exploration in RST
• Improved analytical models for surface elements
• Seamless workflow between RST/RSA
• Improved rigid links

Structural analysis web service and visualisation to democratize analysis and make it more accessible, easy to both use and provide. Long term, we would like to deliver structural analysis in the cloud and thus support partner ecosystem growth. Support for modal and deformation analysis, enhanced results visualization.

Enhanced physical properties to centralize analysis workflows around BIM data and improve the efficiency of BIM-based analysis workflows.

• Extended thermal and structural properties of building envelope
• Material authoring and library management workflows
• Foundation for material ecosystem
• Data flow with key Building Performance and Structural Analysis applications

Now let's look at how these changes affect the API:

Reinforcement

The Rebar class provides a number of new methods and properties:

• CreateFromCurvesAndShape
• GetBarPositionTransform
• GetBarExistsAtPosition
• GetHookTypeId/SetHookTypeId
• RebarShapeMatchesCurvesAndHooks
• ScheduleMark
• TotalLength
• Volume

The Rebar.GetCenterlineCurves method takes new arguments to control

• Adjustment for self-intersection
• Inclusion of hooks
• Inclusion of bend radius curves (fillets)

The BarDescription class is now obsolete and replaced by the new RebarInSystem class representing a bar in an AreaReinforcement or PathReinforcement system, providing access to individual rebars in a system and the ability to switch back and forth between system and individual elements.

A new class ReinforcementSettings is provided. When ReinforcementSettings.HostStructuralRebar is true, area and path reinforcement elements create individual rebar elements that participate in views and schedules. The individual RebarInSystem elements have the same graphical representation and parameters as Rebar elements, and have the same API methods for inquiry. Since the RebarInSystem elements are almost entirely controlled by their area or path system element, they lack most of the modification methods of the Rebar class.

These two system classes now have types, and provide new members to retrieve system members, curve boundaries, remove an element and convert its bars into standard rebar via the new methods GetRebarInSystemIds, RemoveAreaReinforcementSystem, and RemovePathReinforcementSystem.

Welded Wire Mesh

• FabricSheet
  • Planar sheet of welded wire mesh
  • Created and cut by FabricArea
  • Option to automatically add symbols and tags
• FabricArea
  • Creates and manages a distribution of FabricSheets
  • Allows sketched welded wire mesh objects
  • Planar hosts only, identical criteria to Area and Path Reinforcement
• Related type classes
  • FabricAreaType provides identity data
  • FabricSheetType includes uncut dimensions, wire sizes and layouts
  • FabricWireType defines wire diameter

Physical Properties

• Structural family instances support additional structural material element
• Structural and thermal material assets can be shared and set on materials

Structural Analytical Model

• New element type AnalyticalLink
• Created between two analytical elements, e.g. a beam and a column
• Two kinds of links: user-defined and automatically generated
• Access link properties like "fixity state"

Analysis Visualization Framework

• Support for deformed shapes as part of AVF display
• AnalysisDisplayStyleDeformedShapeTextLabelType
• AnalysisDisplayDeformedShapeSettings input argument to new CreateAnalysisDisplayStyle override

Revit Structure Labs RstLabs Migration

As said, I migrated the Revit Structure API material from 2012 to 2013, starting with the labs RstLabs. The standard steps are getting to be a habit, after already completing the The Building Coder samples, ADN Revit API training labs, AdnRme Revit MEP API and extensible storage samples:

• Updated the Revit API assembly references.
• Set the target .NET framework version to 4.
• Removed the warnings caused by calls to the Element property in VB, represented as a call to the get_Element method n C#, replacing them by the new Revit 2013 GetElement method, which has the advantage of looking identical in both languages.

After that, no warnings remain.

There are four errors, though, which all are caused by the removal of the LOAD_USE_LOCAL_COORDINATE_SYSTEM_HOSTED built-in parameter.

Since the parameter value retrieved is not used anywhere and the call is just to demonstrate the retrieval of a parameter value in general, I simply commented out the offending statements.

New Revit Structure Labs NewRstLab Migration

Standard stuff, same as before: change the Revit API assembly references, .NET framework version, and replace the use of the Element property by calls to GetElement.

I also replaced the test for a concrete column by new code, since the MaterialConcrete class no longer exists in Revit 2013. Here is the old code I replaced:

  MaterialSet materials = column.Materials;
 
  MaterialConcrete matConcrete = null;
 
  foreach( Material mat in materials )
  {
    // cast it to concrete material
    matConcrete = mat as MaterialConcrete; 
    break;
  }
  if( null == matConcrete )
  {
    messages = "The selected column is not concrete";
    trans.RollBack();
    return Result.Failed;
  }

The new code is much clearer and simpler:

  if( StructuralMaterialType.Concrete 
    != column.StructuralMaterialType )
  {
    messages = "The selected column is not concrete";
    trans.RollBack();
    return Result.Failed;
  }

Revit Structure AVF and DMU Sample RstAvfDmu Migration

RstAvfDmu is a dual sample by Saikat Bhattacharya on using the analysis visualisation framework AVF and the dynamic model update DMU in the context of Revit Structure.

The only significant change required is due to the GetCenterlineCurves method taking some additional arguments in Revit 2013:

  // For this we first access 
  // the rebar line geometry
 
  //Line rebarLine = rebar.Curves.get_Item( 
  //  0 ) as Line; // 2011
 
  //Line rebarLine = rebar.GetCenterlineCurves( 
  //  false )[0] as Line; // 2012
 
  Line rebarLine = rebar.GetCenterlineCurves(
    false, true, true )[0] as Line; // 2013

Materials

Here is rst_2013_2012-06-12.zip containing the result of my efforts so far, the Revit Structure 2013 versions of RstLabs, NewRstLab and RstAvfDmu.

The Revit Structure link sample RstLink is not yet completed, nor have I yet updated the Revit Structure API slide deck.

DevCamp Day Two

This morning I presented my second session, on some of the Revit 2013 UI API enhancements, in the Revit API beginner track. After that, I returned back to the Revit API expert one to attend the presentations on modeless interaction and IFC before presenting my final session on the Revit MEP API. Here then are my sessions of today, in chronological order:

• 1-4 Revit 2013 UI API enhancements
• 2-3 Asynchronous interactions
• 2-2 IFC export open source
• 2-7 Revit MEP API

Revit 2013 UI API Enhancements

Enhanced add-in integration is an important topic in the Revit 2013 API. This session discusses four of the add-in integration topics in more depth, building on a preceding presentation by Saikat Bhattacharya presenting a snapshot of the entire Revit UI API functionality:

• Revit progress bar notifications
• Options dialogue WPF custom extensions
• Embed and control a Revit view
• Drag and drop

All four of these are covered by existing SDK samples, the first by ProgressNotifier (Events), the others by the comprehensive UIAPI sample.

For someone like me, feeling a strong affinity to Winnie the Pooh, the "bear of very little brain", the existing SDK samples are way beyond simple comprehension and reuse, so I ended up creating four own extremely simple and minimal ones exercising these features in just a few lines of code each instead, to reduce the code and required audience comprehension power to an absolute minimum.

Revit progress bar notifications

To receive information about the current Revit progress bar status, you can subscribe to the ProgressChanged event.

The event handler will receive a ProgressChangedEventArgs instance providing the following properties:

• Caption – progress bar caption describing operation in progress
• Stage – current stage of the progress bar, one of Started, CaptionChanged, RangeChanged, PositionChanged, UserCancelled, Finished
• LowerRange – lower limit of range, always zero
• UpperRange – upper limit of range, any non-zero number
• Position – Value between zero and UpperRange incremented with "PositionChanged" stage

The ProgressNotifier SDK sample displays a WPF-based dialogue box. It provides a button to open and load a Revit model. Loading the selected file will cause a number of progress bar actions to execute. These actions are monitored and presented in a stack structure, since occasionally more than one progress bar event may be active simultaneously:

My new ProgressWatcher sample in much simpler and tracks all progress bar events by just printing the event argument data to the Visual Studio debug output window. This can be achieved in a very few lines of code, basically only one each to subscribe to the event and to access and print the progress bar event data:

[Transaction( TransactionMode.ReadOnly )]
public class Command : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication uiapp = commandData.Application;
    Application app = uiapp.Application;
 
    app.ProgressChanged 
      += new EventHandler<ProgressChangedEventArgs>( 
        OnProgressChanged );
 
    return Result.Succeeded;
  }
 
  void OnProgressChanged( 
    object sender, 
    ProgressChangedEventArgs e )
  {
    double percent = 100.0 * e.Position / e.UpperRange;
 
    Debug.Print( 
      "'{0}' stage {1} position {2} [{3}, {4}] ({5}%)",
      e.Caption, e.Stage, e.Position, e.LowerRange, 
      e.UpperRange, percent.ToString( "0.##" ) );
  }
}

Saving the output to a text file will allow you to analyse in detail the progress bar event sequence and nesting.

Options dialogue WPF custom extensions

In Revit 2013, an add-in can add its own custom tabs to the standard Revit Options dialogue.

This is achieved by defining a WPF control to display and subscribing to the UIApplication DisplayingOptionsDialog event.

The event handler receives an DisplayingOptionsDialogEventArgs instance. It has a PagesCount property providing the number of Options dialogue tabs including default Revit ones. It also sports the AddTab method that can be used to add a tab, providing a name and a handler for it. The handler information is encapsulated in the TabbedDialogExtension class.

The TabbedDialogExtension class provides a constructor taking two arguments, a WPF user control instance and an OK handler. These cannot be changed later. It provides methods to get and set contextual help, and properties to read the WPF control and OK handler. It also provides properties to both get and set the cancel and 'restore defaults' handlers:

• Control – the control
• OnOKAction – the ok handler
• OnCancelAction – the cancel handler
• OnRestoreDefaultsAction – the restore defaults handler

The UIAPI SDK sample adds several custom tabs demonstrating most available features.

I created a minimal sample named AddOptionsTab which defines the simplest possible WPF control with one single button to click:

If you click the button, the corresponding event handler on the form is called, which simply displays a task dialog:

If this tab has ever been activated after the Options dialogue was opened, its OK, cancel and 'restore defaults' handlers are called, depending on the user actions.

Here is the entire user control source code defining its handlers:

public partial class UserControl1 : UserControl
{
  string _name;
 
  public UserControl1( string name )
  {
    _name = name;
 
    InitializeComponent();
  }
 
  private void button1_Click( 
    object sender, 
    RoutedEventArgs e )
  {
    TaskDialog.Show( _name, "I was clicked..." );
  }
 
  public void OnOK()
  {
    TaskDialog.Show( _name, "OK" );
  }
 
  public void OnCancel()
  {
    TaskDialog.Show( _name, "OnCancel" );
  }
 
  public void OnRestoreDefaults()
  {
    TaskDialog.Show( _name, "OnRestoreDefaults" );
  }
}

The event handler code reacting to the Options dialogue displaying simply instantiates the user control, calls the TabbedDialogExtension constructor with it, and feeds that to the event handler arguments AddTab method:

void OnDisplayingOptionsDialog( 
  object sender, 
  DisplayingOptionsDialogEventArgs e )
{
  UserControl1 c = new UserControl1( 
    "DevCamp User Control" );
 
  e.AddTab( "DevCamp Custom Tab", 
    new TabbedDialogExtension( 
      c, c.OnOK ) );
}

The event handler is called each time the Options dialogue is invoked once the event has been subscribed to, which is achieved in a single line of code like this in the AddOptionsTab external command:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  UIApplication uiapp = commandData.Application;
 
  uiapp.DisplayingOptionsDialog 
    += new EventHandler<DisplayingOptionsDialogEventArgs>( 
      OnDisplayingOptionsDialog );
 
  return Result.Succeeded;
}

Embed and control a Revit view

Another of the add-in integration enhancements enables you to embed and control a Revit view in your own form, dialogue or window.

The new PreviewControl class presents a preview control to browse the Revit model. It takes two input arguments, a document and a view id. The hosting form or window must be modal. The View can be any graphical view, i.e. must be printable. Perspective views are also supported, and all 3D Views can be manipulated by view cube. The visibility and graphical settings of the view are effective and respected by the control.

The UIAPI SDK sample proves a demonstration of this as well, which allows you to interactively select any of the open documents to view, or even open a new one, and secondly presents a list of all the documents views for you to switch between. Each time you change any of these two selections, the current preview control is discarded and a new one is instantiated with the updated input arguments. These input arguments are the only way in which the add-in affects the view, all further interaction happens between the control and the user.

To use a Revit preview control, you simply create a standard .NET form and insert a WPF host in it. A suitable host is the System.Windows.Forms.Integration.ElementHost. You populate this with a new Revit preview control instance, e.g. like this

  elementHost.Child = new PreviewControl( 
    doc, view.Id );

The PreviewControl instance needs to be disposed of after use:

  PreviewControl vc = elementHost.Child
    as PreviewControl;

  if( vc != null ) { vc.Dispose(); }

Here is a code snippet showing how all the printable views can be retrieved using a filtered element collector:

  IEnumerable<View> views
    = new FilteredElementCollector( doc )
      .OfClass( typeof( View ) )
      .Cast<View>()
      .Where<View>( v => v.CanBePrinted );

I created a minimal sample application PreviewControlSimple for this DevCamp class with much less code (and functionality than the UIAPI one, since it just displays the current view of a document with no further ado.

It does add one interesting twist, though: to show exactly how the hosting form is set up, I implemented that twice over, first using the Visual Studio designer as usual, and then converting the form to be completely programmatically generated. Here is the DisplayRevitView method taking the document and view input arguments for the preview control. It also takes a third argument for the main Revit window, so that the generated control can be hooked up to that as a parent window. This defines an appropriate relationship between the two as far as the Windows OS is concerned, ensuring correct minimisation and restoration behaviour:

const string _caption_prefix
  = "Simple Revit Preview - ";
 
void DisplayRevitView( 
  Document doc,
  View view,
  IWin32Window owner )
{
 
  using( PreviewControl pc
    = new PreviewControl( doc, view.Id ) )
  {
 
#if CREATE_FORM_BY_CODE
 
    using( System.Windows.Forms.Form form
      = new System.Windows.Forms.Form() )
    {
      ElementHost elementHost = new ElementHost();
 
      elementHost.Location
        = new System.Drawing.Point( 0, 0 );
 
      elementHost.Dock = DockStyle.Fill;
      elementHost.TabIndex = 0;
      elementHost.Parent = form;
      elementHost.Child = pc;
 
      form.Text = _caption_prefix + view.Name;
      form.Controls.Add( elementHost );
      form.Size = new Size( 400, 400 );
      form.ShowDialog( owner );
    }
 
#else // if not CREATE_FORM_BY_CODE
 
    Form1 form = new Form1( pc );
    form.ShowDialog( owner );
 
#endif // CREATE_FORM_BY_CODE
 
  }
}

Please note that correct disposal of the preview control is ensured by the 'using' statement. This is similar to Arnošt's strong recommendation to always encapsulate Revit Transactions in a 'using' statement.

Calling this method from the external command mainline with the current document view is trivial. I add one line of code to access the Revit main window:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  IWin32Window revit_window
    = new JtWindowHandle(
      ComponentManager.ApplicationWindow );
 
  UIApplication uiapp = commandData.Application;
  UIDocument uidoc = uiapp.ActiveUIDocument;
  Document doc = uidoc.Document;
 
  View view = doc.ActiveView;
 
  DisplayRevitView( doc, view, revit_window );
 
  return Result.Succeeded;
}

Drag and Drop API

I recently discussed the new drag and drop functionality and the UIAPI sample command demonstrating it.

The UIApplication provides the new static DoDragDrop method, with two overloads:

• DoDragDrop( ICollection<string> ) – initiate a standard built-in Revit drag and drop operation taking a collection of file names.
• DoDragDrop( object, IDropHandler ) – initiate a drag and drop operation with a custom drop implementation.

This method is designed for use in a modeless form.

Please note that this is currently the one and only Revit API method not requiring a valid Revit API context.

This method can be called from your modeless form at any time, even without Revit giving you explicit permission to interact with the API via some form of callback or notification, as required for all other Revit API calls.

The behaviour of drag and drop given a list of filenames depends on the type of files, as I already recently pointed out:

• One AutoCAD format or image file dragged onto Revit – A new import placement editor is started to import the file.
• More than one AutoCAD format or image files dragged – A new import placement editor is started for the first file.
• One family file dragged onto Revit – The family is loaded, and an editor started to place an instance.
• More than one family file dragged onto Revit – All the families are loaded.
• More than one family file including other format files dragged – Revit tries to open all the files.
• Valid file or list of files is passed – Revit does its best to use them appropriately.
• Any files are not usable – Failure is signalled to user, no exception is thrown, add-in is not notified.

Here again, I implemented a new DevCamp sample add-in DragDropApi to be able to show the necessary steps in a simpler context than the corresponding UIAPI example.

Here are my four new Revit 2013 UI API samples AddOptionsTab, DragDropApi, PreviewControlSimple, ProgressWatcher and the slides I used.

Asynchronous Interactions

Arnošt Löbel already presented on this topic at Autodesk University 2011 in his class CP5381 'Asynchronous Interactions and Managing Modeless UI with the Autodesk Revit API', as mentioned in the overview of the AU 2011 Revit and AEC API sessions.

In this class, Arnošt also covered the new external events and demonstrated his ModelessForm_ExternalEvent, ModelessForm_IdlingEvent (ModelessDialog) and WorkThread (MultiThreading) SDK samples.

The conclusion of the presentation is the following pledge that we are all strongly recommended to take:

• I shall not call the API unless invoked by it
• I shall not call the API from anywhere but the main thread
• I shall call the API only, not directly the Revits UI
• I shall use the Idling event cautiously and considerably

Here is a snapshot of the entire slide deck. This is not the final version, which will be posted soon after the end of DevCamp.

IFC Export Open Source

Angel Velez is senior principal engineer in the Revit development team and presented on the IFC exporter open source project, covering the following main topics:

• Introduction
  • History of IFC in Revit
  • Why open source?
• How the code Works
  • Overall structure of code
  • Key points of interest, e.g. element traversal, property sets
  • Look at alternate UI

Here is the snapshot of his slides.

Revit MEP API

The Revit MEP API is a recurring topic of mine at Autodesk University, and I presented on this once again last year in my session CP4453 'Everything in Place with Autodesk Revit MEP Programming', as mentioned in the overview of the AU 2011 Revit and AEC API sessions. The AU materials and the sample code that I use there was already published and discussed.

In preparation for the sessions here in Waltham, I also discussed the Revit 2013 MEP API and completed the migration of the ADN MEP sample code to Revit 2013.

Here is the slide deck I used today, based on the AU one and updated for Revit MEP 2013.

Please note again that all the materials provided above are just snapshots. Soon after the conference completes, the complete and final materials will be published.

Winding Down and Winding Up Again

In the evening we went out for a DevTech dinner, Japanese and Chinese cuisine. It was great to hang out with the guys for a while and wind down a bit:

Next stop is the DevLab tomorrow with a record number of almost fifty registered participants, so we will be way busy! Time to wind up again. No rest for the wicked! These events are always great, and I'm looking forward to it a lot.

DevCamp Day One

The first thing that happened here at DevCamp was that I was personally really deeply touched and honoured.

The conference was opened by Jim Quanci, director of ADN, the Autodesk Developer Network. He asked all of us twenty-five-plus Autodesk employees up onto stage and introduced us one by one. When the turn came to your humble author (or not so humble, after all), he asked all readers of this blog to raise their hands. Almost every person in the room did. Deep thanks to all DevCamp participants and to all you readers out there for your appreciation and support; it really helps motivate and improve the work of us all. Grazie.

Jim's introduction wound up with some impressive cloud and mobile demos.

Adam presented his Revit 3D model cloud uploader and mobile device viewer, which I definitely want to write a separate post on as soon as possible, really soon now! Come on Adam, let's do it!

Augusto presented his cloud based cost per unit for AEC materials demo.

Nicolas Magnon gave the keynote speech with interesting insights on the AEC market and current Autodesk developments and focus areas.

Some of the questions and answers to Nicolas were really interesting, and probably not public, even though this is a public event, as far as I know. I don't even dare mention the two main Revit API topics that were discussed. You'd have to be here, man.

After that we moved on to the various lectures, split into the following five parallel tracks:

• Revit Beginner
• Revit Expert
• Infrastructure and Other
• Cloud/Mobile and Other
• Business and Other

I started off presenting the first session in the expert track, and then was able to hang around in the same room to attend the interesting presentations of members of the Revit API development team, going through the following topics, in chronological order:

• 2-8 Extensible storage
• 2-5 Materials, physical properties and compound structure
• 2-6 Geometry API
• 2-4 Core concepts

Extensible Storage

The first session in the Revit expert track was on extensible storage.

I presented a class and a lab on this topic at Autodesk University 2011, as mentioned in the overview of the AU 2011 Revit and AEC API sessions.

I never got around to writing about this class in much detail here on the blog, mainly because the AU handout is so good and complete that there was never any need for it.

Here is an overview of the discussions related to this area that I published here anyway so far:

• Extensible storage
• Estorage of a map or dictionary
• Estorage features a collection of questions and answers
• AU 2011 Estorage materials, handouts and sample code
• Project Wide Data Storage
• DataStorage Element
  • Simple DataStorage Sample
  • Identifying DataStorage Elements

Anyway, the first session here at AEC DevCamp was based on that AU class, so I now updated the sample code and presentation for Revit 2013.

The migration was done in ten minutes after I got up this morning. That also gave me a chance to admire the beautiful sunrise before the sun disappeared again up into the clouds above.

As in previous migrations, I simply updated the Revit API assembly references from 2012 to 2013, bumped the .NET framework version from 3.5 to 4, and replaced the obsolete Document Element property usages via the get_Element method to its new GetElement replacement.

There was one single further issue I ran into, in the wall face selection filter, which was using the obsolete Reference GeometryObject property. I fixed that like this:

/// <summary>
/// Selection filter allowing only wall elements.
/// </summary>
class WallFilter : ISelectionFilter
{
  public bool AllowElement( Element e )
  {
    return e is Wall;
  }
 
  public bool AllowReference( Reference r, XYZ p )
  {
    //return r.GeometryObject is Face; // 2012
 
    return r.ElementReferenceType == // 2013
      ElementReferenceType.REFERENCE_TYPE_SURFACE; 
  }
}

After migrating the add-in, I also rearranged it slightly. I renamed the About command and added an external command Cmd_7_DataStorage to exercise the new Revit 2013 DataStorage element, based on Victor's DataStorage sample.

Here is the list of the commands now provided by this add-in, or rather a list of its project files:

It is worthwhile pointing out that the external application implementation is neat, since it generates the ribbon panel and the entries for the individual commands in a loop. Here is the resulting panel:

The About box implementation is also neat, since it reads the information it displays from the add-in assembly DLL attributes instead of duplicating that information:

Here is Estorage_2013.zip containing the full updated sample application including its add-in manifest, Visual Studio solution and full source. For good measure, here is the updated slide deck as well.

Materials, Physical Properties and Compound Structure

After my own session on extensible storage, I could stay put right there in the same room to join the one by Steven Mycynek on 'Revit Materials, Physical Properties and Compound Structure API Basics', with the following agenda:

• Material Model History
• Material Properties
• Dealing with Units
• Working with Materials
• GbXML’s role in Revit
• Family Thermal Properties
• Layered Assemblies
• Layered Assembly Thermal Properties
• A few last enhancements

From here on, my notes are very fragmentary. Hopefully, you will be able to access the DevCamp materials on the internet quite soon. At that point, these notes might help you decide what to explore. Actually, I added a snapshot of the materials in their current state below, so please refer to those for more details.

Revit 2011 material inheritance model, in 2012 property set, obsolete material subclasses.

Revit 2013 material asset model, material subclasses removed.

Why? Extensibility, add new assets instead of deriving.

Airmax, consolidate all material handling across AutoCAD, Inventor, Revit, all Autodesk products to share same material library.

Material property hierarchy, PropertySetElement, StructuralAsset and ThermalAsset, discoverable properties, new in 2013.

Asset types and properties.

Units: length in feet, all other units in SI units, making compound units a bit confusing.

UnitUtility.cs Steve's personal sample code...

ExporterIFCUtils.ConvertUnits...

There is no official API from display units back to system units, but Steve's sample includes the method DisplayUnitsToSystem.

FormatUnitValue<ValueType>...

Using ProjectUnits.get_FormatOptions( unitType )

Duplicating a material, a deep copy, including all assets; creating one from scratch.

FamilyThermalProperties...

Geometry API

After that, I attended Scott Conover's session on 'Geometry API in Autodesk Revit'. It is a continuation of his AU 2011 presentation CP4011 'Geometric Progression: Further Analysis of Geometry Using the Autodesk Revit 2012 API', enhanced for the Revit 2013 API.

In consists of two main sections, on geometry extraction fundamentals and tools, and supports you in the following areas:

• Extract and analyze the geometry of existing Revit elements
• Create and manipulate temporary curve and solid geometry
• Find elements by 3D intersection
• Find elements by ray projection and filtering
• Apply an ExtrusionAnalyzer to geometry
• Utilize parts to analyze geometry of HostObjects and their layers
• Extract and analyze the boundary geometry of rooms and spaces
• Analyze the geometry of point clouds

More details are available on the developer guide wiki, and examples of use of all the tools discussed are provided in the sample materials.

Display solids on the graphics screen marking the areas around doors that must not be obstructed in order to ensure safe fire or other emergency egress.

ReferenceIntersector class...

Point cloud geometry analysis...

Hashing Instead of Core Concepts

The last session of the day in the Revit expert track was Arnošt Löbel's class on the Core Revit API Frameworks, covering the following topics:

• Regeneration modes
• Transaction modes
• Transaction phases
• Document modifiability
• Element validity
• Object lifespan
• API events
• External commands
• API callbacks
• Dynamic updaters
• API Scopes
• API Firewall

I would have loved to attend, but was unfortunately forced to flee, breathe some fresh air, escape the so-called air conditioning, go running, join the hashers, the Boston Hash House Harriers, the "drinking club with a running problem", that Michael Priestman introduced me to two years back. Once again, it was great fun.

Snapshot of Materials

Here is a snapshot of the materials of today's four Revit API expert sessions:

• 2-4 Core frameworks
• 2-5 Materials, physical properties and compound structure
• 2-5 Materials sample code
• 2-6 Geometry API
• 2-6 Geometry sample code
• 2-8 Extensible storage
• 2-8 Estorage sample code

Please note that this is just a snapshot. Soon after the conference completes, the complete and final materials will be published.

Revit 2013 API Webcast Recording

The recording of the Revit 2013 API webcast that we held on May 17 is now available from the ADN DevTech Webcast Recordings Archive, entering "Revit API" as the course topic, or directly from here.

The 34 MB zip file includes:

• ReadMe.txt
• Slide deck
• Recording
• Code Samples

The webcast addresses two main areas: an introduction to Revit programming for beginners, including a quick walkthrough of basic concepts, and a discussion of some of the new functionality provided by the Revit 2013 API, which will be of interest to both beginners and experienced developers. The two parts are roughly equal in length.

The new API topics discussed have been selected to avoid too much overlap with the DevDays Online presentation on What's New in Revit 2013, from which a recording is also available, so these two complement each other and should do quite a good job together to cover all important aspects of the Revit 2013 API. This is the agenda of the second half of the webcast:

• New feature overview and DevDays Online recording
• Add-in integration features in depth, Idling and external events
• Analysis, simulation, MEP and Structure
• New SDK samples
• More News

For your convenience, here is the content of the readme file describing the sample code provided:

Webcast on Revit 2013 API

This folder includes the following materials:

• Recording – recording of the webcast and the Q&A collection. Click on the WMV file to view the recording. Answers to questions asked using the Q&A Console can be found in document file.
• Webcast – powerpoint slides used in the recording.
• Code Samples – code samples used for the demo. Please see below for notes on each sample.

About Code Samples Folder

This folder includes samples demonstrated in the webcast presentation. Some samples that were not demonstrated during the webcast but used in the presentation slides are also included.

The sample code is available in both C# and VB in the directories SourceCS and SourceVB, respectively. Both of these contain a Visual Studio solution file WebcastDemo.sln to compile and run it.

A sample Revit model Demo.rvt containing a few simple elements that can be used to test the functionality demonstrated by the sample code is also included. If you prefer, you may use any other Revit file.

Functionality Demonstrated by the Solutions

1. HelloWorldCmd – a bare-bones example of an external command.
2. HelloWorldApp – a bare-bones example of an external application.
3. CommandData – parameters of the execute method of the IExternalCommand interface.
4. SelectedElements – method to retrieve selected elements.
5. FilteredElements – use of FilteredElementCollector to identify all Walls that exceed a certain length.
6. AllElements – use of FilteredElementCollector to retrieve all elements in the model.
7. ElementIdentification – method to identify the type of an element.
8. AllWalls – use of FilteredElementCollector to retrieve all walls in the model.
9. AllDoors – use of FilteredElementCollector to retrieve all doors in the model.
10. ElementCreation – use of the Creation namespace and the static creation method to create a wall.
11. ElementModification – use of ElementTransformUtils to rotate a wall.
12. BuiltInParameters – method to retrieve built-in parameters.
13. SharedParameter – creation of a shared parameter and binding it to the Doors category.

DevDays Online on What's New in Revit 2013

A recording of the "What's New in the Revit 2013 API" presentation from the DevDays conferences that we presented on the world-wide tour during the winter months is now live, both by selecting "DevDaysOnline-Revit2013API" in the public ADN webcast recording archive (download recording) and on the members-only ADN web site.

The 88 MB download contains the following:

• Recording – MP4 and supporting files (73,682,898 bytes)
• Presentation – DevDays Online - Revit 2013_Whats New.pptx (4,915,103 bytes)
• Sample code
  • ReadMe.txt
  • RoutingPreferenceAPI
  • ScheduleAPI
  • StairsAPI
  • UIAPI

The samples have also made it into the updated Revit 2013 SDK by now.

The presentation includes a product overview and a summary of the new API features, obviously going into much more detail than my recent brief overview of Revit 2013 and its API.

To give you an idea of the new product features, here is the list of main Revit 2013 product related projects:

• Construction, Fabrication and Engineering
  • Construction Modeling
  • Fabrication Platform
  • Precast Elements
  • Reinforcement Detailing
  • Point Clouds
  • Piping & System Routing
  • Customer Requests
• Platform Scalability
  • Revit Server
  • Performance
• Countrification
  • Stairs & Railings
  • MEP Centerlines
  • IFC API
• Suites & Interoperability
  • First Experience
  • Revit One Box
  • Consistent Visualization
  • Translation Fidelity
  • Add-In Integration
  • View API
  • Visualization API
  • Suites Visualization Workflows
  • Inventor Interoperability API
• Analysis & Simulation
  • Physical Properties
  • Structural Analysis in BIM
  • Structural Code Checking
  • Analysis Visualization
  • Analytical Volumes
  • MEP Calculations

For more details on the new product features, you can check out the

• New feature videos and
• What's New section in the developer guide.

On the API front, I mentioned the main topics already in my Revit 2013 API overview, without, as said, being able to go into as much detail as this presentation does.

Many thanks to Saikat Bhattacharya for creating this recording!

Developer Center and SDK Update

I enjoyed the first really hot weekend this spring. It was warming up seriously last week in Munich, and now it feels as if we were suddenly catapulted from a hesitant spring straight into summertime. I also took some time to explore the developer centre and Revit 2013 SDK update, though.

The Revit Developer Center has been updated to a new layout.

The API and the available training material have grown so fast and voluminous that the old layout was getting hard to navigate. I hope the updated site makes it easier still for you to quickly find exactly what you need. Take a look and let us know what you think.

At the same time, the Revit SDK has been updated. If you are using the SDK, I recommend that you immediately switch to the updated version.

Revit 2013 Developer Guide

Some developers asked about the Revit 2013 developer guide, pointing out that it is not included in the SDK in PDF format as it was in previous releases.

The fact is that the one and only official version of the Revit API Developer Guide is the one provided online at wikihelp.autodesk.com/Revit/enu/2013 > API Developer's Guide.

The developer guide has been available online for a year and is now 100% on wikihelp. The PDF provided in previous releases was never as up-to-date as the wikihelp location.

Work on the 2013 version is still underway, and it is already in a completely usable state.

More New Revit 2013 SDK Samples

I recently presented an overview of the enhancements, new functionality and six new SDK samples provided by the Revit 2013 API:

• ModelessForm_ExternalEvent and ModelessForm_IdlingEvent (ModelessDialog)
• ProgressNotifier (Events)
• RoutingPreferenceTools
• UIAPI
• WorkThread (MultiThreading)

The updated version includes three more ones in addition to those:

• DisableCommand
• ScheduleCreation
• StairsAutomation

These three all have to do with the enhanced add-in integration supported by Revit 2013, and just like several of the previous samples, they were demonstrated at the DevDays 2011 conferences by the Revit UI API demo sample application, which is available for ADN members together with all other DevDays presentations on the ADN Extranet at adn.autodesk.com under "Events".

The only noteworthy other changes in the updated version are the inclusion of the three new samples plus the UIAPI one to the SDKSamples2013.sln Visual Studio solution file, and the addition of these four plus CompoundStructure to the SamplesReadMe.htm documentation file.

Well, OK, the What's New section of the Revit API help file RevitAPI.chm has been revamped and looks nicer, as well.

Compiling and Installing the Revit SDK

To compile the new version of the SDK, I had to go through the same steps as always:

1. Compile and install RevitLookup
2. Compile the SDK samples
3. Install RvtSamples

1. Compile and install RevitLookup. Nothing special here; just open the project file, compile, edit the add-in manifest, and copy it to the add-ins folder.

2. Compile all the SDK samples using the SDKSamples2013.sln Visual Studio solution. This requires updating the Revit API assembly DLL paths in the project files to whatever version of Revit I have installed. In my case, I still only have the Revit Quasar RP version installed, whereas the project files refer to Revit Architechture 2013, Revit MEP 2013 and Revit Structure 2013.

One way to do this is to use the RevitAPIDllsPathUpdater.exe provided in the SDK Samples folder.

I prefer not to modify the HintPath tags in the project files at all, but rather to simply create dummy directory structures for the three products under the Program Files > Autodesk root folder and copy the required DLLs into a Program subfolder in each of them, ending up with the following seven copied assemblies:

• C:\Program Files\Autodesk\
  • Revit Architecture 2013\Program\
    • RevitAddInUtility.dll
    • RevitAPI.dll
    • RevitAPIUI.dll
  • Revit MEP 2013\Program\
    • RevitAPI.dll
    • RevitAPIUI.dll
  • Revit Structure 2013\Program\
    • RevitAPI.dll
    • RevitAPIUI.dll

The copy of RevitAddInUtility.dll in the architectural dummy folder is only required to compile the ExternalCommand RevitAddInUtilitySample SDK sample. By the way, the location of this reference is not updated by RevitAPIDllsPathUpdater.exe, like the other two main Revit API assembly DLLs. It would help if the source code for this utility were available.

I also had to change the ProgressNotifier sample Revit API assembly reference paths, which were hardwired to 64 bits.

Once that was done, the SDKSamples2013.sln solution compiled all SDK samples with no problems.

3. Set up RvtSamples to load all SDK samples into Revit.

To achieve this, I had to set up and install RvtSamples and make a few fixes to the text file it reads to specify the locations of all the samples to load; here is my slightly updated version of RvtSamples.txt.

All in all this is a very clean update with only minor changes required to set it up on my system.

Now let's take a look at the three newly introduced SDK samples.

DisableCommand

This sample is an external application, not a command, so you cannot test it by simply invoking it via RvtSamples. You have to copy its add-in manifest to the add-ins folder.

Once installed, it disables a command by replacing its implementation with a simple popup message. Specifically, it overrides the Design Options command, thus prevent users from accessing it. It performs the following steps:

• A RevitCommandId is found to match the journal name of the command.
• An AddInCommandBinding is created for this command id.
• An alternate implementation is provided for the command binding.

To run it, once installed, simply start up Revit, open or create a project, and choose the Design Options button on the Manage tab. A popup explains that the command is disabled:

ScheduleCreation

This sample demonstrates how to create a wall category view schedule and display its data on a sheet. It performs the following steps:

• Create an empty wall schedule.
• Add some schedule fields by schedulable field.
• Create new schedule filter.
• Create schedule sorting/grouping field.
• Display a sheet containing the wall schedule.

Run it as follows:

1. Open Revit and create a new project based on the default Revit template.
2. Manually create a couple of walls with different types.
3. Run this command, for instance via RvtSamples > Views > ScheduleAPI.
4. A view schedule of wall category and a sheet to show its data are created.

Here is a trivial sample model to test it in:

This is the resulting schedule:

StairsAutomation

This is a slightly more complex sample that creates a series of stairs, stairs runs and stairs landings configurations based upon predefined hard-wired rules and parameters. It provides an example of how to create and populate stairs elements, e.g.

• Use of StairsEditMode
• Creation of standard stairs runs
• Creation of sketched stairs runs
• Creation of sketched landings

It also implements an extensible structure demonstrating how runs and landings creation can be combined into different stairs configurations.

To test this, start up Revit and open the 'Stairs automation.rvt' sample model. Execute the command, e.g. using RvtSamples > Elements > Stairs automation. Each time the command is run, a different predefined stair configuration is created:

1. Single straight stair run

2. Stairs/landing combination up to level 2

3. Multi-span stairs/landing combination up to level 3

4. Single curved stairs run

5. Curve stairs run > 360 degrees

As said, a clean and interesting update, and I highly recommend you grab and install it.