glimmer 0.4.8 → 0.4.9

data/lib/glimmer/swt/g_widget.rb

@@ -14,7 +14,7 @@ module Glimmer
       include_package 'org.eclipse.swt.graphics'
       include_package 'org.eclipse.swt.browser'
 
-      include Glimmer
+      include Glimmer # TODO consider removing when no longer needed
       include Parent
 
       attr_reader :widget
@@ -45,21 +45,41 @@ module Glimmer
         @@default_initializers[underscored_widget_name].call(@widget) if @@default_initializers[underscored_widget_name]
       end
 
-      def has_style?(swt_style)
-        pd(pd(@widget.getStyle) & swt_style) == pd(swt_style)
+      def widget_custom_attribute_mapping
+        @widget_custom_attribute_mapping ||= {
+          'focus' => {
+            getter: {name: 'isFocusControl'},
+            setter: {name: 'setFocus', invoker: lambda { |widget, args| widget.setFocus if args.first }},
+          }
+        }
       end
 
       def has_attribute?(attribute_name, *args)
-        @widget.respond_to?(attribute_setter(attribute_name), args)
+        widget_custom_attribute = widget_custom_attribute_mapping[attribute_name.to_s]
+        if widget_custom_attribute
+          @widget.respond_to?(widget_custom_attribute[:setter][:name])
+        else
+          @widget.respond_to?(attribute_setter(attribute_name), args)
+        end
       end
 
       def set_attribute(attribute_name, *args)
-        apply_property_type_converters(attribute_name, args)
-        @widget.send(attribute_setter(attribute_name), *args)
+        widget_custom_attribute = widget_custom_attribute_mapping[attribute_name.to_s]
+        if widget_custom_attribute
+          widget_custom_attribute[:setter][:invoker].call(@widget, args)
+        else
+          apply_property_type_converters(attribute_name, args)
+          @widget.send(attribute_setter(attribute_name), *args)
+        end
       end
 
       def get_attribute(attribute_name)
-        @widget.send(attribute_getter(attribute_name))
+        widget_custom_attribute = widget_custom_attribute_mapping[attribute_name.to_s]
+        if widget_custom_attribute
+          @widget.send(widget_custom_attribute[:getter][:name])
+        else
+          @widget.send(attribute_getter(attribute_name))
+        end
       end
 
       def property_type_converters
@@ -75,6 +95,20 @@ module Glimmer
           :items => Proc.new { |value| value.to_java :string},
           :visible => Proc.new { |value| !!value},
           :background => color_converter,
+          :background_image => Proc.new do |value|
+            if value.is_a?(String)
+              image_data = ImageData.new(value)
+              # TODO in the future, look into unregistering this listener when no longer needed
+              on_event_Resize do |resize_event|
+                new_image_data = image_data.scaledTo(widget.getSize.x, widget.getSize.y)
+                widget.getBackgroundImage&.dispose
+                widget.setBackgroundImage(Image.new(widget.getDisplay, new_image_data))
+              end
+              Image.new(widget.getDisplay, image_data)
+            else
+              value
+            end
+          end,
           :foreground => color_converter,
           :font => Proc.new do |value|
             if value.is_a?(Hash)
@@ -89,6 +123,18 @@ module Glimmer
 
       def widget_property_listener_installers
         @widget_property_listener_installers ||= {
+          Java::OrgEclipseSwtWidgets::Control => {
+            :focus => Proc.new do |observer|
+              add_contents(self) {
+                on_focus_gained { |focus_event|
+                  observer.call(true)
+                }
+                on_focus_lost { |focus_event|
+                  observer.call(false)
+                }
+              }
+            end,
+          },
           Java::OrgEclipseSwtWidgets::Text => {
             :text => Proc.new do |observer|
               add_contents(self) {
@@ -153,21 +199,11 @@ module Glimmer
         nil
       end
 
-      def widget_listener_exists?(underscored_listener_name)
-        listener_method_name = underscored_listener_name.listener_method_name(:lower)
-        @widget.getClass.getMethods.each do |widget_method|
-          if widget_method.getName.match(/add.*Listener/)
-            widget_method.getParameterTypes.each do |listener_type|
-              listener_type.getMethods.each do |listener_method|
-                if (listener_method.getName == listener_method_name)
-                  return true
-                end
-              end
-            end
-          end
-        end
-        return false
-      end
+      # TODO refactor following methods to eliminate duplication
+      # perhaps consider relying on raising an exception to avoid checking first
+      # unless that gives obscure SWT errors
+      # Otherwise, consider caching results from can_add_lsitener and using them in
+      # add_listener knowing it will be called for sure afterwards
 
       def can_add_listener?(underscored_listener_name)
         listener_method_name = underscored_listener_name.camelcase(:lower)
@@ -213,15 +249,15 @@ module Glimmer
       end
 
       def process_block(block)
-        block.call(@widget)
+        block.call(self)
       end
 
       def async_exec(&block)
-        @widget.getDisplay.asyncExec(GRunnable.new(&block))
+        GDisplay.instance.async_exec(&block)
       end
 
       def sync_exec(&block)
-        @widget.getDisplay.syncExec(GRunnable.new(&block))
+        GDisplay.instance.sync_exec(&block)
       end
 
       def has_style?(style)
@@ -232,16 +268,63 @@ module Glimmer
         @widget.dispose
       end
 
+      # TODO Consider renaming these methods as they are mainly used for data-binding
+
+      def can_add_observer?(property_name)
+        @widget.class.ancestors.map {|ancestor| widget_property_listener_installers[ancestor]}.compact.map(&:keys).flatten.map(&:to_s).include?(property_name.to_s)
+      end
+
       def add_observer(observer, property_name)
-        property_listener_installers = widget_property_listener_installers[widget.class]
-        widget_listener_installer = property_listener_installers[property_name.to_s.to_sym] if property_listener_installers
-        widget_listener_installer.call(observer) if widget_listener_installer
+        property_listener_installers = @widget.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.each do |widget_listener_installer|
+          widget_listener_installer.call(observer)
+        end
       end
 
       def remove_observer(observer, property_name)
         # TODO consider implementing if remove_observer is needed (consumers can remove listener via SWT API)
       end
 
+      # TODO eliminate duplication in the following methods perhaps by relying on exceptions
+
+      def can_handle_observation_request?(observation_request)
+        observation_request = observation_request.to_s
+        if observation_request.start_with?('on_event_')
+          constant_name = observation_request.sub(/^on_event_/, '')
+          GSWT.has_constant?(constant_name)
+        elsif observation_request.start_with?('on_')
+          event = observation_request.sub(/^on_/, '')
+          can_add_listener?(event)
+        else
+          false
+        end
+      end
+
+      def handle_observation_request(observation_request, &block)
+        if observation_request.start_with?('on_event_')
+          constant_name = observation_request.sub(/^on_event_/, '')
+          @widget.addListener(GSWT[constant_name], &block)
+        elsif observation_request.start_with?('on_')
+          event = observation_request.sub(/^on_/, '')
+          add_listener(event, &block)
+        end
+        nil
+      end
+
+      def method_missing(method, *args, &block)
+        method_name = method.to_s
+        if can_handle_observation_request?(method_name)
+          handle_observation_request(method_name, &block)
+        else
+          super
+        end
+      end
+
+      def add_content(&block)
+        Glimmer.add_contents(self, &block)
+      end
+
       private
 
       def style(underscored_widget_name, styles)

data/lib/glimmer/swt/list_selection_binding.rb

@@ -30,11 +30,9 @@ module Glimmer
         property_type = :string if property_type.nil? or property_type == :undefined
         @widget = widget
         @property_type = property_type
-        add_contents(@widget) {
-          on_widget_disposed { |dispose_event|
-            unregister_all_observables
-          }
-        }
+        @widget.on_widget_disposed do |dispose_event|
+          unregister_all_observables
+        end
       end
       def call(value)
         @@property_type_updaters[@property_type].call(@widget, value) unless evaluate_property == value

data/lib/glimmer/swt/model_binding.rb

@@ -96,15 +96,6 @@ module Glimmer
             )
           end
         end
-        # @nested_property_observers_collection[observer].keys.each_with_index do |property_name, i|
-        #   previous_property_name = nested_property_names[i-1]
-        #   previous_observer = @nested_property_observers_collection[observer][previous_property_name]
-        #   nested_property_observer = @nested_property_observers_collection[observer][property_name]
-        #   previous_observer.add_dependent(nested_property_observer) unless previous_observer.nil?
-        # end
-        # TODO remove this brainstorming
-        # person.addresses[1].streets[2].number
-        # person.addresses[1] = ...
         @nested_property_observers_collection[observer]
       end
       def add_observer(observer)
@@ -113,8 +104,9 @@ module Glimmer
         elsif nested_property?
           add_nested_observers(observer)
         else
-          observer.observe(model, property_name)
-          observer.add_dependent([self, nil] => [observer, model, property_name])
+          observer_registration = observer.observe(model, property_name)
+          my_registration = observer.registration_for(self)
+          observer.add_dependent(my_registration => observer_registration)
         end
       end
       def remove_observer(observer)
@@ -140,8 +132,9 @@ module Glimmer
       end
       def add_computed_observers(observer)
         @computed_model_bindings.each do |computed_model_binding|
-          computed_observer_for(observer).observe(computed_model_binding)
-          observer.add_dependent([self, nil] => [computed_observer_for(observer), computed_model_binding, nil])
+          observer_registration = computed_observer_for(observer).observe(computed_model_binding)
+          my_registration = observer.registration_for(self)
+          observer.add_dependent(my_registration => observer_registration)
         end
       end
       def add_nested_observers(observer)
@@ -157,17 +150,12 @@ module Glimmer
           unless model.nil?
             if property_indexed?(property_name)
               # TODO figure out a way to deal with this more uniformly
-              nested_property_observer.observe(model)
-              parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, nil])
+              observer_registration = nested_property_observer.observe(model)
             else
-              # pd property_name, announcer: '[NESTED]', header: true
-              # pd model, announcer: '[NESTED]'
-              # pd nested_property_observer, announcer: '[NESTED]'
-              nested_property_observer.observe(model, property_name)
-              # pd 'DONE ADDING OBSERVER', announcer: '[NESTED]'
-              parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, property_name])
-              # pd 'DONE ADDING DEPENDENT', announcer: '[NESTED]'
+              observer_registration = nested_property_observer.observe(model, property_name)
             end
+            parent_registration = parent_observer.registration_for(parent_model, parent_property_name)
+            parent_observer.add_dependent(parent_registration => observer_registration)
           end
         end
       end

data/lib/glimmer/swt/observable_array.rb

@@ -28,7 +28,7 @@ module Glimmer
         end
         observer
       end
-      
+
       def has_observer?(observer)
         property_observer_list.include?(observer)
       end
@@ -97,7 +97,7 @@ module Glimmer
         # TODO look into optimizing this
         return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
         property_observer_list.each do |observer|
-          observer.unregister_dependents_with_observable([self, nil], old_value)
+          observer.unregister_dependents_with_observable(observer.registration_for(self), old_value)
         end
       end
     end

data/lib/glimmer/swt/observable_model.rb

@@ -21,9 +21,6 @@ module Glimmer
       end
 
       def add_observer(observer, property_name)
-        # pd property_name, announcer: '[ADD_OBSERVER]'
-        # pd observer, announcer: '[ADD_OBSERVER]'
-        # pd has_observer?(observer, property_name)
         return observer if has_observer?(observer, property_name)
         property_observer_list(property_name) << observer
         add_property_writer_observers(property_name)
@@ -85,16 +82,17 @@ module Glimmer
         # TODO look into optimizing this
         return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
         property_observer_list(property_name).each do |observer|
-          observer.unregister_dependents_with_observable([self, property_name], old_value)
+          observer.unregister_dependents_with_observable(observer.registration_for(self, property_name), old_value)
         end
       end
 
       def ensure_array_object_observer(property_name, object, old_object = nil)
         return unless object.is_a?(Array)
         array_object_observer = array_object_observer_for(property_name)
-        array_object_observer.observe(object)
+        array_observer_registration = array_object_observer.observe(object)
         property_observer_list(property_name).each do |observer|
-          observer.add_dependent([self, property_name] => [array_object_observer, object, nil])
+          my_registration = observer.registration_for(self, property_name) # TODO eliminate repetition
+          observer.add_dependent(my_registration => array_observer_registration)
         end
         array_object_observer_for(property_name).unregister(old_object) if old_object.is_a?(ObservableArray)
       end

data/lib/glimmer/swt/observer.rb

@@ -25,6 +25,13 @@ module Glimmer
         end
       end
 
+      class Registration < Struct.new(:observer, :observable, :property, keyword_init: true)
+        def unregister
+          observer.unobserve(observable, property)
+        end
+        alias unobserve unregister
+      end
+
       class << self
         def proc(&observer_block)
           Proc.new(&observer_block)
@@ -35,8 +42,8 @@ module Glimmer
         @registrations ||= Set.new
       end
 
-      def registrations_for(observable, property = nil)
-        registrations.select {|o, p| o == observable && p == property}
+      def registration_for(observable, property = nil)
+        Registration.new(observer: self, observable: observable, property: property)
       end
 
       # mapping of registrations to dependents
@@ -52,36 +59,27 @@ module Glimmer
       # registers observer in an observable on a property (optional)
       # observer maintains registration list to unregister later
       def register(observable, property = nil)
-        # pd property, announcer: '[OBSERVE]', header: true
-        # pd observable, announcer: '[OBSERVE]'
-        # pd self, announcer: '[OBSERVE]'
         unless observable.is_a?(Observable)
-          # pd 'not an observable'
           # TODO refactor code to be more smart/polymorphic/automated and honor open/closed principle
           if observable.is_a?(Array)
-            # pd 'array'
             observable.extend(ObservableArray)
           else
-            # pd 'not array'
             observable.extend(ObservableModel)
           end
         end
-        # pd 'adding observer', announcer: '[OBSERVE]'
-        # pd [self, property], announcer: '[OBSERVE]'
         observable.add_observer(*[self, property].compact)
-        # pd 'adding registration', announcer: '[OBSERVE]'
-        [observable, property].tap do |registration|
+        registration_for(observable, property).tap do |registration|
           self.registrations << registration
         end
       end
       alias observe register
 
       def unregister(observable, property = nil)
+        # TODO optimize performance in the future via indexing and/or making a registration official object/class
         observable.remove_observer(*[self, property].compact)
-        registration = [observable, property]
+        registration = registration_for(observable, property)
         dependents_for(registration).each do |dependent|
-          dependent_observer, dependent_observable, dependent_property = dependent
-          dependent_observer.unregister(dependent_observable, dependent_property)
+          dependent.unregister
           remove_dependent(registration => dependent)
         end
         registrations.delete(registration)
@@ -89,32 +87,32 @@ module Glimmer
       alias unobserve unregister
 
       def unregister_dependents_with_observable(registration, dependent_observable)
-        thedependents = dependents_for(registration).select do |d_observer, d_observable, d_property|
-          d_observable == dependent_observable
+        thedependents = dependents_for(registration).select do |thedependent|
+          thedependent.observable == dependent_observable
         end
-        thedependents.each do |d_observer, d_observable, d_property|
-          d_observer.unregister(d_observable, d_property)
+        thedependents.each do |thedependent|
+          thedependent.unregister
         end
       end
 
       # cleans up all registrations in observables
       def unregister_all_observables
-        registrations.each do |observable, property|
-          unregister(observable, property)
+        registrations.each do |registration|
+          registration.unregister
         end
       end
       alias unobserve_all_observables unregister_all_observables
 
       # add dependent observer to unregister when unregistering observer
       def add_dependent(parent_to_dependent_hash)
-        observable, property = registration = parent_to_dependent_hash.keys.first
-        dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
+        registration = parent_to_dependent_hash.keys.first
+        dependent = parent_to_dependent_hash.values.first
         dependents_for(registration) << dependent
       end
 
       def remove_dependent(parent_to_dependent_hash)
-        observable, property = registration = parent_to_dependent_hash.keys.first
-        dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
+        registration = parent_to_dependent_hash.keys.first
+        dependent = parent_to_dependent_hash.values.first
         dependents_for(registration).delete(dependent)
       end
 

data/lib/glimmer/swt/table_items_binding.rb

@@ -19,11 +19,9 @@ module Glimmer
         call(@model_binding.evaluate_property)
         model = model_binding.base_model
         observe(model, model_binding.property_name_expression)
-        add_contents(@table) {
-          on_widget_disposed { |dispose_event|
-            unregister_all_observables
-          }
-        }
+        @table.on_widget_disposed do |dispose_event|
+          unregister_all_observables
+        end
       end
       def call(model_collection=nil)
         if model_collection and model_collection.is_a?(Array)