Inconsistent UI state initialization in QtAutoPlugin (Qt6)

[dev-jam]

Hi Sebastiaan, I had some problems with correctly setting the state of items in a plugin. I created this bug report with gemini.

Description:
When developing a plugin using QtAutoPlugin in OpenSesame 4.0+, there is an inconsistency in how the enabled state of widgets is handled during initialization.

While QLineEdit widgets correctly maintain an setEnabled(False) state set within init_edit_widget(), other widgets like QComboBox and QCheckBox appear to be "reset" to Enabled=True by the framework immediately after init_edit_widget() finishes.

Steps to reproduce:

1. Create a plugin based on QtAutoPlugin.
2. In init_edit_widget(), set several widgets to setEnabled(False) based on the state of a "master" checkbox.
3. Observe that QLineEdit objects are correctly disabled when the UI loads.
4. Observe that QComboBox and QCheckBox objects remain enabled, despite widget.isChecked() returning the expected value and the manual setEnabled(False) call being executed.

Current workaround:
The only way to force the correct state is by using a QTimer.singleShot(0, self.update_ui_states) to defer the setEnabled calls until after the framework has completed its internal setup/variable binding.

Expected behavior:
The framework should respect the enabled state set by the developer in init_edit_widget(), or provide a specific hook that is called after variable binding is complete but before the UI is shown to the user.

Environment:

• OpenSesame version: 4.1.8
• Operating System: Debian Trixie

---

Example snippet:

class MyPlugin(QtAutoPlugin):
    """ 
    Minimal example showing that QLineEdit respects setEnabled(False) 
    during init, but QComboBox and QCheckBox do not.
    """

    def init_edit_widget(self):
        super().init_edit_widget()
        
        # Assume self.checkbox_master is the trigger (default Unchecked)
        master_state = self.checkbox_master.isChecked() # Returns False
        
        # 1. This WORKS: LineEdit will be disabled on startup
        self.line_edit_test.setEnabled(master_state)
        
        # 2. This FAILS: ComboBox will be enabled on startup despite master_state being False
        self.combobox_test.setEnabled(master_state)
        
        # 3. This FAILS: CheckBox will be enabled on startup
        self.checkbox_test.setEnabled(master_state)

        # Connections work fine once the user starts interacting:
        self.checkbox_master.stateChanged.connect(self.combobox_test.setEnabled)

[smathot]

Thanks for this! Can you provide a complete example that also shows how the widgets are initialized? This can either be explicitly in init_edit_widget() or implicitly in the plugins controls field in __init__.py (in which case they're also bound to a variable).

[dev-jam]

Ofcourse, it is in this item:

https://github.com/dev-jam/opensesame-plugin-titta_eyetracking/blob/main/opensesame_plugins/titta/titta_init/titta_init.py

[smathot]

Thanks for this. The issue results from the fact that after the widgets have been initialized by init_edit_widget(), their values are set by auto_edit_widget(). This causes some widgets to be enabled again. (These are the widgets that could in theory also be disabled if the script contains values that cannot be parsed into the UI.) So to have this work properly you'll need to move the enabled-status logic to auto_edit_widget(). But because this function is called each time that the controls may need to be updated, you need to use a flag (_need_to_set_enabled) to make sure you only do this once.

Here's how this would look like:

class MyPlugin(QtAutoPlugin):
    """ 
    Minimal example showing that QLineEdit respects setEnabled(False) 
    during init, but QComboBox and QCheckBox do not.
    """

    def __init__(self, name, experiment, script=None):
        TittaInit.__init__(self, name, experiment, script)
        MyPlugin.__init__(self, __file__)
        self._need_to_set_enabled = True    

    def auto_edit_widget(self):
        super().auto_edit_widget()
        if not self._need_to_set_enabled:
            return
        self._need_to_set_enabled = False
        
        # Assume self.checkbox_master is the trigger (default Unchecked)
        master_state = self.checkbox_master.isChecked() # Returns False
        
        # 1. This WORKS: LineEdit will be disabled on startup
        self.line_edit_test.setEnabled(master_state)
        
        # 2. This FAILS: ComboBox will be enabled on startup despite master_state being False
        self.combobox_test.setEnabled(master_state)
        
        # 3. This FAILS: CheckBox will be enabled on startup
        self.checkbox_test.setEnabled(master_state)

        # Connections work fine once the user starts interacting:
        self.checkbox_master.stateChanged.connect(self.combobox_test.setEnabled)

In the process, I also spotted an issue in qtplugin.py, which incorrectly re-implements edit_widget(). qtplugin.edit_widget() should be removed altogether, otherwise the logic above won't work.

Can you try if the above works? This means not only testing whether dragging the item fresh into the experiment works, but also whether the controls are properly initialized when changing the settings, saving an experiment and then re-opening it again. UI controls are pretty finicky, so before I fix anything (in this case removing qtplugin.edit_widget()) it needs to be tested properly.

[dev-jam]

Your example seems to have a couple of errors, for example this combination:

        TittaInit.__init__(self, name, experiment, script)
        MyPlugin.__init__(self, __file__)

I guess MyPlugin should be QtAutoPlugin.

I tried to add your logic to my titta_init.py with as result:

class QtTittaInit(TittaInit, QtAutoPlugin):

    def __init__(self, name, experiment, script=None):
        TittaInit.__init__(self, name, experiment, script)
        QtAutoPlugin.__init__(self, __file__)
        self._need_to_set_enabled = True 

    def auto_edit_widget(self):
        super().auto_edit_widget()
        if not self._need_to_set_enabled:
            return
        self._need_to_set_enabled = False
       
        # set default state
        self.combobox_calibration_dot.setEnabled(
            self.checkbox_calibration_custom.isChecked())
        self.line_edit_calibration_dot_size.setEnabled(
            self.checkbox_calibration_custom.isChecked())
        self.line_edit_calibration_movement_duration.setEnabled(
            self.checkbox_calibration_custom.isChecked())
        
        # connect to checkbox_calibration_custom
        self.checkbox_calibration_custom.stateChanged.connect(
            self.combobox_calibration_dot.setEnabled)
        self.checkbox_calibration_custom.stateChanged.connect(
            self.line_edit_calibration_dot_size.setEnabled)
        self.checkbox_calibration_custom.stateChanged.connect(
            self.line_edit_calibration_movement_duration.setEnabled)

        # set default state
        self.line_edit_xres.setEnabled(self.checkbox_operator.isChecked())
        self.line_edit_yres.setEnabled(self.checkbox_operator.isChecked())
        self.line_edit_screen_nr.setEnabled(self.checkbox_operator.isChecked())
        self.line_edit_screen_name.setEnabled(self.checkbox_operator.isChecked())
        self.checkbox_waitblanking.setEnabled(self.checkbox_operator.isChecked())
        
        # connect to checkbox_operator
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_xres.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_yres.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_screen_nr.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_screen_name.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.checkbox_waitblanking.setEnabled)

But this does not work correctly.

Gemini gave a lazy load as workaround and it works both with dragging a fresh item as reopening a saved experiment :

from PyQt6.QtCore import QTimer

class QtTittaInit(TittaInit, QtAutoPlugin):

    def __init__(self, name, experiment, script=None):
        TittaInit.__init__(self, name, experiment, script)
        QtAutoPlugin.__init__(self, __file__)

    def init_edit_widget(self):
        super().init_edit_widget()

        # 1. Connect signals (ensures manual clicks continue to work)
        self.checkbox_calibration_custom.stateChanged.connect(
            self.combobox_calibration_dot.setEnabled)
        self.checkbox_calibration_custom.stateChanged.connect(
            self.line_edit_calibration_dot_size.setEnabled)
        self.checkbox_calibration_custom.stateChanged.connect(
            self.line_edit_calibration_movement_duration.setEnabled)

        self.checkbox_operator.stateChanged.connect(
            self.line_edit_xres.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_yres.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_screen_nr.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.line_edit_screen_name.setEnabled)
        self.checkbox_operator.stateChanged.connect(
            self.checkbox_waitblanking.setEnabled)

        # 2. 'Lazy Load': Wait until OpenSesame has finished building the UI
        # and then force the correct enabled/disabled states.
        QTimer.singleShot(0, self.update_ui_states)

    def update_ui_states(self):
        """
        Forces the correct enabled/disabled status based on current checkbox values.
        This overrides any automatic resets by OpenSesame during startup.
        """
        # Verify if widgets still exist (safety check for Qt)
        if not hasattr(self, 'checkbox_calibration_custom'):
            return

        # Custom Calibration Group
        custom_checked = self.checkbox_calibration_custom.isChecked()
        self.combobox_calibration_dot.setEnabled(custom_checked)
        self.line_edit_calibration_dot_size.setEnabled(custom_checked)
        self.line_edit_calibration_movement_duration.setEnabled(custom_checked)

        # Operator Group
        op_checked = self.checkbox_operator.isChecked()
        self.line_edit_xres.setEnabled(op_checked)
        self.line_edit_yres.setEnabled(op_checked)
        self.line_edit_screen_nr.setEnabled(op_checked)
        self.line_edit_screen_name.setEnabled(op_checked)
        self.checkbox_waitblanking.setEnabled(op_checked)

        # Debugging: print to console to verify execution
        print(f"Lazy load executed. Operator checked: {op_checked}")

[smathot]

I guess MyPlugin should be QtAutoPlugin.

Indeed.

But this does not work correctly.

It should though, I tested it. Did you remove qtplugin.edit_widget() from the OpenSesame code as explained above? That's necessary for this workaround.

Gemini gave a lazy load as workaround and it works both with dragging a fresh item as reopening a saved experiment

Use a QTimer without a 0 delay indeed works too, but that's mostly a coincidence. This essentially means: call update_ui_states() as soon as possible, but when this is exactly is somewhat undefined and may change with slight implementation changes in either OpenSesame or Qt itself.

The QTimer approach has the advantage that it doesn't require an update to OpenSesame itself, but the disadvantage that it's fragile. I would go with the auto_edit_widget() override. It won't change anything right now, but in combination with a small maintenance release to OpenSesame it will fix the issue.

[dev-jam]

Yeah I did not like the lazy load workaround either.
I did not remove qtplugin.edit_widget() because I read it incorrectly in your earlier post but now it is clear.
And it works correctly now I removed the edit_widget()