scarpe 0.2.1 → 0.3.0

data/lib/scarpe/wv/app.rb

@@ -1,38 +1,30 @@
 # frozen_string_literal: true
 
-class Scarpe
-  # Scarpe::WebviewApp must only be used from the main thread, due to GTK+ limitations.
-  class WebviewApp < WebviewWidget
-    attr_reader :debug
+module Scarpe::Webview
+  # Scarpe::Webview::App must only be used from the main thread, due to GTK+ limitations.
+  class App < Drawable # App inherits from Drawable to set up linkable IDs and event methods
     attr_reader :control_interface
 
     attr_writer :shoes_linkable_id
 
     def initialize(properties)
-      # Is this a thing? Do we care about this?
-      # opts = @control_interface.app_opts_get_override(opts)
-
       super
 
-      # It's possible to provide a Ruby script by setting
-      # SCARPE_TEST_CONTROL to its file path. This can
-      # allow pre-setting test options or otherwise
-      # performing additional actions not written into
-      # the Shoes app itself.
-      #
-      # The control interface is what lets these files see
-      # events, specify overrides and so on.
+      # Scarpe's ControlInterface sets up event handlers
+      # for the display service that aren't sent to
+      # Lacci (Shoes). In general it's used for setup
+      # and additional control or testing, outside the
+      # Shoes app. This is how CatsCradle and Shoes-Spec
+      # set up testing, for instance.
       @control_interface = ControlInterface.new
-      if ENV["SCARPE_TEST_CONTROL"]
-        @control_interface.instance_eval File.read(ENV["SCARPE_TEST_CONTROL"])
-      end
 
       # TODO: rename @view
-      @view = Scarpe::WebWrangler.new title: @title,
+      @view = Scarpe::Webview::WebWrangler.new title: @title,
         width: @width,
         height: @height,
-        resizable: @resizable,
-        debug: @debug
+        resizable: @resizable
+
+      @callbacks = {}
 
       # The control interface has to exist to get callbacks like "override Scarpe app opts".
       # But the Scarpe App needs those options to be created. So we can't pass these to
@@ -50,11 +42,11 @@ class Scarpe
       scarpe_app = self
 
       @view.init_code("scarpeInit") do
-        @document_root.request_redraw!
+        request_redraw!
       end
 
       @view.bind("scarpeHandler") do |*args|
-        @document_root.handle_callback(*args)
+        handle_callback(*args)
       end
 
       @view.bind("scarpeExit") do
@@ -65,6 +57,8 @@ class Scarpe
     def run
       @control_interface.dispatch_event(:init)
 
+      @view.empty_page = empty_page_element
+
       # This takes control of the main thread and never returns. And it *must* be run from
       # the main thread. And it stops any Ruby background threads.
       # That's totally cool and normal, right?
@@ -81,5 +75,33 @@ class Scarpe
         @view = nil
       end
     end
+
+    # All JS callbacks to Scarpe drawables are dispatched
+    # via this handler
+    def handle_callback(name, *args)
+      if @callbacks.key?(name)
+        @callbacks[name].call(*args)
+      else
+        raise Scarpe::UnknownEventTypeError, "No such Webview callback: #{name.inspect}!"
+      end
+    end
+
+    # Bind a Scarpe callback name; see handle_callback above.
+    # See Scarpe::Drawable for how the naming is set up
+    def bind(name, &block)
+      @callbacks[name] = block
+    end
+
+    # Request a full redraw if Webview is running. Otherwise
+    # this is a no-op.
+    #
+    # @return [void]
+    def request_redraw!
+      wrangler = DisplayService.instance.wrangler
+      if wrangler.is_running
+        wrangler.replace(@document_root.to_html)
+      end
+      nil
+    end
   end
 end

data/lib/scarpe/wv/arc.rb

@@ -1,57 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "shape_helper"
-
-class Scarpe
-  class WebviewArc < Scarpe::WebviewWidget
-    include ShapeHelper
+module Scarpe::Webview
+  class Arc < Drawable
     def initialize(properties)
       super(properties)
     end
 
-    def element(&block)
-      HTML.render do |h|
-        h.div(id: html_id, style: style) do
-          h.svg(width: @width, height: @height) do
-            h.path(d: arc_path)
-          end
-          block.call(h) if block_given?
-        end
-      end
-    end
-
-    private
-
-    def style
-      {
-        left: "#{@left}px",
-        top: "#{@top}px",
-        width: "#{@width}px",
-        height: "#{@height}px",
-      }
-    end
-
-    def arc_path
-      center_x = @width / 2
-      center_y = @height / 2
-      radius_x = @width / 2
-      radius_y = @height / 2
-      start_angle_degrees = radians_to_degrees(@angle1) % 360
-      end_angle_degrees = radians_to_degrees(@angle2) % 360
-      large_arc_flag = (end_angle_degrees - start_angle_degrees) % 360 > 180 ? 1 : 0
-
-      "M#{center_x} #{center_y} L#{@width} #{center_y} " \
-        "A#{radius_x} #{radius_y} 0 #{large_arc_flag} 0 " \
-        "#{center_x + radius_x * Math.cos(degrees_to_radians(end_angle_degrees))} " \
-        "#{center_y + radius_y * Math.sin(degrees_to_radians(end_angle_degrees))} Z"
-    end
-
-    def degrees_to_radians(degrees)
-      degrees * Math::PI / 180
-    end
-
-    def radians_to_degrees(radians)
-      radians * (180.0 / Math::PI)
+    def element
+      render("arc")
     end
   end
 end

data/lib/scarpe/wv/arrow.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Scarpe::Webview
+  class Arrow < Drawable
+    def element
+      render("arrow")
+    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,41 +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
 
-    private
-
-    def style
-      styles = {}
-      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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Scarpe::Webview
+  class Check < Drawable
+    attr_reader :text
+
+    def initialize(properties)
+      super
+
+      bind("click") do
+        send_self_event(event_name: "click", target: shoes_linkable_id)
+      end
+    end
+
+    def properties_changed(changes)
+      checked = changes.delete("checked")
+
+      html_element.toggle_input_button(checked)
+
+      super
+    end
+
+    def element
+      render("check")
+    end
+  end
+end

data/lib/scarpe/wv/control_interface.rb

@@ -1,28 +1,31 @@
 # 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 override
-# test-relevant values like the options to Shoes.app(). 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.
+# 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
+module Scarpe::Webview
   class ControlInterface
-    include Scarpe::Log
+    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 = {}
@@ -33,13 +36,17 @@ class Scarpe
       "<#ControlInterface>"
     end
 
-    # This should get called once, from Scarpe::App
+    # 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 +57,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
@@ -79,23 +77,17 @@ class Scarpe
     # The control interface has overrides for certain settings. If the override has been specified,
     # those settings will be overridden.
 
-    # Override the Shoes app opts like "debug:" and "die_after:" with new ones.
-    def override_app_opts(new_opts)
-      @new_app_opts = new_opts
-    end
-
-    # Called by Scarpe::App to get the override options
-    def app_opts_get_override(opts)
-      @new_app_opts || opts
-    end
-
     # 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
 
-      @event_handlers[event] << block
+      @unsub_id ||= 0
+      @unsub_id += 1
+
+      @event_handlers[event] << { handler: block, unsub: @unsub_id }
+      @unsub_id
     end
 
     # Send out the specified event
@@ -103,7 +95,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
@@ -145,8 +137,8 @@ class Scarpe
     private
 
     def dumb_dispatch_event(event, *args, **keywords)
-      @event_handlers[event].each do |handler|
-        instance_eval(*args, **keywords, &handler)
+      @event_handlers[event].each do |data|
+        instance_eval(*args, **keywords, &data[:handler])
       end
     end
   end

data/lib/scarpe/wv/document_root.rb

@@ -1,50 +1,85 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class WebviewDocumentRoot < Scarpe::WebviewWidget
-    include Scarpe::WebviewBackground
-
+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)
-      @callbacks = {}
-
       super
-    end
 
-    def element(&blck)
-      HTML.render do |h|
-        h.div(style: style.merge(height: "100%"), &blck)
+      @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("root-fonts")
+          @font_updater.inner_html = font_contents
+        when "alert"
+          bind_ok_event
+          @alerts << args[0]
+          @alert_updater ||= Scarpe::Webview::WebWrangler::ElementWrangler.new("root-alerts")
+          @alert_updater.inner_html = alert_contents
+        else
+          raise Scarpe::UnknownBuiltinCommandError, "Unexpected builtin command: #{cmd_name.inspect}!"
+        end
       end
     end
 
-    # Bind a Scarpe callback name; see Scarpe::Widget for how the naming is set up
-    def bind(name, &block)
-      @callbacks[name] = block
+    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
 
-    # All JS callbacks to Scarpe widgets are dispatched
-    # via this handler, which is set up in Scarpe::App
-    def handle_callback(name, *args)
-      @callbacks[name].call(*args)
-    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
 
-    # The document root knows when a frame has finished. It registers end-of-frame callbacks and calls them
-    # when requested. It also tracks when a redraw has been requested. Note that often frames will be
-    # very rare if nothing is changing, with seconds or minutes passing in between them.
+      @ok_event_setup_done = true
 
-    def request_redraw!
-      wrangler = WebviewDisplayService.instance.wrangler
-      if wrangler.is_running
-        wrangler.replace(self.to_html)
+      # Done with the alert(s), delete them
+      bind("OK") do
+        @alerts = []
+        needs_update!
       end
     end
 
-    # The document root manages the connection between widgets and the WebviewWrangler.
-    # By centralising this and wrapping in API functions, we can keep from executing
-    # random Javascript, mostly.
+    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
 
-    # A Widget can request one or more of these as insertion points in the DOM
-    def get_element_wrangler(html_id)
-      Scarpe::WebWrangler::ElementWrangler.new(html_id)
+    def alert_contents
+      @alerts.map do |alert_text|
+        render("alert", { "text" => alert_text, "event_name" => "OK" })
+      end.join + " "
     end
   end
 end