konpeito 0.1.0

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

@@ -0,0 +1,289 @@
+# LineChart - line chart with point markers
+# Supports multiple series, grid, hover detection
+
+class LineChart < BaseChart
+  def initialize(x_labels, series_data, series_names)
+    super()
+    @x_labels = x_labels
+    @series_data = series_data
+    @series_names = series_names
+    @show_points = true
+    @point_radius = 4.0
+    @line_width = 2.0
+    @show_grid = true
+    @data_min = 0.0
+    @data_max = 0.0
+    # Computed per-frame
+    @y_scale = nil
+    @y_ticks = nil
+    @x_step = 0.0
+    @num_points = 0
+    @num_series = 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_points(v)
+    @show_points = v
+    self
+  end
+
+  def point_radius(r)
+    @point_radius = r
+    self
+  end
+
+  def line_width(w)
+    @line_width = w
+    self
+  end
+
+  def show_grid(v)
+    @show_grid = v
+    self
+  end
+
+  def set_data(x_labels, series_data, series_names)
+    @x_labels = x_labels
+    @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 @x_labels.length == 0
+    return if @series_data.length == 0
+    @chart_px = px
+    @chart_py = py
+    @chart_pw = pw
+    @chart_ph = ph
+    setup_line_counts
+    setup_line_ticks
+    setup_line_y_scale
+    setup_line_x_step
+    draw_y_axis(painter, px, py, pw, ph, @y_ticks, @y_scale)
+    draw_x_axis_line(painter, px, py, pw, ph)
+    draw_x_labels(painter)
+    draw_hover_line(painter)
+    draw_all_series(painter)
+    draw_line_legend(painter, px, py)
+  end
+
+  def setup_line_counts
+    @num_points = @x_labels.length
+    @num_series = @series_data.length
+  end
+
+  def setup_line_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_line_y_scale
+    bottom = @chart_py + @chart_ph
+    @y_scale = LinearScale.new(@y_range_min, @y_range_max, bottom, @chart_py)
+  end
+
+  def setup_line_x_step
+    @x_step = 0.0
+    if @num_points > 1
+      divisor = (@num_points - 1) * 1.0
+      @x_step = @chart_pw / divisor
+    end
+  end
+
+  def draw_x_labels(painter)
+    lc = $theme.text_secondary
+    i = 0
+    while i < @num_points
+      draw_one_x_label(painter, i, lc)
+      i = i + 1
+    end
+  end
+
+  def draw_one_x_label(painter, i, lc)
+    i_f = i * 1.0
+    xx = @chart_px + i_f * @x_step
+    label = @x_labels[i]
+    lw = painter.measure_text_width(label, $theme.font_family, 11.0)
+    ascent = painter.get_text_ascent($theme.font_family, 11.0)
+    label_y = @chart_py + @chart_ph + 14.0 + ascent
+    painter.draw_text(label, xx - lw / 2.0, label_y, $theme.font_family, 11.0, lc)
+  end
+
+  def draw_hover_line(painter)
+    if @hover_index >= 0
+      if @hover_index < @num_points
+        hi_f = @hover_index * 1.0
+        hx = @chart_px + hi_f * @x_step
+        hc = painter.with_alpha($theme.accent, 80)
+        bottom = @chart_py + @chart_ph
+        painter.draw_line(hx, @chart_py, hx, bottom, hc, 1.0)
+      end
+    end
+  end
+
+  def draw_all_series(painter)
+    si = 0
+    while si < @num_series
+      c = series_color(si)
+      data = @series_data[si]
+      draw_series_lines(painter, data, c)
+      if @show_points
+        draw_series_points(painter, data, c)
+      end
+      si = si + 1
+    end
+  end
+
+  def draw_series_lines(painter, data, c)
+    j = 0
+    while j < @num_points - 1
+      j_f = j * 1.0
+      x1 = @chart_px + j_f * @x_step
+      y1 = @y_scale.map(data[j])
+      j1_f = (j + 1) * 1.0
+      x2 = @chart_px + j1_f * @x_step
+      y2 = @y_scale.map(data[j + 1])
+      painter.draw_line(x1, y1, x2, y2, c, @line_width)
+      j = j + 1
+    end
+  end
+
+  def draw_series_points(painter, data, c)
+    j = 0
+    while j < @num_points
+      draw_one_point(painter, data, j, c)
+      j = j + 1
+    end
+  end
+
+  def draw_one_point(painter, data, j, c)
+    j_f = j * 1.0
+    xx = @chart_px + j_f * @x_step
+    yy = @y_scale.map(data[j])
+    r = @point_radius
+    if @hover_index == j
+      r = @point_radius + 2.0
+    end
+    painter.fill_circle(xx, yy, r, c)
+    if @hover_index == j
+      draw_point_label(painter, data[j], xx, yy, r)
+    end
+  end
+
+  def draw_point_label(painter, val, xx, yy, r)
+    vl = format_axis_value(painter, val)
+    vw = painter.measure_text_width(vl, $theme.font_family, 10.0)
+    tc = $theme.text_primary
+    painter.draw_text(vl, xx - vw / 2.0, yy - r - 4.0, $theme.font_family, 10.0, tc)
+  end
+
+  def draw_line_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 @y_scale == nil
+    if @num_points <= 1
+      @hover_index = -1
+      return
+    end
+    mx = @mouse_x
+    px = plot_x
+    pw = plot_w
+    left_bound = px - @x_step / 2.0
+    right_bound = px + pw + @x_step / 2.0
+    if mx < left_bound
+      @hover_index = -1
+      return
+    end
+    if mx > right_bound
+      @hover_index = -1
+      return
+    end
+    find_nearest_point(mx, px)
+  end
+
+  def find_nearest_point(mx, px)
+    best = -1
+    best_dist = 999999.0
+    i = 0
+    while i < @num_points
+      i_f = i * 1.0
+      xx = px + i_f * @x_step
+      d = mx - xx
+      if d < 0.0
+        d = 0.0 - d
+      end
+      if d < best_dist
+        best_dist = d
+        best = i
+      end
+      i = i + 1
+    end
+    @hover_index = best
+  end
+
+  private
+
+  def compute_data_range
+    @data_min = 0.0
+    @data_max = 1.0
+    first = true
+    si = 0
+    while si < @series_data.length
+      ci = 0
+      while ci < @series_data[si].length
+        v = @series_data[si][ci]
+        if first
+          @data_min = v
+          @data_max = v
+          first = false
+        else
+          if v > @data_max
+            @data_max = v
+          end
+          if v < @data_min
+            @data_min = v
+          end
+        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
+      @data_min = @data_min - range * 0.05
+    else
+      @data_max = @data_max + 1.0
+    end
+  end
+end
+
+def LineChart(x_labels, series_data, series_names)
+  LineChart.new(x_labels, series_data, series_names)
+end

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

@@ -0,0 +1,219 @@
+# PieChart - pie/donut chart widget
+# Supports slice labels, percentages, hover, donut mode
+
+PIE_PI = 3.14159265358979323846
+
+class PieChart < BaseChart
+  def initialize(labels, values)
+    super()
+    @labels = labels
+    @values = values
+    @donut = false
+    @donut_ratio = 0.5
+    @show_pct = true
+    @show_labels = true
+    @start_angle = -90.0
+    # Computed per-frame
+    @cx = 0.0
+    @cy = 0.0
+    @radius = 20.0
+    @total = 0.0
+  end
+
+  def donut(v)
+    @donut = v
+    self
+  end
+
+  def donut_ratio(r)
+    @donut_ratio = r
+    self
+  end
+
+  def show_percentages(v)
+    @show_pct = v
+    self
+  end
+
+  def show_labels(v)
+    @show_labels = v
+    self
+  end
+
+  def start_angle(a)
+    @start_angle = a
+    self
+  end
+
+  def set_data(labels, values)
+    @labels = labels
+    @values = values
+    mark_dirty
+    update
+  end
+
+  def render_chart(painter, px, py, pw, ph)
+    return if @labels.length == 0
+    setup_pie(px, py, pw, ph)
+    return if @total <= 0.0
+    draw_slices(painter)
+    draw_donut_hole(painter)
+    draw_pie_legend(painter, px)
+  end
+
+  def setup_pie(px, py, pw, ph)
+    @total = compute_total
+    chart_size = pw
+    if ph < pw
+      chart_size = ph
+    end
+    @radius = chart_size / 2.0 - 10.0
+    if @radius < 20.0
+      @radius = 20.0
+    end
+    @cx = px + pw / 2.0
+    @cy = py + ph / 2.0
+  end
+
+  def compute_total
+    total = 0.0
+    i = 0
+    while i < @values.length
+      total = total + @values[i]
+      i = i + 1
+    end
+    total
+  end
+
+  def draw_slices(painter)
+    angle = @start_angle
+    i = 0
+    while i < @values.length
+      angle = draw_one_slice(painter, i, angle)
+      i = i + 1
+    end
+  end
+
+  def draw_one_slice(painter, i, angle)
+    fraction = @values[i] / @total
+    sweep = fraction * 360.0
+    c = series_color(i)
+    if @hover_index == i
+      c = painter.lighten_color(c, 0.3)
+    end
+    painter.fill_arc(@cx, @cy, @radius, angle, sweep, c)
+    if @show_pct
+      if fraction >= 0.03
+        draw_slice_label(painter, angle, sweep, fraction)
+      end
+    end
+    angle + sweep
+  end
+
+  def draw_slice_label(painter, angle, sweep, fraction)
+    mid_angle = angle + sweep / 2.0
+    rad = mid_angle * PIE_PI / 180.0
+    label_r = compute_label_radius
+    lx = @cx + label_r * painter.math_cos(rad)
+    ly = @cy + label_r * painter.math_sin(rad)
+    pct_val = fraction * 100.0
+    pct = painter.number_to_string(pct_val) + "%"
+    pw2 = painter.measure_text_width(pct, $theme.font_family, 11.0)
+    ascent = painter.get_text_ascent($theme.font_family, 11.0)
+    painter.draw_text(pct, lx - pw2 / 2.0, ly + ascent / 2.0, $theme.font_family, 11.0, 4294967295)
+  end
+
+  def compute_label_radius
+    if @donut
+      @radius * (1.0 + @donut_ratio) / 2.0
+    else
+      @radius * 0.65
+    end
+  end
+
+  def draw_donut_hole(painter)
+    if @donut
+      inner_r = @radius * @donut_ratio
+      painter.fill_circle(@cx, @cy, inner_r, $theme.bg_primary)
+    end
+  end
+
+  def draw_pie_legend(painter, px)
+    if @show_legend
+      legend_y = @cy + @radius + 16.0
+      colors = []
+      i = 0
+      while i < @labels.length
+        colors << series_color(i)
+        i = i + 1
+      end
+      draw_legend(painter, @labels, colors, px + 8.0, legend_y)
+    end
+  end
+
+  def update_hover
+    return if @painter == nil
+    mx = @mouse_x
+    my = @mouse_y
+    dx = mx - @cx
+    dy = my - @cy
+    dist = @painter.math_sqrt(dx * dx + dy * dy)
+    if dist > @radius
+      @hover_index = -1
+      return
+    end
+    if @donut
+      inner = @radius * @donut_ratio
+      if dist < inner
+        @hover_index = -1
+        return
+      end
+    end
+    find_hover_slice(dx, dy)
+  end
+
+  def find_hover_slice(dx, dy)
+    angle_rad = @painter.math_atan2(dy, dx)
+    angle_deg = angle_rad * 180.0 / PIE_PI
+    relative = angle_deg - @start_angle
+    relative = normalize_angle(relative)
+    total = compute_total
+    if total <= 0.0
+      @hover_index = -1
+      return
+    end
+    find_slice_at_angle(relative, total)
+  end
+
+  def normalize_angle(a)
+    while a < 0.0
+      a = a + 360.0
+    end
+    while a >= 360.0
+      a = a - 360.0
+    end
+    a
+  end
+
+  def find_slice_at_angle(relative, total)
+    cumulative = 0.0
+    i = 0
+    while i < @values.length
+      fraction = @values[i] / total
+      sweep = fraction * 360.0
+      if relative >= cumulative
+        if relative < cumulative + sweep
+          @hover_index = i
+          return
+        end
+      end
+      cumulative = cumulative + sweep
+      i = i + 1
+    end
+    @hover_index = -1
+  end
+end
+
+def PieChart(labels, values)
+  PieChart.new(labels, values)
+end

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

@@ -0,0 +1,77 @@
+# Chart Scales - domain-to-pixel coordinate mapping
+# Pure math classes, no UI dependency
+# IMPORTANT: In constructors, use local params (not @field) to avoid JVM field type issues
+
+class LinearScale
+  def initialize(domain_min, domain_max, range_min, range_max)
+    @domain_min = domain_min
+    @domain_max = domain_max
+    @range_min = range_min
+    @range_max = range_max
+    span = domain_max - domain_min
+    if span == 0.0
+      @factor = 0.0
+    else
+      @factor = (range_max - range_min) / span
+    end
+  end
+
+  def map(value)
+    @range_min + (value - @domain_min) * @factor
+  end
+
+  def domain_min
+    @domain_min
+  end
+
+  def domain_max
+    @domain_max
+  end
+
+  def range_min
+    @range_min
+  end
+
+  def range_max
+    @range_max
+  end
+end
+
+class BandScale
+  def initialize(count, range_min, range_max, padding)
+    @count = count
+    @range_min = range_min
+    @range_max = range_max
+    @padding = padding
+    total = range_max - range_min
+    @band_width = compute_band_width(count, total, padding)
+  end
+
+  def compute_band_width(count, total, padding)
+    if count > 0.0
+      slots = count + 1.0
+      pad_total = padding * slots
+      usable = total - pad_total
+      bw = usable / count
+      if bw < 1.0
+        bw = 1.0
+      end
+      bw
+    else
+      total
+    end
+  end
+
+  def map(index)
+    idx = index * 1.0
+    @range_min + @padding + idx * (@band_width + @padding)
+  end
+
+  def band_width
+    @band_width
+  end
+
+  def count
+    @count
+  end
+end