kumiki 0.1.1

data/lib/kumiki/widgets/multiline_text.rb

@@ -0,0 +1,180 @@
+module Kumiki
+  # MultilineText widget - displays multiline text with optional word wrapping
+
+  class MultilineText < Widget
+    def initialize(text)
+      super()
+      @text = text
+      @font_family = nil
+      @font_size_val = 14.0
+      @color_val = 0xFFC0CAF5
+      @custom_color = false
+      @kind_val = 0
+      @padding_val = 8.0
+      @line_spacing = 4.0
+      @wrap_enabled = false
+      @border_width_val = 1.0
+      @cached_lines = []
+    end
+
+    def font_family(f)
+      @font_family = f
+      self
+    end
+
+    def resolved_font_family
+      if @font_family != nil
+        @font_family
+      else
+        Kumiki.theme.font_family
+      end
+    end
+
+    def font_size(s)
+      @font_size_val = s
+      self
+    end
+
+    def color(c)
+      @color_val = c
+      @custom_color = true
+      self
+    end
+
+    def kind(k)
+      @kind_val = k
+      self
+    end
+
+    def padding(p)
+      @padding_val = p
+      self
+    end
+
+    def line_spacing(s)
+      @line_spacing = s
+      self
+    end
+
+    def wrap_text(w)
+      @wrap_enabled = w
+      self
+    end
+
+    def set_text(t)
+      @text = t
+      @cached_lines = []
+      mark_dirty
+    end
+
+    def get_text
+      @text
+    end
+
+    def measure(painter)
+      lines = split_lines(painter)
+      @cached_lines = lines
+      if lines.length == 0
+        return Size.new(@padding_val * 2.0, @padding_val * 2.0)
+      end
+      ff = resolved_font_family
+      max_w = 0.0
+      i = 0
+      while i < lines.length
+        lw = painter.measure_text_width(lines[i], ff, @font_size_val)
+        if lw > max_w
+          max_w = lw
+        end
+        i = i + 1
+      end
+      w = max_w + (@padding_val + @border_width_val) * 2.0
+      h = @font_size_val * lines.length + @line_spacing * (lines.length - 1) + @padding_val * 2.0 + @border_width_val * 2.0
+      Size.new(w, h)
+    end
+
+    def redraw(painter, completely)
+      lines = split_lines(painter)
+      @cached_lines = lines
+
+      # Background
+      bg_c = Kumiki.theme.bg_primary
+      brd_c = Kumiki.theme.border
+      painter.fill_rect(0.0, 0.0, @width, @height, bg_c)
+      painter.stroke_rect(0.0, 0.0, @width, @height, brd_c, @border_width_val)
+
+      # Text
+      ff = resolved_font_family
+      c = @custom_color ? @color_val : Kumiki.theme.text_color_for_kind(@kind_val)
+      ascent = painter.get_text_ascent(ff, @font_size_val)
+      y = @padding_val + @border_width_val + ascent
+      i = 0
+      while i < lines.length
+        painter.draw_text(lines[i], @padding_val + @border_width_val, y, ff, @font_size_val, c)
+        y = y + @font_size_val + @line_spacing
+        i = i + 1
+      end
+    end
+
+    def split_lines(painter)
+      raw_lines = @text.split("\n")
+      if !@wrap_enabled
+        return raw_lines
+      end
+      # Word wrapping
+      ff = resolved_font_family
+      line_width = @width - (@padding_val + @border_width_val) * 2.0
+      if line_width <= 0.0
+        return raw_lines
+      end
+      result = []
+      ri = 0
+      while ri < raw_lines.length
+        line = raw_lines[ri]
+        words = line.split(" ")
+        if words.length == 0
+          result.push("")
+          ri = ri + 1
+          next
+        end
+        current_words = []
+        current_width = 0.0
+        wi = 0
+        while wi < words.length
+          word = words[wi]
+          word_w = painter.measure_text_width(word, ff, @font_size_val)
+          space_w = 0.0
+          if current_words.length > 0
+            space_w = painter.measure_text_width(" ", ff, @font_size_val)
+          end
+          if current_width + space_w + word_w > line_width
+            if current_words.length > 0
+              result.push(current_words.join(" "))
+              current_words = [word]
+              current_width = word_w
+            else
+              # Single word wider than line - just include it
+              result.push(word)
+              current_words = []
+              current_width = 0.0
+            end
+          else
+            current_words.push(word)
+            current_width = current_width + space_w + word_w
+          end
+          wi = wi + 1
+        end
+        if current_words.length > 0
+          result.push(current_words.join(" "))
+        end
+        ri = ri + 1
+      end
+      result
+    end
+  end
+
+  # Top-level helper
+  def MultilineText(text)
+    MultilineText.new(text)
+  end
+
+end

data/lib/kumiki/widgets/net_image.rb

@@ -0,0 +1,100 @@
+module Kumiki
+  # NetImage widget - displays an image from a network URL
+
+  class NetImageWidget < Widget
+    def initialize(url)
+      super()
+      @url = url
+      @image_id = 0
+      @img_width = 0.0
+      @img_height = 0.0
+      @fit_mode = IMAGE_FIT_CONTAIN
+    end
+
+    def fit(mode)
+      @fit_mode = mode
+      self
+    end
+
+    def set_url(url)
+      @url = url
+      @image_id = 0
+      @img_width = 0.0
+      @img_height = 0.0
+      mark_dirty
+    end
+
+    def load_if_needed(painter)
+      if @image_id == 0
+        @image_id = painter.load_net_image(@url)
+        if @image_id != 0
+          @img_width = painter.get_image_width(@image_id) * 1.0
+          @img_height = painter.get_image_height(@image_id) * 1.0
+        end
+      end
+    end
+
+    def measure(painter)
+      load_if_needed(painter)
+      if @image_id != 0
+        Size.new(@img_width, @img_height)
+      else
+        Size.new(100.0, 100.0)
+      end
+    end
+
+    def redraw(painter, completely)
+      load_if_needed(painter)
+      if @image_id == 0
+        # Draw placeholder while loading or on error
+        painter.fill_round_rect(0.0, 0.0, @width, @height, 4.0, 0x40FFFFFF)
+        painter.stroke_round_rect(0.0, 0.0, @width, @height, 4.0, 0x80FFFFFF, 1.0)
+        return
+      end
+
+      if @fit_mode == IMAGE_FIT_FILL
+        painter.draw_image(@image_id, 0.0, 0.0, @width, @height)
+      elsif @fit_mode == IMAGE_FIT_CONTAIN
+        draw_fitted(painter, true)
+      else
+        draw_fitted(painter, false)
+      end
+    end
+
+    def draw_fitted(painter, contain)
+      if @img_width < 1.0 || @img_height < 1.0 || @width < 1.0 || @height < 1.0
+        return
+      end
+      img_aspect = @img_width / @img_height
+      widget_aspect = @width / @height
+
+      if contain
+        if img_aspect > widget_aspect
+          new_w = @width
+          new_h = @width / img_aspect
+        else
+          new_h = @height
+          new_w = @height * img_aspect
+        end
+      else
+        if img_aspect > widget_aspect
+          new_h = @height
+          new_w = @height * img_aspect
+        else
+          new_w = @width
+          new_h = @width / img_aspect
+        end
+      end
+
+      dx = (@width - new_w) / 2.0
+      dy = (@height - new_h) / 2.0
+      painter.draw_image(@image_id, dx, dy, new_w, new_h)
+    end
+  end
+
+  # Top-level helper
+  def NetImage(url)
+    NetImageWidget.new(url)
+  end
+
+end

data/lib/kumiki/widgets/progress_bar.rb

@@ -0,0 +1,72 @@
+module Kumiki
+  # ProgressBar widget - progress indicator
+
+  class ProgressBar < Widget
+    def initialize
+      super()
+      @value = 0.0
+      @width_policy = EXPANDING
+      @height_policy = FIXED
+      @height = 8.0
+      # Colors (Tokyo Night)
+      @track_color = 0xFF414868
+      @fill_color = 0xFF7AA2F7
+      @radius = 4.0
+    end
+
+    def with_value(v)
+      if v < 0.0
+        @value = 0.0
+      elsif v > 1.0
+        @value = 1.0
+      else
+        @value = v
+      end
+      self
+    end
+
+    def set_value(v)
+      if v < 0.0
+        v = 0.0
+      end
+      if v > 1.0
+        v = 1.0
+      end
+      if v != @value
+        @value = v
+        mark_dirty
+        update
+      end
+    end
+
+    def get_value
+      @value
+    end
+
+    def fill_color(c)
+      @fill_color = c
+      self
+    end
+
+    def measure(painter)
+      Size.new(200.0, 8.0)
+    end
+
+    def redraw(painter, completely)
+      # Track background
+      painter.fill_round_rect(0.0, 0.0, @width, @height, @radius, @track_color)
+
+      # Fill
+      fill_w = @width * @value
+      if fill_w > 0.0
+        painter.fill_round_rect(0.0, 0.0, fill_w, @height, @radius, @fill_color)
+      end
+    end
+  end
+
+  # Top-level helper
+  def ProgressBar()
+    ProgressBar.new
+  end
+
+end

data/lib/kumiki/widgets/radio_buttons.rb

@@ -0,0 +1,93 @@
+module Kumiki
+  # RadioButtons widget - exclusive selection from a list
+  # Single widget that renders all options (avoids cross-class method calls)
+
+  class RadioButtons < Widget
+    def initialize(options)
+      super()
+      @options = options
+      @option_count = options.length
+      @selected = 0
+      @change_handler = nil
+      @hovered_index = -1
+      # Colors (Tokyo Night)
+      @text_color = 0xFFC0CAF5
+      @ring_color = 0xFF565F89
+      @selected_color = 0xFF7AA2F7
+      @font_size_val = 14.0
+      @item_height = 32.0
+    end
+
+    def with_selected(index)
+      @selected = index
+      self
+    end
+
+    def on_change(&block)
+      @change_handler = block
+      self
+    end
+
+    def get_selected
+      @selected
+    end
+
+    def measure(painter)
+      max_w = 0.0
+      i = 0
+      while i < @option_count
+        tw = painter.measure_text_width(@options[i], Kumiki.theme.font_family, @font_size_val)
+        w = tw + 32.0
+        if w > max_w
+          max_w = w
+        end
+        i = i + 1
+      end
+      Size.new(max_w, @item_height * @option_count)
+    end
+
+    def redraw(painter, completely)
+      circle_r = 7.0
+      i = 0
+      while i < @option_count
+        iy = @item_height * i
+        cx = circle_r + 4.0
+        cy = iy + @item_height / 2.0
+
+        # Outer ring
+        painter.fill_circle(cx, cy, circle_r, @ring_color)
+        painter.fill_circle(cx, cy, circle_r - 1.5, 0xFF1A1B26)
+
+        # Selected dot
+        if @selected == i
+          painter.fill_circle(cx, cy, 4.0, @selected_color)
+        end
+
+        # Label
+        ascent = painter.get_text_ascent(Kumiki.theme.font_family, @font_size_val)
+        text_x = cx + circle_r + 8.0
+        th = painter.measure_text_height(Kumiki.theme.font_family, @font_size_val)
+        text_y = iy + (@item_height - th) / 2.0 + ascent
+        painter.draw_text(@options[i], text_x, text_y, Kumiki.theme.font_family, @font_size_val, @text_color)
+
+        i = i + 1
+      end
+    end
+
+    def mouse_down(ev)
+      index = (ev.pos.y / @item_height).to_i
+      if index >= 0 && index < @option_count && index != @selected
+        @selected = index
+        @change_handler.call(@selected) if @change_handler
+        mark_dirty
+        update
+      end
+    end
+  end
+
+  # Top-level helper
+  def RadioButtons(options)
+    RadioButtons.new(options)
+  end
+
+end

data/lib/kumiki/widgets/slider.rb

@@ -0,0 +1,135 @@
+module Kumiki
+  # Slider widget - draggable range input
+
+  class Slider < Widget
+    def initialize(min_val, max_val)
+      super()
+      @min_val = min_val
+      @max_val = max_val
+      @value = min_val
+      @dragging = false
+      @change_handler = nil
+      @width_policy = EXPANDING
+      @height_policy = FIXED
+      @height = 30.0
+      # Colors (Tokyo Night)
+      @track_color = 0xFF414868
+      @fill_color = 0xFF7AA2F7
+      @thumb_color = 0xFFC0CAF5
+      @thumb_hover = 0xFFFFFFFF
+      @hovered = false
+    end
+
+    def with_value(v)
+      if v < @min_val
+        @value = @min_val
+      elsif v > @max_val
+        @value = @max_val
+      else
+        @value = v
+      end
+      self
+    end
+
+    def on_change(&block)
+      @change_handler = block
+      self
+    end
+
+    def get_value
+      @value
+    end
+
+    def measure(painter)
+      Size.new(200.0, 30.0)
+    end
+
+    def redraw(painter, completely)
+      thumb_r = 8.0
+      track_h = 4.0
+      track_y = (@height - track_h) / 2.0
+      track_x = thumb_r
+      track_w = @width - thumb_r * 2.0
+      if track_w < 0.0
+        track_w = 0.0
+      end
+
+      # Track background
+      painter.fill_round_rect(track_x, track_y, track_w, track_h, 2.0, @track_color)
+
+      # Fill (progress)
+      ratio = 0.0
+      range = @max_val - @min_val
+      if range > 0.0
+        ratio = (@value - @min_val) / range
+      end
+      fill_w = track_w * ratio
+      if fill_w > 0.0
+        painter.fill_round_rect(track_x, track_y, fill_w, track_h, 2.0, @fill_color)
+      end
+
+      # Thumb circle
+      thumb_x = track_x + fill_w
+      thumb_y = @height / 2.0
+      tc = @hovered ? @thumb_hover : @thumb_color
+      painter.fill_circle(thumb_x, thumb_y, thumb_r, tc)
+    end
+
+    def mouse_down(ev)
+      @dragging = true
+      update_from_pos(ev.pos.x)
+    end
+
+    def mouse_drag(ev)
+      if @dragging
+        update_from_pos(ev.pos.x)
+      end
+    end
+
+    def mouse_up(ev)
+      @dragging = false
+    end
+
+    def mouse_over
+      @hovered = true
+      mark_dirty
+      update
+    end
+
+    def mouse_out
+      @hovered = false
+      mark_dirty
+      update
+    end
+
+    def update_from_pos(x)
+      thumb_r = 8.0
+      track_x = thumb_r
+      track_w = @width - thumb_r * 2.0
+      if track_w <= 0.0
+        return
+      end
+      ratio = (x - track_x) / track_w
+      if ratio < 0.0
+        ratio = 0.0
+      end
+      if ratio > 1.0
+        ratio = 1.0
+      end
+      range = @max_val - @min_val
+      new_val = @min_val + ratio * range
+      if new_val != @value
+        @value = new_val
+        @change_handler.call(@value) if @change_handler
+        mark_dirty
+        update
+      end
+    end
+  end
+
+  # Top-level helper
+  def Slider(min_val, max_val)
+    Slider.new(min_val, max_val)
+  end
+
+end

data/lib/kumiki/widgets/switch.rb

@@ -0,0 +1,84 @@
+module Kumiki
+  # Switch widget - ON/OFF toggle
+
+  class Switch < Widget
+    def initialize
+      super()
+      @on = false
+      @change_handler = nil
+      # Colors (Tokyo Night)
+      @on_color = 0xFF7AA2F7
+      @off_color = 0xFF414868
+      @knob_color = 0xFFFFFFFF
+      @hovered = false
+    end
+
+    def with_on(v)
+      @on = v
+      self
+    end
+
+    def on_change(&block)
+      @change_handler = block
+      self
+    end
+
+    def is_on
+      @on
+    end
+
+    def measure(painter)
+      Size.new(44.0, 24.0)
+    end
+
+    def redraw(painter, completely)
+      w = 44.0
+      h = 24.0
+      r = h / 2.0
+
+      # Track
+      track_color = @on ? @on_color : @off_color
+      painter.fill_round_rect(0.0, 0.0, w, h, r, track_color)
+
+      # Knob
+      knob_r = 9.0
+      knob_y = h / 2.0
+      knob_x = 0.0
+      if @on
+        knob_x = w - r
+      else
+        knob_x = r
+      end
+      painter.fill_circle(knob_x, knob_y, knob_r, @knob_color)
+    end
+
+    def mouse_up(ev)
+      if @on
+        @on = false
+      else
+        @on = true
+      end
+      @change_handler.call(@on) if @change_handler
+      mark_dirty
+      update
+    end
+
+    def mouse_over
+      @hovered = true
+      mark_dirty
+      update
+    end
+
+    def mouse_out
+      @hovered = false
+      mark_dirty
+      update
+    end
+  end
+
+  # Top-level helper
+  def Switch()
+    Switch.new
+  end
+
+end