kumiki 0.1.1

data/lib/kumiki/app.rb

@@ -0,0 +1,381 @@
+module Kumiki
+  # rbs_inline: enabled
+
+  # App - main application loop with event dispatching
+
+  class App
+    #: (RanmaFrame frame, untyped widget) -> void
+    def initialize(frame, widget)
+      @@current = self
+      @frame = frame
+      @root = widget
+      @downed = nil
+      @focused = nil
+      @mouse_overed = nil
+      @prev_abs_x = 0.0
+      @prev_abs_y = 0.0
+      @prev_rel_x = 0.0
+      @prev_rel_y = 0.0
+      @focusables = []
+      @prev_frame_w = 0.0
+      @prev_frame_h = 0.0
+      @cursor_x = 0.0
+      @cursor_y = 0.0
+      @animations = []
+      @last_frame_time = 0
+    end
+
+    #: () -> App?
+    def self.current
+      @@current
+    end
+
+    # Clear references to a widget being detached
+    #: (untyped w) -> void
+    def clear_widget_refs(w)
+      if @mouse_overed == w
+        @mouse_overed = nil
+      end
+      if @focused == w
+        @focused = nil
+      end
+      if @downed == w
+        @downed = nil
+      end
+    end
+
+    #: (untyped widget) -> void
+    def post_update(widget)
+      @frame.post_update(nil)
+    end
+
+    #: () -> void
+    def run
+      frame = @frame
+      root = @root
+      app = self
+
+      frame.on_redraw { |painter, completely|
+        # Tick animations
+        now = painter.current_time_millis
+        if @last_frame_time > 0
+          dt = (now - @last_frame_time).to_f
+          if dt > 100.0
+            dt = 100.0  # Cap to avoid jumps
+          end
+          any_active = false
+          i = 0
+          while i < @animations.length
+            still_going = @animations[i].tick(dt)
+            if still_going
+              any_active = true
+            end
+            i = i + 1
+          end
+          # Remove finished animations
+          new_anims = []
+          i = 0
+          while i < @animations.length
+            if @animations[i].animating?
+              new_anims << @animations[i]
+            end
+            i = i + 1
+          end
+          @animations = new_anims
+          if any_active
+            completely = true
+            frame.post_update(nil)
+          end
+        end
+        @last_frame_time = now
+
+        frame_size = frame.get_size
+        # Detect resize → force complete redraw
+        if frame_size.width != @prev_frame_w || frame_size.height != @prev_frame_h
+          @prev_frame_w = frame_size.width
+          @prev_frame_h = frame_size.height
+          completely = true
+        end
+
+        # Resize root based on size policy
+        rw = root.get_width_policy == EXPANDING ? frame_size.width : root.get_width
+        rh = root.get_height_policy == EXPANDING ? frame_size.height : root.get_height
+        root.resize_wh(rw, rh)
+        root.move_xy(0.0, 0.0)
+
+        if completely
+          painter.clear(Kumiki.theme.bg_canvas)
+        end
+        root.redraw(painter, completely)
+      }
+
+      frame.on_mouse_down { |ev|
+        result = root.dispatch(ev.pos)
+        target = result[0]
+        p = result[1]
+        if target
+          @prev_abs_x = ev.pos.x
+          @prev_abs_y = ev.pos.y
+          ev.pos = p
+          @prev_rel_x = p.x
+          @prev_rel_y = p.y
+          target.mouse_down(ev)
+          app.set_downed(target)
+        end
+      }
+
+      frame.on_mouse_up { |ev|
+        downed = app.get_downed
+        if downed
+          # Focus management: unfocus old, focus new
+          old_focused = app.get_focused
+          if old_focused != nil && old_focused != downed
+            old_focused.unfocused
+          end
+          app.set_focused(downed)
+          downed.focused
+
+          # Convert to local coordinates relative to downed widget
+          local_p = Point.new(ev.pos.x - downed.get_x, ev.pos.y - downed.get_y)
+          ev.pos = local_p
+          downed.mouse_up(ev)
+          app.set_downed(nil)
+        end
+      }
+
+      frame.on_cursor_pos { |ev|
+        app.set_cursor_xy(ev.pos.x, ev.pos.y)
+        result = root.dispatch(ev.pos)
+        target = result[0]
+        p = result[1]
+        downed = app.get_downed
+        overed = app.get_mouse_overed
+
+        if target == nil
+          # Cursor left all widgets
+          if overed != nil
+            overed.mouse_out
+            app.set_mouse_overed(nil)
+          end
+        elsif downed == nil
+          # No button pressed - handle hover
+          if overed == nil
+            app.set_mouse_overed(target)
+            target.mouse_over
+          elsif overed != target
+            overed.mouse_out
+            app.set_mouse_overed(target)
+            target.mouse_over
+          end
+          # Notify target of cursor position
+          if p != nil
+            target.cursor_pos(MouseEvent.new(p, 0))
+          end
+        else
+          # Button pressed - handle drag
+          diff_x = ev.pos.x - @prev_abs_x
+          diff_y = ev.pos.y - @prev_abs_y
+          @prev_abs_x = ev.pos.x
+          @prev_abs_y = ev.pos.y
+          drag_pos = Point.new(@prev_rel_x + diff_x, @prev_rel_y + diff_y)
+          @prev_rel_x = drag_pos.x
+          @prev_rel_y = drag_pos.y
+          downed.mouse_drag(MouseEvent.new(drag_pos, 0))
+        end
+      }
+
+      frame.on_mouse_wheel { |ev|
+        cursor = Point.new(app.get_cursor_x, app.get_cursor_y)
+        result = root.dispatch_to_scrollable(cursor, false)
+        target = result[0]
+        if target != nil
+          target.mouse_wheel(ev)
+        end
+      }
+
+      frame.on_input_char { |text|
+        focused = app.get_focused
+        focused.input_char(text) if focused
+      }
+
+      frame.on_input_key { |key_code, modifiers|
+        # Tab (key ordinal 13): cycle focus
+        if key_code == 13
+          shift = (modifiers & 1) != 0
+          app.cycle_focus(root, shift)
+        else
+          focused = app.get_focused
+          focused.input_key(key_code, modifiers) if focused
+        end
+      }
+
+      frame.on_ime_preedit { |text, sel_start, sel_end|
+        focused = app.get_focused
+        focused.ime_preedit(text, sel_start, sel_end) if focused
+      }
+
+      frame.run
+    end
+
+    # Accessors for event state (used from blocks)
+    #: (untyped w) -> void
+    def set_downed(w)
+      @downed = w
+    end
+
+    #: () -> untyped
+    def get_downed
+      @downed
+    end
+
+    #: (untyped w) -> void
+    def set_focused(w)
+      @focused = w
+    end
+
+    #: () -> untyped
+    def get_focused
+      @focused
+    end
+
+    #: (untyped w) -> void
+    def set_mouse_overed(w)
+      @mouse_overed = w
+    end
+
+    #: () -> untyped
+    def get_mouse_overed
+      @mouse_overed
+    end
+
+    #: (Float x, Float y) -> void
+    def set_cursor_xy(x, y)
+      @cursor_x = x
+      @cursor_y = y
+    end
+
+    #: () -> Float
+    def get_cursor_x
+      @cursor_x
+    end
+
+    #: () -> Float
+    def get_cursor_y
+      @cursor_y
+    end
+
+    # --- Animation ---
+
+    #: (untyped anim) -> void
+    def register_animation(anim)
+      i = 0
+      while i < @animations.length
+        return if @animations[i] == anim
+        i = i + 1
+      end
+      @animations << anim
+      @frame.post_update(nil)
+    end
+
+    #: (untyped anim) -> void
+    def unregister_animation(anim)
+      new_list = []
+      i = 0
+      while i < @animations.length
+        if @animations[i] != anim
+          new_list << @animations[i]
+        end
+        i = i + 1
+      end
+      @animations = new_list
+    end
+
+    # --- Clipboard ---
+
+    #: () -> String
+    def get_clipboard_text
+      @frame.get_clipboard_text
+    end
+
+    #: (String text) -> void
+    def set_clipboard_text(text)
+      @frame.set_clipboard_text(text)
+    end
+
+    # --- Text Input / IME ---
+
+    #: () -> void
+    def enable_text_input
+      @frame.enable_text_input
+    end
+
+    #: () -> void
+    def disable_text_input
+      @frame.disable_text_input
+    end
+
+    #: (Integer x, Integer y, Integer w, Integer h) -> void
+    def set_ime_cursor_rect(x, y, w, h)
+      @frame.set_ime_cursor_rect(x, y, w, h)
+    end
+
+    # --- Focus Management ---
+    # Collect focusable widgets from tree into @focusables array
+
+    #: (untyped widget) -> void
+    def collect_focusables_from(widget)
+      if widget.is_focusable
+        @focusables << widget
+      end
+      children = widget.get_children
+      i = 0
+      while i < children.length
+        collect_focusables_from(children[i])
+        i = i + 1
+      end
+    end
+
+    #: (untyped root, bool reverse) -> void
+    def cycle_focus(root, reverse)
+      @focusables = []
+      collect_focusables_from(root)
+      count = @focusables.length
+      return if count == 0
+
+      # Find current focused index
+      current_idx = -1
+      i = 0
+      while i < count
+        if @focusables[i] == @focused
+          current_idx = i
+        end
+        i = i + 1
+      end
+
+      # Compute next index
+      next_idx = 0
+      if reverse
+        next_idx = current_idx - 1
+        if next_idx < 0
+          next_idx = count - 1
+        end
+      else
+        next_idx = current_idx + 1
+        if next_idx >= count
+          next_idx = 0
+        end
+      end
+
+      new_focus = @focusables[next_idx]
+      old = @focused
+      if old != nil
+        old.unfocused
+      end
+      @focused = new_focus
+      new_focus.focused
+    end
+    # Initialize @@current
+    @@current = nil
+  end
+
+end

data/lib/kumiki/box.rb

@@ -0,0 +1,40 @@
+module Kumiki
+  # rbs_inline: enabled
+
+  # Box layout - overlay/stack of children (all at same position)
+
+  class Box < Layout
+    def initialize
+      super
+    end
+
+    #: (untyped painter) -> void
+    def relocate_children(painter)
+      i = 0
+      while i < @children.length
+        c = @children[i]
+        if c.get_width_policy == EXPANDING
+          c.resize_wh(@width, c.get_height)
+        end
+        if c.get_height_policy == EXPANDING
+          c.resize_wh(c.get_width, @height)
+        end
+        c.move_xy(@x, @y)
+        i = i + 1
+      end
+    end
+  end
+
+  # Top-level helper
+  #: (*untyped children) -> Box
+  def Box(*children)
+    box = Box.new
+    i = 0
+    while i < children.length
+      box.add(children[i])
+      i = i + 1
+    end
+    box
+  end
+
+end

data/lib/kumiki/chart/area_chart.rb

@@ -0,0 +1,308 @@
+module Kumiki
+  # AreaChart - line chart with filled areas below
+  # Supports multiple series (stacked or overlapping), grid, hover detection
+
+  class AreaChart < BaseChart
+    def initialize(x_labels, series_data, series_names)
+      super()
+      @x_labels = x_labels
+      @series_data = series_data
+      @series_names = series_names
+      @line_width = 2.0
+      @fill_alpha = 80
+      @show_grid = true
+      @stacked = false
+      @data_min = 0.0
+      @data_max = 0.0
+      @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_area_range
+    end
+
+    def line_width(w)
+      @line_width = w
+      self
+    end
+
+    def fill_alpha(a)
+      @fill_alpha = a
+      self
+    end
+
+    def show_grid(v)
+      @show_grid = v
+      self
+    end
+
+    def stacked(v)
+      @stacked = 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_area_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
+      @num_points = @x_labels.length
+      @num_series = @series_data.length
+      setup_area_ticks
+      setup_area_y_scale
+      setup_area_x_step
+      draw_y_axis(painter, px, py, pw, ph, @y_ticks, @y_scale)
+      draw_x_axis_line(painter, px, py, pw, ph)
+      draw_area_x_labels(painter)
+      draw_area_hover_line(painter)
+      draw_all_areas(painter)
+      draw_area_legend(painter, px, py)
+    end
+
+    def setup_area_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_area_y_scale
+      bottom = @chart_py + @chart_ph
+      @y_scale = LinearScale.new(@y_range_min, @y_range_max, bottom, @chart_py)
+    end
+
+    def setup_area_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_area_x_labels(painter)
+      lc = Kumiki.theme.text_secondary
+      i = 0
+      while i < @num_points
+        i_f = i * 1.0
+        xx = @chart_px + i_f * @x_step
+        label = @x_labels[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_y = @chart_py + @chart_ph + 14.0 + ascent
+        painter.draw_text(label, xx - lw / 2.0, label_y, Kumiki.theme.font_family, 11.0, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_area_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(Kumiki.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_areas(painter)
+      baseline_y = @y_scale.map(0.0)
+      bottom = @chart_py + @chart_ph
+      if baseline_y > bottom
+        baseline_y = bottom
+      end
+      # Draw areas back to front (last series first)
+      si = @num_series - 1
+      while si >= 0
+        c = series_color(si)
+        fill_c = painter.with_alpha(c, @fill_alpha)
+        data = @series_data[si]
+        draw_area_fill(painter, data, fill_c, baseline_y)
+        draw_area_line(painter, data, c)
+        si = si - 1
+      end
+      # Draw hover points on top
+      if @hover_index >= 0
+        if @hover_index < @num_points
+          draw_area_hover_points(painter)
+        end
+      end
+    end
+
+    def draw_area_fill(painter, data, fill_c, baseline_y)
+      return if @num_points < 2
+      # Build path: top line left-to-right, then bottom line right-to-left
+      painter.begin_path
+      # First point
+      x0 = @chart_px
+      y0 = @y_scale.map(data[0])
+      painter.path_move_to(x0, y0)
+      # Line across top
+      i = 1
+      while i < @num_points
+        i_f = i * 1.0
+        xx = @chart_px + i_f * @x_step
+        yy = @y_scale.map(data[i])
+        painter.path_line_to(xx, yy)
+        i = i + 1
+      end
+      # Line down to baseline at last point
+      last_f = (@num_points - 1) * 1.0
+      last_x = @chart_px + last_f * @x_step
+      painter.path_line_to(last_x, baseline_y)
+      # Line back to first x at baseline
+      painter.path_line_to(@chart_px, baseline_y)
+      painter.close_fill_path(fill_c)
+    end
+
+    def draw_area_line(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_area_hover_points(painter)
+      si = 0
+      while si < @num_series
+        c = series_color(si)
+        data = @series_data[si]
+        if @hover_index < data.length
+          hi_f = @hover_index * 1.0
+          xx = @chart_px + hi_f * @x_step
+          yy = @y_scale.map(data[@hover_index])
+          painter.fill_circle(xx, yy, 5.0, c)
+          vl = painter.number_to_string(data[@hover_index])
+          vw = painter.measure_text_width(vl, Kumiki.theme.font_family, 10.0)
+          tc = Kumiki.theme.text_primary
+          painter.draw_text(vl, xx - vw / 2.0, yy - 8.0, Kumiki.theme.font_family, 10.0, tc)
+        end
+        si = si + 1
+      end
+    end
+
+    def draw_area_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
+      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_area_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
+      if @data_min > 0.0
+        @data_min = 0.0
+      end
+      range = @data_max - @data_min
+      if range > 0.0
+        @data_max = @data_max + range * 0.1
+      else
+        @data_max = @data_max + 1.0
+      end
+    end
+  end
+
+  def AreaChart(x_labels, series_data, series_names)
+    AreaChart.new(x_labels, series_data, series_names)
+  end
+
+end