What's New in the Revit 2013 API

This is the fourth and last instalment of a series publishing the information provided in the 'What's New' sections of the past few Revit API releases help file RevitAPI.chm.

The first instalment covering What's New in the Revit 2010 API explains my motivation for this and provides an overview of the other releases.

We now move on to the Revit 2013 API, looking at:

First, however, another update on my vacation.

Turning North Again

I am still on holiday in Italy, so please do not expect any immediate responses to comments for a while.

Almond tree blossoming

After withstanding a snowstorm further north, I did indeed find some warmth further south.

Almond trees are in bloom, and the grass is as green as it will ever get.

Alberobello trulli garden

I explored the sweet Apulian local train system.

Galatina train station

We had some cold and rainy days in the south also.

Portoselvaggio Torre Alto under stormy clouds

Turning back northwards towards Napoli under splendid blue skies, I passed this house beside a cafe I visited changing trains in Taranto.

Taranto house with washing

I walked the wonderful Sentiero degli Dei that I remember so well from my visit in 2009.

Sentiero degli Dei

This time around, I started at the bottom, in Praiano, walked up to the Convento San Domenico, spent the night there, and walked on through Nocelle back down to Positano next morning.


We had a terrible struggle to get there and back out again due to a bus strike. We finally reached Napoli, though, and first of all had a pizza.

Pizzeria Costa in Napoli

The clouds returned and covered the Vesuvio.

Vesuvio in clouds

Spring is eagerly awaited here also, even inspiring the pasticceria.

Spring cakes

Now for the last instalment of the previous Revit API releases' news, bringing us up to date with the current day.

Major Changes and Renovations to the Revit 2013 API

.NET 4.0 for compilation

All Revit components including RevitAPI.dll and RevitAPIUI.dll are now built with the .NET 4.0 compiler. Thus, add-in projects which reference Revit DLLs must be set as .NET 4.0 Framework projects as well.

New macro environment

VSTA has been replaced by SharpDevelop. This provides identical capabilities for macro creation, editing, and debugging as well as for deployment (application-level and document-level macros) and a simple upgrade procedure for existing macros.

SharpDevelop also provides expanded IDE capabilities, .NET 4.0, extended refactoring tools, code analysis tools, a regular expression toolkit, and macro IDE add-in support.

Revit.ini registration disabled

Add-ins will no longer be read from Revit.ini. Revit will look only to .addin files in the machine-wide and user-specific locations when deciding what add-ins to load.

Document.Element properties replaced

The indexed properties:

have been replaced by methods:

The old indexed properties have been marked obsolete.

The behavior for the new methods is identical to what they replaced.

Replacements for use of old-style collections

ElementArray and ElementSet are now obsolete

With a few exceptions, API methods using ElementArray and ElementSet have been replaced with equivalents using .NET generic collections of ElementIds (ICollection<ElementId>).

Some APIs have been obsoleted with no replacement; these methods are batch element creation methods which dated to the time when regeneration was automatic after every database change. Now that regeneration is manual, having separate batch creation methods provides no extra benefit as multiple element creation calls can be chained together with no delay caused by regeneration. Thus these methods are obsolete:

When replacing calls to these methods, you should use the corresponding creation method which creates a single element in a loop, while delaying calls to Regenerate() until the loop has concluded. Because Regenerate() is delayed, you should not make inquiries to the newly created elements' geometry as a part of the loop.

Definitions and DefinitionGroups

These classes used to inherit from base classes consisting of old-style Revit API collections. The new versions of the classes offer the same functionality, but implement System.Collections.Generic.IEnumerable<T>.

Code which referred to the older base class or its associated iterator will need to be changed to access members through iteration or the now-available LINQ methods.

In addition, code which called ForwardIterator() or ReverseIterator() on these classes will need to be changed as the new version of the class does not offer these two legacy methods.


The property

has been obsoleted. GeometryElement now inherits directly from IEnumerable<GeometryObject>, and it possible to directly iterate the contents of the GeometryElement using .NET and LINQ, if needed.

Replacements for wall creation methods

New wall creation APIs have been provided as a part of the Wall class:

These methods replace the obsolete methods on Autodesk.Revit.Creation.Document (NewWall() (all overloads)). The NewWalls() overloads are obsoleted without dedicated replacements, as described in the section ElementArray and ElementSet are now obsolete.

Idling event and External Events

Idling event frequency

The Idling event has been changed to offer two different modes of behavior. The default behavior has changed; pre-existing code that needs the original behavior will need to opt-in to the non-default behavior.

In the default mode, a single raise of the event will be made each time Revit begins an idle session. Note that when the user is active in the Revit user interface, idle sessions begin whenever the mouse stops moving for a moment or when a command completes. However, if the user is not active in the user interface at all, Revit may not invoke additional idling sessions for quite some time; this means that your application may not be able to take advantage of time when the user leaves the machine completely idle for a period of time.

In the non-default mode, your application forces Revit to keep the idling session open and to make repeated calls to your event subscriber. In this mode even if the user is totally inactive the Revit session will continue to make Idling calls to your application. However, this can result in performance degradation for the system on which Revit is running because the CPU remains fully engaged in serving Idling events during the Revit application's downtime.

You can indicate the preference for the non-default Idling frequency by calling

each time the Idling event callback is made. Revit will revert to the default Idling frequency if this method is not called every time in your callback.

Idling event with no active document

The Idling event now is invoked when there is no document active in Revit.

External Events framework

The External Events framework is a new API framework tailored for asynchronous processing such as that which is needed to support modeless dialogs. It operates similarly to the Idling event with default frequency.

With this framework, instead of implementing an event handler and implementing the handler to do nothing when there is no activity in your dialog, instead you do the following:

  1. Implement an external event by deriving from the interface:
  2. Create an ExternalEvent with
  3. When an event happens in your modeless UI where a Revit action needs to be taken, call
  4. Revit will wait for an available Idling timecycle and call the implementation of your event:

This framework is more useful for modeless dialog developers because you can skip the default no-op implementation when nothing has happened, and tell Revit when there is some work you need to do in Revit. It also saves on the time required for Revit to make repeated calls to the Idling event when there is no actual work to be done.

Calling OpenAndActivateDocument during events

The UIApplication.OpenAndActivateDocument can now be invoked during events under the following conditions:

  1. When invoked from an External Event, not restrictions apply except for the original active document to be free of transactions and transaction groups.
  2. When invoked from regular event handlers, the following restrictions apply:

Document & worksharing changes

Worksharing properties

The information required to identify a workshared file on the central or local locations have changed due to changes to RevitServer. As a result, the members

replace the properties

The new members:

provides read access to the worksharing central GUID of the given server-based model. This is applicable only to workshared models saved in Revit 2013 or later.

New overloads for Application.OpenDocumentFile() and UIApplication.OpenAndActivateDocument()

The new overloads support parameters OpenOptions and OpenOptionsForUI, respectively, to specify how a Revit document should be opened. Both options classes currently offer the ability to detach the opened document from central if applicable.

The property:

can be set to DoNotDetach (the default) or DetachAndPreserve.

The property:

can be set to DoNotDetach (the default), DetachAndPreserveWorksets or DetachAndPrompt.


The new class

offers basic information about a Revit file, including worksharing status, Revit version, username and central path. The information can be extracted without fully opening the file.

Point cloud engine API changes

Because these are new methods in a pre-existing interface, existing code will have to be modified to implement the methods.


Unlike other Point Cloud interfaces in the Revit 2012 release, this interface did not offer a method to be called when Revit is finished with it.

When Revit calls this function it indicates that the IPointCloudAccess interface is no longer going to be used and the provider of the interface can dispose of all allocated resources.


Implement this method to return the offset stored in the point cloud. All points are assumed to be offset by the same offset vector. The offset should be expressed in the same units as used by the point coordinates (the scale conversion factor is not applied). The offset will be used by Revit if the user choose to place an instance relative to another point cloud (the "Auto – Origin To Last Placed" placement option).


A second overload with an additional argument – density – the desired number of points per unit area. Area is computed in native units of the point cloud.

IFC export APIs

The IFC export implementation in Revit has switched to a more generic toolkit. As a result, many of the APIs introduced in Revit 2012 to support customized IFC export have been removed and replaced, and new interfaces introduced that allow more flexibility in the data that is written to the IFC file. Autodesk recommends that any customization of IFC export begin with the implementation of the default Revit IFC exporter client, and that customizations written for 2012 be ported incrementally to support Revit 2013.

Construction Modeling changes

The following members are now obsolete:

The following members are now obsolete – they are not being replaced with new members because the information they returned can be obtained by applying GetSourceElementIds recursively to source elements that are Parts.

The following members are obsolete. Their replacements live on the PartMakerMethodToDivideVolumes class, which you can obtain for a given PartMaker using PartUtils.GetPartMakerMethodToDivideVolume():

The methods:

now return ViewSchedule instead of View.

Structure changes


The overload taking one argument is now obsolete.

The new three-argument Rebar.GetCenterlineCurves(Boolean, Boolean, Boolean) has arguments to control whether or not to:

Rebar member changes

These members are now obsolete:

AreaReinforcement and PathReinforcement

BarDescription class

The new RebarInSystem element replaces the BarDescription class. This class and related methods:

are obsolete in 2013.

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. But the RebarInSystem elements are almost entirely controlled by their system element (Area or Path). Therefore they are missing most of the modification methods of the Rebar class.

New methods:

MEP changes

ConnectorProfileType, PartType

ConnectorProfileType enums are renamed to:

PartType::UndefinedPartType is renamed to PartType::Undefined.


Subclasses of ConnectorElement: PipeConnector, DuctConnector, and ElectricalConnector, are obsolete.

Connector element types can now be created using new methods:

These methods replace the methods on Autodesk.Revit.Creation.FamilyItemFactory (NewDuctConnector, NewPipeConnector, NewElectricalConnector). Those methods are now obsolete.

Obsolete API Cleanup

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

Classes removed

Methods and properties removed

Major Enhancements to the Revit API

Stairs and railings API

Stairs and stairs components

The new classes in the Autodesk.Revit.DB.Architecture namespace:

provide access to new stairs elements in the Revit database. Note that these API classes only provide access to the Stairs created "by component" introduced in this release. Stairs elements created by sketch cannot be accessed as a Stairs object in the API. It is possible to identify both type of stairs using the BuiltInCategory OST_Stairs and the static method Stairs.IsByComponent() can identify an element id represents a by component stairs.

The classes:

provide access to the subcomponents and subcomponent types of the new Stairs elements.

Railings and railing components

The new classes in the Autodesk.Revit.DB.Architecture namespace:

provide access to the top level railing elements in the Revit database. Railings can be associated to a host, such as a stairs or a floor, or placed in space. Railings can be continuous or non-continuous. If non-continuous, only a limited level of access is provided.

Stairs annotations

The new class

provides access to the properties and capabilities of a CutMark annotation which can be associated to stairs.

The new classes

provide access to the stairs path annotation.

View API

View Creation

Plan Views can now be created with the new ViewPlan.Create(document, viewFamilyTypeId, levelId) method.

For example, a ceiling plan can be created as follows:

  Element level = doc.GetElement(
      ObjectType.Element ) ) as Level;
  IEnumerable<ViewFamilyType> viewFamilyTypes
    = from elem in new FilteredElementCollector( doc )
      .OfClass( typeof( ViewFamilyType ) )
        let type = elem as ViewFamilyType
        where type.ViewFamily == ViewFamily.CeilingPlan
        select type;
  ViewPlan ceilingPlan = ViewPlan.Create(
    doc, viewFamilyTypes.First().Id, level.Id );
  ceilingPlan.Name = "New Ceiling Plan for "
    + level.Name;
  ceilingPlan.DetailLevel = ViewDetailLevel.Fine;
  // 3D views can be created with 
  // View3D.CreateIsometric and 
  // View3D.CreatePerspective. 
  // The new ViewOrientation3D object is used to 
  // get or set the orientation of 3D views.
  View3D view = View3D.CreateIsometric(
    doc, viewFamily3d );
  XYZ eyePosition = new XYZ( 10, 10, 10 );
  XYZ upDirection = new XYZ( -1, 0, 1 );
  XYZ forwardDirection = new XYZ( 1, 0, 1 );
  view.SetOrientation( new ViewOrientation3D(
    eyePosition, upDirection, forwardDirection ) );


The enum DisplayStyle (with values including Wireframe, HLR, and Shading) has been added so the API can be used to get/set the new DisplayStyle property.


The enum ViewDetailLevel (with values Coarse, Medium, and Fine) has been added with get/set access to the new DetailLevel property.


The view range for plan views can now be retrieved via ViewPlan.GetViewRange().

3D View Locking


Views can now be duplicated via the API with the View.Duplicate(ViewDuplicateOption) method.

UIView class and UIDocument.GetOpenUIViews()

The UIView class has been added to represent a view window in the Revit user interface. GetOpenUIViews provides a list of all open views. UIView.GetWindowRectangle() returns a rectangle that describes the size and placement of the UIView window.

Pan and Zoom

The method

offers the ability to zoom and pan the active view to center on the input region of the model.

The method

returns the two points that define the corners of the view's rectangle in model coordinates.


The enum PlanViewDirection has been added so API can be used to get/set the view direction to either Up or Down for StructuralPlan views.

ViewFamilyType class and ViewFamily enum

The ViewFamilyType class has been created to correspond to the Types seen in the UI's Properties dialog for each view. The ViewFamily enum (FloorPlan, Section, Legend, etc) specifies the family of the ViewFamilyType.

Temporary view modes

View.EnableRevealHiddenMode, View.EnableTemporaryAnalyticalDisplayMode, View.DisableTemporaryViewMode, and the TemporaryViewMode Enumeration have been added to allow control of temporary view modes.


Schedule API

Several new classses have been added to allow schedule views to be created, modified, and added to drawing sheets. Major new classes include:

Running API commands in Schedule Views

API commands may now be active when a Schedule is active in the current document.

Schedule export

The ViewSchedule class has been added to the API and the method ViewSchedule.Export method exports an existing schedule to a text file.

Discipline controls

The properties:

provide read and modify access to the available disciplines. Your application can read the properties to determine when to enable or disable aspects of the UI.

Enabling and disabling disciplines is available only in Autodesk Revit (and not in any other Revit product). When a discipline's status is toggled, Revit's UI will be adjusted, and certain operations and features will be enabled or disabled as appropriate.

Rendering Options

The settings shown in the Rendering Options Dialog are exposed, allowing an API user can get and set Rendering Options for a 3d view.

The new methods:

gets or changes the rendering settings for the 3d view.

The class

offers properties and methods which correspond to the options in the UI dialog:

The rendering properties are exposed with the following supplementary classes and enums:

Example: checking rendering options for a 3D view:

  RenderingSettings renderingSettings
    = view3D.GetRenderingSettings();
  Transaction newTran = new Transaction(
    doc, "Change Rendering Settings" );
    = BackgroundStyle.Image;
  view3D.SetRenderingSettings( renderingSettings );

Construction Modeling

Linked element parents for parts

Parts can be created from linked elements. There are new overloads:

which accept LinkElementIds (representing the id of the element in the link). The existing Part utilities accepting ElementId have not been changed.

Merged parts

The methods:

provide support for merging of parts.

Excluded parts

The new property

allows identification and assignment of parts to be excluded.

Part category

The new members:

provide the ability to get and set the original category id for a given part.

Part division

Part divisions can now be assigned custom geometry divisions. The members:

offer the ability to examine and control properties of the divisions.

Assembly views

The method

transfers the assembly views owned by a source assembly instance to a target sibling assembly instance of the same assembly type.

Assembly instance transform and location

The methods

provide read and write access to the transformation origin of the assembly. Changing this value causes the origin point to change relative to the assembly members (and does not move the assembly members). All assemblies of the same type should have changed their transforms by the same amount. For example, if you changed the transform of the assembly by a rotation of 90 degrees, then other assemblies should also have rotated their transform by 90 degrees.

The inherited property

also has been modified to return a the location for an AssemblyInstance.

Structure improvements

New Rebar members


The new class ReinforcementSettings controls project settings that are accessible from the Reinforcement Settings dialog in the Revit UI. For 2013 the only supported setting is the HostStructuralRebar property, which is new for 2013 and affects the AreaReinforcement and PathReinforcement elements.


AreaReinforcement and PathReinforcement now have types.

The types – AreaReinforcementType and PathReinforcementType – contain only identity data.

There is no change to the interface for creating Area and Path Reinforcement elements. A default, or most-recently-used type, is automatically assigned on element creation.

New Area- and PathReinforcementTypes can be created using the following methods:

Analytical model

The new element type

can be created between two other Analytical Elements, e.g. an analytical beam and analytical column. There are two kinds of Links: user defined and automatically generated. Links have properties like "fixity state" that can be accessed via the API.

MEP improvements

Routing Preferences

Revit MEP now supports a system for selecting preferred pipe and duct sizes, materials, and fitting types for use in an MEP project. The routing preferences API can be used to set routing preference policies for end users as well as to query which fittings and segments will be used given size criteria.

MEP Sections

The new class

is the base class for duct and pipe section. It is a series of connected elements (segments – ducts or pipes, fittings, terminals and accessories). All section members should have same flow analysis properties: Flow, Size, Velocity, Friction and Roughness. One section member element which contains more than one connector can belongs to multiple section.

For example: One Tee fitting that has 3 connectors usually belongs to 3 sections. One segment that connects to a tap will be divided into 2 sections

FluidType and FluidTemperature

The new class

represents the viscosity and density properties as defined at a certain temperature.

The class

has been extended to provide read and write access to a collection of FluidTemperature objects which represent the fluid's properties at various temperatures.

Panel schedule – spare values

The new functions

provide access to the parameter values of spare circuits.


New overloads of

have been added to supply the user-visible string matching members of the enums DuctLossMethodType, PipeLossMethodType, and PipeFlowState.

Physical Properties

Thermal properties

Thermal properties of various elements have been enhanced in Revit 2013.

This class is a property on the following types:

This class is a property on Door, Window, and Curtain Panel family symbols

Structural properties

Beam, Column, and Foundation family instances now support an ElementId of an additional structural Material element

All compound structurals can now elect one layer in the structural to be used as the "structural" layer.

StructuralAsset contains named properties for various structural values, such as PoissonModulus and YoungModulus, that offer enhanced ease of use over the previous parameter-API based access to these same values.

Material assets

GBXML Export

Thermal properties of building construction element types can now be set to use calculated values or pre-defined values from Constructions.xml with:

EnergyDataSettings.IncludeThermalProperties indicates if thermal information from model assemblies and components is included in GreenBuildingXML export of the detailed model.

User interface API improvements

Contextual help support

Items placed on the Ribbon can now be assigned an action for contextual help using

The options supported include linking to an external URL, launching a locally installed help file, or linking to a topic on the Autodesk help wiki.

You can also invoke the same set of contextual help options at any arbitrary time within your add-in by creating a ContextualHelp object with the appropriate target location, and invoking

Support for Keyboard Shortcuts and Quick Access Toolbar

API commands may now be assigned keyboard shortcuts, and those assignments will be preserved even if add-ins are added, removed or changed in subsequent sessions.

API commands may also be moved to the Quick Access Toolbar, and that assignment will also be preserved even if add-ins are added, removed or changed in subsequent sessions.

Replace implementation of commands

It provides ability to replace the existing Revit command (located in any tab, application menu and right-click menus) implementation with add-in routine.

The new class RevitCommandId provides ability to look up and retrieve an object representing Revit Command id given an id string. The id string of the command is the string which appears in the journal when the command is clicked, e.g. "ID_APP_EXIT".

The new class AddInCommandBinding provides ability to override the Revit command implementation with Executed and CanExecute events.

These two new methods provide the ability to create a command binding with a given Revit command id.

Preview control

The new class

provides the ability to embed an interactive Revit view as a WPF control inside a dialog.

Options dialog customization

Subscribe to the new event

to be notified when Revit is preparing the Options dialog for display. During the event callback, your application can call

to add a new tab to the dialog. The contents of the panel shown when this new tab is selected are determined by the members assigned to the input class:

Drag & Drop support

The new methods

initiate a drag and drop operation on the Revit user interface.

The first method accepts a list of file names, which can be Revit files, import CAD and images, or some combination of the two. The second method accepts arbitrary data, and provides an IDropHandler callback to handle the drop of the data when the user completes it.

Translation API enhancements

Several updates have been made to the APIs related to data exchange and translation of models.

DGN import

The new method

supports import of DGN files into Revit views.

DXF import

The method

now also supports DXF files for import.

DWG and DXF export settings changes

The options supported for DWG and DXF export have been expanded. A new base class

supports all properties shared by DWG/DXF & DGN export tasks. New properties include:

DGN export

The options supported for DGN export have changed to match the new implementation of DGN export based on DWG supporting DGN V8. The previously existing class

thus offers many new properties inherited from the same base classes as DWGExportOptions.

The property

has been replaced with:

FBX Export

Three new options have been added:


A DividedPath is an element supported in the massing environment that consists of a set of points distributed along a connected set of curves and edges. The points can be the result of a uniform distribution along the curves. The type of the distribution is determined by a selected 'layout'. The distance between the layout points depends on the curves, the layout, and layout specific settings. In addition, points can also be the result of intersecting the curves with other elements.

The class

exposes the interface for this element type. It permits creation of a new DividedPath from input curves and edges, as well as optionally, intersecting elements. It allows control over the layout type and parameters, as well as other miscellaneous settings.

Analysis Visualization Framework

The following additions have been made to support deformed shapes in analysis visualization display:

A new override to CreateAnalysisDisplayStyle accepts an input argument of AnalysisDisplayDeformedShapeSettings

Revit Link creation

The API now contains two creation methods for Revit links.


The class

has been extended to offer the ability to create Filled regions, to get the boundaries of the region, and to apply a linestyle to all boundary segments.

The class

has been added providing access to the visible properties of a filled region type.

Light API

The classes

have been added to offer the ability to get and set photometric data and all other lighting parameters from both family instances in project documents and all family types in family documents. The LightType and LightFamily classes expose the same data except for light shape and distribution types which are only available from the LightFamily class.

Some examples of lighting parameters exposed are;

Light Group API

The classes

have been added to offer the ability to manage light groups to allow control over which lights are used when rendering the scene.

The LightGroupManager class gives the user the ability to

The LightGroup class gives the user the ability to

Light groups are used in rendering options to turn lights on or off when rendering.


The new class ReferenceIntersector allows ray-cast selection of elements, given a point and direction, similar to FindReferencesWithContextByDirection(), but with support for filtering the output based on element or reference type.

The enum FindReferenceTarget is used with ReferenceIntersector to filter selection of elements, meshes, edges, curves, and faces.

Key members of ReferenceIntersector

Small Enhancements & API Interface Changes

Elements & filtering

Element.PhaseCreated and Element.PhaseDemolished

These readonly properties have been obsoleted and replaced with read/write properties:

The new method Element.AllowsPhases() indicates whether these phase id properties can be modified for any given element.

Phase filter

The new class

and related types support read/write and create access to phase filters.


The new class

provides access to a filter type which contains a selected set of element ids, rather than criteria based on parameters.

Ceiling, Floor and CeilingAndFloor

The newly exposed Ceiling class represents a ceiling in Revit. It inherits from CeilingAndFloor. The Floor class has been modified to also inherit from CeilingAndFloor.

Geometry & sketching

Split volumes

The new method:

takes a solid which includes multiple disjoint enclosed volumes, and returns newly allocated Solids representing each volume. If no splitting was necessary, a copy of the input Solid is returned.

Solid tessellation

The new method:

generates a single triangulated structure for the given input Solid (which could one or more fully closed volumes, or a shell of faces which do not form a closed volume). The function returns:

which allows access to the stored triangulated components and triangles.

Use the method:

with a TriangulationInterface object constructed from the TessellateSolidOrShell results to convert pairs of adjacent, coplanar triangles into quadrilaterals.


A new overload to Face.Triangulate() accepts a level of detail as an argument. Levels of detail close to 0 (the minimum) will result in coarser triangulations than levels of detail close to 1 (the maximum).

Ellipse – axes

The new properties:

provide the unit vectors of the ellipse for the X and Y directions.


This new method provides read access to the bounding box of a given geometry element.


This method can now align a line and a reference plane as well as all other geometry types from previous versions.

CylindricalHelix curve type

A new subclass of Curve has been introduced: CylindricalHelix. The class offers methods useful for reading and creating such curves.

In this release, CylindricalHelix curves are used only in specific applications in stairs and railings, and should not be used or encountered when accessing curves of other Revit elements and geometry.

CurveLoop as IEnumerable<Curve>

The members of a CurveLoop can now be traversed, as CurveLoop implements IEnumerable<Curve>.

CurveElement – center point reference

The new property:

returns a reference to the center of a curve if that curve is one that has a center (e.g. arcs, circles, elliptical arcs or ellipses). This reference can be used for dimensioning to the center point.


ModelCurve.ChangeToReferenceLine is now supported in all family types, not just conceptual modeling.

NewSketchPlane(Document, Reference)

This new overload for NewSketchPlane in the ItemFactoryBase class supports creation of a sketch plane directly from a Reference representing a planar face.

Detailing & Annotations

MultiSegmentGrid class

This class has been added to the API to support multi-segment grids.

Grid geometry

Element.Geometry now supports Grids and MultiSegmentGrids, including the ability to see gaps and extents applied to the grid lines to form different segments.

Diameter dimensions

Revit now supports Diameter dimensions. The DimensionShape enumeration contains a new Diameter member. And there is a new creation method for diameter dimensions:

DimensionSegment overrides

There are several new properties on DimensionSegment to override text properties.

These properties are also available on Dimension, for use with dimensions with just one segment.

Detail element draw order

The class

has been added providing the ability to affect the draw order of detail elements (including FilledRegions)

Families & content


This class provides access to the "Room or Space Calculation Point" seen in families. The Spatial Element Calculation Point is graphically showed as a location point marker with a "snake" line from the origin of the family. If the Spatial Element Calculation Point is turned on, this point will be used as a search point for room and space relations for all instances of this family. The API offer creation, read and modification options for this object type.

RPC content assets

The AssetType enum now contains a value "Content", which can be used to enumerate the loaded RPC content assets in the Revit session.

NewFamilyInstance validation

Some validation has been added to overloads of NewFamilyInstance(). This validation is intended to prevent use of the incorrect overload for a given family symbol input. For specific details on the exceptional conditions which will be validated, consult the documentation.


This new property provides information about the placement type for instances of the given family. PlacementType roughly maps to the overloads of NewFamilyInstance.

DataStorage element

The new DataStorage class represents an element that API applications can create logically organize different sets of ExtensibleStorage entities into separate elements. This allows an application to update one set of data in a local workshared project without locking other elements.

ApplicationInitialized event

The ControlledApplication object now supports an ApplicationInitialized event, which is called once the Revit application is fully initialized, after all external applications have been started and when the application is ready to work with documents.

ProgressChanged application event and ProgressChangedEventArgs

The application object now supports a ProgressChanged event and ProgressChangedEventsArgs object that returns progress bar data from time-consuming transactions.

SiteLocation – PlaceName

The new property:

provides the place name of the site location.


Provides the full path to the default template file for new project documents

UnitType, DisplayUnit and FamilyParameter updates

Many new units have been added to UnitType, DisplayUnitType and ParameterType.

One UnitType was renamed: UT_TemperalExp was renamed to UT_ThermalExpansion.

The corresponding ParameterType value (TemperalExp) was also renamed to ThermalExpansion.

BasePoint and BASEPOINT_ANGLETON_PARAM "True North" Parameter

The parameter to return the "True North" angle parameter "BASEPOINT_ANGLETON_PARAM" on the BasePoint object is now a double instead of a string.

Journaling of Add-in user interface

Revit now activates a tool to collect and journal certain actions which take place in the user interface provided by an add-in. The tool supports actions in both WPF and Windows Forms dialogs.

Some actions and some components may not be fully recorded.

This capability is useful to Autodesk in the event that a journal can be supplied from a Revit user indicating the presence of a software problem. Replay of add-in UI via journals is not supported.

End of document

That completes the list of news in the Revit 2013 API from last year, A.D. 2012, bringing us up to date with the current release.

As said, I look up information in these sections regularly, and still discover topics that I was previously not aware of, frequently leading me to research new Revit API classes and methods.

Since this documentation was not previously available to online Internet searches, it required the extra effort of opening the individual help files and searching it release by release on the off chance of finding something hitherto unknown and useful for the task at hand.

I hope making this information available online proves as helpful to you as it will to me!