zaniah 0.2.0 → 0.3.0

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

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Zaniah
+  module Accessibility
+    module Windows
+      module Provider
+        P = Fiddle::TYPE_VOIDP
+        I = Fiddle::TYPE_INT
+        U = Fiddle::TYPE_UINT
+        N = Fiddle::TYPE_INTPTR_T
+        S_OK = 0
+        E_NOINTERFACE = -2_147_467_262
+        E_FAIL = -2_147_467_259
+        UIA_APPEND_RUNTIME_ID = -1
+
+        GUIDS = {
+          unknown: "00000000-0000-0000-c000-000000000046",
+          simple: "d6dd68d1-86fd-4332-8666-9abedea2d24c",
+          fragment: "f7063da8-8359-439c-9297-bbc5299a7d87",
+          root: "620ce2a5-ab8f-40a9-86cb-de3c75599b58",
+          invoke: "54fcb24b-e18e-47a2-b4d3-eccbe77599a2"
+        }.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 = {
+          button: 50_000, checkbox: 50_002, switch: 50_002, combobox: 50_003, textbox: 50_004,
+          searchbox: 50_004, link: 50_005, image: 50_006, listitem: 50_007, list: 50_008,
+          listbox: 50_008, menu: 50_009, menubar: 50_010, menuitem: 50_011,
+          progressbar: 50_012, meter: 50_012, radio: 50_013, slider: 50_015, status: 50_017,
+          tabpanel: 50_018, tab: 50_019, text: 50_020, heading: 50_020, toolbar: 50_021,
+          tooltip: 50_022, tree: 50_023, treeitem: 50_024, group: 50_026, radiogroup: 50_026,
+          form: 50_026, table: 50_036, row: 50_029, cell: 50_029, columnheader: 50_035,
+          dialog: 50_032, navigation: 50_033, separator: 50_038
+        }.freeze
+
+        class Bridge
+          attr_reader :window, :tree, :root_provider
+
+          def initialize(window)
+            @window, @providers = window, {}
+          end
+
+          def update(root)
+            @tree = NativeTree.new(root)
+            @tree.each do |entry|
+              (@providers[entry.path] ||= Element.new(self, entry.path)).entry = entry
+            end
+            @root_provider = @providers[@tree.root.path]
+          end
+
+          def provider(entry) = entry && @providers[entry.path]
+          def entry(path) = @tree[path]
+
+          def screen_bounds(entry)
+            bounds = @tree.bounds(entry)
+            point = [(bounds.x * scale).round, (bounds.y * scale).round].pack("l2")
+            user.fn(:ClientToScreen, [P, P], I).call(@window.handle, point)
+            x, y = point.unpack("l2")
+            [x.to_f, y.to_f, bounds.width * scale, bounds.height * scale]
+          rescue NoMethodError
+            [bounds.x, bounds.y, bounds.width, bounds.height]
+          end
+
+          def provider_at(x, y)
+            point = [x.round, y.round].pack("l2")
+            user.fn(:ScreenToClient, [P, P], I).call(@window.handle, point)
+            px, py = point.unpack("l2")
+            provider(@tree.hit(Point.new(px / scale, py / scale)))
+          rescue NoMethodError
+            provider(@tree.hit(Point.new(x, y)))
+          end
+
+          def focused_provider = provider(@tree.focused(@window)) || @root_provider
+
+          def return_provider(wparam, lparam)
+            core.fn(:UiaReturnRawElementProvider, [P, N, N, P], N)
+              .call(@window.handle, wparam, lparam, @root_provider.pointer(:simple))
+          end
+
+          def host_provider(output)
+            core.fn(:UiaHostProviderFromHwnd, [P, P], I).call(@window.handle, output)
+          end
+
+          def bstr(value)
+            bytes = value.to_s.encode("UTF-16LE").b + "\0\0".b
+            ole.fn(:SysAllocString, [P], P).call(Fiddle::Pointer[bytes])
+          end
+
+          def safe_array(values)
+            array = ole.fn(:SafeArrayCreateVector, [Fiddle::TYPE_USHORT, Fiddle::TYPE_LONG, U], P).call(3, 0, values.length)
+            data = [0].pack("J")
+            return 0 if array.to_i.zero? || ole.fn(:SafeArrayAccessData, [P, P], I).call(array, data) != S_OK
+            Fiddle::Pointer.new(data.unpack1("J"))[0, values.length * 4] = values.pack("l*")
+            ole.fn(:SafeArrayUnaccessData, [P], I).call(array)
+            array
+          end
+
+          private
+
+          def scale = @window.scale_factor || 1.0
+          def user = @window.instance_variable_get(:@user)
+          def core = (@core ||= Zaniah::FFI::Library.new("UIAutomationCore.dll"))
+          def ole = (@ole ||= Zaniah::FFI::Library.new("oleaut32.dll"))
+        end
+
+        class Element
+          INTERFACES = {}
+          class << self
+            attr_reader :vtables, :closures
+
+            def install
+              return if @vtables
+              @closures = []
+              unknown = [closure(I, [P, P, P]) { |this, iid, output| interface(this).query(iid, output) },
+                closure(U, [P]) { |this| interface(this).add_ref }, closure(U, [P]) { |this| interface(this).release }]
+              simple = unknown + [closure(I, [P, P]) { |_this, output| write_int(output, 1) },
+                closure(I, [P, I, P]) { |this, pattern, output| interface(this).pattern(pattern, output) },
+                closure(I, [P, I, P]) { |this, property, output| interface(this).property(property, output) },
+                closure(I, [P, P]) { |this, output| interface(this).host(output) }]
+              fragment = unknown + [closure(I, [P, I, P]) { |this, direction, output| interface(this).navigate(direction, output) },
+                closure(I, [P, P]) { |this, output| interface(this).runtime_id(output) },
+                closure(I, [P, P]) { |this, output| interface(this).bounding_rectangle(output) },
+                closure(I, [P, P]) { |_this, output| write_pointer(output, 0) },
+                closure(I, [P]) { |this| interface(this).set_focus },
+                closure(I, [P, P]) { |this, output| interface(this).fragment_root(output) }]
+              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
+            end
+
+            def closure(result, arguments, &block)
+              value = Fiddle::Closure::BlockCaller.new(result, arguments) do |*values|
+                block.call(*values)
+              rescue StandardError
+                result == I ? E_FAIL : 1
+              end
+              @closures << value
+              value
+            end
+
+            def vtable(functions)
+              pointer = Fiddle::Pointer.malloc(functions.length * Fiddle::SIZEOF_VOIDP)
+              pointer[0, functions.length * Fiddle::SIZEOF_VOIDP] = functions.map(&:to_i).pack("J*")
+              pointer
+            end
+
+            def interface(pointer) = INTERFACES.fetch(pointer.to_i)
+            def write_pointer(output, value) = (Fiddle::Pointer.new(output)[0, Fiddle::SIZEOF_VOIDP] = [value.to_i].pack("J"); S_OK)
+            def write_int(output, value) = (Fiddle::Pointer.new(output)[0, 4] = [value].pack("l"); S_OK)
+          end
+
+          attr_accessor :entry
+          attr_reader :bridge
+
+          def initialize(bridge, path)
+            self.class.install
+            @bridge, @path, @references, @interfaces = bridge, path, 1, {}
+            %i[simple fragment root invoke].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
+              INTERFACES[pointer.to_i] = self
+            end
+          end
+
+          def pointer(kind) = @interfaces.fetch(kind).to_i
+
+          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?)
+            return self.class.write_pointer(output, 0) && E_NOINTERFACE unless supported
+            add_ref
+            self.class.write_pointer(output, pointer(requested))
+          end
+
+          def add_ref = (@references += 1)
+          def release = (@references = [@references - 1, 1].max)
+
+          def pattern(pattern, output)
+            return self.class.write_pointer(output, 0) unless pattern == 10_000 && invokable?
+            add_ref
+            self.class.write_pointer(output, pointer(:invoke))
+          end
+
+          def property(property, output)
+            variant = Fiddle::Pointer.new(output)
+            variant[0, 16] = "\0" * 16
+            case property
+            when 30_003 then variant_i4(variant, CONTROL_TYPES.fetch(@entry.node.role, 50_025))
+            when 30_005 then variant_bstr(variant, @entry.node.label || @entry.node.value&.to_s || @entry.node.role.to_s)
+            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_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?)
+            when 30_024 then variant_bstr(variant, "Zaniah")
+            end
+            S_OK
+          end
+
+          def host(output) = @entry.parent ? self.class.write_pointer(output, 0) : @bridge.host_provider(output)
+
+          def navigate(direction, output)
+            target = case direction
+            when 0 then @entry.parent
+            when 1, 2
+              siblings = @entry.parent&.children || []
+              index = siblings.index(@entry)
+              index && siblings[index + (direction == 1 ? 1 : -1)] if index && (direction == 1 || index.positive?)
+            when 3 then @entry.children.first
+            when 4 then @entry.children.last
+            end
+            provider = @bridge.provider(target)
+            provider&.add_ref
+            self.class.write_pointer(output, provider&.pointer(:fragment) || 0)
+          end
+
+          def runtime_id(output)
+            array = @bridge.safe_array([UIA_APPEND_RUNTIME_ID, @entry.runtime_id])
+            self.class.write_pointer(output, array)
+          end
+
+          def bounding_rectangle(output)
+            Fiddle::Pointer.new(output)[0, 32] = @bridge.screen_bounds(@entry).pack("d4")
+            S_OK
+          end
+
+          def set_focus
+            bounds = @bridge.tree.bounds(@entry)
+            Accessibility.focus_at(@bridge.window, Point.new(bounds.x + bounds.width / 2.0, bounds.y + bounds.height / 2.0))
+            S_OK
+          end
+
+          def fragment_root(output)
+            root = @bridge.root_provider
+            root.add_ref
+            self.class.write_pointer(output, root.pointer(:root))
+          end
+
+          def from_point(x, y, output)
+            provider = @bridge.provider_at(x, y) || @bridge.root_provider
+            provider.add_ref
+            self.class.write_pointer(output, provider.pointer(:fragment))
+          end
+
+          def focus(output)
+            provider = @bridge.focused_provider
+            provider.add_ref
+            self.class.write_pointer(output, provider.pointer(:fragment))
+          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))
+            S_OK
+          end
+
+          private
+
+          def invokable? = @entry.node.actions.any? { |action| %i[press toggle select sort expand collapse dismiss].include?(action) }
+          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"))
+          def variant_bstr(pointer, value) = (pointer[0, 2] = [8].pack("v"); pointer[8, Fiddle::SIZEOF_VOIDP] = [@bridge.bstr(value)].pack("J"))
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/accessibility/windows.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "windows/provider"
+
+module Zaniah
+  module Accessibility
+    module Windows
+      EVENT_OBJECT_REORDER = 0x8004
+      OBJID_CLIENT = -4
+      CHILDID_SELF = 0
+
+      module_function
+
+      def publish(window, root, _changes)
+        return unless root && window.respond_to?(:handle)
+        bridge = bridges[window.handle.to_i] ||= Provider::Bridge.new(window)
+        bridge.update(root)
+        user = window.instance_variable_get(:@user)
+        return unless user
+        user.fn(:NotifyWinEvent,
+          [Fiddle::TYPE_UINT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_INT], Fiddle::TYPE_VOID)
+          .call(EVENT_OBJECT_REORDER, window.handle, OBJID_CLIENT, CHILDID_SELF)
+      rescue Fiddle::DLError
+        nil
+      end
+
+      def provider_result(window, wparam, lparam)
+        return unless (lparam.to_i & 0xffffffff) == 0xffffffe7
+        bridge = bridges[window.handle.to_i]
+        return unless bridge&.root_provider
+        bridge.return_provider(wparam, lparam)
+      end
+
+      def close(window) = bridges.delete(window.handle.to_i)
+      def bridges = (@bridges ||= {})
+    end
+  end
+end

data/lib/zaniah/accessibility.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "accessibility/node"
+require_relative "accessibility/tree"
+require_relative "accessibility/native_tree"
+
+module Zaniah
+  module Accessibility
+    autoload :Mac, File.expand_path("accessibility/mac", __dir__)
+    autoload :Windows, File.expand_path("accessibility/windows", __dir__)
+    autoload :Linux, File.expand_path("accessibility/linux", __dir__)
+
+    module_function
+
+    def publish(window, root, changes)
+      adapter = case window.class.name
+      when /::Mac::/ then Mac
+      when /::Windows::/ then Windows
+      when /::Linux::/ then Linux
+      end
+      adapter&.publish(window, root, changes)
+    end
+
+    def poll(window)
+      Linux.poll(window) if window.class.name.match?(/::Linux::/)
+    end
+
+    def close(window)
+      case window.class.name
+      when /::Mac::/ then Mac.close(window)
+      when /::Windows::/ then Windows.close(window)
+      when /::Linux::/ then Linux.close(window)
+      end
+    end
+
+    def perform(window, node, action, bounds: node&.bounds)
+      return false unless node && node.actions.include?(action)
+      if action == :dismiss
+        window.input(Input::KeyDown.new("esc", false))
+        return true
+      end
+      return false unless bounds
+      position = Point.new(bounds.x + bounds.width / 2.0, bounds.y + bounds.height / 2.0)
+      if %i[increment decrement].include?(action)
+        focus_at(window, position)
+        window.dispatcher.key(action == :increment ? "right" : "left")
+      else
+        window.input(Input::MouseDown.new(position, :left, [], 1))
+        window.input(Input::MouseUp.new(position, :left, []))
+      end
+      true
+    end
+
+    def focus_at(window, position)
+      hit = window.dispatcher.hits.reverse.find { |candidate| candidate.bounds&.contains?(position) }
+      owner = hit&.owner
+      owner = owner.parent while owner && !owner.respond_to?(:focus_handle)
+      handle = owner&.focus_handle
+      window.dispatcher.focus(handle, origin: :programmatic) if handle
+      !handle.nil?
+    end
+  end
+end

data/lib/zaniah/animation/animator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Animation
+    attr_reader :key, :from, :to, :started_at, :duration, :easing
+
+    def initialize(key, from:, to:, started_at:, duration:, easing:, on_complete: nil)
+      @key, @from, @to, @started_at = key, from, to, started_at
+      @duration, @easing, @on_complete = duration, easing, on_complete
+    end
+
+    def sample(now)
+      progress = duration.zero? ? 1.0 : ((now - started_at) / duration).clamp(0, 1)
+      [Animation.interpolate(from, to, easing.call(progress)), progress >= 1]
+    end
+
+    def complete = @on_complete&.call
+
+    def self.interpolatable?(from, to)
+      (from.is_a?(Numeric) && to.is_a?(Numeric)) ||
+        (from.is_a?(Color) && to.is_a?(Color)) ||
+        (from.is_a?(Length) && to.is_a?(Length) && from.unit == to.unit) ||
+        (from.is_a?(Transform) && to.is_a?(Transform))
+    end
+
+    def self.interpolate(from, to, progress)
+      return from + (to - from) * progress if from.is_a?(Numeric) && to.is_a?(Numeric)
+      return Color.new(*from.to_a.zip(to.to_a).map { |left, right| left + (right - left) * progress }) if from.is_a?(Color) && to.is_a?(Color)
+      return Length.new(from.value + (to.value - from.value) * progress, from.unit) if from.is_a?(Length) && to.is_a?(Length) && from.unit == to.unit
+      return Transform.new(*from.to_a.zip(to.to_a).map { |left, right| left + (right - left) * progress }) if from.is_a?(Transform) && to.is_a?(Transform)
+      progress >= 1 ? to : from
+    end
+  end
+
+  class Animator
+    attr_reader :reduced_motion
+
+    def initialize(clock:, reduced_motion: false)
+      @clock, @reduced_motion = clock, reduced_motion
+      @animations, @values = {}, {}
+    end
+
+    def reduced_motion=(value)
+      @reduced_motion = !!value
+      @animations.keys.each { |key| finish(key) } if @reduced_motion
+      @reduced_motion
+    end
+
+    def animate(key, from:, to:, duration:, easing: :linear, &on_complete)
+      duration = Float(duration)
+      raise ArgumentError, "duration must be finite and nonnegative" unless duration.finite? && duration >= 0
+      duration = 0.0 if reduced_motion
+      animation = Animation.new(key, from: from, to: to, started_at: @clock.call,
+        duration: duration, easing: Easing.resolve(easing), on_complete: on_complete)
+      @values[key] = from
+      if duration.zero?
+        @values[key] = to
+        animation.complete
+      else
+        @animations[key] = animation
+      end
+      animation
+    end
+
+    def spring(key, to:, stiffness: 170, damping: 26, mass: 1, from: value(key, 0), &on_complete)
+      easing = Easing.spring(stiffness: stiffness, damping: damping, mass: mass)
+      animate(key, from: from, to: to, duration: easing.settling_duration, easing: easing, &on_complete)
+    end
+
+    def sample(now = @clock.call)
+      @animations.dup.each do |key, animation|
+        @values[key], finished = animation.sample(now)
+        finish(key) if finished
+      end
+      @values.dup.freeze
+    end
+
+    def active? = !@animations.empty?
+    def animating?(key) = @animations.key?(key)
+    def value(key, fallback = nil) = @values.fetch(key, fallback)
+
+    def cancel(key)
+      @animations.delete(key)
+      @values.delete(key)
+    end
+
+    def finish(key)
+      animation = @animations.delete(key)
+      return @values[key] unless animation
+      @values[key] = animation.to
+      animation.complete
+      @values[key]
+    end
+  end
+end

data/lib/zaniah/animation/easing.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Easing
+    module_function
+
+    def linear = ->(value) { value }
+    def ease_in = cubic_bezier(0.42, 0, 1, 1)
+    def ease_out = cubic_bezier(0, 0, 0.58, 1)
+    def ease_in_out = cubic_bezier(0.42, 0, 0.58, 1)
+
+    def resolve(value)
+      return value if value.respond_to?(:call)
+      public_send(value || :linear)
+    rescue NoMethodError
+      raise ArgumentError, "unknown easing #{value.inspect}"
+    end
+
+    def cubic_bezier(x1, y1, x2, y2)
+      values = [x1, y1, x2, y2].map { |value| Float(value) }
+      raise ArgumentError, "cubic-bezier x values must be between 0 and 1" unless values.values_at(0, 2).all? { |value| value.between?(0, 1) }
+      x1, y1, x2, y2 = values
+      lambda do |input|
+        input = input.to_f.clamp(0, 1)
+        low, high = 0.0, 1.0
+        16.times do
+          time = (low + high) / 2.0
+          sample = bezier(time, x1, x2)
+          sample < input ? low = time : high = time
+        end
+        bezier((low + high) / 2.0, y1, y2)
+      end
+    end
+
+    def spring(stiffness: 170, damping: 26, mass: 1)
+      Spring.new(stiffness: stiffness, damping: damping, mass: mass)
+    end
+
+    def bezier(time, first, second)
+      inverse = 1 - time
+      3 * inverse * inverse * time * first + 3 * inverse * time * time * second + time**3
+    end
+    private_class_method :bezier
+  end
+end

data/lib/zaniah/animation/spring.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Spring
+    attr_reader :stiffness, :damping, :mass, :settling_duration
+
+    def initialize(stiffness:, damping:, mass: 1)
+      @stiffness, @damping, @mass = Float(stiffness), Float(damping), Float(mass)
+      raise ArgumentError, "spring values must be finite and positive" unless [@stiffness, @damping, @mass].all? { |value| value.finite? && value.positive? }
+      @settling_duration = [-Math.log(0.001) / slowest_decay, 10.0].min
+    end
+
+    def call(progress)
+      time = progress.to_f.clamp(0, 1) * settling_duration
+      ratio = damping / (2 * Math.sqrt(stiffness * mass))
+      frequency = Math.sqrt(stiffness / mass)
+      return 1 - Math.exp(-frequency * time) * (1 + frequency * time) if (ratio - 1).abs < 1e-6
+      if ratio < 1
+        damped = frequency * Math.sqrt(1 - ratio * ratio)
+        1 - Math.exp(-ratio * frequency * time) * (Math.cos(damped * time) + ratio * frequency / damped * Math.sin(damped * time))
+      else
+        root = Math.sqrt(ratio * ratio - 1)
+        first, second = -frequency * (ratio - root), -frequency * (ratio + root)
+        1 - (second * Math.exp(first * time) - first * Math.exp(second * time)) / (second - first)
+      end
+    end
+
+    private
+
+    def slowest_decay
+      ratio = damping / (2 * Math.sqrt(stiffness * mass))
+      frequency = Math.sqrt(stiffness / mass)
+      ratio <= 1 ? ratio * frequency : frequency * (ratio - Math.sqrt(ratio * ratio - 1))
+    end
+  end
+end

data/lib/zaniah/animation/transition.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Transition = Data.define(:properties, :duration, :easing)
+end

data/lib/zaniah/animation.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "animation/easing"
+require_relative "animation/spring"
+require_relative "animation/animator"
+require_relative "animation/transition"

data/lib/zaniah/app.rb

@@ -10,7 +10,7 @@ module Zaniah
     attr_reader :windows, :executor
 
     def initialize(clock: MONOTONIC_CLOCK)
-      @slots, @generations, @free, @windows, @globals = [], [], [], [], {}
+      @slots, @generations, @free, @windows, @globals = [], [], [], [], {theme: Theme.dark}
       @listeners, @effects, @updating, @flushing = {}, [], 0, false
       @clock = clock
       @executor = TaskExecutor.new(clock: clock)
@@ -106,25 +106,45 @@ module Zaniah
     def open_window(**options, &render)
       options[:clock] ||= @clock
       window = Platform.open_window(**options)
+      window.app = self
       @windows << window
+      @globals[:theme] = platform_theme(window)
+      window.on_appearance do |appearance|
+        @globals[:theme] = platform_theme(window, appearance)
+        @windows.each(&:request_frame)
+      end
       window.draw(&render) if render
       window
     end
 
     def run
       until @windows.empty? || @windows.all?(&:closed?)
+        @hot_reloads&.each(&:poll)
         @executor.drain
         @windows.reject(&:closed?).each(&:tick)
-        @executor.wait(0.05) unless @windows.any?(&:dirty?)
+        @executor.wait(0.05) unless @windows.any? { |window| window.dirty? || window.animation_active? }
       end
     ensure
+      @hot_reloads&.each(&:close)
       @executor.shutdown
     end
 
+    def hot_reload(paths, **options, &block)
+      require_relative "devtools"
+      reload = DevTools::HotReload.new(self, paths, **options, &block)
+      (@hot_reloads ||= []) << reload
+      reload
+    end
+
     def alive?(entity) = @generations[entity.id] == entity.generation && !@free.include?(entity.id) && entity.id < @slots.length
 
     private
 
+    def platform_theme(window, appearance = window.appearance)
+      theme = Theme.for(appearance)
+      window.reduced_motion? ? theme.with(motion: theme.motion.with(reduced: true)) : theme
+    end
+
     def validate(entity)
       raise Error, "entity has been released" unless alive?(entity)
     end

data/lib/zaniah/color.rb

@@ -14,6 +14,7 @@ module Zaniah
     end
 
     def opacity(value) = Color.new(r, g, b, a * value)
+    def with_alpha(value) = Color.new(r, g, b, value.to_f.clamp(0, 1))
     def premultiplied = [r * a, g * a, b * a, a]
     def to_a = [r, g, b, a]
 
@@ -21,6 +22,21 @@ module Zaniah
       Color.new(*to_a.zip(Color.parse(other).to_a).map { |x, y| x + (y - x) * amount })
     end
 
+    def lighten(amount)
+      value = to_hsla
+      HSLA.new(value.h, value.s, (value.l + amount).clamp(0, 1), value.a).to_rgba
+    end
+
+    def darken(amount) = lighten(-amount)
+
+    def contrast_ratio(other)
+      values = [self, Color.parse(other)].map do |color|
+        channels = [color.r, color.g, color.b].map { |channel| channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055)**2.4 }
+        0.2126 * channels[0] + 0.7152 * channels[1] + 0.0722 * channels[2]
+      end
+      (values.max + 0.05) / (values.min + 0.05)
+    end
+
     def to_hsla
       max, min = [r, g, b].max, [r, g, b].min
       delta, lightness = max - min, (max + min) / 2.0