REVIT API

Primeros pasos
 REVIT API – Primeros pasos

© Structuralia 2
 REVIT API – Primeros pasos

ÍNDICE

ÍNDICE........................................................................................................................................................................... 3

1. INTRODUCCIÓN ....................................................................................................................................................... 4

2. TASKDIALOG CLASS .............................................................................................................................................. 5

3. TASKDIALOG CON UN MACRO............................................................................................................................ 11

4. SELECCIONAR ELEMENTOS Y CONSEGUIR INFORMACIÓN ........................................................................... 29

5. SELECCIONAR ELEMENTOS Y CONSEGUIR INFORMACIÓN CON MACROS ................................................. 44

3 © Structuralia
 REVIT API – Primeros pasos

1. INTRODUCCIÓN
Ya hemos entendido un poco de qué va todo esto de la API de Revit, aunque como todo, lleva
tiempo familiarizarnos con ella y sus particularidades. Por otro lado, ya habéis aprendido las
bases de dos potentísimos lenguajes de programación: Python y C#, lo cual os va a venir
fenomenal para entender todo lo que sigue.

Así que vamos a ir aprendiendo con ejemplos muy sencillitos. En este capítulo y los siguientes
voy a ir haciendo algunas cosas en Dynamo con Python y otras con macros con C#. Procuraré
que los ejemplos sean complementarios.

Alguien me podría decir que por qué no hacemos los macros en Python. Bueno, la verdad es
que por poder se puede, pero la razón principal es que hay muchos foros y comunidad de
programación con código con C# y es uno de los lenguajes que tenemos en el HTML de la API
de Revit.

Por lo tanto, bien está que nos manejemos con los dos.

La idea es que pasando de un lado a otro veáis lo que tienen en común (casi todo) y las
particularidades de cada herramienta (temas muy concretos).

© Structuralia 4
 REVIT API – Primeros pasos

2. TASKDIALOG CLASS
Pues empezamos entonces. Al igual que un niño empieza a conocer el mundo, nosotros lo
vamos a hacer de una manera parecida. Vamos a empezar a decir nuestras primeras palabras
y siguiendo con la analogía del niño, a empezar a tomar cosas y a reconocerlas.

Vamos pues a la API y vamos a buscar una clase que se llama TaskDialog como en la Figura
1.

Recomendación: siempre leer la descripción. Nos dice que es una caja de diálogo que puede
ser utilizada para mostrar información y recibir simples inputs del usuario.

Ahora fijémonos por debajo, en Syntax. Nos dice que es public (grado de accesibilidad). La
clase se llama TaskDialog y vemos que es una subclase de APIObject (lo que vemos en rojo).

Bien, pues ahora vamos a sus miembros (Figura 2). Vemos que tenemos una serie de métodos
que son Show dependiendo de los argumentos. Fijémonos que hay uno con una S delante que
es Show(String, String) como en la Figura 3.

Fijémonos en la descripción: Nos muestra un task dialog con título, instrucción principal y un
botón de cerrar. Vamos a clicarlo y a entrar dentro. Deberíamos ver algo como en la Figura 4.

Figura 1: Buscamos en la API (en Search, arriba a la izquierda) la clase TaskDialog

5 © Structuralia
 REVIT API – Primeros pasos

Figura 2: Ahora nos vamos a sus miembros (constructors, methods y properties)

Figura 3: Buscamos un método que se llama Show(String, String)

© Structuralia 6
 REVIT API – Primeros pasos

Figura 4: Fijémonos en la sintaxis del método: Nos devuelve un TaskDialogResult y necesita de dos strings.

Como vemos es un método estático, es decir, que se aplica sobre la clase no sobre un objeto
(public static). Como vemos nos devuelve un TaskDialogResult y el método Show, requiere de
dos argumentos: un título como string y una instrucción principal también como string.

Bien, pues vamos a aplicar este método en un Python Script. La primera cosa que tenemos
que saber es que necesitamos un dll fundamental como es RevitAPIUI. De la misma forma que
en módulos anteriores añadíamos referencias, aquí vamos a hacer lo mismo. De este dll vamos
a utilizar el namespace Autodesk.Revit.UI y nos vamos a traer todas las clases.

Si nos hemos fijado, sino lo vuelvo a mostrar en la Figura 5, TaskDialog es una clase que
pertenece al namespace: Autodesk.Revit.UI (Fijarse en la parte superior de la imagen) y por
debajo nos dice que el Assembly es en RevitAPIUI.dll. Nada es casual ¿verdad?.

Pues entonces teniendo todo esto en cuenta me voy a Dynamo y con dos code blocks y un
Python Script puedo hacer lo que aparece en la Figura 6. En OUT pondremos siempre algo
porque suele dar error si lo dejamos vacío, así que pongo algo por ejemplo para que cuando
nos pongamos por encima del nodo Python Script nos aparezca algo. Nos debería aparecer lo
que vemos en la Figura 7.

7 © Structuralia
 REVIT API – Primeros pasos

Figura 6: Desde Dynamo trabajamos con la RevitAPIUI.dll y del namespace nos traemos todo para utilizar
TaskDialog

Figura 7: Vemos que nos aparece una pequeña interfaz (un task dialog) en la que aparece el título y la main
instruction.

© Structuralia 8
 REVIT API – Primeros pasos

Todavía podemos llegar a ser más sencillos, sin preparar las variables ni nada. Colocamos los
dos strings como argumentos y voila!!.

Figura 8: Lo mismo haciéndolo directamente con dos strings.

9 © Structuralia
 REVIT API – Primeros pasos

Figura 9: Simplificado al máximo, saliendo por OUT directamente.

Simplificándolo al máximo el proceso, lo podéis directamente pasar por OUT, lo único es que
cuando paséis el cursor por el nodo os aparecerá Cancel.

© Structuralia 10
 REVIT API – Primeros pasos

3. TASKDIALOG CON UN MACRO

Ahora voy a hacer lo mismo sin nodos. Lo voy a hacer con un simple macro. Macros son en
resumidas cuentas, programas que se desarrollan internamente en Revit. Así que no
necesitamos ni Visual Studio, ni nada parecido, solo Revit.

¿Dónde los encontramos?. En la ficha de Gestionar, tenemos un grupo que se llama Macros, y
un icono que se llama Administrador de Macros. Por si acaso mirad la Figura 10.

Cuando clicamos este Administrador de macros, pasamos a una interfaz como la que vemos
en la Figura 11.

Nos aparecen dos grandes opciones: Aplicación o el nombre del proyecto en el que estamos,
en este caso Máster en programación…

¿Qué quiere decir todo esto?. Pues básicamente que tenemos dos opciones. La primera es
desarrollar el macro como aplicación de tal manera que todos los que desarrolle aquí los veré
en mi instalación de Revit. Mientras que si elijo la opción en el proyecto, esos macros serán en
exclusiva para ese proyecto en concreto. Sea cual sea la opción, siempre podemos después
cambiar de opinión y reconvertirlo a la otra opción. El tema es que esa reconversión requiere
de un cierto conocimiento.

Entonces vamos a coger la opción Aplicación, porque este macro en concreto lo quiero en mi
instalación de Revit, de tal manera que lo pueda aplicar en otros proyectos.

Ahora solo tengo una opción de crear, que es la de crear un nuevo Módulo. Dentro de esos
módulos tendré los macros que quiera. En un mismo proyecto, puedo tener un montón de
módulos y en cada uno de estos, otro montón de macros. Es una manera de ir
compartimentando las cosas. Así que nos vamos a crear un módulo y nos aparecerá algo como
esto en la Figura 12.

Así pues, vamos a darle un nombre, por ejemplo: AprenderApi (convención Pascal) y en el
lenguaje tenemos 4 opciones.

Como vemos podría también utilizar Python entre otros. Personalmente utilizo C# como ya he
contado porque en cuanto a código para Revit sigue siendo el más popular. Por otro lado
siempre es bienvenido que hagamos una descripción de en qué consiste dicho módulo.

11 © Structuralia
 REVIT API – Primeros pasos

Figura 10: En la ficha de Gestionar tenemos el apartado de macros y el Administrador de macros en la parte
superior

Figura 11: El administrador de macros tiene dos grandes fichas: Aplicación y la del proyecto (en este caso
Máster…)

© Structuralia 12
 REVIT API – Primeros pasos

Figura 12: Creamos nuestro primer módulo, escogemos el lenguaje y le damos una descripción

Dentro de ese módulo voy a crear mi primer macro, así que nos vamos al botón Macro (Crear)
en la parte derecha de la interfaz.

Deberíamos ver cómo se nos abre SharpDevelop. Éste va a hacer las veces de Visual Studio
pero dentro de Revit.

13 © Structuralia
 REVIT API – Primeros pasos

Figura 13: Se nos abre SharpDevelop

Como podemos apreciar se nos aparecen un montón de cosas que pueden intimidar bastante a
un neófito. Como no es vuestro caso ya que ya conocéis C#, no tengo necesidad de explicaros
qué son esos using. Ya sabemos que son directivas que nos permiten utilizar bibliotecas
creadas por otros y así utilizar sus clases y métodos.

Así pues lo importante aquí es saber que por defecto se nos aparecen toda una serie de
directivas y ya vemos que Autodesk.Revit.UI y Autodesk.Revit.DB cobran mucha importancia.
La primera se refiere a la user interface (UI) así pues a la interfaz de usuario y la otra es la data
base o base de datos.

Ya vamos viendo por encima que nos aparece namespace como keyword y justo después el
nombre del módulo que le hemos dado: AprenderApi.

Dentro de este namespace hay un montón de cosas con las que ahora no me quiero meter.
Las iremos descubriendo poco a poco. Lo importante aquí es quedarnos con la idea de que se
me ha generado un namespace y dentro hay una clase que nos aparece por defecto llamada
ThisApplication y eso es porque lo hemos hecho dentro de Aplicación en el Administrador de
macros.

© Structuralia 14
 REVIT API – Primeros pasos

A partir de ahí, vemos que nos aparece en gris encuadrado: Revit Macros generated code. A
partir de aquí vamos a poner los macros que queramos dentro de este módulo.

Ya vemos que nos aparece: public void MiPrimerMacro(). Public porque es de acceso público,
es decir lo puedo ver desde el administrador de macros, void porque no me devuelve ningún
valor y el nombre del macro como si fuera un método sin parámetros.

En mi Administrador de macros se debería ver así como en la Figura 14.

Figura 14: En el administrador de macros me aparece MiPrimerMacro, como vemos le he dado una descripción

Sin problemas podría crear dentro de esta clase, un macro que fuera de acceso privado, es
decir que no pudiera verlo desde mi Administrador de macros (Figura 15).

15 © Structuralia
 REVIT API – Primeros pasos

Figura 15: Puedo crear también macros privados o no accesibles desde el Administrador de macros

Así que puedo llamarlo: MiMacroNoVisible() y pongo private por delante. Ahora si vuelvo al
administrador de macros, no veré este macro que acabo de crear (Figura 16).

Figura 16: Vemos que no aparece el macro privado que acabo de crear en SharpDevelop

© Structuralia 16
 REVIT API – Primeros pasos

Bien, dicho todo esto, volvamos a la clase TaskDialog (Figura 17).

Figura 17: Volvemos a la clase TaskDialog y nos fijamos que su namespace es: Autodesk.Revit.UI

Como ya hemos comentado en la parte superior de SharpDevelop tenemos: using

Autodesk.Revit.UI. Todo eso nos viene fenomenal porque vamos a utilizar esta clase. Si yo
borrase esta directiva, tendría que escribir: Autodesk.Revit.UI.TaskDialog, etc, etc como en la
Figura 18.

17 © Structuralia
 REVIT API – Primeros pasos

Figura 18: Al haber suprimido la directiva Autodesk.Revit.UI en la parte superior tengo que escribirlo si quiero usar
TaskDialog

Por supuesto todo esto no tiene sentido, así que vuelvo a ponerlo como estaba. Solo tengo que
invocar la clase TaskDialog ya que el método Show es estático y pongo los dos parámetros
que necesito.

Así pues me invento los mensajes que quiero que aparezcan en el task dialog, por ejemplo los
de la Figura 19.

© Structuralia 18
 REVIT API – Primeros pasos

Figura 19: Utilizo el método Show de la clase TaskDialog y me invento sus mensajes correspondientes

Perfecto, ahora solo tenemos que hacer un último paso para ver si algún error y es Generar
Solución, lo tenemos en la parte superior en Generar (Figura 20).

19 © Structuralia
 REVIT API – Primeros pasos

Figura 20: Ahora solo nos queda ir a Generar Solución y como vemos debajo todo ha ido bien

Como podemos apreciar debajo, todo ha ido bien. Nos dice: “Generación iniciada. Compilando
AprenderApi Generación completada correctamente. Así que todo está bien y no ha habido
errores.

Ahora solo nos queda ir a nuestro Administrador de macros. Nos vamos al que acabamos de
crear y le damos a Ejecutar en la parte superior derecha (Figura 21).

© Structuralia 20
 REVIT API – Primeros pasos

Figura 21: Vamos al Administrador de macros, buscamos el que acabamos de hacer, nos ponemos por encima y le
damos a ejecutar.

Figura 22: Nos aparece el mensaje que acabamos de crear. Todo ha funcionado

Nos debería aparecer algo como lo que vemos en la Figura 22. Efectivamente, funciona. Ya
tenemos nuestro primer macro. Enhorabuena, si no te ha quedado muy claro, no te preocupes
porque vamos a repetir este proceso varias veces.

Para rematar este macro, pongamos por caso que quiero que el usuario que ve este task dialog
pueda interactuar. Como ejemplo, podría ser lanzar una pregunta y que responda o bien si o
bien no. En función de lo que haya respondido, le aparecerá otro task dialog.

21 © Structuralia
 REVIT API – Primeros pasos

Así que manos a la obra. Vamos de nuevo a la API y vemos que el método Show tiene otras
opciones como la tercera de Show en la Figura 23.

Figura 23: Tenemos un método Show que requiere también de common buttons

Si entramos a explorar el método, nos sale lo que vemos en la Figura 24.

© Structuralia 22
 REVIT API – Primeros pasos

Figura 24: Este método Show requiere de tres parámetros entre otros TaskDialogCommonButtons

Como vemos requiere de los dos parámetros que hemos visto antes más
TaskDialogCommonButtons. Para ver en qué consisten estos últimos vamos adentro.

Vemos en la Figura 25 que se trata de una enumeration con una serie de botones standard.
Tenemos desde None hasta Cancel pasando por entre otros, Yes y No.

Estos dos últimos nos pueden venir muy bien así que vamos a utilizarlos.

Por lo tanto nos vamos a nuestro macro y vamos a cambiarlo para tener estos dos botones.

23 © Structuralia
 REVIT API – Primeros pasos

Figura 25: La enumeration TaskDialogCommonButtons y sus distintos miembros

Figura 26: Modificamos el macro y metemos los dos botones

© Structuralia 24
 REVIT API – Primeros pasos

Así que cambiamos el macro y ponemos una pregunta tipo: ¿Te gusta programar? Y dos
botones separados por una barra vertical |.

Nos tendría que dar lo que vemos en la Figura 27. Vemos que nos aparecen los dos botones.
Sin embargo tanto si le doy a Sí como a No, no ocurre nada.

Figura 27: Nos aparece la pregunta con las dos opciones que no nos llevan a ninguna parte.

Tenemos por tanto que recurrir a utilizar los conceptos de programación que hemos aprendido.
La idea es clara: si le damos a Sí que nos aparezca otro task dialog dándonos la enhorabuena
y si le damos a No, que nos devuelva un mensaje de ánimo. Podemos utilizar un if / else
stament.

Vamos a darle a Generar Solución de nuevo y nos vamos al Administrador de macros para
ejecutarlo.

Para ello, ya podemos fijarnos que el método nos devuelve un TaskDialogResult que es otra
enumeration (Figura 28).

Si nos fijamos entre los miembros de esta enumeration, tenemos Yes, que en la descripción
nos dice que es el return value o valor de retorno de TaskDialogCommonButtons.Yes y lo
mismo podríamos ver para No, que es el valor de retorno de TaskDialogCommonButtons.No.

25 © Structuralia
 REVIT API – Primeros pasos

Figura 28: El método Show nos devuelve una TaskDialogResult Enumeration con una serie de miembros

Así que lo podríamos hacer de la siguiente manera (ver Figura 29).

© Structuralia 26
 REVIT API – Primeros pasos

Figura 29: Utilizamos if y else para controlar el flujo de nuestro código

Así que si le das a Sí, te aparecerá un mensaje y si a No aparecerá otro. Vamos a Generar
Solución y a ejecutar nuestro macro. Nos aparece primero el mensaje con la pregunta (Figura
30) y cuando le doy a Sí me aparece otro mensaje de enhorabuena como en la Figura 31.

Figura 30: De nuevo salta la pregunta con las dos opciones

27 © Structuralia
 REVIT API – Primeros pasos

Figura 31: Al darle a Sí nos aparece el mensaje de enhorabuena que queríamos

Figura 32: Si le doy a No, me aparece un mensaje de ánimo

© Structuralia 28
 REVIT API – Primeros pasos

4. SELECCIONAR ELEMENTOS Y CONSEGUIR INFORMACIÓN

Ya hemos empezado a balbucear un poco con la Api. Sigamos. Ahora siguiendo con el símil de
los bebés, vamos a empezar a tocar cosas y a reconocerlas. Vámonos de nuevo a Dynamo.

Vamos a incorporar un nuevo dll: RevitServices. Nos va a permitir importar el

DocumentManager y el TransactionManager.

Vamos poco a poco, así que de RevitServices.Persistence vamos a traernos el

DocumentManager. A través de este DocumentManager vamos a poder obtener el
ActiveUIDocument. Ya sé que esto suena un poco a chino al principio. Este ActiveUIDocument,
dicho de manera simple, representa el proyecto activo en ese momento. Básicamente el
proyecto que estoy utilizando ahora. Puedo buscarlo en la API (Figura 33).

Figura 33: Con ActiveUIDocument obtenemos un objeto que representa el proyecto activo actualmente

29 © Structuralia
 REVIT API – Primeros pasos

Como vemos es una propiedad que pertenece a la clase UIApplication y lo que nos devuelve el
un UIDocument (en rojo). Este UIDocument representa como nos dice un proyecto abierto en
nuestra UI (interfaz de usuario) (Figura 34).

Bueno, vámonos entonces a Dynamo y como comentaba vamos a añadir una nueva referencia
y a traernos este UIDocument (proyecto abierto en nuestra UI).

Para ello tenemos que hacer una serie de cosas un poco alambicadas. No os asustéis porque
yo tampoco me las sé de memoria, al final utilizamos plantillas, pero para irnos familiarizando
sería lo que veis en la Figura 35.

Figura 34: Como vemos este UIDocument representa un proyecto de Revit abierto en la interfaz de usuario

© Structuralia 30
 REVIT API – Primeros pasos

Figura 35: Ya vemos que conseguimos un UIDocument y veremos que se le suele representar por uidoc

Ya vemos que le hemos puesto un nombre: uidoc. Éste es el nombre que más se ve en foros y
demás, así que aplico la misma terminología. Si exploro un poco veo que UIDocument tiene
una serie de propiedades (Figura 36). Entre otras, tengo ActiveView que nos devuelve la vista
activa de ese proyecto abierto en la UI. Yo la que tengo activa es una axonométrica de un
proyecto de ejemplo, así que voy a verificar que funciona (Figura 37).

Figura 36: Propiedades de UIDocument, por ejemplo ActiveView

31 © Structuralia
 REVIT API – Primeros pasos

Figura 37: Con ActiveView puedo tener acceso a la vista actual en mi interfaz de usuario.

Si seguimos, veríamos que ActiveView nos devuelve una View y esa clase View tiene una
propiedad llamada Category y entre las propiedades de Category hay una que es nombre. Así
que podemos ver por pantalla el nombre de la categoría. Vemos que es Vistas como en la
Figura 38.

Figura 38: Siguiendo el hilo podríamos ver el nombre de la categoría a la que pertenece la vista activa

© Structuralia 32
 REVIT API – Primeros pasos

Otra de las propiedades de la Figura 36 es Selection. Nos dice que nos devuelve o nos
recupera los elementos actualmente seleccionados. (Figura 39)

Figura 39: Utilizando la propiedad Selection de UIDocument obtenemos los elementos actualmente seleccionados.

Nos devuelve una Selection que tiene otros métodos y propiedades. Entre otros tenemos el
método GetElementIds que nos devuelve los ids de los elementos que hayamos seleccionados.

Lo podemos ver en la Figura 40.

33 © Structuralia
 REVIT API – Primeros pasos

Figura 40: Tenemos el método GetElementIds que nos devuelve los ids de los elementos seleccionados

Así que vamos a seleccionar algo previamente de un proyecto cualquiera, por ejemplo lo que
se ve en la Figura 41.

Ahora utilizando el método que acabamos de ver GetElementIds puede mostrar en el nodo los
ids de dichos elementos. Lo tenemos en la Figura 42.

Después de haber aprendido todo esto, lo vamos a combinar con TaskDialog porque la idea es
enseñar los ids en un task dialog.

Así que podríamos hacer algo como lo que aparece en la Figura 43.

© Structuralia 34
 REVIT API – Primeros pasos

Figura 41: Seleccionamos una serie de elementos en nuestra vista activa, por ejemplo estos

Figura 42: Conseguimos mostrar los ids de lo que acabo de seleccionar utilizando GetElementIds()

35 © Structuralia
 REVIT API – Primeros pasos

Figura 43: Podemos utilizar el bucle for y mostrar en un task dialog los ids

Utilizando un bucle for y definiendo un string vacío (ids_textos) puedo mostrar los ids sin
problemas como en la Figura 44, sabiendo que los ids (ElementId class) tienen un método
llamado ToString para obtener una representación como string de los strings.

Figura 44: Mostramos los ids de lo seleccionado en Revit a través de un task dialog

© Structuralia 36
 REVIT API – Primeros pasos

Lo que hemos hecho está bien, ahora sin embargo lo que vamos a hacer es seleccionar un
elemento individualmente, pero a diferencia de cómo lo hacíamos con anterioridad, esto es
preseleccionándolo, ahora nos va a aparecer un mensaje incitándonos a que seleccionemos un
elemento. Vamos a ello entonces.

Si vamos a Selection class de nuevo, veremos que podemos hacerlo mediante un método
llamado PickObject, lo podemos ver en la Figura 45.

Figura 45: En la clase Selection tenemos el método PickObject

37 © Structuralia
 REVIT API – Primeros pasos

La verdad es que hay varias posibilidades, vámonos a la primera que requiere un ObjectType.
(Figura 46)

Figura 46: Indagamos en el método PickObject que requiere de un ObjectType

Como vemos este método requiere de un ObjectType y nos devuelve una Reference. Si vamos
a ObjectType veremos que es una enumeration con una serie de miembros. Vemos que esos
miembros van desde Nothing (nada) hasta Subelement pasando por Element o Face. Así que
tenemos que especificar en suma, qué tipo de objecto vamos a seleccionar. En este caso es
claro que es un Element (Whole element). (Figura 47)

© Structuralia 38
 REVIT API – Primeros pasos

Figura 47: ObjectType es una enumeration que tiene distintos miembros como Element (Whole element)

Figura 48: Reference nos lo define como una referencia a un objeto geométrico en un modelo de Revit.

39 © Structuralia
 REVIT API – Primeros pasos

Por otro lado la Reference no es más que una referencia a un objeto geométrico, como
aparece en la Figura 48.

Bueno pues con todo esto vámonos a Dynamo (Figura 49).

Figura 49: Con el método PickObject seleccionamos un elemento devolviéndonos una Reference

Bien, con todo esto hemos conseguido una referencia, pero no en si el elemento y esto es lo
verdaderamente fundamental: obtener el elemento a partir de una referencia. ¿Cómo lo
hacemos?.

Para ello tenemos que ver la clase Document, como en la Figura 50. Nos viene a decir que es
un objeto que representa un proyecto de Revit abierto. El tema es bastante parecido a primera
vista al UIDocument, lo que pasa es que este nos habla desde la UI o interfaz de usuario.

© Structuralia 40
 REVIT API – Primeros pasos

Figura 50: Document class nos dice que representa un proyecto abierto de Revit

En suma representa el proyecto abierto activo. Si exploramos entre los métodos tenemos
GetElement(Reference), como vemos en la Figura 51. Nos dice que nos da el elemento
referenciado por la referencia como input. Veámoslo más de cerca (Figura 52).

Con esto ya vamos bien encaminados. Para ello también necesitaremos este documento actual
y lo podemos hacer utilizando de nuevo DocumentManager y lo podemos llamar doc. Toda la
operación la vemos en la Figura 53.

Figura 51: En Document class encontramos el método GetElement(Reference

41 © Structuralia
 REVIT API – Primeros pasos

Figura 52: El método GetElement tiene como resultado un Element y necesita de una referencia

Figura 53: Como he seleccionado un árbol me aparece el nombre del elemento y su id.

© Structuralia 42
 REVIT API – Primeros pasos

Ahora podríamos mostrar por pantalla dos propiedades del elemento: su id y su nombre. Las
dos las tenemos en Element class (Figura 54) y las podemos mostrar por pantalla (Figura 55).

Figura 54: En Element class tenemos propiedades como el nombre y su id

Figura 55: Podemos enseñar por pantalla el id y el nombre del elemento seleccionado

43 © Structuralia
 REVIT API – Primeros pasos

5. SELECCIONAR ELEMENTOS Y CONSEGUIR INFORMACIÓN CON

MACROS
Ya hemos sido capaces de tocar elementos y conseguir información de ellos. Aparte de eso
hemos sido también capaces de mostrar esa información por pantalla a través de task dialogs.
Ahora lo vamos a hacer desde un macro, así que vámonos a Revit.

Figura 56: Creamos un nuevo macro desde el Administrador de macros (SeleccionarElemento)

Vamos a crear un nuevo macro por ejemplo le podemos llamar SeleccionarElemento, lo vamos
a hacer desde Aplicación porque lo queremos para nuestra instalación de Revit (Figura 57).
Debería abrirse SharpDevelop como en la Figura 57.

© Structuralia 44
 REVIT API – Primeros pasos

Figura 57: Se abre SharpDevelop y nos aparece el macro que acabamos de nombrar SeleccionarElemento

La primera cosa que podemos ir haciendo es traernos uidoc y doc (UIDocument y Document).
No tiene mucha complicación. Para un macro de aplicación lo hacemos de esta manera (Figura
58).

Figura 58: Conseguimos el uidoc (UIDocument) y el doc (Document)

45 © Structuralia
 REVIT API – Primeros pasos

Conseguidos los dos, lo demás es muy similar. Primero tendremos que conseguir la referencia
del elemento con el método PickObject. Fijémonos que esta vez no necesito hacer
Selection.ObjectType.Element, sino ObjectType.Element ya que entre las directivas tengo
using Autodesk.Revit.UI.Selection. (Figura 59)

Figura 59: Conseguimos la referencia del elemento

Ahora nos queda conseguir el elemento a partir de la referencia, lo podemos hacer con el
método GetElement de la clase Document (Figura 60).

Figura 60: Conseguimos el elemento a través de la referencia

Bien, pues ahora solo resta enseñar si queremos por pantalla, a través de un task dialog el id y
el nombre por ejemplo del elemento seleccionado. (Figura 61). Fijémonos que como estoy en
C# no necesito transformar el id a string con el método ToString.

© Structuralia 46
 REVIT API – Primeros pasos

Figura 61: Enseñamos información (id y nombre) del elemento con un task dialog

Con lo que tenemos solo tenemos que ejecutar el macro y seleccionando un elemento
cualquiera, nos aparecerá algo parecido a lo que vemos en la Figura 62.

Figura 62: Seleccionando un elemento nos aparece un task dialog con su id y nombre respectivo

47 © Structuralia
 REVIT API – Primeros pasos

Vamos a ahora a seleccionar en vez de uno, varios elementos. En este caso lo vamos a hacer
con otro método aunque muy parecido. Si me voy a Selection en la API veré que también
tenemos un método que se llama PickObjects (en plural) (Figura 63). Entramos en él para ver
en qué consiste (Figura 64).

Figura 63: Tenemos en Selection class el método PickObjects(ObjectType)

Figura 64: Este método PickObjects nos sirve para seleccionar varios objectos y nos devuelve un Ilist

© Structuralia 48
 REVIT API – Primeros pasos

Pues vamos a ello, necesitaremos también el doc y el uidoc. El macro lo he llamado

SeleccionMultiplesElementos. Para empezar deberíamos tener algo como esto (Figura 65).

Figura 65: Utilizamos uidoc y doc y conseguimos las referencias de los elementos

Ahora necesitaremos hacer un foreach loop para conseguir los elementos respectivos y sus ids
y nombres (Figura 66).

Figura 66: Con un foreach loop podemos conseguir los ids y los nombres de los elementos seleccionados

49 © Structuralia
 REVIT API – Primeros pasos

Solo nos queda mostrarlos por pantalla. Ya sabemos que lo podemos hacer con un task dialog
(Figura 67).

Figura 67: Enseñamos la información con un task dialog

Ahora le damos a generar y cuando ejecutamos el macro, nos invita a que vayamos
seleccionando uno a uno los elementos. Hay que fijarse que el cursor tiene un signo más para
irlos seleccionando uno a uno. También si lo pasamos por uno ya seleccionado, nos invita a
que lo deseleccionemos si queremos. (Figura 68)

Finalmente, una vez seleccionado lo que queremos, le damos a Finalizar (en la parte superior
izquierda) y ya nos debería aparecer el task dialog como en la Figura 69.

© Structuralia 50
 REVIT API – Primeros pasos

Figura 68: Podemos seleccionar uno a uno y finalmente le damos a Finalizar en la parte superior izquierda

Figura 69: Nos aparece un task dialog con la información de los elementos seleccionados

51 © Structuralia
 REVIT API – Primeros pasos

Por supuesto lo podemos hacer también utilizando el método que habíamos visto
GetElementIds. Este método nos permite seleccionar varios a la vez de golpe y hay que
seleccionar esos elementos previamente. Para no extenderlo demasiado ya que ya lo hemos
visto, lo pongo todo el código de golpe (Figura 70).

Figura 70: Otra manera de seleccionar múltiples elementos

Si ahora lo generamos y lo ejecutamos (previamente seleccionado lo que queremos) nos

debería aparecer también un task dialog como el de la Figura 71.

Figura 71: Nos aparece un task dialog de nuevo con la información del elemento

© Structuralia 52