scarpe 0.2.2 → 0.3.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Button < Shoes::Drawable
+    include Shoes::Log
+    shoes_styles :text, :width, :height, :top, :left, :color, :padding_top, :padding_bottom, :text_color, :size, :font_size, :tooltip
+    shoes_events :click, :hover
+
+    # Creates a new Button object.
+    #
+    # @param text [String] The text displayed on the button.
+    # @param width [Integer] The requested width of the button in pixels.
+    # @param height [Integer] The requested height of the button in pixels.
+    # @param top [Integer] The position of the top edge of the button relative to its parent widget.
+    # @param left [Integer] The position of the left edge of the button relative to its parent widget.
+    # @param size [Integer] The font size of the button text.
+    # @param color [String] The background color of the button.
+    # @param padding_top [Integer] The padding above the button text.
+    # @param padding_bottom [Integer] The padding below the button text.
+    # @param text_color [String] The color of the button text.
+    # @yield A block of code to be executed when the button is clicked.
+    # @return [Shoes::Button] the button object
+    #
+    # @example
+    #   Shoes.app do
+    #     @push = button "Push me"
+    #     @note = para "Nothing pushed so far"
+    #     @push.click {
+    #       @note.replace(
+    #         "Aha! Click! ",
+    #         link("Go back") { @note.replace("Nothing pushed so far") }
+    #       )
+    #     }
+    #   end
+    def initialize(text, width: nil, height: nil, top: nil, left: nil, color: nil, padding_top: nil, padding_bottom: nil, size: 12, text_color: nil,
+      font_size: nil, tooltip: nil, &block)
+
+      log_init("Button")
+
+      # Properties passed as positional args, not keywords, don't get auto-set
+      @text = text
+      @block = block
+
+      super
+
+      # Bind to a handler named "click"
+      bind_self_event("click") do
+        @log.debug("Button clicked, calling handler") if @block
+        @block&.call
+      end
+
+      bind_self_event("hover") do
+        @hover&.call
+      end
+
+      create_display_drawable
+    end
+
+    # Set the click handler
+    #
+    # @yield A block to be called when the button is clicked.
+    def click(&block)
+      @block = block
+    end
+
+    # Set the hover handler
+    #
+    # @yield A block to be called when the cursor moves to be over the button.
+    def hover(&block)
+      @hover = block
+    end
+  end
+end

data/lacci/lib/shoes/{widgets → drawables}/check.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-module Shoes
-  class Check < Shoes::Widget
-    display_properties :checked
+class Shoes
+  class Check < Shoes::Drawable
+    shoes_styles :checked
+    shoes_events :click
 
     def initialize(checked = nil, &block)
       @block = block
       super
 
       bind_self_event("click") { click }
-      create_display_widget
+      create_display_drawable
     end
 
     def click(&block)

data/lacci/lib/shoes/{widgets → drawables}/document_root.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-module Shoes
+class Shoes
   class DocumentRoot < Shoes::Flow
+    shoes_events # No DocumentRoot-specific events yet
+
     def initialize
       @height = "100%"
       @width = @margin = @padding = nil
       @options = {}
 
       super
-
-      create_display_widget
     end
 
     # The default inspect string can be absolutely huge in console output, and it's frequently printed.

data/lacci/lib/shoes/{widgets → drawables}/edit_box.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-module Shoes
-  class EditBox < Shoes::Widget
-    display_properties :text, :height, :width
+class Shoes
+  class EditBox < Shoes::Drawable
+    shoes_styles :text, :height, :width
+    shoes_events :change
 
     def initialize(text = "", height: nil, width: nil, &block)
+      super
       @text = text
       @callback = block
 
-      super
-
       bind_self_event("change") do |new_text|
         self.text = new_text
         @callback&.call(self)
       end
 
-      create_display_widget
+      create_display_drawable
     end
 
     def change(&block)

data/lacci/lib/shoes/{widgets → drawables}/edit_line.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-module Shoes
-  class EditLine < Shoes::Widget
-    display_properties :text, :width
+class Shoes
+  class EditLine < Shoes::Drawable
+    shoes_styles :text, :width
+    shoes_events :change
 
     def initialize(text = "", width: nil, &block)
+      super
       @block = block
       @text = text
 
-      super
-
       bind_self_event("change") do |new_text|
         self.text = new_text
         @block&.call(new_text)
       end
 
-      create_display_widget
+      create_display_drawable
     end
 
     def change(&block)

data/lacci/lib/shoes/{widgets → drawables}/flow.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-module Shoes
+class Shoes
   class Flow < Shoes::Slot
     include Shoes::Background
     include Shoes::Border
     include Shoes::Spacing
 
-    display_properties :width, :height, :margin, :padding
+    shoes_styles :width, :height, :margin, :padding
+    shoes_events
 
     def initialize(width: "100%", height: nil, margin: nil, padding: nil, **options, &block)
-      @options = options
-
       super
+      @options = options
 
-      # Create the display-side widget *before* instance_eval, which will add child widgets with their display widgets
-      create_display_widget
+      # Create the display-side drawable *before* instance_eval, which will add child drawables with their display drawables
+      create_display_drawable
 
       Shoes::App.instance.with_slot(self, &block) if block_given?
     end

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

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-module Shoes
-  class Image < Shoes::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)

data/lacci/lib/shoes/{widgets → drawables}/line.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-module Shoes
-  class Line < Shoes::Widget
-    display_properties :left, :top, :x2, :y2, :draw_context
+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
 
-      super
-      create_display_widget
+      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/{widgets → drawables}/shape.rb

@@ -1,25 +1,24 @@
 # frozen_string_literal: true
 
-module Shoes
+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 widgets like star, arc, etc. Here we're treating it as
-  # a slot containing those widgets, which is wrong but not *too* wrong.
+  # 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
-    display_properties :left, :top, :shape_commands, :draw_context
+    shoes_styles :left, :top, :shape_commands, :draw_context
+    shoes_events # No Shape-specific events yet
 
     def initialize(left: nil, top: nil, &block)
-      @left = left
-      @top = top
       @shape_commands = []
       @draw_context = Shoes::App.instance.current_draw_context
 
       super
-      create_display_widget
+      create_display_drawable
 
       Shoes::App.instance.with_slot(self, &block) if block_given?
     end

data/lacci/lib/shoes/{widgets → drawables}/slot.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-class Shoes::Slot < Shoes::Widget
+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 ||= []
@@ -19,29 +21,39 @@ class Shoes::Slot < Shoes::Widget
     @children << child
   end
 
-  # Get a list of child widgets
+  # Get a list of child drawables
   def contents
     @children ||= []
     @children.dup
   end
 
-  # Calling stack.app or flow.app will execute the block
-  # with the Shoes::App as self, and with that stack or
-  # flow as the current slot.
-  #
-  # @incompatibility Shoes Classic will only change self
-  #   via this method, while Scarpe will also change self
-  #   with the other Slot Manipulation methods: #clear,
-  #   #append, #prepend, #before and #after.
-  #
-  # @return [Shoes::App] the Shoes app
-  # @yield the block to call with the Shoes App as self
-  def app(&block)
-    Shoes::App.instance.with_slot(self, &block) if block_given?
-    Shoes::App.instance
+  # 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 widget. If a block
+  # Remove all children from this drawable. If a block
   # is given, call the block to replace the children with
   # new contents from that block.
   #
@@ -50,7 +62,7 @@ class Shoes::Slot < Shoes::Widget
   #
   # @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 widget (optional)
+  # @yield The block to call to replace the contents of the drawable (optional)
   # @return [void]
   def clear(&block)
     @children.dup.each(&:destroy)
@@ -67,8 +79,8 @@ class Shoes::Slot < Shoes::Widget
   # @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("append requires a block!") unless block_given?
-    raise("Don't append to something that isn't a slot!") unless self.is_a?(Shoes::Slot)
+    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

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

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
-module Shoes
-  class Span < Shoes::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