konpeito 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7f18a84d8cfece0c51becca2067ab474195205b4d5ce09b7a4e197b129851a
-  data.tar.gz: ca0f8a113919d8ca6b28e8109fd2ed031979de67e695c9aaad9f659b425dab89
+  metadata.gz: 53a3bbb24175ed554f9f560c38e6f8138206da3fb6385f87358e9dfa3eed4f10
+  data.tar.gz: 80026dca6352dcb9effa9e7bac8e7ebc58e517ae84cb1f15627935fbb3d5fee4
 SHA512:
-  metadata.gz: 62a1bd26cf53ddc918f1129772574021154079e492c33f48437290179fd71bdba65ca78c95890f16c224cf58930fbc879040c595580eb73a1d7e6868f0460cd9
-  data.tar.gz: 295d6ac004cda8c7823ad711dca5015a95c78302fd0f3c2da0796cb30ef0c638a13bac53f0c8ae439fc50556bb1262e6a304facdd4dfaa3c6b425f1d3842f85a
+  metadata.gz: 4233ae433c5730c64da97806275ca0300d80f77e5af8c338cf2185f54205d69b99091447a097506b5d2944dac437396a8a4e04ae9a97a90df60f8a93d60e730d
+  data.tar.gz: 911c32b9ac29989060b08fe6fc352074a02038ae20f8b516723e56a263bf602b0ee70206cf41a3bbe682044ab4c7511552fa255ef9d7b137da952dcea271f860

data/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.2] - 2026-02-17
+
+### Fixed
+- Castella UI: include padding and respect FIXED sizes in Column/Row measure
+- Castella UI: use lighter accent variant for normal button hover across all themes
+- JVM backend: preserve subclass type through inherited self-returning method chains
+
+### Changed
+- Documentation: reorganize Castella UI section in README with DSL / Reactive State / Style Composition subheadings
+- Documentation: add Style Composition example and screenshot to README
+- Documentation: remove filler spacers from counter demos (EXPANDING default makes them unnecessary)
+- Documentation: update counter screenshot
+
 ## [0.1.1] - 2026-02-16
 
 ### Fixed
@@ -86,5 +99,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `%a{extern}` - external C struct wrappers
 - `%a{simd}` - SIMD vectorization
 
+[0.1.2]: https://github.com/i2y/konpeito/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/i2y/konpeito/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/i2y/konpeito/releases/tag/v0.1.0

data/README.md

@@ -135,43 +135,100 @@ The JVM backend supports seamless Java interop — call Java libraries directly
 
 ## Castella UI
 
-Castella is a reactive GUI framework that runs on the JVM backend, powered by [JWM](https://github.com/nicenote/jwm) + [Skija](https://github.com/nicenote/skija) for cross-platform rendering. Based on a port of [Castella for Python](https://github.com/i2y/castella).
+A reactive GUI framework for the JVM backend, powered by [JWM](https://github.com/nicenote/jwm) + [Skija](https://github.com/nicenote/skija).
+
+### DSL
+
+Ruby's block syntax becomes a UI DSL — `column`, `row`, `text`, `button` etc. nest naturally with keyword arguments. A plain Ruby method is a reusable component.
+
+<p align="center">
+  <img src="docs/screenshots/dashboard.png" alt="Analytics Dashboard" width="720" />
+</p>
 
 ```ruby
-class CounterApp < Component
+def view
+  column(padding: 20.0, spacing: 16.0) {
+    row(spacing: 12.0) {
+      text("Analytics Dashboard", font_size: 26.0, bold: true)
+      spacer
+      button("Refresh", width: 90.0) {}
+    }.fixed_height(40.0)
+
+    # KPI Cards — extract a method, and it's a reusable component
+    row(spacing: 12.0) {
+      kpi_card("Revenue", "$48,250", "+12.5%", $theme.accent)
+      kpi_card("Users",   "3,842",   "+8.1%",  $theme.success)
+      kpi_card("Orders",  "1,205",   "-2.3%",  $theme.error)
+    }
+
+    # Charts, tables, and layouts compose with blocks
+    row(spacing: 12.0) {
+      column(expanding_width: true, bg_color: $theme.bg_primary, border_radius: 10.0, padding: 14.0) {
+        bar_chart(labels, data, ["Revenue", "Costs"]).title("Monthly Overview").fixed_height(220.0)
+      }
+      column(expanding_width: true, bg_color: $theme.bg_primary, border_radius: 10.0, padding: 14.0) {
+        data_table(headers, widths, rows).fixed_height(200.0)
+      }
+    }
+  }
+end
+
+# A Ruby method is a reusable component
+def kpi_card(label, value, change, color)
+  column(spacing: 6.0, bg_color: $theme.bg_primary, border_radius: 10.0, padding: 16.0, expanding_width: true) {
+    text(label, font_size: 12.0, color: $theme.text_secondary)
+    text(value, font_size: 24.0, bold: true)
+    text(change, font_size: 13.0, color: color)
+  }
+end
+```
+
+### Reactive State
+
+`state(0)` creates an observable value, and the UI re-renders automatically when it changes:
+
+<p align="center">
+  <img src="docs/screenshots/counter.png" alt="Counter App" width="320" />
+</p>
+
+```ruby
+class Counter < Component
   def initialize
     super
     @count = state(0)
   end
 
   def view
-    label = "Count: " + @count.value.to_s
-    Column(
-      Text(label).font_size(32),
-      Row(
-        Button("  -  ").on_click { @count -= 1 },
-        Button("  +  ").on_click { @count += 1 }
-      )
-    )
+    column(padding: 16.0, spacing: 8.0) {
+      text "Count: #{@count}", font_size: 32.0, align: :center
+      row(spacing: 8.0) {
+        button(" - ") { @count -= 1 }
+        button(" + ") { @count += 1 }
+      }
+    }
   end
 end
 ```
 
-A block-based DSL is also available:
+An OOP-style API (`Column(...)`, `Row(...)`) is also available. Available widgets: `Text`, `Button`, `TextInput`, `MultilineText`, `Column`, `Row`, `Image`, `Checkbox`, `Slider`, `ProgressBar`, `Tabs`, `DataTable`, `TreeView`, `BarChart`, `LineChart`, `PieChart`, `Markdown`, and more.
+
+### Style Composition
+
+Styles are first-class objects — store them in variables and compose with `+`:
+
+<p align="center">
+  <img src="docs/screenshots/style_composition.png" alt="Style Composition" width="480" />
+</p>
 
 ```ruby
-def view
-  column(padding: 16.0) do
-    text "Counter: #{@count}", font_size: 24.0, color: 0xFFC0CAF5
-    row(spacing: 8.0) do
-      button("-", width: 60.0) { @count -= 1 }
-      button("+", width: 60.0) { @count += 1 }
-    end
-  end
-end
-```
+card = Style.new.bg_color($theme.bg_primary).border_radius(10.0).padding(16.0)
+green_card = card + Style.new.border_color($theme.success)
 
-Available widgets: `Text`, `Button`, `TextInput`, `MultilineText`, `Column`, `Row`, `Image`, `Checkbox`, `Slider`, `ProgressBar`, `Tabs`, `DataTable`, `TreeView`, `BarChart`, `Markdown`, and more.
+column(spacing: 12.0) {
+  container(card)       { text "Default card" }
+  container(green_card) { text "Green border variant" }
+}
+```
 
 ## Performance
 

data/lib/konpeito/codegen/jvm_generator.rb

@@ -3148,6 +3148,22 @@ module Konpeito
             ensure_slot(result_var, ret_type)
             instructions << store_instruction(result_var, ret_type)
             @variable_types[result_var] = ret_type
+
+            # Propagate class type so subsequent method chains resolve the receiver.
+            # Without this, `Button("Animate!").kind(1)` fails because the receiver
+            # class of `.kind(1)` is unknown after the static call to `Button()`.
+            if ret_type.is_a?(Symbol) && ret_type.to_s.start_with?("class:")
+              cls = ret_type.to_s.sub("class:", "")
+              @variable_class_types[result_var] = cls if @class_info.key?(cls)
+            end
+            # Also check HM-inferred type from the call instruction
+            if !@variable_class_types[result_var] && inst.respond_to?(:type) && inst.type
+              call_type = inst.type
+              call_type = call_type.prune if call_type.respond_to?(:prune)
+              if call_type.is_a?(TypeChecker::Types::ClassInstance) && @class_info.key?(call_type.name.to_s)
+                @variable_class_types[result_var] = call_type.name.to_s
+              end
+            end
           end
         end
 
@@ -5114,8 +5130,16 @@ module Konpeito
           # checkcast when return type is a user class (descriptor returns Object but actual is specific class)
           if ret_type == :value
             rbs_class = resolve_rbs_return_class_name(owner_class, method_name)
-            # Also check inferred return class from function_return_type (self-returning methods)
-            rbs_class ||= inferred_return_class
+            # When function returns self (SelfRef), preserve the receiver's actual class type.
+            # RBS annotations declare the defining class (e.g., Widget#fixed_height → Widget)
+            # but `self` at runtime is the receiver's class (e.g., Button). Without this,
+            # method chains like Button(...).fixed_height(36.0).on_click { ... } break because
+            # the receiver type narrows to Widget and on_click (defined on Button) is not found.
+            if inferred_return_class
+              rbs_class = inferred_return_class
+            else
+              rbs_class ||= inferred_return_class
+            end
             if rbs_class && @class_info.key?(rbs_class)
               instructions << { "op" => "checkcast", "type" => @class_info[rbs_class][:jvm_name] }
               @variable_class_types[result_var] = rbs_class

data/lib/konpeito/type_checker/hm_inferrer.rb

@@ -1429,6 +1429,10 @@ module Konpeito
       # Score how well an argument type matches an RBS parameter type
       def overload_match_score(arg_type, rbs_param_type)
         case rbs_param_type
+        when RBS::Types::Alias
+          # Resolve common aliases: ::int -> Integer, ::string -> String, etc.
+          resolved = resolve_rbs_alias(rbs_param_type)
+          return overload_match_score(arg_type, resolved) if resolved
         when RBS::Types::ClassInstance
           param_name = rbs_param_type.name.name
           if arg_type.is_a?(Types::ClassInstance)
@@ -1444,6 +1448,24 @@ module Konpeito
         0
       end
 
+      # Resolve RBS type aliases to their underlying ClassInstance types
+      def resolve_rbs_alias(alias_type)
+        alias_name = alias_type.name.name
+        class_name = case alias_name
+                     when :int then :Integer
+                     when :string then :String
+                     when :float then :Float
+                     when :bool then :Bool
+                     when :boolish then :Bool
+                     end
+        return nil unless class_name
+        RBS::Types::ClassInstance.new(
+          name: RBS::TypeName.new(name: class_name, namespace: RBS::Namespace.root),
+          args: [],
+          location: alias_type.location
+        )
+      end
+
       def numeric_compatible?(arg_name, param_name)
         numerics = %i[Integer Float Rational Complex Numeric]
         numerics.include?(arg_name) && numerics.include?(param_name)

data/lib/konpeito/type_checker/unification.rb

@@ -186,6 +186,9 @@ module Konpeito
         elsif singleton_value_compatible?(t1, t2)
           # ClassSingleton (value constant like EXPANDING) is compatible with its base type.
           # e.g., singleton(EXPANDING) ↔ Integer when EXPANDING = 2
+        elsif literal_compatible?(t1, t2)
+          # Literals are subtypes of their base type (e.g., Literal(1) <: Integer, Literal("x") <: String)
+          # Unions of same-type literals are also compatible (e.g., -1 | 0 | 1 <: Integer)
         else
           raise UnificationError.new(t1, t2)
         end
@@ -207,6 +210,38 @@ module Konpeito
         (t2.is_a?(Types::ClassSingleton) && t1.is_a?(Types::ClassInstance))
       end
 
+      # Check if a literal type (or union of literals) is compatible with its base class type.
+      # e.g., Literal(1) <: Integer, Literal("hello") <: String, Literal(1.0) <: Float
+      #        Union(Literal(-1), Literal(0), Literal(1)) <: Integer
+      def literal_compatible?(t1, t2)
+        (literal_subtype_of_class?(t1, t2)) || (literal_subtype_of_class?(t2, t1))
+      end
+
+      def literal_subtype_of_class?(literal_side, class_side)
+        return false unless class_side.is_a?(Types::ClassInstance)
+
+        if literal_side.is_a?(Types::Literal)
+          literal_base_type_name(literal_side.value) == class_side.name
+        elsif literal_side.is_a?(Types::Union)
+          literal_side.types.all? do |sub|
+            sub.is_a?(Types::Literal) && literal_base_type_name(sub.value) == class_side.name
+          end
+        else
+          false
+        end
+      end
+
+      # Map a Ruby literal value to its base type name
+      def literal_base_type_name(value)
+        case value
+        when Integer then :Integer
+        when Float then :Float
+        when String then :String
+        when Symbol then :Symbol
+        when true, false then :Bool
+        end
+      end
+
       # Check if `from` can be widened to `to` (Java/Kotlin-style widening primitive conversion).
       # Integer → Float is safe (no precision loss for typical values).
       # Float → Integer is NOT supported (requires explicit conversion).

data/lib/konpeito/ui/column.rb

@@ -25,6 +25,14 @@ class Column < Layout
   #: () -> Column
   def scrollable
     @is_scrollable = true
+    # Retroactively downgrade existing EXPANDING children to CONTENT
+    i = 0
+    while i < @children.length
+      if @children[i].get_height_policy == EXPANDING
+        @children[i].set_height_policy(CONTENT)
+      end
+      i = i + 1
+    end
     self
   end
 
@@ -60,21 +68,43 @@ class Column < Layout
     update
   end
 
+  # Override add: auto-downgrade EXPANDING height to CONTENT in scrollable Column
+  #: (untyped w) -> Column
+  def add(w)
+    if w == nil
+      return self
+    end
+    if @is_scrollable && w.get_height_policy == EXPANDING
+      w.set_height_policy(CONTENT)
+    end
+    super(w)
+    self
+  end
+
   #: (untyped painter) -> Size
   def measure(painter)
     total_h = 0.0
     max_w = 0.0
     i = 0
     while i < @children.length
-      cs = @children[i].measure(painter)
-      total_h = total_h + cs.height
+      c = @children[i]
+      cs = c.measure(painter)
+      if c.get_height_policy == FIXED
+        child_h = c.get_height
+      else
+        child_h = cs.height
+      end
+      total_h = total_h + child_h
       total_h = total_h + @spacing if i > 0
       max_w = cs.width if cs.width > max_w
       i = i + 1
     end
-    Size.new(max_w, total_h)
+    Size.new(max_w + @pad_left + @pad_right, total_h + @pad_top + @pad_bottom)
   end
 
+  # Unified layout: two-pass flex distribution + scroll offset.
+  # With approach C (auto-downgrade), scrollable containers have no EXPANDING
+  # children, so flex distribution is a no-op and content stacks sequentially.
   #: (untyped painter) -> void
   def relocate_children(painter)
     # Account for padding
@@ -90,23 +120,28 @@ class Column < Layout
     remaining = inner_h
     expanding_total_flex = 0
 
-    # First pass: measure FIXED/CONTENT children, collect EXPANDING
-    # In a Column, non-FIXED children fill the column width (for centering, word-wrap, etc.)
+    # First pass: measure CONTENT/FIXED children, collect EXPANDING flex totals
     i = 0
     while i < @children.length
       c = @children[i]
       if c.get_height_policy != EXPANDING
-        # Set width before measure so word-wrapping can calculate line count
+        # Set width before measure (for word-wrap, centering, etc.)
         if c.get_width_policy != FIXED
           c.resize_wh(inner_w, c.get_height)
         end
         cs = c.measure(painter)
+        # Use explicit height for FIXED, measured height for CONTENT
+        if c.get_height_policy == FIXED
+          child_h = c.get_height
+        else
+          child_h = cs.height
+        end
         if c.get_width_policy == FIXED
-          c.resize_wh(cs.width, cs.height)
+          c.resize_wh(cs.width, child_h)
         else
-          c.resize_wh(inner_w, cs.height)
+          c.resize_wh(inner_w, child_h)
         end
-        remaining = remaining - cs.height
+        remaining = remaining - child_h
       else
         expanding_total_flex = expanding_total_flex + c.get_flex
       end
@@ -118,7 +153,7 @@ class Column < Layout
       remaining = 0.0
     end
 
-    # Second pass: distribute remaining space to EXPANDING children, position all
+    # Second pass: distribute remaining space to EXPANDING, position all
     cy = @y + @pad_top
     if @is_scrollable
       cy = cy - @scroll_offset

data/lib/konpeito/ui/core.rb

@@ -1658,6 +1658,16 @@ class Widget
     @enable_to_detach = false
   end
 
+  #: (bool v) -> void
+  def set_cached(v)
+    @cached = v
+  end
+
+  #: () -> bool
+  def is_cached
+    @cached
+  end
+
   # --- Observer Protocol ---
 
   #: (untyped o) -> void
@@ -1923,6 +1933,9 @@ class Layout < Widget
 
   #: (untyped w) -> Layout
   def add(w)
+    if w == nil
+      return self
+    end
     # Remove from old parent if needed
     old_parent = w.get_parent
     if old_parent != nil && old_parent != self
@@ -2103,9 +2116,144 @@ class Layout < Widget
   end
 end
 
+# ===== BuildOwner =====
+# Port of ~/castella/castella/build_owner.py BuildOwner
+# Batches multiple state changes into a single rebuild pass.
+#
+# Usage:
+#   owner = BuildOwner.get
+#   owner.build_scope {
+#     state1.set(value1)
+#     state2.set(value2)
+#   }
+#   # → Only ONE rebuild for all affected components
+
+class BuildOwner
+  @@instance = nil
+
+  #: () -> BuildOwner
+  def self.get
+    if @@instance == nil
+      @@instance = BuildOwner.new
+    end
+    @@instance
+  end
+
+  #: () -> void
+  def self.reset
+    @@instance = nil
+  end
+
+  def initialize
+    @dirty_components = []
+    @in_build_scope = false
+    @scope_depth = 0
+  end
+
+  #: () -> bool
+  def is_in_build_scope
+    @in_build_scope
+  end
+
+  # Schedule a component for rebuild. Deduplicates.
+  # Inside build_scope: just adds to dirty list.
+  # Outside build_scope: immediate mode (backward compatibility).
+  #: (untyped component) -> void
+  def schedule_build_for(component)
+    # Dedup: skip if already in dirty list
+    i = 0
+    while i < @dirty_components.length
+      if @dirty_components[i] == component
+        return
+      end
+      i = i + 1
+    end
+
+    if !@in_build_scope
+      # Immediate mode: mark and trigger redraw now (don't accumulate)
+      component.mark_pending_rebuild
+      app = App.current
+      if app != nil
+        app.post_update(component)
+      end
+    else
+      # Batched mode: just add to dirty list for flush_builds
+      @dirty_components << component
+    end
+  end
+
+  # Execute a block with batched rebuilds.
+  # Supports nesting: only the outermost scope triggers flush.
+  #: () -> void
+  def build_scope
+    @scope_depth = @scope_depth + 1
+    @in_build_scope = true
+    yield
+    @scope_depth = @scope_depth - 1
+    if @scope_depth == 0
+      @in_build_scope = false
+      flush_builds
+    end
+  end
+
+  # Process all pending rebuilds: mark as pending, trigger one redraw.
+  # Components are sorted by depth (parents before children) so parent
+  # rebuilds don't cause redundant child rebuilds.
+  #: () -> void
+  def flush_builds
+    while @dirty_components.length > 0
+      # Sort by depth (parents first)
+      sorted = sort_by_depth(@dirty_components)
+      @dirty_components = []
+
+      # Mark all as pending rebuild
+      i = 0
+      while i < sorted.length
+        sorted[i].mark_pending_rebuild
+        i = i + 1
+      end
+
+      # Trigger single redraw
+      if sorted.length > 0
+        app = App.current
+        if app != nil
+          app.post_update(sorted[0])
+        end
+      end
+    end
+  end
+
+  private
+
+  # Insertion sort by widget depth (ascending)
+  #: (Array components) -> Array
+  def sort_by_depth(components)
+    result = []
+    i = 0
+    while i < components.length
+      result << components[i]
+      i = i + 1
+    end
+    i = 1
+    while i < result.length
+      j = i
+      while j > 0
+        if result[j].get_depth < result[j - 1].get_depth
+          tmp = result[j]
+          result[j] = result[j - 1]
+          result[j - 1] = tmp
+        end
+        j = j - 1
+      end
+      i = i + 1
+    end
+    result
+  end
+end
+
 # ===== Component =====
 # Port of ~/castella/castella/core.py Component
-# Now with pending_rebuild flag and proper detach on rebuild
+# Now with cache() for widget reuse and BuildOwner integration
 
 class Component < Layout
   def initialize
@@ -2114,6 +2262,8 @@ class Component < Layout
     @height_policy = EXPANDING
     @child = nil
     @pending_rebuild = false
+    @cache_data = []     # Array of [keys_array, widgets_array] pairs per cache() call
+    @cache_counter = 0   # Reset each view() call
   end
 
   # Helper: create State + auto-attach
@@ -2130,22 +2280,116 @@ class Component < Layout
     nil
   end
 
-  # State change notification -> schedule rebuild
+  # Cache widget instances across view() rebuilds.
+  # Returns an array of widgets, reusing existing ones for matching items.
+  # Items are matched by == comparison.
+  #
+  # Usage in view():
+  #   widgets = cache(items) { |item| Text.new(item.label) }
+  #   i = 0
+  #   while i < widgets.length
+  #     embed(widgets[i])
+  #     i = i + 1
+  #   end
+  #
+  #: (Array items) -> Array
+  def cache(items)
+    slot = @cache_counter
+    @cache_counter = @cache_counter + 1
+
+    # Get old cache for this slot
+    old_keys = nil
+    old_widgets = nil
+    if slot < @cache_data.length
+      entry = @cache_data[slot]
+      if entry != nil
+        old_keys = entry[0]
+        old_widgets = entry[1]
+      end
+    end
+
+    new_keys = []
+    new_widgets = []
+
+    i = 0
+    while i < items.length
+      item = items[i]
+      # Look up in old cache by == comparison
+      found = nil
+      if old_keys != nil
+        j = 0
+        while j < old_keys.length
+          if old_keys[j] != nil && old_keys[j] == item
+            found = old_widgets[j]
+            old_keys[j] = nil  # Mark as used
+            break
+          end
+          j = j + 1
+        end
+      end
+
+      if found != nil
+        found.set_cached(true)  # Safety: prevent do_unmount if somehow reached
+        new_keys << item
+        new_widgets << found
+      else
+        widget = yield(item)
+        new_keys << item
+        new_widgets << widget
+      end
+      i = i + 1
+    end
+
+    # Old widgets not reused will be detached when old tree is destroyed.
+    # Clear cached flag so they can be properly cleaned up.
+    if old_keys != nil
+      j = 0
+      while j < old_keys.length
+        if old_keys[j] != nil
+          old_widgets[j].set_cached(false)
+        end
+        j = j + 1
+      end
+    end
+
+    # Store updated cache
+    while @cache_data.length <= slot
+      @cache_data << nil
+    end
+    @cache_data[slot] = [new_keys, new_widgets]
+
+    new_widgets
+  end
+
+  # Mark this component as needing rebuild (called by BuildOwner)
   #: () -> void
-  def on_notify
+  def mark_pending_rebuild
     @pending_rebuild = true
     mark_paint_dirty
-    app = App.current
-    if app != nil
-      app.post_update(self)
-    end
+  end
+
+  # State change notification -> route to BuildOwner for batched rebuild
+  #: () -> void
+  def on_notify
+    owner = BuildOwner.get
+    owner.schedule_build_for(self)
   end
 
   #: (untyped painter, bool completely) -> void
   def redraw(painter, completely)
-    # Handle pending rebuild
+    needs_build = false
     if @pending_rebuild
       @pending_rebuild = false
+      needs_build = true
+    end
+    if @child == nil
+      needs_build = true
+    end
+
+    if needs_build
+      # Reset cache counter for view()
+      @cache_counter = 0
+
       # Save focused widget's tab_index
       saved_focus_tab = -1
       app = App.current
@@ -2156,37 +2400,39 @@ class Component < Layout
         end
       end
 
-      # Destroy old tree, build new tree
+      # Build new tree FIRST (cache() may reuse widgets from old tree).
+      # Reused widgets are removed from old tree by Layout#add() when
+      # they are added to the new tree, so they won't be affected by
+      # the subsequent old tree destruction.
+      new_child = view
+
+      # Destroy old tree (cached widgets already removed from it)
       if @child != nil
         remove(@child)
         @child.detach
         @child = nil
       end
-      @child = view
+
+      # Install new tree
+      @child = new_child
       if @child != nil
         add(@child)
         completely = true
       end
 
       # Restore focus (text restoration not needed — InputState persists)
-      if saved_focus_tab > 0 && app != nil
-        focus_target = find_focusable_by_tab_index(@child, saved_focus_tab)
-        if focus_target != nil
-          app.set_focused(focus_target)
-          focus_target.restore_focus
+      if saved_focus_tab > 0
+        app = App.current
+        if app != nil
+          focus_target = find_focusable_by_tab_index(@child, saved_focus_tab)
+          if focus_target != nil
+            app.set_focused(focus_target)
+            focus_target.restore_focus
+          end
         end
       end
     end
 
-    # Build view if needed
-    if @child == nil
-      @child = view
-      if @child != nil
-        add(@child)
-        completely = true
-      end
-    end
-
     # Relocate + redraw
     if @children.length > 0
       relocate_children(painter)

data/lib/konpeito/ui/row.rb

@@ -22,6 +22,14 @@ class Row < Layout
   #: () -> Row
   def scrollable
     @is_scrollable = true
+    # Retroactively downgrade existing EXPANDING children to CONTENT
+    i = 0
+    while i < @children.length
+      if @children[i].get_width_policy == EXPANDING
+        @children[i].set_width_policy(CONTENT)
+      end
+      i = i + 1
+    end
     self
   end
 
@@ -57,21 +65,48 @@ class Row < Layout
     update
   end
 
+  # Override add: auto-downgrade EXPANDING width to CONTENT in scrollable Row
+  #: (untyped w) -> Row
+  def add(w)
+    if w == nil
+      return self
+    end
+    if @is_scrollable && w.get_width_policy == EXPANDING
+      w.set_width_policy(CONTENT)
+    end
+    super(w)
+    self
+  end
+
   #: (untyped painter) -> Size
   def measure(painter)
     total_w = 0.0
     max_h = 0.0
     i = 0
     while i < @children.length
-      cs = @children[i].measure(painter)
-      total_w = total_w + cs.width
+      c = @children[i]
+      cs = c.measure(painter)
+      if c.get_width_policy == FIXED
+        child_w = c.get_width
+      else
+        child_w = cs.width
+      end
+      total_w = total_w + child_w
       total_w = total_w + @spacing if i > 0
-      max_h = cs.height if cs.height > max_h
+      if c.get_height_policy == FIXED
+        child_h = c.get_height
+      else
+        child_h = cs.height
+      end
+      max_h = child_h if child_h > max_h
       i = i + 1
     end
-    Size.new(total_w, max_h)
+    Size.new(total_w + @pad_left + @pad_right, max_h + @pad_top + @pad_bottom)
   end
 
+  # Unified layout: two-pass flex distribution + scroll offset.
+  # With approach C (auto-downgrade), scrollable containers have no EXPANDING
+  # width children, so flex distribution is a no-op and content stacks sequentially.
   #: (untyped painter) -> void
   def relocate_children(painter)
     # Account for padding
@@ -87,22 +122,28 @@ class Row < Layout
     remaining = inner_w
     expanding_total_flex = 0
 
-    # First pass: measure FIXED/CONTENT children, collect EXPANDING
+    # First pass: measure CONTENT/FIXED children, collect EXPANDING flex totals
     i = 0
     while i < @children.length
       c = @children[i]
       if c.get_width_policy != EXPANDING
         # Set height before measure so height-dependent layouts work
-        if c.get_height_policy == EXPANDING
+        if c.get_height_policy != FIXED
           c.resize_wh(c.get_width, inner_h)
         end
         cs = c.measure(painter)
-        if c.get_height_policy == EXPANDING
-          c.resize_wh(cs.width, inner_h)
+        # Use explicit width for FIXED, measured width for CONTENT
+        if c.get_width_policy == FIXED
+          child_w = c.get_width
+        else
+          child_w = cs.width
+        end
+        if c.get_height_policy == FIXED
+          c.resize_wh(child_w, c.get_height)
         else
-          c.resize_wh(cs.width, cs.height)
+          c.resize_wh(child_w, inner_h)
         end
-        remaining = remaining - cs.width
+        remaining = remaining - child_w
       else
         expanding_total_flex = expanding_total_flex + c.get_flex
       end
@@ -114,7 +155,7 @@ class Row < Layout
       remaining = 0.0
     end
 
-    # Second pass: distribute remaining space, position all
+    # Second pass: distribute remaining space to EXPANDING, position all
     cx = @x + @pad_left
     if @is_scrollable
       cx = cx - @scroll_offset
@@ -130,7 +171,8 @@ class Row < Layout
         end
         c.resize_wh(w, inner_h)
       else
-        if c.get_height_policy == EXPANDING
+        # In a Row, non-FIXED height children fill the row height
+        if c.get_height_policy != FIXED
           c.resize_wh(c.get_width, inner_h)
         end
       end

data/lib/konpeito/ui/theme.rb

@@ -50,7 +50,7 @@ class Theme
     @text_on_danger = 0xFF1A1B26
 
     # Kind-specific hover colors
-    @hover_normal = 0xFF414868
+    @hover_normal = 0xFF89B4FA
     @hover_info = 0xFF89B4FA
     @hover_success = 0xFFB9F27C
     @hover_warning = 0xFFFFD280
@@ -462,7 +462,7 @@ def theme_light
   t.hover_success = 0xFF567236
   t.hover_warning = 0xFFA87020
   t.hover_danger = 0xFFA35060
-  t.hover_normal = 0xFFC4C5CB
+  t.hover_normal = 0xFF4A6EA0
   t.scrollbar_bg = 0xFFC4C5CB
   t.scrollbar_fg = 0xFF9699A3
   t.bg_selected = 0x8034548A
@@ -496,7 +496,7 @@ def theme_nord
   t.hover_success = 0xFFB4D89C
   t.hover_warning = 0xFFF5D9A0
   t.hover_danger = 0xFFD08770
-  t.hover_normal = 0xFF4C566A
+  t.hover_normal = 0xFF9DD0DE
   t
 end
 
@@ -527,7 +527,7 @@ def theme_dracula
   t.hover_success = 0xFF69FF94
   t.hover_warning = 0xFFFFFFA5
   t.hover_danger = 0xFFFF6E6E
-  t.hover_normal = 0xFF6272A4
+  t.hover_normal = 0xFFD0ABFF
   t
 end
 
@@ -558,6 +558,6 @@ def theme_catppuccin
   t.hover_success = 0xFFB9F0B4
   t.hover_warning = 0xFFFFF0CC
   t.hover_danger = 0xFFFFA0B8
-  t.hover_normal = 0xFF585B70
+  t.hover_normal = 0xFFDEC0FF
   t
 end

data/lib/konpeito/ui/widgets/button.rb

@@ -15,8 +15,6 @@ class Button < Widget
     @radius = 4.0
     @hovered = false
     @click_handler = nil
-    @width_policy = CONTENT
-    @height_policy = CONTENT
     @pad_top = 8.0
     @pad_right = 16.0
     @pad_bottom = 8.0
@@ -76,8 +74,10 @@ class Button < Widget
     painter.fill_round_rect(0.0, 0.0, @width, @height, @radius, bg_c)
     ascent = painter.get_text_ascent($theme.font_family, @font_size_val)
     th = painter.measure_text_height($theme.font_family, @font_size_val)
+    tw = painter.measure_text_width(@label, $theme.font_family, @font_size_val)
+    text_x = (@width - tw) / 2.0
     text_y = (@height - th) / 2.0 + ascent
-    painter.draw_text(@label, @pad_left, text_y, $theme.font_family, @font_size_val, tc)
+    painter.draw_text(@label, text_x, text_y, $theme.font_family, @font_size_val, tc)
   end
 
   def mouse_up(ev)

data/lib/konpeito/ui/widgets/checkbox.rb

@@ -16,8 +16,6 @@ class Checkbox < Widget
     @custom_check = false
     @custom_text = false
     @hovered = false
-    @width_policy = CONTENT
-    @height_policy = CONTENT
   end
 
   def checked(v)

data/lib/konpeito/ui/widgets/container.rb

@@ -42,6 +42,24 @@ class Container < Layout
     self
   end
 
+  def measure(painter)
+    if @children.length > 0
+      c = @children[0]
+      inner_w = @width - @pad_left - @pad_right
+      if inner_w < 0.0
+        inner_w = 0.0
+      end
+      # Set child width before measuring for word-wrap support
+      if c.get_width_policy != FIXED
+        c.resize_wh(inner_w, c.get_height)
+      end
+      cs = c.measure(painter)
+      Size.new(cs.width + @pad_left + @pad_right, cs.height + @pad_top + @pad_bottom)
+    else
+      Size.new(@pad_left + @pad_right, @pad_top + @pad_bottom)
+    end
+  end
+
   def relocate_children(painter)
     if @children.length > 0
       c = @children[0]

data/lib/konpeito/ui/widgets/image.rb

@@ -14,8 +14,6 @@ class ImageWidget < Widget
     @img_width = 0.0
     @img_height = 0.0
     @fit_mode = IMAGE_FIT_CONTAIN
-    @width_policy = CONTENT
-    @height_policy = CONTENT
   end
 
   def fit(mode)

data/lib/konpeito/ui/widgets/input.rb

@@ -23,8 +23,6 @@ class Input < Widget
     @use_theme = true
     @radius = 4.0
     @focusable = true
-    @width_policy = EXPANDING
-    @height_policy = CONTENT
     @pad_top = 8.0
     @pad_right = 12.0
     @pad_bottom = 8.0

data/lib/konpeito/ui/widgets/markdown.rb

@@ -11,8 +11,6 @@ class Markdown < Widget
     @ast = nil
     @content_height = 0.0
     @padding_val = 12.0
-    @width_policy = EXPANDING
-    @height_policy = CONTENT
   end
 
   def padding(p)

data/lib/konpeito/ui/widgets/multiline_text.rb

@@ -14,8 +14,6 @@ class MultilineText < Widget
     @line_spacing = 4.0
     @wrap_enabled = false
     @border_width_val = 1.0
-    @width_policy = EXPANDING
-    @height_policy = CONTENT
     @cached_lines = []
   end
 

data/lib/konpeito/ui/widgets/net_image.rb

@@ -9,8 +9,6 @@ class NetImageWidget < Widget
     @img_width = 0.0
     @img_height = 0.0
     @fit_mode = IMAGE_FIT_CONTAIN
-    @width_policy = CONTENT
-    @height_policy = CONTENT
   end
 
   def fit(mode)

data/lib/konpeito/ui/widgets/radio_buttons.rb

@@ -10,8 +10,6 @@ class RadioButtons < Widget
     @selected = 0
     @change_handler = nil
     @hovered_index = -1
-    @width_policy = EXPANDING
-    @height_policy = CONTENT
     # Colors (Tokyo Night)
     @text_color = 0xFFC0CAF5
     @ring_color = 0xFF565F89

data/lib/konpeito/ui/widgets/switch.rb

@@ -6,8 +6,6 @@ class Switch < Widget
     super()
     @on = false
     @change_handler = nil
-    @width_policy = CONTENT
-    @height_policy = CONTENT
     # Colors (Tokyo Night)
     @on_color = 0xFF7AA2F7
     @off_color = 0xFF414868

data/lib/konpeito/ui/widgets/text.rb

@@ -18,8 +18,6 @@ class Text < Widget
     @text_align = TEXT_ALIGN_LEFT
     @font_weight = 0
     @font_slant = 0
-    @width_policy = CONTENT
-    @height_policy = CONTENT
   end
 
   def font_size(s)
@@ -85,6 +83,16 @@ class Text < Widget
   def redraw(painter, completely)
     ff = resolved_font_family
     ascent = painter.get_text_ascent(ff, @font_size_val)
+    th = painter.measure_text_height(ff, @font_size_val)
+
+    # Vertical centering when widget is taller than text
+    if @height > th
+      y_offset = (@height - th) / 2.0 + ascent
+    else
+      y_offset = ascent
+    end
+
+    # Horizontal alignment
     x_offset = 0.0
     if @text_align == TEXT_ALIGN_CENTER
       text_w = painter.measure_text_width(@text, ff, @font_size_val)
@@ -100,7 +108,7 @@ class Text < Widget
       end
     end
     c = @custom_color ? @color_val : $theme.text_color_for_kind(@kind_val)
-    painter.draw_text(@text, x_offset, ascent, ff, @font_size_val, c, @font_weight, @font_slant)
+    painter.draw_text(@text, x_offset, y_offset, ff, @font_size_val, c, @font_weight, @font_slant)
   end
 end
 

data/lib/konpeito/ui/widgets/tree.rb

@@ -179,6 +179,12 @@ class Tree < Widget
     update
   end
 
+  def measure(painter)
+    rebuild_visible
+    h = @visible_nodes.length * 1.0 * TREE_ROW_HEIGHT
+    Size.new(@width, h)
+  end
+
   def get_scrollable
     @scrollable_flag
   end

data/lib/konpeito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Konpeito
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Yasushi Itoh