Stack

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
use "collections"

actor Stack is CompositeWidget
  """
  A container that holds multiple named children but only renders the
  active one. Used for tabbed interfaces where switching between views
  should preserve child state.
  """
  let _state: WidgetState
  let _children_by_name: Map[String val, Widget tag]
  let _children_order: Array[(String val, Widget tag)]
  var _active_name: (String val | None) = None
  var _input_actor: (InputActor tag | None) = None

  new create(p: WidgetParent tag) =>
    _state = WidgetState(p)
    _children_by_name = Map[String val, Widget tag]
    _children_order = Array[(String val, Widget tag)]

  fun ref state(): WidgetState => _state

  be set_input_actor(input: InputActor tag) =>
    """
    Store a reference to the InputActor for focus scope gating.
    """
    _input_actor = input

  be add_child(name: String val, widget: Widget tag) =>
    """
    Register a child by name. The first child added becomes active.
    If the Stack already has dimensions, the child is resized immediately.
    Non-active children have their scope disabled if input_actor is set.
    """
    _children_by_name(name) = widget
    _children_order.push((name, widget))
    register_child(widget)

    if _active_name is None then
      _active_name = name
    else
      // Non-active child: disable its scope for focus gating
      match _input_actor
      | let ia: InputActor tag => ia.disable_scope(widget)
      end
    end

    // If already sized, resize the child to fill
    if (_state.width > 0) or (_state.height > 0) then
      widget.resize(_state.width, _state.height)
    end

  be show(name: String val) =>
    """
    Switch the active child. No-op if the name doesn't exist or is
    already active.
    """
    // Check if name exists
    if not _children_by_name.contains(name) then return end

    // Check if already active
    match _active_name
    | let current: String val if current == name => return
    end

    // Disable old scope, enable new scope
    match _input_actor
    | let ia: InputActor tag =>
      // Disable old active child's scope
      match _active_name
      | let old_name: String val =>
        try
          let old_widget = _children_by_name(old_name)?
          ia.disable_scope(old_widget)
        end
      end
      // Enable new child's scope
      try
        let new_widget = _children_by_name(name)?
        ia.enable_scope(new_widget)
      end
    end

    _active_name = name
    // Re-render with the new active child
    render_and_send()

  be receive_grid(widget: Any tag, grid: Grid) =>
    """
    Store all children's grids, but only trigger a deferred render if
    the grid came from the active child.
    """
    let s = _state
    for i in Range(0, s.child_grids.size()) do
      try
        (let w, _) = s.child_grids(i)?
        if w is widget then
          s.child_grids(i)? = (w, grid)
          if _is_active_widget(widget) then
            if not s.dirty then
              s.dirty = true
              _deferred_render()
            end
          end
          return
        end
      end
    end

  be resize(w: USize, h: USize) =>
    """
    Resize ALL children to full container size, not just the active one.
    """
    _state.width = w
    _state.height = h
    for child in _state.child_grids.values() do
      (let cw, _) = child
      match cw
      | let r: Widget tag => r.resize(w, h)
      end
    end
    render_and_send()

  fun ref render(): Grid =>
    """
    Return the active child's grid directly. If no active child,
    return the background.
    """
    match _active_name
    | let name: String val =>
      try
        let widget = _children_by_name(name)?
        for entry in _state.child_grids.values() do
          (let w, let grid) = entry
          if w is widget then
            return grid
          end
        end
      end
    end
    render_background()

  be _register_focusable(widget: Widget tag, scope: Widget tag) =>
    """
    Package-private. Register a focusable widget with the InputActor, using
    the given scope (a direct child of this Stack). Called by UIBuilder so
    that register_focusable and disable_scope both go through this actor,
    guaranteeing causal ordering on the InputActor.
    """
    match _input_actor
    | let ia: InputActor tag =>
      ia.register_focusable(widget, scope)
    end

  be _flush(cb: {()} val) =>
    """
    Package-private. Calls cb after all previously queued behaviors on this
    actor have been processed. Used by tests to establish causal ordering
    between add_child (which sends disable_scope) and a subsequent query.
    """
    cb()

  fun ref _is_active_widget(widget: Any tag): Bool =>
    """
    Check if the given widget is the currently active child.
    """
    match _active_name
    | let name: String val =>
      try
        let active = _children_by_name(name)?
        active is widget
      else
        false
      end
    else
      false
    end