lacci 0.2.2 → 0.4.0

data/lib/shoes/drawables/progress.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Progress < Shoes::Drawable
+    shoes_styles :fraction
+    shoes_events # No Progress-specific events yet
+
+    init_args # No positional args
+    def initialize(**kwargs)
+      super
+
+      create_display_drawable
+    end
+  end
+end

data/lib/shoes/drawables/radio.rb

@@ -0,0 +1,35 @@
+# 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
+
+    init_args
+    opt_init_args :group
+    def initialize(*args, **kwargs, &block)
+      @block = block
+
+      super
+
+      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/lib/shoes/drawables/rect.rb

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

data/lib/shoes/{widgets → drawables}/shape.rb

@@ -1,25 +1,25 @@
 # 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
+    init_args # No positional args
+    def initialize(**kwargs, &block)
       @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/lib/shoes/drawables/slot.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+class Shoes::Slot < Shoes::Drawable
+  # @incompatibility Shoes uses #content, not #children, for this. Scarpe does both.
+  attr_reader :children
+
+  shoes_events # No Slot-specific events
+
+  # This only shows this specific slot's settings, not its parent's.
+  # Use current_draw_context to allow inheritance.
+  attr_reader :draw_context
+
+
+  def initialize(...)
+    # The draw context tracks current settings like fill and stroke,
+    # plus potentially other current state that changes from drawable
+    # to drawable and slot to slot.
+    @draw_context = {
+      "fill" => nil,
+      "stroke" => nil,
+      "strokewidth" => nil,
+      "rotate" => nil,
+      # "transform" => nil, # "corner",
+      # "translate" => nil, # [0, 0],
+    }
+
+    super
+  end
+
+  # 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.
+  # This is similar to the method_missing in Shoes::App, but differs in where
+  # the new drawable will appear.
+  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|
+      instance = nil
+
+      # Look up the Shoes drawable and create it. But first set
+      # this slot as the current one so that draw context
+      # is handled properly.
+      Shoes::App.instance.with_slot(self) do
+        instance = klass.new(*args, **kwargs, &block)
+      end
+
+      instance
+    end
+
+    send(name, *args, **kwargs, &block)
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    return true if ::Shoes::Drawable.drawable_class_by_name(name.to_s)
+
+    false
+  end
+
+  # Draw context methods
+
+  # Set the default fill color in this slot and child slots.
+  # Pass nil for "no setting", so that it can inherit defaults.
+  #
+  # @param color [Nil,Color] a Shoes color for the fill color or nil to use parent setting
+  # @return [void]
+  def fill(color)
+    @draw_context["fill"] = color
+  end
+
+  # Set the default fill in this slot and child slots to transparent.
+  #
+  # @return [void]
+  def nofill
+    @draw_context["fill"] = rgb(0, 0, 0, 0)
+  end
+
+  # Set the default stroke color in this slot and child slots.
+  # Pass nil for "no setting" so it can inherit defaults.
+  #
+  # @param color [Nil,Color] a Shoes color for the stroke color or nil to use parent setting
+  # @return [void]
+  def stroke(color)
+    @draw_context["stroke"] = color
+  end
+
+  # Set the default strokewidth in this slot and child slots.
+  # Pass nil for "no setting".
+  #
+  # @param width [Numeric,Nil] the new width, or nil to use parent setting
+  # @return [void]
+  def strokewidth(width)
+    @draw_context["strokewidth"] = width
+  end
+
+  # Set the default stroke in this slot and child slots
+  # to transparent.
+  #
+  # @return [void]
+  def nostroke
+    @draw_context["stroke"] = rgb(0, 0, 0, 0)
+  end
+
+  # Set the current rotation in this slot and any child slots.
+  # Pass nil to reset the angle to default.
+  #
+  # @param angle [Numeric,Nil] the new default rotation for shapes or nil to use parent setting
+  # @return [void]
+  def rotate(angle)
+    @draw_context["rotate"] = angle
+  end
+
+  # Get the current draw context styles, based on this slot and its parent slots.
+  #
+  # @return [Hash] a hash of Shoes styles for the context
+  def current_draw_context
+    s = @parent ? @parent.current_draw_context : {}
+    @draw_context.each { |k, v| s[k] = v unless v.nil? }
+
+    s
+  end
+
+  # Methods to add or remove children
+
+  # 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 ||= []
+    @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/shoes/drawables/stack.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Stack < Shoes::Slot
+    include Shoes::Background
+
+    shoes_styles :scroll
+
+    shoes_events # No Stack-specific events
+
+    def initialize(*args, **kwargs, &block)
+      super
+
+      create_display_drawable
+
+      # Create the display-side drawable *before* running the block.
+      # Then child drawables have a parent to add themselves to.
+      Shoes::App.instance.with_slot(self, &block) if block_given?
+    end
+  end
+end

data/lib/shoes/drawables/star.rb

@@ -0,0 +1,28 @@
+# 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::Drawable.drawable_default_styles[Shoes::Star][:points] = 10
+    Shoes::Drawable.drawable_default_styles[Shoes::Star][:outer] = 100
+    Shoes::Drawable.drawable_default_styles[Shoes::Star][:inner] = 50
+
+    shoes_events # No Star-specific events
+
+    init_args :left, :top
+    opt_init_args :points, :outer, :inner
+    def initialize(*args, **kwargs)
+      super
+
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      create_display_drawable
+    end
+
+  end
+end

data/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

data/lib/shoes/drawables/text_drawable.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+class Shoes
+  # TextDrawable is the parent class of various classes of
+  # text that can go inside a para. This includes normal
+  # text, but also links, italic text, bold text, etc.
+  #
+  # In Shoes3 this corresponds to cText, and it would
+  # have methods app, contents, children, parent,
+  # style, to_s, text, text= and replace.
+  #
+  # Much of what this does and how is similar to Para.
+  # It's a very similar API.
+  class TextDrawable < Shoes::Drawable
+    shoes_styles :text_items, :size, :stroke, :strokewidth, :fill, :undercolor, :font
+
+    STRIKETHROUGH_VALUES = [nil, "none", "single"]
+    shoes_style :strikethrough do |val, _name|
+      unless STRIKETHROUGH_VALUES.include?(val)
+        raise Shoes::Errors::InvalidAttributeValueError, "Strikethrough must be one of: #{STRIKETHROUGH_VALUES.inspect}!"
+      end
+      val
+    end
+
+    UNDERLINE_VALUES = [nil, "none", "single", "double", "low", "error"]
+    shoes_style :underline do |val, _name|
+      unless UNDERLINE_VALUES.include?(val)
+        raise Shoes::Errors::InvalidAttributeValueError, "Underline must be one of: #{UNDERLINE_VALUES.inspect}!"
+      end
+      val
+    end
+
+    shoes_events # No TextDrawable-specific events yet
+
+    def initialize(*args, **kwargs)
+      # Don't pass text_children args to Drawable#initialize
+      super(*[], **kwargs)
+
+      # 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)
+
+      create_display_drawable
+    end
+
+    def text_children_to_items(text_children)
+      text_children.map { |arg| arg.is_a?(TextDrawable) ? arg.linkable_id : arg.to_s }
+    end
+
+    # 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
+
+    # Return the text, but not the styling, of the para's
+    # contents. For example, if the contents had strong
+    # and emphasized text, the bold and emphasized would
+    # be removed but the text would be returned.
+    #
+    # @return [String] the text from this para
+    def text
+      @text_children.map(&:to_s).join
+    end
+
+    # Return the text but not styling from the para. This
+    # is the same as #text.
+    #
+    # @return [String] the text from this para
+    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
+
+  class << self
+    def default_text_drawable_with(element)
+      class_name = element.capitalize
+
+      drawable_class = Class.new(Shoes::TextDrawable) do
+        shoes_events # No specific events
+
+        init_args # We're going to pass an empty array to super
+      end
+      Shoes.const_set class_name, drawable_class
+    end
+  end
+end
+
+Shoes.default_text_drawable_with(:code)
+Shoes.default_text_drawable_with(:del)
+Shoes.default_text_drawable_with(:em)
+Shoes.default_text_drawable_with(:strong)
+Shoes.default_text_drawable_with(:span)
+Shoes.default_text_drawable_with(:sub)
+Shoes.default_text_drawable_with(:sup)
+Shoes.default_text_drawable_with(:ins) # in Shoes3, looks like "ins" is just underline
+
+# Defaults must come *after* classes are defined
+
+Shoes::Drawable.drawable_default_styles[Shoes::Ins][:underline] = "single"

data/lib/shoes/drawables/video.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Video < Shoes::Drawable
+    shoes_styles :url
+    shoes_events # No specific events yet
+
+    init_args :url
+    def initialize(*args, **kwargs)
+      super
+
+      create_display_drawable
+    end
+
+    # other methods
+  end
+end

data/lib/shoes/drawables/widget.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# A Shoes::Widget is mostly a Slot (related to the
+# old Shoes concepts of Canvas) that creates drawables
+# inside itself. When a subclass of Widget is created,
+# it adds a method to create new objects of that type
+# on Shoes::App and all Shoes slots.
+#
+# The hardest part with a Shoes::Widget is that it
+# should work fine even if initialize() doesn't call
+# super, which would make it hard to set up a Shoes
+# linkable_id, create a display widget, etc.
+#
+# It would be possible to add an extra method to set
+# these up and call it on every created drawable
+# in case a Widget's initialize method doesn't call
+# super, which happens quite often. But then we wouldn't
+# support automatic setting of styles (e.g. padding)
+# for the widget object itself, which is mostly a Flow.
+# We also couldn't support default styles -- I can't tell
+# whether Shoes supports these things either.
+#
+# But there's another way to do all of this. When a
+# subclass of Widget defines an initialize method,
+# we can catch the method_added hook, save a copy of
+# that initialize method, and substitute our own
+# initialize that calls super. We have to be a little
+# careful -- if the widget's initialize *does* call
+# super that shouldn't be an error. But that's
+# workable by defining an extra method with the
+# copied-method name that does nothing.
+
+##### TODO: when this is subclassed, grab :initialize out
+# of the subclass, put it into :initialize_widget, and
+# replace with an initialize that creates the display
+# widget propertly, sets the linkable_id, etc.
+
+class Shoes::Widget < Shoes::Slot
+  include Shoes::Background
+
+  shoes_events
+
+  def self.inherited(subclass)
+    super
+
+    # Widgets are special - we can't know in advance what sort of initialize args they take
+    subclass.init_args :any
+  end
+
+  def self.method_added(name)
+    # We're only looking for the initialize() method, and only on subclasses
+    # of Shoes::Widget, not Shoes::Widget itself.
+    return if self == ::Shoes::Widget || name != :initialize
+
+    # Need to avoid infinite adding of initialize() if we're re-adding the default initialize
+    return if @midway_through_adding_initialize
+
+    # Take the user-provided initialize method and save a copy named __widget_initialize
+    alias_method :__widget_initialize, :initialize
+
+    # And add the default initialize back where it belongs
+    @midway_through_adding_initialize = true
+    define_method(:initialize) do |*args, **kwargs, &block|
+      super(*args, **kwargs, &block)
+      @options = kwargs # Get rid of options?
+      create_display_drawable
+      __widget_initialize(*args, **kwargs, &block)
+
+      # Do Widgets do this?
+      Shoes::App.instance.with_slot(self, &block) if block
+    end
+    @midway_through_adding_initialize = false
+  end
+end

data/lib/shoes/drawables.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "shoes/drawables/slot"
+require "shoes/drawables/stack"
+require "shoes/drawables/flow"
+require "shoes/drawables/widget"
+require "shoes/drawables/document_root"
+
+require "shoes/drawables/text_drawable"
+
+require "shoes/drawables/subscription_item"
+
+require "shoes/drawables/arc"
+require "shoes/drawables/line"
+require "shoes/drawables/rect"
+require "shoes/drawables/shape"
+require "shoes/drawables/star"
+require "shoes/drawables/oval"
+require "shoes/drawables/arrow"
+
+require "shoes/drawables/button"
+require "shoes/drawables/check"
+require "shoes/drawables/edit_box"
+require "shoes/drawables/edit_line"
+require "shoes/drawables/image"
+require "shoes/drawables/link"
+require "shoes/drawables/list_box"
+require "shoes/drawables/para"
+require "shoes/drawables/radio"
+require "shoes/drawables/video"
+require "shoes/drawables/progress"
+require "shoes/drawables/border"