tuile 0.1.0

data/lib/tuile/component/has_content.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A mixin interface for a component with one child tops. The host must
+    # provide a protected `layout(content)` method which repositions the
+    # content component; the mixin manages `@content` itself.
+    module HasContent
+      # @return [Component, nil] the current content component.
+      attr_reader :content
+
+      # @param key [String] a key.
+      # @return [Boolean] true if the key was handled, false if not.
+      def handle_key(key)
+        content.nil? || !content.active? ? false : content.handle_key(key)
+      end
+
+      # @param event [MouseEvent]
+      # @return [void]
+      def handle_mouse(event)
+        content.handle_mouse(event) if !content.nil? && content.rect.contains?(event.point)
+      end
+
+      # @return [Array<Component>]
+      def children = content.nil? ? [] : [content]
+
+      # Sets the new content of this component. Updates `@content` itself;
+      # including classes may still override to add behaviour (e.g. a
+      # special-cased Array input) but should call `super` to perform the
+      # swap.
+      # @param content [Component, nil] the component to set or clear.
+      # @return [void]
+      def content=(content)
+        unless content.nil? || content.is_a?(Component)
+          raise TypeError, "expected Component or nil, got #{content.inspect}"
+        end
+        return if self.content == content
+        if !content.nil? && !content.parent.nil?
+          raise ArgumentError, "#{content} already has a parent #{content.parent}"
+        end
+
+        old = self.content
+        old&.parent = nil
+        @content = content
+        unless content.nil?
+          content.parent = self
+          content.invalidate
+          layout(content)
+        end
+        on_child_removed(old) unless old.nil?
+      end
+
+      # @param rect [Rect]
+      # @return [void]
+      def rect=(rect)
+        super
+        layout(content) unless content.nil?
+      end
+
+      # @return [void]
+      def on_focus
+        super
+        # Let the content component receive focus, so that it can immediately
+        # start responding to key presses.
+        screen.focused = content if !content.nil? && content.focusable?
+      end
+    end
+  end
+end

data/lib/tuile/component/info_window.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A {Window} preconfigured with a {List} of static lines. Useful for
+    # showing read-only information.
+    #
+    # Usable tiled (just add to a {Layout}) or as a popup via {.open}, which
+    # wraps it in a {Popup}.
+    class InfoWindow < Window
+      # @param caption [String]
+      # @param lines [Array<String>] initial content; each entry may contain
+      #   Rainbow formatting.
+      def initialize(caption = "", lines = [])
+        super(caption)
+        list = Component::List.new
+        list.lines = lines
+        self.content = list
+      end
+
+      # Opens the info window as a popup.
+      # @param caption [String]
+      # @param lines [Array<String>] the content, may contain formatting.
+      # @return [Popup] the opened popup.
+      def self.open(caption, lines)
+        Popup.open(content: InfoWindow.new(caption, lines))
+      end
+    end
+  end
+end

data/lib/tuile/component/label.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A label which shows static text. No word-wrapping; clips long lines.
+    class Label < Component
+      def initialize
+        super
+        @lines = []
+        @clipped_lines = []
+      end
+
+      # @param text [String, nil] draws this text. May contain ANSI formatting.
+      #   Clipped automatically.
+      # @return [void]
+      def text=(text)
+        @lines = text.to_s.split("\n")
+        @content_size = nil
+        update_clipped_text
+      end
+
+      # @return [Size]
+      def content_size
+        @content_size ||= begin
+          width = @lines.map { |line| Unicode::DisplayWidth.of(Rainbow.uncolor(line)) }.max || 0
+          Size.new(width, @lines.size)
+        end
+      end
+
+      # @return [void]
+      def repaint
+        clear_background
+        height = rect.height.clamp(0, nil)
+        lines_to_print = @clipped_lines.length.clamp(nil, height)
+        (0..lines_to_print - 1).each do |index|
+          screen.print TTY::Cursor.move_to(rect.left, rect.top + index), @clipped_lines[index]
+        end
+      end
+
+      protected
+
+      # @return [void]
+      def on_width_changed
+        super
+        update_clipped_text
+      end
+
+      private
+
+      # @return [void]
+      def update_clipped_text
+        len = rect.width.clamp(0, nil)
+        clipped = @lines.map do |line|
+          Strings::Truncation.truncate(line, length: len)
+        end
+        return if @clipped_lines == clipped
+
+        @clipped_lines = clipped
+        invalidate
+      end
+    end
+  end
+end

data/lib/tuile/component/layout.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A layout doesn't paint anything by itself: its job is to position child
+    # components.
+    #
+    # All children must completely cover the contents of a layout: that way,
+    # the layout itself doesn't have to draw and no clipping algorithm is
+    # necessary.
+    class Layout < Component
+      def initialize
+        super
+        @children = []
+      end
+
+      # @return [Array<Component>]
+      def children = @children.to_a
+
+      # Adds a child component to this layout.
+      # @param child [Component, Array<Component>]
+      # @return [void]
+      def add(child)
+        if child.is_a? Enumerable
+          child.each { add(it) }
+        else
+          raise TypeError, "expected Component, got #{child.inspect}" unless child.is_a? Component
+          raise ArgumentError, "#{child} already has a parent #{child.parent}" unless child.parent.nil?
+
+          @children << child
+          child.parent = self
+        end
+      end
+
+      # @param child [Component]
+      # @return [void]
+      def remove(child)
+        raise TypeError, "expected Component, got #{child.inspect}" unless child.is_a? Component
+        raise ArgumentError, "#{child}'s parent is #{child.parent}, not this layout #{self}" if child.parent != self
+
+        child.parent = nil
+        @children.delete(child)
+        invalidate if @children.empty?
+        on_child_removed(child)
+      end
+
+      # @return [Size]
+      def content_size
+        return Size::ZERO if @children.empty?
+
+        right  = @children.map { |c| c.rect.left + c.rect.width  }.max
+        bottom = @children.map { |c| c.rect.top  + c.rect.height }.max
+        Size.new(right - rect.left, bottom - rect.top)
+      end
+
+      # @return [void]
+      def repaint
+        clear_background if @children.empty?
+      end
+
+      # Dispatches the event to the child under the mouse cursor.
+      # @param event [MouseEvent]
+      # @return [void]
+      def handle_mouse(event)
+        super
+        @children.each do |child|
+          child.handle_mouse(event) if child.rect.contains?(event.point)
+        end
+      end
+
+      # Called when a character is pressed on the keyboard.
+      # @param key [String] a key.
+      # @return [Boolean] true if the key was handled, false if not.
+      def handle_key(key)
+        return true if super
+
+        sc = @children.find(&:active?)
+        return false if sc.nil?
+
+        sc.handle_key(key)
+      end
+
+      # @return [void]
+      def on_focus
+        super
+        # Let the content component receive focus, so that it can immediately
+        # start responding to key presses.
+        first_focusable = @children.find(&:focusable?)
+        screen.focused = first_focusable unless first_focusable.nil?
+      end
+
+      # Absolute layout. Extend this class, register any children, and
+      # override {Component#rect=} to reposition the children.
+      class Absolute < Layout
+      end
+    end
+  end
+end