scarpe 0.2.2 → 0.4.0

data/lib/scarpe/wv/border.rb

@@ -1,24 +1,15 @@
 # frozen_string_literal: true
 
-class Scarpe
-  module WebviewBorder
-    def style
-      styles = (super if defined?(super)) || {}
-      return styles unless @border_color
+module Scarpe::Webview
+  class Border < Drawable
 
-      border_color = case @border_color
-      when Range
-        { "border-image": "linear-gradient(45deg, #{@border_color.first}, #{@border_color.last})" }
-      when Array
-        { "border-color": "rgba(#{@border_color.join(", ")})" }
-      else
-        { "border-color": @border_color }
-      end
-      styles.merge(
-        "border-style": "solid",
-        "border-width": "#{@options[:strokewidth] || 1}px",
-        "border-radius": "#{@options[:curve] || 0}px",
-      ).merge(border_color)
+    def initialize(properties)
+      super(properties)
+    end
+
+    # If the drawable is intended to be overridable, add element and style to Calzini instead
+    def element
+      render('border')
     end
   end
 end

data/lib/scarpe/wv/button.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class WebviewButton < WebviewWidget
+module Scarpe::Webview
+  class Button < Drawable
     def initialize(properties)
       super
 
@@ -10,43 +10,15 @@ class Scarpe
         # This will be sent to the bind_self_event in Button
         send_self_event(event_name: "click")
       end
-    end
 
-    def element
-      HTML.render do |h|
-        h.button(id: html_id, onclick: handler_js_code("click"), style: style) do
-          @text
-        end
+      bind("hover") do
+        # This will be sent to the bind_self_event in Button
+        send_self_event(event_name: "hover")
       end
     end
 
-    protected
-
-    def style
-      styles = super
-
-      styles[:"background-color"] = @color
-      styles[:"padding-top"] = @padding_top
-      styles[:"padding-bottom"] = @padding_bottom
-      styles[:color] = @text_color
-      styles[:width] = Dimensions.length(@width) if @width
-      styles[:height] = Dimensions.length(@height) if @height
-      styles[:"font-size"] = @font_size
-
-      styles[:top] = Dimensions.length(@top) if @top
-      styles[:left] = Dimensions.length(@left) if @left
-      styles[:position] = "absolute" if @top || @left
-      styles[:"font-size"] = Dimensions.length(font_size) if @size
-      styles[:"font-family"] = @font if @font
-      styles[:color] = rgb_to_hex(@stroke) if @stroke
-
-      styles
-    end
-
-    def font_size
-      font_size = @size.is_a?(Symbol) ? SIZES[@size] : @size
-
-      Dimensions.length(font_size)
+    def element
+      render("button")
     end
   end
 end

data/lib/scarpe/wv/check.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class WebviewCheck < Scarpe::WebviewWidget
+module Scarpe::Webview
+  class Check < Drawable
     attr_reader :text
 
     def initialize(properties)
@@ -21,9 +21,7 @@ class Scarpe
     end
 
     def element
-      HTML.render do |h|
-        h.input(type: :checkbox, id: html_id, onclick: handler_js_code("click"), value: "hmm #{text}", checked: @checked, style:)
-      end
+      render("check")
     end
   end
 end

data/lib/scarpe/wv/control_interface.rb

@@ -1,28 +1,23 @@
 # frozen_string_literal: true
 
-# The ControlInterface is used for testing. It's a way to register interest
-# in important events like redraw, init and shutdown, and to configure a
-# Shoes app for testing. Note that no part of the Scarpe framework should
-# ever *depend* on ControlInterface. It's for testing, not normal operation.
-# If no ControlInterface were ever created or called, Scarpe apps should run
-# fine with no modifications.
-#
-# And if you depend on this from the framework, I'll add a check-mode that
-# never dispatches any events to any handlers. Do NOT test me on this.
-
-class Scarpe
+# The ControlInterface is used to coordinate events. It's a way to register interest
+# in important events like redraw, init and shutdown. It's used extensively for testing.
+module Scarpe::Webview
   class ControlInterface
     include Shoes::Log
 
     SUBSCRIBE_EVENTS = [:init, :shutdown, :next_redraw, :every_redraw, :next_heartbeat, :every_heartbeat]
     DISPATCH_EVENTS = [:init, :shutdown, :redraw, :heartbeat]
+    INVALID_SYSTEM_COMPONENTS_MESSAGE = "Must pass non-nil app and wrangler to ControlInterface#set_system_components!"
+    CONTROL_INTERFACE_INIT_MESSAGE = "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
+      "to make sure they have access to app, doc_root, wrangler, etc!"
 
     attr_writer :doc_root
     attr_reader :do_shutdown
 
     # The control interface needs to see major system components to hook into their events
     def initialize
-      log_init("WV::ControlInterface")
+      log_init("Webview::ControlInterface")
 
       @do_shutdown = false
       @event_handlers = {}
@@ -35,11 +30,15 @@ class Scarpe
 
     # This should get called once, from Shoes::App
     def set_system_components(app:, doc_root:, wrangler:)
-      unless app && wrangler
-        @log.error("False app passed to set_system_components!") unless app
-        @log.error("False wrangler passed to set_system_components!") unless wrangler
-        raise "Must pass non-nil app and wrangler to ControlInterface#set_system_components!"
+      unless app
+        @log.error("False app passed to set_system_components!")
+        raise Scarpe::MissingAppError, INVALID_SYSTEM_COMPONENTS_MESSAGE
       end
+      unless wrangler
+        @log.error("False wrangler passed to set_system_components!")
+        raise Scarpe::MissingWranglerError, INVALID_SYSTEM_COMPONENTS_MESSAGE
+      end
+
       @app = app
       @doc_root = doc_root # May be nil at this point
       @wrangler = wrangler
@@ -50,28 +49,19 @@ class Scarpe
     end
 
     def app
-      unless @app
-        raise "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
-          "to make sure they have access to app, doc_root, wrangler, etc!"
-      end
+      raise Scarpe::MissingAppError, CONTROL_INTERFACE_INIT_MESSAGE unless @app
 
       @app
     end
 
     def doc_root
-      unless @doc_root
-        raise "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
-          "to make sure they have access to app, doc_root, wrangler, etc!"
-      end
+      raise Scarpe::MissingDocRootError, CONTROL_INTERFACE_INIT_MESSAGE unless @doc_root
 
       @doc_root
     end
 
     def wrangler
-      unless @wrangler
-        raise "ControlInterface code needs to be wrapped in handlers like on_event(:init) " +
-          "to make sure they have access to app, doc_root, wrangler, etc!"
-      end
+      raise Scarpe::MissingWranglerError, CONTROL_INTERFACE_INIT_MESSAGE unless @wrangler
 
       @wrangler
     end
@@ -82,7 +72,7 @@ class Scarpe
     # On recognised events, this sets a handler for that event
     def on_event(event, &block)
       unless SUBSCRIBE_EVENTS.include?(event)
-        raise "Illegal subscribe to event #{event.inspect}! Valid values are: #{SUBSCRIBE_EVENTS.inspect}"
+        raise Scarpe::IllegalSubscribeEventError, "Illegal subscribe to event #{event.inspect}! Valid values are: #{SUBSCRIBE_EVENTS.inspect}"
       end
 
       @unsub_id ||= 0
@@ -97,7 +87,7 @@ class Scarpe
       @log.debug("CTL event #{event.inspect} #{args.inspect} #{keywords.inspect}")
 
       unless DISPATCH_EVENTS.include?(event)
-        raise "Illegal dispatch of event #{event.inspect}! Valid values are: #{DISPATCH_EVENTS.inspect}"
+        raise Scarpe::IllegalDispatchEventError, "Illegal dispatch of event #{event.inspect}! Valid values are: #{DISPATCH_EVENTS.inspect}"
       end
 
       if @do_shutdown

data/lib/scarpe/wv/document_root.rb

@@ -1,8 +1,85 @@
 # frozen_string_literal: true
 
-class Scarpe
-  # A WebviewDocumentRoot is a WebviewFlow, with all the same properties
-  # and basic behavior.
-  class WebviewDocumentRoot < Scarpe::WebviewFlow
+module Scarpe::Webview
+  # A DocumentRoot is a {Scarpe::Webview::Flow}, with all the same properties
+  # and basic behavior. It also reserves space for Builtins like fonts, alerts,
+  # etc. which don't have individual {Shoes::Drawable} objects.
+  class DocumentRoot < Flow
+    def initialize(properties)
+      super
+
+      @fonts = []
+      @alerts = []
+
+      bind_shoes_event(event_name: "builtin") do |cmd_name, args|
+        case cmd_name
+        when "font"
+          @fonts << args[0]
+          # Can't just create font_updater and alert_updater on initialize - not everything is set up
+          @font_updater ||= Scarpe::Webview::WebWrangler::ElementWrangler.new(html_id: "root-fonts")
+          @font_updater.inner_html = font_contents
+        when "alert"
+          bind_ok_event
+          @alerts << args[0]
+          @alert_updater ||= Scarpe::Webview::WebWrangler::ElementWrangler.new(html_id: "root-alerts")
+          @alert_updater.inner_html = alert_contents
+        else
+          raise Scarpe::UnknownBuiltinCommandError, "Unexpected builtin command: #{cmd_name.inspect}!"
+        end
+      end
+    end
+
+    def element(&block)
+      contents = block ? block.call : ""
+      super do
+        contents + HTML.render do |h|
+          h.div(id: "root-fonts") do
+            font_contents
+          end
+          h.div(id: "root-alerts") do
+            alert_contents
+          end
+        end
+      end
+    end
+
+    private
+
+    # This needs to occur after initialize() because the app isn't yet allocated initially,
+    # so we can't call bind() for app events yet.
+    def bind_ok_event
+      return if @ok_event_setup_done
+
+      @ok_event_setup_done = true
+
+      # Done with the alert(s), delete them
+      bind("OK") do
+        @alerts = []
+        needs_update!
+      end
+    end
+
+    def font_contents
+      HTML.render do |h|
+        @fonts.each do |font|
+          h.link(href: font, rel: "stylesheet")
+          h.style do
+            font_name = File.basename(font, ".*")
+            <<~CSS
+              @font-face {
+                font-family: #{font_name};
+                src: url("data:font/truetype;base64,#{encode_file_to_base64(font)}") format('truetype');
+              }
+            CSS
+          end
+        end
+      end
+    end
+
+    def alert_contents
+      @alerts.map do |alert_text|
+        render("alert", { "text" => alert_text, "event_name" => "OK" })
+      end.join + " "
+    end
   end
 end

data/lib/scarpe/wv/{widget.rb → drawable.rb}

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-class Scarpe
-  # The WebviewWidget parent class helps connect a Webview widget with
+module Scarpe::Webview
+  # The Webview::Drawable parent class helps connect a Webview drawable with
   # its Shoes equivalent, render itself to the Webview DOM, handle
   # Javascript events and generally keep things working in Webview.
-  class WebviewWidget < Shoes::Linkable
+  class Drawable < Shoes::Linkable
+    # This will pick up the log implementation from wv.rb
     include Shoes::Log
 
     class << self
@@ -12,55 +13,60 @@ class Scarpe
       def display_class_for(scarpe_class_name)
         scarpe_class = Shoes.const_get(scarpe_class_name)
         unless scarpe_class.ancestors.include?(Shoes::Linkable)
-          raise "Scarpe Webview can only get display classes for Shoes " +
-            "linkable widgets, not #{scarpe_class_name.inspect}!"
+          raise Scarpe::InvalidClassError, "Scarpe Webview can only get display classes for Shoes " +
+            "linkable drawables, not #{scarpe_class_name.inspect}!"
         end
 
-        klass = Scarpe.const_get("Webview" + scarpe_class_name.split("::")[-1])
+        klass = Scarpe::Webview.const_get(scarpe_class_name.split("::")[-1])
         if klass.nil?
-          raise "Couldn't find corresponding Scarpe Webview class for #{scarpe_class_name.inspect}!"
+          raise Scarpe::MissingClassError, "Couldn't find corresponding Scarpe Webview class for #{scarpe_class_name.inspect}!"
         end
 
         klass
       end
     end
 
-    # The Shoes ID corresponding to the Shoes widget for this Webview widget
+    # The Shoes ID corresponding to the Shoes drawable for this Webview drawable
     attr_reader :shoes_linkable_id
 
-    # The WebviewWidget parent of this widget
+    # The Webview::Drawable parent of this drawable
     attr_reader :parent
 
-    # An array of WebviewWidget children (possibly empty) of this widget
+    # An array of Webview::Drawable children (possibly empty) of this drawable
     attr_reader :children
 
-    # Set instance variables for the display properties of this widget. Bind Shoes
-    # events for changes of parent widget and changes of property values.
+    # Set instance variables for the Shoes styles of this drawable. Bind Shoes
+    # events for changes of parent drawable and changes of property values.
     def initialize(properties)
-      log_init("WV::Widget")
+      log_init("Webview::Drawable")
+
+      @shoes_style_names = properties.keys.map(&:to_s) - ["shoes_linkable_id"]
 
-      # Call method, which looks up the parent
       @shoes_linkable_id = properties["shoes_linkable_id"] || properties[:shoes_linkable_id]
       unless @shoes_linkable_id
-        raise "Could not find property shoes_linkable_id in #{properties.inspect}!"
+        raise Scarpe::MissingAttributeError, "Could not find property shoes_linkable_id in #{properties.inspect}!"
       end
 
-      # Set the display properties
+      # Set the Shoes styles as instance variables
       properties.each do |k, v|
         next if k == "shoes_linkable_id"
 
         instance_variable_set("@" + k.to_s, v)
       end
 
-      # The parent field is *almost* simple enough that a typed display property would handle it.
+      # Must call this before bind
+      super(linkable_id: @shoes_linkable_id)
+
+      # This will only be used if moving a drawable from one parent to another.
+      # Shoes doesn't normally do that.
       bind_shoes_event(event_name: "parent", target: shoes_linkable_id) do |new_parent_id|
-        display_parent = WebviewDisplayService.instance.query_display_widget_for(new_parent_id)
+        display_parent = DisplayService.instance.query_display_drawable_for(new_parent_id)
         if @parent != display_parent
           set_parent(display_parent)
         end
       end
 
-      # When Shoes widgets change properties, we get a change notification here
+      # When Shoes drawables change properties, we get a change notification here
       bind_shoes_event(event_name: "prop_change", target: shoes_linkable_id) do |prop_changes|
         prop_changes.each do |k, v|
           instance_variable_set("@" + k, v)
@@ -71,35 +77,41 @@ class Scarpe
       bind_shoes_event(event_name: "destroy", target: shoes_linkable_id) do
         destroy_self
       end
+    end
 
-      super(linkable_id: @shoes_linkable_id)
+    def shoes_styles
+      p = {}
+      @shoes_style_names.each do |prop_name|
+        p[prop_name] = instance_variable_get("@#{prop_name}")
+      end
+      p
     end
 
     # Properties_changed will be called automatically when properties change.
-    # The widget should delete any changes from the Hash that it knows how
+    # The drawable should delete any changes from the Hash that it knows how
     # to incrementally handle, and pass the rest to super. If any changes
     # go entirely un-handled, a full redraw will be scheduled.
     # This exists to be overridden by children watching for changes.
     #
     # @param changes [Hash] a Hash of new values for properties that have changed
     def properties_changed(changes)
-      # If a widget does something really nonstandard with its html_id or element, it will
+      # If a drawable does something really nonstandard with its html_id or element, it will
       # need to override to prevent this from happening. That's easy enough, though.
       if changes.key?("hidden")
         hidden = changes.delete("hidden")
         if hidden
           html_element.set_style("display", "none")
         else
-          new_style = style # Get current display CSS property, which may vary by subclass
-          disp = new_style[:display]
-          html_element.set_style("display", disp || "block")
+          # With Calzini we can't easily tell what the display property should be.
+          # Could be flex or inline, not only block or none. Re-render this drawable.
+          needs_update!
         end
       end
 
       needs_update! unless changes.empty?
     end
 
-    # Give this widget a new parent, including managing the appropriate child lists for parent widgets.
+    # Give this drawable a new parent, including managing the appropriate child lists for parent drawables.
     def set_parent(new_parent)
       @parent&.remove_child(self)
       new_parent&.add_child(self)
@@ -108,7 +120,7 @@ class Scarpe
 
     # A shorter inspect text for prettier irb output
     def inspect
-      "#<#{self.class}:#{self.object_id} @shoes_linkable_id=#{@shoes_linkable_id} @parent=#{@parent.inspect} @children=#{@children.inspect}>"
+      "#<#{self.class}:#{self.object_id} @shoes_linkable_id=#{@shoes_linkable_id} @children=#{@children.inspect}>"
     end
 
     protected
@@ -132,55 +144,24 @@ class Scarpe
       needs_update!
     end
 
-    # Convert an [r, g, b, a] array to an HTML hex color code
-    # Arrays support alpha. HTML hex does not. So premultiply.
-    def rgb_to_hex(color)
-      return color if color.nil?
-
-      r, g, b, a = *color
-      if r.is_a?(Float)
-        a ||= 1.0
-        r_float = r * a
-        g_float = g * a
-        b_float = b * a
-      else
-        a ||= 255
-        a_float = (a / 255.0)
-        r_float = (r.to_f / 255.0) * a_float
-        g_float = (g.to_f / 255.0) * a_float
-        b_float = (b.to_f / 255.0) * a_float
-      end
-
-      r_int = (r_float * 255.0).to_i.clamp(0, 255)
-      g_int = (g_float * 255.0).to_i.clamp(0, 255)
-      b_int = (b_float * 255.0).to_i.clamp(0, 255)
-
-      "#%0.2X%0.2X%0.2X" % [r_int, g_int, b_int]
-    end
-
-    # CSS styles
-    def style
-      styles = {}
-      if @hidden
-        styles[:display] = "none"
-      end
-      styles
-    end
-
     public
 
-    # This gets a mini-webview for just this element and its children, if any.
-    # It is normally called by the widget itself to do its DOM management.
+    # This gets an accessor for just this element's HTML ID.
+    # It is normally called by the drawable itself to do its DOM management.
+    # Drawables are required to use their html_id for their outermost element,
+    # to make sure that remove(), hidden() etc. affect every part of the drawable.
     #
     # @return [Scarpe::WebWrangler::ElementWrangler] a DOM object manager
     def html_element
-      @elt_wrangler ||= Scarpe::WebWrangler::ElementWrangler.new(html_id)
+      @elt_wrangler ||= Scarpe::Webview::WebWrangler::ElementWrangler.new(html_id:)
     end
 
     # Return a promise that guarantees all currently-requested changes have completed
     #
     # @return [Scarpe::Promise] a promise that will be fulfilled when all pending changes have finished
     def promise_update
+      # Doesn't matter what ElementWrangler we use -- they all return an update promise
+      # that includes all pending updates, no matter who they're for.
       html_element.promise_update
     end
 
@@ -188,7 +169,7 @@ class Scarpe
     #
     # @return [String] the HTML ID
     def html_id
-      object_id.to_s
+      @linkable_id.to_s
     end
 
     # to_html is intended to get the HTML DOM rendering of this object and its children.
@@ -198,50 +179,58 @@ class Scarpe
     def to_html
       @children ||= []
       child_markup = @children.map(&:to_html).join
-      if respond_to?(:element)
-        element { child_markup }
-      else
-        child_markup
-      end
+      element { child_markup }
     end
 
     # This binds a Scarpe JS callback, handled via a single dispatch point in the app
     #
-    # @param event [String] the Scarpe widget event name
+    # @param event [String] the Scarpe drawable event name
     # @yield the block to call when the event occurs
     def bind(event, &block)
-      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+      raise(Scarpe::MissingAttributeError, "Drawable has no linkable_id! #{inspect}") unless linkable_id
 
-      WebviewDisplayService.instance.app.bind("#{linkable_id}-#{event}", &block)
+      DisplayService.instance.app.bind("#{linkable_id}-#{event}", &block)
     end
 
-    # Removes the element from both the Ruby Widget tree and the HTML DOM.
+    # Removes the element from both the Ruby Drawable tree and the HTML DOM.
+    # Unsubscribe from all Shoes events.
     # Return a promise for when that HTML change will be visible.
     #
     # @return [Scarpe::Promise] a promise that is fulfilled when the HTML change is complete
     def destroy_self
       @parent&.remove_child(self)
+      unsub_all_shoes_events
       html_element.remove
     end
 
-    # Request a full redraw of all widgets.
+    # Request a full redraw of the entire window, including the entire tree of
+    # drawables and the outer "empty page" frame.
+    #
+    # @return [void]
+    def full_window_redraw!
+      DisplayService.instance.app.request_redraw!
+    end
+
+    # Request a full redraw of this drawable, including all its children.
+    # Can be overridden in drawable subclasses if needed. An override would normally
+    # only be needed if re-rendering the element with the given html_id
+    # wasn't enough (and then remove would also need to be overridden.)
     #
-    # It's really hard to do dirty-tracking here because the redraws are fully asynchronous.
-    # And so we can't easily cancel one "in flight," and we can't easily pick up the latest
-    # changes... And we probably don't want to, because we may be halfway through a batch.
+    # This occurs by default if a property is changed and the drawable
+    # doesn't remove its change in property_changed.
     #
     # @return [void]
     def needs_update!
-      WebviewDisplayService.instance.app.request_redraw!
+      html_element.outer_html = to_html
     end
 
-    # Generate JS code to trigger a specific event name on this widget with the supplies arguments.
+    # Generate JS code to trigger a specific event name on this drawable with the supplies arguments.
     #
     # @param handler_function_name [String] the event name - @see #bind
     # @param args [Array] additional arguments that will be passed to the event in the generated JS
     # @return [String] the generated JS code
     def handler_js_code(handler_function_name, *args)
-      raise("Widget has no linkable_id! #{inspect}") unless linkable_id
+      raise(Scarpe::MissingAttributeError, "Drawable has no linkable_id! #{inspect}") unless linkable_id
 
       js_args = ["'#{linkable_id}-#{handler_function_name}'", *args].join(", ")
       "scarpeHandler(#{js_args})"

data/lib/scarpe/wv/edit_box.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class WebviewEditBox < Scarpe::WebviewWidget
-    attr_reader :text, :height, :width
+module Scarpe::Webview
+  class EditBox < Drawable
+    attr_reader :text, :height, :width, :tooltip , :font
 
     def initialize(properties)
       super
 
-      # The JS handler sends a "change" event, which we forward to the Shoes widget tree
+      # The JS handler sends a "change" event, which we forward to the Shoes drawable tree
       bind("change") do |new_text|
         send_self_event(new_text, event_name: "change")
       end
+      bind("hover") do
+        send_self_event(event_name: "hover")
+      end
     end
 
     def properties_changed(changes)
@@ -23,20 +26,7 @@ class Scarpe
     end
 
     def element
-      oninput = handler_js_code("change", "this.value")
-
-      HTML.render do |h|
-        h.textarea(id: html_id, oninput: oninput, style: style) { text }
-      end
-    end
-
-    protected
-
-    def style
-      super.merge({
-        height: Dimensions.length(height),
-        width: Dimensions.length(width),
-      }.compact)
+      render("edit_box")
     end
   end
 end