def ui(self):
super(RotationAxisView, self).ui()
set_rot_top_layout = layouts.HorizontalLayout(spacing=5)
self._set_rot_axis_box = combobox.BaseComboBox(parent=self)
set_rot_top_layout.addWidget(self._set_rot_axis_box)
for rotAxis in ROTATION_AXES:
self._set_rot_axis_box.addItem(rotAxis)
set_rot_axis_common_btn = buttons.BaseButton(' <', parent=self)
set_rot_axis_common_btn.setMaximumWidth(45)
set_rot_axis_common_btn.setStyleSheet(
"QPushButton::menu-indicator{image:url(none.jpg);}")
self._set_rot_axis_common_btn_menu = QMenu(self)
# self._set_common_rotation_axis()
set_rot_axis_common_btn.setMenu(self._set_rot_axis_common_btn_menu)
set_rot_top_layout.addWidget(set_rot_axis_common_btn)
set_rot_axis_btn_layout = layouts.HorizontalLayout()
set_rot_axis_btn_layout.setAlignment(Qt.AlignCenter)
self._set_rot_axis_btn = buttons.BaseButton('Apply', parent=self)
self._set_rot_axis_btn.setIcon(resources.icon('ok'))
self._affect_children_cbx = checkbox.BaseCheckBox('Affect Children',
parent=self)
self._set_rot_axis_btn.setMaximumWidth(100)
set_rot_axis_btn_layout.addWidget(self._set_rot_axis_btn)
set_rot_axis_btn_layout.addWidget(self._affect_children_cbx)
self.main_layout.addLayout(set_rot_top_layout)
self.main_layout.addLayout(set_rot_axis_btn_layout)
def __init__(self, search_line=None, parent=None):
super(SearchFindWidget, self).__init__(parent=parent)
self.setObjectName('SearchFindWidget')
self.text = ''
self._placeholder_text = ''
main_layout = layouts.HorizontalLayout(spacing=2, margins=(2, 2, 2, 2))
self.setLayout(main_layout)
self._search_line = search_line or QLineEdit(self)
self._search_menu = QMenu()
self._search_menu.addAction('Test')
icon_size = self.style().pixelMetric(QStyle.PM_SmallIconSize)
delete_icon = resources.icon('delete')
search_icon = QIcon(resources.icon('search'))
self._clear_btn = buttons.IconButton(delete_icon,
icon_padding=2,
parent=self)
self._clear_btn.setIconSize(QSize(icon_size, icon_size))
self._clear_btn.setFixedSize(QSize(icon_size, icon_size))
self._clear_btn.hide()
self._search_btn = buttons.IconButton(search_icon,
icon_padding=2,
parent=self)
self._search_btn.setIconSize(QSize(icon_size, icon_size))
self._search_btn.setFixedSize(QSize(icon_size, icon_size))
# self._search_btn.setStyleSheet('border: none;')
# self._search_btn.setPopupMode(QToolButton.InstantPopup)
self._search_btn.setEnabled(True)
self._search_line.setStyleSheet("""
QLineEdit { padding-left: %spx; padding-right: %spx; border-radius:10px; border:2px; border-color:red; }
""" % (self._search_button_padded_width(),
self._clear_button_padded_width()))
self._search_line.setMinimumSize(
max(
self._search_line.minimumSizeHint().width(),
self._clear_button_padded_width() +
self._search_button_padded_width()),
max(
self._search_line.minimumSizeHint().height(),
max(self._clear_button_padded_width(),
self._search_button_padded_width())))
main_layout.addWidget(self._search_line)
self._search_line.setFocus()
self._search_line.textChanged.connect(self.textChanged)
self._search_line.textChanged.connect(self.set_text)
# self._search_line.editingFinished.connect(self.editingFinished)
# self._search_line.returnPressed.connect(self.returnPressed)
self._clear_btn.clicked.connect(self.clear)
self._search_btn.clicked.connect(self._popup_menu)
def __init__(self, name, parent, dataType, direction, **kwargs):
QGraphicsWidget.__init__(self)
PinBase.__init__(self, name, parent, dataType, direction, **kwargs)
self.setParentItem(parent)
self.setCursor(QtCore.Qt.CrossCursor)
## context menu for pin
self.menu = QMenu()
## Disconnect all connections
self.actionDisconnect = self.menu.addAction('disconnect all')
self.actionDisconnect.triggered.connect(self.disconnectAll)
## Copy UUID to buffer
self.actionCopyUid = self.menu.addAction('copy uid')
self.actionCopyUid.triggered.connect(self.saveUidToClipboard)
## Call exec pin
self.actionCall = self.menu.addAction('execute')
self.actionCall.triggered.connect(self.call)
self.newPos = QtCore.QPointF()
self.setFlag(QGraphicsWidget.ItemSendsGeometryChanges)
self.setCacheMode(self.DeviceCoordinateCache)
self.setAcceptHoverEvents(True)
self.setZValue(2)
self.width = 8 + 1
self.height = 8 + 1
self.hovered = False
self.startPos = None
self.endPos = None
self._container = None
self._execPen = QtGui.QPen(Colors.Exec, 0.5, QtCore.Qt.SolidLine)
self.setGeometry(0, 0, self.width, self.height)
self._dirty_pen = QtGui.QPen(Colors.DirtyPen, 0.5, QtCore.Qt.DashLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
self.pinImage = QtGui.QImage(':/icons/resources/array.png')
def _create_context_menu(self):
self._context_menu = QMenu()
move_up_icon = resources.icon('sort_up')
move_down_icon = resources.icon('sort_down')
rename_icon = resources.icon('rename')
remove_icon = resources.icon('delete')
copy_icon = resources.icon('copy')
move_up_action = QAction(move_up_icon, 'Move Up', self._context_menu)
self._context_menu.addAction(move_up_action)
move_down_action = QAction(move_down_icon, 'Move Down',
self._context_menu)
self._context_menu.addAction(move_down_action)
self._context_menu.addSeparator()
copy_action = QAction(copy_icon, 'Copy', self._context_menu)
self._context_menu.addAction(copy_action)
rename_action = QAction(rename_icon, 'Rename', self._context_menu)
self._context_menu.addAction(rename_action)
remove_action = QAction(remove_icon, 'Remove', self._context_menu)
self._context_menu.addAction(remove_action)
move_up_action.triggered.connect(self.move_up)
move_down_action.triggered.connect(self.move_down)
rename_action.triggered.connect(self.rename)
remove_action.triggered.connect(self.remove)
def create(self, delete_if_exists=True):
"""
Creates a new shelf
"""
if delete_if_exists:
if gui.shelf_exists(shelf_name=self._name):
gui.delete_shelf(shelf_name=self._name)
else:
assert not gui.shelf_exists(self._name), 'Shelf with name {} already exists!'.format(self._name)
self._name = gui.create_shelf(name=self._name)
# ========================================================================================================
self._category_btn = QPushButton('')
if self._category_icon:
self._category_btn.setIcon(self._category_icon)
self._category_btn.setIconSize(QSize(18, 18))
self._category_menu = QMenu(self._category_btn)
self._category_btn.setStyleSheet(
'QPushButton::menu-indicator {image: url(myindicator.png);'
'subcontrol-position: right center;subcontrol-origin: padding;left: -2px;}')
self._category_btn.setMenu(self._category_menu)
self._category_lbl = QLabel('MAIN')
self._category_lbl.setAlignment(Qt.AlignCenter)
font = self._category_lbl.font()
font.setPointSize(6)
self._category_lbl.setFont(font)
menu_ptr = maya.OpenMayaUI.MQtUtil.findControl(self._name)
menu_widget = qtutils.wrapinstance(menu_ptr, QWidget)
menu_widget.layout().addWidget(self._category_btn)
menu_widget.layout().addWidget(self._category_lbl)
self.add_separator()
def __init__(self, owningNode, raw_pin):
"""UI wrapper for :class:`PyFlow.Core.PinBase`
:param owningNode: Owning node
:type owningNode: :class:`PyFlow.UI.Canvas.NodeBase`
:param raw_pin: PinBase reference
:type raw_pin: :class:`PyFlow.Core.PinBase`
"""
super(UIPinBase, self).__init__()
self.setGraphicsItem(self)
self.setFlag(QGraphicsWidget.ItemSendsGeometryChanges)
self.setCacheMode(self.DeviceCoordinateCache)
self.setAcceptHoverEvents(True)
self.setZValue(1)
self.setParentItem(owningNode)
self.UiNode = weakref.ref(owningNode)
self._rawPin = raw_pin
if self._rawPin is not None:
self._rawPin.serializationHook.connect(self.serializationHook)
self._rawPin.containerTypeChanged.connect(
self.onContainerTypeChanged)
self._displayName = self._rawPin.name
self._rawPin.setWrapper(self)
self._rawPin.killed.connect(self.kill)
self._rawPin.nameChanged.connect(self.setDisplayName)
# Context menu for pin
self.menu = QMenu()
self.menu.addAction("Rename").triggered.connect(self.onRename)
self.menu.addAction("Remove").triggered.connect(self._rawPin.kill)
self.actionDisconnect = self.menu.addAction('Disconnect all')
self.actionDisconnect.triggered.connect(self._rawPin.disconnectAll)
self.actionResetValue = self.menu.addAction("Reset value")
self.actionResetValue.triggered.connect(self.resetToDefault)
if self._rawPin._structure == PinStructure.Multi:
self.menu.addAction("changeStructure").triggered.connect(
self.selectStructure)
# GUI
self._font = QtGui.QFont("Consolas")
self._font.setPointSize(6)
self.pinSize = 6
self.hovered = False
self.bLabelHidden = False
if self._rawPin is not None:
self._pinColor = QtGui.QColor(*self._rawPin.color())
self._labelColor = QtCore.Qt.white
self._execPen = QtGui.QPen(Colors.White, 0.5, QtCore.Qt.SolidLine)
self._dirty_pen = QtGui.QPen(Colors.DirtyPen, 0.5, QtCore.Qt.DashLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
self.uiConnectionList = []
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
self.pinCircleDrawOffset = QtCore.QPointF()
# TODO: This is check is for PinGroup. Improve it
if self._rawPin is not None:
self.setToolTip(self._rawPin.description)
def _on_show_menu(self):
"""
Internal callback that shows field menu using the actions from the data
"""
menu = QMenu(self)
actions = self.data().get('actions', list())
for action in actions:
name = action.get('name', 'No name found')
enabled = action.get('enabled', True)
callback = action.get('callback')
fn = partial(self._action_callback, callback)
action = menu.addAction(name)
action.setEnabled(enabled)
action.triggered.connect(fn)
point = QCursor.pos()
point.setX(point.x() + 3)
point.setY(point.y() + 3)
self._action_result = None
menu.exec_(point)
if self._action_result is not None:
self.set_value(self._action_result)
def __init__(self, name, graph):
super(implicitPinCall, self).__init__(name, graph)
self.inExec = self.addInputPin('inp', DataTypes.Exec, self.compute, hideLabel=True)
self.uidInp = self.addInputPin('UUID', DataTypes.String)
self.outExec = self.addOutputPin('out', DataTypes.Exec, hideLabel=True)
self.menu = QMenu()
self.actionFindPin = self.menu.addAction('Find pin')
self.actionFindPin.triggered.connect(self.OnFindPin)
def showContextMenu(self, pos):
self.row = self.propertiesTableView.indexAt(pos).row()
self.menu = QMenu(self)
deleteRowAction = QAction('Delete', self)
deleteRowAction.triggered.connect(self.deleteRow)
self.menu.addAction(deleteRowAction)
# add other required actions
self.menu.popup(QCursor.pos())
def __init__(self, name, graph):
super(sequence, self).__init__(name, graph)
self.inExecPin = self.addInputPin('inExec',
DataTypes.Exec,
self.compute,
hideLabel=True)
self.menu = QMenu()
self.action = self.menu.addAction('add pin')
self.action.triggered.connect(self.addOutPin)
def __init__(self, name, graph):
super(pythonNode, self).__init__(name, graph)
self.menu = QMenu()
self.actionEdit = self.menu.addAction('edit')
self.actionEdit.triggered.connect(self.openEditor)
self.actionEdit.setIcon(QtGui.QIcon(':/icons/resources/py.png'))
self.editorUUID = None
self.bKillEditor = True
self.label().icon = QtGui.QImage(':/icons/resources/py.png')
self.currentComputeCode = Node.jsonTemplate()['computeCode']
def __init__(self, parent=None, dataSetCallback=None, defaultValue=None, **kwds):
super(InputWidgetRaw, self).__init__(parent=parent)
self._defaultValue = defaultValue
# function with signature void(object)
# this will set data to pin
self.dataSetCallback = dataSetCallback
self._widget = None
self._menu = QMenu()
self.actionReset = self._menu.addAction("ResetValue")
self.actionReset.triggered.connect(self.onResetValue)
class ExternalCodeList(QListWidget):
directoriesChanged = Signal(object)
def __init__(self, parent=None):
super(ExternalCodeList, self).__init__(parent)
self.setAlternatingRowColors(True)
self.setSelectionMode(self.NoSelection)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self._on_item_menu)
self._create_context_menu()
def get_directories(self):
count = self.count()
found = list()
if not count:
return found
for i in range(count):
item = self.item(i)
if not item:
continue
found.append(str(item.text()))
return found
def refresh(self, directories):
directories = python.force_list(directories)
self.clear()
for diretory_found in directories:
name = diretory_found
if not path_utils.is_dir(diretory_found):
name = 'Directory Not Valid! {}'.format(diretory_found)
item = QListWidgetItem()
item.setText(name)
item.setSizeHint(QSize(20, 25))
self.addItem(item)
def _create_context_menu(self):
self._context_menu = QMenu()
remove_action = self._context_menu.addAction('Remove')
remove_action.setIcon(resources.icon('trash'))
remove_action.triggered.connect(self._on_remove_action)
def _on_item_menu(self, pos):
item = self.itemAt(pos)
if not item:
return
self._context_menu.exec_(self.viewport().mapToGlobal(pos))
def _on_remove_action(self):
index = self.currentIndex()
self.takeItem(index.row())
self.directoriesChanged.emit(self.get_directories())
def handlePopupMenu(self):
"""
Called when user right-clicks on a trace
"""
menu = QMenu()
selected = self.selectedDataNames()
if len(selected) != 0:
menu.addAction(self.actionDeleteTrace)
menu.exec_(QCursor.pos())
def menuHideEvent(self, event):
items = self.getSelectedItems()
if items:
s = ''
if len(items) > 2:
s = ',...'
self.button.setText(','.join(items[:2]) + s)
else:
self.setHintText(self.msg)
if event:
QMenu.hideEvent(self.menu, event)
self.selectionDone.emit(items)
def __init__(self, parent=None, msg='--Select--', triState=False):
super(MultiSelectComboBox, self).__init__(parent)
loadUi(osp.join(uiPath, 'multiSelectComboBox.ui'), self)
self.triState = triState
self.msg = msg
self.menu = QMenu(self)
self.menu.setStyleSheet("QMenu { menu-scrollable: 1; }")
self.button.setMenu(self.menu)
self.menu.hideEvent = self.menuHideEvent
self.setHintText(self.msg)
def _on_show_menu(self):
"""
Internal callback function triggered when item menu should be opened
:return: QAction
"""
menu = QMenu(self)
self.item().context_edit_menu(menu)
point = QCursor.pos()
point.setX(point.x() + 3)
point.setY(point.y() + 3)
return menu.exec_(point)
def _on_show_menu(self):
"""
Internal callback function that is called when menu button is clicked byu the user
:return: QAction
"""
menu = QMenu(self)
self._item_view.context_edit_menu(menu)
point = QCursor.pos()
point.setX(point.x() + 3)
point.setY(point.y() + 3)
return menu.exec_(point)
class implicitPinCall(Node):
def __init__(self, name, graph):
super(implicitPinCall, self).__init__(name, graph)
self.inExec = self.addInputPin('inp', DataTypes.Exec, self.compute, hideLabel=True)
self.uidInp = self.addInputPin('UUID', DataTypes.String)
self.outExec = self.addOutputPin('out', DataTypes.Exec, hideLabel=True)
self.menu = QMenu()
self.actionFindPin = self.menu.addAction('Find pin')
self.actionFindPin.triggered.connect(self.OnFindPin)
def contextMenuEvent(self, event):
self.menu.exec_(event.screenPos())
@staticmethod
def pinTypeHints():
return {'inputs': [DataTypes.String, DataTypes.Exec], 'outputs': [DataTypes.Exec]}
@staticmethod
def category():
return 'FlowControl'
@staticmethod
def keywords():
return []
@staticmethod
def description():
return 'Implicit execution pin call by provided <a href="https://ru.wikipedia.org/wiki/UUID"> uuid</a>.\nUse this when pins are far from each other.'
def OnFindPin(self):
uidStr = self.uidInp.getData()
if len(uidStr) == 0:
return
try:
uid = uuid.UUID(uidStr)
pin = self.graph().pins[uid]
self.graph().centerOn(pin)
pin.highlight()
except Exception as e:
print(e)
pass
def compute(self):
uidStr = self.uidInp.getData()
if len(uidStr) == 0:
return
uid = uuid.UUID(uidStr)
if uid in self.graph().pins:
pin = self.graph().pins[uid]
if not pin.hasConnections():
pin.call()
def contextMenuEvent(self, event):
menu = QMenu(self)
remove_icon = resources.icon(name='delete')
remove_action = QAction(remove_icon, 'Remove', menu)
remove_action.setStatusTip(consts.DELETE_PROJECT_TOOLTIP)
remove_action.setToolTip(consts.DELETE_PROJECT_TOOLTIP)
remove_action.triggered.connect(self._on_remove_project)
folder_icon = resources.icon(name='open_folder', extension='png')
folder_action = QAction(folder_icon, 'Open in Browser', menu)
folder_action.setStatusTip(consts.OPEN_PROJECT_IN_EXPLORER_TOOLTIP)
folder_action.setToolTip(consts.OPEN_PROJECT_IN_EXPLORER_TOOLTIP)
folder_action.triggered.connect(self._on_open_in_browser)
image_icon = resources.icon(name='picture', extension='png')
set_image_action = QAction(image_icon, 'Set Project Image', menu)
set_image_action.setToolTip(consts.SET_PROJECT_IMAGE_TOOLTIP)
set_image_action.setStatusTip(consts.SET_PROJECT_IMAGE_TOOLTIP)
set_image_action.triggered.connect(self._on_set_project_image)
for action in [
remove_action, None, folder_action, None, set_image_action
]:
if action is None:
menu.addSeparator()
else:
menu.addAction(action)
menu.exec_(self.mapToGlobal(event.pos()))
def handlePopupMenu(self):
"""
Called when user right-clicks on the sources tree
"""
menu = QMenu()
menu.addAction(self.actionAdd)
selected = self.main.treeView.selectedItems()
if len(selected) != 0:
if "config" in selected[0].source.__dict__:
menu.addAction(self.actionConfig)
menu.addAction(self.actionDelete)
menu.exec_(QCursor.pos())
def contextMenuEvent(self, event):
menu = QMenu(self)
remove_icon = resources.icon(name='delete')
remove_action = QAction(remove_icon, 'Remove', menu)
remove_tooltip = 'Delete selected project'
remove_action.setStatusTip(remove_tooltip)
remove_action.setToolTip(remove_tooltip)
remove_action.triggered.connect(self._on_remove_project)
folder_icon = resources.icon(name='open_folder', extension='png')
folder_action = QAction(folder_icon, 'Open in Browser', menu)
open_project_in_explorer_tooltip = 'Open project folder in explorer'
folder_action.setStatusTip(open_project_in_explorer_tooltip)
folder_action.setToolTip(open_project_in_explorer_tooltip)
folder_action.triggered.connect(self._on_open_in_browser)
image_icon = resources.icon(name='picture', extension='png')
set_image_action = QAction(image_icon, 'Set Project Image', menu)
set_project_image_tooltip = 'Set the image used by the project'
set_image_action.setToolTip(set_project_image_tooltip)
set_image_action.setStatusTip(set_project_image_tooltip)
set_image_action.triggered.connect(self._on_set_project_image)
for action in [remove_action, None, folder_action, None, set_image_action]:
if action is None:
menu.addSeparator()
else:
menu.addAction(action)
menu.exec_(self.mapToGlobal(event.pos()))
class makeArray(Node):
def __init__(self, name, graph):
super(makeArray, self).__init__(name, graph)
self.out0 = self.addOutputPin('Array', DataTypes.Array)
self.menu = QMenu()
self.action = self.menu.addAction('add input')
self.action.triggered.connect(self.addInPin)
def addInPin(self):
if len(self.inputs) == 0:
p = self.addInputPin(str(len(self.inputs)),
DataTypes.Any,
constraint="1")
else:
p = self.addInputPin(str(len(self.inputs)),
DataTypes.Any,
constraint="1")
p.setType(self.inputs.items()[0][1])
p.setDeletable()
pinAffects(p, self.out0)
def contextMenuEvent(self, event):
self.menu.exec_(event.screenPos())
@staticmethod
def pinTypeHints():
return {'inputs': supportedDataTypesList, 'outputs': [DataTypes.Array]}
@staticmethod
def category():
return 'GenericTypes'
@staticmethod
def keywords():
return []
@staticmethod
def description():
return 'Genertic array'
def postCreate(self, jsonTemplate):
Node.postCreate(self, jsonTemplate)
# restore dynamically created inputs
for inp in jsonTemplate['inputs']:
p = PinWidgetBase.deserialize(self, inp)
pinAffects(p, self.out0)
def compute(self):
self.out0.setData(list([i.getData() for i in self.inputs.values()]))
def __init__(self, source, destination, canvas):
QGraphicsPathItem.__init__(self)
self.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
self.setAcceptHoverEvents(True)
self.setFlag(QGraphicsPathItem.ItemIsSelectable)
self._menu = QMenu()
self.actionDisconnect = self._menu.addAction("Disconnect")
self.actionDisconnect.triggered.connect(self.kill)
self._uid = uuid4()
self.canvasRef = weakref.ref(canvas)
self.source = weakref.ref(source)
self.destination = weakref.ref(destination)
self.drawSource = self.source()
self.drawDestination = self.destination()
# Overrides for getting endpoints positions
# if None - pin centers will be used
self.sourcePositionOverride = None
self.destinationPositionOverride = None
self.mPath = QtGui.QPainterPath()
self.cp1 = QtCore.QPointF(0.0, 0.0)
self.cp2 = QtCore.QPointF(0.0, 0.0)
self.setZValue(NodeDefaults().Z_LAYER - 1)
self.color = self.source().color()
self.selectedColor = self.color.lighter(150)
self.thickness = 1
if source.isExec():
self.thickness = 2
self.pen = QtGui.QPen(self.color, self.thickness, QtCore.Qt.SolidLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
points = self.getEndPoints()
self.updateCurve(points[0], points[1])
self.setPen(self.pen)
self.source().update()
self.destination().update()
self.fade = 0.0
self.source().uiConnectionList.append(self)
self.destination().uiConnectionList.append(self)
self.source().pinConnected(self.destination())
self.destination().pinConnected(self.source())
def __init__(self, name, graph):
super(switchOnString, self).__init__(name, graph)
self.inExecPin = self.addInputPin('inExec',
DataTypes.Exec,
self.compute,
hideLabel=True)
self.defaultPin = None
self.outString = None
self.inString = self.addInputPin('String', DataTypes.String)
self.menu = QMenu()
self.action = self.menu.addAction('add pin')
self.action.triggered.connect(self.addOutPin)
self.actionDebug = self.menu.addAction('debug')
self.actionDebug.triggered.connect(self.OnDebug)
self._map = {}
class sequence(Node):
def __init__(self, name, graph):
super(sequence, self).__init__(name, graph)
self.inExecPin = self.addInputPin('inExec',
DataTypes.Exec,
self.compute,
hideLabel=True)
self.menu = QMenu()
self.action = self.menu.addAction('add pin')
self.action.triggered.connect(self.addOutPin)
def addOutPin(self):
p = self.addOutputPin(str(len(self.outputs)), DataTypes.Exec)
pinAffects(self.inExecPin, p)
def contextMenuEvent(self, event):
self.menu.exec_(event.screenPos())
@staticmethod
def pinTypeHints():
return {'inputs': [DataTypes.Exec], 'outputs': [DataTypes.Exec]}
@staticmethod
def category():
return 'FlowControl'
@staticmethod
def keywords():
return []
@staticmethod
def description():
return 'The Sequence node allows for a single execution pulse to trigger a series of events in order. The node may have any number of outputs, all of which get called as soon as the Sequence node receives an input. They will always get called in order, but without any delay. To a typical user, the outputs will likely appear to have been triggered simultaneously.'
def postCreate(self, jsonTemplate):
Node.postCreate(self, jsonTemplate)
# restore dynamically created outputs
if len(jsonTemplate['outputs']) == 0:
self.addOutPin()
self.addOutPin()
else:
for out in jsonTemplate['outputs']:
PinWidgetBase.deserialize(self, out)
def compute(self):
for out in self.outputs.values():
out.call()
def build(self):
menu_data = self._builder.get()
menu = QMenu()
for menu_entry in menu_data:
self._create_menu_entry(menu, menu_entry)
return menu
def handlePopupMenu(self):
"""
Called when user right-clicks on the sources tree
"""
menu = QMenu()
menu.addAction(self.actionAdd)
selected = self.main.treeView.selectedItems()
if len(selected) != 0:
if 'config' in selected[0].source.__dict__:
menu.addAction(self.actionConfig)
menu.addAction(self.actionDelete)
menu.exec_(QCursor.pos())
def create_copy_text_menu(self):
"""
Creates a menu to cpoy the selected item data to the clipboard
:return: QMenu
"""
menu = QMenu('Copy Text', self)
if self.selectedItems():
for column in range(self.columnCount()):
label = self.label_from_column(column)
action = menu.addAction(label)
action_callback = partial(self.copy_text, column)
action.triggered.connect(action_callback)
else:
action = menu.addAction('No items selected')
action.setEnabled(False)
return menu
def __init__(self, name, graph):
super(scene_inputs, self).__init__(name, graph)
self.menu = QMenu()
self.action = self.menu.addAction('add port')
self.action.triggered.connect(self.addInPin)
self.setPos(self.graph().mapToScene(self.graph().viewport().rect().x(),self.graph().viewport().rect().y()+50) )
self.asGraphSides = True
self.sizes[4] = 0
self.sizes[5] = 0
self.setFlag(QGraphicsItem.ItemIsMovable,False)
self.setFlag(QGraphicsItem.ItemIsFocusable,False)
self.setFlag(QGraphicsItem.ItemIsSelectable,False)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges,False)
#self.setFlag(QGraphicsItem.ItemIgnoresTransformations)
self.label().hide()
self.sender = sender()
class InputWidgetRaw(QWidget, IInputWidget):
"""
This type of widget can be used as a base class for complex ui generated by designer
"""
def __init__(self,
parent=None,
dataSetCallback=None,
defaultValue=None,
**kwds):
super(InputWidgetRaw, self).__init__(parent=parent, **kwds)
self._defaultValue = defaultValue
# fuction with signature void(object)
# this will set data to pin
self.dataSetCallback = dataSetCallback
self._widget = None
self._menu = QMenu()
self.actionReset = self._menu.addAction("ResetValue")
self.actionReset.triggered.connect(self.onResetValue)
def setWidgetValueNoSignals(self, value):
self.blockWidgetSignals(True)
self.setWidgetValue(value)
self.blockWidgetSignals(False)
def setWidget(self, widget):
self._widget = widget
def getWidget(self):
assert (self._widget is not None)
return self._widget
def onResetValue(self):
self.setWidgetValue(self._defaultValue)
def setWidgetValue(self, value):
'''to widget'''
pass
def widgetValueUpdated(self, value):
'''from widget'''
pass
def contextMenuEvent(self, event):
self._menu.exec_(event.globalPos())
class makeM44Array(Node):
def __init__(self, name, graph):
super(makeM44Array, self).__init__(name, graph)
self.out0 = self.addOutputPin('matrices', DataTypes.Array)
self.menu = QMenu()
self.action = self.menu.addAction('add input')
self.action.triggered.connect(self.addInPin)
def addInPin(self):
p = self.addInputPin(str(len(self.inputs)), DataTypes.Matrix44)
pinAffects(p, self.out0)
def contextMenuEvent(self, event):
self.menu.exec_(event.screenPos())
@staticmethod
def pinTypeHints():
return {'inputs': [DataTypes.Matrix44], 'outputs': [DataTypes.Array]}
@staticmethod
def category():
return 'GenericTypes'
@staticmethod
def keywords():
return []
@staticmethod
def description():
return 'Array of matrix44.'
def postCreate(self, jsonTemplate):
Node.postCreate(self, jsonTemplate)
# restore dynamically created inputs
for inp in jsonTemplate['inputs']:
p = PinWidgetBase.deserialize(self, inp)
pinAffects(p, self.out0)
def compute(self):
self.out0.setData(list([i.getData() for i in self.inputs.values()]))
