MNT: Migrate VTK Widgets to GUI API

.coveragerc

@@ -14,3 +14,5 @@ omit =
 exclude_lines =
     pragma: no cover
     if __name__ == .__main__.:
+    @abstractmethod
+    @abstractclassmethod

mne/viz/_brain/_linkviewer.py

@@ -26,30 +26,31 @@ def __init__(self, brains, time=True, camera=False, colorbar=True,
 
         if time:
             # link time sliders
-            self.link_sliders(
+            self.link_widgets(
                 name="time",
                 callback=self.set_time_point,
-                event_type="always"
+                signal_type="valueChanged",
             )
 
             # link playback speed sliders
-            self.link_sliders(
+            self.link_widgets(
                 name="playback_speed",
                 callback=self.set_playback_speed,
-                event_type="always"
+                signal_type="valueChanged",
             )
 
             # link toggle to start/pause playback
-            for brain in self.brains:
-                brain.actions["play"].triggered.disconnect()
-                brain.actions["play"].triggered.connect(
-                    self.toggle_playback)
+            self.link_widgets(
+                name="play",
+                callback=self.toggle_playback,
+                signal_type="triggered",
+                actions=True,
+            )
 
             # link time course canvas
             def _time_func(*args, **kwargs):
                 for brain in self.brains:
                     brain.callbacks["time"](*args, **kwargs)
-
             for brain in self.brains:
                 if brain.show_traces:
                     brain.mpl_canvas.time_func = _time_func
@@ -95,13 +96,12 @@ def _func_remove(*args, **kwargs):
                 brain.callbacks["fmin"](fmin)
                 brain.callbacks["fmid"](fmid)
                 brain.callbacks["fmax"](fmax)
-
-            for slider_name in ('fmin', 'fmid', 'fmax'):
-                func = getattr(self, "set_" + slider_name)
-                self.link_sliders(
-                    name=slider_name,
+            for name in ('fmin', 'fmid', 'fmax'):
+                func = getattr(self, "set_" + name)
+                self.link_widgets(
+                    name=name,
                     callback=func,
-                    event_type="always"
+                    signal_type="valueChanged"
                 )
 
     def set_fmin(self, value):
@@ -125,22 +125,22 @@ def set_playback_speed(self, value):
             brain.callbacks["playback_speed"](value, update_widget=True)
 
     def toggle_playback(self):
-        value = self.leader.callbacks["time"].slider_rep.GetValue()
+        value = self.leader.callbacks["time"].widget.get_value()
         # synchronize starting points before playback
         self.set_time_point(value)
         for brain in self.brains:
             brain.toggle_playback()
 
-    def link_sliders(self, name, callback, event_type):
-        from ..backends._pyvista import _update_slider_callback
+    def link_widgets(self, name, callback, signal_type, actions=False):
         for brain in self.brains:
-            slider = brain.sliders[name]
-            if slider is not None:
-                _update_slider_callback(
-                    slider=slider,
-                    callback=callback,
-                    event_type=event_type
-                )
+            if actions:
+                widget = brain._renderer.actions[name]
+            else:
+                widget = brain.widgets[name].widget
+            if widget is not None:
+                signal = getattr(widget, signal_type)
+                signal.disconnect()
+                signal.connect(callback)
 
     def link_cameras(self):
         from ..backends._pyvista import _add_camera_callback

mne/viz/_brain/callback.py

@@ -6,188 +6,170 @@
 import time
 
 
-class IntSlider(object):
-    """Class to set a integer slider."""
-
-    def __init__(self, plotter=None, callback=None, first_call=True):
-        self.plotter = plotter
-        self.callback = callback
-        self.slider_rep = None
-        self.first_call = first_call
-        self._first_time = True
-
-    def __call__(self, value):
-        """Round the label of the slider."""
-        idx = int(round(value))
-        if self.slider_rep is not None:
-            self.slider_rep.SetValue(idx)
-            self.plotter.update()
-        if not self._first_time or all([self._first_time, self.first_call]):
-            self.callback(idx)
-        if self._first_time:
-            self._first_time = False
-
-
-class TimeSlider(object):
-    """Class to update the time slider."""
-
-    def __init__(self, plotter=None, brain=None, callback=None,
-                 first_call=True):
-        self.plotter = plotter
+class Widget(object):
+    """Helper class to interface with widgets."""
+
+    def __init__(self, widget, notebook=False):
+        self.widget = widget
+        self.notebook = notebook
+
+    def set_value(self, value):
+        """Set the widget value."""
+        if self.notebook:
+            self.widget.value = value
+        else:
+            if hasattr(self.widget, "setValue"):
+                self.widget.setValue(value)
+            elif hasattr(self.widget, "setCurrentText"):
+                self.widget.setCurrentText(value)
+            elif hasattr(self.widget, "setText"):
+                self.widget.setText(value)
+
+    def get_value(self):
+        """Get the widget value."""
+        if self.notebook:
+            return self.widget.value
+        else:
+            if hasattr(self.widget, "value"):
+                return self.widget.value()
+            elif hasattr(self.widget, "currentText"):
+                return self.widget.currentText()
+            elif hasattr(self.widget, "text"):
+                return self.widget.text()
+
+
+class TimeCallBack(object):
+    """Callback to update the time."""
+
+    def __init__(self, brain=None, callback=None):
         self.brain = brain
         self.callback = callback
-        self.slider_rep = None
-        self.first_call = first_call
-        self._first_time = True
-        self.time_label = None
+        self.widget = None
+        self.label = None
         if self.brain is not None and callable(self.brain._data['time_label']):
             self.time_label = self.brain._data['time_label']
+        else:
+            self.time_label = None
 
     def __call__(self, value, update_widget=False, time_as_index=True):
         """Update the time slider."""
-        value = float(value)
         if not time_as_index:
             value = self.brain._to_time_index(value)
-        if not self._first_time or all([self._first_time, self.first_call]):
-            self.brain.set_time_point(value)
+        self.brain.set_time_point(value)
+        if self.label is not None:
+            current_time = self.brain._current_time
+            self.label.set_value(f"{current_time: .3f}")
         if self.callback is not None:
             self.callback()
-        current_time = self.brain._current_time
-        if self.slider_rep is not None:
-            if self.time_label is not None:
-                current_time = self.time_label(current_time)
-                self.slider_rep.SetTitleText(current_time)
-            if update_widget:
-                self.slider_rep.SetValue(value)
-                self.plotter.update()
-        if self._first_time:
-            self._first_time = False
+        if self.widget is not None and update_widget:
+            self.widget.set_value(int(value))
 
 
 class UpdateColorbarScale(object):
     """Class to update the values of the colorbar sliders."""
 
-    def __init__(self, plotter=None, brain=None):
-        self.plotter = plotter
+    def __init__(self, brain=None):
         self.brain = brain
-        self.keys = ('fmin', 'fmid', 'fmax')
-        self.reps = {key: None for key in self.keys}
-        self.slider_rep = None
-        self._first_time = True
+        self.widget = None
+        self.widgets = {key: None for key in self.brain.keys}
 
     def __call__(self, value):
         """Update the colorbar sliders."""
-        if self._first_time:
-            self._first_time = False
-            return
         self.brain._update_fscale(value)
-        for key in self.keys:
-            if self.reps[key] is not None:
-                self.reps[key].SetValue(self.brain._data[key])
-        if self.slider_rep is not None:
-            self.slider_rep.SetValue(1.0)
-        self.plotter.update()
+        for key in self.brain.keys:
+            if self.widgets[key] is not None:
+                self.widgets[key].set_value(self.brain._data[key])
+        if self.widget is not None:
+            self.widget.set_value(1.0)
 
 
 class BumpColorbarPoints(object):
     """Class that ensure constraints over the colorbar points."""
 
-    def __init__(self, plotter=None, brain=None, name=None):
-        self.plotter = plotter
+    def __init__(self, brain=None, name=None):
         self.brain = brain
         self.name = name
         self.callback = {
             "fmin": lambda fmin: brain.update_lut(fmin=fmin),
             "fmid": lambda fmid: brain.update_lut(fmid=fmid),
             "fmax": lambda fmax: brain.update_lut(fmax=fmax),
         }
-        self.keys = ('fmin', 'fmid', 'fmax')
-        self.reps = {key: None for key in self.keys}
+        self.widgets = {key: None for key in self.brain.keys}
         self.last_update = time.time()
-        self._first_time = True
 
     def __call__(self, value):
         """Update the colorbar sliders."""
-        if self._first_time:
-            self._first_time = False
-            return
-        vals = {key: self.brain._data[key] for key in self.keys}
-        if self.name == "fmin" and self.reps["fmin"] is not None:
+        vals = {key: self.brain._data[key] for key in self.brain.keys}
+        if self.name == "fmin" and self.widgets["fmin"] is not None:
             if vals['fmax'] < value:
                 vals['fmax'] = value
-                self.reps['fmax'].SetValue(value)
+                self.widgets['fmax'].set_value(value)
             if vals['fmid'] < value:
                 vals['fmid'] = value
-                self.reps['fmid'].SetValue(value)
-            self.reps['fmin'].SetValue(value)
-        elif self.name == "fmid" and self.reps['fmid'] is not None:
+                self.widgets['fmid'].set_value(value)
+            self.widgets['fmin'].set_value(value)
+        elif self.name == "fmid" and self.widgets['fmid'] is not None:
             if vals['fmin'] > value:
                 vals['fmin'] = value
-                self.reps['fmin'].SetValue(value)
+                self.widgets['fmin'].set_value(value)
             if vals['fmax'] < value:
                 vals['fmax'] = value
-                self.reps['fmax'].SetValue(value)
-            self.reps['fmid'].SetValue(value)
-        elif self.name == "fmax" and self.reps['fmax'] is not None:
+                self.widgets['fmax'].set_value(value)
+            self.widgets['fmid'].set_value(value)
+        elif self.name == "fmax" and self.widgets['fmax'] is not None:
             if vals['fmin'] > value:
                 vals['fmin'] = value
-                self.reps['fmin'].SetValue(value)
+                self.widgets['fmin'].set_value(value)
             if vals['fmid'] > value:
                 vals['fmid'] = value
-                self.reps['fmid'].SetValue(value)
-            self.reps['fmax'].SetValue(value)
+                self.widgets['fmid'].set_value(value)
+            self.widgets['fmax'].set_value(value)
+        self.brain.widgets[f'entry_{self.name}'].set_value(str(value))
         self.brain.update_lut(**vals)
         if time.time() > self.last_update + 1. / 60.:
             self.callback[self.name](value)
             self.last_update = time.time()
-        self.plotter.update()
 
 
 class ShowView(object):
     """Class that selects the correct view."""
 
-    def __init__(self, plotter=None, brain=None, orientation=None,
-                 row=None, col=None, hemi=None):
-        self.plotter = plotter
+    def __init__(self, brain=None, data=None):
         self.brain = brain
-        self.orientation = orientation
-        self.short_orientation = [s[:3] for s in orientation]
-        self.row = row
-        self.col = col
-        self.hemi = hemi
-        self.slider_rep = None
+        self.data = data
+        self.widget = None
 
     def __call__(self, value, update_widget=False):
         """Update the view."""
-        self.brain.show_view(value, row=self.row, col=self.col,
-                             hemi=self.hemi)
-        if update_widget:
-            if len(value) > 3:
-                idx = self.orientation.index(value)
-            else:
-                idx = self.short_orientation.index(value)
-            if self.slider_rep is not None:
-                self.slider_rep.SetValue(idx)
-                self.slider_rep.SetTitleText(self.orientation[idx])
-                self.plotter.update()
-
-
-class SmartSlider(object):
+        if "renderer" in self.brain.widgets:
+            idx = self.brain.widgets["renderer"].get_value()
+        else:
+            idx = 0
+        idx = int(idx)
+        if self.data[idx] is not None:
+            self.brain.show_view(
+                value,
+                row=self.data[idx]['row'],
+                col=self.data[idx]['col'],
+                hemi=self.data[idx]['hemi'],
+            )
+        if update_widget and self.widget is not None:
+            self.widget.set_value(value)
+
+
+class SmartCallBack(object):
     """Class to manage smart slider.
 
     It stores it's own slider representation for efficiency
     and uses it when necessary.
     """
 
-    def __init__(self, plotter=None, callback=None):
-        self.plotter = plotter
+    def __init__(self, callback=None):
         self.callback = callback
-        self.slider_rep = None
+        self.widget = None
 
     def __call__(self, value, update_widget=False):
         """Update the value."""
         self.callback(value)
-        if update_widget:
-            if self.slider_rep is not None:
-                self.slider_rep.SetValue(value)
-                self.plotter.update()
+        if self.widget is not None and update_widget:
+            self.widget.set_value(value)