glimmer-dsl-opal 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0deb6c6d04586f92d01c22a4228072fcfa145359121f33d92265c580fc1abd91
-  data.tar.gz: fc11c74ce51115dc92548debd2bf3a1d590ba638915de71f33455ee62a82c5fb
+  metadata.gz: 885895f5a47d453757426eb0b05e0b413972ef5b11f5c9045c8df92c4c1cd03d
+  data.tar.gz: a33b454cd1229e8b6d640d31f55379875fdde969b3634ef85e524496b277117f
 SHA512:
-  metadata.gz: e7849b84f8ee8c749c69636abbe7490a3ac2585957fa7c526b1a2a322eb40d7d1bfdba66e344c8f1f3b76095fb1a2ed5210ae62c08db093828be823f10fd9e33
-  data.tar.gz: 12125b86cdd30f321311e3909b8f50e4383eb2fea2938b4983d02a5860f0d3a056d50dce9d94abe7a68f557d1c374d998e3fcfb25de90edc1d3b936cc033f1b6
+  metadata.gz: dad2612713d1ebcc95cc08fc0bdaddbb45a9f07032af5e583da857adba54327752f853d8f28bfd76d545c7271e9be86e825d42d600c798775328864e8d651927
+  data.tar.gz: 037c3e6f77c68a8edf343b3323b543f708adf5f41dffb03944148670ac46aa786cafbecb12675c24a5d4c5e3242ff2929886214d6ea43d9017de588ddc5db486

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Change Log
 
+## 0.27.0
+
+- Hello, Text!
+- Support unbordered `text` widget if SWT style `:none` was passed
+- Support `:center`, `:left`, `:right` SWT styles for `text` widget
+- Support `:read_only` SWT style for `text` widget
+- Support `text` widget `on_verify_text` `event.doit = false` cancellation feature
+
+## 0.26.3
+
+- Support key_event.key_location in all key capturing widgets, not just display
+
+## 0.26.2
+
+- Support key_event.key_location to distinguish between left and right alt/shift/command/ctrl buttons
+- Use right/left alt/shift keys in Tetris for rotate right and rotate left
+
+## 0.26.1
+
+- Support display on_swt_keydown event keyCode/key_code values for arrow keys and alt/shift/ctrl
+- Use arrow keys for movement in Tetris
+- Use alt/shift keys for rotate right in Tetris
+
 ## 0.26.0
 
 - Tetris elaborate sample (minimal initial version of the one in Glimmer DSL for SWT)

data/README.md

@@ -145,7 +145,7 @@ Hello, Table! Game Booked
 
 NOTE: Glimmer DSL for Opal is an alpha project. Please help make better by contributing, adopting for small or low risk projects, and providing feedback. It is still an early alpha, so the more feedback and issues you report the better.
 
-**Alpha Version** 0.25.4 only supports bare-minimum capabilities for the included [samples](https://github.com/AndyObtiva/glimmer-dsl-opal#samples) (originally written for [glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt))
+**Alpha Version** 0.27.0 only supports bare-minimum capabilities for the included [samples](https://github.com/AndyObtiva/glimmer-dsl-opal#samples) (originally written for [glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt))
 
 Other [Glimmer](https://github.com/AndyObtiva/glimmer) DSL gems:
 - [glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt): Glimmer DSL for SWT (JRuby Desktop Development GUI Framework)
@@ -269,7 +269,7 @@ gem 'opal', '1.0.5'
 gem 'opal-rails', '1.1.2'
 gem 'opal-async', '~> 1.4.0'
 gem 'opal-jquery', '~> 0.4.4'
-gem 'glimmer-dsl-opal', '~> 0.25.4'
+gem 'glimmer-dsl-opal', '~> 0.27.0'
 gem 'glimmer-dsl-xml', '~> 1.2.0', require: false
 gem 'glimmer-dsl-css', '~> 1.2.0', require: false
 

data/VERSION

@@ -1 +1 @@
-0.26.0
+0.27.0

data/lib/glimmer/swt/c_tab_folder_proxy.rb

@@ -28,7 +28,7 @@ module Glimmer
       attr_reader :closeable_children
         
       def initialize(parent, args, block)
-        @closeable_children = args.detect { |arg| SWTProxy[:close] == SWTProxy[arg] }
+        @closeable_children = !!args.detect { |arg| SWTProxy[arg] == SWTProxy[:close] }
         super(parent, args, block)
       end
           

data/lib/glimmer/swt/combo_proxy.rb

@@ -55,45 +55,6 @@ module Glimmer
               }
             }
           },
-          '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
-              }
-            }
-          },
         }
       end
       

data/lib/glimmer/swt/date_time_proxy.rb

@@ -136,43 +136,6 @@ module Glimmer
               }
             },
           ],
-          'on_key_pressed' => {
-            event: 'keydown',
-            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(: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/display_proxy.rb

@@ -1,4 +1,5 @@
 require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/swt_proxy'
 
 module Glimmer
   module SWT
@@ -85,91 +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) {event.which}
-                  event.define_singleton_method(:key_code, &event.method(:keyCode))
-                  # TODO support alt/ctrl/shift/command & arrow keys in 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) {
-                  event.singleton_class.define_method(:character) do
-                    which || key_code
-                  end
-                  event.define_singleton_method(:keyCode) {event.which}
-                  event.define_singleton_method(:key_code, &event.method(:keyCode))
-                  # TODO support alt/ctrl/shift/command & arrow keys in 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.key_code != 13 && (event.key_code == 127 || event.key_code <= 31)
-                  
-                    # 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/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

@@ -32,7 +32,24 @@ module 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
@@ -373,7 +390,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 +417,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 +441,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 +521,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 +560,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
+                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(: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_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 +600,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

data/lib/glimmer-dsl-opal/samples/elaborate/tetris/view/block.rb

@@ -19,8 +19,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-# require_relative 'bevel'
-
 class Tetris
   module View
     class Block
@@ -31,9 +29,6 @@ class Tetris
       body {
         canvas { |canvas_proxy|
           background <= [game_playfield[row][column], :color]
-#           bevel(size: block_size) {
-#             base_color <= [game_playfield[row][column], :color]
-#           }
         }
       }
     end

data/lib/glimmer-dsl-opal/samples/elaborate/tetris/view/playfield.rb

@@ -29,7 +29,7 @@ class Tetris
       options :game_playfield, :playfield_width, :playfield_height, :block_size
   
       body {
-        composite((:double_buffered unless OS.mac?)) {
+        composite {
           grid_layout {
             num_columns playfield_width
             make_columns_equal_width true

data/lib/glimmer-dsl-opal/samples/elaborate/tetris/view/score_lane.rb

@@ -39,10 +39,6 @@ class Tetris
           row_layout {
             type :vertical
             center true
-#             fill true
-#             margin_width 0
-#             margin_right block_size
-#             margin_height block_size
           }
           label(:center) {
             text 'Next'

data/lib/glimmer-dsl-opal/samples/elaborate/tetris.rb

@@ -25,8 +25,11 @@ require_relative 'tetris/view/playfield'
 require_relative 'tetris/view/score_lane'
 require_relative 'tetris/view/high_score_dialog'
 require_relative 'tetris/view/tetris_menu_bar'
-
-# Tetris App View Custom Shell (represents `tetris` keyword)
+class Event
+  def location
+    `#@native.location`
+  end
+end
 class Tetris
   include Glimmer::UI::CustomShell
   
@@ -49,7 +52,7 @@ class Tetris
     display {
       on_swt_keydown do |key_event|
         case key_event.keyCode
-        when 'w'.bytes.first
+        when swt(:arrow_up), 'w'.bytes.first
           case game.up_arrow_action
           when :instant_down
             game.down!(instant: true)
@@ -58,17 +61,24 @@ class Tetris
           when :rotate_left
             game.rotate!(:left)
           end
-        when 's'.bytes.first
+        when swt(:arrow_down), 's'.bytes.first
           game.down!
-        when 'a'.bytes.first
+        when swt(:arrow_left), 'a'.bytes.first
           game.left!
-        when 'd'.bytes.first
+        when swt(:arrow_right), 'd'.bytes.first
           game.right!
         when 'q'.bytes.first
           game.rotate!(:left)
         when 'e'.bytes.first
           game.rotate!(:right)
+        when swt(:shift), swt(:alt)
+          if key_event.keyLocation == swt(:right) # right key
+            game.rotate!(:right)
+          elsif key_event.keyLocation == swt(:left) # left key
+            game.rotate!(:left)
+          end
         end
+        
       end
     }
   end
@@ -102,8 +112,6 @@ class Tetris
       }
       
       text 'Glimmer Tetris'
-#       minimum_size 475, 500
-#       image tetris_icon
       background rgb(236, 236, 236)
 
       tetris_menu_bar(game: game)
@@ -119,30 +127,11 @@ class Tetris
       }
     }
   }
-  
-#   def tetris_icon
-#     icon_block_size = 64
-#     icon_bevel_size = icon_block_size.to_f / 25.to_f
-#     icon_bevel_pixel_size = 0.16*icon_block_size.to_f
-#     icon_size = 8
-#     icon_pixel_size = icon_block_size * icon_size
-#     image(icon_pixel_size, icon_pixel_size) {
-#       icon_size.times { |row|
-#         icon_size.times { |column|
-#           colored = row >= 1 && column.between?(1, 6)
-#           color = colored ? color(([:white] + Model::Tetromino::LETTER_COLORS.values).sample) : color(:white)
-#           x = column * icon_block_size
-#           y = row * icon_block_size
-#           bevel(x: x, y: y, base_color: color, size: icon_block_size)
-#         }
-#       }
-#     }
-#   end
 
   def start_moving_tetrominos_down
     Async::Task.new do
       work = lambda do
-        @game.down! # unless @game.paused?
+        @game.down!
         Async::Task.new(delay: @game.delay * 1000.0, &work) unless @game.game_over? || body_root.disposed?
       end
       Async::Task.new(delay: @game.delay * 1000.0, &work)
@@ -158,7 +147,7 @@ class Tetris
   def show_about_dialog
     message_box {
       text 'Glimmer Tetris'
-      message "Glimmer Tetris\n\nGlimmer DSL for SWT Sample\n\nLeft is A\nRight is D\nDown is S\nUp is W\nRotate Left is Q\nRotate Right is E\n\n for Left, Down, Right, Up\n\nCopyright (c) 2007-2021 Andy Maleh"
+      message "Glimmer Tetris\n\nGlimmer DSL for SWT Sample\n\nUse arrow keys for movement\nand right/left alt/shift keys for rotation\nAlternatively:\nLeft is A\nRight is D\nDown is S\nUp is W\nRotate Left is Q\nRotate Right is E\n\n for Left, Down, Right, Up\n\nCopyright (c) 2007-2021 Andy Maleh"
     }.open
   end
 end

data/lib/glimmer-dsl-opal/samples/hello/hello_text.rb

@@ -0,0 +1,149 @@
+# Copyright (c) 2020-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class HelloText
+  include Glimmer::UI::CustomShell
+  
+  attr_accessor :default, :no_border, :center, :left, :right, :password, :telephone, :read_only, :wrap, :multi
+  
+  before_body do
+    self.default = 'default is :border style'
+    self.no_border = 'no border'
+    self.center = 'centered'
+    self.left = 'left-aligned'
+    self.right = 'right-aligned'
+    self.password = 'password'
+    self.telephone = '555-555-5555'
+    self.read_only = 'Telephone area code is 555'
+    self.wrap = 'wraps if text content is too long like this example'
+    self.multi = "multi-line enables hitting enter,\nbut works like wrap on the web"
+  end
+  
+  body {
+    shell {
+      grid_layout 2, false
+      
+      text 'Hello, Text!'
+      minimum_size 350, 100
+      
+      label {
+        text 'text'
+      }
+      text { # includes :border style by default
+        layout_data :fill, :center, true, false
+        text <=> [self, :default]
+      }
+
+      label {
+        text 'text(:none)'
+      }
+      text(:none) { # no border
+        layout_data :fill, :center, true, false
+        text <=> [self, :no_border]
+      }
+
+      label {
+        text 'text(:center, :border)'
+      }
+      text(:center, :border) {
+        layout_data :fill, :center, true, false
+        text <=> [self, :center]
+      }
+
+      label {
+        text 'text(:left, :border)'
+      }
+      text(:left, :border) {
+        layout_data :fill, :center, true, false
+        text <=> [self, :left]
+      }
+
+      label {
+        text 'text(:right, :border)'
+      }
+      text(:right, :border) {
+        layout_data :fill, :center, true, false
+        text <=> [self, :right]
+      }
+
+      label {
+        text 'text(:password, :border)'
+      }
+      text(:password, :border) {
+        layout_data :fill, :center, true, false
+        text <=> [self, :password]
+      }
+
+      label {
+        text 'text(:read_only, :border)'
+      }
+      text(:read_only, :border) {
+        layout_data :fill, :center, true, false
+        text <=> [self, :read_only]
+      }
+      
+      label {
+        text 'text with event handlers'
+      }
+      text {
+        layout_data :fill, :center, true, false
+        text <=> [self, :telephone]
+        
+        # this event kicks in just after the user typed and before modifying the text attribute value
+        on_verify_text do |verify_event|
+          new_text = verify_event.widget.text.clone
+          # new_text[verify_event.start...verify_event.end] = verify_event.text # Opal does not allow string mutation like JRuby in Glimmer DSL for SWT
+          new_text = "#{new_text[0...verify_event.start]}#{verify_event.text}#{new_text[verify_event.end..-1]}"
+          verify_event.doit = telephone?(new_text)
+        end
+        
+        # this event kicks in just after the text widget is verified and modified
+        on_modify_text do |modify_event|
+          self.read_only = "Telephone area code is #{modify_event.widget.text.gsub(/[^0-9]/, '')[0...3]}"
+        end
+      }
+      
+      label {
+        text 'text(:wrap, :border)'
+      }
+      text(:wrap, :border) {
+        layout_data(:fill, :center, true, false) {
+          width_hint 100
+        }
+        text <=> [self, :wrap]
+      }
+
+      label {
+        text 'text(:multi, :border)'
+      }
+      text(:multi, :border) {
+        layout_data :fill, :center, true, false
+        text <=> [self, :multi]
+      }
+    }
+  }
+  
+  def telephone?(text)
+    !!text.match(/^\d{0,3}[-.\/]?\d{0,3}[-.\/]?\d{0,4}$/)
+  end
+end
+
+HelloText.launch

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer-dsl-opal
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.27.0
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-23 00:00:00.000000000 Z
+date: 2021-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glimmer
@@ -328,6 +328,7 @@ files:
 - lib/glimmer-dsl-opal/samples/hello/hello_tab.rb
 - lib/glimmer-dsl-opal/samples/hello/hello_table.rb
 - lib/glimmer-dsl-opal/samples/hello/hello_table/baseball_park.png
+- lib/glimmer-dsl-opal/samples/hello/hello_text.rb
 - lib/glimmer-dsl-opal/samples/hello/hello_world.rb
 - lib/glimmer-dsl-opal/samples/hello/images/denmark.png
 - lib/glimmer-dsl-opal/samples/hello/images/finland.png