glimmer-dsl-opal 0.5.1 → 0.7.2

data/lib/glimmer/swt/text_proxy.rb

@@ -20,13 +20,61 @@ module Glimmer
             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
+                  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
+              }
+            }
+          },
+          'on_key_pressed' => {
+            event: 'keydown',
+            event_handler: -> (event_listener) {
+              -> (event) {
+                @last_key_pressed_event = event
                 @text = event.target.value
-                event_listener.call(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      
+      end
       
       def dom
         text_text = @text

data/lib/glimmer/swt/widget_proxy.rb

@@ -29,13 +29,16 @@ module Glimmer
       include Glimmer
       include PropertyOwner
       
-      attr_reader :parent, :args, :path, :children, :enabled, :foreground, :background, :font, :focus
+      attr_reader :parent, :args, :path, :children, :enabled, :foreground, :background, :font, :focus, :disposed?, :rendered
+      alias isDisposed disposed?
+      alias is_disposed disposed?
+      alias rendered? rendered
       
       class << self
         # Factory Method that translates a Glimmer DSL keyword into a WidgetProxy object
-        def for(keyword, parent, args)
+        def for(keyword, parent, args, block)
           the_widget_class = widget_class(keyword)
-          the_widget_class.respond_to?(:create) ? the_widget_class.create(parent, args) : the_widget_class.new(parent, args)
+          the_widget_class.respond_to?(:create) ? the_widget_class.create(keyword, parent, args, block) : the_widget_class.new(parent, args, block)
         end
         
         def widget_class(keyword)
@@ -97,21 +100,69 @@ module Glimmer
 #         end,
       }
       
-      def initialize(parent, args)
+      def initialize(parent, args, block)
         @parent = parent
         @args = args
+        @block = block
         @children = Set.new # TODO consider moving to composite
         @enabled = true
+        @data = {}
         DEFAULT_INITIALIZERS[self.class.underscored_widget_name(self)]&.call(self)
-        @parent.add_child(self) # TODO rename to post_initialize_child to be closer to glimmer-dsl-swt terminology
+        @parent.post_initialize_child(self) # TODO rename to post_initialize_child to be closer to glimmer-dsl-swt terminology
       end
       
+      # Executes for the parent of a child that just got added
+      def post_initialize_child(child)
+        @children << child
+        child.render
+      end
+      
+      # Executes for the parent of a child that just got disposed
+      def post_dispose_child(child)
+        @children&.delete(child)
+      end
+      
+      # Executes at the closing of a parent widget curly braces after all children/properties have been added/set
+      def post_add_content
+        # No Op by default
+      end
+      
+      def set_data(key=nil, value)
+        @data[key] = value
+      end
+      alias setData set_data
+      alias data= set_data
+      
+      def get_data(key=nil)
+        @data[key]
+      end
+      alias getData get_data
+      alias data get_data
+      
       def css_classes
         dom_element.attr('class').to_s.split
       end
       
       def dispose
+        remove_all_listeners
         Document.find(path).remove
+        parent&.post_dispose_child(self)
+        # TODO fire on_widget_disposed listener
+        @disposed = true
+      end
+      
+      def remove_all_listeners
+        effective_observation_request_to_event_mapping.keys.each do |keyword|
+          [effective_observation_request_to_event_mapping[keyword]].flatten.each do |mapping|
+            observation_requests[keyword].to_a.each do |event_listener|
+              event = mapping[:event]
+              event_handler = mapping[:event_handler]
+              event_element_css_selector = mapping[:event_element_css_selector]
+              the_listener_dom_element = event_element_css_selector ? Element[event_element_css_selector] : listener_dom_element
+              the_listener_dom_element.off(event)
+            end
+          end
+        end
       end
       
       def path
@@ -123,11 +174,6 @@ module Glimmer
         'div'
       end
 
-      def add_child(child)
-        @children << child
-        child.render
-      end
-      
       def enabled=(value)
         @enabled = value
         dom_element.prop('disabled', !@enabled)
@@ -165,31 +211,52 @@ module Glimmer
         @parent.path
       end
 
-      def render
+      def parent_dom_element
+        Document.find(parent_path)
+      end
+      
+      def render(custom_parent_dom_element = nil)
+        the_parent_dom_element = custom_parent_dom_element || parent_dom_element
         old_element = dom_element
         brand_new = @dom.nil? || old_element.empty?
-        build_dom
+        build_dom(!custom_parent_dom_element) # TODO handle custom parent layout by passing parent instead of parent dom element
         if brand_new
-          Document.find(parent_path).append(@dom)
+          the_parent_dom_element.append(@dom)
         else
           old_element.replace_with(@dom)
         end
-        @observation_requests&.clone&.each do |keyword, event_listener_set|
+        observation_requests&.clone&.each do |keyword, event_listener_set|
           event_listener_set.each do |event_listener|
-            @observation_requests[keyword].delete(event_listener)
+            observation_requests[keyword].delete(event_listener) # TODO look into the implications of this and if it's needed.
             handle_observation_request(keyword, &event_listener)
           end
         end
         children.each do |child|
           child.render
         end
+        @rendered = true
+        content_on_render_blocks.each { |content_block| content(&content_block) }
       end
       alias redraw render
       
-      def build_dom
+      def content_on_render_blocks
+        @content_on_render_blocks ||= []
+      end
+      
+      def add_content_on_render(&content_block)
+        if rendered?
+          content_block.call
+        else
+          content_on_render_blocks << content_block
+        end
+      end
+      
+      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 = @parent.layout.dom(@dom) if @parent.respond_to?(:layout) && @parent.layout
+        @dom
       end
       
       def content(&block)
@@ -201,6 +268,21 @@ module Glimmer
         {}
       end
       
+      def effective_observation_request_to_event_mapping
+        default_observation_request_to_event_mapping.merge(observation_request_to_event_mapping)
+      end
+      
+      def default_observation_request_to_event_mapping
+        {
+          'on_focus_gained' => {
+            event: 'focus',
+          },
+          'on_focus_lost' => {
+            event: 'blur',
+          },
+        }
+      end
+      
       def name
         self.class.name.split('::').last.underscore.sub(/_proxy$/, '').gsub('_', '-')
       end
@@ -248,6 +330,8 @@ module Glimmer
         Document.find(path)
       end
       
+      # TODO consider adding a default #dom method implementation for the common case, automatically relying on #element and other methods to build the dom html
+      
       def style_element
         style_element_id = "#{id}-style"
         style_element_selector = "style##{style_element_id}"
@@ -262,10 +346,6 @@ module Glimmer
         element
       end
       
-      def parent_dom_element
-        Document.find(parent_path)
-      end
-      
       def listener_path
         path
       end
@@ -287,26 +367,36 @@ module Glimmer
         end
       end
       
-      def handle_observation_request(keyword, &event_listener)
-        return unless observation_request_to_event_mapping.keys.include?(keyword)
+      def observation_requests
         @observation_requests ||= {}
-        @observation_requests[keyword] ||= Set.new
+      end
+      
+      def handle_observation_request(keyword, &event_listener)
+        return unless effective_observation_request_to_event_mapping.keys.include?(keyword)
         event = nil
         delegate = nil
-        [observation_request_to_event_mapping[keyword]].flatten.each do |mapping|
-          @observation_requests[keyword] << event_listener
+        [effective_observation_request_to_event_mapping[keyword]].flatten.each do |mapping|
+          observation_requests[keyword] ||= Set.new
+          observation_requests[keyword] << event_listener
           event = mapping[:event]
           event_handler = mapping[:event_handler]
+          event_element_css_selector = mapping[:event_element_css_selector]
           potential_event_listener = event_handler&.call(event_listener)
           event_listener = potential_event_listener || event_listener
-          delegate = listener_dom_element.on(event, &event_listener)
+          async_event_listener = lambda do |event|
+            Async::Task.new do
+              event_listener.call(event)
+            end
+          end
+          the_listener_dom_element = event_element_css_selector ? Element[event_element_css_selector] : listener_dom_element
+          delegate = the_listener_dom_element.on(event, &async_event_listener)
         end
         # TODO update code below for new WidgetProxy API
         EventListenerProxy.new(element_proxy: self, event: event, selector: selector, delegate: delegate)
       end
       
       def add_observer(observer, property_name)
-        property_listener_installers = self.class.ancestors.map {|ancestor| widget_property_listener_installers[ancestor]}.compact
+        property_listener_installers = self.class&.ancestors&.to_a.map {|ancestor| widget_property_listener_installers[ancestor]}.compact
         widget_listener_installers = property_listener_installers.map{|installer| installer[property_name.to_s.to_sym]}.compact if !property_listener_installers.empty?
         widget_listener_installers.to_a.each do |widget_listener_installer|
           widget_listener_installer.call(observer)
@@ -318,6 +408,14 @@ module Glimmer
         super(attribute_name, *args) # PropertyOwner
       end
       
+      def method_missing(method, *args, &block)
+        if method.to_s.start_with?('on_')
+          handle_observation_request(method, &block)
+        else
+          super(method, *args, &block)
+        end
+      end
+      
       def apply_property_type_converters(attribute_name, args)
         if args.count == 1
           value = args.first
@@ -458,6 +556,13 @@ module Glimmer
 #               }
 #             end,
 #           },
+          DateTimeProxy => {
+            :date_time => lambda do |observer|
+              on_widget_selected { |selection_event|
+                observer.call(date_time)
+              }
+            end
+          },
           RadioProxy => { #radio?
             :selection => lambda do |observer|
               on_widget_selected { |selection_event|
@@ -465,6 +570,13 @@ module Glimmer
               }
             end
           },
+          TableProxy => {
+            :selection => lambda do |observer|
+              on_widget_selected { |selection_event|
+                observer.call(selection_event.table_item.get_data)  # TODO ensure selection doesn't conflict with editing
+              }
+            end,
+          },
 #           Java::OrgEclipseSwtWidgets::MenuItem => {
 #             :selection => lambda do |observer|
 #               on_widget_selected { |selection_event|
@@ -486,11 +598,13 @@ module Glimmer
   end
 end
 
+require 'glimmer/swt/display_proxy'
 require 'glimmer/swt/browser_proxy'
 require 'glimmer/swt/button_proxy'
 require 'glimmer/swt/combo_proxy'
 require 'glimmer/swt/checkbox_proxy'
 require 'glimmer/swt/composite_proxy'
+require 'glimmer/swt/date_time_proxy'
 require 'glimmer/swt/group_proxy'
 require 'glimmer/swt/label_proxy'
 require 'glimmer/swt/list_proxy'

data/lib/glimmer/ui/custom_widget.rb

@@ -1,5 +1,5 @@
 # Copyright (c) 2020 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
@@ -7,10 +7,10 @@
 # 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
@@ -89,7 +89,7 @@ module Glimmer
         def included(klass)
           klass.extend(ClassMethods)
           unless klass.name.include?('Glimmer::UI::CustomShell')
-            klass.include(Glimmer) 
+            klass.include(Glimmer)
             Glimmer::UI::CustomWidget.add_custom_widget_namespaces_for(klass)
           end
         end
@@ -107,7 +107,7 @@ module Glimmer
               end
               begin
                 constant = result.const_get(namespace)
-                return constant if constant.ancestors.include?(Glimmer::UI::CustomWidget)
+                return constant if constant&.respond_to?(:ancestors) && constant&.ancestors&.to_a.include?(Glimmer::UI::CustomWidget)
                 constant
               rescue => e
                 # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
@@ -158,7 +158,7 @@ module Glimmer
           args = []
         end
         options ||= {}
-        args = options.delete('swt_style').split(',').map(&:to_sym) if options['swt_style']                
+        args = options.delete('swt_style').split(',').map(&:to_sym) if options['swt_style']
         @args = args
         @swt_style = SWT::SWTProxy[*@args]
         options ||= {}
@@ -244,7 +244,7 @@ module Glimmer
 
       def has_style?(symbol)
         @args.include?(symbol) # not a very solid implementation. Bring SWT constants eventually
-      end      
+      end
 
       def async_exec(&block)
         SWT::DisplayProxy.instance.async_exec(&block)
@@ -273,7 +273,7 @@ module Glimmer
         end
       end
 
-      alias local_respond_to? respond_to?      
+      alias local_respond_to? respond_to?
       def respond_to?(method, *args, &block)
         super or
           can_handle_observation_request?(method) or

data/lib/net/http.rb

@@ -7,11 +7,7 @@ module Net
   # Note: ignore Protocol superclass for now
   class HTTP
     def post_form(uri, params)
-#       pd uri.scheme
-#       pd uri.host
-#       pd uri.path
-#       pd uri.query
-#       pd params
+      # TODO
     end
   end
 end

data/lib/os.rb

@@ -0,0 +1,36 @@
+# Copyright (c) 2020 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 OS
+  class << self
+    def windows?
+      # No Op in Opal
+    end
+    
+    def mac?
+      # No Op in Opal
+    end
+    
+    def linux?
+      # No Op in Opal
+    end
+  end
+end