- This is a breaking implementation of the Values System v2

- [Editor] Stub code for the value connect button change in the details panel / deprecation of the old 'global_checkbox' code
- [Editor] Input entries now have the 'SetDefaultValue' function which the handler invokes when neither 'value' nor 'default' keys are present in the data. This forces a minimum such as 0 or 'None'
- [Editor] Cleaned up working and type annotations in the input entry handler to be clear on which functions are generalized for all item views, and which are explicitly for tree view only

Author: Cronza

HBEditor/Core/EditorCommon/DetailsPanel/details_panel.py

@@ -51,7 +51,7 @@ def __init__(self, excluded_properties: list = None):
         self.details_tree = QtWidgets.QTreeWidget(self)
         self.details_tree.setObjectName("no-top")
         self.details_tree.setColumnCount(3)
-        self.details_tree.setHeaderLabels(['Name', 'Input', 'G'])
+        self.details_tree.setHeaderLabels(['Name', 'Input', 'C'])
         self.details_tree.setAutoScroll(False)
         self.details_tree.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollMode.ScrollPerPixel)
         self.details_tree.header().setStretchLastSection(False)  # Disable to allow custom sizing
@@ -61,7 +61,7 @@ def __init__(self, excluded_properties: list = None):
         self.details_tree.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.NoSelection)
         self.details_tree.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
 
-        # --- Specialized Settings for the 'G' column ---
+        # --- Specialized Settings for the 'C' column ---
         # 1. Allow columns to be significantly smaller than normal
         self.details_tree.header().setMinimumSectionSize(round(self.details_tree.header().width() / 4))
 
@@ -139,9 +139,9 @@ def ConnectSignals(self, tree_item):
         input_widget = self.details_tree.itemWidget(tree_item, 1)
         input_widget.SIG_USER_UPDATE.connect(self.UserUpdatedInputWidget)
 
-        global_checkbox = self.details_tree.itemWidget(tree_item, 2)
-        if global_checkbox:
-            global_checkbox.SIG_USER_UPDATE.connect(self.UserClickedGlobalCheckbox)
+        #global_checkbox = self.details_tree.itemWidget(tree_item, 2)
+        #if global_checkbox:
+        #    global_checkbox.SIG_USER_UPDATE.connect(self.UserClickedGlobalCheckbox)
 
     def StoreData(self, parent: QtWidgets.QTreeWidgetItem = None) -> dict:
         """

HBEditor/Core/EditorCommon/connect_button.py

@@ -0,0 +1,35 @@
+from PyQt6 import QtWidgets, QtCore
+
+
+class ConnectButton(QtWidgets.QToolButton):
+    def __init__(self, parent = None):
+        super().__init__(parent)
+        print("Spawned Connect Button")
+
+        self.clicked.connect(self.ShowConnectionDialog)
+
+    def ShowConnectionDialog(self):
+        dialog = ConnectionDialog()
+        dialog.exec()
+
+class ConnectionDialog(QtWidgets.QDialog):
+    def __init__(self):
+        super().__init__()
+
+        # Hide the OS header to lock its position
+        self.setWindowFlags(QtCore.Qt.WindowType.FramelessWindowHint)
+        self.resize(640, 480)
+        self.main_layout = QtWidgets.QTabBar(self)
+
+        self.value_tab = QtWidgets.QTabWidget()
+
+        self.project_setting_tab = QtWidgets.QTabWidget()
+        self.main_layout
+
+
+
+        # Confirmation Buttons
+        self.button_box = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.StandardButton.Ok | QtWidgets.QDialogButtonBox.StandardButton.Cancel)
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+        self.main_layout.addWidget(self.button_box)

HBEditor/Core/EditorValues/editor_values_ui.py

@@ -14,7 +14,8 @@
 """
 from PyQt6 import QtWidgets, QtGui, QtCore
 from HBEditor.Core.base_editor_ui import EditorBaseUI
-from HBEditor.Core.Primitives.input_entries import InputEntryText
+from HBEditor.Core.DataTypes.parameter_types import ParameterType
+from HBEditor.Core.Primitives.input_entries import InputEntryText, InputEntryDropdown
 from HBEditor.Core.Primitives import input_entry_handler as ieh
 from HBEditor.Core import settings
 
@@ -23,6 +24,25 @@ class EditorValuesUI(EditorBaseUI):
     def __init__(self, core_ref):
         super().__init__(core_ref)
 
+        # Limit what editing types are usable as some (such as Array or Event) are complex and would require
+        # additional work to allow user control
+        self.possible_input_types = [
+            ParameterType.String,
+            ParameterType.Bool,
+            ParameterType.Int,
+            ParameterType.Float,
+            ParameterType.Vector2,
+            ParameterType.Paragraph,
+            ParameterType.Color,
+            ParameterType.Asset_Scene,
+            ParameterType.Asset_Dialogue,
+            ParameterType.Asset_Data,
+            ParameterType.Asset_Interface,
+            ParameterType.Asset_Font,
+            ParameterType.Asset_Image,
+            ParameterType.Asset_Sound
+        ]
+
         # Build the core editor layout object
         self.main_layout = QtWidgets.QHBoxLayout(self)
         self.main_layout.setContentsMargins(0, 0, 0, 0)
@@ -51,17 +71,21 @@ def __init__(self, core_ref):
         # Main Table
         self.values_table = QtWidgets.QTableWidget(self)
         self.values_table.setObjectName('values-table')
-        self.values_table.setColumnCount(2)
+        self.values_table.setColumnCount(3)
         self.values_table.verticalHeader().hide()
-        self.values_table.setHorizontalHeaderLabels(['Name', 'Value'])
+        self.values_table.setHorizontalHeaderLabels(['Type', 'Name', 'Value'])
         self.values_table.horizontalHeader().setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Interactive)
-        self.values_table.horizontalHeader().setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeMode.Stretch)
+        self.values_table.horizontalHeader().setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeMode.Interactive)
+        self.values_table.horizontalHeader().setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeMode.Stretch)
         self.values_table.setAlternatingRowColors(True)
         self.values_table.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.SingleSelection)
         self.values_table.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)  # Disable the selection outline
         self.values_table.setSortingEnabled(True)
-        # TODO: Investigate how to improve the sizing for the first col. It should be a percentage of the available space
+
+        # TODO: Investigate how to improve sizing calculations. It should be a percentage of the available space
         self.values_table.horizontalHeader().setDefaultSectionSize(self.values_table.horizontalHeader().defaultSectionSize() * 3)
+        self.values_table.setColumnWidth(0, round(self.values_table.horizontalHeader().defaultSectionSize() / 2))
+
         self.values_table.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.DoubleClicked | QtWidgets.QAbstractItemView.EditTrigger.SelectedClicked)
         values_delegate = ValuesItemDelegate(self)
         self.values_table.setItemDelegate(values_delegate)
@@ -70,18 +94,47 @@ def __init__(self, core_ref):
 
     def AddValue(self, data: tuple = None):
         self.values_table.insertRow(self.values_table.rowCount())
+
+        # Populate the row with items
         self.values_table.setItem(self.values_table.rowCount() - 1, 0, QtWidgets.QTableWidgetItem())
         self.values_table.setItem(self.values_table.rowCount() - 1, 1, QtWidgets.QTableWidgetItem())
-        self.values_table.resizeRowsToContents()
+        self.values_table.setItem(self.values_table.rowCount() - 1, 2, QtWidgets.QTableWidgetItem())
+
+        # Add the type dropdown
+        #type_input = InputEntryDropdown({"options": [param_type.name for param_type in self.possible_input_types]})
+        type_input = ieh.Create(
+            owner=self,
+            name="",
+            data={"type": "Dropdown", "options": [param_type.name for param_type in self.possible_input_types]},
+            owning_model_item=self.values_table.item(self.values_table.rowCount() - 1, 2),
+            owning_view=self.values_table
+        )[1]
+        type_input.SIG_USER_UPDATE.connect(self.SwitchInputType)
+        self.values_table.setCellWidget(self.values_table.rowCount() - 1, 0, type_input)
+        self.SwitchInputType(self.values_table.item(self.values_table.rowCount() - 1, 0))
 
         # Load data if provided
         if data:
             row = self.values_table.rowCount() - 1
             self.values_table.item(row, 0).setData(0, data[0])
             self.values_table.item(row, 1).setData(0, data[1])
+            self.values_table.item(row, 2).setData(0, data[2])
 
+        self.values_table.resizeRowsToContents()
         self.SIG_USER_UPDATE.emit()
 
+    def SwitchInputType(self, table_item: QtWidgets.QTableWidgetItem):
+        """ Creates and replaces the input entry type for the provided item s"""
+        row = self.values_table.row(table_item)
+        input_entry = ieh.Create(
+            owner=self,
+            name="",
+            data={"type": self.values_table.cellWidget(row, 0).Get()['value']},
+            owning_model_item=self.values_table.item(row, 2),
+            owning_view=self.values_table
+        )[1]
+        self.values_table.setCellWidget(row, 2, input_entry)
+
     def RemoveValue(self):
         selected_rows = self.values_table.selectedIndexes()
         if selected_rows:

HBEditor/Core/Primitives/input_entries.py

@@ -69,6 +69,9 @@ def Disconnect(self):
     def SetEditable(self, state: int):
         pass
 
+    def SetDefaultValue(self):
+        pass
+
 
 class InputEntryBool(InputEntryBase):
     def __init__(self, data):
@@ -97,10 +100,14 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = False
+
 
 class InputEntryColor(InputEntryBase):
     def __init__(self, data):
         super().__init__(data)
+
         self.input_widget = QtWidgets.QFrame()
         self.input_widget.setFrameStyle(QtWidgets.QFrame.Shape.Panel)
         self.input_widget.setStyleSheet("border: 1px solid rgb(122,122,122);background-color: rgb(255,255,255)")
@@ -137,6 +144,9 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = [255, 255, 255]
+
     def OpenColorPrompt(self):
         color_choice = QtWidgets.QColorDialog().getColor(
             QtGui.QColor(self.data['value'][0], self.data['value'][1], self.data['value'][2])
@@ -160,7 +170,7 @@ def __init__(self, data):
         self.input_widget = QtWidgets.QComboBox()
         self.options = data["options"]
 
-        # Pre-load the list of dropdown options
+        # Preload the list of dropdown options
         for option in self.options:
             self.input_widget.addItem(str(option))
 
@@ -187,6 +197,10 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = self.options[0]
+        self.Set(self.data['value'])
+
 
 class InputEntryAssetSelector(InputEntryBase):
     def __init__(self, data: dict, details_panel: object, type_filter: set):
@@ -233,6 +247,10 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = 'None'
+        self.Set(self.data['value'])
+
     def OpenAssetPrompt(self):
         """
         Prompts the user with the AssetBrowser, allowing them to select an asset matching the type
@@ -283,6 +301,9 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = 0.0
+        self.Set(self.data['value'])
 
 class InputEntryInt(InputEntryBase):
     def __init__(self, data):
@@ -324,6 +345,10 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = 0
+        self.Set(self.data['value'])
+
 
 class InputEntryParagraph(InputEntryBase):
     def __init__(self,data):
@@ -354,6 +379,10 @@ def SetEditable(self, state: int):
         elif state == 2:
             self.input_widget.setReadOnly(True)
 
+    def SetDefaultValue(self):
+        self.data['value'] = ''
+        self.Set(self.data['value'])
+
 
 class InputEntryText(InputEntryBase):
     def __init__(self, data):
@@ -381,6 +410,10 @@ def SetEditable(self, state: int):
 
         self.input_widget.style().polish(self.input_widget)
 
+    def SetDefaultValue(self):
+        self.data['value'] = ''
+        self.Set(self.data['value'])
+
 
 class InputEntryTuple(InputEntryBase):
     def __init__(self, data):
@@ -394,7 +427,7 @@ def __init__(self, data):
         self.input_widget_alt = QtWidgets.QLineEdit()
 
         # Limit entered values to int only
-        validator = QtGui.QDoubleValidator(-2, 2, 8, notation=QtGui.QDoubleValidator.Notation.StandardNotation)
+        validator = QtGui.QDoubleValidator(notation=QtGui.QDoubleValidator.Notation.StandardNotation)
         self.input_widget.setValidator(validator)
         self.input_widget_alt.setValidator(validator)
         self.input_widget.setText("0")
@@ -448,6 +481,10 @@ def SetEditable(self, state: int):
         self.input_widget.style().polish(self.input_widget)
         self.input_widget_alt.style().polish(self.input_widget_alt)
 
+    def SetDefaultValue(self):
+        self.data['value'] = (0,0)
+        self.Set(self.data['value'])
+
 
 class InputEntryArray(InputEntryBase):
     """

HBEditor/Core/Primitives/input_entry_handler.py

@@ -16,6 +16,7 @@
 from HBEditor.Core.Primitives.simple_checkbox import SimpleCheckbox
 from HBEditor.Core.DataTypes.parameter_types import ParameterType
 from HBEditor.Core.DataTypes.file_types import FileType
+from HBEditor.Core.EditorCommon.connect_button import ConnectButton
 from HBEditor.Core.Primitives.input_entries import *
 
 
@@ -38,7 +39,7 @@ def Add(owner: QWidget, name: str, data: dict, view: QtWidgets.QTreeView,
     else:
         view.addTopLevelItem(entry)
 
-    name_widget, input_widget, global_checkbox = Create(
+    name_widget, input_widget, connect_button = Create(
         owner, name, data, entry, view, signal_func, excluded_properties
     )
     view.setItemWidget(entry, 0, name_widget)
@@ -50,14 +51,14 @@ def Add(owner: QWidget, name: str, data: dict, view: QtWidgets.QTreeView,
     return entry
 
 
-def Create(owner: QWidget, name: str, data: dict, owning_model_item: QTreeWidgetItem,
+def Create(owner: QWidget, name: str, data: dict, owning_model_item,
            owning_view: QtWidgets.QAbstractItemView, signal_func: callable = None,
-           excluded_properties: dict = None) -> object:
+           excluded_properties: dict = None) -> tuple:
     """
     Creates and returns each element of an InputEntry:
     - QLabel (Name)
     - InputEntry
-    - Global Checkbox (SimpleCheckbox)
+    - ConnectButton (Value / Project Setting Connection Button)
     """
     # @TODO: Replace with a switch when the Python version is upgraded to allow it (3.10)
     data_type = ParameterType[data["type"]]
@@ -110,34 +111,42 @@ def Create(owner: QWidget, name: str, data: dict, owning_model_item: QTreeWidget
     input_widget.owning_model_item = owning_model_item
     input_widget.Connect()
 
-    # Update the entry with the value key if applicable. Otherwise, use the default value
+    # Update the entry with the value key if applicable. Otherwise, use the default value. If no default is available,
+    # let the entry load its own default
     if "value" in data:
         input_widget.Set(data["value"])
     elif "default" in data:
         data["value"] = data["default"]
         input_widget.Set(data["value"])
+    else:
+        input_widget.SetDefaultValue()
 
     name_widget = QLabel(name)
 
     # The global checkbox isn't universally used, so only use it if relevant. If it's enabled, mark
     # the input widget as uneditable by the user
-    global_checkbox = None
+    connect_button = None
     if "global" in data and "flags" in data:
-        global_checkbox = SimpleCheckbox()
-        global_checkbox.owner = owning_model_item
-        global_checkbox.setToolTip("Whether to use the global value specified in the project file for this entry")
-        owning_view.setItemWidget(owning_model_item, 2, global_checkbox)
-        if "global_active" in data["flags"]:
-            global_checkbox.Set(True)
-            input_widget.SetEditable(2)
-        else:
-            global_checkbox.Set(False)
-        global_checkbox.Connect()
+        connect_button = ConnectButton()
+        owning_view.setItemWidget(owning_model_item, 2, connect_button)
+
+
+    #    global_checkbox = SimpleCheckbox()
+    #    global_checkbox.owner = owning_model_item
+    #    global_checkbox.setToolTip("Whether to use the global value specified in the project file for this entry")
+    #    owning_view.setItemWidget(owning_model_item, 2, global_checkbox)
+    #    if "global_active" in data["flags"]:
+    #        global_checkbox.Set(True)
+    #        input_widget.SetEditable(2)
+    #    else:
+    #        global_checkbox.Set(False)
+    #    global_checkbox.Connect()
 
-    return name_widget, input_widget, global_checkbox
+    return name_widget, input_widget, connect_button
 
 
-def Remove(item: QTreeWidgetItem, owning_view: QtWidgets.QAbstractItemView = None):
+def Remove(item: QTreeWidgetItem, owning_view: QtWidgets.QTreeView = None):
+    """ Removes the provided item and all of its children from the provided QTreeView"""
     parent = item.parent()
     if parent:
         parent.removeChild(item)