glimmer-dsl-opal 0.0.9 → 0.5.0

data/lib/glimmer/{opal/table_item.rb → swt/table_item_proxy.rb}

@@ -1,8 +1,8 @@
-  require 'glimmer/opal/element_proxy'
+require 'glimmer/swt/widget_proxy'
 
 module Glimmer
-  module Opal
-    class TableItem < ElementProxy
+  module SWT
+    class TableItemProxy < WidgetProxy
       attr_reader :data
       
       def initialize(parent, args)
@@ -45,10 +45,58 @@ module Glimmer
         @data_hash ||= {}
       end
       
-      def name
+      def parent_path
+        parent.items_path
+      end
+      
+      def element
         'tr'
       end
       
+      def redraw
+        super() #TODO re-enalbe and remove below lines
+
+        # TODO perhaps turn the following lambdas into methods
+        table_item_edit_handler = lambda do |event, cancel = false|
+          Async::Task.new do
+            text_value = event.target.value
+            edit_property = parent.column_properties[@edit_column_index]
+            edit_model = get_data
+            if !cancel && edit_model.send(edit_property) != text_value
+              edit_model.send("#{edit_property}=", text_value)
+              set_text(@edit_column_index, text_value)
+            end
+            @edit_column_index = nil
+            redraw
+          end
+        end
+        table_item_edit_cancel_handler = lambda do |event|           
+          Async::Task.new do
+            table_item_edit_handler.call(event, true)
+          end
+        end   
+        table_item_edit_key_handler = lambda do |event|
+          Async::Task.new do
+            if event.key_code == 13
+              table_item_edit_handler.call(event)
+            elsif event.key_code == 27
+              table_item_edit_cancel_handler.call(event)
+            end
+          end
+        end
+        
+        if @edit_column_index
+          table_item_input = dom_element.find("td:nth-child(#{@edit_column_index + 1}) input")
+          if !table_item_input.empty?
+            Async::Task.new do
+              table_item_input.focus
+              table_item_input.on('keyup', &table_item_edit_key_handler)
+              table_item_input.on('focusout', &table_item_edit_cancel_handler)                
+            end
+          end
+        end
+      end
+      
       def edit(column_index)
         return if @edit_column_index == column_index.to_i
         parent.select(parent.index_of(self), false)
@@ -63,13 +111,14 @@ module Glimmer
       end
       
       def max_column_width(column_index)
-        parent.dom.css("tr td:nth-child(#{column_index + 1})").first.width
+        parent_dom_element.find("tr td:nth-child(#{column_index + 1})").first.width
       end
       
       def dom
         table_item_id = id
         table_item_id_style = css
         table_item_css_classes = css_classes
+        table_item_css_classes << name
         table_item_selection = parent.selection.include?(self)
         if table_item_selection
           table_item_css_classes << 'selected'
@@ -77,40 +126,13 @@ module Glimmer
           table_item_css_classes.delete('selected')
         end
         table_item_text_array = text_array
-        table_item_edit_column_index = @edit_column_index
-        table_item_max_width = max_column_width(table_item_edit_column_index) if table_item_edit_column_index
-        table_item_edit_handler = lambda do |event, cancel = false|
-          Async::Task.new do
-            text_value = event.target.value
-            edit_property = parent.column_properties[table_item_edit_column_index]
-            edit_model = get_data
-            if !cancel && edit_model.send(edit_property) != text_value
-              edit_model.send("#{edit_property}=", text_value)
-              set_text(table_item_edit_column_index, text_value)
-            end
-            @edit_column_index = nil
-            redraw
-          end
-        end
-        table_item_edit_cancel_handler = lambda do |event|           
-          Async::Task.new do
-            table_item_edit_handler.call(event, true)
-          end
-        end   
-        table_item_edit_key_handler = lambda do |event|
-          Async::Task.new do
-            if event.code == 13
-              table_item_edit_handler.call(event)
-            elsif event.code == 27
-              table_item_edit_cancel_handler.call(event)
-            end
-          end
-        end
-        @dom ||= DOM {
+        table_item_max_width = max_column_width(@edit_column_index) if @edit_column_index
+
+        @dom ||= html {
           tr(id: table_item_id, style: table_item_id_style, class: table_item_css_classes.to_a.join(' ')) {
             table_item_text_array.each_with_index do |table_item_text, column_index|
               td('data-column-index' => column_index) {
-                if table_item_edit_column_index == column_index                  
+                if @edit_column_index == column_index                  
                   input(type: 'text', value: table_item_text, style: "max-width: #{table_item_max_width - 11}px;")
                 else
                   table_item_text
@@ -118,18 +140,7 @@ module Glimmer
               }
             end
           }
-        }.tap do |the_dom|
-          if table_item_edit_column_index
-            table_item_input = the_dom.css("td:nth-child(#{table_item_edit_column_index + 1}) input").first
-            if table_item_input
-              Async::Task.new do
-                table_item_input.focus
-                table_item_input.on('keyup', &table_item_edit_key_handler)
-                table_item_input.on('focusout', &table_item_edit_cancel_handler)                
-              end
-            end
-          end
-        end
+        }.to_s
       end
     end
   end

data/lib/glimmer/{opal → swt}/table_proxy.rb

@@ -1,9 +1,9 @@
-require 'glimmer/opal/element_proxy'
-require 'glimmer/opal/table_column'
+require 'glimmer/swt/widget_proxy'
+require 'glimmer/swt/table_column_proxy'
 
 module Glimmer
-  module Opal
-    class TableProxy < ElementProxy
+  module SWT
+    class TableProxy < WidgetProxy
       attr_reader :columns, :selection
       attr_accessor :column_properties
       alias items children
@@ -17,18 +17,17 @@ module Glimmer
       
       # Only table_columns may be added as children
       def add_child(child)
-        if child.is_a?(TableColumn)
+        if child.is_a?(TableColumnProxy)
           @columns << child
-          columns_dom << child.dom
         else
           @children << child        
-          items_dom << child.dom
         end
+        child.redraw
       end
       
       def remove_all
         items.clear
-        @items_dom = nil
+        redraw
       end
       
       def selection=(new_selection)
@@ -36,8 +35,8 @@ module Glimmer
         @selection = new_selection
         changed.each(&:redraw)
       end
-      
-      def items=(new_items)
+            
+      def items=(new_items)        
         @children = new_items
         redraw
       end
@@ -71,66 +70,74 @@ module Glimmer
       end
       
       def observation_request_to_event_mapping
+        mouse_handler = -> (event_listener) {
+          -> (event) {
+            event.singleton_class.send(:define_method, :table_item=) do |item|
+              @table_item = item
+            end
+            event.singleton_class.send(:define_method, :table_item) do
+              @table_item
+            end
+            table_row = event.target.parents('tr').first
+            table_data = event.target.parents('td').first
+            event.table_item = items.detect {|item| item.id == table_row.attr('id')}
+            event.singleton_class.send(:define_method, :column_index) do
+              (table_data || event.target).attr('data-column-index')
+            end
+            event_listener.call(event)              
+          }
+        } 
+
         {
           'on_mouse_down' => {
             event: 'mousedown',
-            event_handler: -> (event_listener) {
-              -> (event) {
-                event.singleton_class.send(:define_method, :table_item=) do |item|
-                  @table_item = item
-                end
-                event.singleton_class.send(:define_method, :table_item) do
-                  @table_item
-                end
-                table_row = event.target.ancestors('tr').first
-                table_data = event.target.ancestors('td').first
-                event.table_item = items.detect {|item| item.id == table_row.attributes['id']}
-                event.singleton_class.send(:define_method, :column_index) do
-                  (table_data || event.target).attributes['data-column-index']
-                end
-                event_listener.call(event)              
-              }
-            }
+            event_handler: mouse_handler,
+          },
+          'on_mouse_up' => {
+            event: 'mouseup',
+            event_handler: mouse_handler,
           }
         }
       end
       
       def redraw
-        if @dom
-          old_dom = @dom
-          @dom = nil
-          old_dom.replace dom
-        else
-          dom
-        end
-        if @last_redrawn_children != @children
-          items_dom.clear
-          @last_redrawn_children = @children
-          @children = []
-          @last_redrawn_children.each do |child|            
-            add_child(child)
-          end
-        end
+        super()
+        @columns.to_a.each(&:redraw)  
+      end
+      
+      def element
+        'table'
+      end
+      
+      def columns_path
+        path + ' thead tr'
       end
 
+      def columns_dom_element
+        Document.find(columns_path)
+      end
+      
+      def items_path
+        path + ' tbody'
+      end
+
+      def items_dom_element
+        Document.find(items_path)
+      end
+      
       def columns_dom        
-        @columns_dom ||= DOM {
-          tr {
-          }
+        tr {
         }
       end
       
       def thead_dom
-        @thead_dom ||= DOM {
-          thead {
-          }
-        }.tap {|the_dom| the_dom << columns_dom }
-      end
+        thead {
+          columns_dom
+        }
+      end            
       
       def items_dom        
-        @items_dom ||= DOM {
-          tbody {
-          }
+        tbody {
         }
       end
       
@@ -138,11 +145,14 @@ module Glimmer
         table_id = id
         table_id_style = css
         table_id_css_classes = css_classes
+        table_id_css_classes << 'table'
         table_id_css_classes_string = table_id_css_classes.to_a.join(' ')
-        @dom ||= DOM {
-          table(id: table_id, style: table_id_style, class: table_id_css_classes_string) {            
+        @dom ||= html {
+          table(id: table_id, style: table_id_style, class: table_id_css_classes_string) {
+            thead_dom
+            items_dom
           }
-        }.tap {|the_dom| the_dom >> thead_dom }.tap {|the_dom| the_dom << items_dom }
+        }.to_s
       end
     end
   end

data/lib/glimmer/swt/text_proxy.rb

@@ -0,0 +1,46 @@
+require 'glimmer/swt/widget_proxy'
+
+module Glimmer
+  module SWT
+    class TextProxy < WidgetProxy
+      attr_reader :text
+
+      def text=(value)
+        @text = value
+        Document.find(path).value = value
+      end
+      
+      def element
+        'input'
+      end
+      
+      def observation_request_to_event_mapping
+        {
+          'on_modify_text' => {
+            event: 'keyup',
+            event_handler: -> (event_listener) {
+              -> (event) {
+                @text = event.target.value
+                event_listener.call(event)              
+              }
+            }
+          }
+        }
+      end      
+      
+      def dom
+        text_text = @text
+        text_id = id
+        text_style = css
+        text_class = name
+        # TODO support password field
+        options = {type: 'text', id: text_id, style: text_style, class: text_class, value: text_text, style: 'min-width: 27px;'}
+        options = options.merge('disabled': 'disabled') unless @enabled
+        options = options.merge(type: 'password') if has_style?(:password)
+        @dom ||= html {
+          input(options)
+        }.to_s
+      end
+    end
+  end
+end

data/lib/glimmer/swt/widget_proxy.rb

@@ -0,0 +1,511 @@
+# 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.
+
+require 'glimmer/swt/event_listener_proxy'
+require 'glimmer/swt/property_owner'
+require 'glimmer/swt/swt_proxy'
+
+module Glimmer
+  module SWT
+    class WidgetProxy
+      include Glimmer
+      include PropertyOwner
+      
+      attr_reader :parent, :args, :path, :children, :enabled, :foreground, :background, :font, :focus
+      
+      class << self
+        # Factory Method that translates a Glimmer DSL keyword into a WidgetProxy object
+        def for(keyword, parent, args)
+          the_widget_class = widget_class(keyword)
+          the_widget_class.respond_to?(:create) ? the_widget_class.create(parent, args) : the_widget_class.new(parent, args)
+        end
+        
+        def widget_class(keyword)
+          class_name_alternative = keyword.camelcase(:upper)
+          class_name_main = "#{class_name_alternative}Proxy"
+          Glimmer::SWT.const_get(class_name_main.to_sym) rescue Glimmer::SWT.const_get(class_name_alternative.to_sym)
+        rescue => e
+          puts "Widget #{keyword} was not found!"
+          nil
+        end
+        
+        def widget_exists?(keyword)
+          !!widget_class(keyword)
+        end
+      
+        def next_id_number_for(name)
+          @max_id_numbers[name] = max_id_number_for(name) + 1
+        end
+        
+        def max_id_number_for(name)
+          @max_id_numbers[name] = max_id_numbers[name] || 0
+        end
+        
+        def max_id_numbers
+          @max_id_numbers ||= reset_max_id_numbers!
+        end
+        
+        def reset_max_id_numbers!
+          @max_id_numbers = {}
+        end
+        
+        def underscored_widget_name(widget_proxy)
+          widget_proxy.class.name.split(/::|\./).last.sub(/Proxy$/, '').underscore
+        end
+      end
+      
+      DEFAULT_INITIALIZERS = {
+        "composite" => lambda do |composite_proxy|
+          if composite_proxy.layout.nil?
+            layout = GridLayoutProxy.new(composite_proxy, [])
+            composite_proxy.layout = layout
+            layout.margin_width = 15
+            layout.margin_height = 15
+          end
+        end,
+#         "scrolled_composite" => lambda do |scrolled_composite|
+#           scrolled_composite.expand_horizontal = true
+#           scrolled_composite.expand_vertical = true
+#         end,
+#         "table" => lambda do |table|
+#           table.setHeaderVisible(true)
+#           table.setLinesVisible(true)
+#         end,
+        "table_column" => lambda do |table_column_proxy|
+          table_column_proxy.width = 80
+        end,
+#         "group" => lambda do |group_proxy|
+#           group_proxy.layout = GridLayoutProxy.new(group_proxy, []) if group.layout.nil?
+#         end,
+      }
+      
+      def initialize(parent, args)
+        @parent = parent
+        @args = args
+        @children = Set.new # TODO consider moving to composite
+        @enabled = true
+        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
+      end
+      
+      def css_classes
+        dom_element.attr('class').to_s.split
+      end
+      
+      def dispose
+        Document.find(path).remove
+      end
+      
+      def path
+        "#{parent_path} #{element}##{id}.#{name}"
+      end
+
+      # Root element representing widget. Must be overridden by subclasses if different from div
+      def element
+        'div'
+      end
+
+      def add_child(child)
+        @children << child
+        child.render
+      end
+      
+      def enabled=(value)
+        @enabled = value
+        dom_element.prop('disabled', !@enabled)
+      end
+      
+      def foreground=(value)
+        @foreground = value
+        dom_element.css('color', foreground.to_css) unless foreground.nil?
+      end
+      
+      def background=(value)
+        @background = value
+        dom_element.css('background-color', background.to_css) unless background.nil?
+      end
+      
+      def font=(value)
+        @font = value.is_a?(FontProxy) ? value : FontProxy.new(self, value)
+        dom_element.css('font-family', @font.name) unless @font.nil?
+        dom_element.css('font-style', 'italic') if @font&.style == :italic
+        dom_element.css('font-weight', 'bold') if @font&.style == :bold
+        dom_element.css('font-size', "#{@font.height}px") unless @font.nil?
+      end
+      
+      def focus=(value)
+        @focus = value
+        dom_element.focus # TODO consider if a delay or async_exec is needed here
+      end
+      
+      def set_focus
+        self.focus = true
+      end
+      alias setFocus set_focus
+      
+      def parent_path
+        @parent.path
+      end
+
+      def render
+        old_element = dom_element
+        brand_new = @dom.nil? || old_element.empty?
+        build_dom
+        if brand_new
+          Document.find(parent_path).append(@dom)
+        else
+          old_element.replace_with(@dom)
+        end
+        @observation_requests&.clone&.each do |keyword, event_listener_set|
+          event_listener_set.each do |event_listener|
+            @observation_requests[keyword].delete(event_listener)
+            handle_observation_request(keyword, &event_listener)
+          end
+        end
+        children.each do |child|
+          child.render
+        end
+      end
+      alias redraw render
+      
+      def build_dom
+        @dom = nil
+        @dom = dom
+        @dom = @parent.layout.dom(@dom) if @parent.respond_to?(:layout) && @parent.layout
+      end
+      
+      def content(&block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::Opal::WidgetExpression.new, &block)
+      end
+      
+      # Subclasses must override with their own mappings
+      def observation_request_to_event_mapping
+        {}
+      end
+      
+      def name
+        self.class.name.split('::').last.underscore.sub(/_proxy$/, '').gsub('_', '-')
+      end
+      
+      def id
+        @id ||= "#{name}-#{WidgetProxy.next_id_number_for(name)}"
+      end
+            
+      # Sets id explicitly. Useful in cases of wanting to maintain a stable id
+      def id=(value)
+        @id = value
+      end
+            
+      # Subclasses can override with their own selector
+      def selector
+        "#{name}##{id}"
+      end
+      
+      def add_css_class(css_class)
+        dom_element.add_class(css_class)
+      end
+      
+      def add_css_classes(css_classes_to_add)
+        css_classes_to_add.each {|css_class| add_css_class(css_class)}
+      end
+      
+      def remove_css_class(css_class)
+        dom_element.remove_class(css_class)
+      end
+      
+      def remove_css_classes(css_classes_to_remove)
+        css_classes_to_remove.each {|css_class| remove_css_class(css_class)}
+      end
+      
+      def clear_css_classes
+        css_classes.each {|css_class| remove_css_class(css_class)}
+      end
+      
+      def has_style?(symbol)
+        @args.include?(symbol) # not a very solid implementation. Bring SWT constants eventually
+      end
+      
+      def dom_element
+        # TODO consider making this pick an element in relation to its parent, allowing unhooked dom elements to be built if needed (unhooked to the visible page dom)
+        Document.find(path)
+      end
+      
+      def style_element
+        style_element_id = "#{id}-style"
+        style_element_selector = "style##{style_element_id}"
+        element = dom_element.find(style_element_selector)
+        if element.empty?
+          new_element = Element.new(:style)
+          new_element.attr('id', style_element_id)
+          new_element.attr('class', "#{name.gsub('_', '-')}-instance-style widget-instance-style")
+          dom_element.prepend(new_element)
+          element = dom_element.find(style_element_selector)
+        end
+        element
+      end
+      
+      def parent_dom_element
+        Document.find(parent_path)
+      end
+      
+      def listener_path
+        path
+      end
+      
+      def listener_dom_element
+        Document.find(listener_path)
+      end
+      
+      def can_handle_observation_request?(observation_request)
+        # TODO sort this out for Opal
+        observation_request = observation_request.to_s
+        if observation_request.start_with?('on_swt_')
+          constant_name = observation_request.sub(/^on_swt_/, '')
+          SWTProxy.has_constant?(constant_name)
+        elsif observation_request.start_with?('on_')
+#           event = observation_request.sub(/^on_/, '')
+#           can_add_listener?(event) || can_handle_drag_observation_request?(observation_request) || can_handle_drop_observation_request?(observation_request)
+          true # TODO filter by valid listeners only in the future
+        end
+      end
+      
+      def handle_observation_request(keyword, &event_listener)
+        return unless observation_request_to_event_mapping.keys.include?(keyword)
+        @observation_requests ||= {}
+        @observation_requests[keyword] ||= Set.new
+        event = nil
+        delegate = nil
+        [observation_request_to_event_mapping[keyword]].flatten.each do |mapping|
+          @observation_requests[keyword] << event_listener
+          event = mapping[:event]
+          event_handler = mapping[:event_handler]
+          potential_event_listener = event_handler&.call(event_listener)
+          event_listener = potential_event_listener || event_listener
+          delegate = listener_dom_element.on(event, &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
+        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)
+        end
+      end
+      
+      def set_attribute(attribute_name, *args)
+        apply_property_type_converters(attribute_name, args)
+        super(attribute_name, *args) # PropertyOwner
+      end
+      
+      def apply_property_type_converters(attribute_name, args)
+        if args.count == 1
+          value = args.first
+          converter = property_type_converters[attribute_name.to_sym]
+          args[0] = converter.call(value) if converter
+        end
+#         if args.count == 1 && args.first.is_a?(ColorProxy)
+#           g_color = args.first
+#           args[0] = g_color.swt_color
+#         end
+      end
+      
+      def property_type_converters
+        color_converter = lambda do |value|
+          if value.is_a?(Symbol) || value.is_a?(String)
+            ColorProxy.new(value)
+          else
+            value
+          end
+        end
+        @property_type_converters ||= {
+          :background => color_converter,
+#           :background_image => lambda do |value|
+#             if value.is_a?(String)
+#               if value.start_with?('uri:classloader')
+#                 value = value.sub(/^uri\:classloader\:\//, '')
+#                 object = java.lang.Object.new
+#                 value = object.java_class.resource_as_stream(value)
+#                 value = java.io.BufferedInputStream.new(value)
+#               end
+#               image_data = ImageData.new(value)
+#               on_event_Resize do |resize_event|
+#                 new_image_data = image_data.scaledTo(@swt_widget.getSize.x, @swt_widget.getSize.y)
+#                 @swt_widget.getBackgroundImage&.dispose
+#                 @swt_widget.setBackgroundImage(Image.new(@swt_widget.getDisplay, new_image_data))
+#               end
+#               Image.new(@swt_widget.getDisplay, image_data)
+#             else
+#               value
+#             end
+#           end,
+          :foreground => color_converter,
+#           :font => lambda do |value|
+#             if value.is_a?(Hash)
+#               font_properties = value
+#               FontProxy.new(self, font_properties).swt_font
+#             else
+#               value
+#             end
+#           end,
+          :items => lambda do |value|
+            value.to_java :string
+          end,
+          :text => lambda do |value|
+#             if swt_widget.is_a?(Browser)
+#               value.to_s
+#             else
+              value.to_s
+#             end
+          end,
+#           :visible => lambda do |value|
+#             !!value
+#           end,
+        }
+      end
+      
+      def widget_property_listener_installers
+        @swt_widget_property_listener_installers ||= {
+#           WidgetProxy => {
+#             :focus => lambda do |observer|
+#               on_focus_gained { |focus_event|
+#                 observer.call(true)
+#               }
+#               on_focus_lost { |focus_event|
+#                 observer.call(false)
+#               }
+#             end,
+#           },
+          TextProxy => {
+            :text => lambda do |observer|
+              on_modify_text { |modify_event|
+                observer.call(text)
+              }
+            end,
+#             :caret_position => lambda do |observer|
+#               on_event_keydown { |event|
+#                 observer.call(getCaretPosition)
+#               }
+#               on_event_keyup { |event|
+#                 observer.call(getCaretPosition)
+#               }
+#               on_event_mousedown { |event|
+#                 observer.call(getCaretPosition)
+#               }
+#               on_event_mouseup { |event|
+#                 observer.call(getCaretPosition)
+#               }
+#             end,
+#             :selection => lambda do |observer|
+#               on_event_keydown { |event|
+#                 observer.call(getSelection)
+#               }
+#               on_event_keyup { |event|
+#                 observer.call(getSelection)
+#               }
+#               on_event_mousedown { |event|
+#                 observer.call(getSelection)
+#               }
+#               on_event_mouseup { |event|
+#                 observer.call(getSelection)
+#               }
+#             end,
+#             :selection_count => lambda do |observer|
+#               on_event_keydown { |event|
+#                 observer.call(getSelectionCount)
+#               }
+#               on_event_keyup { |event|
+#                 observer.call(getSelectionCount)
+#               }
+#               on_event_mousedown { |event|
+#                 observer.call(getSelectionCount)
+#               }
+#               on_event_mouseup { |event|
+#                 observer.call(getSelectionCount)
+#               }
+#             end,
+#             :top_index => lambda do |observer|
+#               @last_top_index = getTopIndex
+#               on_paint_control { |event|
+#                 if getTopIndex != @last_top_index
+#                   @last_top_index = getTopIndex
+#                   observer.call(@last_top_index)
+#                 end
+#               }
+#             end,
+          },
+#           Java::OrgEclipseSwtCustom::StyledText => {
+#             :text => lambda do |observer|
+#               on_modify_text { |modify_event|
+#                 observer.call(getText)
+#               }
+#             end,
+#           },
+          RadioProxy => { #radio?
+            :selection => lambda do |observer|
+              on_widget_selected { |selection_event|
+                observer.call(selection)
+              }
+            end
+          },
+#           Java::OrgEclipseSwtWidgets::MenuItem => {
+#             :selection => lambda do |observer|
+#               on_widget_selected { |selection_event|
+#                 observer.call(getSelection)
+#               }
+#             end
+#           },
+#           Java::OrgEclipseSwtWidgets::Spinner => {
+#             :selection => lambda do |observer|
+#               on_widget_selected { |selection_event|
+#                 observer.call(getSelection)
+#               }
+#             end
+#           },
+        }
+      end
+      
+    end
+  end
+end
+
+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/group_proxy'
+require 'glimmer/swt/label_proxy'
+require 'glimmer/swt/list_proxy'
+require 'glimmer/swt/radio_proxy'
+require 'glimmer/swt/tab_folder_proxy'
+require 'glimmer/swt/tab_item_proxy'
+require 'glimmer/swt/table_column_proxy'
+require 'glimmer/swt/table_item_proxy'
+require 'glimmer/swt/table_proxy'
+require 'glimmer/swt/text_proxy'
+require 'glimmer/swt/radio_proxy'
+require 'glimmer/swt/scrolled_composite_proxy'
+require 'glimmer/swt/styled_text_proxy'
+
+require 'glimmer/dsl/opal/widget_expression'