scarpe 0.2.2 → 0.4.0

data/lib/scarpe/wv/subscription_item.rb

@@ -1,12 +1,38 @@
 # frozen_string_literal: true
 
-class Scarpe::WebviewSubscriptionItem < Scarpe::WebviewWidget
+class Scarpe::Webview::SubscriptionItem < Scarpe::Webview::Drawable
   def initialize(properties)
     super
 
     bind(@shoes_api_name) do |*args|
       send_self_event(*args, event_name: @shoes_api_name)
     end
+
+    @wrangler = Scarpe::Webview::DisplayService.instance.wrangler
+
+    case @shoes_api_name
+    when "animate"
+      frame_rate = (@args[0] || 10)
+      @counter = 0
+      @wrangler.periodic_code("animate_#{@shoes_linkable_id}", 1.0 / frame_rate) do
+        @counter += 1
+        send_self_event(@counter, event_name: @shoes_api_name)
+      end
+    when "every"
+      delay = @args[0]
+      @counter = 0
+      @wrangler.periodic_code("every_#{@shoes_linkable_id}", delay) do
+        @counter += 1
+        send_self_event(@counter, event_name: @shoes_api_name)
+      end
+    when "timer"
+      # JS setTimeout?
+      raise "Implement me!"
+    when "motion", "hover", "leave", "click", "release", "keypress"
+      # Wait for set_parent
+    else
+      raise Scarpe::UnknownShoesEventAPIError, "Unknown Shoes event API: #{@shoes_api_name}!"
+    end
   end
 
   def element
@@ -21,7 +47,7 @@ class Scarpe::WebviewSubscriptionItem < Scarpe::WebviewWidget
     case @shoes_api_name
     when "motion"
       # TODO: what do we do for whole-screen mousemove outside the window?
-      # Those should be set on body, which right now doesn't have a widget.
+      # Those should be set on body, which right now doesn't have a drawable.
       # TODO: figure out how to handle alt and meta keys - does Shoes3 recognise those?
       new_parent.set_event_callback(
         self,
@@ -36,15 +62,23 @@ class Scarpe::WebviewSubscriptionItem < Scarpe::WebviewWidget
       )
     when "hover"
       new_parent.set_event_callback(self, "onmouseenter", handler_js_code(@shoes_api_name))
+    when "leave"
+      new_parent.set_event_callback(self, "onmouseleave", handler_js_code(@shoes_api_name))
     when "click"
       new_parent.set_event_callback(self, "onclick", handler_js_code(@shoes_api_name, "arguments[0].button", "arguments[0].x", "arguments[0].y"))
+    when "release"
+      new_parent.set_event_callback(self, "onmouseup", handler_js_code(@shoes_api_name, "arguments[0].button", "arguments[0].x", "arguments[0].y"))
+    when "keypress"
+      raise "Implement me!"
+    when "animate", "every", "timer"
+      # These were handled in initialize(), ignore them here
     else
-      raise "Unknown Shoes event API: #{@shoes_api_name}!"
+      raise Scarpe::UnknownShoesEventAPIError, "Unknown Shoes event API: #{@shoes_api_name}!"
     end
   end
 
   def destroy_self
-    @parent.remove_event_callbacks(self)
+    @parent&.remove_event_callbacks(self)
     super
   end
 end

data/lib/scarpe/wv/text_drawable.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# There are different ways to implement these tags. You can change the HTML tag (link,
+# code, strong) or set default values (del for strikethrough.) There's no reason the
+# Shoes tag name has to match the HTML tag (del, link). This can be a little
+# complicated since CSS often sets default values (e.g. del for strikethrough) and
+# Scarpe may use those default values or override them. Long term it may be easier
+# for us to set up our own CSS for this somehow that does *not* use the HTML-tag
+# defaults since the browser can mess with those, and there's no guarantee that
+# Webview uses the same default CSS style across all OSes.
+
+module Scarpe::Webview
+  # This class renders text tags like em, strong, link, etc.
+  class TextDrawable < Drawable
+    # Calzini renders based on properties, mostly Shoes styles.
+    # To have Calzini render this for us, we convert to the format
+    # Calzini expects and then let it render. See Webview::Para
+    # for the specific Calzini call.
+    def to_calzini_hash
+      text_array = items_to_display_children(@text_items).map do |item|
+        if item.respond_to?(:to_calzini_hash)
+          item.to_calzini_hash
+        elsif item.is_a?(String)
+          item
+        else
+          # This should normally be filtered out in Lacci, long before we see it
+          raise "Unrecognized item in TextDrawable! #{item.inspect}"
+        end
+      end
+
+      {
+        items: text_array,
+        html_id: @linkable_id.to_s,
+        tag: nil, # have Calzini assign a default unless a subclass overrides this
+        props: shoes_styles,
+      }
+    end
+
+    def element
+      render("text_drawable", [to_calzini_hash])
+    end
+
+    def items_to_display_children(items)
+      return [] if items.nil?
+
+      items.map do |item|
+        if item.is_a?(String)
+          item
+        else
+          Scarpe::Webview::DisplayService.instance.query_display_drawable_for(item)
+        end
+      end
+    end
+
+    # Usually we query by ID, but for TextDrawable it has to be by class.
+    # That's how needs_update!, etc continue to work.
+    def html_element
+      @elt_wrangler ||= Scarpe::Webview::WebWrangler::ElementWrangler.new(selector: %{document.getElementsByClassName("id_#{html_id}")}, multi: true)
+    end
+  end
+
+  class << self
+    def default_wv_text_drawable_with_tag(shoes_tag, html_tag = nil)
+      html_tag ||= shoes_tag
+      webview_class_name = shoes_tag.capitalize
+      webview_drawable_class = Class.new(Scarpe::Webview::TextDrawable) do
+        class << self
+          attr_accessor :html_tag
+        end
+
+        def to_calzini_hash
+          h = super
+          h[:tag] = self.class.html_tag
+          h
+        end
+      end
+      Scarpe::Webview.const_set webview_class_name, webview_drawable_class
+      webview_drawable_class.html_tag = html_tag
+    end
+  end
+end
+
+Scarpe::Webview.default_wv_text_drawable_with_tag(:code)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:del)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:em)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:strong)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:span)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:sub)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:sup)
+Scarpe::Webview.default_wv_text_drawable_with_tag(:ins, "span") # Styled in Shoes, not CSS

data/lib/scarpe/wv/video.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-class Scarpe
-  class WebviewVideo < Scarpe::WebviewWidget
+module Scarpe::Webview
+  class Video < Drawable
     SUPPORTED_FORMATS = {
       "video/mp4" => [".mp4"],
       "video/webp" => [".webp"],
@@ -9,26 +9,26 @@ class Scarpe
       "video/x-matroska" => [".mkv"],
       # Add more formats and their associated file extensions if needed
     }.freeze
+    FORMAT_FOR_EXT = {}
+    SUPPORTED_FORMATS.each do |format, extensions|
+      extensions.each do |ext|
+        if FORMAT_FOR_EXT.key?(ext)
+          raise "Internal Scarpe-Webview error! Must have a specific format for each extension!"
+        end
+
+        FORMAT_FOR_EXT[ext] = format
+      end
+    end
+    FORMAT_FOR_EXT.freeze
 
     def initialize(properties)
       @url = properties[:url]
       super
+      @format = FORMAT_FOR_EXT[File.extname(@url)]
     end
 
     def element
-      HTML.render do |h|
-        h.video(id: html_id, style: style, controls: true) do
-          supported_formats.each do |format|
-            h.source(src: @url, type: format)
-          end
-        end
-      end
-    end
-
-    private
-
-    def supported_formats
-      SUPPORTED_FORMATS.select { |_format, extensions| extensions.include?(File.extname(@url)) }.keys
+      render "video", shoes_styles.merge("format" => @format)
     end
   end
 end