scarpe 0.2.2 → 0.4.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Border < Shoes::Drawable
+    # Shoes style with verification or value mapping:
+    # shoes_style(:left) { |val| convert_to_integer(val, "left") }
+
+    shoes_styles :stroke, :strokewidth  # Write your shoes styles here
+
+    shoes_style(:strokewidth) { |val| convert_to_integer(val, "strokewidth") }
+    shoes_style(:curve) { |val| convert_to_integer(val, "curve") }
+
+    Shoes::Drawable.drawable_default_styles[Shoes::Border][:stroke] = :black
+    Shoes::Drawable.drawable_default_styles[Shoes::Border][:strokewidth] = 1
+    Shoes::Drawable.drawable_default_styles[Shoes::Border][:curve] = 0
+    
+    opt_init_args :stroke, :strokewidth, :curve
+    def initialize(*args, **kwargs)
+      super
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      create_display_drawable
+    end
+
+    private
+
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Button < Shoes::Drawable
+    shoes_styles :text, :width, :height, :top, :left, :color, :padding_top, :padding_bottom, :text_color, :size, :font_size, :tooltip
+    shoes_events :click
+
+    init_args :text
+    # 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(*args, **kwargs, &block)
+      # Properties passed as positional args, not keywords, don't get auto-set
+      @block = block
+
+      super
+
+      # Bind block to a handler named "click"
+      bind_self_event("click") do
+        @log.debug("Button clicked, calling handler") if @block
+        @block&.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
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Check < Shoes::Drawable
+    shoes_styles :checked
+    shoes_events :click
+
+    init_args
+    opt_init_args :checked
+    def initialize(*args, **kwargs, &block)
+      @block = block
+      super
+
+      bind_self_event("click") do
+        self.checked = !checked?
+        @block.call(self) if @block
+      end
+      create_display_drawable
+    end
+
+    def click(&block)
+      @block = block
+    end
+
+    def checked?
+      @checked ? true : false
+    end
+
+    def checked(value)
+      self.checked = value
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Shoes
+  class DocumentRoot < Shoes::Flow
+    shoes_events # No DocumentRoot-specific events yet
+
+    Shoes::Drawable.drawable_default_styles[Shoes::DocumentRoot][:height] = "100%"
+    Shoes::Drawable.drawable_default_styles[Shoes::DocumentRoot][:width] = "100%"
+
+    init_args
+    def initialize(**kwargs, &block)
+      super
+    end
+
+    # The default inspect string can be absolutely huge in console output, and it's frequently printed.
+    def inspect
+      "<Shoes::DocumentRoot>"
+    end
+  end
+end

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

@@ -1,13 +1,14 @@
 # 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 ,:tooltip, :font
+    shoes_events :change
 
-    def initialize(text = "", height: nil, width: nil, &block)
-      @text = text
+    init_args
+    opt_init_args :text
+    def initialize(*args, **kwargs, &block)
       @callback = block
-
       super
 
       bind_self_event("change") do |new_text|
@@ -15,7 +16,7 @@ module Shoes
         @callback&.call(self)
       end
 
-      create_display_widget
+      create_display_drawable
     end
 
     def change(&block)
@@ -23,7 +24,7 @@ module Shoes
     end
 
     def append(new_text)
-      self.text = self.text + new_text
+      self.text = (self.text || "") + new_text
     end
   end
 end

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

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-module Shoes
-  class EditLine < Shoes::Widget
-    display_properties :text, :width
+class Shoes
+  class EditLine < Shoes::Drawable
+    shoes_styles :text, :width, :font, :tooltip, :stroke
+    shoes_events :change
 
-    def initialize(text = "", width: nil, &block)
+    init_args
+    opt_init_args :text
+    def initialize(*args, **kwargs, &block)
       @block = block
-      @text = text
-
       super
 
       bind_self_event("change") do |new_text|
@@ -15,7 +16,7 @@ module Shoes
         @block&.call(new_text)
       end
 
-      create_display_widget
+      create_display_drawable
     end
 
     def change(&block)

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Flow < Shoes::Slot
+    include Shoes::Background
+
+    Shoes::Drawable.drawable_default_styles[Shoes::Flow][:width] = "100%"
+
+    shoes_events
+
+    def initialize(*args, **kwargs, &block)
+      super
+
+      # 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
+  end
+end

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

@@ -0,0 +1,62 @@
+module FontHelper
+
+    def parse_font(font)
+        
+        input = font
+        regex = /\s+(?=(?:[^']*'[^']*')*[^']*$)(?![^']*,[^']*')/
+        result = input.split(regex)
+       
+        fs = nil
+        fv = nil
+        fw = nil
+        fss = nil
+        ff = ""
+        
+        fos = ["italic", "oblique"]
+        fov = ["small-caps", "initial", "inherit"]
+        fow = ["bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"]
+        foss = ["xx-small", "x-small", "small","large", "x-large", "xx-large", "smaller", "larger"]
+        
+        result.each do |i|
+          if fos.include?(i)
+            fs = i
+            next
+          elsif fov.include?(i)
+            fv = i
+            next
+          elsif fow.include?(i)
+            fw = i
+            next
+          elsif foss.include?(i)
+            fss = i
+            next
+          else
+            if contains_number?(i)
+              
+              fss=i;
+    
+            elsif i != "normal" && i != "medium" && i.strip != ""
+    
+              if ff == "Arial"
+    
+                ff = i
+    
+              else
+                
+                ff = ff+" "+i
+    
+              end
+            end
+          end
+          
+        end
+        
+          [fs, fv , fw , fss , ff.strip]
+    end
+
+    def contains_number?(str)
+    
+      !!(str =~ /\d/)
+
+    end
+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
-
-    def initialize(url, width: nil, height: nil, top: nil, left: nil, click: nil)
-      @url = url
+class Shoes
+  class Image < Shoes::Drawable
+    shoes_styles :url, :width, :height, :top, :left, :click
+    shoes_events # No Image-specific events yet
 
+    init_args :url
+    def initialize(*args, **kwargs)
       super
 
       # Get the image dimensions
       # @width, @height = size
 
-      create_display_widget
+      create_display_drawable
     end
 
     def replace(url)

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

@@ -0,0 +1,17 @@
+# 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
+
+    init_args :left, :top, :x2, :y2
+    def initialize(*args, **kwargs)
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super
+
+      create_display_drawable
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Shoes
+  class Link < Shoes::TextDrawable
+    shoes_styles :text, :click, :has_block
+    shoes_events :click
+
+    #Shoes::Drawable.drawable_default_styles[Shoes::Link][:click] = "#"
+
+    init_args # Empty by the time it reaches Drawable#initialize
+    def initialize(*args, **kwargs, &block)
+      @block = block
+      # We can't send a block to the display drawable, but we can send a boolean
+      @has_block = !block.nil?
+
+      super
+
+      bind_self_event("click") do
+        @block&.call
+      end
+    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 directly! Use link, not link_hover!"
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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
+
+    init_args # No positional args
+    def initialize(**kwargs, &block)
+      # These aren't being set as styles -- remove them from kwargs before calling super
+      # TODO: set [] as default value for items?
+      @items = kwargs.delete(:items) || []
+      @chosen = kwargs.delete(:choose) || @items&.first
+
+      super(**kwargs, &block)
+
+      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/oval.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Shoes
+  # Docs: https://github.com/scarpe-team/scarpe/blob/main/docs/static/manual.md#ovalleft-top-radius--shoesshape
+  class Oval < Shoes::Drawable
+    shoes_styles :center, :draw_context, :stroke, :fill
+
+    shoes_style(:left) { |val| convert_to_integer(val, "left") }
+    shoes_style(:top) { |val| convert_to_integer(val, "top") }
+    shoes_style(:radius) { |val| convert_to_integer(val, "radius") }
+    shoes_style(:height) { |val| convert_to_integer(val, "height") }
+    shoes_style(:width) { |val| convert_to_integer(val, "width") }
+    shoes_style(:strokewidth) { |val| convert_to_integer(val, "strokewidth") }
+
+    Shoes::Drawable.drawable_default_styles[Shoes::Oval][:fill] = "black"
+    Shoes::Drawable.drawable_default_styles[Shoes::Oval][:stroke] = "black"
+
+    init_args :left, :top
+    opt_init_args :radius, :height
+    def initialize(*args, **options)
+      @draw_context = Shoes::App.instance.current_draw_context
+
+      super # Parse any positional or keyword args
+
+      unless @left && @top && (@width || @height || @radius)
+        raise Shoes::Errors::InvalidAttributeValueError, "Oval requires left, top and one of (width, height, radius) to be specified!"
+      end
+
+      # Calzini expects "radius" to mean the x-axis-aligned radius, not y-axis-aligned.
+      # For an axis-aligned oval the two may be different.
+
+      # If we have no width, but a radius, default the width to be the radius * 2
+      @width ||= @radius * 2 if @radius
+
+      # We now know we have width or height, but maybe not both.
+
+      # Default to a circle - set height from width or vice-versa
+      @width ||= @height
+      @height ||= @width
+
+      # If we don't have radius yet, set it from width
+      @radius ||= @width / 2
+
+      create_display_drawable
+    end
+
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+require_relative 'font_helper.rb'
+class Shoes
+  class Para < Shoes::Drawable 
+  include FontHelper
+    shoes_styles :text_items, :size, :family, :font_weight, :font, :font_variant, :emphasis, :kerning
+    shoes_style(:stroke) { |val, _name| Shoes::Colors.to_rgb(val) }
+    shoes_style(:fill) { |val, _name| Shoes::Colors.to_rgb(val) }
+
+    shoes_style(:align) do |val|
+      unless ["left", "center", "right"].include?(val)
+        raise(Shoes::Errors::InvalidAttributeValueError, "Align must be one of left, center or right!")
+      end
+      val
+    end
+
+    Shoes::Drawable.drawable_default_styles[Shoes::Para][:size] = :para
+
+    shoes_events # No Para-specific events yet
+
+    # Initializes a new instance of the `Para` drawable. There are different
+    # methods to instantiate slightly different styles of Para, such as
+    # `tagline`, `caption` and `subtitle`. These will always be different
+    # sizes, but may be generally styled differently for some display services.
+    #
+    # @param args The text content of the paragraph.
+    # @param kwargs [Hash] the various Shoes styles for this 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, **kwargs)
+
+      if kwargs[:font]
+        arr= parse_font(kwargs[:font])
+        
+        if arr[0] != nil
+
+          kwargs[:emphasis] = arr[0]
+
+        end
+
+        if arr[1] != nil
+
+          kwargs[:font_variant] = arr[1]
+
+        end
+
+        if arr[2] != nil
+
+          kwargs[:font_weight] = arr[2]
+
+        end
+
+        if arr[3] != nil
+
+          kwargs[:size] = arr[3]
+
+        end
+
+        if arr[4] != ""
+
+          kwargs[:family] = arr[4]
+
+        end
+
+      end
+ 
+      # 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
+
+    
+
+    private
+
+    def text_children_to_items(text_children)
+      text_children.map { |arg| arg.is_a?(TextDrawable) ? arg.linkable_id : arg.to_s }
+    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
+
+    # 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
+end
+
+class Shoes
+  class Drawable
+    # Return a banner-sized para. This can use all the normal
+    # Para styles and arguments. See {Para#initialize} for
+    # details.
+    #
+    # @return [Shoes::Para] the new para drawable
+    def banner(*args, **kwargs)
+      para(*args, **{ size: :banner }.merge(kwargs))
+    end
+
+    # Return a title-sized para. This can use all the normal
+    # Para styles and arguments. See {Para#initialize} for
+    # details.
+    #
+    # @return [Shoes::Para] the new para drawable
+    def title(*args, **kwargs)
+      para(*args, **{ size: :title }.merge(kwargs))
+    end
+
+    # Return a subtitle-sized para. This can use all the normal
+    # Para styles and arguments. See {Para#initialize} for
+    # details.
+    #
+    # @return [Shoes::Para] the new para drawable
+    def subtitle(*args, **kwargs)
+      para(*args, **{ size: :subtitle }.merge(kwargs))
+    end
+
+    # Return a tagline-sized para. This can use all the normal
+    # Para styles and arguments. See {Para#initialize} for
+    # details.
+    #
+    # @return [Shoes::Para] the new para drawable
+    def tagline(*args, **kwargs)
+      para(*args, **{ size: :tagline }.merge(kwargs))
+    end
+
+    # Return a caption-sized para. This can use all the normal
+    # Para styles and arguments. See {Para#initialize} for
+    # details.
+    #
+    # @return [Shoes::Para] the new para drawable
+    def caption(*args, **kwargs)
+      para(*args, **{ size: :caption }.merge(kwargs))
+    end
+
+    # Return an inscription-sized para. This can use all the normal
+    # Para styles and arguments. See {Para#initialize} for
+    # details.
+    #
+    # @return [Shoes::Para] the new para drawable
+    def inscription(*args, **kwargs)
+      para(*args, **{ size: :inscription }.merge(kwargs))
+    end
+  end
+end