scarpe 0.2.1 → 0.3.0

data/{lib/scarpe → lacci/lib/shoes/drawables}/image.rb

@@ -1,30 +1,26 @@
 # frozen_string_literal: true
 
-require "fastimage"
-require "open-uri"
-
-class Scarpe
-  class Image < Scarpe::Widget
-    display_properties :url, :width, :height, :top, :left, :click
+class Shoes
+  class Image < Shoes::Drawable
+    shoes_styles :url, :width, :height, :top, :left, :click
+    shoes_events # No Image-specific events yet
 
     def initialize(url, width: nil, height: nil, top: nil, left: nil, click: nil)
-      @url = url
-
       super
+      @url = url
 
       # Get the image dimensions
       # @width, @height = size
 
-      create_display_widget
+      create_display_drawable
     end
 
     def replace(url)
       self.url = url
     end
-  end
 
-  class Widget
     def size
+      require "fastimage"
       width, height = FastImage.size(@url)
 
       [width, height]

data/lacci/lib/shoes/drawables/line.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Line < Shoes::Drawable
+    shoes_styles :left, :top, :x2, :y2, :draw_context
+    shoes_events # No Line-specific events yet
+
+    def initialize(left, top, x2, y2)
+      super
+
+      @left = left
+      @top = top
+      @x2 = x2
+      @y2 = y2
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      create_display_drawable
+    end
+  end
+end

data/lacci/lib/shoes/drawables/link.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Link < Shoes::TextDrawable
+    shoes_styles :text, :click, :has_block
+    shoes_events :click
+
+    def initialize(text, click: nil, &block)
+      super
+
+      @text = text
+      @block = block
+      # We can't send a block to the display drawable, but we can send a boolean
+      @has_block = !block.nil?
+
+      # The click property should be changed before it gets sent to the display drawable
+      @click ||= "#"
+
+      bind_self_event("click") do
+        @block&.call
+      end
+
+      create_display_drawable
+    end
+  end
+
+  # In Shoes, the LinkHover pseudo-class is used to set default styles for links when
+  # hovered over. The functionality isn't present in Lacci yet.
+  class LinkHover < Link
+    def initialize
+      raise "This class should never be instantiated! Use link, not link_hover!"
+    end
+  end
+end

data/lacci/lib/shoes/drawables/list_box.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class Shoes
+  class ListBox < Shoes::Drawable
+    shoes_styles :items, :height, :width
+
+    # Shoes3 uses choose as the initialize arg, and .choose(item) as the setter here,
+    # but queries it with .text. So this is an unusual style, and we've chosen this
+    # name not to conflict with Shoes3.
+    shoes_style :chosen
+
+    shoes_events :change
+
+    def initialize(**args, &block)
+      super
+
+      @items = args[:items] || []
+      @chosen = args[:choose] || args[:items]&.first
+
+      bind_self_event("change") do |new_item|
+        self.chosen = new_item
+        @callback&.call(self)
+      end
+
+      create_display_drawable
+    end
+
+    # Select an item. `item` should be a text entry from `items`.
+    #
+    # @param item [String] the item to choose
+    # @return [void]
+    def choose(item)
+      unless self.items.include?(item)
+        raise Shoes::Errors::NoSuchListItemError, "List items (#{self.items.inspect}) do not contain item #{item.inspect}!"
+      end
+
+      @chosen = item
+    end
+
+    # The currently chosen text item or nil.
+    #
+    # @return [String|NilClass] the current text item or nil.
+    def text
+      @chosen
+    end
+
+    # Register a block to be called when the selection changes.
+    #
+    # @yield the block to be called when selection changes
+    # @return [Shoes::ListBox] self
+    def change(&block)
+      @callback = block
+      self # Allow chaining calls
+    end
+  end
+end

data/lacci/lib/shoes/drawables/para.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Para < Shoes::Drawable
+    shoes_styles :text_items, :size, :font, :html_attributes, :hidden
+    shoes_style(:stroke) { |val| Shoes::Colors.to_rgb(val) }
+
+    shoes_events # No Para-specific events yet
+
+    # Initializes a new instance of the `Para` widget.
+    #
+    # @param args The text content of the paragraph.
+    # @param stroke [String, nil] The color of the text stroke.
+    # @param size [Symbol] The size of the paragraph text.
+    # @param font [String, nil] The font of the paragraph text.
+    # @param hidden [Boolean] Determines if the paragraph is initially hidden.
+    # @param html_attributes [Hash] Additional HTML attributes for the paragraph.
+    #
+    # @example
+    #    Shoes.app do
+    #      p = para "Hello, This is at the top!", stroke: "red", size: :title, font: "Arial"
+    #
+    #      banner("Welcome to Shoes!")
+    #      title("Shoes Examples")
+    #      subtitle("Explore the Features")
+    #      tagline("Step into a World of Shoes")
+    #      caption("A GUI Framework for Ruby")
+    #      inscription("Designed for Easy Development")
+    #
+    #      p.replace "On top we'll switch to ", strong("bold"), "!"
+    #    end
+    def initialize(*args, stroke: nil, size: :para, font: nil, **html_attributes)
+      super
+
+      # Text_children alternates strings and TextDrawables, so we can't just pass
+      # it as a Shoes style. It won't serialize.
+      update_text_children(args)
+
+      @html_attributes = html_attributes || {}
+
+      create_display_drawable
+    end
+
+    private
+
+    def text_children_to_items(text_children)
+      text_children.map { |arg| arg.is_a?(String) ? arg : arg.linkable_id }
+    end
+
+    public
+
+    # Sets the paragraph text to a new value, which can
+    # include {TextDrawable}s like em(), strong(), etc.
+    #
+    # @param children [Array] the arguments can be Strings and/or TextDrawables
+    # @return [void]
+    def replace(*children)
+      update_text_children(children)
+    end
+
+    # Set the paragraph text to a single String.
+    # To use bold, italics, etc. use {Para#replace} instead.
+    #
+    # @param child [String] the new text to use for this Para
+    # @return [void]
+    def text=(*children)
+      update_text_children(children)
+    end
+
+    def text
+      @text_children.map(&:to_s).join
+    end
+
+    def to_s
+      self.text
+    end
+
+    private
+
+    # Text_children alternates strings and TextDrawables, so we can't just pass
+    # it as a Shoes style. It won't serialize.
+    def update_text_children(children)
+      @text_children = children.flatten
+      # This should signal the display drawable to change
+      self.text_items = text_children_to_items(@text_children)
+    end
+  end
+end
+
+class Shoes
+  class Drawable
+    def banner(*args, **kwargs)
+      para(*args, **{ size: :banner }.merge(kwargs))
+    end
+
+    def title(*args, **kwargs)
+      para(*args, **{ size: :title }.merge(kwargs))
+    end
+
+    def subtitle(*args, **kwargs)
+      para(*args, **{ size: :subtitle }.merge(kwargs))
+    end
+
+    def tagline(*args, **kwargs)
+      para(*args, **{ size: :tagline }.merge(kwargs))
+    end
+
+    def caption(*args, **kwargs)
+      para(*args, **{ size: :caption }.merge(kwargs))
+    end
+
+    def inscription(*args, **kwargs)
+      para(*args, **{ size: :inscription }.merge(kwargs))
+    end
+
+    alias_method :ins, :inscription
+  end
+end

data/lacci/lib/shoes/drawables/progress.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Progress < Shoes::Drawable
+    shoes_styles :fraction
+    shoes_events # No Progress-specific events yet
+
+    def initialize(fraction: nil)
+      super
+
+      create_display_drawable
+    end
+  end
+end

data/lacci/lib/shoes/drawables/radio.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Shoes
+  # A Radio button drawable. Only a single radio button may be checked in each
+  # group. If no group is specified, or the group is nil, default to all
+  # radio buttons in the same slot being treated as being in the same group.
+  class Radio < Shoes::Drawable
+    shoes_styles :group, :checked
+    shoes_events :click
+
+    def initialize(group = nil, checked: nil, &block)
+      super
+      @group = group
+      @block = block
+
+      bind_self_event("click") { click }
+      create_display_drawable
+    end
+
+    def click(&block)
+      @block = block
+      self.checked = !checked?
+    end
+
+    def checked?
+      @checked ? true : false
+    end
+
+    def checked(value)
+      self.checked = value
+    end
+  end
+end

data/lacci/lib/shoes/drawables/rect.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Rect < Shoes::Drawable
+    shoes_styles :left, :top, :width, :height, :draw_context, :curve
+    shoes_events # No Rect-specific events yet
+
+    def initialize(*args)
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+      self.left, self.top, self.width, self.height, self.curve = args
+
+      create_display_drawable
+    end
+  end
+end

data/lacci/lib/shoes/drawables/shape.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Shoes
+  # A Shape acts as a sort of union type for drawn shapes. In Shoes you can use it to merge multiple
+  # ovals, arcs, stars, etc. into a single drawn shape.
+  #
+  # In Shoes3, a Shape isn't really a Slot. It's a kind of DSL with drawing commands that happen
+  # to have the same name as the Art drawables like star, arc, etc. Here we're treating it as
+  # a slot containing those drawables, which is wrong but not *too* wrong.
+  #
+  # @incompatibility A Shoes3 Shape is *not* a slot; Scarpe does *not* do union shapes
+  class Shape < Shoes::Slot
+    shoes_styles :left, :top, :shape_commands, :draw_context
+    shoes_events # No Shape-specific events yet
+
+    def initialize(left: nil, top: nil, &block)
+      @shape_commands = []
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+      create_display_drawable
+
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+
+    # The cmd should be an array of the form:
+    #
+    #     [cmd_name, *args]
+    #
+    # such as ["move_to", 50, 50]. Note that these must
+    # be JSON-serializable.
+    def add_shape_command(cmd)
+      @shape_commands << cmd
+    end
+  end
+end

data/lacci/lib/shoes/drawables/slot.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Shoes::Slot < Shoes::Drawable
+  # @incompatibility Shoes uses #content, not #children, for this
+  attr_reader :children
+
+  shoes_events # No Slot-specific events yet
+
+  # Do not call directly, use set_parent
+  def remove_child(child)
+    @children ||= []
+    unless @children.include?(child)
+      @log.warn("remove_child: no such child(#{child.inspect}) for parent(#{parent.inspect})!")
+    end
+    @children.delete(child)
+  end
+
+  # Do not call directly, use set_parent
+  def add_child(child)
+    @children ||= []
+    @children << child
+  end
+
+  # Get a list of child drawables
+  def contents
+    @children ||= []
+    @children.dup
+  end
+
+  # We use method_missing for drawable-creating methods like "button".
+  # The parent's method_missing will auto-create Shoes style getters and setters.
+  def method_missing(name, *args, **kwargs, &block)
+    klass = ::Shoes::Drawable.drawable_class_by_name(name)
+    return super unless klass
+
+    ::Shoes::Slot.define_method(name) do |*args, **kwargs, &block|
+      # Look up the Shoes drawable and create it...
+      drawable_instance = klass.new(*args, **kwargs, &block)
+
+      unless klass.ancestors.include?(::Shoes::TextDrawable)
+        drawable_instance.set_parent self # Create drawable in THIS SLOT, not current app slot
+      end
+
+      drawable_instance
+    end
+
+    send(name, *args, **kwargs, &block)
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    return true if Drawable.drawable_class_by_name(name.to_s)
+
+    false
+  end
+
+  # Remove all children from this drawable. If a block
+  # is given, call the block to replace the children with
+  # new contents from that block.
+  #
+  # Should only be called on Slots, which can
+  # have children.
+  #
+  # @incompatibility Shoes Classic calls the clear block with current self, while Scarpe uses the Shoes::App as self
+  #
+  # @yield The block to call to replace the contents of the drawable (optional)
+  # @return [void]
+  def clear(&block)
+    @children.dup.each(&:destroy)
+    append(&block) if block_given?
+    nil
+  end
+
+  # Call the block to append new children to a Slot.
+  #
+  # Should only be called on a Slot, since only Slots can have children.
+  #
+  # @incompatibility Shoes Classic calls the append block with current self, while Scarpe uses the Shoes::App as self
+  #
+  # @yield the block to call to replace children; will be called on the Shoes::App, appending to the called Slot as the current slot
+  # @return [void]
+  def append(&block)
+    raise(Shoes::Errors::InvalidAttributeValueError, "append requires a block!") unless block_given?
+    raise(Shoes::Errors::InvalidAttributeValueError, "Don't append to something that isn't a slot!") unless self.is_a?(Shoes::Slot)
+
+    Shoes::App.instance.with_slot(self, &block)
+  end
+end

data/{lib/scarpe → lacci/lib/shoes/drawables}/span.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class Span < Scarpe::Widget
-    display_properties :text, :stroke, :size, :font, :html_attributes
+class Shoes
+  class Span < Shoes::Drawable
+    shoes_styles :text, :stroke, :size, :font, :html_attributes
+    shoes_events # No Span-specific events yet
 
     def initialize(text, stroke: nil, size: :span, font: nil, **html_attributes)
+      super
+
       @text = text
       @stroke = stroke
       @size = size
       @font = font
       @html_attributes = html_attributes
 
-      super
-
-      create_display_widget
+      create_display_drawable
     end
 
     def replace(text)
       @text = text
 
-      # This should signal the display widget to change
+      # This should signal the display drawable to change
       self.text = @text
     end
   end

data/lacci/lib/shoes/drawables/stack.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Stack < Shoes::Slot
+    include Shoes::Background
+    include Shoes::Border
+    include Shoes::Spacing
+
+    # TODO: sort out various margin and padding properties, including putting stuff into spacing
+    shoes_styles :width, :height, :scroll
+
+    shoes_events # No Stack-specific events yet
+
+    def initialize(width: nil, height: nil, margin: nil, padding: nil, scroll: false, margin_top: nil, margin_bottom: nil, margin_left: nil,
+      margin_right: nil, **options, &block)
+
+      @options = options
+
+      super
+
+      create_display_drawable
+      # Create the display-side drawable *before* running the block, which will add child drawables with their display drawables
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+  end
+end

data/lacci/lib/shoes/drawables/star.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Star < Shoes::Drawable
+    shoes_styles :left, :top, :draw_context
+
+    shoes_style(:points) { |val| convert_to_integer(val, "points") }
+    shoes_style(:outer) { |val| convert_to_float(val, "outer") }
+    shoes_style(:inner) { |val| convert_to_float(val, "inner") }
+
+    shoes_events # No Star-specific events yet
+
+    def initialize(left, top, points = 10, outer = 100, inner = 50)
+      super
+      self.left = left
+      self.top = top
+      self.points = points
+      self.outer = outer
+      self.inner = inner
+
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      create_display_drawable
+    end
+
+    def self.convert_to_integer(value, attribute_name)
+      begin
+        value = Integer(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative num '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
+
+    def self.convert_to_float(value, attribute_name)
+      begin
+        value = Float(value)
+        raise Shoes::Errors::InvalidAttributeValueError, "Negative num '#{value}' not allowed for attribute '#{attribute_name}'" if value < 0
+
+        value
+      rescue ArgumentError
+        error_message = "Invalid value '#{value}' provided for attribute '#{attribute_name}'. The value should be a number."
+        raise Shoes::Errors::InvalidAttributeValueError, error_message
+      end
+    end
+  end
+end

data/lacci/lib/shoes/drawables/subscription_item.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Certain Shoes calls like motion and keydown are basically an
+# event subscription, with no other visible presence. However,
+# they have a place in the drawable tree and can be deleted.
+#
+# Depending on the display library they may not have any
+# direct visual (or similar) presence there either.
+#
+# Inheriting from Drawable gives these a parent slot and a
+# linkable_id automatically.
+#
+# Events not yet implemented: start, finish events for slots -
+# start is first draw, finish is drawable destroyed
+class Shoes::SubscriptionItem < Shoes::Drawable
+  shoes_styles :shoes_api_name, :args
+  shoes_events :animate, :every, :timer, :hover, :leave, :motion, :click, :release, :keypress
+
+  def initialize(args: [], shoes_api_name:, &block)
+    super
+
+    @callback = block
+
+    case shoes_api_name
+    when "animate"
+      @unsub_id = bind_self_event("animate") do |frame|
+        @callback.call(frame)
+      end
+    when "every"
+      @unsub_id = bind_self_event("every") do |count|
+        @callback.call(count)
+      end
+    when "timer"
+      @unsub_id = bind_self_event("timer") do
+        @callback.call
+      end
+    when "hover"
+      # Hover passes the Shoes drawable as the block param
+      @unsub_id = bind_self_event("hover") do
+        @callback&.call(self)
+      end
+    when "leave"
+      # Leave passes the Shoes drawable as the block param
+      @unsub_id = bind_self_event("leave") do
+        @callback&.call(self)
+      end
+    when "motion"
+      # Shoes sends back x, y, mods as the args.
+      # Shoes3 uses the strings "control" "shift" and
+      # "control_shift" as the mods arg.
+      @unsub_id = bind_self_event("motion") do |x, y, ctrl_key, shift_key, **_kwargs|
+        mods = [ctrl_key ? "control" : nil, shift_key ? "shift" : nil].compact.join("_")
+        @callback&.call(x, y, mods)
+      end
+    when "click"
+      # Click has block params button, left, top
+      # button is the button number, left and top are coords
+      @unsub_id = bind_self_event("click") do |button, x, y, **_kwargs|
+        @callback&.call(button, x, y)
+      end
+    when "release"
+      # Click has block params button, left, top
+      # button is the button number, left and top are coords
+      @unsub_id = bind_self_event("release") do |button, x, y, **_kwargs|
+        @callback&.call(button, x, y)
+      end
+    when "keypress"
+      # Keypress passes the key string or symbol to the handler
+      # Do anything special for serialisation here?
+      @unsub_id = bind_self_event("keypress") do |key|
+        @callback&.call(key)
+      end
+    else
+      raise "Unknown Shoes event #{shoes_api_name.inspect} passed to SubscriptionItem!"
+    end
+
+    @unsub_id = bind_self_event(shoes_api_name) do |*args|
+      @callback&.call(*args)
+    end
+
+    # This won't create a visible display drawable, but will turn into
+    # an invisible drawable and a stream of events.
+    create_display_drawable
+  end
+
+  def destroy
+    # TODO: we need a better way to do this automatically. See https://github.com/scarpe-team/scarpe/issues/291
+    unsub_shoes_event(@unsub_id) if @unsub_id
+    @unsub_id = nil
+
+    super
+  end
+end