kumiki 0.1.1

data/lib/kumiki/markdown/theme.rb

@@ -0,0 +1,168 @@
+module Kumiki
+  # Markdown theme - color and size tokens for markdown rendering
+  # Integrates with the global Kumiki.theme
+
+  class MarkdownTheme
+    def initialize
+      # Text colors - derive from global theme
+      @text_color = Kumiki.theme.text_primary
+      @heading_color = Kumiki.theme.accent
+      @link_color = Kumiki.theme.accent
+      @code_color = Kumiki.theme.warning
+      @emphasis_color = 0xFF9AA5CE       # Slightly muted blue for italic
+      @strikethrough_color = Kumiki.theme.text_secondary
+
+      # Background colors
+      @code_bg_color = Kumiki.theme.bg_secondary
+      @code_inline_bg = Kumiki.theme.bg_secondary
+      @blockquote_bg = Kumiki.theme.accent
+
+      # Heading sizes
+      @h1_size = 28.0
+      @h2_size = 24.0
+      @h3_size = 20.0
+      @h4_size = 18.0
+      @h5_size = 16.0
+      @h6_size = 14.0
+      @base_font_size = 14.0
+
+      # Table colors
+      @table_header_bg = Kumiki.theme.bg_secondary
+      @table_border_color = Kumiki.theme.text_secondary
+      @checkbox_checked_color = Kumiki.theme.success
+      @checkbox_unchecked_color = Kumiki.theme.text_secondary
+
+      # Mermaid colors
+      @mermaid_node_fill = 0xFF4A90D9
+      @mermaid_node_stroke = 0xFF2C5F8A
+      @mermaid_node_text = 0xFFFFFFFF
+      @mermaid_edge_color = Kumiki.theme.text_secondary
+      @mermaid_subgraph_bg = 0x20FFFFFF
+      @mermaid_subgraph_border = Kumiki.theme.text_secondary
+      @mermaid_font_size = 12.0
+
+      # Spacing
+      @paragraph_spacing = 8.0
+      @block_spacing = 12.0
+      @list_indent = 24.0
+      @blockquote_indent = 20.0
+    end
+
+    def text_color
+      @text_color
+    end
+
+    def heading_color
+      @heading_color
+    end
+
+    def link_color
+      @link_color
+    end
+
+    def code_color
+      @code_color
+    end
+
+    def emphasis_color
+      @emphasis_color
+    end
+
+    def strikethrough_color
+      @strikethrough_color
+    end
+
+    def code_bg_color
+      @code_bg_color
+    end
+
+    def code_inline_bg
+      @code_inline_bg
+    end
+
+    def blockquote_bg
+      @blockquote_bg
+    end
+
+    def base_font_size
+      @base_font_size
+    end
+
+    def paragraph_spacing
+      @paragraph_spacing
+    end
+
+    def block_spacing
+      @block_spacing
+    end
+
+    def list_indent
+      @list_indent
+    end
+
+    def blockquote_indent
+      @blockquote_indent
+    end
+
+    def table_header_bg
+      @table_header_bg
+    end
+
+    def table_border_color
+      @table_border_color
+    end
+
+    def checkbox_checked_color
+      @checkbox_checked_color
+    end
+
+    def checkbox_unchecked_color
+      @checkbox_unchecked_color
+    end
+
+    def mermaid_node_fill
+      @mermaid_node_fill
+    end
+
+    def mermaid_node_stroke
+      @mermaid_node_stroke
+    end
+
+    def mermaid_node_text
+      @mermaid_node_text
+    end
+
+    def mermaid_edge_color
+      @mermaid_edge_color
+    end
+
+    def mermaid_subgraph_bg
+      @mermaid_subgraph_bg
+    end
+
+    def mermaid_subgraph_border
+      @mermaid_subgraph_border
+    end
+
+    def mermaid_font_size
+      @mermaid_font_size
+    end
+
+    def heading_size(level)
+      if level == 1
+        @h1_size
+      elsif level == 2
+        @h2_size
+      elsif level == 3
+        @h3_size
+      elsif level == 4
+        @h4_size
+      elsif level == 5
+        @h5_size
+      else
+        @h6_size
+      end
+    end
+  end
+
+end

data/lib/kumiki/render_node.rb

@@ -0,0 +1,262 @@
+module Kumiki
+  # rbs_inline: enabled
+
+  # RenderNode system - layout/paint dirty tracking and z-order caching
+
+  # Base render node with fine-grained dirty tracking
+  class RenderNodeBase
+    #: (untyped widget) -> void
+    def initialize(widget)
+      @widget = widget
+      @layout_dirty = true
+      @paint_dirty = true
+      @subtree_dirty = false
+      @measured_size = nil
+    end
+
+    #: () -> untyped
+    def get_widget
+      @widget
+    end
+
+    # ===== Dirty Tracking =====
+
+    #: () -> bool
+    def is_layout_dirty
+      @layout_dirty
+    end
+
+    #: () -> bool
+    def is_paint_dirty
+      @paint_dirty
+    end
+
+    #: () -> void
+    def mark_layout_dirty
+      @layout_dirty = true
+      @paint_dirty = true
+      @measured_size = nil
+    end
+
+    #: () -> void
+    def mark_paint_dirty
+      @paint_dirty = true
+    end
+
+    #: () -> bool
+    def is_subtree_dirty
+      @subtree_dirty
+    end
+
+    #: () -> void
+    def mark_subtree_dirty
+      @subtree_dirty = true
+    end
+
+    #: () -> void
+    def clear_dirty
+      @layout_dirty = false
+      @paint_dirty = false
+      @subtree_dirty = false
+    end
+
+    # ===== Layout =====
+
+    #: (untyped painter) -> Size
+    def cached_measure(painter)
+      if @measured_size == nil || @layout_dirty
+        @measured_size = @widget.measure(painter)
+      end
+      @measured_size
+    end
+
+    # ===== Hit Testing =====
+
+    #: (Point point) -> bool
+    def hit_test(point)
+      @widget.contain(point)
+    end
+  end
+
+  # Layout render node with z-order caching and child management
+  class LayoutRenderNode < RenderNodeBase
+    #: (untyped widget) -> void
+    def initialize(widget)
+      super(widget)
+      @children = []
+      @sorted_children = nil
+      @z_order_dirty = true
+    end
+
+    # ===== Child Management =====
+
+    #: (untyped child) -> void
+    def add_child(child)
+      @children << child
+      @z_order_dirty = true
+      mark_layout_dirty
+    end
+
+    #: (untyped child) -> void
+    def remove_child(child)
+      i = 0
+      while i < @children.length
+        if @children[i] == child
+          @children.delete_at(i)
+          @z_order_dirty = true
+          mark_layout_dirty
+          return
+        end
+        i = i + 1
+      end
+    end
+
+    #: () -> void
+    def clear_children
+      @children = []
+      @sorted_children = nil
+      @z_order_dirty = true
+      mark_layout_dirty
+    end
+
+    #: () -> Integer
+    def child_count
+      @children.length
+    end
+
+    #: () -> Array
+    def get_children
+      @children
+    end
+
+    # ===== Z-Order Management =====
+
+    #: () -> void
+    def invalidate_z_order
+      @z_order_dirty = true
+      @sorted_children = nil
+    end
+
+    #: () -> Array
+    def get_sorted_children
+      if @z_order_dirty || @sorted_children == nil
+        # Copy children list
+        @sorted_children = []
+        i = 0
+        while i < @children.length
+          @sorted_children << @children[i]
+          i = i + 1
+        end
+        # Sort by z_index (bubble sort - children count is typically small)
+        changed = true
+        while changed
+          changed = false
+          j = 0
+          while j < @sorted_children.length - 1
+            if @sorted_children[j].get_z_index > @sorted_children[j + 1].get_z_index
+              tmp = @sorted_children[j]
+              @sorted_children[j] = @sorted_children[j + 1]
+              @sorted_children[j + 1] = tmp
+              changed = true
+            end
+            j = j + 1
+          end
+        end
+        @z_order_dirty = false
+      end
+      @sorted_children
+    end
+
+    # Paint order: lower z-index first (background to foreground)
+    #: () -> Array
+    def iter_paint_order
+      get_sorted_children
+    end
+
+    # Hit test order: higher z-index first (foreground to background)
+    #: () -> Array
+    def iter_hit_test_order
+      sorted = get_sorted_children
+      result = []
+      i = sorted.length - 1
+      while i >= 0
+        result << sorted[i]
+        i = i - 1
+      end
+      result
+    end
+
+    # ===== Dirty Propagation =====
+
+    #: () -> bool
+    def is_any_child_dirty
+      i = 0
+      while i < @children.length
+        if @children[i].is_dirty
+          return true
+        end
+        i = i + 1
+      end
+      false
+    end
+  end
+
+  # Scrollable layout render node with viewport culling
+  class ScrollableLayoutRenderNode < LayoutRenderNode
+    #: (untyped widget) -> void
+    def initialize(widget)
+      super(widget)
+      @scroll_x = 0.0
+      @scroll_y = 0.0
+      @viewport_width = 0.0
+      @viewport_height = 0.0
+      @viewport_set = false
+    end
+
+    #: () -> Float
+    def get_scroll_x
+      @scroll_x
+    end
+
+    #: (Float v) -> void
+    def set_scroll_x(v)
+      if @scroll_x != v
+        @scroll_x = v
+        mark_paint_dirty
+      end
+    end
+
+    #: () -> Float
+    def get_scroll_y
+      @scroll_y
+    end
+
+    #: (Float v) -> void
+    def set_scroll_y(v)
+      if @scroll_y != v
+        @scroll_y = v
+        mark_paint_dirty
+      end
+    end
+
+    #: (Float w, Float h) -> void
+    def set_viewport_size(w, h)
+      @viewport_width = w
+      @viewport_height = h
+      @viewport_set = true
+    end
+
+    #: (untyped child) -> bool
+    def is_child_visible(child)
+      if !@viewport_set
+        return true
+      end
+      cx = child.get_x - @scroll_x
+      cy = child.get_y - @scroll_y
+      cw = child.get_width
+      ch = child.get_height
+      !(cx + cw < 0.0 || cx > @viewport_width || cy + ch < 0.0 || cy > @viewport_height)
+    end
+  end
+
+end

data/lib/kumiki/row.rb

@@ -0,0 +1,288 @@
+module Kumiki
+  # rbs_inline: enabled
+
+  # Row layout - horizontal arrangement of children
+
+  class Row < Layout
+    def initialize
+      super
+      @spacing = 0.0
+      @is_scrollable = false
+      @scroll_offset = 0.0
+      @content_width = 0.0
+      @pin_right = false
+      @external_scroll_state = nil
+    end
+
+    #: (Float s) -> Row
+    def spacing(s)
+      @spacing = s
+      self
+    end
+
+    #: (ScrollState ss) -> Row
+    def scroll_state(ss)
+      @external_scroll_state = ss
+      @scroll_offset = ss.x
+      self
+    end
+
+    #: () -> 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
+
+    #: () -> Row
+    def pin_to_end
+      @pin_right = true
+      self
+    end
+
+    #: () -> bool
+    def is_scrollable
+      @is_scrollable
+    end
+
+    #: (bool is_direction_x) -> bool
+    def has_scrollbar(is_direction_x)
+      if is_direction_x
+        @is_scrollable
+      else
+        false
+      end
+    end
+
+    #: () -> Float
+    def get_scroll_offset
+      @scroll_offset
+    end
+
+    #: (Float v) -> void
+    def set_scroll_offset(v)
+      @scroll_offset = v
+      @external_scroll_state&.set_x(v)
+      mark_dirty
+      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
+        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
+        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 + @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
+      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_w
+      expanding_total_flex = 0
+
+      # 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 != FIXED
+            c.resize_wh(c.get_width, inner_h)
+          end
+          cs = c.measure(painter)
+          # 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(child_w, inner_h)
+          end
+          remaining = remaining - child_w
+        else
+          expanding_total_flex = expanding_total_flex + c.get_flex
+        end
+        remaining = remaining - @spacing if i > 0
+        i = i + 1
+      end
+
+      if remaining < 0.0
+        remaining = 0.0
+      end
+
+      # Second pass: distribute remaining space to EXPANDING, position all
+      cx = @x + @pad_left
+      if @is_scrollable
+        cx = cx - @scroll_offset
+      end
+      total_content_w = 0.0
+      i = 0
+      while i < @children.length
+        c = @children[i]
+        if c.get_width_policy == EXPANDING
+          w = 0.0
+          if expanding_total_flex > 0 && remaining > 0.0
+            w = remaining * c.get_flex / expanding_total_flex
+          end
+          c.resize_wh(w, inner_h)
+        else
+          # 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
+        c.move_xy(cx, @y + @pad_top)
+        cx = cx + c.get_width + @spacing
+        total_content_w = total_content_w + c.get_width
+        total_content_w = total_content_w + @spacing if i > 0
+        i = i + 1
+      end
+      @content_width = total_content_w
+
+      # Auto-scroll to end when pinned
+      if @pin_right && @is_scrollable
+        max_scroll = @content_width - inner_w
+        if max_scroll > 0.0
+          @scroll_offset = max_scroll
+          @external_scroll_state&.set_x(@scroll_offset)
+        end
+      end
+    end
+
+    #: (untyped painter, bool completely) -> void
+    def redraw(painter, completely)
+      saved_bg = Kumiki._bg_clear_color
+      if @custom_bg && is_dirty
+        parent_bg = saved_bg
+        if parent_bg == nil || parent_bg == 0
+          parent_bg = Kumiki.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
+      Kumiki._bg_clear_color = saved_bg
+    end
+
+    #: (untyped painter) -> void
+    def draw_scrollbar(painter)
+      viewport_w = @width
+      content_w = @content_width
+      return if content_w <= viewport_w
+
+      bar_height = 8.0
+      thumb_color = 0xC0AAAAAA
+
+      # Thumb
+      thumb_w = viewport_w * viewport_w / content_w
+      if thumb_w < 20.0
+        thumb_w = 20.0
+      end
+      thumb_x = (@scroll_offset / content_w) * viewport_w
+      if thumb_x + thumb_w > viewport_w
+        thumb_x = viewport_w - thumb_w
+      end
+      painter.fill_round_rect(thumb_x, @height - bar_height + 2.0, thumb_w, bar_height - 4.0, 2.0, thumb_color)
+    end
+
+    #: (WheelEvent ev) -> void
+    def mouse_wheel(ev)
+      if @is_scrollable
+        scroll_speed = 30.0
+        @scroll_offset = @scroll_offset - ev.delta_y * scroll_speed
+        # Clamp scroll offset
+        max_scroll = @content_width - @width
+        if max_scroll < 0.0
+          max_scroll = 0.0
+        end
+        if @scroll_offset < 0.0
+          @scroll_offset = 0.0
+        end
+        if @scroll_offset > max_scroll
+          @scroll_offset = max_scroll
+        end
+        # Toggle pin_to_end: disable on scroll left, re-enable at end
+        if ev.delta_y > 0.0
+          @pin_right = false
+        end
+        if max_scroll > 0.0 && @scroll_offset >= max_scroll
+          @pin_right = true
+        end
+        @external_scroll_state&.set_x(@scroll_offset)
+        mark_dirty
+        update
+      end
+    end
+  end
+
+  # Top-level helper
+  #: (*untyped children) -> Row
+  def Row(*children)
+    row = Row.new
+    i = 0
+    while i < children.length
+      row.add(children[i])
+      i = i + 1
+    end
+    row
+  end
+
+end