opal-browser 0.1.0.beta1 → 0.2.0.beta1

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

@@ -2,7 +2,7 @@ module Browser; module DOM; class Event
 
 class Animation < Event
   def self.supported?
-    not $$[:AnimationEvent].nil?
+    Browser.supports? 'Event.Animation'
   end
 
   class Definition < Definition
@@ -15,9 +15,21 @@ class Animation < Event
     end
   end
 
-  def self.create(name, &block)
-    new(`new AnimationEvent(#{name}, #{Definition.new(&block)})`)
-  end
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new AnimationEvent(#{name}, #{desc})`
+    end
+  elsif Browser.supports? 'Event.create'
+    def self.construct(name, desc)
+      %x{
+        var event = document.createEvent("AnimationEvent");
+            event.initAnimationEvent(name, desc.bubbles, desc.cancelable,
+              desc.animationName, desc.elapsedTime);
+
+        return event;
+      }
+    end
+  end if supported?
 
   alias_native :name, :animationName
   alias_native :elapsed, :elapsedTime

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

@@ -2,7 +2,7 @@ module Browser; module DOM; class Event
 
 class AudioProcessing < Event
   def self.supported?
-    not $$[:AudioProcessingEvent].nil?
+    Browser.supports? 'Event.AudioProcessing'
   end
 
   class Definition < Definition
@@ -19,9 +19,11 @@ class AudioProcessing < Event
     end
   end
 
-  def self.create(name, &block)
-    new(`new AudioProcessingEvent(#{name}, #{Definition.new(&block)})`)
-  end
+  if Browser.supports? 'Event.constructor'
+    def self.construct(name, desc)
+      `new AudioProcessingEvent(#{name}, #{desc})`
+    end
+  end if supported?
 
   alias_native :time, :playbackTime
   alias_native :input, :inputBuffer

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

@@ -7,30 +7,33 @@ class Event
     include Native
 
     def self.new(&block)
-      data = super(`{}`)
+      data = super(`{ bubbles: true, cancelable: true }`)
       block.call(data) if block
 
       data.to_n
     end
 
-    def bubbles!
-      `#@native.bubbles = true`
+    def bubbles=(value)
+      `#@native.bubbles = #{value}`
     end
 
-    def cancelable!
-      `#@native.cancelable = true`
+    def cancelable=(value)
+      `#@native.cancelable = #{value}`
     end
   end
 
   module Target
+    # @private
     def self.converters
       @converters ||= []
     end
 
+    # @private
     def self.register(&block)
       converters << block
     end
 
+    # @private
     def self.convert(value)
       return value unless native?(value)
 
@@ -55,60 +58,183 @@ class Event
       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`)};
+        @target   = target
+        @name     = name
+        @selector = selector
+        @block    = block
+      end
 
-            if (!#{`event`.stopped?}) {
-              #{block.call(`event`, *`event`.arguments)};
-            }
+      def call(e)
+        to_proc.call(e)
+      end
 
-            return !#{`event`.stopped?};
+      def to_proc
+        @proc ||= -> event {
+          %x{
+            if (!event.currentTarget) {
+              event.currentTarget = self.target.native;
+            }
           }
+
+          event = Event.new(event, self)
+
+          unless event.stopped?
+            @block.call(event, *event.arguments)
+          end
+
+          !event.prevented?
         }
+      end
 
-        @function = `func`
-        @target   = target
-        @name     = name
-        @selector = selector
+      def event
+        Event.class_for(@name)
       end
 
       def off
         target.off(self)
       end
+    end
 
-      def to_n
-        @function
+    class Delegate
+      def initialize(target, name, pair)
+        @target = target
+        @name   = name
+        @pair   = pair
+      end
+
+      def off
+        delegate = @target.delegated[@name]
+        delegate.last.delete(@pair)
+
+        if delegate.last.empty?
+          delegate.first.off
+          delegate.delete(@name)
+        end
       end
     end
 
-    def on(name, selector = nil, &block)
-      raise ArgumentError, 'no block has been passed' unless block
+    Delegates = Struct.new(:callback, :handlers)
 
-      name     = Event.name_for(name)
-      callback = Callback.new(self, name, selector, &block)
+    def on(name, selector = nil, &block)
+      raise ArgumentError, 'no block has been given' unless block
 
-      callbacks.push(callback)
+      name = Event.name_for(name)
 
       if selector
-        observe
-        deferred << [name, selector, block]
+        unless delegate = delegated[name]
+          delegate = delegated[name] = Delegates.new
+
+          if %w[blur focus].include?(name)
+            delegate.callback = on! name do |e|
+              delegate(delegate, e)
+            end
+          else
+            delegate.callback = on name do |e|
+              delegate(delegate, e)
+            end
+          end
 
-        css(selector).on(name, &block)
+          pair = [selector, block]
+          delegate.handlers = [pair]
+
+          Delegate.new(self, name, pair)
+        else
+          pair = [selector, block]
+          delegate.handlers << pair
+
+          Delegate.new(self, name, pair)
+        end
       else
-        `#@native.addEventListener(#{name}, #{callback.to_n})`
+        callback = Callback.new(self, name, selector, &block)
+        callbacks.push(callback)
+
+        attach(callback)
+      end
+    end
+
+    def on!(name, &block)
+      raise ArgumentError, 'no block has been given' unless block
+
+      name     = Event.name_for(name)
+      callback = Callback.new(self, name, &block)
+      callbacks.push(callback)
+
+      attach!(callback)
+    end
+
+    if Browser.supports? 'Event.addListener'
+      def attach(callback)
+        `#@native.addEventListener(#{callback.name}, #{callback.to_proc})`
+
+        callback
+      end
+
+      def attach!(callback)
+        `#@native.addEventListener(#{callback.name}, #{callback.to_proc}, true)`
+
+        callback
+      end
+    elsif Browser.supports? 'Event.attach'
+      def attach(callback)
+        if callback.event == Custom
+          %x{
+            if (!#@native.$custom) {
+              #@native.$custom = function(event) {
+                for (var i = 0, length = #@native.$callbacks.length; i < length; i++) {
+                  var callback = #@native.$callbacks[i];
+
+                  if (#{`callback`.event == Custom}) {
+                    event.type = callback.name;
+
+                    #{`callback`.call(`event`)};
+                  }
+                }
+              };
+
+              #@native.attachEvent("ondataavailable", #@native.$custom);
+            }
+          }
+        else
+          `#@native.attachEvent("on" + #{callback.name}, #{callback.to_proc})`
+        end
+
+        callback
       end
 
-      callback
+      def attach!(callback)
+        case callback.name
+        when :blur
+          `#@native.attachEvent("onfocusout", #{callback.to_proc})`
+
+        when :focus
+          `#@native.attachEvent("onfocusin", #{callback.to_proc})`
+
+        else
+          warn "attach: capture doesn't work on this browser"
+          attach(callback)
+        end
+
+        callback
+      end
+    else
+      # @todo implement polyfill
+      # @private
+      def attach(*)
+        raise NotImplementedError
+      end
+
+      # @todo implement polyfill
+      # @private
+      def attach!(*)
+        raise NotImplementedError
+      end
     end
 
     def off(what = nil)
       case what
       when Callback
         callbacks.delete(what)
-
-        `#@native.removeEventListener(#{what.name}, #{what.to_n}, false)`
+        detach(what)
 
       when String
         if what.include?(?*) or what.include?(??)
@@ -118,7 +244,7 @@ class Event
 
           callbacks.delete_if {|callback|
             if callback.name == what
-              `#@native.removeEventListener(#{callback.name}, #{callback.to_n}, false)`
+              detach(callback)
 
               true
             end
@@ -128,7 +254,7 @@ class Event
       when Regexp
         callbacks.delete_if {|callback|
           if callback.name =~ what
-            `#@native.removeEventListener(#{callback.name}, #{callback.to_n}, false)`
+            detach(callback)
 
             true
           end
@@ -136,19 +262,73 @@ class Event
 
       else
         callbacks.each {|callback|
-          `#@native.removeEventListener(#{callback.name}, #{callback.to_n}, false)`
+          detach(callback)
         }
 
         callbacks.clear
       end
     end
 
+    if Browser.supports? 'Event.removeListener'
+      def detach(callback)
+        `#@native.removeEventListener(#{callback.name}, #{callback.to_proc}, false)`
+      end
+    elsif Browser.supports? 'Event.detach'
+      def detach(callback)
+        if callback.event == Custom
+          if callbacks.none? { |c| c.event == Custom }
+            %x{
+              #@native.detachEvent("ondataavailable", #@native.$custom);
+
+              delete #@native.$custom;
+            }
+          end
+        else
+          `#@native.detachEvent("on" + #{callback.name}, #{callback.to_proc})`
+        end
+      end
+    else
+      # @todo implement internal handler thing
+      # @private
+      def detach(callback)
+        raise NotImplementedError
+      end
+    end
+
     def trigger(event, *args, &block)
       if event.is_a? String
         event = Event.create(event, *args, &block)
       end
 
-      `#@native.dispatchEvent(#{event.to_n})`
+      dispatch(event)
+    end
+
+    # Trigger the event without bubbling.
+    def trigger!(event, *args, &block)
+      trigger event, *args do |e|
+        block.call(e) if block
+        e.bubbles = false
+      end
+    end
+
+    if Browser.supports? 'Event.dispatch'
+      def dispatch(event)
+        `#@native.dispatchEvent(#{event.to_n})`
+      end
+    elsif Browser.supports? 'Event.fire'
+      def dispatch(event)
+        if Custom === event
+          `#@native.fireEvent("ondataavailable", #{event.to_n})`
+        else
+          `#@native.fireEvent("on" + #{event.name}, #{event.to_n})`
+        end
+      end
+    else
+      # @todo implement polyfill
+      # @private
+      def dispatch(*)
+        raise NotImplementedError
+      end
     end
 
   private
@@ -162,44 +342,29 @@ class Event
       }
     end
 
-    def observe
+    def delegated
       %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)}
+        if (!#@native.$delegated) {
+          #@native.$delegated = #{{}};
         }
+
+        return #@native.$delegated;
       }
     end
 
-    def deferred
-      %x{
-        if (!#@native.$deferred) {
-          #@native.$deferred = [];
-        }
+    def delegate(delegates, event, element = event.target)
+      return if element.nil? || element == event.on
 
-        return #@native.$deferred;
-      }
-    end
+      delegates.handlers.each {|selector, block|
+        if element.matches? selector
+          new    = event.dup
+          new.on = element
 
-    def defer(node)
-      deferred.each {|name, selector, block|
-        if node.matches?(selector)
-          node.on(name, &block)
+          block.call new, *new.arguments
         end
-
-        node.elements.each {|el|
-          defer(el)
-        }
       }
+
+      delegate(delegates, event, element.parent)
     end
   end
 end