def getDependent(self, filterClass=None):
"""
Returns a list of dependent elements.
Args:
filterClass (class, optional): An optional class to filter the list of dependent elements by. Defaults to None.
Returns:
list: The list with the dependent Revit elements.
"""
import revitron
from revitron import _
# The GetDependentElements() method doesn't exist in older Revit API versions.
# Therefore it is required to fallback to a more compatible way of getting those dependent elements
# in case an execption is raised.
# The fallback solution basically tries to get the list of affected IDs when trying to delete
# the actual parent element within a transaction that will be cancelled.
try:
fltr = None
if filterClass:
fltr = revitron.DB.ElementClassFilter(filterClass)
dependentIds = self._element.GetDependentElements(fltr)
except:
sub = revitron.Transaction()
ids = revitron.DOC.Delete(self._element.Id)
sub.rollback()
if filterClass:
dependentIds = revitron.Filter(ids).byClass(
filterClass).noTypes().getElementIds()
else:
dependentIds = revitron.Filter(ids).noTypes().getElementIds()
dependent = []
for eId in dependentIds:
dependent.append(_(eId).element)
return dependent
def context(self, doc=False):
if not doc:
doc = self.mainDoc
self.doc = doc
revitron.DOC = self.doc
revitron.APP = self.doc.Application
self.level = revitron.Filter().byCategory(
'Levels').noTypes().getElements()[0]
revitron.ACTIVE_VIEW = revitron.Filter().byCategory(
'Views').noTypes().getElements()[0]
def isBoundToCategory(category, paramName):
"""
Test if a parameter is bound to a given category.
Args:
category (string): The category name
paramName (string): The parameter name
Returns:
boolean: Returns True if parameter is bound already
"""
import revitron
definition = None
for param in revitron.Filter().byClass(
revitron.DB.SharedParameterElement).getElements():
if param.GetDefinition().Name == paramName:
definition = param.GetDefinition()
break
if definition:
binding = revitron.DOC.ParameterBindings[definition]
for cat in binding.Categories:
if cat.Name == category:
return True
def __init__(self): """ Inits a new ParameterNameList instance including all parameter names in the document. """ import revitron self.parameters = [] for name in BuiltInParameterNameMap().map: self.parameters.append(name) for param in revitron.Filter().byClass(revitron.DB.SharedParameterElement).getElements(): self.parameters.append(param.GetDefinition().Name) for param in revitron.Filter().byClass(revitron.DB.ParameterElement).getElements(): self.parameters.append(param.GetDefinition().Name) self.parameters = sorted(list(set(self.parameters)))
def add(method, title):
import revitronui
roomTagTypes = revitron.Filter().byCategory(
'Room Tags').onlyTypes().getElements()
roomTagType = revitronui.SelectType(roomTagTypes, title).show()
scope = revitron.Selection.get()
if not scope:
scope = revitron.ACTIVE_VIEW.Id
if roomTagType:
rooms = revitron.Filter(scope).byCategory(
'Rooms').noTypes().getElements()
max_value = len(rooms)
counter = 0
with forms.ProgressBar(
title='Tagging rooms ... ({value} of {max_value})') as pb:
for room in rooms:
counter = counter + 1
try:
method(room, roomTagType.Id)
except:
pass
pb.update_progress(counter, max_value)
def _filterElements(self):
"""
Filter elements in the target model by applying all filters that
are defined in the configuration.
Returns:
list: The list of filtered elements
"""
import revitron
filters = self.config.get('filters')
fltr = revitron.Filter()
for f in filters:
evaluator = getattr(revitron.Filter, f.get('rule'))
fltr = evaluator(fltr, *f.get('args'))
return fltr.noTypes().getElements()
def view3D():
"""
Create a new 3D view.
Returns:
object: A Revit 3D view element
"""
import revitron
view3DType = None
for viewFamilyType in revitron.Filter().byClass(
revitron.DB.ViewFamilyType).onlyTypes().getElements():
if viewFamilyType.FamilyName == '3D View':
view3DType = viewFamilyType
break
return revitron.DB.View3D.CreateIsometric(revitron.DOC, view3DType.Id)
def applyStringFilter(self, paramName, value, evaluator, invert = False):
"""
Applies a string filter.
Args:
paramName (string): The parameter name
value (mixed): the value
evaluator (object): The FilterStringRuleEvaluator
invert (boolean): Inverts the filter
"""
import revitron
filters = []
# Since a visible parameter name could match multiple built-in parameters,
# we get a list of value providers.
# While iterating that list, the parameter filter is applied each time
# to a fresh element collector that will be later merged or intersected with the others.
for valueProvider in revitron.ParameterValueProviders(paramName).get():
rule = revitron.DB.FilterStringRule(valueProvider, evaluator, value, True)
_filter = Filter()
# Try to get elements from the collector as base for the fresh collector.
# In case there was never a filter applied before, getting elements will raise an exception
# and new Filter() instance is created with the same scope.
try:
_filter.collector = revitron.DB.FilteredElementCollector(revitron.DOC, self.collector.ToElementIds())
except:
_filter.collector = revitron.Filter(self.scope).collector
_filter.applyParameterFilter(rule, invert)
filters.append(_filter)
self.collector = filters[0].collector
if len(filters) > 1:
for i in range(1, len(filters)):
if not invert:
self.collector.UnionWith(filters[i].collector)
else:
self.collector.IntersectWith(filters[i].collector)
def _getLines(self, typeFilterCsv=False):
"""
Create the filtered dict of grid lines.
Args:
typeFilterCsv (string, optional): A CSV filter. Defaults to False.
Returns:
dict: A dict of Revit grid line elements where the grid name serves as key
"""
if hasattr(self, '_lines'):
return self._lines
import revitron
fltr = revitron.Filter().byCategory('Grids').noTypes()
if typeFilterCsv:
fltr = fltr.byStringContainsOneInCsv('Type', typeFilterCsv)
lines = dict()
for line in fltr.getElements():
try:
lines[line.Name] = line
except:
pass
return lines
def getLinkedDocuments(self, scope = None):
"""
Returns a dictionary of all linked documents.
The key is the ID of the link and the value is the actual document object.
Args:
scope (mixed, optional): List or view ID. Defaults to None.
Returns:
dict: A dictionary of all linked documents.
"""
import revitron
linkedDocuments = dict()
extension = '.rvt'
for link in revitron.Filter(scope).byCategory('RVT Links').noTypes().getElements():
linkType = revitron.Parameter(link, 'Type').getValueString()
if linkType.endswith(extension):
linkType = linkType[:-len(extension)]
for openDoc in revitron.APP.Documents:
if openDoc.IsLinked:
if openDoc.Title == linkType:
linkedDocuments[link.Id] = openDoc
return linkedDocuments
if selection:
components.append(
CheckBox('selection', 'Search in selection only', default=True))
else:
components.append(
CheckBox('viewOnly', 'Search in this view only', default=False))
components.append(
Button('Select',
Width=100,
HorizontalAlignment=System.Windows.HorizontalAlignment.Right))
form = FlexForm('Select by Parameter', components)
form.show()
if 'search' in form.values:
scope = False
if 'selection' in form.values and form.values['selection']:
scope = selection
else:
if 'viewOnly' in form.values and form.values['viewOnly']:
scope = revitron.ACTIVE_VIEW.Id
ids = revitron.Filter(scope).noTypes().byStringContains(
form.values['parameter'], form.values['search'],
form.values['invert']).getElementIds()
revitron.Selection.set(ids)
def testIsType(self):
for item in revitron.Filter().onlyTypes().getElements():
self.assertTrue(_(item).isType())
wall = self.fixture.createWall()
self.assertFalse(_(wall).isType())
components.append(
CheckBox('viewOnly', 'Search in this view only', default=False))
components.append(
Button('Select',
Width=100,
HorizontalAlignment=System.Windows.HorizontalAlignment.Right))
form = FlexForm('Select by String Parameter', components)
form.show()
if 'search' in form.values:
scope = False
if 'selection' in form.values and form.values['selection']:
scope = selection
else:
if 'viewOnly' in form.values and form.values['viewOnly']:
scope = revitron.ACTIVE_VIEW.Id
fltr = (revitron.Filter(scope).noTypes().byStringContains(
form.values['parameter'], form.values['search'],
form.values['invert']))
if form.values['category'] != 'All':
fltr.byCategory(form.values['category'])
ids = fltr.getElementIds()
revitron.Selection.set(ids)
else:
components.append(
CheckBox('viewOnly', 'Search in this view only', default=False))
components.append(
Button('Select',
Width=100,
HorizontalAlignment=System.Windows.HorizontalAlignment.Right))
form = FlexForm('Select by Numeric Parameter', components)
form.show()
if 'value' in form.values:
try:
el = (revitron.Filter().byNumberIsGreater(
form.values['parameter'], 0.0).noTypes().getElementIds()[0])
unit = _(el).getParameter(form.values['parameter']).unit()
value = revitron.Unit.convertToInternalUnit(form.values['value'], unit)
except:
value = float(form.values['value'])
print('no unit', value)
scope = False
if 'selection' in form.values and form.values['selection']:
scope = selection
else:
if 'viewOnly' in form.values and form.values['viewOnly']:
scope = revitron.ACTIVE_VIEW.Id
evaluator = getattr(revitron.Filter, form.values['evaluator'])
if form.values:
transaction = revitron.Transaction(suppressWarnings=True)
revitron.DocumentConfigStorage().set('revitron.rooms.calculateRoomHeights',
form.values)
max_value = 4
with ProgressBar(indeterminate=True,
title='Preparing ... ({value} of {max_value})') as pb:
pb.update_progress(0, max_value)
roomFilter = revitron.Filter().noTypes().byCategory('Rooms')
if values.roomFltrParam and values.roomFltrList:
roomFilter = roomFilter.byStringContainsOneInCsv(
values.roomFltrParam, values.roomFltrList,
values.roomFltrInvert)
rooms = roomFilter.getElements()
rawElements = None
finElements = None
pb.update_progress(1, max_value)
if values.rawEleFltrParam:
rawFilter = revitron.Filter().byStringContainsOneInCsv(
values.rawEleFltrParam, values.rawEleFltrList,
