clogs 0.1.0

data/lib/clogs/clipboard.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Clogs
+  # libui has no clipboard API at all, so Clogs shells out to whatever the
+  # platform provides. If nothing is available, copy and paste quietly do
+  # nothing rather than raising in the middle of someone's keystroke.
+  module Clipboard
+    module_function
+
+    def read
+      cmd = read_command
+      return @fallback.to_s unless cmd
+
+      out = `#{cmd} 2>/dev/null`
+      $?.success? ? out : @fallback.to_s
+    rescue StandardError
+      @fallback.to_s
+    end
+
+    def write(text)
+      @fallback = text
+      cmd = write_command
+      return unless cmd
+
+      IO.popen(cmd, "w") { |io| io.write(text) }
+    rescue StandardError
+      nil
+    end
+
+    def read_command
+      @read_command ||= case RUBY_PLATFORM
+      when /darwin/ then "pbpaste"
+      when /mingw|mswin/ then "powershell -command Get-Clipboard"
+      else
+        if system("which xclip > /dev/null 2>&1")
+          "xclip -selection clipboard -o"
+        elsif system("which xsel > /dev/null 2>&1")
+          "xsel --clipboard --output"
+        end
+      end
+    end
+
+    def write_command
+      @write_command ||= case RUBY_PLATFORM
+      when /darwin/ then "pbcopy"
+      when /mingw|mswin/ then "clip"
+      else
+        if system("which xclip > /dev/null 2>&1")
+          "xclip -selection clipboard -i"
+        elsif system("which xsel > /dev/null 2>&1")
+          "xsel --clipboard --input"
+        end
+      end
+    end
+  end
+end

data/lib/clogs/dialogs.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "ui"
+
+module Clogs
+  # Shoes' modal helpers.
+  #
+  # libui gives us exactly two dialogs of its own -- a message box and a file
+  # picker -- and neither can ask a question. `ask` and `confirm` are therefore
+  # built as small real windows made of native libui controls, run on a nested
+  # `uiMainStep` loop so they block the caller the way Shoes expects.
+  module Dialogs
+    module_function
+
+    def alert(parent, message)
+      UI::L.msg_box(parent, "", message.to_s)
+      nil
+    end
+
+    def error(parent, message)
+      UI::L.msg_box_error(parent, "", message.to_s)
+      nil
+    end
+
+    def open_file(parent)
+      ptr = UI::L.open_file(parent)
+      pointer_to_string(ptr)
+    end
+
+    def save_file(parent)
+      ptr = UI::L.save_file(parent)
+      pointer_to_string(ptr)
+    end
+
+    def open_folder(parent)
+      return nil unless UI::L.respond_to?(:open_folder)
+
+      pointer_to_string(UI::L.open_folder(parent))
+    end
+
+    def pointer_to_string(ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      str = ptr.to_s
+      UI::L.free_text(ptr)
+      str.empty? ? nil : str
+    end
+
+    # A one-line text prompt. Returns the string, or nil if cancelled.
+    def ask(parent, message, secret: false)
+      result = nil
+      modal(parent, "", 320, 100) do |win, box, finish|
+        UI::L.box_append(box, label(message.to_s), 0)
+        entry = secret ? UI::L.new_password_entry : UI::L.new_entry
+        UI::L.box_append(box, entry, 0)
+
+        buttons = UI::L.new_horizontal_box
+        UI::L.box_set_padded(buttons, 1)
+        ok = UI::L.new_button("OK")
+        cancel = UI::L.new_button("Cancel")
+        UI::L.box_append(buttons, ok, 1)
+        UI::L.box_append(buttons, cancel, 1)
+        UI::L.box_append(box, buttons, 0)
+
+        UI::L.button_on_clicked(ok) do
+          result = UI::L.entry_text(entry).to_s
+          finish.call
+          0
+        end
+        UI::L.button_on_clicked(cancel) do
+          result = nil
+          finish.call
+          0
+        end
+        _ = win
+      end
+      result
+    end
+
+    # A yes/no question. Returns true or false.
+    def confirm(parent, question)
+      result = false
+      modal(parent, "", 320, 90) do |_win, box, finish|
+        UI::L.box_append(box, label(question.to_s), 0)
+        buttons = UI::L.new_horizontal_box
+        UI::L.box_set_padded(buttons, 1)
+        yes = UI::L.new_button("OK")
+        no = UI::L.new_button("Cancel")
+        UI::L.box_append(buttons, yes, 1)
+        UI::L.box_append(buttons, no, 1)
+        UI::L.box_append(box, buttons, 0)
+
+        UI::L.button_on_clicked(yes) do
+          result = true
+          finish.call
+          0
+        end
+        UI::L.button_on_clicked(no) do
+          result = false
+          finish.call
+          0
+        end
+      end
+      result
+    end
+
+    def label(text)
+      UI::L.new_label(text)
+    end
+
+    # Run a modal window on a nested event loop. libui does not allow uiMain to
+    # be re-entered, but stepping it by hand is fine and is how a blocking
+    # dialog has to work here.
+    def modal(parent, title, width, height)
+      win = UI::L.new_window(title, width, height, 0)
+      UI::L.window_set_margined(win, 1)
+      box = UI::L.new_vertical_box
+      UI::L.box_set_padded(box, 1)
+      UI::L.window_set_child(win, box)
+
+      done = false
+      finish = -> { done = true }
+      UI::L.window_on_closing(win) do
+        done = true
+        0
+      end
+
+      yield win, box, finish
+
+      UI::L.control_show(win)
+      UI::L.main_step(1) until done
+      UI::L.control_destroy(win)
+      _ = parent
+    end
+  end
+end

data/lib/clogs/display_service.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "drawable"
+require_relative "app"
+
+module Clogs
+  # Lacci's half of the bargain: it hands us a Shoes drawable class name and an
+  # id, and expects a display-side peer back. Everything after that happens
+  # through events on that id.
+  class DisplayService < Shoes::DisplayService
+    class << self
+      attr_accessor :instance
+    end
+
+    def initialize
+      raise Shoes::SingletonError, "Clogs::DisplayService is a singleton!" if DisplayService.instance
+
+      DisplayService.instance = self
+      super()
+    end
+
+    # Shoes class name (minus namespace) => Clogs peer class.
+    PEERS = {
+      "App" => "App",
+      "DocumentRoot" => "DocumentRoot",
+      "Stack" => "Stack",
+      "Flow" => "Flow",
+      "Shape" => "Shape",
+      "Mask" => "Mask",
+      "Para" => "Para",
+      "Link" => "Link",
+      "LinkHover" => "Link",
+      "Strong" => "Strong",
+      "Em" => "Em",
+      "Code" => "Code",
+      "Del" => "Del",
+      "Ins" => "Ins",
+      "Sub" => "Sub",
+      "Sup" => "Sup",
+      "Span" => "Span",
+      "Bg" => "Bg",
+      "Fg" => "Fg",
+      "Button" => "Button",
+      "Check" => "Check",
+      "Radio" => "Radio",
+      "Progress" => "Progress",
+      "EditLine" => "EditLine",
+      "EditBox" => "EditBox",
+      "ListBox" => "ListBox",
+      "Image" => "Image",
+      "Video" => "Video",
+      "Arrow" => "Arrow",
+      "Rect" => "Rect",
+      "Oval" => "Oval",
+      "Line" => "Line",
+      "Star" => "Star",
+      "Arc" => "Arc",
+      "Background" => "Background",
+      "Border" => "Border",
+      "SubscriptionItem" => "SubscriptionItem"
+    }.freeze
+
+    def create_display_drawable_for(drawable_class_name, drawable_id, properties, parent_id:, is_widget:)
+      existing = query_display_drawable_for(drawable_id, nil_ok: true)
+      return existing if existing
+
+      properties = properties.dup
+      properties["shoes_linkable_id"] ||= drawable_id
+
+      peer = build_peer(drawable_class_name, properties, is_widget)
+      set_drawable_pairing(drawable_id, peer)
+
+      if peer.is_a?(App)
+        @app = peer
+      else
+        parent = parent_id ? query_display_drawable_for(parent_id, nil_ok: true) : nil
+        peer.set_parent(parent)
+        @document_root = peer if peer.is_a?(DocumentRoot)
+      end
+
+      # Lacci builds the document root *before* the app, so neither one can
+      # simply look the other up on creation. Whichever arrives second links
+      # them: the root is the app's canvas contents but is not its child.
+      @app.document_root = @document_root if @app && @document_root && @app.document_root.nil?
+
+      peer
+    end
+
+    def build_peer(class_name, properties, is_widget)
+      short = class_name.to_s.split("::").last
+      return Widget.new(properties) if is_widget && !PEERS.key?(short)
+
+      peer_name = PEERS[short]
+      if peer_name
+        Clogs.const_get(peer_name).new(properties)
+      else
+        # A Shoes drawable Clogs does not know about still needs a peer so the
+        # tree stays consistent; it simply draws nothing.
+        warn "Clogs: no peer for #{class_name}, ignoring it visually."
+        Drawable.new(properties)
+      end
+    end
+
+    def destroy
+      @app&.destroy
+      DisplayService.instance = nil
+    end
+  end
+end

data/lib/clogs/drawable.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "style"
+
+module Clogs
+  # Base class for every Clogs peer: the display-side half of a Shoes drawable.
+  #
+  # Lacci owns the Shoes-side object and tells us about it through three events
+  # (`parent`, `prop_change`, `destroy`). We own pixels: where the thing sits,
+  # how big it is, and what it looks like.
+  #
+  # The layout contract is two passes:
+  #
+  #   measure(available_width) -> sets @width / @height
+  #   paint(painter, ox, oy)   -> draws, and records absolute geometry so that
+  #                               mouse hit-testing has something to test
+  class Drawable < Shoes::Linkable
+    attr_accessor :parent, :x, :y
+    attr_reader :children, :shoes_linkable_id, :styles, :abs_x, :abs_y, :width, :height
+
+    class << self
+      # Peer class lookup by Shoes class name, e.g. "Shoes::Button" -> Clogs::Button.
+      def for_shoes_class(name)
+        short = name.split("::").last
+        Clogs.const_get(short) if Clogs.const_defined?(short, false)
+      end
+    end
+
+    def initialize(properties)
+      @styles = {}
+      properties.each { |k, v| @styles[k.to_s] = v }
+      @shoes_linkable_id = @styles.delete("shoes_linkable_id")
+      @children = []
+      @x = @y = 0
+      @width = @height = 0
+
+      super(linkable_id: @shoes_linkable_id)
+
+      bind_shoes_event(event_name: "parent", target: @shoes_linkable_id) do |new_parent_id|
+        new_parent = DisplayService.instance.query_display_drawable_for(new_parent_id, nil_ok: true)
+        set_parent(new_parent) unless new_parent == @parent
+      end
+
+      bind_shoes_event(event_name: "prop_change", target: @shoes_linkable_id) do |changes|
+        changes.each { |k, v| @styles[k.to_s] = v }
+        properties_changed(changes)
+      end
+
+      bind_shoes_event(event_name: "destroy", target: @shoes_linkable_id) do
+        destroy_self
+      end
+    end
+
+    def properties_changed(_changes)
+      needs_layout!
+    end
+
+    def destroy_self
+      set_parent(nil)
+      needs_layout!
+    end
+
+    def set_parent(new_parent)
+      @parent&.remove_child(self)
+      new_parent&.add_child(self)
+      @parent = new_parent
+      needs_layout!
+    end
+
+    def add_child(child)
+      @children << child unless @children.include?(child)
+    end
+
+    def remove_child(child)
+      @children.delete(child)
+    end
+
+    # The owning Clogs::App, found by walking up the tree.
+    def app
+      @app ||= @parent&.app
+    end
+
+    def needs_layout!
+      app&.needs_layout!
+    end
+
+    def redraw!
+      app&.redraw!
+    end
+
+    # ---- styles -------------------------------------------------------
+
+    def style(name)
+      @styles[name.to_s]
+    end
+
+    def hidden?
+      !!style(:hidden)
+    end
+
+    # A drawable with an explicit left/top is taken out of the normal flow and
+    # placed at those coordinates within its slot, exactly as in Shoes.
+    def positioned?
+      !style(:left).nil? && !style(:top).nil?
+    end
+
+    def margin
+      @margin ||= Style.margins(@styles)
+    end
+
+    def requested_width(available)
+      Style.dimension(style(:width), available)
+    end
+
+    def requested_height(available)
+      Style.dimension(style(:height), available)
+    end
+
+    # ---- layout -------------------------------------------------------
+
+    # Subclasses override. Must set @width and @height.
+    def measure(available_width)
+      @width = requested_width(available_width) || 0
+      @height = requested_height(available_width) || 0
+    end
+
+    def paint(painter, ox, oy)
+      @abs_x = ox + @x
+      @abs_y = oy + @y
+      draw(painter, @abs_x, @abs_y)
+    end
+
+    def draw(_painter, _x, _y); end
+
+    # ---- events -------------------------------------------------------
+
+    def contains?(px, py)
+      return false if @abs_x.nil? || hidden?
+
+      px >= @abs_x && px < @abs_x + @width && py >= @abs_y && py < @abs_y + @height
+    end
+
+    # Overridden by controls that want the keyboard.
+    def focusable?
+      false
+    end
+
+    # In Shoes any drawable can carry a click handler, so every peer is a
+    # candidate; the topmost one under the pointer wins.
+    def clickable?
+      true
+    end
+
+    def on_click(_x, _y, _button); end
+
+    def on_release(x, y, button)
+      notify("click", button, x.round, y.round) if contains?(x, y)
+    end
+
+    def on_mouse_move(_x, _y); end
+
+    def on_key(_event)
+      false
+    end
+
+    def focus_gained; end
+
+    def focus_lost; end
+
+    def notify(event_name, *args)
+      send_shoes_event(*args, event_name: event_name, target: @shoes_linkable_id)
+    end
+
+    # Depth-first list of visible peers in paint order, for hit testing.
+    def each_peer(&block)
+      return if hidden?
+
+      block.call(self)
+      @children.each { |c| c.each_peer(&block) }
+    end
+  end
+end