glimmer-dsl-opal 0.26.2 → 0.28.1

data/lib/glimmer/swt/display_proxy.rb

@@ -4,22 +4,6 @@ require 'glimmer/swt/swt_proxy'
 module Glimmer
   module SWT
     class DisplayProxy < WidgetProxy
-      JS_KEY_CODE_TO_SWT_KEY_CODE_MAP = {
-        16 => SWTProxy[:shift],
-        17 => SWTProxy[:ctrl],
-        18 => SWTProxy[:alt],
-        37 => SWTProxy[:arrow_left],
-        38 => SWTProxy[:arrow_up],
-        39 => SWTProxy[:arrow_right],
-        40 => SWTProxy[:arrow_down],
-      }
-      
-      JS_LOCATION_TO_SWT_KEY_LOCATION_MAP = {
-        1 => SWTProxy[:left],
-        2 => SWTProxy[:right],
-      }
-      
-    
       class << self
         def instance
           @instance ||= new
@@ -102,99 +86,6 @@ module Glimmer
       # sync_exec kept for API compatibility reasons
       alias sync_exec async_exec
       
-      def observation_request_to_event_mapping
-        {
-          'on_swt_keydown' => [
-            {
-              event: 'keypress',
-              event_handler: -> (event_listener) {
-                -> (event) {
-                  event.singleton_class.define_method(:character) do
-                    which || key_code
-                  end
-                  event.define_singleton_method(:keyCode) {
-                    JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
-                  }
-                  event.define_singleton_method(:key_code, &event.method(:keyCode))
-                  event.define_singleton_method(:character) {event.which.chr}
-                  event.define_singleton_method(:stateMask) do
-                    state_mask = 0
-                    state_mask |= SWTProxy[:alt] if event.alt_key
-                    state_mask |= SWTProxy[:ctrl] if event.ctrl_key
-                    state_mask |= SWTProxy[:shift] if event.shift_key
-                    state_mask |= SWTProxy[:command] if event.meta_key
-                    state_mask
-                  end
-                  event.define_singleton_method(:state_mask, &event.method(:stateMask))
-                  doit = true
-                  event.define_singleton_method(:doit=) do |value|
-                    doit = value
-                  end
-                  event.define_singleton_method(:doit) { doit }
-                  event_listener.call(event)
-                  
-                    # TODO Fix doit false, it's not stopping input
-                  unless doit
-                    event.prevent
-                    event.prevent_default
-                    event.stop_propagation
-                    event.stop_immediate_propagation
-                  end
-                  
-                  doit
-                }
-              }
-            },
-            {
-              event: 'keydown',
-              event_handler: -> (event_listener) {
-                -> (event) {
-                  original_event = event
-                  event = ::Event.new(event)
-                  event.define_singleton_method(:keyLocation) do
-                    key_location = `#{original_event}.location`
-                    JS_LOCATION_TO_SWT_KEY_LOCATION_MAP[key_location]
-                  end
-                  event.define_singleton_method(:key_location, &event.method(:keyLocation))
-                  event.define_singleton_method(:character) do
-                    which || key_code
-                  end
-                  event.define_singleton_method(:keyCode) {
-                    JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
-                  }
-                  event.define_singleton_method(:key_code, &event.method(:keyCode))
-                  event.define_singleton_method(:character) {event.which.chr}
-                  event.define_singleton_method(:stateMask) do
-                    state_mask = 0
-                    state_mask |= SWTProxy[:alt] if event.alt_key
-                    state_mask |= SWTProxy[:ctrl] if event.ctrl_key
-                    state_mask |= SWTProxy[:shift] if event.shift_key
-                    state_mask |= SWTProxy[:command] if event.meta_key
-                    state_mask
-                  end
-                  event.define_singleton_method(:state_mask, &event.method(:stateMask))
-                  doit = true
-                  event.define_singleton_method(:doit=) do |value|
-                    doit = value
-                  end
-                  event.define_singleton_method(:doit) { doit }
-                  event_listener.call(event) if event.which != 13 && (event.which == 127 || event.which <= 40)
-                  
-                    # TODO Fix doit false, it's not stopping input
-                  unless doit
-                    event.prevent
-                    event.prevent_default
-                    event.stop_propagation
-                    event.stop_immediate_propagation
-                  end
-                  doit
-                }
-              }
-            }
-          ]
-        }
-      end
-      
       private
       
       def async_exec_queues

data/lib/glimmer/swt/point.rb

@@ -1,5 +1,7 @@
 module Glimmer
   module SWT
+    # emulating org.eclipse.swt.graphics.Point
     Point = Struct.new(:x, :y)
+    # TODO alias as org.eclipse.swt.graphics.Point
   end
 end

data/lib/glimmer/swt/rectangle.rb

@@ -0,0 +1,7 @@
+module Glimmer
+  module SWT
+    # emulating org.eclipse.swt.graphics.Rectangle
+    Rectangle = Struct.new(:x, :y, :width, :height)
+    # TODO alias as org.eclipse.swt.graphics.Rectangle
+  end
+end

data/lib/glimmer/swt/spinner_proxy.rb

@@ -153,45 +153,6 @@ module Glimmer
               }
             }
           },
-          'on_key_pressed' => {
-            event: 'keydown',
-            event_handler: -> (event_listener) {
-              -> (event) {
-                @last_key_pressed_event = event
-                self.text = event.target.value
-                # TODO generalize this solution to all widgets that support key presses
-                # TODO support event.location once DOM3 is supported by opal-jquery
-                event.define_singleton_method(:keyCode) {event.which}
-                event.define_singleton_method(:key_code, &event.method(:keyCode))
-                event.define_singleton_method(:character) {event.which.chr}
-                event.define_singleton_method(:stateMask) do
-                  state_mask = 0
-                  state_mask |= SWTProxy[:alt] if event.alt_key
-                  state_mask |= SWTProxy[:ctrl] if event.ctrl_key
-                  state_mask |= SWTProxy[:shift] if event.shift_key
-                  state_mask |= SWTProxy[:command] if event.meta_key
-                  state_mask
-                end
-                event.define_singleton_method(:state_mask, &event.method(:stateMask))
-                doit = true
-                event.define_singleton_method(:doit=) do |value|
-                  doit = value
-                end
-                event.define_singleton_method(:doit) { doit }
-                event_listener.call(event)
-                
-                  # TODO Fix doit false, it's not stopping input
-                unless doit
-                  event.prevent
-                  event.prevent_default
-                  event.stop_propagation
-                  event.stop_immediate_propagation
-                end
-                
-                doit
-              }
-            }
-          },
         }
       end
       

data/lib/glimmer/swt/text_proxy.rb

@@ -3,7 +3,26 @@ require 'glimmer/swt/widget_proxy'
 module Glimmer
   module SWT
     class TextProxy < WidgetProxy
-      attr_reader :text
+      attr_reader :text, :border, :left, :center, :right, :read_only, :wrap, :multi
+      alias border? border
+      alias left? left
+      alias center? center
+      alias right? right
+      alias read_only? read_only
+      alias wrap? wrap
+      alias multi? multi
+      
+      def initialize(parent, args, block)
+        args << :border if args.empty?
+        @border = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:border] }
+        @left = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:left] }
+        @center = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:center] }
+        @right = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:right] }
+        @read_only = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:read_only] }
+        @wrap = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:wrap] }
+        @multi = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:multi] }
+        super(parent, args, block)
+      end
 
       def text=(value)
         @text = value
@@ -11,81 +30,86 @@ module Glimmer
       end
       
       def element
-        'input'
+        @wrap || @multi ? 'textarea' : 'input'
       end
       
       def observation_request_to_event_mapping
+        myself = self
         {
-          'on_modify_text' => {
-            event: 'keyup',
-            event_handler: -> (event_listener) {
-              -> (event) {
-                # TODO consider unifying this event handler with on_key_pressed by relying on its result instead of hooking another keyup event
-                if @last_key_pressed_event.nil? || @last_key_pressed_event.doit
-                  @text = event.target.value
+          'on_verify_text' => [
+            {
+              event: 'beforeinput',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  event.define_singleton_method(:widget) {myself}
+                  event.define_singleton_method(:text) {`#{event.to_n}.originalEvent.data` || ''}
+                  selection_start = `#{event.target}[0].selectionStart`
+                  selection_end = `#{event.target}[0].selectionEnd`
+                  if `#{event.to_n}.originalEvent.inputType` == 'deleteContentBackward' && selection_start == selection_end
+                    selection_start -= 1
+                    selection_start = 0 if selection_start < 0
+                  end
+                  event.define_singleton_method(:start) do
+                    selection_start
+                  end
+                  event.define_singleton_method(:end) {selection_end}
+                  doit = true
+                  event.define_singleton_method(:doit=) do |value|
+                    doit = value
+                  end
+                  event.define_singleton_method(:doit) { doit }
                   event_listener.call(event)
-                else
-                  # TODO Fix doit false, it's not stopping input
-                  event.prevent
-                  event.prevent_default
-                  event.stop_propagation
-                  event.stop_immediate_propagation
-                end
+                  
+                  if !doit
+                    `#{event.to_n}.originalEvent.returnValue = false`
+                  end
+                  
+                  doit
+                }
+              }
+            },
+            {
+              event: 'input',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  event.define_singleton_method(:widget) {myself}
+                  @text = event.target.value
+                }
               }
             }
-          },
-          'on_key_pressed' => {
-            event: 'keydown',
-            event_handler: -> (event_listener) {
-              -> (event) {
-                @last_key_pressed_event = event
-                @text = event.target.value
-                # TODO generalize this solution to all widgets that support key presses
-                # TODO support event.location once DOM3 is supported by opal-jquery
-                event.define_singleton_method(:keyCode) {event.which}
-                event.define_singleton_method(:key_code, &event.method(:keyCode))
-                event.define_singleton_method(:character) {event.which.chr}
-                event.define_singleton_method(:stateMask) do
-                  state_mask = 0
-                  state_mask |= SWTProxy[:alt] if event.alt_key
-                  state_mask |= SWTProxy[:ctrl] if event.ctrl_key
-                  state_mask |= SWTProxy[:shift] if event.shift_key
-                  state_mask |= SWTProxy[:command] if event.meta_key
-                  state_mask
-                end
-                event.define_singleton_method(:state_mask, &event.method(:stateMask))
-                doit = true
-                event.define_singleton_method(:doit=) do |value|
-                  doit = value
-                end
-                event.define_singleton_method(:doit) { doit }
-                event_listener.call(event)
-                
-                  # TODO Fix doit false, it's not stopping input
-                unless doit
-                  event.prevent
-                  event.prevent_default
-                  event.stop_propagation
-                  event.stop_immediate_propagation
-                end
-                
-                doit
+          ],
+          'on_modify_text' => [
+            {
+              event: 'input',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  # TODO add all attributes for on_modify_text modify event
+                  event.define_singleton_method(:widget) {myself}
+                  @text = event.target.value
+                  event_listener.call(event)
+                }
               }
             }
-          },
+          ],
         }
       end
       
       def dom
         text_text = @text
         text_id = id
-        text_style = css
+        text_style = 'min-width: 27px; '
+        text_style += 'border: none; ' if !@border
+        text_style += 'text-align: left; ' if @left
+        text_style += 'text-align: center; ' if @center
+        text_style += 'text-align: right; ' if @right
         text_class = name
-        options = {type: 'text', id: text_id, style: text_style, class: text_class, value: text_text, style: 'min-width: 27px;'}
+        options = {type: 'text', id: text_id, style: text_style, class: text_class, value: text_text}
         options = options.merge('disabled': 'disabled') unless @enabled
+        options = options.merge('readonly': 'readonly') if @read_only
+        options = options.merge('contenteditable': 'true')
         options = options.merge(type: 'password') if has_style?(:password)
         @dom ||= html {
-          input(options)
+          send(element, options)
         }.to_s
       end
     end

data/lib/glimmer/swt/widget_proxy.rb

@@ -30,9 +30,26 @@ module Glimmer
     class WidgetProxy
       include Glimmer
       include PropertyOwner
-      
+            
       Event = Struct.new(:widget, keyword_init: true)
+    
+      JS_KEY_CODE_TO_SWT_KEY_CODE_MAP = {
+        16 => SWTProxy[:shift],
+        17 => SWTProxy[:ctrl],
+        18 => SWTProxy[:alt],
+        37 => SWTProxy[:arrow_left],
+        38 => SWTProxy[:arrow_up],
+        39 => SWTProxy[:arrow_right],
+        40 => SWTProxy[:arrow_down],
+      }
       
+      JS_LOCATION_TO_SWT_KEY_LOCATION_MAP = {
+        0 => SWTProxy[:none],
+        1 => SWTProxy[:left],
+        2 => SWTProxy[:right],
+        3 => SWTProxy[:keypad],
+      }
+            
       SWT_CURSOR_TO_CSS_CURSOR_MAP = {
         wait: 'wait',
         sizenwse: 'nwse-resize',
@@ -141,7 +158,7 @@ module Glimmer
         @block = block
         # TODO consider changing children to an array (why is it a Set if order matters?)
         @children = Set.new # TODO consider moving to composite
-        @enabled = true
+        @enabled = true if @enabled.nil?
         DEFAULT_INITIALIZERS[self.class.underscored_widget_name(self).to_s.to_sym]&.call(self)
         @parent.post_initialize_child(self) # TODO rename to post_initialize_child to be closer to glimmer-dsl-swt terminology
       end
@@ -314,9 +331,10 @@ module Glimmer
         brand_new = @dom.nil? || old_element.empty? || brand_new
         build_dom(layout: !custom_parent_dom_element) # TODO handle custom parent layout by passing parent instead of parent dom element
         if brand_new
-          the_parent_dom_element.append(@dom) # TODO make a method attach to allow subclasses to override if needed
+          # TODO make a method attach to allow subclasses to override if needed
+          attach(the_parent_dom_element)
         else
-          old_element.replace_with(@dom)
+          reattach(old_element)
         end
         observation_requests&.each do |keyword, event_listener_set|
           event_listener_set.each do |event_listener|
@@ -330,6 +348,14 @@ module Glimmer
         content_on_render_blocks.each { |content_block| content(&content_block) } unless skip_content_on_render_blocks?
       end
       alias redraw render
+        
+      def attach(the_parent_dom_element)
+        the_parent_dom_element.append(@dom)
+      end
+        
+      def reattach(old_element)
+        old_element.replace_with(@dom)
+      end
       
       def content_on_render_blocks
         @content_on_render_blocks ||= []
@@ -350,7 +376,7 @@ module Glimmer
       def build_dom(layout: true)
         # TODO consider passing parent element instead and having table item include a table cell widget only for opal
         @dom = nil
-        @dom = dom
+        @dom = dom # TODO unify how to build dom for most widgets based on element, id, and name (class)
         @dom = @parent.get_layout.dom(@dom) if @parent.respond_to?(:layout) && @parent.get_layout
         @dom
       end
@@ -373,7 +399,6 @@ module Glimmer
         mouse_event_handler = -> (event_listener) {
           -> (event) {
             # TODO generalize this solution to all widgets that support key presses
-            # TODO support event.location once DOM3 is supported by opal-jquery
             event.define_singleton_method(:widget) {myself}
             event.define_singleton_method(:button, &event.method(:which))
             event.define_singleton_method(:count) {1} # TODO support double-click count of 2 in the future by using ondblclick
@@ -401,7 +426,6 @@ module Glimmer
         mouse_move_event_handler = -> (event_listener) {
           -> (event) {
             # TODO generalize this solution to all widgets that support key presses
-            # TODO support event.location once DOM3 is supported by opal-jquery
             event.define_singleton_method(:widget) {myself}
             event.define_singleton_method(:button, &event.method(:which))
             event.define_singleton_method(:count) {1} # TODO support double-click count of 2 in the future by using ondblclick
@@ -426,7 +450,6 @@ module Glimmer
         context_menu_handler = -> (event_listener) {
           -> (event) {
             # TODO generalize this solution to all widgets that support key presses
-            # TODO support event.location once DOM3 is supported by opal-jquery
             event.define_singleton_method(:widget) {myself}
             event.define_singleton_method(:button, &event.method(:which))
             event.define_singleton_method(:count) {1} # TODO support double-click count of 2 in the future by using ondblclick
@@ -507,10 +530,15 @@ module Glimmer
             event: 'keypress',
             event_handler: -> (event_listener) {
               -> (event) {
-                # TODO generalize this solution to all widgets that support key presses
-                # TODO support event.location once DOM3 is supported by opal-jquery
                 event.define_singleton_method(:widget) {myself}
-                event.define_singleton_method(:keyCode) {event.which}
+                event.define_singleton_method(:keyLocation) do
+                  location = `#{event.to_n}.originalEvent.location`
+                  JS_LOCATION_TO_SWT_KEY_LOCATION_MAP[location] || location
+                end
+                event.define_singleton_method(:key_location, &event.method(:keyLocation))
+                event.define_singleton_method(:keyCode) {
+                  JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
+                }
                 event.define_singleton_method(:key_code, &event.method(:keyCode))
                 event.define_singleton_method(:character) {event.which.chr}
                 event.define_singleton_method(:stateMask) do
@@ -541,50 +569,18 @@ module Glimmer
               }
             }          },
           'on_key_released' => {
-            event: 'keydown',
+            event: 'keyup',
             event_handler: -> (event_listener) {
               -> (event) {
-                # TODO generalize this solution to all widgets that support key presses
-                # TODO support event.location once DOM3 is supported by opal-jquery
-                event.define_singleton_method(:widget) {myself}
-                event.define_singleton_method(:keyCode) {event.which}
-                event.define_singleton_method(:key_code, &event.method(:keyCode))
-                event.define_singleton_method(:character) {event.which.chr}
-                event.define_singleton_method(:stateMask) do
-                  state_mask = 0
-                  state_mask |= SWTProxy[:alt] if event.alt_key
-                  state_mask |= SWTProxy[:ctrl] if event.ctrl_key
-                  state_mask |= SWTProxy[:shift] if event.shift_key
-                  state_mask |= SWTProxy[:command] if event.meta_key
-                  state_mask
-                end
-                event.define_singleton_method(:state_mask, &event.method(:stateMask))
-                doit = true
-                event.define_singleton_method(:doit=) do |value|
-                  doit = value
-                end
-                event.define_singleton_method(:doit) { doit }
-                event_listener.call(event)
-                
-                  # TODO Fix doit false, it's not stopping input
-                unless doit
-                  event.prevent
-                  event.prevent_default
-                  event.stop_propagation
-                  event.stop_immediate_propagation
+                event.define_singleton_method(:keyLocation) do
+                  location = `#{event.to_n}.originalEvent.location`
+                  JS_LOCATION_TO_SWT_KEY_LOCATION_MAP[location] || location
                 end
-                
-                doit
-              }
-            }          },
-          'on_swt_keydown' => {
-            event: 'keypress',
-            event_handler: -> (event_listener) {
-              -> (event) {
-                # TODO generalize this solution to all widgets that support key presses
-                # TODO support event.location once DOM3 is supported by opal-jquery
+                event.define_singleton_method(:key_location, &event.method(:keyLocation))
                 event.define_singleton_method(:widget) {myself}
-                event.define_singleton_method(:keyCode) {event.which}
+                event.define_singleton_method(:keyCode) {
+                  JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
+                }
                 event.define_singleton_method(:key_code, &event.method(:keyCode))
                 event.define_singleton_method(:character) {event.which.chr}
                 event.define_singleton_method(:stateMask) do
@@ -613,15 +609,108 @@ module Glimmer
                 
                 doit
               }
-            }          },
+            }
+          },
+          'on_swt_keydown' => [
+            {
+              event: 'keypress',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  event.define_singleton_method(:keyLocation) do
+                    location = `#{event.to_n}.originalEvent.location`
+                    JS_LOCATION_TO_SWT_KEY_LOCATION_MAP[location] || location
+                  end
+                  event.define_singleton_method(:key_location, &event.method(:keyLocation))
+                  event.define_singleton_method(:keyCode) {
+                    JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
+                  }
+                  event.define_singleton_method(:key_code, &event.method(:keyCode))
+                  event.define_singleton_method(:widget) {myself}
+                  event.define_singleton_method(:character) {event.which.chr}
+                  event.define_singleton_method(:stateMask) do
+                    state_mask = 0
+                    state_mask |= SWTProxy[:alt] if event.alt_key
+                    state_mask |= SWTProxy[:ctrl] if event.ctrl_key
+                    state_mask |= SWTProxy[:shift] if event.shift_key
+                    state_mask |= SWTProxy[:command] if event.meta_key
+                    state_mask
+                  end
+                  event.define_singleton_method(:state_mask, &event.method(:stateMask))
+                  doit = true
+                  event.define_singleton_method(:doit=) do |value|
+                    doit = value
+                  end
+                  event.define_singleton_method(:doit) { doit }
+                  event_listener.call(event)
+                  
+                    # TODO Fix doit false, it's not stopping input
+                  unless doit
+                    event.prevent
+                    event.prevent_default
+                    event.stop_propagation
+                    event.stop_immediate_propagation
+                  end
+                  
+                  doit
+                }
+              }
+            },
+            {
+              event: 'keydown',
+              event_handler: -> (event_listener) {
+                -> (event) {
+                  event.define_singleton_method(:keyLocation) do
+                    location = `#{event.to_n}.originalEvent.location`
+                    JS_LOCATION_TO_SWT_KEY_LOCATION_MAP[location] || location
+                  end
+                  event.define_singleton_method(:key_location, &event.method(:keyLocation))
+                  event.define_singleton_method(:keyCode) {
+                    JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
+                  }
+                  event.define_singleton_method(:key_code, &event.method(:keyCode))
+                  event.define_singleton_method(:widget) {myself}
+                  event.define_singleton_method(:character) {event.which.chr}
+                  event.define_singleton_method(:stateMask) do
+                    state_mask = 0
+                    state_mask |= SWTProxy[:alt] if event.alt_key
+                    state_mask |= SWTProxy[:ctrl] if event.ctrl_key
+                    state_mask |= SWTProxy[:shift] if event.shift_key
+                    state_mask |= SWTProxy[:command] if event.meta_key
+                    state_mask
+                  end
+                  event.define_singleton_method(:state_mask, &event.method(:stateMask))
+                  doit = true
+                  event.define_singleton_method(:doit=) do |value|
+                    doit = value
+                  end
+                  event.define_singleton_method(:doit) { doit }
+                  event_listener.call(event) if event.which != 13 && (event.which == 127 || event.which <= 40)
+                  
+                    # TODO Fix doit false, it's not stopping input
+                  unless doit
+                    event.prevent
+                    event.prevent_default
+                    event.stop_propagation
+                    event.stop_immediate_propagation
+                  end
+                  doit
+                }
+              }
+            }
+          ],
           'on_swt_keyup' => {
-            event: 'keydown',
+            event: 'keyup',
             event_handler: -> (event_listener) {
               -> (event) {
-                # TODO generalize this solution to all widgets that support key presses
-                # TODO support event.location once DOM3 is supported by opal-jquery
+                event.define_singleton_method(:keyLocation) do
+                  location = `#{event.to_n}.originalEvent.location`
+                  JS_LOCATION_TO_SWT_KEY_LOCATION_MAP[location] || location
+                end
+                event.define_singleton_method(:key_location, &event.method(:keyLocation))
                 event.define_singleton_method(:widget) {myself}
-                event.define_singleton_method(:keyCode) {event.which}
+                event.define_singleton_method(:keyCode) {
+                  JS_KEY_CODE_TO_SWT_KEY_CODE_MAP[event.which] || event.which
+                }
                 event.define_singleton_method(:key_code, &event.method(:keyCode))
                 event.define_singleton_method(:character) {event.which.chr}
                 event.define_singleton_method(:stateMask) do
@@ -800,11 +889,7 @@ module Glimmer
           end
           the_listener_dom_element = event_element_css_selector ? Element[event_element_css_selector] : listener_dom_element
           unless the_listener_dom_element.empty?
-            if is_a?(DisplayProxy) && event == 'keydown'
-              `document.addEventListener('keydown', #{async_event_listener})`
-            else
-              the_listener_dom_element.on(event, &async_event_listener)
-            end
+            the_listener_dom_element.on(event, &async_event_listener)
             # TODO ensure uniqueness of insertion (perhaps adding equals/hash method to event listener proxy)
             
             event_listener_proxies << EventListenerProxy.new(element_proxy: self, selector: selector, dom_element: the_listener_dom_element, event: event, listener: async_event_listener, original_event_listener: original_event_listener)
@@ -1067,6 +1152,7 @@ require 'glimmer/swt/combo_proxy'
 require 'glimmer/swt/c_combo_proxy'
 require 'glimmer/swt/checkbox_proxy'
 require 'glimmer/swt/composite_proxy'
+require 'glimmer/swt/canvas_proxy'
 require 'glimmer/swt/date_time_proxy'
 require 'glimmer/swt/group_proxy'
 require 'glimmer/swt/label_proxy'