Add support for {enabled/visible}_when for Tabbed and VFold

traitsui/qt4/ui_panel.py

@@ -28,8 +28,7 @@
 
 from pyface.qt import QtCore, QtGui
 
-from traits.api import Any, HasPrivateTraits, Instance, Undefined
-from traits.observation.api import match
+from traits.api import Any, HasPrivateTraits, Instance, List, Undefined
 
 from traitsui.api import Group
 
@@ -293,7 +292,14 @@ def panel(ui):
     return panel
 
 
-def _fill_panel(panel, content, ui, item_handler=None):
+def _fill_panel(
+    panel,
+    content,
+    ui,
+    item_handler=None,
+    _visible_when_groups=None,
+    _enabled_when_groups=None
+):
     """Fill a page based container panel with content.
     """
     active = 0
@@ -306,7 +312,6 @@ def _fill_panel(panel, content, ui, item_handler=None):
         if isinstance(item, Group):
             if item.selected:
                 active = index
-
             gp = _GroupPanel(item, ui, suppress_label=True)
             page = gp.control
             sub_page = gp.sub_control
@@ -337,9 +342,14 @@ def _fill_panel(panel, content, ui, item_handler=None):
 
         # Add the content.
         if isinstance(panel, QtGui.QTabWidget):
-            panel.addTab(new, page_name)
+            idx = panel.addTab(new, page_name)
         else:
-            panel.addItem(new, page_name)
+            idx = panel.addItem(new, page_name)
+
+        if item.visible_when and (_visible_when_groups is not None):
+            _visible_when_groups.append((item.visible_when, idx, new, page_name))
+        if item.enabled_when and (_enabled_when_groups is not None):
+            _enabled_when_groups.append((item.enabled_when, idx, new, page_name))
 
     panel.setCurrentIndex(active)
 
@@ -582,16 +592,30 @@ def __init__(self, group, ui, suppress_label=False):
             policy.setHorizontalStretch(50)
             policy.setVerticalStretch(50)
             sub.setSizePolicy(policy)
-
-            _fill_panel(sub, content, self.ui, self._add_page_item)
+            _visible_when_groups = []
+            _enabled_when_groups = []
+            _fill_panel(
+                sub,
+                content,
+                self.ui,
+                self._add_page_item,
+                _visible_when_groups,
+                _enabled_when_groups
+            )
 
             if outer is None:
                 outer = sub
             else:
                 inner.addWidget(sub)
 
             # Create an editor.
-            editor = TabbedFoldGroupEditor(container=sub, control=outer, ui=ui)
+            editor = TabbedFoldGroupEditor(
+                container=sub,
+                control=outer,
+                ui=ui,
+                _visible_when_groups=_visible_when_groups,
+                _enabled_when_groups=_enabled_when_groups
+            )
             self._setup_editor(group, editor)
 
         else:
@@ -1300,6 +1324,95 @@ class TabbedFoldGroupEditor(GroupEditor):
 
     #: The QTabWidget or QToolBox for the group
     container = Any()
+
+    _visible_when_groups = List()
+    _enabled_when_groups = List()
+
+    def __init__(self, **traits):
+        """ Initialise the object.
+        """
+        super().__init__(**traits)
+        num_enabled_or_visible_whens = len(self._visible_when_groups) \
+                                       + len(self._enabled_when_groups)
+        if num_enabled_or_visible_whens > 0:
+            for object in self.ui.context.values():
+                object.on_trait_change(
+                    lambda: self._when(), dispatch="ui"
+                )
+            self._when()
+
+    def _when(self):
+        """Set the visible and enabled states of all tabs in the editor as
+        controlled by a 'visible_when' or 'enabled_when' expression.
+        """
+        self._evaluate_enabled_condition(self._enabled_when_groups)
+        self._evaluate_visible_condition(self._visible_when_groups)
+
+    def _evaluate_enabled_condition(self, conditions):
+        """Evaluates a list of (eval, widget) pairs and calls the
+        appropriate method on the widget to toggle whether it is
+        enabled as needed.
+        """
+        context = self.ui._get_context(self.ui.context)
+
+        if isinstance(self.container, QtGui.QTabWidget):
+            method_to_call_name = "setTabEnabled"
+        elif isinstance(self.container, QtGui.QToolBox):
+            method_to_call_name = "setItemEnabled"
+        else:
+            raise
+
+        for when, widget, idx in conditions:
+            method_to_call = getattr(self.container, method_to_call_name)
+            try:
+                cond_value = eval(when, globals(), context)
+                method_to_call(idx, cond_value)
+            except Exception:
+                # catch errors in the validate_when expression
+                from traitsui.api import raise_to_debug
+
+                raise_to_debug()
+
+    def _evaluate_visible_condition(self, conditions):
+        """Evaluates a list of (eval, widget) pairs and calls the
+        appropriate method on the tab widget to toggle whether it is
+        visible as needed.
+        """
+        context = self.ui._get_context(self.ui.context)
+
+        if isinstance(self.container, QtGui.QTabWidget):
+            tab_or_item = "Tab"
+        elif isinstance(self.container, QtGui.QToolBox):
+            tab_or_item = "Item"
+        else:
+            raise
+
+        for when, idx, widget, label in conditions:
+
+            try:
+                cond_value = eval(when, globals(), context)
+                if cond_value:
+                    method_to_call_name = "insert" + tab_or_item
+                    method_to_call = getattr(
+                        self.container, method_to_call_name
+                    )
+                    # check that the tab for this widget is not already showing
+                    if self.container.indexOf(widget) == -1:
+                        method_to_call(idx, widget, label)
+                else:
+                    method_to_call_name = "remove" + tab_or_item
+                    method_to_call = getattr(
+                        self.container, method_to_call_name
+                    )
+                    # check that the tab for this widget is already showing
+                    if self.container.indexOf(widget) != -1:
+                        method_to_call(idx)
+            except Exception:
+                # catch errors in the validate_when expression
+                from traitsui.api import raise_to_debug
+
+                raise_to_debug()
+
 
     # -- UI preference save/restore interface ---------------------------------