def copy_sheet(activedoc, source_sheet, dest_doc):
logger.debug('Copying sheet {} to document {}'.format(
source_sheet.Name, dest_doc.Title))
print('\tCopying/updating Sheet: {}'.format(source_sheet.Name))
with revit.TransactionGroup('Import Sheet', doc=dest_doc):
logger.debug('Creating destination sheet...')
new_sheet = copy_view(activedoc, source_sheet, dest_doc)
if new_sheet:
if not new_sheet.IsPlaceholder:
if OPTION_SET.op_copy_vports:
logger.debug('Copying sheet viewports...')
copy_sheet_viewports(activedoc, source_sheet, dest_doc,
new_sheet)
else:
print('Skipping viewports...')
if OPTION_SET.op_copy_guides:
logger.debug('Copying sheet guide grids...')
copy_sheet_guides(activedoc, source_sheet, dest_doc,
new_sheet)
else:
print('Skipping sheet guides...')
if OPTION_SET.op_copy_revisions:
logger.debug('Copying sheet revisions...')
copy_sheet_revisions(activedoc, source_sheet, dest_doc,
new_sheet)
else:
print('Skipping revisions...')
else:
logger.error('Failed copying sheet: {}'.format(source_sheet.Name))
def allign_X(tagType, starting_pt):
"""Main X allignment routine for elements of given category."""
# all actions under one transaction
with revit.TransactionGroup("Allign tags vertically"):
# make sure target elements are easily selectable
# with EasilySelectableElements(revit.active_view, BIC.OST_Tags):
# ask user to pick a tag and allign them
for picked_element in revit.get_picked_elements_by_category(
revit.query.get_category(tagType),
message="Select a tag to allign"):
# need nested transactions to push revit to update view
# on each allignment
with revit.Transaction("Allign tag \'{}\' by X".format(
picked_element.Id)):
# actual allignment
if picked_element.GetType() == DB.IndependentTag:
cPosition = picked_element.TagHeadPosition
picked_element.TagHeadPosition = DB.XYZ(
starting_pt.X, cPosition.Y, cPosition.Z)
else:
cPosition = picked_element.Location.Point
delta = DB.XYZ(starting_pt.X - cPosition.X, 0, 0)
picked_element.Location.Move(
DB.XYZ(starting_pt.X - cPosition.X, 0, 0))
def remove_all_groups():
"""Remove (and Explode) All Groups"""
def confirm_removal(group_type):
return group_type \
and group_type.Category.Name != 'Attached Detail Groups'
group_types = list(
DB.FilteredElementCollector(revit.doc).OfClass(
framework.get_type(DB.GroupType)).ToElements())
groups = list(
DB.FilteredElementCollector(revit.doc).OfClass(
framework.get_type(DB.Group)).ToElements())
output = script.get_output()
print_header('EXPLODING GROUPS') # ungroup all groups
with revit.TransactionGroup('Remove All Groups', assimilate=True):
with revit.Transaction('Exploding All Groups'):
for grp in groups:
grp.UngroupMembers()
# delete group types
output.print_md('### {}'.format('REMOVING GROUPS'))
remove_action('Remove All Groups',
'Group Type',
group_types,
validity_func=confirm_removal)
def pick_and_renumber(rnopts, starting_index):
"""Main renumbering routine for elements of given category."""
# all actions under one transaction
with revit.TransactionGroup("Renumber {}".format(rnopts.name)):
# make sure target elements are easily selectable
with EasilySelectableElements(revit.active_view, rnopts.bicat):
index = starting_index
# collect existing elements number:id data
existing_elements_data = get_elements_dict(rnopts.bicat)
# list to collect renumbered elements
renumbered_element_ids = []
# ask user to pick elements and renumber them
for picked_element in revit.get_picked_elements_by_category(
rnopts.bicat,
message="Select {} in order".format(rnopts.name.lower())):
# need nested transactions to push revit to update view
# on each renumber task
with revit.Transaction("Renumber {}".format(rnopts.name)):
# actual renumber task
renumber_element(picked_element, index,
existing_elements_data)
# record the renumbered element
renumbered_element_ids.append(picked_element.Id)
index = increment(index)
# unmark all renumbered elements
_unmark_collected(rnopts.name, renumbered_element_ids)
def ask_for_options():
"""Ask for isolation options and isolate elements"""
element_cats = isolate_config.load_configs()
select_options = sorted(x.Name for x in element_cats) + [
"Room Tags",
"Model Groups",
"Painted Elements",
"Model Elements",
]
selected_switch = forms.CommandSwitchWindow.show(
select_options, message="Temporarily isolate elements of type:")
if selected_switch:
curview = revit.active_view
with revit.TransactionGroup("Isolate {}".format(selected_switch)):
with revit.Transaction("Reset temporary hide/isolate"):
# reset temporary hide/isolate before filtering elements
curview.DisableTemporaryViewMode(
DB.TemporaryViewMode.TemporaryHideIsolate)
element_to_isolate = get_isolation_elements(selected_switch)
with revit.Transaction("Isolate {}".format(selected_switch)):
# now that list of elements is ready,
# let's isolate them in the active view
curview.IsolateElementsTemporary(element_to_isolate)
def main():
sheet_order_dict = sheet_duplicate.get_sheet_order_dict()
sheet_list = sheet_duplicate.sheet_selection()
with revit.TransactionGroup('Create Sheet'):
for sheet in sheet_list:
sheet_order_dict, new_sheet = sheet_duplicate.create_new_sheet(
sheet, sheet_order_dict)
sheet_duplicate.duplicate_sheet_contents(sheet, new_sheet)
def door_by_room_renumber(rnopts):
"""Main renumbering routine for elements of given categories."""
# all actions under one transaction
active_view = revit.active_view
with revit.TransactionGroup("Renumber Doors by Room"):
# collect existing elements number:id data
existing_doors_data = get_elements_dict(rnopts.bicat)
renumbered_door_ids = []
# make sure target elements are easily selectable
with EasilySelectableElements(active_view, rnopts.bicat) \
and EasilySelectableElements(active_view, rnopts.by_bicat):
while True:
# pick door
picked_door = \
revit.pick_element_by_category(rnopts.bicat,
message="Select a door")
if not picked_door:
# user cancelled
return _unmark_collected("Doors", renumbered_door_ids)
# grab the associated rooms
from_room, to_room = revit.query.get_door_rooms(picked_door)
# if more than one option for room, ask to pick
if all([from_room, to_room]) or not any([from_room, to_room]):
# pick room
picked_room = \
revit.pick_element_by_category(rnopts.by_bicat,
message="Select a room")
if not picked_room:
# user cancelled
return _unmark_collected("Rooms", renumbered_door_ids)
else:
picked_room = from_room or to_room
# get data on doors associated with picked room
room_doors = revit.query.get_doors(room_id=picked_room.Id)
room_number = get_number(picked_room)
with revit.Transaction("Renumber Door"):
door_count = len(room_doors)
if door_count == 1:
# match door number to room number
renumber_element(picked_door, room_number,
existing_doors_data)
renumbered_door_ids.append(picked_door.Id)
elif door_count > 1:
# match door number to extended room number e.g. 100A
# check numbers of existing room doors and pick the next
room_door_numbers = [get_number(x) for x in room_doors]
new_number = coreutils.extend_counter(room_number)
# attempts = 1
# max_attempts =len([x for x in room_door_numbers if x])
while new_number in room_door_numbers:
new_number = increment(new_number)
renumber_element(picked_door, new_number,
existing_doors_data)
renumbered_door_ids.append(picked_door.Id)
def flip_wall_location():
with revit.TransactionGroup("Flip Wall On CenterLine"):
for el in revit.get_selection():
if isinstance(el, DB.Wall):
param = el.Parameter[DB.BuiltInParameter.WALL_KEY_REF_PARAM]
current_value = param.AsInteger()
with revit.Transaction('Change Wall Location Line'):
param.Set(location_line_values['Core Centerline'][0])
with revit.Transaction('Flip Selected Wall'):
el.Flip()
param.Set(current_value)
def match_orientation(tagType, starting_or):
# all actions under one transaction
with revit.TransactionGroup("Match tag orientation"):
# make sure target elements are easily selectable
# with EasilySelectableElements(revit.active_view, BIC.OST_Tags):
# ask user to pick a tag and allign them
for picked_element in revit.get_picked_elements_by_category(
revit.query.get_category(tagType),
message="Select a tag to match"):
# need nested transactions to push revit to update view
# on each allignment
with revit.Transaction("Setting tag \'{}\' orientation".format(
picked_element.Id)):
picked_element.TagOrientation = starting_or
def paste(self):
fo_data = script.load_data(slot_name=self.__class__.__name__)
source_view = revit.doc.GetElement(fo_data.source_viewid)
source_filter_ids = fo_data.filter_ids
# to view template or to selected view
mode_templates = \
forms.CommandSwitchWindow.show(
['Active View', 'Select View Templates'],
message='Where do you want to paste filters?'
) == 'Select Templates'
if mode_templates:
views = forms.select_viewtemplates()
else:
views = [revit.active_view]
views_controlled_by_template = \
[x for x in views
if FilterOverridesAction.controlled_by_template(x)]
if views_controlled_by_template:
forms.alert(
'You have selected views with template applied.'
' They will be skipped'
)
if not views:
raise PyRevitException('Nothing selected')
# check if there are views controlled by template
with revit.TransactionGroup('Paste Filter Overrides'):
for view in views:
with revit.Transaction('Paste filter'):
# check if filters are controlled by template
if FilterOverridesAction.controlled_by_template(view):
mlogger.warn('Skip view \'{}\''.format(
revit.query.get_name(view)))
continue
view_filters_ids = view.GetFilters()
for filter_id in source_filter_ids:
# remove filter override if exists
if filter_id in view_filters_ids:
view.RemoveFilter(filter_id)
# add new fitler override
filter_overrides = source_view.GetFilterOverrides(
filter_id)
view.SetFilterOverrides(filter_id, filter_overrides)
def allign_X(tagType, starting_pt):
# all actions under one transaction
with revit.TransactionGroup("Allign tags vertically"):
# make sure target elements are easily selectable
# with EasilySelectableElements(revit.active_view, BIC.OST_Tags):
# ask user to pick a tag and allign them
for picked_element in revit.get_picked_elements_by_category(
revit.query.get_category(tagType),
message="Select a tag to allign"):
# need nested transactions to push revit to update view
# on each allignment
with revit.Transaction("Allign tag \'{}\' by X".format(
picked_element.Id)):
# actual allignment
cPosition = picked_element.TagHeadPosition
picked_element.TagHeadPosition = DB.XYZ(
starting_pt.X, cPosition.Y, cPosition.Z)
print("No panels with Type Comment = 'Panel' found.")
# with revit.TransactionGroup('Populate Thermal Bridge Values'):
# win = revit.pick_element("pick a window") # Keep for visual debugging
# PopulateIntersection(win, elements, current_view)
counter = 0
max_value = len(phpp_win)
names = ''
elements = [
e for e in elements if "Default" not in revit.doc.GetElement(e).Name
]
# for el in elements:
# names += revit.doc.GetElement(el).Family.Name + '\n'
print(names)
with ProgressBar(cancellable=True, step=1) as pb:
with revit.TransactionGroup('Populate Thermal Bridge Values'):
for win in phpp_win:
if pb.cancelled:
break
else:
PopulateIntersection(win, elements, current_view)
pb.update_progress(counter, max_value)
counter += 1
print("Successfully processed {} windows panels".format(max_value))
'conjunction with the "Swap Line Styles" tool. The swap tool '\
'updates the line styles inside Filled region but does not '\
'currently shake the filled regions (Revit crashes on large models.)'
output = script.get_output()
selection = revit.get_selection()
def shake_filled_regions(view):
fregions = DB.FilteredElementCollector(revit.doc)\
.OwnedByView(view.Id)\
.OfClass(framework.get_type(DB.FilledRegion))\
.WhereElementIsNotElementType()\
.ToElements()
print('Shaking Filled Regions in: {}'.format(revit.query.get_name(view)))
for i, fr in enumerate(fregions):
with revit.Transaction('Shake Filled Region #{}'.format(i)):
fr.Location.Move(DB.XYZ(0.01, 0, 0))
fr.Location.Move(DB.XYZ(-0.01, 0, 0))
print('Shaking Filled Regions in {} views'.format(len(selection)))
with revit.TransactionGroup('Shake Filled Regions'):
for i, view in enumerate(selection.elements):
shake_filled_regions(view)
output.update_progress(i + 1, len(selection))
print('All Filled Regions where shaken...')
def set_tansform_matrix(selvp, selview):
# making sure the cropbox is active.
cboxactive = selview.CropBoxActive
cboxvisible = selview.CropBoxVisible
cboxannoparam = selview.get_Parameter(
DB.BuiltInParameter.VIEWER_ANNOTATION_CROP_ACTIVE
)
cboxannostate = cboxannoparam.AsInteger()
curviewelements = \
DB.FilteredElementCollector(revit.doc)\
.OwnedByView(selview.Id)\
.WhereElementIsNotElementType()\
.ToElements()
viewspecificelements = []
for el in curviewelements:
if el.ViewSpecific \
and not el.IsHidden(selview) \
and el.CanBeHidden(selview) \
and el.Category is not None:
viewspecificelements.append(el.Id)
basepoints = DB.FilteredElementCollector(revit.doc)\
.OfClass(DB.BasePoint)\
.WhereElementIsNotElementType()\
.ToElements()
excludecategories = ['Survey Point',
'Project Base Point']
for el in basepoints:
if el.Category and el.Category.Name in excludecategories:
viewspecificelements.append(el.Id)
with revit.TransactionGroup('Activate & Read Cropbox Boundary'):
with revit.Transaction('Hiding all 2d elements'):
if viewspecificelements:
try:
selview.HideElements(List[DB.ElementId](viewspecificelements))
except Exception as e:
logger.debug(e)
with revit.Transaction('Activate & Read Cropbox Boundary'):
selview.CropBoxActive = True
selview.CropBoxVisible = False
cboxannoparam.Set(0)
# get view min max points in modelUCS.
modelucsx = []
modelucsy = []
crsm = selview.GetCropRegionShapeManager()
cllist = crsm.GetCropShape()
if len(cllist) == 1:
cl = cllist[0]
for l in cl:
modelucsx.append(l.GetEndPoint(0).X)
modelucsy.append(l.GetEndPoint(0).Y)
cropmin = DB.XYZ(min(modelucsx), min(modelucsy), 0.0)
cropmax = DB.XYZ(max(modelucsx), max(modelucsy), 0.0)
# get vp min max points in sheetUCS
ol = selvp.GetBoxOutline()
vptempmin = ol.MinimumPoint
vpmin = DB.XYZ(vptempmin.X + vpboundaryoffset,
vptempmin.Y + vpboundaryoffset, 0.0)
vptempmax = ol.MaximumPoint
vpmax = DB.XYZ(vptempmax.X - vpboundaryoffset,
vptempmax.Y - vpboundaryoffset, 0.0)
transmatrix.sourcemin = vpmin
transmatrix.sourcemax = vpmax
transmatrix.destmin = cropmin
transmatrix.destmax = cropmax
revtransmatrix.sourcemin = cropmin
revtransmatrix.sourcemax = cropmax
revtransmatrix.destmin = vpmin
revtransmatrix.destmax = vpmax
selview.CropBoxActive = cboxactive
selview.CropBoxVisible = cboxvisible
cboxannoparam.Set(cboxannostate)
if viewspecificelements:
selview.UnhideElements(
List[DB.ElementId](viewspecificelements)
)
add_cmd_name=False)
selected_ids = revit.get_selection().element_ids
if len(selected_ids) == 1:
vport_id = selected_ids[0]
try:
vport = revit.doc.GetElement(vport_id)
except Exception:
DB.TaskDialog.Show('pyrevit',
'Select exactly one viewport.')
if isinstance(vport, DB.Viewport):
view = revit.doc.GetElement(vport.ViewId)
if view is not None and isinstance(view, DB.ViewPlan):
with revit.TransactionGroup('Paste Viewport Location'):
set_tansform_matrix(vport, view)
try:
with open(datafile, 'rb') as fp:
originalviewtype = pickle.load(fp)
if originalviewtype == 'ViewPlan':
savedcen_pt = pickle.load(fp)
savedmdl_pt = pickle.load(fp)
else:
raise OriginalIsViewDrafting
except IOError:
forms.alert('Could not find saved viewport '
'placement.\n'
'Copy a Viewport Placement first.')
except OriginalIsViewDrafting:
forms.alert('Viewport placement info is from a '
'The sheet name change will be printed if logging is set '\
'to Verbose in pyRevit settings.'
logger = script.get_logger()
selection = revit.get_selection()
shift = 1
selected_sheets = forms.select_sheets(title='Select Sheets')
if not selected_sheets:
script.exit()
sorted_sheet_list = sorted(selected_sheets, key=lambda x: x.SheetNumber)
if shift >= 0:
sorted_sheet_list.reverse()
with revit.TransactionGroup('Shift Sheets'):
for sheet in sorted_sheet_list:
with revit.Transaction('Shift Single Sheet'):
try:
cur_sheet_num = sheet.SheetNumber
sheetnum_p = sheet.Parameter[DB.BuiltInParameter.SHEET_NUMBER]
sheetnum_p.Set(
coreutils.increment_str(sheet.SheetNumber, shift))
new_sheet_num = sheet.SheetNumber
logger.info('{} -> {}'.format(cur_sheet_num, new_sheet_num))
except Exception as shift_err:
logger.error(shift_err)
revit.doc.Regenerate()
def paste(self):
vp_data = script.load_data(slot_name=self.__class__.__name__,
this_project=False)
viewports = revit.get_selection().include(DB.Viewport)
align_axis = None
if __shiftclick__: # pylint: disable=undefined-variable
align_axis = forms.CommandSwitchWindow.show(
['X', 'Y', 'XY'], message='Align specific axis?')
# read saved values
alignment = vp_data.alignment
center = vp_data.center
offset_uv = vp_data.offset_uv
if alignment == ALIGNMENT_CROPBOX:
corner_alignment = forms.CommandSwitchWindow.show(
ALIGNMENT_OPTIONS, message='Select Alignment Option')
with revit.TransactionGroup('Paste Viewport Location'):
for viewport in viewports:
view = revit.doc.GetElement(viewport.ViewId)
title_block_pt = \
ViewportPlacementAction.get_title_block_placement(viewport)
crop_region_current = None
cropbox_values_current = None
hidden_elements = None
# set temporary settings: hide elements, set cropbox visibility
# if cropbox is not active, do nothing (use visible elements)
if alignment == ALIGNMENT_BASEPOINT or view.CropBoxActive:
with revit.Transaction('Temporary settings'):
# 'base point' mode - set cropbox to 'zero' temporary
if alignment == ALIGNMENT_BASEPOINT:
crop_region_current = revit.query.get_crop_region(
view)
revit.update.set_crop_region(
view,
ViewportPlacementAction.zero_cropbox(view))
cropbox_values_current = \
ViewportPlacementAction.activate_cropbox(view)
hidden_elements = \
ViewportPlacementAction.hide_all_elements(view)
with revit.Transaction('Apply Viewport Placement'):
new_center = center
# 'crop box' mode - align to vp corner if necessary
if alignment == ALIGNMENT_CROPBOX \
and corner_alignment:
offset_xyz = ViewportPlacementAction.calculate_offset(
view, offset_uv, corner_alignment)
new_center += offset_xyz
# isolate alignment by x- or y-axis if necessary
new_center = ViewportPlacementAction.isolate_axis(
viewport, new_center, align_axis)
# apply new viewport position
viewport.SetBoxCenter(new_center + title_block_pt)
# unset temporary values
if crop_region_current:
with revit.Transaction('Recover crop region form'):
revit.update.set_crop_region(view, crop_region_current)
if cropbox_values_current:
with revit.Transaction('Recover crop region values'):
ViewportPlacementAction.recover_cropbox(
view, cropbox_values_current)
if hidden_elements:
with revit.Transaction('Recover hidden elements'):
ViewportPlacementAction.unhide_elements(
view, hidden_elements)
def _print_combined_sheets_in_order(self):
print_mgr = revit.doc.PrintManager
print_mgr.PrintRange = DB.PrintRange.Select
viewsheet_settings = print_mgr.ViewSheetSetting
sheet_set = DB.ViewSet()
# add non-printable char in front of sheet Numbers
# to push revit to sort them per user
original_sheetnums = []
with revit.TransactionGroup('Print Sheets in Order') as tg:
with revit.Transaction('Fix Sheet Numbers') as t:
for idx, sheet in enumerate(self.sheets_lb.ItemsSource):
sht = sheet.revit_sheet
original_sheetnums.append(sht.SheetNumber)
sht.SheetNumber = NPC * (idx + 1) + sht.SheetNumber
sheet_set.Insert(sht)
# Collect existing sheet sets
cl = DB.FilteredElementCollector(revit.doc)
viewsheetsets = cl.OfClass(framework.get_type(DB.ViewSheetSet))\
.WhereElementIsNotElementType()\
.ToElements()
all_viewsheetsets = {vss.Name: vss for vss in viewsheetsets}
sheetsetname = 'OrderedPrintSet'
with revit.Transaction('Update Ordered Print Set') as t:
# Delete existing matching sheet set
if sheetsetname in all_viewsheetsets:
viewsheet_settings.CurrentViewSheetSet = \
all_viewsheetsets[sheetsetname]
viewsheet_settings.Delete()
try:
viewsheet_settings.CurrentViewSheetSet.Views = sheet_set
except Exception as viewset_err:
sheet_report = ''
for sheet in sheet_set:
sheet_report += '{} {}\n'.format(
sheet.SheetNumber if isinstance(
sheet, DB.ViewSheet) else '---', type(sheet))
logger.critical(
'Error setting sheet set on print mechanism. '
'These items are included in the viewset '
'object:\n{}'.format(sheet_report))
raise viewset_err
viewsheet_settings.SaveAs(sheetsetname)
print_mgr.PrintOrderReverse = self.reverse_print
try:
print_mgr.CombinedFile = True
except Exception as e:
forms.alert(
str(e) + '\nSet printer correctly in Print settings.')
script.exit()
print_mgr.PrintToFile = True
print_mgr.PrintToFileName = op.join(r'C:', 'Ordered Sheet Set.pdf')
print_mgr.Apply()
print_mgr.SubmitPrint()
# now fix the sheet names
with revit.Transaction('Restore Sheet Numbers') as t:
for sheet, sheetnum in zip(self.sheets_lb.ItemsSource,
original_sheetnums):
sht = sheet.revit_sheet
sht.SheetNumber = sheetnum
file_ext='pym',
add_cmd_name=False)
selected_ids = revit.get_selection().element_ids
if len(selected_ids) == 1:
vport_id = selected_ids[0]
try:
vport = revit.doc.GetElement(vport_id)
except Exception:
forms.alert('Select exactly one viewport.')
if isinstance(vport, DB.Viewport):
view = revit.doc.GetElement(vport.ViewId)
if view is not None and isinstance(view, DB.ViewPlan):
with revit.TransactionGroup('Copy Viewport Location'):
set_tansform_matrix(vport, view)
center = vport.GetBoxCenter()
modelpoint = sheet_to_view_transform(center)
center_pt = Point(center.X, center.Y, center.Z)
model_pt = Point(modelpoint.X, modelpoint.Y, modelpoint.Z)
with open(datafile, 'wb') as fp:
originalviewtype = 'ViewPlan'
pickle.dump(originalviewtype, fp)
pickle.dump(center_pt, fp)
pickle.dump(model_pt, fp)
elif view is not None and isinstance(view, DB.ViewDrafting):
center = vport.GetBoxCenter()
center_pt = Point(center.X, center.Y, center.Z)
with open(datafile, 'wb') as fp:
]
# make a iCollection of inplace families
inplace_families_toIsolate = List[ElementId](i.Id for i in inplace_families)
print('Found {} in-place families'.format(len(inplace_families)))
print('\nCATEGORY & FAMILY NAME')
report = []
for inplace_family in inplace_families:
inplace_family_type = revit.doc.GetElement(inplace_family.GetTypeId())
if inplace_family_type:
category_name = inplace_family_type.Category.Name
family_name = inplace_family.Symbol.Family.Name
print('{} category:\"{}\" name:\"{}\"'.format(
output.linkify(inplace_family.Id), category_name, family_name))
# based on isolate function in pyRevit
with revit.TransactionGroup("InPlace Families"):
with revit.Transaction("Reset temporary hide/isolate"):
newview = revit.db.create.create_3d_view(
'InPlace Families') #active_view
# reset temporary hide/isolate before filtering elements
newview.DisableTemporaryViewMode(
DB.TemporaryViewMode.TemporaryHideIsolate)
with revit.Transaction("Isolate"):
# isolate them in the newly created view
newview.IsolateElementsTemporary(inplace_families_toIsolate)
#Make newly created view active
HOST_APP.uidoc.RequestViewChange(newview)
def _print_combined_sheets_in_order(self):
# make sure we can access the print config
print_mgr = self._get_printmanager()
with revit.TransactionGroup('Print Sheets in Order'):
if not print_mgr:
return
with revit.Transaction('Set Printer Settings'):
print_mgr.PrintSetup.CurrentPrintSetting = \
self.selected_print_setting
print_mgr.SelectNewPrintDriver(self.selected_printer)
print_mgr.PrintRange = DB.PrintRange.Select
# add non-printable char in front of sheet Numbers
# to push revit to sort them per user
sheet_set = DB.ViewSet()
original_sheetnums = []
with revit.Transaction('Fix Sheet Numbers'):
for idx, sheet in enumerate(self.sheet_list):
rvtsheet = sheet.revit_sheet
original_sheetnums.append(rvtsheet.SheetNumber)
rvtsheet.SheetNumber = \
NPC * (idx + 1) + rvtsheet.SheetNumber
if sheet.printable:
sheet_set.Insert(rvtsheet)
# Collect existing sheet sets
cl = DB.FilteredElementCollector(revit.doc)
viewsheetsets = cl.OfClass(framework.get_type(DB.ViewSheetSet))\
.WhereElementIsNotElementType()\
.ToElements()
all_viewsheetsets = {vss.Name: vss for vss in viewsheetsets}
sheetsetname = 'OrderedPrintSet'
with revit.Transaction('Remove Previous Print Set'):
# Delete existing matching sheet set
if sheetsetname in all_viewsheetsets:
print_mgr.ViewSheetSetting.CurrentViewSheetSet = \
all_viewsheetsets[sheetsetname]
print_mgr.ViewSheetSetting.Delete()
with revit.Transaction('Update Ordered Print Set'):
try:
viewsheet_settings = print_mgr.ViewSheetSetting
viewsheet_settings.CurrentViewSheetSet.Views = \
sheet_set
viewsheet_settings.SaveAs(sheetsetname)
except Exception as viewset_err:
sheet_report = ''
for sheet in sheet_set:
sheet_report += '{} {}\n'.format(
sheet.SheetNumber if isinstance(
sheet, DB.ViewSheet) else '---', type(sheet))
logger.critical(
'Error setting sheet set on print mechanism. '
'These items are included in the viewset '
'object:\n%s', sheet_report)
raise viewset_err
# set print job configurations
print_mgr.PrintOrderReverse = self.reverse_print
try:
print_mgr.CombinedFile = True
except Exception as e:
forms.alert(
str(e) + '\nSet printer correctly in Print settings.')
script.exit()
print_mgr.PrintToFile = True
print_mgr.PrintToFileName = \
op.join(r'C:\\', 'Ordered Sheet Set.pdf')
print_mgr.Apply()
print_mgr.SubmitPrint()
# now fix the sheet names
with revit.Transaction('Restore Sheet Numbers'):
for sheet, sheetnum in zip(self.sheet_list,
original_sheetnums):
rvtsheet = sheet.revit_sheet
rvtsheet.SheetNumber = sheetnum
def main():
with revit.TransactionGroup("Platemation"):
pm_engine.add_baseplate_param()
pm_engine.create_baseplate_schedule()
pm_engine.set_value()
else:
sys.exit()
# Collect all elements that are somehow linked to the
# viewport types to be purged
purge_dict = {}
for purge_vp_type in purge_vp_types:
logger.info('Finding all viewports of type: {}'.format(purge_vp_type.name))
logger.debug('Purging: {}'.format(repr(purge_vp_type)))
linked_elements = purge_vp_type.find_linked_elements()
logger.debug('{} elements are linked to this viewport type.'.format(
len(linked_elements)))
purge_dict[purge_vp_type.name] = linked_elements
# Perform cleanup
with revit.TransactionGroup('Fixed Unpurgable Viewport Types'):
# Correct all existing viewports that use the viewport types to be purged
# Collect viewports and find the ones that use the purging viewport types
all_viewports = \
DB.FilteredElementCollector(revit.doc)\
.OfClass(framework.get_type(DB.Viewport))\
.ToElements()
purge_vp_ids = [x.get_rvt_obj().Id for x in purge_vp_types]
with revit.Transaction('Correct Viewport Types'):
for vp in all_viewports:
if vp.GetTypeId() in purge_vp_ids:
try:
# change their type to the destination type
logger.debug('Changing viewport type for '
'viewport with id: {}'.format(vp.Id))
