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()]))