clogs 0.1.0

data/lib/clogs/drawables/image.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "../drawable"
+
+module Clogs
+  # Bitmaps.
+  #
+  # This is the one place where libui really lets Shoes down. libui-ng has
+  # `uiImage`, but the only thing that can display one is a table cell -- the
+  # released library exports no `uiDrawImage`, so there is no way to blit a
+  # bitmap into an area. (Clogs checks for it at runtime and uses it if a
+  # future build provides one.)
+  #
+  # The fallback is the same trick glimmer-dsl-libui uses: turn the image into
+  # filled rectangles. Clogs run-length encodes each row first, so flat art --
+  # icons, logos, screenshots of text -- costs a handful of rectangles per row
+  # instead of one per pixel. Photographs are genuinely slow and are best
+  # avoided until libui grows a draw-image call.
+  class Image < Drawable
+    class << self
+      def cache
+        @cache ||= {}
+      end
+
+      # Load an image and reduce it to per-row colour runs at the requested
+      # size. Cached by [path, width, height].
+      def runs_for(url, width, height)
+        key = [url, width, height]
+        cache[key] ||= build_runs(url, width, height)
+      end
+
+      # Every rectangle is a separate libui fill, so a photograph can cost tens
+      # of thousands of draw calls per frame and starve the event loop. Flat
+      # art stays well under this; anything that does not gets sampled at a
+      # coarser resolution until it fits, trading sharpness for a UI that still
+      # responds. None of this is needed once libui exports uiDrawImage.
+      RUN_BUDGET = 40_000
+
+      def build_runs(url, width, height)
+        pixels, src_w, src_h = load_pixels(url)
+        return nil unless pixels
+
+        width = src_w if width.nil? || width <= 0
+        height = src_h if height.nil? || height <= 0
+
+        runs = encode(pixels, src_w, src_h, width, height, 1)
+        step = 1
+        while runs.size > RUN_BUDGET && step < 8
+          step *= 2
+          runs = encode(pixels, src_w, src_h, width, height, step)
+        end
+        [runs, width, height]
+      end
+
+      # Walk the target rectangle at `step` pixels at a time, emitting one
+      # rectangle per run of equal colour.
+      def encode(pixels, src_w, src_h, width, height, step)
+        runs = []
+        0.step(height - 1, step) do |y|
+          sy = src_h == height ? y : (y * src_h / height)
+          row_start = sy * src_w
+          run_color = nil
+          run_x = 0
+          0.step(width - 1, step) do |x|
+            sx = src_w == width ? x : (x * src_w / width)
+            color = pixels[row_start + sx]
+            next if color == run_color
+
+            runs << [run_x, y, x - run_x, run_color] if run_color && run_color[3].positive?
+            run_color = color
+            run_x = x
+          end
+          runs << [run_x, y, width - run_x, run_color] if run_color && run_color[3].positive?
+        end
+        compact(runs, step)
+      end
+
+      # Rows that repeat identically become one taller rectangle. Flat art
+      # collapses dramatically here.
+      def compact(runs, step = 1)
+        by_key = {}
+        result = []
+        runs.each do |x, y, w, color|
+          key = [x, w, color]
+          prev = by_key[key]
+          if prev && prev[1] + prev[3] == y
+            prev[3] += step
+          else
+            rect = [x, y, w, step, color]
+            result << rect
+            by_key[key] = rect
+          end
+        end
+        result
+      end
+
+      def load_pixels(url)
+        path = local_path(url)
+        return nil unless path && File.exist?(path)
+
+        png = png_canvas(path)
+        return nil unless png
+
+        pixels = Array.new(png.width * png.height)
+        png.height.times do |y|
+          png.width.times do |x|
+            v = png[x, y]
+            pixels[y * png.width + x] = [(v >> 24) & 0xff, (v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff]
+          end
+        end
+        [pixels, png.width, png.height]
+      rescue StandardError => e
+        warn "Clogs: could not load image #{url.inspect}: #{e.message}"
+        nil
+      end
+
+      def png_canvas(path)
+        require "chunky_png"
+        return ChunkyPNG::Canvas.from_file(path) if File.extname(path).downcase == ".png"
+
+        converted = convert_to_png(path)
+        converted ? ChunkyPNG::Canvas.from_file(converted) : nil
+      end
+
+      # chunky_png only reads PNG. Anything else goes through ImageMagick if it
+      # happens to be installed.
+      def convert_to_png(path)
+        require "tmpdir"
+        out = File.join(Dir.tmpdir, "clogs-#{File.basename(path)}.png")
+        return out if File.exist?(out)
+        return nil unless system("which convert > /dev/null 2>&1")
+
+        system("convert", path, out) ? out : nil
+      end
+
+      def local_path(url)
+        return nil if url.nil?
+
+        url = url.to_s
+        return url unless url.start_with?("http://", "https://")
+
+        download(url)
+      end
+
+      def download(url)
+        require "tmpdir"
+        require "digest"
+        require "open-uri"
+        dest = File.join(Dir.tmpdir, "clogs-img-#{Digest::SHA256.hexdigest(url)[0, 16]}")
+        return dest if File.exist?(dest)
+
+        URI.parse(url).open { |io| File.binwrite(dest, io.read) }
+        dest
+      rescue StandardError => e
+        warn "Clogs: could not fetch #{url}: #{e.message}"
+        nil
+      end
+    end
+
+    def positioned?
+      !style(:left).nil? && !style(:top).nil?
+    end
+
+    def measure(available_width)
+      req_w = requested_width(available_width)
+      req_h = requested_height(available_width)
+      loaded = self.class.runs_for(style(:url), req_w, req_h)
+      if loaded
+        @runs, @width, @height = loaded
+      else
+        @runs = nil
+        @width = req_w || 0
+        @height = req_h || 0
+      end
+    end
+
+    def draw(painter, x, y)
+      unless @runs
+        # Nothing loaded: a light placeholder box beats an invisible hole.
+        painter.stroke_rect(x + 0.5, y + 0.5, [@width - 1, 1].max, [@height - 1, 1].max,
+          [200, 200, 200, 255], thickness: 1)
+        return
+      end
+
+      @runs.each do |rx, ry, rw, rh, color|
+        painter.fill_rect(x + rx, y + ry, rw, rh, color)
+      end
+    end
+
+    def clickable?
+      !style(:click).nil?
+    end
+
+    def on_release(x, y, _button)
+      notify("click") if contains?(x, y) && style(:click)
+    end
+  end
+end

data/lib/clogs/drawables/misc.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../drawable"
+require_relative "slot"
+
+module Clogs
+  # `animate`, `every`, `timer`, `motion`, `click`, `hover`, `keypress`: Shoes
+  # calls that subscribe to something rather than drawing anything.
+  class SubscriptionItem < Drawable
+    def initialize(properties)
+      super
+      @frame = 0
+      start_timer
+    end
+
+    def api_name
+      style(:shoes_api_name).to_s
+    end
+
+    def args
+      Array(style(:args))
+    end
+
+    def measure(_available_width)
+      @width = 0
+      @height = 0
+    end
+
+    def clickable?
+      false
+    end
+
+    def start_timer
+      case api_name
+      when "animate"
+        fps = (args[0] || 10).to_i
+        fps = 10 if fps <= 0
+        schedule(1000 / fps) { notify("animate", @frame += 1) }
+      when "every"
+        seconds = (args[0] || 1).to_f
+        schedule((seconds * 1000).round) { notify("every", @frame += 1) }
+      when "timer"
+        seconds = (args[0] || 1).to_f
+        schedule((seconds * 1000).round, repeat: false) { notify("timer") }
+      end
+    end
+
+    # The app may not exist yet when the subscription is created, so defer.
+    def schedule(interval, repeat: true, &block)
+      @pending_timer = [interval, repeat, block]
+      install_timer
+    end
+
+    def install_timer
+      return unless @pending_timer
+      return unless app
+
+      interval, repeat, block = @pending_timer
+      @pending_timer = nil
+      @stopped = false
+      app.add_timer(interval, repeat: repeat) do
+        block.call unless @stopped
+      end
+    end
+
+    def set_parent(new_parent)
+      super
+      @app = nil
+      install_timer
+    end
+
+    def destroy_self
+      @stopped = true
+      super
+    end
+  end
+
+  # A user-defined Shoes::Widget subclass. It behaves as a slot.
+  class Widget < Slot; end
+
+  # Shoes' `mask` composites its contents as an alpha mask over the slot
+  # beneath it. libui has no group/alpha-compositing support, so the contents
+  # are drawn normally; see the coverage matrix.
+  class Mask < Slot; end
+
+  class Video < Drawable
+    def measure(available_width)
+      @width = requested_width(available_width) || 320
+      @height = requested_height(available_width) || 240
+    end
+
+    # libui has no media support at all, so this is an honest placeholder
+    # rather than a silent no-op.
+    def draw(painter, x, y)
+      painter.fill_rect(x, y, @width, @height, [20, 20, 20, 255])
+      painter.draw(fill: [200, 200, 200, 255]) do |p|
+        cx = x + @width / 2.0
+        cy = y + @height / 2.0
+        p.move_to(cx - 12, cy - 16).line_to(cx + 16, cy).line_to(cx - 12, cy + 16).close
+      end
+    end
+  end
+
+  class Arrow < ArtDrawable
+    def measure(available_width)
+      @width = Style.dimension(style(:width), available_width).to_i
+      @height = (@width / 2.0).round
+    end
+
+    def draw(painter, x, y)
+      w = @width
+      h = @height
+      painter.draw(fill: fill_paint, stroke: stroke_paint, thickness: strokewidth) do |p|
+        p.move_to(x, y + h * 0.35)
+          .line_to(x + w * 0.6, y + h * 0.35)
+          .line_to(x + w * 0.6, y)
+          .line_to(x + w, y + h * 0.5)
+          .line_to(x + w * 0.6, y + h)
+          .line_to(x + w * 0.6, y + h * 0.65)
+          .line_to(x, y + h * 0.65)
+          .close
+      end
+    end
+  end
+end

data/lib/clogs/drawables/shapes.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require_relative "../drawable"
+
+module Clogs
+  # A rounded rectangle, built from four quarter-circle arcs.
+  def self.rounded_rect(path, x, y, w, h, r)
+    r = [r, w / 2.0, h / 2.0].min
+    hp = Math::PI / 2
+    path.arc_figure(x + r, y + r, r, Math::PI, hp)
+    path.arc_to(x + w - r, y + r, r, -hp, hp)
+    path.arc_to(x + w - r, y + h - r, r, 0, hp)
+    path.arc_to(x + r, y + h - r, r, hp, hp)
+    path.close
+  end
+
+  # Shoes' art drawables. In Shoes these always carry their own left/top and so
+  # are positioned within the current slot rather than flowed.
+  class ArtDrawable < Drawable
+    def positioned?
+      true
+    end
+
+    def left
+      Style.dimension(style(:left), parent_content_width).to_i
+    end
+
+    def top
+      Style.dimension(style(:top), parent_content_width).to_i
+    end
+
+    def parent_content_width
+      @parent.respond_to?(:instance_variable_get) ? (@parent&.instance_variable_get(:@content_width) || 0) : 0
+    end
+
+    # Shoes' `fill`, `stroke`, `strokewidth` and `rotate` are *draw context*
+    # styles: set once on a slot, inherited by every art drawable made inside
+    # it. Lacci copies them onto drawables that declare them as their own
+    # styles, but drawables like Line and Shape do not, so the draw context has
+    # to be consulted directly.
+    def draw_context
+      @styles["draw_context"] || {}
+    end
+
+    def context_style(name)
+      value = style(name)
+      value.nil? ? draw_context[name.to_s] : value
+    end
+
+    # `nofill` and `nostroke` arrive as fully transparent colours rather than
+    # as nil, so treat zero alpha as "do not paint this".
+    def fill_paint
+      opaque(Style.color(context_style(:fill), nil))
+    end
+
+    def stroke_paint
+      opaque(Style.color(context_style(:stroke), nil))
+    end
+
+    def opaque(color)
+      color && color[3].to_i.positive? ? color : nil
+    end
+
+    def strokewidth
+      (context_style(:strokewidth) || 1).to_i
+    end
+
+    def rotation
+      context_style(:rotate).to_f
+    end
+
+    # Art drawables paint relative to the slot, honouring any rotation from the
+    # draw context.
+    def paint(painter, ox, oy)
+      @abs_x = ox + @x
+      @abs_y = oy + @y
+      if rotation.zero?
+        draw(painter, @abs_x, @abs_y)
+      else
+        painter.save do |p|
+          p.rotate(rotation, @abs_x + @width / 2.0, @abs_y + @height / 2.0)
+          draw(p, @abs_x, @abs_y)
+        end
+      end
+    end
+  end
+
+  class Rect < ArtDrawable
+    def measure(available_width)
+      @width = Style.dimension(style(:width), available_width).to_i
+      @height = Style.dimension(style(:height), available_width).to_i
+    end
+
+    def draw(painter, x, y)
+      curve = style(:curve).to_i
+      if curve.positive?
+        painter.draw(fill: fill_paint, stroke: stroke_paint, thickness: strokewidth) do |p|
+          Clogs.rounded_rect(p, x, y, @width, @height, curve)
+        end
+      else
+        painter.fill_rect(x, y, @width, @height, fill_paint) if fill_paint
+        painter.stroke_rect(x, y, @width, @height, stroke_paint, thickness: strokewidth) if stroke_paint
+      end
+    end
+
+  end
+
+  class Oval < ArtDrawable
+    def measure(available_width)
+      radius = style(:radius)
+      if radius && !style(:width)
+        @width = @height = radius.to_i * 2
+      else
+        @width = Style.dimension(style(:width), available_width).to_i
+        @height = Style.dimension(style(:height), available_width).to_i
+      end
+    end
+
+    def draw(painter, x, y)
+      # Shoes' `center: true` means left/top name the centre, not the corner.
+      if style(:center)
+        x -= @width / 2.0
+        y -= @height / 2.0
+      end
+      painter.fill_oval(x, y, @width, @height, fill_paint) if fill_paint
+      painter.stroke_oval(x, y, @width, @height, stroke_paint, thickness: strokewidth) if stroke_paint
+    end
+  end
+
+  class Line < ArtDrawable
+    def measure(available_width)
+      @x2 = Style.dimension(style(:x2), available_width).to_i
+      @y2 = Style.dimension(style(:y2), available_width).to_i
+      @width = (@x2 - left).abs
+      @height = (@y2 - top).abs
+    end
+
+    # A line's endpoints are both slot coordinates, so it cannot use the usual
+    # "draw at my top-left" convention.
+    def paint(painter, ox, oy)
+      @abs_x = ox + [left, @x2].min
+      @abs_y = oy + [top, @y2].min
+      painter.line(ox + left, oy + top, ox + @x2, oy + @y2,
+        stroke_paint || [0, 0, 0, 255], thickness: strokewidth)
+    end
+  end
+
+  class Star < ArtDrawable
+    def points
+      (style(:points) || 10).to_i
+    end
+
+    def outer
+      (style(:outer) || 100).to_f
+    end
+
+    def inner
+      (style(:inner) || 50).to_f
+    end
+
+    def measure(_available_width)
+      @width = @height = (outer * 2).round
+    end
+
+    def draw(painter, x, y)
+      cx = x + outer
+      cy = y + outer
+      painter.draw(fill: fill_paint, stroke: stroke_paint, thickness: strokewidth) do |p|
+        (0...(points * 2)).each do |i|
+          r = i.even? ? outer : inner
+          angle = -Math::PI / 2 + i * Math::PI / points
+          px = cx + r * Math.cos(angle)
+          py = cy + r * Math.sin(angle)
+          i.zero? ? p.move_to(px, py) : p.line_to(px, py)
+        end
+        p.close
+      end
+    end
+  end
+
+  class Arc < ArtDrawable
+    def measure(available_width)
+      @width = Style.dimension(style(:width), available_width).to_i
+      @height = Style.dimension(style(:height), available_width).to_i
+    end
+
+    def draw(painter, x, y)
+      a1 = style(:angle1).to_f
+      a2 = style(:angle2).to_f
+      sweep = a2 - a1
+      radius = [@width, @height].min / 2.0
+      cx = x + @width / 2.0
+      cy = y + @height / 2.0
+      painter.draw(fill: fill_paint, stroke: stroke_paint, thickness: strokewidth) do |p|
+        p.move_to(cx, cy) if style(:wedge)
+        p.arc_figure(cx, cy, radius, a1, sweep) unless style(:wedge)
+        p.arc_to(cx, cy, radius, a1, sweep) if style(:wedge)
+        p.close if style(:wedge)
+      end
+    end
+  end
+
+  # `shape { move_to ...; line_to ... }` -- Shoes records the commands and the
+  # display service replays them.
+  class Shape < ArtDrawable
+    def measure(_available_width)
+      xs = []
+      ys = []
+      Array(style(:shape_commands)).each do |cmd|
+        _name, *args = cmd
+        args.each_slice(2) { |px, py| xs << px.to_f; ys << py.to_f if py }
+      end
+      @width = xs.empty? ? 0 : xs.max.ceil
+      @height = ys.empty? ? 0 : ys.max.ceil
+    end
+
+    def draw(painter, x, y)
+      painter.draw(fill: fill_paint, stroke: stroke_paint, thickness: strokewidth) do |p|
+        started = false
+        Array(style(:shape_commands)).each do |cmd|
+          name, *args = cmd
+          case name.to_s
+          when "move_to"
+            p.move_to(x + args[0], y + args[1])
+            started = true
+          when "line_to"
+            p.move_to(x + args[0], y + args[1]) unless started
+            started = true
+            p.line_to(x + args[0], y + args[1])
+          when "curve_to"
+            p.curve_to(x + args[2], y + args[3], x + args[4], y + args[5], x + args[0], y + args[1])
+          when "arc_to"
+            p.arc_to(x + args[0], y + args[1], args[2], args[4].to_f, args[5].to_f - args[4].to_f)
+          end
+        end
+      end
+    end
+  end
+
+  # Background and Border cover the slot that contains them rather than
+  # occupying a place in its layout.
+  class SlotDecoration < Drawable
+    def measure_for_slot(width, height)
+      @width = width
+      @height = height
+    end
+
+    def measure(_available_width); end
+  end
+
+  class Background < SlotDecoration
+    def paint_for_slot(painter, x, y, w, h)
+      @abs_x = x
+      @abs_y = y
+      @width = w
+      @height = h
+      paint = background_paint(x, y, w, h)
+      return unless paint
+
+      curve = style(:curve).to_i
+      if curve.positive?
+        painter.draw(fill: paint) { |p| Clogs.rounded_rect(p, x, y, w, h, curve) }
+      else
+        painter.fill_rect(x, y, w, h, paint)
+      end
+    end
+
+    # Shoes lets a background be a colour, or a gradient written as
+    # `background red..blue`.
+    def background_paint(x, y, w, h)
+      fill = style(:fill) || style(:color)
+      if fill.is_a?(Range) || (fill.is_a?(Array) && fill.length == 2 && fill.first.is_a?(Array))
+        from, to = fill.is_a?(Range) ? [fill.first, fill.last] : fill
+        UI.gradient_brush(UI::BRUSH_LINEAR_GRADIENT, [x, y], [x, y + h],
+          [[0.0, Style.color(from)], [1.0, Style.color(to)]])
+      else
+        _ = w
+        Style.color(fill, nil)
+      end
+    end
+  end
+
+  class Border < SlotDecoration
+    def paint_for_slot(painter, x, y, w, h)
+      @abs_x = x
+      @abs_y = y
+      @width = w
+      @height = h
+      color = Style.color(style(:stroke), [0, 0, 0, 255])
+      thickness = (style(:strokewidth) || 1).to_i
+      inset = thickness / 2.0
+      curve = style(:curve).to_i
+      if curve.positive?
+        painter.draw(stroke: color, thickness: thickness) do |p|
+          Clogs.rounded_rect(p, x + inset, y + inset, w - thickness, h - thickness, curve)
+        end
+      else
+        painter.stroke_rect(x + inset, y + inset, w - thickness, h - thickness, color, thickness: thickness)
+      end
+    end
+  end
+end