diff --git a/NodeGraphQt/__init__.py b/NodeGraphQt/__init__.py index a2b15fde..85a75927 100644 --- a/NodeGraphQt/__init__.py +++ b/NodeGraphQt/__init__.py @@ -98,6 +98,7 @@ def __init__(self): from .widgets.node_tree import NodeTreeWidget from .widgets.properties_bin import PropertiesBinWidget from .widgets.node_publish_widget import NodePublishWidget +from .widgets.node_widgets import NodeBaseWidget __version__ = VERSION @@ -105,6 +106,7 @@ def __init__(self): 'BackdropNode', 'BaseNode', 'LICENSE', + 'NodeBaseWidget', 'NodeGraph', 'NodeGraphCommand', 'NodeGraphMenu', diff --git a/NodeGraphQt/base/node.py b/NodeGraphQt/base/node.py index eb631c93..8650ca28 100644 --- a/NodeGraphQt/base/node.py +++ b/NodeGraphQt/base/node.py @@ -4,6 +4,7 @@ from .port import Port from .utils import update_node_down_stream from ..constants import (NODE_PROP, + NODE_PROP_QLABEL, NODE_PROP_QLINEEDIT, NODE_PROP_QTEXTEDIT, NODE_PROP_QCOMBO, @@ -15,7 +16,7 @@ NODE_LAYOUT_VERTICAL, NODE_LAYOUT_HORIZONTAL, NODE_LAYOUT_DIRECTION) -from ..errors import PortRegistrationError,NodeWidgetError +from ..errors import PortRegistrationError, NodeWidgetError from ..qgraphics.node_backdrop import BackdropNodeItem from ..qgraphics.node_base import NodeItem, NodeItemVertical from ..widgets.node_widgets import (NodeBaseWidget, @@ -628,28 +629,31 @@ def get_widget(self, name): """ return self.view.widgets.get(name) - def add_custom_widget(self, name, widget=None, widget_type=NODE_PROP, - tab=None): + def add_custom_widget(self, widget, widget_type=NODE_PROP_QLABEL, tab=None): """ Add a custom node widget into the node. + see example :ref:`Embedding Custom Widgets`. + Note: The ``value_changed`` signal from the added node widget is wired up to the :meth:`NodeObject.set_property` function. Args: - name (str): name for the custom property. - widget (NodeBaseWidget): custom node widget. + widget_cls (NodeBaseWidget): node widget class object. widget_type: widget flag to display in the - :class:`NodeGraphQt.PropertiesBinWidget`. + :class:`NodeGraphQt.PropertiesBinWidget` (default: QLabel). tab (str): name of the widget tab to display in. """ if not isinstance(widget, NodeBaseWidget): raise NodeWidgetError( '\'widget\' must be an instance of a NodeBaseWidget') - self.create_property( - name, widget.value, widget_type=widget_type, tab=tab) + self.create_property(widget.get_name(), + widget.get_value(), + widget_type=widget_type, + tab=tab) widget.value_changed.connect(lambda k, v: self.set_property(k, v)) + widget._node = self self.view.add_widget(widget) def add_combo_menu(self, name, label='', items=None, tab=None): diff --git a/NodeGraphQt/pkg_info.py b/NodeGraphQt/pkg_info.py index b2ef4608..bf8d8663 100644 --- a/NodeGraphQt/pkg_info.py +++ b/NodeGraphQt/pkg_info.py @@ -1,6 +1,6 @@ #!/usr/bin/python # -*- coding: utf-8 -*- -__version__ = '0.1.1' +__version__ = '0.1.2' __status__ = 'Work in Progress' __license__ = 'MIT' diff --git a/NodeGraphQt/qgraphics/node_base.py b/NodeGraphQt/qgraphics/node_base.py index 95266596..b9d5892f 100644 --- a/NodeGraphQt/qgraphics/node_base.py +++ b/NodeGraphQt/qgraphics/node_base.py @@ -608,7 +608,7 @@ def height(self, height=0.0): def disabled(self, state=False): AbstractNodeItem.disabled.fset(self, state) for n, w in self._widgets.items(): - w.widget.setDisabled(state) + w.get_custom_widget().setDisabled(state) self._tooltip_disable(state) self._x_item.setVisible(state) @@ -800,7 +800,7 @@ def widgets(self): return self._widgets.copy() def add_widget(self, widget): - self._widgets[widget.name] = widget + self._widgets[widget.get_name()] = widget def get_widget(self, name): widget = self._widgets.get(name) diff --git a/NodeGraphQt/widgets/node_widgets.py b/NodeGraphQt/widgets/node_widgets.py index 14f22524..1f0c4dd0 100644 --- a/NodeGraphQt/widgets/node_widgets.py +++ b/NodeGraphQt/widgets/node_widgets.py @@ -5,161 +5,210 @@ from .. import QtCore, QtWidgets from ..constants import Z_VAL_NODE_WIDGET +from ..errors import NodeWidgetError class _NodeGroupBox(QtWidgets.QGroupBox): def __init__(self, label, parent=None): super(_NodeGroupBox, self).__init__(parent) + layout = QtWidgets.QVBoxLayout(self) + layout.setSpacing(1) + self.setTitle(label) + + def setTitle(self, text): margin = (0, 0, 0, 0) padding_top = '14px' - if label == '': + if text == '': margin = (0, 2, 0, 0) padding_top = '2px' style = STYLE_QGROUPBOX.replace('$PADDING_TOP', padding_top) - self.setTitle(label) + self.layout().setContentsMargins(*margin) self.setStyleSheet(style) - - self._layout = QtWidgets.QVBoxLayout(self) - self._layout.setContentsMargins(*margin) - self._layout.setSpacing(1) + super(_NodeGroupBox, self).setTitle(text) def add_node_widget(self, widget): - self._layout.addWidget(widget) + self.layout().addWidget(widget) + + def get_node_widget(self): + return self.layout().itemAt(0).widget() class NodeBaseWidget(QtWidgets.QGraphicsProxyWidget): """ - This is the main wrapper class that allows a widget to be - added in a :class:`NodeGraphQt.BaseNode`. + This is the main wrapper class that allows a ``QtWidgets.QWidget`` to be + added in a :class:`NodeGraphQt.BaseNode` object. + + See :ref:`Embedding Custom Widgets` example to adding your own widget + into a node. - If you want to add your own custom widget into a node you'll need - to subclass ``NodeBaseWidget`` for an example have a look at the source - code for the ``NodeComboBox`` - `here `_. + Args: + parent (NodeGraphQt.BaseNode.view): parent node view. + name (str): property name for the parent node. + label (str): label text above the embedded widget. """ value_changed = QtCore.Signal(str, object) """ Signal triggered when the ``value`` attribute has changed. + + (This is connected to the :meth: `BaseNode.set_property` function when the + widget is added into the node.) :parameters: str, object :emits: property name, propety value """ - def __init__(self, parent=None, name='widget', label=''): + def __init__(self, parent=None, name=None, label=''): super(NodeBaseWidget, self).__init__(parent) self.setZValue(Z_VAL_NODE_WIDGET) self._name = name self._label = label - - def _value_changed(self): - self.value_changed.emit(self.name, self.value) + self._node = None def setToolTip(self, tooltip): tooltip = tooltip.replace('\n', '
') tooltip = '{}
{}'.format(self.name, tooltip) super(NodeBaseWidget, self).setToolTip(tooltip) - @property - def widget(self): + def on_value_changed(self, *args, **kwargs): """ - Returns the embedded QWidget used in the node. + This is the slot function that + Emits the widgets current :meth:`NodeBaseWidget.value` with the + :attr:`NodeBaseWidget.value_changed` signal. + + Args: + args: not used. + kwargs: not used. - Note: - To add your own custom widget in a :class:`NodeGraphQt.BaseNode` - you must re-implement this function. + Emits: + str, object: , + """ + self.value_changed.emit(self.get_name(), self.get_value()) + + @property + def type_(self): + """ + Returns the node widget type. Returns: - QtWidgets.QWidget: nested QWidget + str: widget type. """ - raise NotImplementedError + return str(self.__class__.__name__) @property - def value(self): + def node(self): """ - Returns the widgets current value. + Returns the node object this widget is embedded in. + (This will return ``None`` if the widget has not been added to + the node yet.) - Note: - You must re-implement this function to get the value from your - custom widget. + Returns: + NodeGraphQt.BaseNode: parent node. + """ + return self._node + + def get_icon(self, name): + """ + Returns the default icon from the Qt framework. Returns: - str: current property value. + str: icon name. """ - raise NotImplementedError + return self.style().standardIcon(QtWidgets.QStyle.StandardPixmap(name)) - @value.setter - def value(self, text): + def get_name(self): """ - Sets the widgets current value. + Returns the parent node property name. + + Returns: + str: property name. + """ + return self._name - Note: - You must re-implement this function to update your custom widget. + def set_name(self, name): + """ + Set the property name for the parent node. + + Important: + The property name must be set before the widget is added to + the node. Args: - text (str): new text value. + name (str): property name. """ - raise NotImplementedError + if not name: + return + if self.node: + raise NodeWidgetError( + 'Can\'t set property name widget already added to a Node' + ) + self._name = name - @property - def label(self): + def get_value(self): """ - Returns the label text displayed above the embedded node widget. + Returns the widgets current value. + + You must re-implement this property to if you're using a custom widget. Returns: - str: label text. + str: current property value. """ - return self._label + raise NotImplementedError - @label.setter - def label(self, label): + def set_value(self, text): """ - Sets the label text above the embedded widget. + Sets the widgets current value. + + You must re-implement this property to if you're using a custom widget. Args: - label (str): new label ext. + text (str): new text value. """ - self._label = label + raise NotImplementedError - @property - def type_(self): + def get_custom_widget(self): """ - Returns the node widget type. + Returns the embedded QWidget used in the node. Returns: - str: widget type. + QtWidgets.QWidget: nested QWidget """ - return str(self.__class__.__name__) + widget = self.widget() + return widget.get_node_widget() - @property - def node(self): + def set_custom_widget(self, widget): """ - Returns the parent base node qgraphics item. + Set the custom QWidget used in the node. - Returns: - NodeItem: parent node. + Args: + widget (QtWidgets.QWidget): custom. """ - return self.parentItem() + if self.widget(): + raise NodeWidgetError('Custom node widget already set.') + group = _NodeGroupBox(self._label) + group.add_node_widget(widget) + self.setWidget(group) - @property - def name(self): + def get_label(self): """ - Returns the parent node property name. + Returns the label text displayed above the embedded node widget. Returns: - str: property name. + str: label text. """ - return self._name + return self._label - def get_icon(self, name): + def set_label(self, label=''): """ - Returns the Qt default icon. + Sets the label text above the embedded widget. - Returns: - str: icon name. + Args: + label (str): new label ext. """ - return self.style().standardIcon(QtWidgets.QStyle.StandardPixmap(name)) + if self.widget(): + self.widget().setTitle(label) + self._label = label class NodeComboBox(NodeBaseWidget): @@ -176,64 +225,63 @@ class NodeComboBox(NodeBaseWidget): def __init__(self, parent=None, name='', label='', items=None): super(NodeComboBox, self).__init__(parent, name, label) self.setZValue(Z_VAL_NODE_WIDGET + 1) - self._combo = QtWidgets.QComboBox() - self._combo.setStyleSheet(STYLE_QCOMBOBOX) - self._combo.setMinimumHeight(24) - self._combo.currentIndexChanged.connect(self._value_changed) - list_view = QtWidgets.QListView(self._combo) + combo = QtWidgets.QComboBox() + combo.setStyleSheet(STYLE_QCOMBOBOX) + combo.setMinimumHeight(24) + combo.currentIndexChanged.connect(self.on_value_changed) + list_view = QtWidgets.QListView(combo) list_view.setStyleSheet(STYLE_QLISTVIEW) - self._combo.setView(list_view) - self._combo.clearFocus() + combo.setView(list_view) + combo.clearFocus() + self.set_custom_widget(combo) self.add_items(items) - group = _NodeGroupBox(label) - group.add_node_widget(self._combo) - self.setWidget(group) @property def type_(self): return 'ComboNodeWidget' - @property - def widget(self): - return self._combo - - @property - def value(self): + def get_value(self): """ Returns the widget current text. Returns: str: current text. """ - return str(self._combo.currentText()) + combo_widget = self.get_custom_widget() + return str(combo_widget.currentText()) - @value.setter - def value(self, text=''): + def set_value(self, text=''): + combo_widget = self.get_custom_widget() if type(text) is list: - self._combo.clear() - self._combo.addItems(text) + combo_widget.clear() + combo_widget.addItems(text) return - if text != self.value: - index = self._combo.findText(text, QtCore.Qt.MatchExactly) - self._combo.setCurrentIndex(index) + if text != self.get_value(): + index = combo_widget.findText(text, QtCore.Qt.MatchExactly) + combo_widget.setCurrentIndex(index) def add_item(self, item): - self._combo.addItem(item) + combo_widget = self.get_custom_widget() + combo_widget.addItem(item) def add_items(self, items=None): if items: - self._combo.addItems(items) + combo_widget = self.get_custom_widget() + combo_widget.addItems(items) def all_items(self): - return [self._combo.itemText(i) for i in range(self._combo.count())] + combo_widget = self.get_custom_widget() + return [combo_widget.itemText(i) for i in range(combo_widget.count())] def sort_items(self): items = sorted(self.all_items()) - self._combo.clear() - self._combo.addItems(items) + combo_widget = self.get_custom_widget() + combo_widget.clear() + combo_widget.addItems(items) def clear(self): - self._combo.clear() + combo_widget = self.get_custom_widget() + combo_widget.clear() class NodeLineEdit(NodeBaseWidget): @@ -249,40 +297,32 @@ class NodeLineEdit(NodeBaseWidget): def __init__(self, parent=None, name='', label='', text=''): super(NodeLineEdit, self).__init__(parent, name, label) - self._ledit = QtWidgets.QLineEdit() - self._ledit.setStyleSheet(STYLE_QLINEEDIT) - self._ledit.setAlignment(QtCore.Qt.AlignCenter) - self._ledit.editingFinished.connect(self._value_changed) - self._ledit.clearFocus() - group = _NodeGroupBox(label) - group.add_node_widget(self._ledit) - group.setMaximumWidth(120) - self.setWidget(group) - self.text = text + ledit = QtWidgets.QLineEdit() + ledit.setText(text) + ledit.setStyleSheet(STYLE_QLINEEDIT) + ledit.setAlignment(QtCore.Qt.AlignCenter) + ledit.editingFinished.connect(self.on_value_changed) + ledit.clearFocus() + self.set_custom_widget(ledit) + self.widget().setMaximumWidth(140) @property def type_(self): return 'LineEditNodeWidget' - @property - def widget(self): - return self._ledit - - @property - def value(self): + def get_value(self): """ Returns the widgets current text. Returns: str: current text. """ - return str(self._ledit.text()) + return str(self.get_custom_widget().text()) - @value.setter - def value(self, text=''): - if text != self.value: - self._ledit.setText(text) - self._value_changed() + def set_value(self, text=''): + if text != self.get_value(): + self.get_custom_widget().setText(text) + self.on_value_changed() class NodeFloatEdit(NodeBaseWidget): @@ -298,40 +338,32 @@ class NodeFloatEdit(NodeBaseWidget): def __init__(self, parent=None, name='', label='', value=0.0): super(NodeFloatEdit, self).__init__(parent, name, label) - self._ledit = _ValueEdit() - self._ledit.setStyleSheet(STYLE_QLINEEDIT) - self._ledit.setAlignment(QtCore.Qt.AlignCenter) - self._ledit.valueChanged.connect(self._value_changed) - self._ledit.clearFocus() - self._ledit.setValue(value) - group = _NodeGroupBox(label) - group.add_node_widget(self._ledit) - group.setMaximumWidth(120) - self.setWidget(group) + val_ledit = _ValueEdit() + val_ledit.setStyleSheet(STYLE_QLINEEDIT) + val_ledit.setAlignment(QtCore.Qt.AlignCenter) + val_ledit.valueChanged.connect(self.on_value_changed) + val_ledit.setValue(value) + val_ledit.clearFocus() + self.set_custom_widget(val_ledit) + self.widget().setMaximumWidth(140) @property def type_(self): return 'FloatEditNodeWidget' - @property - def widget(self): - return self._ledit - - @property - def value(self): + def get_value(self): """ Returns the widgets current value. Returns: float: current value. """ - return self._ledit.value() + return self.get_custom_widget().value() - @value.setter def value(self, value): - if value != self.value: - self._ledit.setValue(value) - self._value_changed() + if value != self.get_value(): + self.get_custom_widget().setValue(value) + self.on_value_changed() class NodeIntEdit(NodeFloatEdit): @@ -347,8 +379,12 @@ class NodeIntEdit(NodeFloatEdit): def __init__(self, parent=None, name='', label='', value=0): super(NodeIntEdit, self).__init__(parent, name, label) - self._ledit.set_data_type(int) - self._ledit.setValue(value) + self.get_custom_widget().set_data_type(int) + self.get_custom_widget().setValue(value) + + @property + def type_(self): + return 'IntEditNodeWidget' class NodeCheckBox(NodeBaseWidget): @@ -364,44 +400,34 @@ class NodeCheckBox(NodeBaseWidget): def __init__(self, parent=None, name='', label='', text='', state=False): super(NodeCheckBox, self).__init__(parent, name, label) - self._cbox = QtWidgets.QCheckBox(text) - self._cbox.setChecked(state) - self._cbox.setMinimumWidth(80) + _cbox = QtWidgets.QCheckBox(text) + _cbox.setChecked(state) + _cbox.setMinimumWidth(80) + _cbox.setStyleSheet(STYLE_QCHECKBOX) - self._cbox.setStyleSheet(STYLE_QCHECKBOX) - - font = self._cbox.font() + font = _cbox.font() font.setPointSize(11) - self._cbox.setFont(font) - self._cbox.stateChanged.connect(self._value_changed) - group = _NodeGroupBox(label) - group.add_node_widget(self._cbox) - self.setWidget(group) - self.text = text - self.state = state + _cbox.setFont(font) + _cbox.stateChanged.connect(self.on_value_changed) + self.set_custom_widget(_cbox) + self.widget().setMaximumWidth(140) @property def type_(self): return 'CheckboxNodeWidget' - @property - def widget(self): - return self._cbox - - @property - def value(self): + def get_value(self): """ Returns the widget checked state. Returns: bool: checked state. """ - return self._cbox.isChecked() + return self.get_custom_widget().isChecked() - @value.setter - def value(self, state=False): - if state != self.value: - self._cbox.setChecked(state) + def set_value(self, state=False): + if state != self.get_value(): + self.get_custom_widget().setChecked(state) class NodeFilePath(NodeLineEdit): @@ -417,30 +443,27 @@ class NodeFilePath(NodeLineEdit): def __init__(self, parent=None, name='', label='', text='', ext='*'): super(NodeLineEdit, self).__init__(parent, name, label) - self._ledit = QtWidgets.QLineEdit() - self._ledit.setStyleSheet(STYLE_QLINEEDIT) - self._ledit.setAlignment(QtCore.Qt.AlignCenter) - self._ledit.editingFinished.connect(self._value_changed) - self._ledit.clearFocus() + _ledit = QtWidgets.QLineEdit() + _ledit.setStyleSheet(STYLE_QLINEEDIT) + _ledit.setAlignment(QtCore.Qt.AlignCenter) + _ledit.editingFinished.connect(self.on_value_changed) + _ledit.clearFocus() _button = QtWidgets.QPushButton() _button.setStyleSheet(STYLE_QPUSHBUTTON) _button.setIcon(self.get_icon(21)) + _button.clicked.connect(self._on_select_file) widget = QtWidgets.QWidget() hbox = QtWidgets.QHBoxLayout() - hbox.addWidget(self._ledit) + hbox.addWidget(_ledit) hbox.addWidget(_button) widget.setLayout(hbox) widget.setStyleSheet(STYLE_QWIDGET) - group = _NodeGroupBox(label) - group.add_node_widget(widget) - self.text = text - - _button.clicked.connect(self._on_select_file) - self.setWidget(group) self._ext = ext + self.set_custom_widget(widget) + self.widget().setMaximumWidth(140) def _on_select_file(self): file_path = FileDialog.getOpenFileName(ext_filter=self._ext) diff --git a/NodeGraphQt/widgets/properties_bin.py b/NodeGraphQt/widgets/properties_bin.py index ee3cce61..541e9060 100644 --- a/NodeGraphQt/widgets/properties_bin.py +++ b/NodeGraphQt/widgets/properties_bin.py @@ -52,7 +52,9 @@ def __init__(self, parent=None): def wheelEvent(self, event): delta = event.delta() * 0.2 - self.verticalScrollBar().setValue(self.verticalScrollBar().value() - delta) + self.verticalScrollBar().setValue( + self.verticalScrollBar().value() - delta + ) class PropertiesBinWidget(QtWidgets.QWidget): @@ -135,8 +137,8 @@ def __on_graph_property_changed(self, node, prop_name, prop_value): Args: node (NodeGraphQt.NodeObject): - prop_name (str): - prop_value (object): + prop_name (str): node property name. + prop_value (object): node property value. """ properties_widget = self.prop_widget(node) if not properties_widget: @@ -154,9 +156,9 @@ def __on_property_widget_changed(self, node_id, prop_name, prop_value): Slot function triggered when a property widget value has changed. Args: - node_id (str): - prop_name (str): - prop_value (object): + node_id (str): node id. + prop_name (str): node property name. + prop_value (object): node property value. """ if not self._block_signal: self.property_changed.emit(node_id, prop_name, prop_value) @@ -195,7 +197,7 @@ def add_node(self, node): if itm_find[0].row() == 0: try: itm_find[0].setEnabled(node.graph.editable) - except: + except Exception as e: pass return self._prop_list.removeRow(itm_find[0].row()) diff --git a/docs/examples/ex_node.rst b/docs/examples/ex_node.rst index c39ba274..4a16a326 100644 --- a/docs/examples/ex_node.rst +++ b/docs/examples/ex_node.rst @@ -42,7 +42,7 @@ Creating Nodes Embedding Widgets ***************** -The :class:`NodeGraphQt.BaseNode` class allows you to embed widgets inside a node here's a +The :class:`NodeGraphQt.BaseNode` class allows you to embed some basic widgets inside a node here's a example to simply embed a ``QComboBox`` widget when reimplementing the ``BaseNode``. .. code-block:: python @@ -78,6 +78,115 @@ To you update the widget you can call the :meth:`NodeGraphQt.NodeObject.set_prop See: :ref:`Node Widgets` for more node widget types. +Embedding Custom Widgets +************************ + +Here's an example to embed a custom widget where we subclass the +:class:`NodeGraphQt.NodeBaseWidget` and then add to the node with the +:meth:`NodeGraphQt.BaseNode.add_custom_widget` function. + +.. code-block:: python + :linenos: + :emphasize-lines: 38, 96, 97 + + from NodeGraphQt import QtCore, QtWidgets, BaseNode, NodeBaseWidget + + class MyCustomWidget(QtWidgets.QWidget): + """ + Custom widget to be embedded inside a node. + """ + + def __init__(self, parent=None): + super(MyCustomWidget, self).__init__(parent) + self.combo_1 = QtWidgets.QComboBox() + self.combo_1.addItems(['a', 'b', 'c']) + self.combo_2 = QtWidgets.QComboBox() + self.combo_2.addItems(['a', 'b', 'c']) + self.btn_go = QtWidgets.QPushButton('Go') + + layout = QtWidgets.QHBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + layout.addWidget(self.combo_1) + layout.addWidget(self.combo_2) + layout.addWidget(self.btn_go) + + + class NodeWidgetWrapper(NodeBaseWidget): + """ + Wrapper that allows the widget to be added in a node object. + """ + + def __init__(self, parent=None): + super(NodeWidgetWrapper, self).__init__(parent) + + # set the name for node property. + self.set_name('my_widget') + + # set the label above the widget. + self.set_label('Custom Widget') + + # set the custom widget. + self.set_custom_widget(MyCustomWidget()) + + # connect up the signals & slots. + self.wire_signals() + + def wire_signals(self): + widget = self.get_custom_widget() + + # wire up the combo boxes. + widget.combo_1.currentIndexChanged.connect(self.on_value_changed) + widget.combo_2.currentIndexChanged.connect(self.on_value_changed) + + # wire up the button. + widget.btn_go.clicked.connect(self.on_btn_go_clicked) + + def on_btn_go_clicked(self): + print('Clicked on node: "{}"'.format(self.node.name())) + + def get_value(self): + widget = self.get_custom_widget() + return '{}/{}'.format(widget.combo_1.currentText(), + widget.combo_2.currentText()) + + def set_value(self, value): + value = value.split('/') + if len(value) < 2: + combo1_val = value[0] + combo2_val = '' + else: + combo1_val, combo2_val = value + widget = self.get_custom_widget() + + cb1_index = widget.combo_1.findText(combo1_val, QtCore.Qt.MatchExactly) + cb2_index = widget.combo_1.findText(combo2_val, QtCore.Qt.MatchExactly) + + widget.combo_1.setCurrentIndex(cb1_index) + widget.combo_2.setCurrentIndex(cb2_index) + + + class MyNode(BaseNode): + """ + Example node. + """ + + # set a unique node identifier. + __identifier__ = 'com.chantasticvfx' + + # set the initial default node name. + NODE_NAME = 'my node' + + def __init__(self): + super(MyNode, self).__init__() + + # create input and output port. + self.add_input('in') + self.add_output('out') + + # add custom widget to node with "node.view" as the parent. + node_widget = NodeWidgetWrapper(self.view) + self.add_custom_widget(node_widget, tab='Custom') + Connecting Nodes **************** diff --git a/docs/node_widgets.rst b/docs/node_widgets.rst index c1aed5ac..fc311405 100644 --- a/docs/node_widgets.rst +++ b/docs/node_widgets.rst @@ -7,10 +7,14 @@ displayed in the node graph. NodeBaseWidget ************** -.. autoclass:: NodeGraphQt.widgets.node_widgets.NodeBaseWidget +.. autoclass:: NodeGraphQt.NodeBaseWidget :members: :exclude-members: node, setToolTip, type_, value, widget +----- + +Below are builtin node widgets inherited from :class:`NodeGraphQt.NodeBaseWidget` + NodeCheckBox ************