clogs 0.1.0

data/lib/clogs/drawables/slot.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "../drawable"
+
+module Clogs
+  # A slot: the container drawable that does Shoes' layout.
+  #
+  # Shoes has exactly two layout modes and they are both simple:
+  #
+  #   stack - children are placed one below another, each as wide as the slot
+  #   flow  - children are placed left to right and wrap when they run out of
+  #           room, like words in a paragraph
+  #
+  # Anything with an explicit `left` and `top` is lifted out of that flow and
+  # placed at those coordinates relative to the slot, which is how Shoes
+  # programs do absolute positioning.
+  class Slot < Drawable
+    def flow?
+      false
+    end
+
+    def padding
+      @padding ||= Style.paddings(@styles)
+    end
+
+    # Backgrounds and borders are children in the Shoes tree but they are not
+    # laid out: they cover the whole slot.
+    def decorations
+      @children.select { |c| c.is_a?(Background) || c.is_a?(Border) }
+    end
+
+    def laid_out_children
+      @children.reject { |c| c.is_a?(Background) || c.is_a?(Border) || c.hidden? }
+    end
+
+    def measure(available_width)
+      ml, _mt, mr, _mb = margin
+      pl, pt, pr, pb = padding
+
+      outer_width = requested_width(available_width) || (available_width - ml - mr)
+      outer_width = 0 if outer_width.negative?
+      content_width = [outer_width - pl - pr, 0].max
+
+      flowed, positioned = laid_out_children.partition { |c| !c.positioned? }
+      content_height = flow? ? layout_flow(flowed, content_width) : layout_stack(flowed, content_width)
+
+      positioned.each do |child|
+        child.measure(content_width)
+        child.x = pl + Style.dimension(child.style(:left), content_width).to_i
+        child.y = pt + Style.dimension(child.style(:top), outer_width).to_i
+      end
+
+      @content_width = content_width
+      @width = outer_width
+      @height = requested_height(available_width) || (content_height + pt + pb)
+      decorations.each { |d| d.measure_for_slot(@width, @height) }
+    end
+
+    def layout_stack(kids, content_width)
+      _pl, pt, = padding
+      pl = padding[0]
+      y = pt
+      kids.each do |child|
+        cml, cmt, _cmr, cmb = child.margin
+        child.measure(content_width)
+        child.x = pl + cml
+        child.y = y + cmt
+        y += cmt + child.height + cmb
+      end
+      y - pt
+    end
+
+    def layout_flow(kids, content_width)
+      pl, pt, = padding
+      x = 0
+      y = 0
+      line_height = 0
+      kids.each do |child|
+        cml, cmt, cmr, cmb = child.margin
+        child.measure(content_width)
+        advance = cml + child.width + cmr
+        if x.positive? && x + advance > content_width
+          y += line_height
+          x = 0
+          line_height = 0
+        end
+        child.x = pl + x + cml
+        child.y = pt + y + cmt
+        x += advance
+        line_height = [line_height, cmt + child.height + cmb].max
+      end
+      y + line_height
+    end
+
+    def paint(painter, ox, oy)
+      @abs_x = ox + @x
+      @abs_y = oy + @y
+
+      decorations.grep(Background).each { |d| d.paint_for_slot(painter, @abs_x, @abs_y, @width, @height) }
+      @children.each do |child|
+        next if child.hidden? || child.is_a?(Background) || child.is_a?(Border)
+
+        child.paint(painter, @abs_x, @abs_y)
+      end
+      decorations.grep(Border).each { |d| d.paint_for_slot(painter, @abs_x, @abs_y, @width, @height) }
+    end
+  end
+
+  class Stack < Slot; end
+
+  class Flow < Slot
+    def flow?
+      true
+    end
+  end
+
+  # The invisible slot that holds an app's whole document. Shoes' top level
+  # behaves like a flow.
+  class DocumentRoot < Flow
+    def app=(app)
+      @app = app
+    end
+
+    def app
+      @app
+    end
+  end
+end

data/lib/clogs/drawables/text.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative "../drawable"
+require_relative "../paragraph"
+
+module Clogs
+  # The display side of Shoes' inline text drawables: strong, em, code, link,
+  # span and friends. These have no geometry of their own -- they contribute
+  # styled runs to whichever paragraph contains them.
+  class TextDrawable < Drawable
+    def emphasis_style(base)
+      style_for_tag(base)
+    end
+
+    # Overridden per tag.
+    def style_for_tag(base)
+      base
+    end
+
+    def own_style(base)
+      s = style_for_tag(base)
+      s = s.with(size: resolved_size(s.size)) if style(:size)
+      s = s.with(color: Style.color(style(:stroke), s.color)) if style(:stroke)
+      s = s.with(bg: Style.color(style(:fill), s.bg)) if style(:fill)
+      s = s.with(family: style(:family)) if style(:family)
+      s = s.with(underline: true) if truthy_underline?
+      s = s.with(italic: true) if style(:emphasis).to_s == "italic"
+      s.with(owner: self)
+    end
+
+    def truthy_underline?
+      u = style(:underline)
+      !u.nil? && u != "" && u != "none" && u != false
+    end
+
+    def resolved_size(default)
+      Paragraph::SIZES[style(:size).to_s.to_sym] || (style(:size).is_a?(Numeric) ? style(:size) : default)
+    end
+
+    # Contribute [text, style] pairs to the enclosing paragraph.
+    def runs(base_style)
+      mine = own_style(base_style)
+      Clogs.expand_text_items(style(:text_items), mine)
+    end
+  end
+
+  class Strong < TextDrawable
+    def style_for_tag(base) = base.with(bold: true)
+  end
+
+  class Em < TextDrawable
+    def style_for_tag(base) = base.with(italic: true)
+  end
+
+  class Code < TextDrawable
+    def style_for_tag(base) = base.with(family: Clogs.monospace_font_family)
+  end
+
+  class Ins < TextDrawable
+    def style_for_tag(base) = base.with(underline: true)
+  end
+
+  class Del < TextDrawable
+    # libui's attributed strings have no strikethrough attribute exposed by the
+    # Ruby binding, so del() renders as plain text. Documented in the coverage
+    # matrix rather than silently pretending.
+    def style_for_tag(base) = base
+  end
+
+  class Sub < TextDrawable
+    def style_for_tag(base) = base.with(size: (base.size * 0.7).round)
+  end
+
+  class Sup < TextDrawable
+    def style_for_tag(base) = base.with(size: (base.size * 0.7).round)
+  end
+
+  class Span < TextDrawable; end
+
+  class Bg < TextDrawable
+    def style_for_tag(base) = base.with(bg: Style.color(style(:fill), base.bg))
+  end
+
+  class Fg < TextDrawable
+    def style_for_tag(base) = base.with(color: Style.color(style(:stroke), base.color))
+  end
+
+  # A clickable run of text. Clicks are routed by the containing paragraph,
+  # which knows where the link's words ended up on screen.
+  class Link < TextDrawable
+    DEFAULT_COLOR = [0, 0, 238, 255].freeze
+
+    def style_for_tag(base)
+      base.with(color: DEFAULT_COLOR, underline: true)
+    end
+
+    def clickable?
+      true
+    end
+
+    def click!(x, y)
+      notify("click", 1, x, y)
+    end
+  end
+
+  # A paragraph: the only text drawable with real geometry.
+  class Para < Drawable
+    def default_size
+      Paragraph::SIZES[:para]
+    end
+
+    def base_style
+      size = style(:size)
+      resolved = Paragraph::SIZES[size.to_s.to_sym] || (size.is_a?(Numeric) ? size.to_i : default_size)
+      Paragraph::TextStyle.new(
+        family: style(:family) || Clogs.default_font_family,
+        size: resolved,
+        bold: style(:font_weight).to_s == "bold",
+        italic: %w[italic oblique].include?(style(:emphasis).to_s),
+        underline: false,
+        color: Style.color(style(:stroke), [0, 0, 0, 255]),
+        bg: Style.color(style(:fill), nil),
+        owner: self
+      )
+    end
+
+    def align
+      case style(:align).to_s
+      when "center" then :center
+      when "right" then :right
+      else :left
+      end
+    end
+
+    def measure(available_width)
+      ml, _mt, mr, = margin
+      avail = requested_width(available_width) || (available_width - ml - mr)
+      @paragraph = Paragraph.new(Clogs.expand_text_items(style(:text_items), base_style), avail, align: align)
+      @width = requested_width(available_width) || [@paragraph.width.ceil, avail].min
+      @height = requested_height(available_width) || @paragraph.height.ceil
+    end
+
+    def draw(painter, x, y)
+      return unless @paragraph
+
+      @paragraph.draw(painter, x, y)
+      draw_text_cursor(painter, x, y)
+    end
+
+    # Shoes' `para.cursor = n` puts a caret at character n. libui's text layouts
+    # do not expose caret geometry, but Clogs lays out word by word, so the
+    # position is a lookup plus one substring measurement.
+    def draw_text_cursor(painter, x, y)
+      position = style(:text_cursor)
+      return if position.nil? || ENV["CLOGS_NO_CARET"]
+
+      item = @paragraph.placed.find do |placed|
+        position >= placed.char_offset && position <= placed.char_offset + placed.text.length
+      end
+      item ||= @paragraph.placed.last
+      return unless item
+
+      prefix = item.text[0...(position - item.char_offset)].to_s
+      cx = x + item.x + Paragraph.measure(prefix, item.style)[0]
+      cy = y + item.y
+      painter.line(cx, cy, cx, cy + item.height, [0, 0, 0, 255], thickness: 1)
+    end
+
+    def clickable?
+      true
+    end
+
+    # Find the link (if any) under this point and fire it.
+    def on_click(x, y, button)
+      return unless @paragraph
+
+      lx = x - @abs_x
+      ly = y - @abs_y
+      link = link_at(lx, ly)
+      link&.click!(x, y)
+      _ = button
+    end
+
+    def link_at(lx, ly)
+      owners = @paragraph.placed.map(&:owner).uniq.select { |o| o.is_a?(Link) }
+      owners.find do |owner|
+        @paragraph.boxes_for(owner).any? do |bx, by, bw, bh|
+          lx >= bx && lx < bx + bw && ly >= by && ly < by + bh
+        end
+      end
+    end
+
+    def cursor_index_at(x, y)
+      @paragraph&.index_at(x - @abs_x, y - @abs_y) || 0
+    end
+  end
+
+  class << Clogs
+    # text_items is an array of Strings and linkable IDs of TextDrawables.
+    # Resolve it into a flat list of [text, style] pairs.
+    def expand_text_items(items, style)
+      return [] if items.nil?
+
+      # An item is either literal text or the linkable id of a nested text
+      # drawable such as strong() or link(). Ids are not always Strings, so
+      # ask the display service about anything that could be one.
+      Array(items).flat_map do |item|
+        peer = DisplayService.instance&.query_display_drawable_for(item, nil_ok: true)
+        if peer.is_a?(TextDrawable)
+          peer.runs(style)
+        else
+          [[item.to_s, style]]
+        end
+      end
+    end
+  end
+end

data/lib/clogs/lacci_compat.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Small pieces of the Shoes API that Lacci 0.5.0 does not implement but that
+# real Shoes programs use constantly. Each is defined only if the installed
+# Lacci lacks it, so newer versions win.
+
+class Shoes::App
+  # `app.clear { ... }` empties the top-level slot and optionally refills it.
+  # Animated Shoes programs redraw themselves this way on every frame.
+  unless method_defined?(:clear)
+    def clear(&block)
+      root = instance_variable_get(:@document_root)
+      root&.clear(&block)
+    end
+  end
+
+  # `self.mouse` returns [button, x, y]. Clogs tracks the pointer as libui
+  # reports it.
+  unless method_defined?(:mouse)
+    def mouse
+      Clogs::App.instance&.mouse_state || [0, 0, 0]
+    end
+  end
+
+  # Shoes 3's `visit` opened a URL; without a browser widget the best we can do
+  # is hand it to the desktop.
+  unless method_defined?(:visit)
+    def visit(url)
+      opener = case RUBY_PLATFORM
+      when /darwin/ then "open"
+      when /mingw|mswin/ then "start"
+      else "xdg-open"
+      end
+      system(opener, url.to_s, out: File::NULL, err: File::NULL)
+    end
+  end
+
+  # Shoes 3 read and wrote the system clipboard through the app.
+  unless method_defined?(:clipboard)
+    def clipboard
+      Clogs::Clipboard.read
+    end
+
+    def clipboard=(text)
+      Clogs::Clipboard.write(text.to_s)
+    end
+  end
+end

data/lib/clogs/log.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Clogs
+  # Lacci insists on a logging implementation being plugged in before any Shoes
+  # object exists. Scarpe ships two (one backed by the `logging` gem, one
+  # simple); Clogs has its own so that a packaged app needs no logging
+  # dependency at all.
+  #
+  # Configure with SCARPE_LOG_LEVEL (debug/info/warn/error/fatal) or
+  # SCARPE_DEBUG=1.
+  class Log
+    LEVELS = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }.freeze
+
+    def initialize(out = $stderr)
+      @out = out
+      @level = :warn
+    end
+
+    def configure_logger(config)
+      level = if ENV["SCARPE_LOG_LEVEL"]
+        ENV["SCARPE_LOG_LEVEL"].downcase.to_sym
+      elsif config.is_a?(Hash)
+        (config["default"] || config[:default] || "warn").to_s.to_sym
+      else
+        :warn
+      end
+      @level = LEVELS.key?(level) ? level : :warn
+    end
+
+    def logger_for_component(component)
+      Logger.new(self, component.to_s)
+    end
+
+    def emit(component, level, message)
+      return if LEVELS[level] < LEVELS[@level]
+
+      @out.puts("[#{level.to_s.upcase}] #{component}: #{message}")
+    end
+
+    # One of these per component, matching the interface Lacci expects.
+    class Logger
+      def initialize(sink, component)
+        @sink = sink
+        @component = component
+      end
+
+      LEVELS.each_key do |level|
+        define_method(level) do |message = nil, &block|
+          @sink.emit(@component, level, message || block&.call)
+        end
+      end
+    end
+  end
+end

data/lib/clogs/painter.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative "ui"
+
+module Clogs
+  # A path under construction. libui aborts the process if a path is ended
+  # twice or drawn before being ended, so the state is tracked here rather
+  # than left to callers.
+  class Path
+    attr_reader :ptr
+
+    def initialize(fill_mode)
+      @ptr = UI::L.draw_new_path(fill_mode)
+      @ended = false
+    end
+
+    def move_to(x, y)
+      UI::L.draw_path_new_figure(@ptr, x, y)
+      self
+    end
+
+    def line_to(x, y)
+      UI::L.draw_path_line_to(@ptr, x, y)
+      self
+    end
+
+    def curve_to(c1x, c1y, c2x, c2y, x, y)
+      UI::L.draw_path_bezier_to(@ptr, c1x, c1y, c2x, c2y, x, y)
+      self
+    end
+
+    def arc_to(cx, cy, radius, start_angle, sweep, negative = false)
+      UI::L.draw_path_arc_to(@ptr, cx, cy, radius, start_angle, sweep, negative ? 1 : 0)
+      self
+    end
+
+    def arc_figure(cx, cy, radius, start_angle, sweep, negative = false)
+      UI::L.draw_path_new_figure_with_arc(@ptr, cx, cy, radius, start_angle, sweep, negative ? 1 : 0)
+      self
+    end
+
+    def rect(x, y, w, h)
+      UI::L.draw_path_add_rectangle(@ptr, x, y, w, h)
+      self
+    end
+
+    # Four beziers approximate an ellipse closely enough for UI work and avoid
+    # needing a scale matrix per oval (libui arcs are always circular).
+    K = 0.5522847498307936
+    def oval(x, y, w, h)
+      rx = w / 2.0
+      ry = h / 2.0
+      cx = x + rx
+      cy = y + ry
+      move_to(cx + rx, cy)
+      curve_to(cx + rx, cy + ry * K, cx + rx * K, cy + ry, cx, cy + ry)
+      curve_to(cx - rx * K, cy + ry, cx - rx, cy + ry * K, cx - rx, cy)
+      curve_to(cx - rx, cy - ry * K, cx - rx * K, cy - ry, cx, cy - ry)
+      curve_to(cx + rx * K, cy - ry, cx + rx, cy - ry * K, cx + rx, cy)
+      close
+    end
+
+    def close
+      UI::L.draw_path_close_figure(@ptr)
+      self
+    end
+
+    def end!
+      return self if @ended
+
+      @ended = true
+      UI::L.draw_path_end(@ptr)
+      self
+    end
+
+    def free
+      UI::L.draw_free_path(@ptr) if @ptr
+      @ptr = nil
+    end
+  end
+
+  # An immediate-mode drawing surface over a uiDrawContext.
+  #
+  # Shoes is a canvas library: everything from a `rect` to a `button` is
+  # ultimately painted. libui's draw API is closely modelled on Cairo (paths,
+  # brushes, matrices, clipping, save/restore), so the mapping is direct.
+  class Painter
+    WINDING = UI::WINDING
+    ALTERNATE = UI::ALTERNATE
+
+    attr_reader :context, :width, :height
+
+    def initialize(context, width, height)
+      @context = context
+      @width = width
+      @height = height
+    end
+
+    # libui has no "unclip" and no way to read back the current transform, so
+    # every clip or transform must be scoped by save/restore.
+    def save
+      UI::L.draw_save(@context)
+      yield self
+    ensure
+      UI::L.draw_restore(@context)
+    end
+
+    def translate(x, y)
+      return if x.zero? && y.zero?
+
+      apply_matrix { |m| UI::L.draw_matrix_translate(m, x, y) }
+    end
+
+    def rotate(degrees, cx = 0, cy = 0)
+      apply_matrix { |m| UI::L.draw_matrix_rotate(m, cx, cy, degrees * Math::PI / 180.0) }
+    end
+
+    def scale(sx, sy, cx = 0, cy = 0)
+      apply_matrix { |m| UI::L.draw_matrix_scale(m, cx, cy, sx, sy) }
+    end
+
+    def skew(ax, ay, cx = 0, cy = 0)
+      apply_matrix { |m| UI::L.draw_matrix_skew(m, cx, cy, ax * Math::PI / 180.0, ay * Math::PI / 180.0) }
+    end
+
+    def clip_rect(x, y, w, h)
+      p = Path.new(WINDING)
+      p.rect(x, y, w, h).end!
+      UI::L.draw_clip(@context, p.ptr)
+    ensure
+      p&.free
+    end
+
+    def fill_rect(x, y, w, h, paint)
+      return if w <= 0 || h <= 0
+
+      draw(fill: paint) { |p| p.rect(x, y, w, h) }
+    end
+
+    def stroke_rect(x, y, w, h, paint, thickness: 1)
+      draw(stroke: paint, thickness: thickness) { |p| p.rect(x, y, w, h) }
+    end
+
+    def fill_oval(x, y, w, h, paint)
+      draw(fill: paint) { |p| p.oval(x, y, w, h) }
+    end
+
+    def stroke_oval(x, y, w, h, paint, thickness: 1)
+      draw(stroke: paint, thickness: thickness) { |p| p.oval(x, y, w, h) }
+    end
+
+    def line(x1, y1, x2, y2, paint, thickness: 1, cap: UI::CAP_FLAT)
+      draw(stroke: paint, thickness: thickness, cap: cap) do |p|
+        p.move_to(x1, y1).line_to(x2, y2)
+      end
+    end
+
+    # The workhorse: build a path in the block, then fill and/or stroke it.
+    def draw(fill: nil, stroke: nil, thickness: 1, cap: UI::CAP_FLAT, join: UI::JOIN_MITER,
+      dashes: nil, fill_mode: WINDING)
+      p = Path.new(fill_mode)
+      yield p
+      p.end!
+      UI::L.draw_fill(@context, p.ptr, brush_for(fill).to_ptr) if fill
+      if stroke
+        sp = UI.stroke_params(thickness, cap: cap, join: join, dashes: dashes)
+        UI::L.draw_stroke(@context, p.ptr, brush_for(stroke).to_ptr, sp.to_ptr)
+      end
+    ensure
+      p&.free
+    end
+
+    def draw_text(layout, x, y)
+      UI::L.draw_text(@context, layout, x, y)
+    end
+
+    private
+
+    def brush_for(paint)
+      return paint if paint.respond_to?(:Type)
+
+      UI.solid_brush(paint)
+    end
+
+    def apply_matrix
+      m = UI.malloc(UI::L::FFI::DrawMatrix)
+      UI::L.draw_matrix_set_identity(m)
+      yield m
+      UI::L.draw_transform(@context, m)
+    end
+  end
+end