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:
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:
This document consists of three main sections:
I hope this proves useful to you and you find the new API features as useful and exciting as I do!
Several modifications have been made to the Document.Save() methods.
Several modifications have been made to the Document.SaveAs() functions.
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).
New options are available in this class:
This Boolean option specifies whether to expand all elements, to check for corruption. Defaults to false.
This boolean option specifies whether a local file is allowed to be opened ReadOnly by a user other than its owner.
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
This method returns a collection of WorksetPreview classes containing the workset id, unique id, owner, name and whether or not the workset is default.
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.
This method has been reimplemented. While the signature has not changed, failures are now signaled with specific documented exceptions.
The signature and the implementation of this method has changed.
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:
Failures are now signaled with specific documented exceptions.
This method has been reimplemented. Failures are now signaled with specific documented exceptions.
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:
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.
New curve creation methods have been added as statics on the associated curve type:
The older curve creation properties and methods are now obsolete:
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:
Some other adjustments have been made to the validation on specific curve creation routines, consult the documentation for details.
The new methods:
replace the indexed property utilities on Curve:
The setter for EndParameter is deprecated and code should be adjusted to call MakeBound(double, double) instead.
The new methods:
replace:
The new methods:
replace:
The SketchPlane creation methods of Autodesk.Revit.Creation.ItemFactoryBase have been replaced.
A new SketchPlane creation has been added:
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.
The BeamSystem creation methods of Autodesk.Revit.Creation.Document have been replaced:
The Truss creation method of Autodesk.Revit.Creation.Document have been replaced.
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
To activate an inactive family symbol, use
The API for Units in Revit has been expanded and changed. The methods
allow interaction with the units of a document. The Units class provides access to data such as
The FormatOptions class provides access to data including:
LabelUtils.GetLabelFor() has been enhanced so that it can now return the user-visible name for a UnitSymbolType.
The methods:
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.
The new class UnitUtils contains methods to convert between unit types:
The method
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.
The property
is now obsolete. View.Name can be used.
The name of this method has now been correctly capitalized.
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:
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:
relate to the style and formatting applied to schedule columns, and:
relate to information about the type of a field.
The new members:
provide access to fonts stored in the table and applied to cells.
The new members:
affect header grouping in the schedule.
The new method:
returns the object which provides access to the sections of the table.
The method
has been deprecated. The Render appearance properties should be set via the related ApperanceAssetElement.
Use the new property:
to assign the element to the material.
AppearanceAssetElements can be found via element filtering – they expose the following members:
AssetProperty no longer inherits from APIObject.
New subclasses of AssetProperty are exposed:
Some of the return values of AssetProperty.GetTypeName() have been changed as shown here listing input argument, old return and new return:
API commands and macros are now enabled when the Revit active view is the Project Browser.
Note that API commands are still disabled when the active view is the MEP system browser.
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.
There are new extension and cutback parameters assigned to Beam and Brace elements.
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:
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.
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:
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:
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).
The class DividedSurfaceData and the associated method Element.GetDividedSurfaceData() have been replaced. The new methods to access DividedSurfaces applied to elements are:
The method:
has been replaced by:
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.
The method
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.
The method
has been deprecated and replaced by
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.
The classes
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
identifies point clouds which support override settings (clouds which are based on .rcp or .rcs files).
The method
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.
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.
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:
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.
The property HideUnreferencedViewTages was renamed to HideUnreferencedViewTags.
API classes and methods previously marked Obsolete in Revit 2013 or earlier have been removed from the API.
The method:
Fetches changes from central (due to one or more synchronizations with central and merges them into the current session. After this call finishes, use
to confirm that there were no Synchronizations with Central performed during execution of ReloadLatest.
The method:
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.
The following methods affect element and workset ownership:
The new method:
takes a path to a central model and copies the model into a new local file for the current user.
The new method Document.EnableWorksharing will enable worksharing in a project.
Several improvements have been made to increase API functionality when working with RVT links.
The property:
identifies if a document is in session because it is a linked Revit file.
The method:
gets the document that corresponds to an Revit Link instance.
Two functions have been added to RevitLinkOptions, used to specify options for RevitLinkType.Create.
This allows the user to specify which worksets should be opened when creating and loading a new Revit link.
The methods
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:
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.
The property:
allows read and modification of the path type associated with a link.
The new APIs:
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().
The new method:
can create room tags in Revit Links.
PickObject() and PickObjects() now allow selection of elements in RVT Links.
These new members expose read and write of graphic display options:
Display of category classes may be overridden by the user. The new properties:
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.
Display of categories can be overridden. This can be done with the new class OverrideGraphicSettings and the new View methods:
Display of elements can be overridden with the new methods:
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.
Views can now be assigned a crop region which is non-rectangular. The new View members:
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:
The properties:
also apply to non-rectangular crop regions which may be assigned to a given view.
The new property
controls the rotation of the viewport on the sheet.
The new method
moves the viewport so that the center of the box outline (excluding the viewport label) is at a given point.
The new method
returns the center of the outline of the viewport on the sheet, excluding the viewport label.
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.
The new methods:
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.
The new methods:
provide shortcuts to quickly adjust the zoom of the graphical view window.
The new method:
closes a visible view window. Note that the last open view for a given document cannot be closed by this method.
The new property:
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:
accesses the visibility setting for the preview view scrollbars.
The event
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.
The method
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:
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
The method
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).
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().
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:
New properties of DimensionStyle provide access to alternate units settings:
The property:
returns the type of units supported by this dimension style (length, angle, or slope).
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
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:
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:
Revit also offers a new UI API method
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.
Revit now support an API for listing, creating, removing, editing, debugging, and running macros through several supporting classes and enums
The MacroManager APIs are all in the Autodesk.Revit.DB.Macros namespace and are available in RevitAPIMacros.dll and RevitAPIUIMacros.dll
The attributes
and the interface
have been moved to the namespace Autodesk.Revit.DB.Macros.
The new method
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.
The property
Has been replaced by a new property
As this label applies only to dimension in families and their corresponding family parameter.
The new property
identifies if the family parameter is a shared parameter.
Revit now supports APIs for joining, unjoining, querying join state, and changing join order of elements in a model through the JoinGeometryUtils class.
The method
returns the Schema Guids of any Entities present on an Element.
The methods
are now restricted based on the read permission defined in the Schema.
An ExtensibleStorageFilter is a new ElementQuickFilter for finding elements that contain an extensible storage entity of a given Schema Guid.
The new function:
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
to check if there is an exporter registered.
The functions:
import or link an SAT file into the document.
The functions:
import or link an SKP file into the document.
The function:
imports DWF markups into the document.
The new classes
expose read and write access to the tables used for mapping on export to various formats such as DWG, IFC and DGN.
Editing the points in a TopographySurface now requires establishment of an edit scope. The class
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:
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:
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.
The new method:
returns a list of the points stored in the surface.
The method:
filters and returns only the points of the topography surface which lie within the input bounding box.
The method:
identifies if the input point is found in points stored in the surface.
The methods:
identify points which are a part of the boundary of the surface.
Several new validation methods have been added to the TopographySurface class:
These methods are newly used in AddPoints() to prevent problematic inputs from causing issues.
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:
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:
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:
Several new interfaces and classes based on external services are supported for pipe and duct calculations.
ElectricalLoadClassificationData has several new string properties corresponding to the load classification section of the electrical panel schedule.
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
The members:
provide access to fitting angle usage settings for ducts, pipes, cable trays and conduits.
Duct settings for size prefixes and suffixes, annotations, and air density and viscosity may now be set through the DuctSettings class.
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.
The methods
allow creation of connector elements in families on centered on internal loops of a given face.
The property
accesses the MEPSystemType of the connector
The members:
access the direction of the connector.
The new method:
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.
There are many new reinforcement and rebar-related methods and classes in Revit 2014.
AreaReinforcement has several new methods and properties.
PathReinforcement has several new methods and properties.
FabricArea has several new methods and properties.
FabricSheet has several new methods and properties.
Rebar has several new methods and properties.
RebarType has several new methods and properties.
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.
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.
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:
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.
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.
Classes of which instance are sent to an export context during a custom export.
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.
The paint tool is now supported in the 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:
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:
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.
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.
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.
The new methods:
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 applied with the Paint tool and their areas can be found by specifying "true" for the 'usePaintMaterial' argumement in Element.GetMaterialIds and Element.GetMaterialArea
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.
The new method
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.
The method
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.
The new option findReferencesInRevitLinks allows ReferenceIntersector to find geometry in RVT links.
The new method
determines if the rulings of the ruled surface are parallel.
The class
now includes routines to BringToFront, BringForward, SendToBack, SendBackward multiple detail members. The draw order of the members does not change relative to one another.
New values LeftExterior and RightExterior have been added to this enum to support jusitification to the left and right supports.
The new members:
provide automatic landing(s) creation and creation validation between two stairs runs.
The new properties:
represent the extension/trim value for the run, depending upon whether the run begins with a riser or tread.
These replace the deprecated property:
which now accesses whichever property listed above depending on the run's configuration.
The new methods:
provide information about connections among stairs components (run to run, or run to landing).
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.
This new property provides access to the UnitType of a parameter definition.
The new members:
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.
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:
has been replaced by
This new property provides the specific heat value of a thermal asset in feet per Kelvin, squared-second.
This new class provides access to settings related to volume and area computations. The old VolumeCalculationSetting class is obsolete.
This method previously returned null if the element or elements could not be deleted. It now will throw an exception in this situation.
The new methods:
provide the ability to inquire about and to unregister updaters that are associated to specific documents.
The static properties of UIThemeManager provide access to the current UI theme and the default theme.
The property
can now be set. This allows the category of an family being edited to be changed.
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:
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 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.
The method
creates an arc curve through three input ReferencePoints.
For the methods GetAddedElementIds()/GetModifiedElementIds() – internal Revit element ids that are not visible to UI and API are now excluded from the return set.
The new methods:
only return ElementIds that pass the input element filter. This helps applications detect only specific changes of interest.
The new classes:
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?