konpeito 0.1.0

data/lib/konpeito/ui/chart/base_chart.rb

@@ -0,0 +1,210 @@
+# 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 = $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, $theme.font_family, 16.0)
+    tx = (@width - tw) / 2.0
+    ascent = painter.get_text_ascent($theme.font_family, 16.0)
+    tc = $theme.text_primary
+    painter.draw_text(@title_text, tx, 8.0 + ascent, $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($theme.font_family, 11.0)
+    tc = $theme.text_secondary
+    painter.draw_text(label, lx, y + ascent, $theme.font_family, 11.0, tc)
+    lw = painter.measure_text_width(label, $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, $theme.font_family, 11.0)
+    ascent = painter.get_text_ascent($theme.font_family, 11.0)
+    lx = px - lw - 6.0
+    ly = yy + ascent / 2.0
+    painter.draw_text(label, lx, ly, $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 = $theme.border
+    painter.draw_line(px, py, px, py + ph, bc, 1.0)
+    gc = painter.with_alpha(bc, 60)
+    lc = $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 = $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

data/lib/konpeito/ui/chart/chart_helpers.rb

@@ -0,0 +1,79 @@
+# Chart helper functions
+# NOTE: Color manipulation (with_alpha, lighten_color, darken_color)
+# is done in KUIRuntime.java to avoid JVM verifier issues with bitwise ops.
+# Call via: painter.with_alpha(color, alpha)
+#           painter.lighten_color(color, amount)
+#           painter.darken_color(color, amount)
+
+# Compute nice axis tick values
+# Simplified to avoid Math.log10 and ** operator (JVM compatibility)
+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
+# NOTE: Uses painter.number_to_string (Java method) because
+# .to_i/.to_s dispatch doesn't work on untyped JVM Objects
+def format_axis_value(painter, val)
+  painter.number_to_string(val)
+end

data/lib/konpeito/ui/chart/gauge_chart.rb

@@ -0,0 +1,171 @@
+# GaugeChart - arc gauge with thresholds and center value display
+# Uses fill_arc/stroke_arc APIs for drawing
+
+GAUGE_PI = 3.14159265358979323846
+
+class GaugeChart < BaseChart
+  def initialize(value, min_val, max_val)
+    super()
+    @value = value
+    @min_val = min_val
+    @max_val = max_val
+    @thresholds = nil     # Array of [threshold_value, color] pairs
+    @arc_width = 20.0
+    @show_value = true
+    @value_format = nil
+    @unit_text = ""
+    @bg_arc_color = 0xFF3B4261
+  end
+
+  def thresholds(t)
+    @thresholds = t
+    self
+  end
+
+  def arc_width(w)
+    @arc_width = w
+    self
+  end
+
+  def show_value(v)
+    @show_value = v
+    self
+  end
+
+  def unit(u)
+    @unit_text = u
+    self
+  end
+
+  def set_value(v)
+    @value = v
+    mark_dirty
+    update
+  end
+
+  def render_chart(painter, px, py, pw, ph)
+    chart_size = pw
+    if ph < pw
+      chart_size = ph
+    end
+    radius = chart_size / 2.0 - @arc_width / 2.0 - 10.0
+    if radius < 30.0
+      radius = 30.0
+    end
+    cx = px + pw / 2.0
+    cy = py + ph / 2.0 + 10.0
+
+    # Background arc (270 degrees, from 135 to 405)
+    start_angle = 135.0
+    sweep_total = 270.0
+    painter.stroke_arc(cx, cy, radius, start_angle, sweep_total, @bg_arc_color, @arc_width)
+
+    # Value arc
+    range = @max_val - @min_val
+    if range <= 0.0
+      range = 1.0
+    end
+    fraction = (@value - @min_val) / range
+    if fraction < 0.0
+      fraction = 0.0
+    end
+    if fraction > 1.0
+      fraction = 1.0
+    end
+    value_sweep = fraction * sweep_total
+    arc_color = get_gauge_color(painter, fraction)
+    painter.stroke_arc(cx, cy, radius, start_angle, value_sweep, arc_color, @arc_width)
+
+    # Draw threshold tick marks
+    draw_gauge_ticks(painter, cx, cy, radius)
+
+    # Center value display
+    if @show_value
+      draw_gauge_value(painter, cx, cy)
+    end
+
+    # Min/Max labels
+    draw_gauge_min_max(painter, cx, cy, radius)
+  end
+
+  def get_gauge_color(painter, fraction)
+    if @thresholds == nil
+      return series_color(0)
+    end
+    # thresholds: [[0.5, green], [0.75, yellow], [1.0, red]]
+    i = 0
+    while i < @thresholds.length
+      threshold_frac = @thresholds[i][0]
+      if fraction <= threshold_frac
+        return @thresholds[i][1]
+      end
+      i = i + 1
+    end
+    # Past all thresholds, use last color
+    if @thresholds.length > 0
+      return @thresholds[@thresholds.length - 1][1]
+    end
+    series_color(0)
+  end
+
+  def draw_gauge_ticks(painter, cx, cy, radius)
+    return if @thresholds == nil
+    start_angle = 135.0
+    sweep_total = 270.0
+    tick_r_inner = radius - @arc_width / 2.0 - 2.0
+    tick_r_outer = radius + @arc_width / 2.0 + 2.0
+    tc = $theme.text_secondary
+    i = 0
+    while i < @thresholds.length
+      frac = @thresholds[i][0]
+      if frac < 1.0
+        angle_deg = start_angle + frac * sweep_total
+        angle_rad = angle_deg * GAUGE_PI / 180.0
+        cos_a = painter.math_cos(angle_rad)
+        sin_a = painter.math_sin(angle_rad)
+        x1 = cx + tick_r_inner * cos_a
+        y1 = cy + tick_r_inner * sin_a
+        x2 = cx + tick_r_outer * cos_a
+        y2 = cy + tick_r_outer * sin_a
+        painter.draw_line(x1, y1, x2, y2, tc, 1.0)
+      end
+      i = i + 1
+    end
+  end
+
+  def draw_gauge_value(painter, cx, cy)
+    vl = painter.number_to_string(@value)
+    if @unit_text != ""
+      vl = vl + @unit_text
+    end
+    vw = painter.measure_text_width(vl, $theme.font_family, 28.0)
+    ascent = painter.get_text_ascent($theme.font_family, 28.0)
+    vx = cx - vw / 2.0
+    vy = cy + ascent / 2.0
+    tc = $theme.text_primary
+    painter.draw_text(vl, vx, vy, $theme.font_family, 28.0, tc)
+  end
+
+  def draw_gauge_min_max(painter, cx, cy, radius)
+    lc = $theme.text_secondary
+    r_label = radius + @arc_width / 2.0 + 16.0
+    # Min label at 135 degrees
+    min_angle = 135.0 * GAUGE_PI / 180.0
+    min_label = painter.number_to_string(@min_val)
+    mlw = painter.measure_text_width(min_label, $theme.font_family, 11.0)
+    mx = cx + r_label * painter.math_cos(min_angle) - mlw
+    my = cy + r_label * painter.math_sin(min_angle)
+    ascent = painter.get_text_ascent($theme.font_family, 11.0)
+    painter.draw_text(min_label, mx, my + ascent, $theme.font_family, 11.0, lc)
+    # Max label at 405 degrees = 45 degrees
+    max_angle = 45.0 * GAUGE_PI / 180.0
+    max_label = painter.number_to_string(@max_val)
+    max_x = cx + r_label * painter.math_cos(max_angle)
+    max_y = cy + r_label * painter.math_sin(max_angle)
+    painter.draw_text(max_label, max_x, max_y + ascent, $theme.font_family, 11.0, lc)
+  end
+end
+
+def GaugeChart(value, min_val, max_val)
+  GaugeChart.new(value, min_val, max_val)
+end

data/lib/konpeito/ui/chart/heatmap_chart.rb

@@ -0,0 +1,222 @@
+# HeatmapChart - 2D grid heatmap with color interpolation
+# Supports axis labels, value display, color scale legend
+
+class HeatmapChart < BaseChart
+  def initialize(x_labels, y_labels, data_2d)
+    super()
+    @x_labels = x_labels      # Array of String (column headers)
+    @y_labels = y_labels      # Array of String (row headers)
+    @data_2d = data_2d        # Array of Array[Float] (rows x cols)
+    @show_cell_values = true
+    @color_low = 0xFF1A1B26     # Dark blue/black
+    @color_high = 0xFF7AA2F7    # Bright blue
+    @cell_padding = 2.0
+    @data_min = 0.0
+    @data_max = 1.0
+    @chart_px = 0.0
+    @chart_py = 0.0
+    @chart_pw = 0.0
+    @chart_ph = 0.0
+    @num_rows = 0
+    @num_cols = 0
+    compute_heatmap_range
+  end
+
+  def show_cell_values(v)
+    @show_cell_values = v
+    self
+  end
+
+  def color_range(low, high)
+    @color_low = low
+    @color_high = high
+    self
+  end
+
+  def cell_padding(p)
+    @cell_padding = p
+    self
+  end
+
+  def set_data(x_labels, y_labels, data_2d)
+    @x_labels = x_labels
+    @y_labels = y_labels
+    @data_2d = data_2d
+    compute_heatmap_range
+    mark_dirty
+    update
+  end
+
+  def render_chart(painter, px, py, pw, ph)
+    return if @x_labels.length == 0
+    return if @y_labels.length == 0
+    @chart_px = px
+    @chart_py = py
+    @chart_pw = pw
+    @chart_ph = ph
+    @num_rows = @y_labels.length
+    @num_cols = @x_labels.length
+    draw_heatmap_cells(painter)
+    draw_heatmap_x_labels(painter)
+    draw_heatmap_y_labels(painter)
+    draw_heatmap_color_legend(painter)
+  end
+
+  def draw_heatmap_cells(painter)
+    cell_w = @chart_pw / (@num_cols * 1.0)
+    cell_h = (@chart_ph - 20.0) / (@num_rows * 1.0)
+    range = @data_max - @data_min
+    if range <= 0.0
+      range = 1.0
+    end
+    ri = 0
+    while ri < @num_rows
+      ci = 0
+      while ci < @num_cols
+        draw_heatmap_cell(painter, ri, ci, cell_w, cell_h, range)
+        ci = ci + 1
+      end
+      ri = ri + 1
+    end
+  end
+
+  def draw_heatmap_cell(painter, ri, ci, cell_w, cell_h, range)
+    val = 0.0
+    if ri < @data_2d.length
+      if ci < @data_2d[ri].length
+        val = @data_2d[ri][ci]
+      end
+    end
+    t = (val - @data_min) / range
+    if t < 0.0
+      t = 0.0
+    end
+    if t > 1.0
+      t = 1.0
+    end
+    c = painter.interpolate_color(@color_low, @color_high, t)
+    cx = @chart_px + ci * 1.0 * cell_w + @cell_padding
+    cy = @chart_py + ri * 1.0 * cell_h + @cell_padding
+    cw = cell_w - @cell_padding * 2.0
+    ch = cell_h - @cell_padding * 2.0
+    painter.fill_round_rect(cx, cy, cw, ch, 3.0, c)
+
+    # Hover highlight
+    if @hover_series == ri
+      if @hover_index == ci
+        hc = painter.with_alpha(4294967295, 60)
+        painter.stroke_rect(cx, cy, cw, ch, hc, 2.0)
+      end
+    end
+
+    if @show_cell_values
+      vl = painter.number_to_string(val)
+      vw = painter.measure_text_width(vl, $theme.font_family, 10.0)
+      ascent = painter.get_text_ascent($theme.font_family, 10.0)
+      vx = cx + cw / 2.0 - vw / 2.0
+      vy = cy + ch / 2.0 + ascent / 2.0
+      # Use white text on dark cells, dark on light cells
+      text_c = 4294967295
+      if t > 0.6
+        text_c = 4278190080
+      end
+      painter.draw_text(vl, vx, vy, $theme.font_family, 10.0, text_c)
+    end
+  end
+
+  def draw_heatmap_x_labels(painter)
+    cell_w = @chart_pw / (@num_cols * 1.0)
+    lc = $theme.text_secondary
+    ascent = painter.get_text_ascent($theme.font_family, 11.0)
+    label_y = @chart_py + @chart_ph - 20.0 + 14.0 + ascent
+    i = 0
+    while i < @num_cols
+      label = @x_labels[i]
+      lw = painter.measure_text_width(label, $theme.font_family, 11.0)
+      lx = @chart_px + i * 1.0 * cell_w + cell_w / 2.0 - lw / 2.0
+      painter.draw_text(label, lx, label_y, $theme.font_family, 11.0, lc)
+      i = i + 1
+    end
+  end
+
+  def draw_heatmap_y_labels(painter)
+    cell_h = (@chart_ph - 20.0) / (@num_rows * 1.0)
+    lc = $theme.text_secondary
+    ascent = painter.get_text_ascent($theme.font_family, 11.0)
+    i = 0
+    while i < @num_rows
+      label = @y_labels[i]
+      lw = painter.measure_text_width(label, $theme.font_family, 11.0)
+      lx = @chart_px - lw - 6.0
+      ly = @chart_py + i * 1.0 * cell_h + cell_h / 2.0 + ascent / 2.0
+      painter.draw_text(label, lx, ly, $theme.font_family, 11.0, lc)
+      i = i + 1
+    end
+  end
+
+  def draw_heatmap_color_legend(painter)
+    # Draw a small gradient bar at the right side
+    lg_w = 16.0
+    lg_h = @chart_ph - 20.0
+    lg_x = @chart_px + @chart_pw + 8.0
+    lg_y = @chart_py
+    steps = 20
+    step_h = lg_h / (steps * 1.0)
+    i = 0
+    while i < steps
+      t = 1.0 - (i * 1.0 / (steps * 1.0))
+      c = painter.interpolate_color(@color_low, @color_high, t)
+      sy = lg_y + i * 1.0 * step_h
+      painter.fill_rect(lg_x, sy, lg_w, step_h + 1.0, c)
+      i = i + 1
+    end
+    # Labels
+    lc = $theme.text_secondary
+    ascent = painter.get_text_ascent($theme.font_family, 9.0)
+    max_label = painter.number_to_string(@data_max)
+    min_label = painter.number_to_string(@data_min)
+    painter.draw_text(max_label, lg_x + lg_w + 4.0, lg_y + ascent, $theme.font_family, 9.0, lc)
+    painter.draw_text(min_label, lg_x + lg_w + 4.0, lg_y + lg_h, $theme.font_family, 9.0, lc)
+  end
+
+  def update_hover
+    # Hover detection disabled for HeatmapChart on JVM
+    # (field type issues with @chart_px etc before first render)
+  end
+
+  private
+
+  def compute_heatmap_range
+    @data_min = 0.0
+    @data_max = 1.0
+    first = true
+    ri = 0
+    while ri < @data_2d.length
+      ci = 0
+      while ci < @data_2d[ri].length
+        v = @data_2d[ri][ci]
+        if first
+          @data_min = v
+          @data_max = v
+          first = false
+        else
+          if v < @data_min
+            @data_min = v
+          end
+          if v > @data_max
+            @data_max = v
+          end
+        end
+        ci = ci + 1
+      end
+      ri = ri + 1
+    end
+    if @data_min == @data_max
+      @data_max = @data_min + 1.0
+    end
+  end
+end
+
+def HeatmapChart(x_labels, y_labels, data_2d)
+  HeatmapChart.new(x_labels, y_labels, data_2d)
+end