opal-browser 0.1.0.beta1

data/opal/browser/dom/event/base.rb

@@ -0,0 +1,207 @@
+module Browser; module DOM
+
+class Event
+  include Native
+
+  class Definition
+    include Native
+
+    def self.new(&block)
+      data = super(`{}`)
+      block.call(data) if block
+
+      data.to_n
+    end
+
+    def bubbles!
+      `#@native.bubbles = true`
+    end
+
+    def cancelable!
+      `#@native.cancelable = true`
+    end
+  end
+
+  module Target
+    def self.converters
+      @converters ||= []
+    end
+
+    def self.register(&block)
+      converters << block
+    end
+
+    def self.convert(value)
+      return value unless native?(value)
+
+      converters.each {|block|
+        if result = block.call(value)
+          return result
+        end
+      }
+
+      nil
+    end
+
+    def self.included(klass)
+      klass.instance_eval {
+        def self.target(&block)
+          DOM::Event::Target.register(&block)
+        end
+      }
+    end
+
+    class Callback
+      attr_reader :target, :name, :selector
+
+      def initialize(target, name, selector = nil, &block)
+        %x{
+          callback = #{self};
+          func     = function(event) {
+            event = #{::Browser::DOM::Event.new(`event`, `callback`)};
+
+            if (!#{`event`.stopped?}) {
+              #{block.call(`event`, *`event`.arguments)};
+            }
+
+            return !#{`event`.stopped?};
+          }
+        }
+
+        @function = `func`
+        @target   = target
+        @name     = name
+        @selector = selector
+      end
+
+      def off
+        target.off(self)
+      end
+
+      def to_n
+        @function
+      end
+    end
+
+    def on(name, selector = nil, &block)
+      raise ArgumentError, 'no block has been passed' unless block
+
+      name     = Event.name_for(name)
+      callback = Callback.new(self, name, selector, &block)
+
+      callbacks.push(callback)
+
+      if selector
+        observe
+        deferred << [name, selector, block]
+
+        css(selector).on(name, &block)
+      else
+        `#@native.addEventListener(#{name}, #{callback.to_n})`
+      end
+
+      callback
+    end
+
+    def off(what = nil)
+      case what
+      when Callback
+        callbacks.delete(what)
+
+        `#@native.removeEventListener(#{what.name}, #{what.to_n}, false)`
+
+      when String
+        if what.include?(?*) or what.include?(??)
+          off(Regexp.new(what.gsub(/\*/, '.*?').gsub(/\?/, ?.)))
+        else
+          what = Event.name_for(what)
+
+          callbacks.delete_if {|callback|
+            if callback.name == what
+              `#@native.removeEventListener(#{callback.name}, #{callback.to_n}, false)`
+
+              true
+            end
+          }
+        end
+
+      when Regexp
+        callbacks.delete_if {|callback|
+          if callback.name =~ what
+            `#@native.removeEventListener(#{callback.name}, #{callback.to_n}, false)`
+
+            true
+          end
+        }
+
+      else
+        callbacks.each {|callback|
+          `#@native.removeEventListener(#{callback.name}, #{callback.to_n}, false)`
+        }
+
+        callbacks.clear
+      end
+    end
+
+    def trigger(event, *args, &block)
+      if event.is_a? String
+        event = Event.create(event, *args, &block)
+      end
+
+      `#@native.dispatchEvent(#{event.to_n})`
+    end
+
+  private
+    def callbacks
+      %x{
+        if (!#@native.$callbacks) {
+          #@native.$callbacks = [];
+        }
+
+        return #@native.$callbacks;
+      }
+    end
+
+    def observe
+      %x{
+        if (!#@native.$observer) {
+          #@native.$observer = #{MutationObserver.new {|mutations|
+            mutations.each {|mutation|
+              mutation.added.each {|node|
+                next unless Element === node
+
+                defer(node)
+              }
+            }
+          }};
+
+          #{`#@native.$observer`.observe(@native, children: true, tree: true)}
+        }
+      }
+    end
+
+    def deferred
+      %x{
+        if (!#@native.$deferred) {
+          #@native.$deferred = [];
+        }
+
+        return #@native.$deferred;
+      }
+    end
+
+    def defer(node)
+      deferred.each {|name, selector, block|
+        if node.matches?(selector)
+          node.on(name, &block)
+        end
+
+        node.elements.each {|el|
+          defer(el)
+        }
+      }
+    end
+  end
+end
+
+end; end

data/opal/browser/dom/event/before_unload.rb

@@ -0,0 +1,13 @@
+module Browser; module DOM; class Event
+
+class BeforeUnload < Event
+  def self.supported?
+    not $$[:BeforeUnloadEvent].nil?
+  end
+
+  def self.create(name, &block)
+    new(`new BeforeUnloadEvent(#{name}, #{Definition.new(&block)})`)
+  end
+end
+
+end; end; end

data/opal/browser/dom/event/clipboard.rb

@@ -0,0 +1,26 @@
+module Browser; module DOM; class Event
+
+class Clipboard < Event
+  def self.supported?
+    not $$[:ClipboardEvent].nil?
+  end
+
+  class Definition < Definition
+    def data=(value)
+      `#@native.data = #{value}`
+    end
+
+    def type=(value)
+      `#@native.dataType = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new ClipboardEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :data
+  alias_native :type, :dataType
+end
+
+end; end; end

data/opal/browser/dom/event/close.rb

@@ -0,0 +1,35 @@
+module Browser; module DOM; class Event
+
+class Close < Event
+  def self.supported?
+    not $$[:CloseEvent].nil?
+  end
+
+  class Definition < Definition
+    def code=(value)
+      `#@native.code = #{value}`
+    end
+
+    def reason=(value)
+      `#@native.reason = #{value}`
+    end
+
+    def clean!(value)
+      `#@native.wasClean = true`
+    end
+
+    def not_clean!(value)
+      `#@native.wasClean = false`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new CloseEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :code
+  alias_native :reason
+  alias_native :clean?, :wasClean
+end
+
+end; end; end

data/opal/browser/dom/event/composition.rb

@@ -0,0 +1,38 @@
+module Browser; module DOM; class Event
+
+class Composition < UI
+  def self.supported?
+    not $$[:CompositionEvent].nil?
+  end
+
+  class Definition < UI::Definition
+    def data=(value)
+      `#@native.data = #{value}`
+    end
+
+    def locale=(value)
+      `#@native.locale = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new CompositionEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :data
+  alias_native :locale
+
+  def start?
+    name.downcase == 'compositionstart'
+  end
+
+  def update?
+    name.downcase == 'compositionupdate'
+  end
+
+  def end?
+    name.downcase == 'compositionend'
+  end
+end
+
+end; end; end

data/opal/browser/dom/event/custom.rb

@@ -0,0 +1,30 @@
+require 'ostruct'
+
+module Browser; module DOM; class Event
+
+class Custom < Event
+  def self.supported?
+    not $$[:CustomEvent].nil?
+  end
+
+  def self.create(name, &block)
+    data = OpenStruct.new
+    block.call(data) if block
+
+    new(`new CustomEvent(#{name}, { detail: #{data.to_n} })`)
+  end
+
+  def initialize(native)
+    super(native); @native = native # TODO: remove this when super is fixed
+
+    @detail = Hash.new(`#{native}.detail`)
+  end
+
+  def method_missing(id, *)
+    return @detail[id] if @detail.has_key?(id)
+
+    super
+  end
+end
+
+end; end; end

data/opal/browser/dom/event/device_light.rb

@@ -0,0 +1,21 @@
+module Browser; module DOM; class Event
+
+class DeviceLight < Event
+  def self.supported?
+    not $$[:DeviceLightEvent].nil?
+  end
+
+  class Definition < Definition
+    def value=(value)
+      `#@native.value = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new DeviceLightEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :value
+end
+
+end; end; end

data/opal/browser/dom/event/device_motion.rb

@@ -0,0 +1,38 @@
+module Browser; module DOM; class Event
+
+class DeviceMotion < Event
+  def self.supported?
+    not $$[:DeviceMotionEvent].nil?
+  end
+
+  Acceleration = Struct.new(:x, :y, :z)
+
+  class Definition < Definition
+    def acceleration=(value)
+      `#@native.acceleration = #{value.to_n}`
+    end
+
+    def acceleration_with_gravity=(value)
+      `#@native.accelerationIncludingGravity = #{value.to_n}`
+    end
+
+    def rotation=(value)
+      `#@native.rotationRate = #{value}`
+    end
+
+    def interval=(value)
+      `#@native.interval = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new DeviceMotionEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :acceleration
+  alias_native :acceleration_with_gravity, :accelerationIncludingGravity
+  alias_native :rotation, :rotationRate
+  alias_native :interval
+end
+
+end; end; end

data/opal/browser/dom/event/device_orientation.rb

@@ -0,0 +1,36 @@
+module Browser; module DOM; class Event
+
+class DeviceOrientation < Event
+  def self.supported?
+    not $$[:DeviceOrientationEvent].nil?
+  end
+
+  class Definition < Definition
+    def absolute=(value)
+      `#@native.absolute = #{value}`
+    end
+
+    def alpha=(value)
+      `#@native.alpha = #{value}`
+    end
+
+    def beta=(value)
+      `#@native.beta = #{value}`
+    end
+
+    def gamma=(value)
+      `#@native.gamma = #{value}`
+    end
+  end
+
+  def self.create(name, &block)
+    new(`new DeviceOrientationEvent(#{name}, #{Definition.new(&block)})`)
+  end
+
+  alias_native :absolute
+  alias_native :alpha
+  alias_native :beta
+  alias_native :gamma
+end
+
+end; end; end