kumiki 0.1.1

data/lib/kumiki/chart/bar_chart.rb

@@ -0,0 +1,291 @@
+module Kumiki
+  # BarChart - grouped bar chart widget
+  # Supports multiple series, hover highlight, value labels
+
+  class BarChart < BaseChart
+    def initialize(categories, series_data, series_names)
+      super()
+      @categories = categories
+      @series_data = series_data
+      @series_names = series_names
+      @show_values = false
+      @bar_radius = 2.0
+      @data_min = 0.0
+      @data_max = 0.0
+      # Computed per-frame
+      @y_scale = nil
+      @y_ticks = nil
+      @band = nil
+      @bar_w = 2.0
+      @bar_gap = 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_data_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_data_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
+      setup_chart_counts
+      setup_chart_ticks
+      setup_chart_y_scale
+      setup_chart_band
+      setup_chart_bar_width
+      setup_chart_baseline
+      draw_y_axis(painter, px, py, pw, ph, @y_ticks, @y_scale)
+      draw_x_axis_line(painter, px, py, pw, ph)
+      draw_cat_labels(painter)
+      draw_all_bars(painter)
+      draw_bar_legend(painter, px, py)
+    end
+
+    def setup_chart_counts
+      @num_series = @series_data.length
+      @num_cats = @categories.length
+    end
+
+    def setup_chart_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_chart_y_scale
+      bottom = @chart_py + @chart_ph
+      @y_scale = LinearScale.new(@y_range_min, @y_range_max, bottom, @chart_py)
+    end
+
+    def setup_chart_band
+      right = @chart_px + @chart_pw
+      nc = @num_cats * 1.0
+      @band = BandScale.new(nc, @chart_px, right, 12.0)
+    end
+
+    def setup_chart_bar_width
+      @bar_gap = 2.0
+      group_w = @band.band_width
+      ns = @num_series * 1.0
+      ns_minus_1 = ns - 1.0
+      @bar_w = (group_w - @bar_gap * ns_minus_1) / ns
+      if @bar_w < 2.0
+        @bar_w = 2.0
+      end
+    end
+
+    def setup_chart_baseline
+      @baseline_y = @y_scale.map(0.0)
+      if @baseline_y < @chart_py
+        @baseline_y = @chart_py
+      end
+      bmax = @chart_py + @chart_ph
+      if @baseline_y > bmax
+        @baseline_y = bmax
+      end
+    end
+
+    def draw_cat_labels(painter)
+      lc = Kumiki.theme.text_secondary
+      i = 0
+      while i < @num_cats
+        draw_one_cat_label(painter, i, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_one_cat_label(painter, i, lc)
+      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 + @band.band_width / 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)
+    end
+
+    def draw_all_bars(painter)
+      si = 0
+      while si < @num_series
+        ci = 0
+        while ci < @num_cats
+          draw_one_bar(painter, si, ci)
+          ci = ci + 1
+        end
+        si = si + 1
+      end
+    end
+
+    def draw_one_bar(painter, si, ci)
+      val = @series_data[si][ci]
+      bx = compute_bar_x(ci, si)
+      bar_top = @y_scale.map(val)
+      bar_h = @baseline_y - bar_top
+      if bar_h < 0.0
+        bar_top = @baseline_y
+        bar_h = 0.0 - bar_h
+      end
+      c = get_bar_color(painter, si, ci)
+      painter.fill_round_rect(bx, bar_top, @bar_w, bar_h, @bar_radius, c)
+      if @show_values
+        draw_bar_value(painter, val, bx, bar_top)
+      end
+    end
+
+    def compute_bar_x(ci, si)
+      ci_f = ci * 1.0
+      si_f = si * 1.0
+      @band.map(ci_f) + si_f * (@bar_w + @bar_gap)
+    end
+
+    def get_bar_color(painter, si, ci)
+      c = series_color(si)
+      if @hover_index == ci
+        if @hover_series == si
+          c = painter.lighten_color(c, 0.3)
+        end
+      end
+      c
+    end
+
+    def draw_bar_value(painter, val, bx, bar_top)
+      vl = format_axis_value(painter, val)
+      vw = painter.measure_text_width(vl, Kumiki.theme.font_family, 10.0)
+      vx = bx + @bar_w / 2.0 - vw / 2.0
+      vy = bar_top - 4.0
+      painter.draw_text(vl, vx, vy, Kumiki.theme.font_family, 10.0, Kumiki.theme.text_secondary)
+    end
+
+    def draw_bar_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_bar_hover(mx)
+    end
+
+    def find_bar_hover(mx)
+      @hover_index = -1
+      @hover_series = -1
+      ci = 0
+      while ci < @num_cats
+        si = 0
+        while si < @num_series
+          bx = compute_bar_x(ci, si)
+          if mx >= bx
+            if mx <= bx + @bar_w
+              @hover_index = ci
+              @hover_series = si
+              return
+            end
+          end
+          si = si + 1
+        end
+        ci = ci + 1
+      end
+    end
+
+    private
+
+    def compute_data_range
+      @data_min = 0.0
+      @data_max = 1.0
+      si = 0
+      while si < @series_data.length
+        ci = 0
+        while ci < @series_data[si].length
+          v = @series_data[si][ci]
+          if v > @data_max
+            @data_max = v
+          end
+          if v < @data_min
+            @data_min = v
+          end
+          ci = ci + 1
+        end
+        si = si + 1
+      end
+      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 BarChart(categories, series_data, series_names)
+    BarChart.new(categories, series_data, series_names)
+  end
+
+end

data/lib/kumiki/chart/base_chart.rb

@@ -0,0 +1,213 @@
+module Kumiki
+  # BaseChart - abstract base class for all chart widgets
+  # Provides margin management, title, legend, and hover detection
+
+  # Chart margin constants
+  CHART_MARGIN_TOP = 40.0
+  CHART_MARGIN_RIGHT = 20.0
+  CHART_MARGIN_BOTTOM = 50.0
+  CHART_MARGIN_LEFT = 60.0
+
+  # Default series colors (8-color palette, Tokyo Night inspired)
+  def series_color(index)
+    i = index % 8
+    c = 0
+    if i == 0
+      c = 4288807671
+    elsif i == 1
+      c = 4288452202
+    elsif i == 2
+      c = 4294604430
+    elsif i == 3
+      c = 4292886376
+    elsif i == 4
+      c = 4290530039
+    elsif i == 5
+      c = 4285791434
+    elsif i == 6
+      c = 4294934372
+    else
+      c = 4286361599
+    end
+    c
+  end
+
+  class BaseChart < Widget
+    def initialize
+      super()
+      @margin_top = CHART_MARGIN_TOP
+      @margin_right = CHART_MARGIN_RIGHT
+      @margin_bottom = CHART_MARGIN_BOTTOM
+      @margin_left = CHART_MARGIN_LEFT
+      @title_text = nil
+      @show_legend = true
+      @hover_index = -1
+      @hover_series = -1
+      @mouse_x = -1.0
+      @mouse_y = -1.0
+      @painter = nil
+      @width_policy = EXPANDING
+      @height_policy = EXPANDING
+    end
+
+    def title(t)
+      @title_text = t
+      self
+    end
+
+    def legend(show)
+      @show_legend = show
+      self
+    end
+
+    def margins(top, right, bottom, left)
+      @margin_top = top
+      @margin_right = right
+      @margin_bottom = bottom
+      @margin_left = left
+      self
+    end
+
+    def plot_x
+      @margin_left
+    end
+
+    def plot_y
+      @margin_top
+    end
+
+    def plot_w
+      w = @width - @margin_left - @margin_right
+      if w < 0.0
+        w = 0.0
+      end
+      w
+    end
+
+    def plot_h
+      h = @height - @margin_top - @margin_bottom
+      if h < 0.0
+        h = 0.0
+      end
+      h
+    end
+
+    def redraw(painter, completely)
+      @painter = painter
+      bg = Kumiki.theme.bg_primary
+      painter.fill_rect(0.0, 0.0, @width, @height, bg)
+      draw_title(painter)
+      render_chart(painter, plot_x, plot_y, plot_w, plot_h)
+    end
+
+    def draw_title(painter)
+      return if @title_text == nil
+      tw = painter.measure_text_width(@title_text, Kumiki.theme.font_family, 16.0)
+      tx = (@width - tw) / 2.0
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 16.0)
+      tc = Kumiki.theme.text_primary
+      painter.draw_text(@title_text, tx, 8.0 + ascent, Kumiki.theme.font_family, 16.0, tc)
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+    end
+
+    # Draw one legend item
+    def draw_legend_item(painter, label, color, cx, y)
+      painter.fill_rect(cx, y, 12.0, 12.0, color)
+      lx = cx + 16.0
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+      tc = Kumiki.theme.text_secondary
+      painter.draw_text(label, lx, y + ascent, Kumiki.theme.font_family, 11.0, tc)
+      lw = painter.measure_text_width(label, Kumiki.theme.font_family, 11.0)
+      lx + lw + 16.0
+    end
+
+    # Draw legend items
+    def draw_legend(painter, labels, colors, x, y)
+      return if labels.length == 0
+      cx = x
+      i = 0
+      while i < labels.length
+        c = colors[i % colors.length]
+        cx = draw_legend_item(painter, labels[i], c, cx, y)
+        i = i + 1
+      end
+    end
+
+    # Draw one Y-axis tick (grid line + tick mark)
+    def draw_y_tick(painter, px, pw, yy, grid_color, border_color)
+      painter.draw_line(px, yy, px + pw, yy, grid_color, 1.0)
+      painter.draw_line(px - 4.0, yy, px, yy, border_color, 1.0)
+    end
+
+    # Draw one Y-axis tick label
+    def draw_y_tick_label(painter, px, yy, label, label_color)
+      lw = painter.measure_text_width(label, Kumiki.theme.font_family, 11.0)
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+      lx = px - lw - 6.0
+      ly = yy + ascent / 2.0
+      painter.draw_text(label, lx, ly, Kumiki.theme.font_family, 11.0, label_color)
+    end
+
+    # Draw Y-axis with tick marks and grid lines
+    def draw_y_axis(painter, px, py, pw, ph, ticks, scale)
+      bc = Kumiki.theme.border
+      painter.draw_line(px, py, px, py + ph, bc, 1.0)
+      gc = painter.with_alpha(bc, 60)
+      lc = Kumiki.theme.text_secondary
+      i = 0
+      while i < ticks.length
+        yy = scale.map(ticks[i])
+        draw_y_tick(painter, px, pw, yy, gc, bc)
+        label = format_axis_value(painter, ticks[i])
+        draw_y_tick_label(painter, px, yy, label, lc)
+        i = i + 1
+      end
+    end
+
+    # Draw X-axis line
+    def draw_x_axis_line(painter, px, py, pw, ph)
+      bc = Kumiki.theme.border
+      painter.draw_line(px, py + ph, px + pw, py + ph, bc, 1.0)
+    end
+
+    # Mouse tracking for hover
+    def cursor_pos(ev)
+      @mouse_x = ev.pos.x
+      @mouse_y = ev.pos.y
+      old_hi = @hover_index
+      old_hs = @hover_series
+      update_hover
+      if @hover_index != old_hi
+        mark_dirty
+        update
+      elsif @hover_series != old_hs
+        mark_dirty
+        update
+      end
+    end
+
+    def mouse_out
+      changed = false
+      if @hover_index != -1
+        @hover_index = -1
+        changed = true
+      end
+      if @hover_series != -1
+        @hover_series = -1
+        changed = true
+      end
+      if changed
+        @mouse_x = -1.0
+        @mouse_y = -1.0
+        mark_dirty
+        update
+      end
+    end
+
+    def update_hover
+    end
+  end
+
+end

data/lib/kumiki/chart/chart_helpers.rb

@@ -0,0 +1,74 @@
+module Kumiki
+  # Chart helper functions
+
+  # Compute nice axis tick values
+  def compute_ticks(min_val, max_val, target_count)
+    ticks = []
+    range = max_val - min_val
+    if range <= 0.0
+      ticks << min_val
+      return ticks
+    end
+    rough_step = range / target_count
+    nice_step = pick_nice_step(rough_step)
+    start = compute_tick_start(min_val, nice_step)
+    v = start
+    while v <= max_val + nice_step * 0.001
+      if v >= min_val - nice_step * 0.001
+        ticks << v
+      end
+      v = v + nice_step
+    end
+    ticks
+  end
+
+  def pick_nice_step(rough_step)
+    if rough_step >= 500.0
+      return 500.0
+    end
+    if rough_step >= 200.0
+      return 200.0
+    end
+    if rough_step >= 100.0
+      return 100.0
+    end
+    if rough_step >= 50.0
+      return 50.0
+    end
+    if rough_step >= 20.0
+      return 20.0
+    end
+    if rough_step >= 10.0
+      return 10.0
+    end
+    if rough_step >= 5.0
+      return 5.0
+    end
+    if rough_step >= 2.0
+      return 2.0
+    end
+    if rough_step >= 1.0
+      return 1.0
+    end
+    if rough_step >= 0.5
+      return 0.5
+    end
+    if rough_step >= 0.2
+      return 0.2
+    end
+    0.1
+  end
+
+  def compute_tick_start(min_val, nice_step)
+    ratio = min_val / nice_step
+    int_part = ratio.to_i
+    int_f = int_part * 1.0
+    int_f * nice_step
+  end
+
+  # Format a number for axis labels
+  def format_axis_value(painter, val)
+    painter.number_to_string(val)
+  end
+
+end