itasc 0.2.0.dev0__py3-none-any.whl

itasc/napari/track_path_controller.py

@@ -0,0 +1,387 @@
+"""Single all-tracks overlay for the nucleus correction workflow.
+
+This owns one in-canvas napari ``Tracks`` layer that draws *every* track's
+trajectory through the per-frame nucleus centroids, plus a small "tip" Points
+layer that marks the focused track's position in the current frame with a cross.
+
+Two presentation states share the one tracks layer:
+
+* **overview** (nothing selected) — all tracks coloured by id, moderately
+  transparent;
+* **focus** (a cell selected) — the selected track recoloured bright
+  viridis-by-time while every other track fades to a faint translucent grey.
+
+The focus switch only rewrites the layer's ``properties``/``color_by`` (an
+O(track) write), never its geometry, so selecting cells stays cheap. The
+geometry is rebuilt (:meth:`refresh`) only when the label stack itself changes.
+
+The pure geometry/colour maths lives in
+:mod:`itasc.napari.correction._correction_track_path`; this controller is the
+layer-lifecycle glue.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+import numpy as np
+
+from itasc.napari.correction._correction_track_path import build_all_tracks_data
+from itasc.napari._track_render import _track_label_color_styling
+from itasc.napari.correction._correction_centroids import (
+    FOCUS_CROSS_COLOR,
+    NEUTRAL_OVERLAY_COLOR,
+)
+
+TRACK_LAYER = "[Correction] Nucleus tracks"
+TRACK_TIP_LAYER = "[Correction] Track Tip"
+TRACK_TAIL_WIDTH = 4
+# Trailing history shown behind the current frame, in frames. Short so the
+# overview reads as a comet around the current frame instead of the whole path.
+TRACK_TAIL_LENGTH = 15
+OVERVIEW_COLORMAP = "hsv"
+FOCUS_COLORMAP = "viridis"
+# The overview is drawn fully opaque in both view modes so the tracks read as
+# strongly as the labels they're coloured to match.
+OVERVIEW_OPACITY = 1.0
+FILLED_OVERVIEW_OPACITY = 1.0
+FOCUS_OPACITY = 1.0
+TIP_CROSS_SIZE = 5
+
+_NEUTRAL_TRACKS_COLORMAP = None
+
+
+def _neutral_tracks_colormap():
+    """A single-colour colormap so every track vertex reads :data:`NEUTRAL_OVERLAY_COLOR`.
+
+    A ``Tracks`` layer always colours by a property through a colormap; mapping
+    every value to one colour (two identical stops) yields a uniform neutral
+    overview regardless of ``color_by``. Built lazily and cached.
+    """
+    global _NEUTRAL_TRACKS_COLORMAP
+    if _NEUTRAL_TRACKS_COLORMAP is None:
+        from napari.utils.colormaps import Colormap
+
+        rgba = list(NEUTRAL_OVERLAY_COLOR)
+        _NEUTRAL_TRACKS_COLORMAP = Colormap([rgba, rgba], name="neutral_overview")
+    return _NEUTRAL_TRACKS_COLORMAP
+
+_CORRECTION_TRACKS_CLS = None
+
+
+def _correction_tracks_cls():
+    """A ``Tracks`` subclass whose temporal tail fade can be forced on/off.
+
+    napari's ``Tracks.use_fade`` is read-only (it fades whenever the time axis
+    is hidden, i.e. always in a T/Y/X viewer). We need the focused track to be
+    fully opaque end-to-end (``use_fade`` off → the shader pins every vertex's
+    alpha to 1.0) while the overview keeps its fading comet, so the layer carries
+    an override flag the controller toggles per focus state. Built lazily so the
+    module stays import-light. ``use_fade`` is read back by the vispy layer on
+    the appearance events (tail/head/color_by) the controller fires anyway.
+    """
+    global _CORRECTION_TRACKS_CLS
+    if _CORRECTION_TRACKS_CLS is None:
+        from napari.layers import Tracks
+
+        class _CorrectionTracks(Tracks):
+            def __init__(self, *args, **kwargs) -> None:
+                self._fade_override: bool | None = None
+                super().__init__(*args, **kwargs)
+
+            @property
+            def use_fade(self) -> bool:
+                if self._fade_override is not None:
+                    return self._fade_override
+                return 0 in self._slice_input.not_displayed
+
+            @use_fade.setter
+            def use_fade(self, value: bool | None) -> None:
+                self._fade_override = None if value is None else bool(value)
+
+        _CORRECTION_TRACKS_CLS = _CorrectionTracks
+    return _CORRECTION_TRACKS_CLS
+
+
+class AllTracksController:
+    """Own the single all-tracks layer and its current-frame tip cross."""
+
+    def __init__(
+        self,
+        viewer,
+        *,
+        tracked_layer_provider: Callable[[], object | None],
+        selected_label_provider: Callable[[], int],
+        enabled_provider: Callable[[], bool],
+        current_t_provider: Callable[[], int],
+        status_callback: Callable[[str], None],
+        owned_layers: set[str],
+    ) -> None:
+        self.viewer = viewer
+        self._tracked_layer_provider = tracked_layer_provider
+        self._selected_label_provider = selected_label_provider
+        self._enabled_provider = enabled_provider
+        self._current_t_provider = current_t_provider
+        self._status = status_callback
+        self._owned_layers = owned_layers
+        # Cached from the last refresh so focusing a track can slice its vertices
+        # out of the full data without rescanning the stack. All share one order.
+        self._data: np.ndarray = np.empty((0, 4), dtype=float)
+        self._properties: dict[str, np.ndarray] = {}
+        self._row_index: dict[int, np.ndarray] = {}
+        self._span: int = 1
+        # False = default outline view (neutral single colour, translucent);
+        # True = filled view (per-id hsv colour, opaque). Only changes the
+        # *overview* presentation — a focused track stays viridis-by-time.
+        self._filled_mode: bool = False
+
+    # ── lifecycle ──────────────────────────────────────────────────────────
+
+    def refresh(self) -> None:
+        """Rebuild the tracks layer from the current stack, then re-apply focus."""
+        if not self._enabled_provider():
+            self.clear()
+            return
+        layer = self._tracked_layer_provider()
+        if layer is None:
+            self.clear()
+            return
+        data = np.asarray(layer.data)
+        rows, properties, row_index = build_all_tracks_data(data)
+        # Per-vertex position in [0, 1] used to colour each track by its label
+        # colour (see _apply_overview_coloring). Colour-independent, so it is
+        # cached once with the geometry; the colormap is rebuilt per view mode.
+        styling = _track_label_color_styling(properties.get("track_id", []), {})
+        if styling is not None:
+            properties = {**properties, "label_pos": styling[1]}
+        self._data = rows
+        self._properties = properties
+        self._row_index = row_index
+        if len(rows) == 0:
+            self.clear()
+            return
+        self._span = max(int(data.shape[0]) if data.ndim == 3 else 1, 1)
+        self._ensure_layer()
+        self.set_focus(int(self._selected_label_provider() or 0))
+        self._status(f"Tracks: {len(row_index)} track(s).")
+
+    def clear(self) -> None:
+        """Remove the tracks + tip layers from the viewer."""
+        for name in (TRACK_LAYER, TRACK_TIP_LAYER):
+            if name in self.viewer.layers:
+                self.viewer.layers.remove(self.viewer.layers[name])
+            self._owned_layers.discard(name)
+        self._data = np.empty((0, 4), dtype=float)
+        self._properties = {}
+        self._row_index = {}
+
+    # ── view mode (outline-neutral ↔ filled-by-id overview) ───────────────────
+
+    def set_filled_mode(self, filled: bool) -> None:
+        """Switch the overview between neutral (outline view) and by-id (filled view).
+
+        Re-applies the current focus so the live layer picks up the new overview
+        colour/opacity; a focused single track is unaffected (still by time).
+        """
+        self._filled_mode = bool(filled)
+        if self._tracks_layer() is not None:
+            self.set_focus(int(self._selected_label_provider() or 0))
+
+    def _overview_opacity(self) -> float:
+        return FILLED_OVERVIEW_OPACITY if self._filled_mode else OVERVIEW_OPACITY
+
+    def _label_color_dict(self):
+        """The active labels layer's per-id colour dict, or None."""
+        layer = self._tracked_layer_provider()
+        raw = getattr(getattr(layer, "colormap", None), "color_dict", None)
+        return raw if isinstance(raw, Mapping) else None
+
+    def _apply_overview_coloring(self, layer) -> None:
+        """Colour the overview by mode: per-id label colours (filled) or one neutral colour.
+
+        A ``Tracks`` layer's ``colormap`` is a *registered name*, so custom
+        colours are supplied through ``colormaps_dict`` (keyed by the ``color_by``
+        property, which bypasses the name registry and the property
+        normalisation). Assigning ``color_by`` re-runs the recolour.
+
+        Filled mode colours each track to match its cell label by reproducing the
+        labels layer's colour dict through a step colormap over ``label_pos``
+        (same technique as the contact-analysis tracks). Outline mode keeps the
+        single neutral colour that matches the neutral label outlines.
+        """
+        styling = None
+        if self._filled_mode and "label_pos" in self._properties:
+            color_dict = self._label_color_dict()
+            if color_dict:
+                styling = _track_label_color_styling(
+                    self._properties["track_id"], color_dict
+                )
+        if styling is not None:
+            layer.colormaps_dict = {"label_pos": styling[0]}
+            layer.color_by = "label_pos"
+        else:
+            layer.colormaps_dict = {"track_id": _neutral_tracks_colormap()}
+            layer.color_by = "track_id"
+
+    # ── focus / current-frame presentation ───────────────────────────────────
+
+    def set_focus(self, lab: int) -> None:
+        """Switch the layer between the overview and a single focused track.
+
+        Focus mode draws *only* the selected track (the surrounding tracks are
+        dropped from the layer entirely — a Tracks layer has no per-track
+        visibility) coloured by time and fully opaque, image-like. ``lab == 0``
+        (or an absent track) restores the all-tracks overview and hides the tip
+        cross. A no-op when the tracks layer is not present (toggle off).
+        """
+        lab = int(lab or 0)
+        layer = self._tracks_layer()
+        if layer is None:
+            return
+        if not lab or lab not in self._row_index:
+            # Overview: every track, a short trailing comet that fades out behind
+            # the current frame (no forward head), all dimmed together. Park
+            # color_by on the always-present 'track_id' before the data swap so
+            # napari doesn't warn about the old key vanishing.
+            layer.use_fade = None  # default (fade on, scaled by tail_length)
+            layer.color_by = "track_id"
+            layer.data = self._data
+            layer.properties = self._properties
+            layer.color_by = "track_id"
+            self._apply_overview_coloring(layer)
+            layer.tail_length = min(TRACK_TAIL_LENGTH, self._span)
+            layer.head_length = 0
+            layer.opacity = self._overview_opacity()
+            self._hide_tip()
+            return
+
+        # Focus: keep only the selected track's vertices, coloured by its time
+        # gradient. use_fade off pins every vertex's alpha to 1.0 so the whole
+        # trajectory reads fully opaque (image-like) on every frame; set it before
+        # the tail/head/color_by writes the vispy layer reads use_fade back from.
+        rows = self._row_index[lab]
+        layer.use_fade = False
+        # Park color_by on 'track_id' (always present) across the data swap so
+        # napari doesn't warn about the previous key vanishing, then colour by time.
+        layer.color_by = "track_id"
+        layer.data = self._data[rows]
+        layer.properties = {
+            "track_id": self._properties["track_id"][rows],
+            "time": self._properties["time"][rows],
+        }
+        layer.color_by = "time"
+        try:
+            layer.colormap = FOCUS_COLORMAP
+        except Exception:
+            pass
+        layer.tail_length = self._span
+        layer.head_length = self._span
+        layer.opacity = FOCUS_OPACITY
+        self.set_current_frame(int(self._current_t_provider()))
+        self._restore_active_layer()
+
+    def set_current_frame(self, t: int) -> None:
+        """Move/show the tip cross at the focused track's centroid in frame ``t``."""
+        lab = int(self._selected_label_provider() or 0)
+        if not self._enabled_provider() or not lab:
+            self._hide_tip()
+            return
+        layer = self._tracked_layer_provider()
+        if layer is None:
+            self._hide_tip()
+            return
+        data = np.asarray(layer.data)
+        if data.ndim != 3 or not (0 <= int(t) < data.shape[0]):
+            self._hide_tip()
+            return
+        mask = data[int(t)] == lab
+        if not mask.any():
+            self._hide_tip()
+            return
+        ys, xs = np.nonzero(mask)
+        self._update_tip(np.asarray([[float(ys.mean()), float(xs.mean())]]))
+
+    def spotlight_mask(self, _t: int, lab: int, _default_mask):
+        """Widen the inner widget's spotlight to the selected track's whole union."""
+        if not self._enabled_provider() or not lab:
+            return None
+        layer = self._tracked_layer_provider()
+        if layer is None:
+            return None
+        data = np.asarray(layer.data)
+        if data.ndim != 3:
+            return None
+        union = np.any(data == int(lab), axis=0)
+        return union if union.any() else None
+
+    # ── layer plumbing ───────────────────────────────────────────────────────
+
+    def _tracks_layer(self):
+        from napari.layers import Tracks
+
+        if TRACK_LAYER in self.viewer.layers:
+            layer = self.viewer.layers[TRACK_LAYER]
+            if isinstance(layer, Tracks):
+                return layer
+        return None
+
+    def _ensure_layer(self) -> None:
+        """Create the tracks layer if absent; ``set_focus`` sets its data/colours.
+
+        Built from the cached full data with overview defaults so there's no
+        flash before the ``set_focus`` call that follows every refresh.
+        """
+        if self._tracks_layer() is not None:
+            return
+        if TRACK_LAYER in self.viewer.layers:
+            self.viewer.layers.remove(TRACK_LAYER)
+        # Build the fade-controllable Tracks subclass directly (rather than
+        # viewer.add_tracks, which always makes a plain Tracks) so focus mode can
+        # pin the focused track fully opaque.
+        layer = _correction_tracks_cls()(
+            self._data,
+            name=TRACK_LAYER,
+            properties=self._properties,
+            color_by="track_id",
+            colormap=OVERVIEW_COLORMAP,
+            tail_width=TRACK_TAIL_WIDTH,
+            tail_length=min(TRACK_TAIL_LENGTH, self._span),
+            head_length=0,
+            blending="translucent",
+            opacity=self._overview_opacity(),
+        )
+        self.viewer.add_layer(layer)
+        # Construction takes a registered colormap *name*; apply the mode's real
+        # overview colouring (the neutral colormaps_dict, etc.) now. The
+        # ``set_focus`` that follows ``refresh`` re-applies it for the live state.
+        self._apply_overview_coloring(layer)
+        self._owned_layers.add(TRACK_LAYER)
+        self._restore_active_layer()
+
+    def _update_tip(self, points: np.ndarray) -> None:
+        if TRACK_TIP_LAYER in self.viewer.layers:
+            layer = self.viewer.layers[TRACK_TIP_LAYER]
+            layer.data = points
+            layer.visible = True
+        else:
+            self.viewer.add_points(
+                points,
+                name=TRACK_TIP_LAYER,
+                ndim=2,
+                symbol="cross",
+                size=TIP_CROSS_SIZE,
+                face_color=[FOCUS_CROSS_COLOR],
+                border_color=[FOCUS_CROSS_COLOR],
+                opacity=1.0,
+            )
+        self._owned_layers.add(TRACK_TIP_LAYER)
+        self._restore_active_layer()
+
+    def _hide_tip(self) -> None:
+        if TRACK_TIP_LAYER in self.viewer.layers:
+            self.viewer.layers[TRACK_TIP_LAYER].visible = False
+
+    def _restore_active_layer(self) -> None:
+        try:
+            self.viewer.layers.selection.active = self._tracked_layer_provider()
+        except Exception:
+            pass

itasc/napari/ui_gate.py

@@ -0,0 +1,266 @@
+"""Application-wide UI gating for the ITASC napari plugin.
+
+Historically each widget rolled its own ``setEnabled`` logic from local
+booleans, and a handful of overlapping guards (the nucleus "viewer activity"
+guard, the main-widget position lock, per-widget running/preview flags) tried
+to coordinate without knowing about each other. The result was incoherent:
+config-load could move the position out from under an in-progress correction,
+harmless ⚙ params buttons got disabled, and the nucleus section was guarded
+while the cell section was not.
+
+``UiGate`` replaces all of that with a single source of truth. The one
+contended resource is **write/auto-update ownership of the viewer**: a
+correction session, the database browser, and every live preview are all
+*viewer owners*, and only one may be active at a time. Headless jobs (writing
+to disk only) run independently of ownership.
+
+Every gated control is registered once with a :class:`ControlClass`; on each
+state transition :meth:`UiGate.recompute` derives ``enabled`` (and a tooltip)
+for every control from a single policy table. Widgets never call ``setEnabled``
+on gated controls themselves — they call :meth:`claim_viewer`,
+:meth:`release_viewer`, :meth:`set_task`, or :meth:`recompute` and let the gate
+apply the policy.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+from qtpy.QtCore import QObject, Signal
+from qtpy.QtWidgets import QMessageBox, QWidget
+
+ReasonSource = str | Callable[[], str] | None
+
+
+class ControlClass(Enum):
+    """How a control relates to viewer ownership and the data context.
+
+    The class — not the widget it lives in — determines when a control is
+    enabled. See the policy table in :meth:`UiGate._enabled_for`.
+    """
+
+    #: A checkable control that *enters* an exclusive viewer-owner state
+    #: (correction, db-browser, a live preview). Mutually exclusive: enabled
+    #: only when nothing else owns the viewer, or this control owns it.
+    VIEWER_OWNER = auto()
+
+    #: Launches a job that mutates state an active viewer owner depends on
+    #: (live previews, pipeline rebuilds of the data being viewed). Blocked
+    #: while any viewer owner is active.
+    RUN_VIEWER = auto()
+
+    #: Launches a disk-only job that no active owner is viewing. Independent of
+    #: viewer ownership; gated only by its own ``when`` predicate.
+    RUN_HEADLESS = auto()
+
+    #: Swaps the underlying data (position, project directory, Load Config).
+    #: Always *enabled*; the danger is guarded at click time via
+    #: :meth:`UiGate.confirm_context_change`, which offers to exit the owner
+    #: first.
+    CONTEXT_CHANGING = auto()
+
+    #: No viewer/context side effect (⚙ params dialogs, Save Config, param
+    #: spinboxes). Always enabled.
+    HARMLESS = auto()
+
+    #: Only meaningful inside one owner (correction cleanup/outline/goto).
+    #: Enabled only while that owner is active and its ``when`` holds.
+    MODE_LOCAL = auto()
+
+
+@dataclass
+class _Registration:
+    control: object
+    klass: ControlClass
+    owner_token: str | None = None
+    when: Callable[[], bool] | None = None
+    reason: ReasonSource = None
+
+
+@dataclass
+class _Owner:
+    label: str
+    exit_fn: Callable[[], None]
+
+
+@dataclass
+class _GateState:
+    owner: str | None = None
+    tasks: set[str] = field(default_factory=set)
+    owners: dict[str, _Owner] = field(default_factory=dict)
+
+
+class UiGate(QObject):
+    """Single source of truth for control enablement across the plugin."""
+
+    changed = Signal()
+
+    def __init__(self, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self._state = _GateState()
+        self._registrations: list[_Registration] = []
+        self._gated_disabled: set[int] = set()
+        self._idle_tooltips: dict[int, str] = {}
+        #: Overridable in tests; returns True if the user confirms exiting the
+        #: active owner. Defaults to a modal yes/no dialog.
+        self.confirm_handler: Callable[[QWidget | None, str], bool] = (
+            self._default_confirm
+        )
+
+    # ── Registration ──────────────────────────────────────────────────────
+    def register(
+        self,
+        control,
+        klass: ControlClass,
+        *,
+        owner_token: str | None = None,
+        when: Callable[[], bool] | None = None,
+        reason: ReasonSource = None,
+    ) -> None:
+        """Register *control* under *klass*.
+
+        ``owner_token`` ties a ``VIEWER_OWNER``/``MODE_LOCAL`` control to a
+        viewer-owner token. ``when`` is an optional zero-arg predicate for
+        additional readiness (e.g. inputs present, stage not running);
+        ``reason`` is the tooltip shown while the control is gate-disabled.
+        """
+        self._registrations.append(
+            _Registration(control, klass, owner_token, when, reason)
+        )
+
+    def register_owner(
+        self, token: str, label: str, exit_fn: Callable[[], None]
+    ) -> None:
+        """Describe a viewer-owner token: a human label and how to leave it."""
+        self._state.owners[token] = _Owner(label, exit_fn)
+
+    # ── State transitions ─────────────────────────────────────────────────
+    @property
+    def owner(self) -> str | None:
+        return self._state.owner
+
+    def owner_label(self) -> str | None:
+        """Human label of the active viewer owner, or ``None`` when idle."""
+        owner = self._state.owner
+        info = self._state.owners.get(owner) if owner else None
+        return info.label if info else None
+
+    def claim_viewer(self, token: str) -> None:
+        """Mark *token* as the active viewer owner and recompute."""
+        if self._state.owner == token:
+            return
+        self._state.owner = token
+        self.recompute()
+
+    def release_viewer(self, token: str) -> None:
+        """Clear ownership if *token* currently owns the viewer."""
+        if self._state.owner != token:
+            return
+        self._state.owner = None
+        self.recompute()
+
+    def set_task(self, token: str, running: bool) -> None:
+        """Track a running job (headless or viewer-writing) and recompute."""
+        before = len(self._state.tasks)
+        if running:
+            self._state.tasks.add(token)
+        else:
+            self._state.tasks.discard(token)
+        if len(self._state.tasks) != before or running:
+            self.recompute()
+
+    # ── Context-change guard ──────────────────────────────────────────────
+    def can_change_context(self) -> bool:
+        """True when no viewer owner is active, so a context change is safe."""
+        return self._state.owner is None
+
+    def confirm_context_change(
+        self, parent, action: Callable[[], None]
+    ) -> bool:
+        """Run *action*, first offering to exit the active owner if any.
+
+        Returns ``True`` if *action* ran, ``False`` if the user declined.
+        """
+        owner = self._state.owner
+        if owner is None:
+            action()
+            return True
+        info = self._state.owners.get(owner)
+        label = info.label if info else "the current mode"
+        if not self.confirm_handler(parent, label):
+            return False
+        if info is not None:
+            info.exit_fn()
+        action()
+        return True
+
+    @staticmethod
+    def _default_confirm(parent, label: str) -> bool:
+        reply = QMessageBox.question(
+            parent,
+            f"Exit {label}?",
+            f"This will exit {label}. Continue?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No,
+        )
+        return reply == QMessageBox.Yes
+
+    # ── Policy ────────────────────────────────────────────────────────────
+    def _predicate(self, reg: _Registration) -> bool:
+        if reg.when is None:
+            return True
+        try:
+            return bool(reg.when())
+        except Exception:
+            return True
+
+    def _enabled_for(self, reg: _Registration) -> bool:
+        owner = self._state.owner
+        klass = reg.klass
+        if klass is ControlClass.HARMLESS or klass is ControlClass.CONTEXT_CHANGING:
+            return True
+        if klass is ControlClass.VIEWER_OWNER:
+            return (owner is None or owner == reg.owner_token) and self._predicate(reg)
+        if klass is ControlClass.RUN_VIEWER:
+            return owner is None and self._predicate(reg)
+        if klass is ControlClass.RUN_HEADLESS:
+            return self._predicate(reg)
+        if klass is ControlClass.MODE_LOCAL:
+            return owner == reg.owner_token and self._predicate(reg)
+        return True
+
+    def _reason_text(self, reg: _Registration) -> str:
+        if callable(reg.reason):
+            try:
+                return reg.reason()
+            except Exception:
+                pass
+        elif isinstance(reg.reason, str):
+            return reg.reason
+        owner = self._state.owner
+        info = self._state.owners.get(owner) if owner else None
+        if info is not None:
+            if reg.klass is ControlClass.VIEWER_OWNER:
+                return f"Exit {info.label} first."
+            return f"Unavailable while {info.label} is active."
+        return "Currently unavailable."
+
+    def recompute(self) -> None:
+        """Apply the policy to every registered control."""
+        for reg in self._registrations:
+            control = reg.control
+            key = id(control)
+            enabled = self._enabled_for(reg)
+            if enabled:
+                control.setEnabled(True)
+                if key in self._gated_disabled:
+                    control.setToolTip(self._idle_tooltips.pop(key, control.toolTip()))
+                    self._gated_disabled.discard(key)
+            else:
+                if key not in self._gated_disabled:
+                    self._idle_tooltips[key] = control.toolTip()
+                    self._gated_disabled.add(key)
+                control.setEnabled(False)
+                control.setToolTip(self._reason_text(reg))
+        self.changed.emit()