zaniah 0.3.0 → 0.5.0

data/lib/zaniah/accessibility/tree.rb

@@ -3,20 +3,28 @@
 module Zaniah
   module Accessibility
     Change = Data.define(:kind, :path, :before, :after)
+    Event = Data.define(:kind, :id, :path, :node)
 
     class Tree
-      attr_reader :root, :changes, :revision
+      attr_reader :root, :changes, :events, :revision
 
       def initialize
-        @root, @changes, @revision = nil, [], 0
+        @root, @changes, @events, @revision = nil, [], [], 0
       end
 
       def update(renderable, context, overlays: [])
+        @next_action_owners = {}
         nodes = [renderable, *overlays].filter_map { |item| semantic(item, context) }
         next_root = nodes.length == 1 ? nodes.first : nodes.empty? ? nil : Accessibility.node(role: :group, label: "Application", children: nodes)
+        validate_ids(next_root) if next_root
         @changes = diff(@root, next_root).freeze
-        return false if @changes.empty?
+        @events = events_for(@changes).freeze
+        if @changes.empty?
+          @action_owners = previous_action_owners(@root, next_root)
+          return false
+        end
         @root = next_root
+        @action_owners = @next_action_owners
         @revision += 1
         true
       end
@@ -28,12 +36,25 @@ module Zaniah
 
       def find(&predicate) = each.find { |node, _path| predicate.call(node) }&.first
 
+      def perform(node, action)
+        owner = @action_owners&.[](node.object_id)
+        owner&.accessibility_action(node, action)
+      end
+
+      def assign(node, value)
+        owner = @action_owners&.[](node.object_id)
+        owner&.accessibility_value(node, value) if owner&.respond_to?(:accessibility_value)
+      end
+
       private
 
       def semantic(renderable, context)
         return unless renderable
         node = renderable.accessibility_node(context) if renderable.respond_to?(:accessibility_node)
-        return node if node.is_a?(Node)
+        if node.is_a?(Node)
+          register_actions(node, renderable) if renderable.respond_to?(:accessibility_action)
+          return node
+        end
         children = renderable.respond_to?(:children) ? renderable.children : []
         nodes = children.filter_map { |child| semantic(child, context) }
         Accessibility.node(role: :group, children: nodes) unless nodes.empty?
@@ -46,12 +67,97 @@ module Zaniah
         if before.with(children: []) != after.with(children: [])
           changes << Change.new(kind: :updated, path: path.freeze, before: before, after: after)
         end
-        [before.children.length, after.children.length].max.times do |index|
-          changes.concat(diff(before.children[index], after.children[index], path + [index]))
+
+        before_ids = indexed_ids(before.children)
+        matched = {}
+        pairs = after.children.map.with_index do |child, after_index|
+          before_index = child.id.nil? ? after_index : before_ids[child.id]
+          before_child = before.children[before_index] if before_index && !matched[before_index]
+          before_child = nil if child.id.nil? && before_child && !before_child.id.nil?
+          matched[before_index] = true if before_child
+          [child, after_index, before_child, before_index]
+        end
+        before.children.each_with_index do |child, index|
+          changes.concat(diff(child, nil, path + [index])) unless matched[index]
+        end
+        pairs.each do |child, after_index, before_child, before_index|
+          unless before_child
+            changes.concat(diff(nil, child, path + [after_index]))
+            next
+          end
+          if !child.id.nil? && before_index != after_index
+            changes << Change.new(kind: :moved, path: (path + [after_index]).freeze,
+              before: before_child, after: child)
+          end
+          changes.concat(diff(before_child, child, path + [after_index]))
         end
         changes
       end
 
+      def indexed_ids(children)
+        children.each_with_index.each_with_object({}) do |(child, index), result|
+          result[child.id] = index unless child.id.nil?
+        end
+      end
+
+      def events_for(changes)
+        changes.flat_map do |change|
+          node = change.after || change.before
+          path = change.path
+          id = node.id.nil? ? path : node.id
+          events = [Event.new(kind: {added: :structure, removed: :structure, updated: :property, moved: :layout}.fetch(change.kind),
+            id: id, path: path, node: node)]
+          special_nodes(change).each do |after, before, special_path|
+            special_id = after.id.nil? ? special_path : after.id
+            if after.states[:focused] && !before&.states&.[](:focused)
+              events << Event.new(kind: :focus, id: special_id, path: special_path, node: after)
+            end
+            if after.states[:live] && live_changed?(change.with(path: special_path, before: before, after: after))
+              events << Event.new(kind: :announcement, id: special_id, path: special_path, node: after)
+            end
+          end
+          events
+        end
+      end
+
+      def special_nodes(change)
+        return [] unless change.after
+        return [] if change.kind == :moved
+        return [[change.after, change.before, change.path]] unless change.kind == :added && change.after
+        nodes = []
+        walk(change.after, change.path) { |node, path| nodes << [node, nil, path] }
+        nodes
+      end
+
+      def live_changed?(change)
+        !change.before || change.before.label != change.after.label || change.before.value != change.after.value ||
+          change.before.states[:revision] != change.after.states[:revision]
+      end
+
+      def register_actions(node, owner)
+        @next_action_owners[node.object_id] = owner unless node.actions.empty?
+        node.children.each { |child| register_actions(child, owner) }
+      end
+
+      def validate_ids(node)
+        ids = node.children.map(&:id).reject(&:nil?)
+        raise ArgumentError, "accessibility ids must be unique among siblings" unless ids.uniq.length == ids.length
+        node.children.each { |child| validate_ids(child) }
+      end
+
+      def previous_action_owners(before, after)
+        owners = {}
+        return owners unless before && after
+        pending = [[before, after]]
+        until pending.empty?
+          previous, current = pending.pop
+          owner = @next_action_owners[current.object_id]
+          owners[previous.object_id] = owner if owner
+          previous.children.zip(current.children) { |pair| pending << pair }
+        end
+        owners
+      end
+
       def walk(node, path = [], &block)
         yield node, path.freeze
         node.children.each_with_index { |child, index| walk(child, path + [index], &block) }

data/lib/zaniah/accessibility/windows/provider.rb

@@ -20,7 +20,8 @@ module Zaniah
           simple: "d6dd68d1-86fd-4332-8666-9abedea2d24c",
           fragment: "f7063da8-8359-439c-9297-bbc5299a7d87",
           root: "620ce2a5-ab8f-40a9-86cb-de3c75599b58",
-          invoke: "54fcb24b-e18e-47a2-b4d3-eccbe77599a2"
+          invoke: "54fcb24b-e18e-47a2-b4d3-eccbe77599a2",
+          range: "36dc7aef-33e6-4691-afe1-2be7274b3d33"
         }.transform_values { |value| first, second, third, fourth, fifth = value.split("-"); [first.hex, second.hex, third.hex].pack("Vvv") + [fourth + fifth].pack("H*") }.freeze
 
         CONTROL_TYPES = {
@@ -42,16 +43,27 @@ module Zaniah
           end
 
           def update(root)
-            @tree = NativeTree.new(root)
+            @tree = NativeTree.new(root, previous: @tree)
             @tree.each do |entry|
-              (@providers[entry.path] ||= Element.new(self, entry.path)).entry = entry
+              provider = @providers[entry.runtime_id] ||= Element.new(self)
+              provider.entry = entry
             end
-            @root_provider = @providers[@tree.root.path]
+            @root_provider = @providers[@tree.root.runtime_id]
           end
 
-          def provider(entry) = entry && @providers[entry.path]
+          def provider(entry) = entry && @providers[entry.runtime_id]
           def entry(path) = @tree[path]
 
+          def raise_events(events)
+            events.each do |event|
+              provider = %i[structure layout].include?(event.kind) ? @root_provider : provider(@tree[event.path]) || @root_provider
+              id = Windows::AUTOMATION_EVENTS[event.kind]
+              core.fn(:UiaRaiseAutomationEvent, [P, I], I).call(provider.pointer(:simple), id) if id
+            end
+          rescue Fiddle::DLError
+            nil
+          end
+
           def screen_bounds(entry)
             bounds = @tree.bounds(entry)
             point = [(bounds.x * scale).round, (bounds.y * scale).round].pack("l2")
@@ -127,7 +139,15 @@ module Zaniah
               root = unknown + [closure(I, [P, Fiddle::TYPE_DOUBLE, Fiddle::TYPE_DOUBLE, P]) { |this, x, y, output| interface(this).from_point(x, y, output) },
                 closure(I, [P, P]) { |this, output| interface(this).focus(output) }]
               invoke = unknown + [closure(I, [P]) { |this| interface(this).invoke }]
-              @vtables = {simple: vtable(simple), fragment: vtable(fragment), root: vtable(root), invoke: vtable(invoke)}.freeze
+              range = unknown + [closure(I, [P, Fiddle::TYPE_DOUBLE]) { |this, value| interface(this).set_range_value(value) },
+                closure(I, [P, P]) { |this, output| interface(this).range_property(:value, output) },
+                closure(I, [P, P]) { |this, output| interface(this).range_property(:readonly, output) },
+                closure(I, [P, P]) { |this, output| interface(this).range_property(:maximum, output) },
+                closure(I, [P, P]) { |this, output| interface(this).range_property(:minimum, output) },
+                closure(I, [P, P]) { |this, output| interface(this).range_property(:large_change, output) },
+                closure(I, [P, P]) { |this, output| interface(this).range_property(:small_change, output) }]
+              @vtables = {simple: vtable(simple), fragment: vtable(fragment), root: vtable(root),
+                invoke: vtable(invoke), range: vtable(range)}.freeze
             end
 
             def closure(result, arguments, &block)
@@ -154,10 +174,10 @@ module Zaniah
           attr_accessor :entry
           attr_reader :bridge
 
-          def initialize(bridge, path)
+          def initialize(bridge)
             self.class.install
-            @bridge, @path, @references, @interfaces = bridge, path, 1, {}
-            %i[simple fragment root invoke].each do |kind|
+            @bridge, @references, @interfaces = bridge, 1, {}
+            %i[simple fragment root invoke range].each do |kind|
               pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
               pointer[0, Fiddle::SIZEOF_VOIDP] = [self.class.vtables.fetch(kind).to_i].pack("J")
               @interfaces[kind] = pointer
@@ -170,7 +190,8 @@ module Zaniah
           def query(iid, output)
             requested = GUIDS.key(Fiddle::Pointer.new(iid)[0, 16])
             requested = :simple if requested == :unknown
-            supported = requested && (requested != :root || @entry.parent.nil?) && (requested != :invoke || invokable?)
+            supported = requested && (requested != :root || @entry.parent.nil?) &&
+              (requested != :invoke || invokable?) && (requested != :range || range?)
             return self.class.write_pointer(output, 0) && E_NOINTERFACE unless supported
             add_ref
             self.class.write_pointer(output, pointer(requested))
@@ -180,9 +201,10 @@ module Zaniah
           def release = (@references = [@references - 1, 1].max)
 
           def pattern(pattern, output)
-            return self.class.write_pointer(output, 0) unless pattern == 10_000 && invokable?
+            kind = pattern == 10_000 && invokable? ? :invoke : pattern == 10_003 && range? ? :range : nil
+            return self.class.write_pointer(output, 0) unless kind
             add_ref
-            self.class.write_pointer(output, pointer(:invoke))
+            self.class.write_pointer(output, pointer(kind))
           end
 
           def property(property, output)
@@ -194,6 +216,9 @@ module Zaniah
             when 30_008 then variant_bool(variant, @bridge.focused_provider.equal?(self))
             when 30_009 then variant_bool(variant, focusable?)
             when 30_010 then variant_bool(variant, !@entry.node.states[:disabled])
+            when 30_011
+              id = @entry.node.id
+              variant_bstr(variant, id.nil? ? @entry.runtime_id : id)
             when 30_012 then variant_bstr(variant, "Zaniah")
             when 30_016, 30_017 then variant_bool(variant, true)
             when 30_022 then variant_bool(variant, @bridge.tree.bounds(@entry).empty?)
@@ -254,14 +279,31 @@ module Zaniah
           end
 
           def invoke
-            action = %i[press toggle select sort expand collapse dismiss].find { |candidate| @entry.node.actions.include?(candidate) }
-            Accessibility.perform(@bridge.window, @entry.node, action, bounds: @bridge.tree.bounds(@entry))
+            actions = @entry.node.role == :treeitem ? %i[select collapse expand] : %i[press toggle select sort expand collapse dismiss]
+            action = actions.find { |candidate| @entry.node.actions.include?(candidate) }
+            Accessibility.perform(@bridge.window, @entry.node, action, bounds: @bridge.tree.bounds(@entry)) if action
+            S_OK
+          end
+
+          def set_range_value(value)
+            Accessibility.assign(@bridge.window, @entry.node, value) ? S_OK : E_FAIL
+          end
+
+          def range_property(name, output)
+            values = {value: @entry.node.value, readonly: 0, maximum: @entry.node.states.fetch(:maximum, 1.0),
+              minimum: @entry.node.states.fetch(:minimum, 0.0), large_change: @entry.node.states.fetch(:large_change, 0.1),
+              small_change: @entry.node.states.fetch(:small_change, 0.01)}
+            pointer = Fiddle::Pointer.new(output)
+            name == :readonly ? pointer[0, 4] = [values[name]].pack("l") : pointer[0, 8] = [Float(values[name])].pack("d")
             S_OK
           end
 
           private
 
           def invokable? = @entry.node.actions.any? { |action| %i[press toggle select sort expand collapse dismiss].include?(action) }
+          def range? = @entry.node.value.is_a?(Numeric) &&
+            @entry.node.states.key?(:minimum) && @entry.node.states.key?(:maximum) &&
+            (@entry.node.actions & %i[increment decrement]).any?
           def focusable? = !@entry.node.states[:disabled] && (!@entry.node.actions.empty? || %i[textbox searchbox slider combobox].include?(@entry.node.role))
           def variant_i4(pointer, value) = (pointer[0, 2] = [3].pack("v"); pointer[8, 4] = [value].pack("l"))
           def variant_bool(pointer, value) = (pointer[0, 2] = [11].pack("v"); pointer[8, 2] = [value ? -1 : 0].pack("s"))

data/lib/zaniah/accessibility/windows.rb

@@ -6,6 +6,8 @@ module Zaniah
   module Accessibility
     module Windows
       EVENT_OBJECT_REORDER = 0x8004
+      AUTOMATION_EVENTS = {structure: 20_002, property: 20_004, focus: 20_005,
+        layout: 20_008, announcement: 20_024}.freeze
       OBJID_CLIENT = -4
       CHILDID_SELF = 0
 
@@ -15,6 +17,7 @@ module Zaniah
         return unless root && window.respond_to?(:handle)
         bridge = bridges[window.handle.to_i] ||= Provider::Bridge.new(window)
         bridge.update(root)
+        bridge.raise_events(window.accessibility_tree.events)
         user = window.instance_variable_get(:@user)
         return unless user
         user.fn(:NotifyWinEvent,
@@ -32,6 +35,7 @@ module Zaniah
       end
 
       def close(window) = bridges.delete(window.handle.to_i)
+      def event_ids(events) = events.filter_map { |event| AUTOMATION_EVENTS[event.kind] }
       def bridges = (@bridges ||= {})
     end
   end

data/lib/zaniah/accessibility.rb

@@ -35,6 +35,8 @@ module Zaniah
 
     def perform(window, node, action, bounds: node&.bounds)
       return false unless node && node.actions.include?(action)
+      direct = window.accessibility_tree.perform(node, action) if window.respond_to?(:accessibility_tree)
+      return !!direct unless direct.nil?
       if action == :dismiss
         window.input(Input::KeyDown.new("esc", false))
         return true
@@ -51,6 +53,11 @@ module Zaniah
       true
     end
 
+    def assign(window, node, value)
+      return false unless node && window.respond_to?(:accessibility_tree)
+      !!window.accessibility_tree.assign(node, value)
+    end
+
     def focus_at(window, position)
       hit = window.dispatcher.hits.reverse.find { |candidate| candidate.bounds&.contains?(position) }
       owner = hit&.owner

data/lib/zaniah/drag_drop.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module DragDrop
+    Target = Data.define(:id, :position)
+    Event = Data.define(:phase, :source_id, :target, :point, :reason)
+
+    class Reorder
+      POSITIONS = %i[before after inside].freeze
+
+      attr_reader :source_id, :target, :announcement
+
+      def initialize(threshold: 4, locate:, keyboard: nil, label: nil)
+        @threshold = Float(threshold)
+        raise ArgumentError, "drag threshold must be nonnegative" unless @threshold.finite? && @threshold >= 0
+        raise ArgumentError, "a pointer target locator is required" unless locate.respond_to?(:call)
+        raise TypeError, "keyboard target locator must respond to call" if keyboard && !keyboard.respond_to?(:call)
+        raise TypeError, "item labeler must respond to call" if label && !label.respond_to?(:call)
+
+        @locate, @keyboard, @label = locate, keyboard, label || ->(id) { id.to_s }
+      end
+
+      def on_event(&block) = (guard_reentry; @on_event = block; self)
+      def on_drop(&block) = (guard_reentry; @on_drop = block; self)
+      def on_announce(&block) = (guard_reentry; @on_announce = block; self)
+      def dragging? = !!@dragging
+
+      def press(id, point)
+        guard_reentry
+        validate_id(id)
+        validate_point(point)
+        begin
+          cancel(:replaced) if @active
+          @active = true
+          @source_id, @pressed_at, @last_point = id, point, point
+          emit(:press, point: point)
+          true
+        rescue StandardError => error
+          recover(error)
+        end
+      end
+
+      def move(point)
+        guard_reentry
+        return false unless @active
+        validate_point(point)
+        begin
+          @last_point = point
+          unless @dragging
+            return false if distance(@pressed_at, point) < @threshold
+            @dragging = true
+            emit(:start, point: point)
+          end
+          transition(normalize_target(callback(@locate, point, @source_id)), point)
+          true
+        rescue StandardError => error
+          recover(error)
+        end
+      end
+
+      def release(point = @last_point)
+        guard_reentry
+        return false unless @active
+        validate_point(point) if point
+        begin
+          move(point) if point && (!@last_point.equal?(point) || !@dragging)
+          return reset(false) unless @dragging
+
+          dropped = @target
+          unless dropped
+            cancel(:no_target)
+            return false
+          end
+          source = @source_id
+          message = move_announcement(source, dropped)
+          event = Event.new(phase: :drop, source_id: source, target: dropped, point: point, reason: nil)
+          reset
+          publish(event)
+          callback(@on_drop, event)
+          announce(message)
+          true
+        rescue StandardError => error
+          recover(error)
+        end
+      end
+
+      def keyboard(id, direction)
+        guard_reentry
+        validate_id(id)
+        raise ArgumentError, "keyboard reordering is not configured" unless @keyboard
+        raise ArgumentError, "keyboard direction must be previous, next, or inside" unless %i[previous next inside].include?(direction)
+
+        begin
+          cancel(:replaced) if @active
+          @active, @source_id, @dragging = true, id, true
+          emit(:start, reason: :keyboard)
+          destination = normalize_target(callback(@keyboard, id, direction))
+          unless destination
+            cancel(:no_target)
+            return false
+          end
+          transition(destination, nil)
+          message = move_announcement(id, destination)
+          event = Event.new(phase: :drop, source_id: id, target: destination, point: nil, reason: :keyboard)
+          reset
+          publish(event)
+          callback(@on_drop, event)
+          announce(message)
+          true
+        rescue StandardError => error
+          recover(error)
+        end
+      end
+
+      def action(id, action)
+        case action
+        when :reorder_before then keyboard(id, :previous)
+        when :reorder_after then keyboard(id, :next)
+        when :reorder_inside then keyboard(id, :inside)
+        when :cancel_reorder then cancel
+        else false
+        end
+      end
+
+      def accessibility_actions(id)
+        validate_id(id)
+        @keyboard ? %i[reorder_before reorder_after reorder_inside cancel_reorder] : [].freeze
+      end
+
+      def remove(id)
+        guard_reentry
+        return cancel(:removed) if @source_id == id
+        return false unless @target&.id == id
+
+        begin
+          emit(:leave, target: @target, point: @last_point, reason: :removed)
+          @target = nil
+          true
+        rescue StandardError => error
+          recover(error)
+        end
+      end
+
+      def cancel(reason = :cancelled)
+        guard_reentry
+        return false unless @active
+
+        begin
+          source, destination, point = @source_id, @target, @last_point
+          message = "Cancelled moving #{label(source)}" if @dragging
+          events = []
+          events << Event.new(phase: :leave, source_id: source, target: destination, point: point, reason: reason) if destination
+          events << Event.new(phase: :cancel, source_id: source, target: destination, point: point, reason: reason)
+          reset
+          events.each { |event| publish(event) }
+          announce(message) if message
+          true
+        rescue StandardError => error
+          recover(error)
+        end
+      end
+
+      def accessibility_node(_context = nil)
+        return unless @announcement
+        Accessibility.node(role: :status, id: [:reorder_status, object_id].freeze, label: @announcement,
+          states: {live: :polite, atomic: true, revision: @announcement_revision})
+      end
+
+      private
+
+      def transition(destination, point)
+        if destination == @target
+          emit(:over, target: destination, point: point) if destination
+          return
+        end
+        emit(:leave, target: @target, point: point) if @target
+        @target = destination
+        emit(:enter, target: destination, point: point) if destination
+      end
+
+      def normalize_target(destination)
+        return unless destination
+        raise TypeError, "target locator must return a DragDrop::Target" unless destination.is_a?(Target)
+        validate_id(destination.id)
+        raise ArgumentError, "drop position must be before, after, or inside" unless POSITIONS.include?(destination.position)
+        return if destination.id == @source_id
+
+        destination
+      end
+
+      def emit(phase, target: @target, point: @last_point, reason: nil)
+        Event.new(phase: phase, source_id: @source_id, target: target, point: point, reason: reason).tap { |event| publish(event) }
+      end
+
+      def publish(event) = (callback(@on_event, event); event)
+      def move_announcement(source, destination) = "Moved #{label(source)} #{destination.position} #{label(destination.id)}"
+
+      def announce(message)
+        return false if @announcement == message
+        @announcement = message.freeze
+        @announcement_revision = (@announcement_revision || 0) + 1
+        callback(@on_announce, @announcement)
+        true
+      end
+
+      def label(id) = callback(@label, id).to_s
+      def distance(first, second) = Math.hypot(second.x - first.x, second.y - first.y)
+      def guard_reentry
+        raise Error, "drag-and-drop callbacks must not re-enter their controller" if @notifying
+      end
+
+      def callback(callable, *arguments)
+        return unless callable
+        @notifying = true
+        callable.call(*arguments)
+      ensure
+        @notifying = false
+      end
+
+      def validate_id(id)
+        raise ArgumentError, "drag item id must not be nil" if id.nil?
+      end
+
+      def validate_point(point)
+        raise TypeError, "drag position must be a Point" unless point.is_a?(Point)
+      end
+
+      def reset(result = nil)
+        @active = @source_id = @pressed_at = @last_point = @target = @dragging = nil
+        result
+      end
+
+      def recover(error)
+        active, source, target, point = @active, @source_id, @target, @last_point
+        reset
+        begin
+          publish(Event.new(phase: :cancel, source_id: source, target: target,
+            point: point, reason: :error)) if active
+        rescue StandardError
+          # Preserve the first callback failure.
+        end
+        raise error
+      end
+    end
+  end
+end

data/lib/zaniah/input/keymap.rb

@@ -62,6 +62,9 @@ module Zaniah
             .bind("end", :last, context: "in_tree")
             .bind("left", :collapse, context: "in_tree")
             .bind("right", :expand, context: "in_tree")
+            .bind("alt-up", :reorder_before, context: "reorderable")
+            .bind("alt-down", :reorder_after, context: "reorderable")
+            .bind("esc", :cancel_reorder, context: "reorderable")
             .bind("up", :previous_option, context: "in_table")
             .bind("down", :next_option, context: "in_table")
             .bind("shift-up", :extend_previous, context: "in_table")

data/lib/zaniah/layout/engine.rb

@@ -125,6 +125,16 @@ module Zaniah
       end
 
       def layout(node, x, y, width, height, available_w, available_h, clamp = true)
+        if node.children.empty?
+          if node.style[:display] == :none
+            node.bounds = Bounds.new(x, y, 0, 0)
+          else
+            width = clamp_size(node, :width, width, available_w) if clamp
+            height = clamp_size(node, :height, height, available_h) if clamp
+            node.bounds = Bounds.new(x, y, width, height)
+          end
+          return
+        end
         key = [node.generation, x, y, width, height, available_w, available_h]
         return if node.cache[key]
         if node.style[:display] == :none
@@ -137,11 +147,6 @@ module Zaniah
           height = clamp_size(node, :height, height, available_h)
         end
         node.bounds = Bounds.new(x, y, width, height)
-        if node.children.empty?
-          node.cache.shift if node.cache.length >= 5
-          node.cache[key] = true
-          return
-        end
         content = content_bounds(node)
         flow, absolute = node.children.partition { |child| child.style[:position] != :absolute }
         s = node.style