Improve Button List UIWidget

src/model/board_configuration.py

@@ -231,7 +231,7 @@ def _distribute_filter_update_message(self, param: proto.FilterMode_pb2.update_p
             for c in candidate_list:
                 c(param)
 
-    def register_filter_update_callback(self, target_scene: int, target_filter_id: str, c: Callable) -> None:
+    def register_filter_update_callback(self, target_scene: int | Scene, target_filter_id: str, c: Callable) -> None:
         """Register a new callback for filter update messages.
 
         If filter update messages are received, they need to be routed to their intended destination. This is done using
@@ -243,6 +243,8 @@ def register_filter_update_callback(self, target_scene: int, target_filter_id: s
             c: The callable to register.
 
         """
+        if isinstance(target_scene, Scene):
+            target_scene = target_scene.scene_id
         callable_list = self._filter_update_msg_register.get((target_scene, target_filter_id))
         if callable_list is None:
             callable_list = set()

src/view/show_mode/editor/editor_tab_widgets/ui_widget_editor/_widget_holder.py

@@ -58,8 +58,8 @@ def __init__(self, child: UIWidget, parent: QWidget, instance_for_editor: bool =
 
     def update_size(self) -> None:
         """Update dimensions of show UI widget."""
-        self.setMinimumWidth(100)
-        self.setMinimumHeight(30)
+        self.setMinimumWidth(max(100, self._child.minimumSizeHint().width()))
+        self.setMinimumHeight(max(30, self._child.minimumSizeHint().height()))
         self.setMaximumHeight(65565)
         self.setMaximumWidth(65565)
 

src/view/show_mode/editor/filter_settings_item.py

@@ -33,6 +33,7 @@
 from .node_editor_widgets.dimmer_brightness_mixin_config_widget import DimmerBrightnessMixinConfigWidget
 from .node_editor_widgets.import_vfilter_settings_widget import ImportVFilterSettingsWidget
 from .node_editor_widgets.lua_widget import LuaScriptConfigWidget
+from .node_editor_widgets.number_constant_settings_widget import NumberConstantSettingsWidget
 from .node_editor_widgets.sequencer_editor.widget import SequencerEditor
 
 if TYPE_CHECKING:
@@ -145,6 +146,13 @@ def check_if_filter_has_special_widget(filter_: Filter) -> NodeEditorFilterConfi
         return SequencerEditor(f=filter_)
     if filter_.filter_type == FilterTypeEnumeration.VFILTER_DIMMER_BRIGHTNESS_MIXIN:
         return DimmerBrightnessMixinConfigWidget()
+    if filter_.filter_type in [FilterTypeEnumeration.FILTER_CONSTANT_8BIT,
+                               FilterTypeEnumeration.FILTER_CONSTANT_16_BIT,
+                               FilterTypeEnumeration.FILTER_CONSTANT_FLOAT,
+                               FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT,
+                               FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT,
+                               FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_FLOAT]:
+        return NumberConstantSettingsWidget(filter_)
     return None
 
 

src/view/show_mode/editor/node_editor_widgets/number_constant_settings_widget.py

@@ -0,0 +1,104 @@
+"""Contains editor widget for number constants."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, override
+
+from PySide6.QtWidgets import QCheckBox, QDoubleSpinBox, QFormLayout, QSpinBox, QWidget
+
+from model import DataType
+from model.filter import FilterTypeEnumeration
+from view.show_mode.editor.node_editor_widgets import NodeEditorFilterConfigWidget
+
+if TYPE_CHECKING:
+    from model import Filter
+
+
+class NumberConstantSettingsWidget(NodeEditorFilterConfigWidget):
+    """Widget to set the requested number and provide feedback check box.
+
+    Toggling the feedback check box changes the filter type of the connected filter.
+
+    """
+
+    def __init__(self, _filter: Filter) -> None:
+        """Initialize widget using given parent."""
+        super().__init__()
+        self._filter = _filter
+        if isinstance(_filter.filter_type, int):
+            _filter.filter_type = FilterTypeEnumeration(_filter.filter_type)
+        if _filter.filter_type in [
+            FilterTypeEnumeration.FILTER_CONSTANT_8BIT,
+            FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT]:
+            self._data_type = DataType.DT_8_BIT
+        elif _filter.filter_type in [
+            FilterTypeEnumeration.FILTER_CONSTANT_16_BIT,
+            FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT]:
+            self._data_type = DataType.DT_16_BIT
+        else:
+            self._data_type = DataType.DT_DOUBLE
+        self._widget = QWidget()
+        layout = QFormLayout()
+        match self._data_type:
+            case DataType.DT_8_BIT:
+                self._value_widget = QSpinBox(self._widget)
+                self._value_widget.setMinimum(0)
+                self._value_widget.setMaximum(255)
+            case DataType.DT_16_BIT:
+                self._value_widget = QSpinBox(self._widget)
+                self._value_widget.setMinimum(0)
+                self._value_widget.setMaximum(65535)
+            case _:
+                self._value_widget = QDoubleSpinBox(self._widget)
+        layout.addRow("Value", self._value_widget)
+        self._response_cb = QCheckBox("Send Feedback to GUI", self._widget)
+        self._response_cb.setChecked(_filter.filter_type in [
+            FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT,
+            FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT,
+            FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_FLOAT
+        ])
+        layout.addWidget(self._response_cb)
+        self._widget.setLayout(layout)
+
+    @override
+    def _get_parameters(self) -> dict[str, str]:
+        if self._response_cb.isChecked():
+            if self._data_type == DataType.DT_8_BIT:
+                self._filter.filter_type = FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT
+            elif self._data_type == DataType.DT_16_BIT:
+                self._filter.filter_type = FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT
+            else:
+                self._filter.filter_type = FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_FLOAT
+        else:
+            if self._data_type == DataType.DT_8_BIT:
+                self._filter.filter_type = FilterTypeEnumeration.FILTER_CONSTANT_8BIT
+            elif self._data_type == DataType.DT_16_BIT:
+                self._filter.filter_type = FilterTypeEnumeration.FILTER_CONSTANT_16_BIT
+            else:
+                self._filter.filter_type = FilterTypeEnumeration.FILTER_CONSTANT_FLOAT
+        return {
+            "value": str(self._value_widget.value()),
+        }
+
+    @override
+    def _load_parameters(self, conf: dict[str, str]) -> None:
+        if self._data_type == DataType.DT_DOUBLE:
+            self._value_widget.setValue(float(conf.get("value", "0")))
+        else:
+            self._value_widget.setValue(int(conf.get("value", "0")))
+
+    @override
+    def get_widget(self) -> QWidget:
+        return self._widget
+
+    @override
+    def _load_configuration(self, parameters: dict[str, str]) -> dict:
+        pass  # Nothing to do here
+
+    @override
+    def _get_configuration(self) -> dict[str, str]:
+        return {}
+
+    @override
+    def parent_opened(self) -> None:
+        pass  # Nothing to do here

src/view/show_mode/editor/nodes/type_to_node_dict.py

@@ -111,8 +111,11 @@
     FilterTypeEnumeration.VFILTER_AUTOTRACKER: AutoTrackerNode.nodeName,
     FilterTypeEnumeration.VFILTER_EFFECTSSTACK: EffectsStackNode.nodeName,
     FilterTypeEnumeration.FILTER_CONSTANT_8BIT: Constants8BitNode.nodeName,
+    FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT: Constants8BitNode.nodeName,
     FilterTypeEnumeration.FILTER_CONSTANT_16_BIT: Constants16BitNode.nodeName,
+    FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT: Constants16BitNode.nodeName,
     FilterTypeEnumeration.FILTER_CONSTANT_FLOAT: ConstantsFloatNode.nodeName,
+    FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_FLOAT: ConstantsFloatNode.nodeName,
     FilterTypeEnumeration.FILTER_CONSTANT_COLOR: ConstantsColorNode.nodeName,
     FilterTypeEnumeration.FILTER_DEBUG_OUTPUT_8BIT: Debug8BitNode.nodeName,
     FilterTypeEnumeration.FILTER_DEBUG_OUTPUT_16BIT: Debug16BitNode.nodeName,

src/view/show_mode/show_ui_widgets/__init__.py

@@ -33,25 +33,31 @@
         AutoTrackerUIWidget,
         [[FilterTypeEnumeration.VFILTER_POSITION_CONSTANT, FilterTypeEnumeration.VFILTER_AUTOTRACKER]],
     ),
-    "buttonarray": (
-        "Button Array",
+    "buttonarray_submit": (
+        "Button Array w/ Submit",
         ButtonsWithValueSubmit,
         [
             [
                 FilterTypeEnumeration.FILTER_CONSTANT_8BIT,
                 FilterTypeEnumeration.FILTER_CONSTANT_16_BIT,
                 FilterTypeEnumeration.FILTER_CONSTANT_FLOAT,
+                FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT,
+                FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT,
+                FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_FLOAT,
             ]
         ],
     ),
-    "buttonarray_submit": (
-        "Button Array w/ Submit",
+    "buttonarray": (
+        "Button Array",
         ConstantNumberButtonList,
         [
             [
                 FilterTypeEnumeration.FILTER_CONSTANT_8BIT,
                 FilterTypeEnumeration.FILTER_CONSTANT_16_BIT,
                 FilterTypeEnumeration.FILTER_CONSTANT_FLOAT,
+                FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_8BIT,
+                FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_16BIT,
+                FilterTypeEnumeration.FILTER_RESPONDING_CONSTANT_FLOAT,
             ]
         ],
     ),

src/view/show_mode/show_ui_widgets/button_list_with_submit_value.py

@@ -1,91 +1,77 @@
-"""This file contains a widget with a textfield and a button, extended by a list of buttons to update constants nodes
-with a new value or predefined one in fish"""
+"""File contains ButtonsWithValueSubmit module."""
+
 from __future__ import annotations
 
 import sys
-from typing import override
+from typing import TYPE_CHECKING, override
 
-from PySide6.QtWidgets import QDialog, QDoubleSpinBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
+from PySide6.QtWidgets import QDoubleSpinBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
 
-from model import Filter, UIPage, UIWidget
 from model.filter import FilterTypeEnumeration
 from view.show_mode.show_ui_widgets.constant_button_list import ConstantNumberButtonList
 
+if TYPE_CHECKING:
+    import proto.FilterMode_pb2
+    from model import UIPage
+
+class ButtonsWithValueSubmit(ConstantNumberButtonList):
+    """UI widget for the show mode (extended with ConstantNumberButtonList also for the editor mode).
 
-class ButtonsWithValueSubmit(UIWidget):
-    """ UI widget for the show mode (extended with ConstantNumberButtonList also for the editor mode).
     Provides a textfield with a submit-button to update a value (of a constant node).
-    Provides also (from ConstantNumberButtonList) a button list to send pre-defined values
-    """
+    Provides also (from ConstantNumberButtonList) a button list to send pre-defined values.
 
-    @override
-    def get_config_dialog_widget(self, parent: QDialog) -> QWidget:
-        return self._button_list.get_config_dialog_widget(parent)
+    """
 
     def __init__(self, parent: UIPage, configuration: dict[str, str]) -> None:
+        """Initialize UI widget."""
         super().__init__(parent, configuration)
         self._filter_type = None
         self._player_widget: QWidget | None = None
-        self._button_list = ConstantNumberButtonList(self.parent, configuration)
-
-    def set_filter(self, f: Filter, i: int) -> None:
-        super().set_filter(f, i)
-        self._filter_type = f.filter_type
-        self._button_list.set_filter(f, i)
-        self.associated_filters["constant"] = f.filter_id
-
-    @override
-    def generate_update_content(self) -> list[tuple[str, str]]:
-        return self._button_list.generate_update_content()
+        self._spinbox: QDoubleSpinBox | None = None
 
     @override
     def get_player_widget(self, parent: QWidget | None) -> QWidget:
-        if self._player_widget:
-            self._player_widget.deleteLater()
-        self.construct_player_widget(parent)
-        return self._player_widget
+        w = super().get_player_widget(parent)
+        return self._append_direct_widget(w, player=True)
 
     @override
     def get_configuration_widget(self, parent: QWidget | None) -> QWidget:
-        return self._button_list.get_configuration_widget(parent)
-
-    @override
-    def copy(self, new_parent: UIPage) -> UIWidget:
-        fid = self.associated_filters.get("constant")
-        w = ButtonsWithValueSubmit(self.parent, self.configuration.copy())
-        w.set_filter(Filter(None, fid, self._filter_type, None, None), 0)
-        super().copy_base(w)
-        return w
-
-    def construct_player_widget(self, parent: QWidget | None) -> None:
-        widget = QWidget(parent)
-        self._player_widget = QWidget(parent)
-        self._player_widget.setMinimumWidth(50)
-        self._player_widget.setMinimumHeight(30)
-        layout = QHBoxLayout(widget)
-        layout_submit_own_value = QVBoxLayout(widget)
-        valuefield = QDoubleSpinBox(widget)
+        w = super().get_configuration_widget(parent)
+        return self._append_direct_widget(w)
+
+    def _append_direct_widget(self, existing_widget: QWidget, player: bool = False) -> QWidget:
+        top_widget = QWidget()
+        top_layout = QHBoxLayout()
+        layout_submit_own_value = QVBoxLayout()
+        valuefield = QDoubleSpinBox(top_widget)
         if self._filter_type == FilterTypeEnumeration.FILTER_CONSTANT_FLOAT:
             valuefield.setMaximum(sys.float_info.max)
             valuefield.setMinimum(-sys.float_info.max)
             valuefield.setDecimals(20)
         else:
-            valuefield.setMaximum(self._button_list._maximum)
+            valuefield.setMaximum(self._maximum)
+            valuefield.setMinimum(0)
             valuefield.setDecimals(0)
-        submit_button = QPushButton("Send Value", widget)
+        if player:
+            self._spinbox = valuefield
+        submit_button = QPushButton("Send Value", top_widget)
 
         def pressed_button() -> None:
             value = valuefield.value() if self._filter_type == FilterTypeEnumeration.FILTER_CONSTANT_FLOAT else int(
                 valuefield.value())
-            self._button_list._set_value(value)
+            self._set_value(value)
 
         submit_button.clicked.connect(pressed_button)
         layout_submit_own_value.addWidget(valuefield)
         layout_submit_own_value.addWidget(submit_button)
-        layout.addLayout(layout_submit_own_value)
-        buttons = self._button_list.get_player_widget(parent)
-        layout.addWidget(buttons)
-        self._player_widget.setLayout(layout)
+        top_layout.addLayout(layout_submit_own_value)
+
+        top_layout.addWidget(existing_widget)
+        top_widget.setLayout(top_layout)
+        return top_widget
 
-    def __str__(self) -> str:
-        return str(self.configuration.get("constant"))
+    @override
+    def _update_from_fish(self, param: proto.FilterMode_pb2.update_parameter) -> None:
+        super()._update_from_fish(param)
+        if self._spinbox is not None and param.parameter_key == "value":
+            self._spinbox.setValue(float(param.parameter_value))