def mousePressEvent(self, event):
"""
Overrides base QListView mousePressEvent function
:param event: QMouseEvent
"""
item = self.item_at(event.pos())
if not item:
self.clearSelection()
mixinview.ViewerViewWidgetMixin.mousePressEvent(self, event)
if event.isAccepted():
QListView.mousePressEvent(self, event)
if item:
# NOTE: This causes viewer tree widget selectionChanged signal to be emitted multiple times.
# NOTE: This causes that item preview widgets are created twice when selecting an item in the viewer.
# NOTE: For this reason, we block tree widgets signals before selecting the item
with qt_contexts.block_signals(self.tree_widget()):
item.setSelected(True)
self.endDrag()
self._drag_start_pos = event.pos()
is_left_button = self.mouse_press_button() == Qt.LeftButton
is_item_draggable = item and item.drag_enabled()
is_selection_empty = not self.selected_items()
if is_left_button and (is_selection_empty or not is_item_draggable):
self.rubber_band_start_event(event)
def _on_houdini_slider_value_changed(self, value):
in_value = mathlib.map_range_unclamped(
self._input.value(), self._input.minimum(), self._input.maximum(),
self._slider.minimum(), self._slider.maximum())
with qt_contexts.block_signals(self._slider):
self._slider.setValue(int(in_value))
self.valueChanged.emit(value)
def _on_global_tolerance_changed(self, tolerance_value):
"""
Internal callback function that is called when global tolerance value is updated in the model
:param tolerance_value: float, global tolerance value used to check symmetry of the geometry
"""
with qt_contexts.block_signals(self._model):
self._global_tolerance_spn.setValue(tolerance_value)
def _on_use_pivot_as_origin_changed(self, flag):
"""
Internal callback function that is called when use pivot as origin flag changes in the model
:param flag: bool
"""
with qt_contexts.block_signals(self._model):
self._use_pivot_as_origin_cbx.setChecked(flag)
def _on_revert_bias_changed(self, value):
"""
Internal callback function that is called when revert bias value changes in the model
:param value: float, value that sets how much the revert to base geo should be applied to selected vertices
"""
with qt_contexts.block_signals(self._model):
self._revert_bias_slider.set_value(value)
def _on_live_revert_bias_changed(self, flag):
"""
Internal callback function that is called when live revert bias flag changes in the model
:param flag: bool, Whether or not revert bias should be applied while its value changes
"""
with qt_contexts.block_signals(self._model):
self._live_revert_bias_cbx.setChecked(flag)
def _on_script_text_changed(self, text):
"""
Internal callback function that is called when script text changes
:param text: str
"""
with qt_contexts.block_signals(self._model):
self._controller.set_current_text(text)
def _on_joints_display_size_changed(self, value):
live = self._model.joints_display_size_live
with qt_contexts.block_signals(self._joints_display_size_spn):
self._joints_display_size_spn.setValue(value)
if live:
self._controller.joint_display_size()
def _on_operate_positive_to_negative_x_axis_changed(self, flag):
"""
Internal callback function that is called when operate positive ot negate x axis flag changes in the model
:param flag: bool
"""
with qt_contexts.block_signals(self._model):
self._neg_to_pos_cbx.setChecked(flag)
def set_expanded(self, flag):
"""
Expands the options if True, otherwise collapses the options
:param flag: bool
"""
with qt_contexts.block_signals(self._title_widget):
self._title_widget.setChecked(flag)
self._fields_frame.setVisible(flag)
def _on_output_text_changed(self, output_text):
"""
Internal callback function that is called when output text is updated in the model
:param output_text: str
"""
with qt_contexts.block_signals(self._model):
self._output_console.setText(output_text)
self._output_console.move_cursor_to_line_end()
def _on_selection_changed(self, text):
"""
Internal callback function that is called when user selects new script text
:param text: str
"""
with qt_contexts.block_signals(self._model):
self._controller.set_selected_text(text)
self._execute_selected_action.setEnabled(
bool(self._model.selected_text))
def _on_current_text_changed(self, script_text):
"""
Internal callback function that is called when current script text is updated by the model
:param script_text: str
"""
script_widget = self._scripts_tab.currentWidget()
if not script_widget:
return
with qt_contexts.block_signals(self._model):
script_widget.editor.setPlainText(script_text)
def set_items_selected(self, items, value):
"""
Sets the selected state for the given items
:param items: list(LibraryItem)
:param value: bool
"""
with qt_contexts.block_signals(self.tree_widget()):
try:
for item in items:
item.setSelected(value)
except Exception:
LOGGER.error(str(traceback.format_exc()))
def set_value(self, value):
"""
Overrides FileWidget set_value function
Sets the value of the widget
:param value: str
"""
pos = self.widget().cursorPosition()
with qt_contexts.block_signals(self.widget()):
self.widget().setText(value)
self.widget().setCursorPosition(pos)
super(StringFieldWidget, self).set_value(value)
def set_value(self, value):
"""
Overrides FileWidget set_value function
Sets the path of the image in disk
:param value: str
"""
self._value = value
with qt_contexts.block_signals(self):
for button in list(self._buttons.values()):
button.setChecked(False)
if value in self._buttons:
self._buttons[value].setChecked(True)
super(ButtonGroupFieldWidget, self).set_value(value)
def _on_current_tab_changed(self, index):
"""
Internal callback function that is called when current user selects a new script tab
:param index: int
"""
script_widget = self._scripts_tab.widget(index)
if not script_widget:
return
script_path = script_widget.file_path
all_text = self._scripts_tab.get_current_text()
with qt_contexts.block_signals(self._model):
self._controller.set_current_script(script_path)
self._controller.set_current_text(
all_text.strip() if all_text else '')
def set_data(self, data, root='', split=None):
"""
Sets the items to the given items
:param data: list(str)
:param root: str
:param split: str
"""
self._data = data
settings = self.settings()
with qt_contexts.block_signals(self):
self.clear()
if not root:
root = self.find_root(list(data.keys()), self.separator())
self.add_paths(data, root=root, split=split)
self.set_settings(settings)
self.parent().search()
def _on_script_saved(self, script_path):
"""
Internal callback function that is called when a script is saved
:param script_path: str
"""
script_widget = self._scripts_tab.currentWidget()
if not script_widget:
return
with qt_contexts.block_signals(self._model):
script_path = path_utils.clean_path(script_path)
current_file_path = path_utils.clean_path(script_widget.file_path)
if script_path != current_file_path:
script_widget.file_path = script_path
self._scripts_tab.set_current_tab_name(
os.path.basename(script_widget.file_path))
self._controller.set_current_script(script_widget.file_path)
self._controller.set_current_text(
self._scripts_tab.get_current_text())
self._controller.set_selected_text(
self._scripts_tab.get_current_selected_text())
def update_items(self):
"""
Sets the items to the viewer
"""
selected_items = self.selected_items()
with qt_contexts.block_signals(self.tree_widget()):
try:
self.clear_selection()
if self.library():
results = self.library().grouped_results()
item_views = list()
for group in results:
if group != 'None':
group_item = self.create_group_item(group)
item_views.append(group_item)
for item in results[group]:
view_class = self.library_window(
).factory.get_view(item)
if not view_class:
continue
item_view = view_class(
item, library_window=self.library_window())
item_views.append(item_view)
if item_views:
self.tree_widget().set_items(item_views)
if selected_items:
self.select_items(selected_items)
self.scroll_to_selected_item()
else:
self.clear()
else:
self.clear()
finally:
self.itemSelectionChanged.emit()
def _set_directory(self, directory):
with qt_contexts.block_signals(self):
self.set_directory(directory)
def set_data(self, data):
"""
Sets the current state of the field widget using a dictionary
:param data: dict
"""
state = data
with qt_contexts.block_signals(self):
items = state.get('items', None)
if items is not None:
self.set_items(items)
value = state.get('value', None)
default = state.get('default', None)
if default is not None:
self.set_default(default)
elif value is not None:
self.set_default(value)
if value is not None or (value and value != self.value()):
try:
self.set_value(value)
except TypeError:
LOGGER.exception(str(traceback.format_exc()))
enabled = state.get('enabled', None)
if enabled is not None:
self.setEnabled(enabled)
self._label.setEnabled(enabled)
hidden = state.get('hidden', None)
if hidden is not None:
self.setHidden(hidden)
required = state.get('required', None)
if required is not None:
self.set_required(required)
error = state.get('error', None)
if error is not None:
self.set_error(error)
error_visible = data.get('errorVisible')
if error_visible is not None:
self.set_error_visible(error_visible)
tooltip = state.get('toolTip', None)
if tooltip is not None:
self.setToolTip(tooltip)
self.setStatusTip(tooltip)
style = state.get('style', None)
if style is not None:
self.setStyleSheet(style)
title = self.title() or ''
self.set_text(title)
lbl = state.get('label')
if lbl is not None:
text = lbl.get('name', None)
if text is not None:
self.set_text(text)
visible = lbl.get('visible', None)
if visible is not None:
self.label().setVisible(visible)
# Menu items
actions = state.get('actions', None)
if actions is not None:
self._menu_button.setVisible(True)
menu = state.get('menu', None)
if menu is not None:
text = menu.get('name')
if text is not None:
self._menu_button.setText(text)
visible = menu.get('visible', True)
self._menu_button.setVisible(visible)
self._data.update(data)
self.refresh()
def _set_value(self, value):
with qt_contexts.block_signals(self, children=True):
self.setValue(value)
def _set_checked(self, flag):
with qt_contexts.block_signals(self):
self.setChecked(flag)
def _set_value(self, value):
with qt_contexts.block_signals(self):
self.set_value(value)
def _on_slider_value_changed(self, value):
out_value = mathlib.map_range_unclamped(
value, self._slider.minimum(), self._slider.maximum(), self._input.minimum(), self._input.maximum())
with qt_contexts.block_signals(self._input):
self._input.setValue(out_value)
self.valueChanged.emit(out_value)
