konpeito 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e06886ab2b9bd1bcc2638dcc1c0788c7a0bbe40c0416a630eb89ca8e86945a7a
-  data.tar.gz: 3921d4b460e10864329173fcdf6ba0c925c89ad9d7959fab5ac74c640041e0e4
+  metadata.gz: 53a3bbb24175ed554f9f560c38e6f8138206da3fb6385f87358e9dfa3eed4f10
+  data.tar.gz: 80026dca6352dcb9effa9e7bac8e7ebc58e517ae84cb1f15627935fbb3d5fee4
 SHA512:
-  metadata.gz: 970fff312f787c003978377350ff5cbeeccd46aab454999b1214d1c17a2e04530c2ec9149a4015b6c477cd21984b43ebf03390120cd1ce9b22670fe767845338
-  data.tar.gz: 32b1f3c137e224a89f57df986f667a3bc4fbe9ea12997b340927ed70e7b00458b10106be3b1f827f86ff4e147e79eafc94601b4026ce225284e4fe2d06a4597c
+  metadata.gz: 4233ae433c5730c64da97806275ca0300d80f77e5af8c338cf2185f54205d69b99091447a097506b5d2944dac437396a8a4e04ae9a97a90df60f8a93d60e730d
+  data.tar.gz: 911c32b9ac29989060b08fe6fc352074a02038ae20f8b516723e56a263bf602b0ee70206cf41a3bbe682044ab4c7511552fa255ef9d7b137da952dcea271f860

data/CHANGELOG.md

@@ -5,6 +5,33 @@ 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
+- JVM backend: detect and resolve field type conflicts in `dedup_inherited_fields` to prevent runtime NPE when parent/child classes use same ivar with different types
+- JVM backend: UI layout fixes for Castella dashboard (`.class` dispatch, `attr_accessor` field access, scrollbar thumb rendering, etc.)
+- Remove duplicate `source_code_uri` from gemspec metadata
+- Remove debug `puts` from data_table widget
+
+### Added
+- Castella UI: visual properties (`bg_color`, `border_radius`, `border_color`, `border_width`) directly on Column/Row layouts, eliminating Container wrapper boilerplate
+
+### Changed
+- Documentation: note that JVM backend might be more mature than LLVM backend
+
 ## [0.1.0] - 2026-02-13
 
 ### Added
@@ -72,4 +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

@@ -187,6 +187,10 @@ module Konpeito
         # Classes are generated before main class, so we need this early.
         prescan_top_level_constants(hir_program)
 
+        # Pre-scan: register global variable static fields early so that
+        # global variables referenced inside blocks have fields available.
+        prescan_global_variables(hir_program)
+
         # Generate module interfaces FIRST (before classes that may implement them)
         hir_program.modules.each do |module_def|
           @block_methods = []
@@ -294,17 +298,43 @@ module Konpeito
         }
       end
 
+      # Yield every instruction in basic_blocks, recursing into block bodies
+      # attached to HIR::Call nodes.
+      def each_instruction_recursive(basic_blocks, &blk)
+        basic_blocks.each do |bb|
+          bb.instructions.each do |inst|
+            blk.call(inst)
+            if inst.is_a?(HIR::Call) && inst.block
+              each_instruction_recursive(inst.block.body, &blk)
+            end
+          end
+        end
+      end
+
       # Pre-scan top-level StoreConstant instructions to populate @constant_fields early.
       # This is needed because user classes are generated before the main class, and
       # class constructors may reference top-level constants (e.g. EXPANDING = 1).
+      # Recurses into block bodies so constants defined inside lambdas are also found.
       def prescan_top_level_constants(hir_program)
         hir_program.functions.each do |func|
           next if func.owner_class || func.owner_module
-          func.body.each do |bb|
-            bb.instructions.each do |inst|
-              if inst.is_a?(HIR::StoreConstant) && inst.scope.nil?
-                @constant_fields << inst.name.to_s
-              end
+          each_instruction_recursive(func.body) do |inst|
+            if inst.is_a?(HIR::StoreConstant) && inst.scope.nil?
+              @constant_fields << inst.name.to_s
+            end
+          end
+        end
+      end
+
+      # Pre-scan all functions for global variable access (LoadGlobalVar/StoreGlobalVar)
+      # and register the corresponding static fields early. This ensures global variables
+      # referenced inside blocks have their fields available during code generation.
+      def prescan_global_variables(hir_program)
+        hir_program.functions.each do |func|
+          each_instruction_recursive(func.body) do |inst|
+            if inst.is_a?(HIR::LoadGlobalVar) || inst.is_a?(HIR::StoreGlobalVar)
+              field_name = inst.name.sub(/^\$/, "GLOBAL_")
+              register_global_field(field_name)
             end
           end
         end
@@ -3118,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
 
@@ -3709,6 +3755,11 @@ module Konpeito
       # Remove fields from child classes that are already declared on a parent class.
       # Must run AFTER all classes are registered (register_class_info) since the
       # HIR class order may register children before parents.
+      #
+      # Type conflict detection: when a child class assigns a concrete but different type
+      # to a field that the parent typed narrowly (e.g. parent :i64, child :string), widen
+      # the parent's field to :value (Object) to prevent runtime NPE.
+      # If the child type is :value (unresolved/unknown), keep the parent's concrete type.
       def dedup_inherited_fields
         @class_info.each do |class_name, info|
           parent = info[:super_name]
@@ -3719,6 +3770,16 @@ module Konpeito
             if parent_info[:fields]
               parent_info[:fields].each_key do |fname|
                 if info[:fields].key?(fname)
+                  child_type = info[:fields][fname]
+                  parent_type = parent_info[:fields][fname]
+                  # Only widen when both types are concrete but different.
+                  # If child is :value (unknown), trust the parent's type.
+                  # If parent is :value, trust it (already wide enough).
+                  if child_type != parent_type && child_type != :value && parent_type != :value
+                    warn "[konpeito] JVM field type conflict: #{parent_name}##{fname} is :#{parent_type}, " \
+                         "but subclass #{class_name} uses :#{child_type}. Widening to :value (Object)."
+                    parent_info[:fields][fname] = :value
+                  end
                   info[:fields].delete(fname)
                 end
               end
@@ -5069,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
@@ -5189,8 +5258,13 @@ module Konpeito
                     end
         instructions = []
 
-        # Load self
-        instructions << { "op" => "aload", "var" => 0 }
+        # Load self — use @block_self_slot if inside a block that captured self
+        self_slot = @block_self_slot || 0
+        instructions << { "op" => "aload", "var" => self_slot }
+        # If self was captured as Object, checkcast to the expected class
+        if @block_self_slot
+          instructions << { "op" => "checkcast", "type" => jvm_class }
+        end
 
         # Prefer registered descriptor for consistency with method definition
         registered = @method_descriptors["#{@current_class_name}##{method_name}"]
@@ -6478,7 +6552,8 @@ module Konpeito
         instructions
       end
 
-      # Check if a block body accesses instance variables (needs self reference).
+      # Check if a block body accesses instance variables or calls methods on
+      # implicit self (receiver-less calls like `kpi_card(label, value)`).
       # Recursively checks nested blocks (e.g., on_click inside a yield block)
       # so that outer blocks capture self when inner blocks need it.
       def block_needs_self?(block_def)
@@ -6486,6 +6561,8 @@ module Konpeito
           bb.instructions.any? { |inst|
             if inst.is_a?(HIR::LoadInstanceVar) || inst.is_a?(HIR::StoreInstanceVar)
               true
+            elsif inst.is_a?(HIR::Call) && (inst.receiver.nil? || inst.receiver.is_a?(HIR::SelfRef))
+              true
             elsif inst.is_a?(HIR::Call) && inst.block
               block_needs_self?(inst.block)
             else

data/lib/konpeito/hir/builder.rb

@@ -2072,12 +2072,14 @@ module Konpeito
             # Check if this is a keyword hash argument
             if arg.node.is_a?(Prism::KeywordHashNode)
               # Extract keyword arguments from the hash
-              arg.node.elements.each do |elem|
+              # arg.children are typed AssocNode wrappers; each has children[0]=key, children[1]=value
+              arg.node.elements.each_with_index do |elem, ei|
                 if elem.is_a?(Prism::AssocNode) && elem.key.is_a?(Prism::SymbolNode)
                   key_name = elem.key.unescaped.to_sym
-                  # Find the typed value from the children
-                  value_typed = arg.children.find { |c| c.node == elem.value }
-                  if value_typed
+                  # Navigate through the typed AssocNode to get the typed value child
+                  typed_assoc = arg.children[ei]
+                  if typed_assoc && typed_assoc.children && typed_assoc.children.size >= 2
+                    value_typed = typed_assoc.children[1]
                     keyword_args[key_name] = visit(value_typed)
                   else
                     # Fallback: create typed node for the value

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,38 +68,80 @@ 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)
-    remaining = @height
+    # Account for padding
+    inner_w = @width - @pad_left - @pad_right
+    inner_h = @height - @pad_top - @pad_bottom
+    if inner_w < 0.0
+      inner_w = 0.0
+    end
+    if inner_h < 0.0
+      inner_h = 0.0
+    end
+
+    remaining = inner_h
     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_height_policy != EXPANDING
-        # Set width before measure so word-wrapping can calculate line count
-        if c.get_width_policy == EXPANDING
-          c.resize_wh(@width, c.get_height)
+        # 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)
-        c.resize_wh(@width, cs.height)
-        remaining = remaining - cs.height
+        # 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, child_h)
+        else
+          c.resize_wh(inner_w, child_h)
+        end
+        remaining = remaining - child_h
       else
         expanding_total_flex = expanding_total_flex + c.get_flex
       end
@@ -103,8 +153,8 @@ class Column < Layout
       remaining = 0.0
     end
 
-    # Second pass: distribute remaining space to EXPANDING children, position all
-    cy = @y
+    # Second pass: distribute remaining space to EXPANDING, position all
+    cy = @y + @pad_top
     if @is_scrollable
       cy = cy - @scroll_offset
     end
@@ -117,14 +167,14 @@ class Column < Layout
         if expanding_total_flex > 0 && remaining > 0.0
           h = remaining * c.get_flex / expanding_total_flex
         end
-        c.resize_wh(@width, h)
+        c.resize_wh(inner_w, h)
       else
-        # Set width for non-expanding too
-        if c.get_width_policy == EXPANDING
-          c.resize_wh(@width, c.get_height)
+        # In a Column, non-FIXED children fill the column width
+        if c.get_width_policy != FIXED
+          c.resize_wh(inner_w, c.get_height)
         end
       end
-      c.move_xy(@x, cy)
+      c.move_xy(@x + @pad_left, cy)
       cy = cy + c.get_height + @spacing
       total_content_h = total_content_h + c.get_height
       total_content_h = total_content_h + @spacing if i > 0
@@ -134,7 +184,7 @@ class Column < Layout
 
     # Auto-scroll to bottom when pinned
     if @pin_bottom && @is_scrollable
-      max_scroll = @content_height - @height
+      max_scroll = @content_height - inner_h
       if max_scroll > 0.0
         @scroll_offset = max_scroll
       end
@@ -143,9 +193,24 @@ class Column < Layout
 
   #: (untyped painter, bool completely) -> void
   def redraw(painter, completely)
+    saved_bg = $__bg_clear_color
+    # When this layout has a custom background and is dirty, we handle clearing
+    # ourselves to preserve rounded corners. Clear dirty flag so redraw_children
+    # won't overwrite with a solid fill_rect.
+    if @custom_bg && is_dirty
+      parent_bg = saved_bg
+      if parent_bg == nil || parent_bg == 0
+        parent_bg = $theme.bg_canvas
+      end
+      painter.fill_rect(0.0, 0.0, @width, @height, parent_bg)
+      set_dirty(false)
+      completely = true
+    end
+    draw_visual_background(painter)
     relocate_children(painter)
     redraw_children(painter, completely)
     draw_scrollbar(painter) if @is_scrollable
+    $__bg_clear_color = saved_bg
   end
 
   #: (untyped painter) -> void