kumiki 0.1.1

data/lib/kumiki/chart/stacked_bar_chart.rb

@@ -0,0 +1,279 @@
+module Kumiki
+  # StackedBarChart - stacked bar chart widget
+  # Supports multiple series stacked on top of each other, hover highlight
+
+  class StackedBarChart < BaseChart
+    def initialize(categories, series_data, series_names)
+      super()
+      @categories = categories
+      @series_data = series_data
+      @series_names = series_names
+      @show_values = false
+      @bar_radius = 0.0
+      @data_min = 0.0
+      @data_max = 0.0
+      @y_scale = nil
+      @y_ticks = nil
+      @band = nil
+      @bar_w = 2.0
+      @baseline_y = 0.0
+      @num_series = 0
+      @num_cats = 0
+      @y_range_min = 0.0
+      @y_range_max = 1.0
+      @chart_px = 0.0
+      @chart_py = 0.0
+      @chart_pw = 0.0
+      @chart_ph = 0.0
+      compute_stacked_range
+    end
+
+    def show_values(v)
+      @show_values = v
+      self
+    end
+
+    def bar_radius(r)
+      @bar_radius = r
+      self
+    end
+
+    def set_data(categories, series_data, series_names)
+      @categories = categories
+      @series_data = series_data
+      @series_names = series_names
+      compute_stacked_range
+      mark_dirty
+      update
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+      return if @categories.length == 0
+      return if @series_data.length == 0
+      @chart_px = px
+      @chart_py = py
+      @chart_pw = pw
+      @chart_ph = ph
+      @num_series = @series_data.length
+      @num_cats = @categories.length
+      setup_stacked_ticks
+      setup_stacked_y_scale
+      setup_stacked_band
+      @baseline_y = @y_scale.map(0.0)
+      bmax = @chart_py + @chart_ph
+      if @baseline_y > bmax
+        @baseline_y = bmax
+      end
+      draw_y_axis(painter, px, py, pw, ph, @y_ticks, @y_scale)
+      draw_x_axis_line(painter, px, py, pw, ph)
+      draw_stacked_cat_labels(painter)
+      draw_all_stacked_bars(painter)
+      draw_stacked_legend(painter, px, py)
+    end
+
+    def setup_stacked_ticks
+      @y_ticks = compute_ticks(@data_min, @data_max, 5)
+      @y_range_min = @data_min
+      @y_range_max = @data_max
+      if @y_ticks.length > 0
+        @y_range_min = @y_ticks[0]
+        @y_range_max = @y_ticks[@y_ticks.length - 1]
+      end
+    end
+
+    def setup_stacked_y_scale
+      bottom = @chart_py + @chart_ph
+      @y_scale = LinearScale.new(@y_range_min, @y_range_max, bottom, @chart_py)
+    end
+
+    def setup_stacked_band
+      right = @chart_px + @chart_pw
+      nc = @num_cats * 1.0
+      @band = BandScale.new(nc, @chart_px, right, 12.0)
+      @bar_w = @band.band_width
+    end
+
+    def draw_stacked_cat_labels(painter)
+      lc = Kumiki.theme.text_secondary
+      i = 0
+      while i < @num_cats
+        i_f = i * 1.0
+        bx = @band.map(i_f)
+        label = @categories[i]
+        lw = painter.measure_text_width(label, Kumiki.theme.font_family, 11.0)
+        ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+        label_x = bx + @bar_w / 2.0 - lw / 2.0
+        label_y = @chart_py + @chart_ph + 14.0 + ascent
+        painter.draw_text(label, label_x, label_y, Kumiki.theme.font_family, 11.0, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_all_stacked_bars(painter)
+      ci = 0
+      while ci < @num_cats
+        draw_stacked_column(painter, ci)
+        ci = ci + 1
+      end
+    end
+
+    def draw_stacked_column(painter, ci)
+      ci_f = ci * 1.0
+      bx = @band.map(ci_f)
+      cumulative = 0.0
+      si = 0
+      while si < @num_series
+        val = @series_data[si][ci]
+        top_val = cumulative + val
+        bar_bottom = @y_scale.map(cumulative)
+        bar_top = @y_scale.map(top_val)
+        bar_h = bar_bottom - bar_top
+        if bar_h < 0.0
+          bar_h = 0.0 - bar_h
+          bar_top = bar_bottom
+        end
+        c = series_color(si)
+        if @hover_index == ci
+          if @hover_series == si
+            c = painter.lighten_color(c, 0.3)
+          end
+        end
+        painter.fill_round_rect(bx, bar_top, @bar_w, bar_h, @bar_radius, c)
+        if @show_values
+          if val > 0.0
+            vl = painter.number_to_string(val)
+            vw = painter.measure_text_width(vl, Kumiki.theme.font_family, 9.0)
+            ascent = painter.get_text_ascent(Kumiki.theme.font_family, 9.0)
+            vx = bx + @bar_w / 2.0 - vw / 2.0
+            vy = bar_top + bar_h / 2.0 + ascent / 2.0
+            painter.draw_text(vl, vx, vy, Kumiki.theme.font_family, 9.0, 4294967295)
+          end
+        end
+        cumulative = top_val
+        si = si + 1
+      end
+    end
+
+    def draw_stacked_legend(painter, px, py)
+      if @show_legend
+        if @series_names.length > 1
+          colors = []
+          si = 0
+          while si < @series_names.length
+            colors << series_color(si)
+            si = si + 1
+          end
+          draw_legend(painter, @series_names, colors, px + 8.0, py - 20.0)
+        end
+      end
+    end
+
+    def update_hover
+      return if @band == nil
+      mx = @mouse_x
+      my = @mouse_y
+      px = plot_x
+      py = plot_y
+      pw = plot_w
+      ph = plot_h
+      if mx < px
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      if mx > px + pw
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      if my < py
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      if my > py + ph
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      find_stacked_hover(mx, my)
+    end
+
+    def find_stacked_hover(mx, my)
+      @hover_index = -1
+      @hover_series = -1
+      ci = 0
+      while ci < @num_cats
+        ci_f = ci * 1.0
+        bx = @band.map(ci_f)
+        if mx >= bx
+          if mx <= bx + @bar_w
+            # Found the category, now find which series segment
+            cumulative = 0.0
+            si = 0
+            while si < @num_series
+              val = @series_data[si][ci]
+              top_val = cumulative + val
+              bar_bottom = @y_scale.map(cumulative)
+              bar_top = @y_scale.map(top_val)
+              if bar_top > bar_bottom
+                tmp = bar_top
+                bar_top = bar_bottom
+                bar_bottom = tmp
+              end
+              if my >= bar_top
+                if my <= bar_bottom
+                  @hover_index = ci
+                  @hover_series = si
+                  return
+                end
+              end
+              cumulative = top_val
+              si = si + 1
+            end
+            @hover_index = ci
+            return
+          end
+        end
+        ci = ci + 1
+      end
+    end
+
+    private
+
+    def compute_stacked_range
+      @data_min = 0.0
+      @data_max = 1.0
+      return if @series_data.length == 0
+      return if @categories.length == 0
+      max_stack = 0.0
+      ci = 0
+      while ci < @categories.length
+        stack_total = 0.0
+        si = 0
+        while si < @series_data.length
+          if ci < @series_data[si].length
+            stack_total = stack_total + @series_data[si][ci]
+          end
+          si = si + 1
+        end
+        if stack_total > max_stack
+          max_stack = stack_total
+        end
+        ci = ci + 1
+      end
+      @data_max = max_stack
+      range = @data_max - @data_min
+      if range > 0.0
+        @data_max = @data_max + range * 0.1
+      else
+        @data_max = @data_min + 1.0
+      end
+    end
+  end
+
+  def StackedBarChart(categories, series_data, series_names)
+    StackedBarChart.new(categories, series_data, series_names)
+  end
+
+end

data/lib/kumiki/column.rb

@@ -0,0 +1,351 @@
+module Kumiki
+  # rbs_inline: enabled
+
+  # Column layout - vertical arrangement of children
+
+  class Column < Layout
+    def initialize
+      super
+      @spacing = 0.0
+      @is_scrollable = false
+      @scroll_offset = 0.0
+      @content_height = 0.0
+      @pin_bottom = false
+      @sb_dragging = false
+      @sb_drag_start_y = 0.0
+      @sb_drag_start_offset = 0.0
+      @external_scroll_state = nil
+    end
+
+    #: (Float s) -> Column
+    def spacing(s)
+      @spacing = s
+      self
+    end
+
+    #: (ScrollState ss) -> Column
+    def scroll_state(ss)
+      @external_scroll_state = ss
+      @scroll_offset = ss.y
+      self
+    end
+
+    #: () -> 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
+
+    #: () -> Column
+    def pin_to_bottom
+      @pin_bottom = 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
+        false
+      else
+        @is_scrollable
+      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_y(v)
+      mark_dirty
+      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
+        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 + @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
+      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 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 (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, 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
+        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
+      cy = @y + @pad_top
+      if @is_scrollable
+        cy = cy - @scroll_offset
+      end
+      total_content_h = 0.0
+      i = 0
+      while i < @children.length
+        c = @children[i]
+        if c.get_height_policy == EXPANDING
+          h = 0.0
+          if expanding_total_flex > 0 && remaining > 0.0
+            h = remaining * c.get_flex / expanding_total_flex
+          end
+          c.resize_wh(inner_w, h)
+        else
+          # 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 + @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
+        i = i + 1
+      end
+      @content_height = total_content_h
+
+      # Auto-scroll to bottom when pinned
+      if @pin_bottom && @is_scrollable
+        max_scroll = @content_height - inner_h
+        if max_scroll > 0.0
+          @scroll_offset = max_scroll
+          @external_scroll_state&.set_y(@scroll_offset)
+        end
+      end
+    end
+
+    #: (untyped painter, bool completely) -> void
+    def redraw(painter, completely)
+      saved_bg = Kumiki._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 = 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_h = @height
+      content_h = @content_height
+      return if content_h <= viewport_h
+
+      bar_width = 8.0
+      thumb_color = 0xC0AAAAAA
+
+      # Thumb
+      thumb_h = viewport_h * viewport_h / content_h
+      if thumb_h < 20.0
+        thumb_h = 20.0
+      end
+      thumb_y = (@scroll_offset / content_h) * viewport_h
+      if thumb_y + thumb_h > viewport_h
+        thumb_y = viewport_h - thumb_h
+      end
+      painter.fill_round_rect(@width - bar_width + 2.0, thumb_y, bar_width - 4.0, thumb_h, 2.0, thumb_color)
+    end
+
+    # Intercept clicks on the scrollbar area before dispatching to children
+    #: (Point p) -> Array
+    def dispatch(p)
+      if @is_scrollable && @content_height > @height && contain(p)
+        local_x = p.x - @x
+        if local_x >= @width - 8.0
+          local_p = Point.new(local_x, p.y - @y)
+          return [self, local_p]
+        end
+      end
+      super(p)
+    end
+
+    #: (MouseEvent ev) -> void
+    def mouse_down(ev)
+      if @is_scrollable && @content_height > @height
+        @sb_dragging = true
+        @sb_drag_start_y = ev.pos.y
+        @sb_drag_start_offset = @scroll_offset
+        # Jump scroll to clicked position
+        viewport_h = @height
+        content_h = @content_height
+        max_scroll = content_h - viewport_h
+        @scroll_offset = (ev.pos.y / viewport_h) * max_scroll
+        if @scroll_offset < 0.0
+          @scroll_offset = 0.0
+        end
+        if @scroll_offset > max_scroll
+          @scroll_offset = max_scroll
+        end
+        @external_scroll_state&.set_y(@scroll_offset)
+        mark_dirty
+        update
+      end
+    end
+
+    #: (MouseEvent ev) -> void
+    def mouse_drag(ev)
+      if @sb_dragging
+        viewport_h = @height
+        content_h = @content_height
+        if content_h > viewport_h
+          max_scroll = content_h - viewport_h
+          @scroll_offset = (ev.pos.y / viewport_h) * max_scroll
+          if @scroll_offset < 0.0
+            @scroll_offset = 0.0
+          end
+          if @scroll_offset > max_scroll
+            @scroll_offset = max_scroll
+          end
+          @external_scroll_state&.set_y(@scroll_offset)
+          mark_dirty
+          update
+        end
+      end
+    end
+
+    #: (MouseEvent ev) -> void
+    def mouse_up(ev)
+      @sb_dragging = false
+    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_height - @height
+        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_bottom: disable on scroll up, re-enable at bottom
+        if ev.delta_y > 0.0
+          @pin_bottom = false
+        end
+        if max_scroll > 0.0 && @scroll_offset >= max_scroll
+          @pin_bottom = true
+        end
+        @external_scroll_state&.set_y(@scroll_offset)
+        mark_dirty
+        update
+      end
+    end
+  end
+
+  # Top-level helper
+  #: (*untyped children) -> Column
+  def Column(*children)
+    col = Column.new
+    i = 0
+    while i < children.length
+      col.add(children[i])
+      i = i + 1
+    end
+    col
+  end
+
+end