glimmer-dsl-swt 4.22.0.0 → 4.22.2.0

data/lib/glimmer/swt/custom/shape.rb

@@ -25,6 +25,7 @@ require 'glimmer/swt/display_proxy'
 require 'glimmer/swt/color_proxy'
 require 'glimmer/swt/font_proxy'
 require 'glimmer/swt/transform_proxy'
+require 'glimmer/swt/shape_listener_proxy'
 
 class Java::OrgEclipseSwtGraphics::GC
   def setLineDashOffset(value)
@@ -65,7 +66,7 @@ module Glimmer
         DropEvent = Struct.new(:doit, :x, :y, :dragged_shape, :dragged_shape_original_x, :dragged_shape_original_y, :dragging_x, :dragging_y, :drop_shapes, keyword_init: true)
         
         class << self
-          attr_accessor :dragging, :dragging_x, :dragging_y, :dragged_shape, :dragged_shape_original_x, :dragged_shape_original_y
+          attr_accessor :dragging, :dragging_x, :dragging_y, :dragged_shape, :dragged_shape_original_x, :dragged_shape_original_y, :drop_shape_handling_count
           alias dragging? dragging
         
           def create(parent, keyword, *args, &property_block)
@@ -132,15 +133,13 @@ module Glimmer
           def flyweight_patterns
             @flyweight_patterns ||= {}
           end
-          
-          # shapes that have defined on_drop expecting to received a dragged shape
-          def drop_shapes
-            @drop_shapes ||= []
-          end
         end
         
-        attr_reader :drawable, :parent, :name, :args, :options, :shapes, :properties
+        attr_reader :drawable, :parent, :name, :args, :options, :shapes, :properties, :disposed, :widget_listener_proxies
         attr_accessor :extent
+        alias disposed? disposed
+        alias is_disposed disposed # for SWT widget compatibility
+        # TODO consider making shapes return a dup, always, in case consumers want to dispose
         
         def initialize(parent, keyword, *args, &property_block)
           @parent = parent
@@ -229,20 +228,47 @@ module Glimmer
           contain?(x, y)
         end
 
-        def include_with_children?(x, y, except_child: nil)
-          included = include?(x, y)
-          included ||= expanded_shapes.reject {|shape| shape == except_child}.detect { |shape| shape.include?(x, y) }
+        def include_with_children?(x, y, except_shape: nil)
+          included_in_self = (!self.equal?(except_shape) && include?(x, y))
+          # TODO note that expanded shapes does not filter when reject below happens, keeping nested shapes
+          included_in_self || expanded_shapes(except_shape: except_shape).any? { |shape| shape.include?(x, y) }
+        end
+        
+        def bounds_contain?(x, y)
+          x, y = inverse_transform_point(x, y)
+          bounds.contains(x, y)
+        end
+        
+        # Recursively checks if other shape is included in this shape, beginning by comparing to self
+        # and then recursing into children shapes.
+        def include_shape?(other)
+          self == other || shapes.any? { |shape| shape.include_shape?(other) }
         end
         
+        # if there is a transform, apply on x, y point coordinates
+        def transform_point(x, y)
+          # keep in mind that transform is an array of a single element that is the transform object
+          current_transform = (transform || parent_shape_containers.map(&:transform).first)&.first
+          if current_transform
+            transform_array = [x, y].to_java(:float) # just placeholder data that gets overwritten with getElements
+            current_transform.transform(transform_array)
+            x = transform_array[0]
+            y = transform_array[1]
+          end
+          [x, y]
+        end
+
         # if there is a transform, invert it and apply on x, y point coordinates
         def inverse_transform_point(x, y)
-          current_transform = (transform || parent_shape_containers.map(&:transform).first)&.first
+          # keep in mind that transform is an array of a single element that is the transform object
+          current_transform = (transform || parent_shape_containers.map(&:transform).compact.first)&.first
           if current_transform
-            transform_array = [1,2,3,4,5,6].to_java(:float)
+            transform_array = [1,2,3,4,5,6].to_java(:float) # just placeholder data that gets overwritten with getElements
             current_transform.getElements(transform_array)
             inverse_transform = TransformProxy.new(DisplayProxy.instance.swt_display, *transform_array.to_a)
-            inverse_transform_array = [1,2,3,4,5,6].to_java(:float)
+            inverse_transform_array = [1,2,3,4,5,6].to_java(:float) # just placeholder data that gets overwritten with getElements
             inverse_transform.getElements(inverse_transform_array)
+            # TODO avoid Matrix usage directly by relying on SWT Transform#invert method instead (much simpler)
             matrix = Matrix[[inverse_transform_array[0], inverse_transform_array[1]], [inverse_transform_array[2], inverse_transform_array[3]]]
             result = matrix * Matrix.column_vector([x, y])
             x, y = result.to_a.flatten
@@ -315,6 +341,7 @@ module Glimmer
         end
         
         def content(&block)
+          # TODO consider supporting adding content without redraw (redraw: false)
           Glimmer::SWT::DisplayProxy.instance.auto_exec do
             Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShapeExpression.new, @name, &block)
             calculated_args_changed!(children: false)
@@ -601,17 +628,27 @@ module Glimmer
         end
         
         def can_handle_observation_request?(observation_request)
-          drawable.can_handle_observation_request?(observation_request)
-        end
-        
-        def handle_observation_request(observation_request, &block)
-          shape_block = lambda do |event|
-            block.call(event) if include_with_children?(event.x, event.y)
+          observation_request = observation_request.to_s
+          observation_request.start_with?('on_') &&
+          (
+            observation_request == 'on_shape_disposed' ||
+            (
+              drawable.respond_to?(:can_handle_observation_request?) &&
+              drawable.can_handle_observation_request?(observation_request)
+            )
+          )
+        end
+        
+        def handle_observation_request(observation_request, source_observation_request: nil, &block)
+          if observation_request.to_s == 'on_shape_disposed'
+            @on_shape_disposed_handlers ||= []
+            @on_shape_disposed_handlers << block
+            return ShapeListenerProxy.new(shape: self, drawable: drawable, shape_listener_block: block, observation_request: 'on_shape_disposed')
           end
           if observation_request == 'on_drop'
-            Shape.drop_shapes << self
-            handle_observation_request('on_mouse_up') do |event|
-              if Shape.dragging && include_with_children?(event.x, event.y, except_child: Shape.dragged_shape)
+            drawable.drop_shapes << self
+            handle_observation_request('on_mouse_up', source_observation_request: 'on_drop') do |event|
+              if Shape.dragging && include_with_children?(event.x, event.y, except_shape: Shape.dragged_shape)
                 drop_event = DropEvent.new(
                   doit: true,
                   dragged_shape: Shape.dragged_shape,
@@ -619,29 +656,56 @@ module Glimmer
                   dragged_shape_original_y: Shape.dragged_shape_original_y,
                   dragging_x: Shape.dragging_x,
                   dragging_y: Shape.dragging_y,
-                  drop_shapes: Shape.drop_shapes,
+                  drop_shapes: drawable.drop_shapes,
                   x: event.x,
                   y: event.y
                 )
                 begin
                   block.call(drop_event)
                 rescue => e
-                  Glimmer::Config.logger.error e.full_message
+                  Glimmer::Config.logger.error {e.full_message}
                 ensure
-                  Shape.dragging = false
-                  if !drop_event.doit && Shape.dragged_shape
-                    Shape.dragged_shape.x = Shape.dragged_shape_original_x
-                    Shape.dragged_shape.y = Shape.dragged_shape_original_y
+                  if drop_event.doit
+                    Shape.dragging = false
+                    Shape.dragged_shape = nil
+                  elsif Shape.drop_shape_handling_count.to_i >= drawable.drop_shapes.count && Shape.dragged_shape
+                    cancel_dragging!
                   end
-                  Shape.dragged_shape = nil
+                end
+              else
+                if Shape.drop_shape_handling_count.to_i >= drawable.drop_shapes.count
+                  cancel_dragging!
                 end
               end
             end
           else
-            drawable.handle_observation_request(observation_request, &shape_block)
+            widget_listener_proxy = nil
+            shape_block = lambda do |event|
+              if @disposed
+                widget_listener_proxy.deregister
+                @widget_listener_proxies.delete(widget_listener_proxy)
+              else
+                Shape.drop_shape_handling_count += 1 if source_observation_request == 'on_drop' && event.x == Shape.dragging_x && event.y == Shape.dragging_y
+                if !event.respond_to?(:x) || !event.respond_to?(:y) || include_with_children?(event.x, event.y)
+                  block.call(event)
+                elsif source_observation_request == 'on_drop' && Shape.drop_shape_handling_count.to_i >= drawable.drop_shapes.count
+                  cancel_dragging!
+                end
+              end
+            end
+            widget_listener_proxy = drawable.respond_to?(:handle_observation_request) && drawable.handle_observation_request(observation_request, &shape_block)
+            @widget_listener_proxies ||= []
+            if widget_listener_proxy
+              @widget_listener_proxies << widget_listener_proxy
+              ShapeListenerProxy.new(shape: self, drawable: drawable, shape_listener_block: shape_block, observation_request: source_observation_request || observation_request, widget_listener_proxy: widget_listener_proxy)
+            end
           end
         end
         
+        def remove_shape_disposed_listener(listener_block)
+          @on_shape_disposed_handlers.delete(listener_block)
+        end
+        
         # Sets data just like SWT widgets
         def set_data(key=nil, value)
           @data ||= {}
@@ -656,55 +720,75 @@ module Glimmer
         end
         alias getData get_data # for compatibility with SWT APIs
         alias data get_data # for compatibility with SWT APIs
+        
+        def shell_proxy
+          drawable.shell_proxy
+        end
   
+        def respond_to?(method_name, *args, &block)
+          options = args.last if args.last.is_a?(Hash)
+          super_invocation = options && options[:super]
+          if !super_invocation && has_attribute?(method_name)
+            true
+          else
+            result = super
+            return true if result
+            can_handle_observation_request?(method_name)
+          end
+        end
+        
         def method_missing(method_name, *args, &block)
           if method_name.to_s.end_with?('=')
             set_attribute(method_name, *args)
           elsif has_attribute?(method_name)
             get_attribute(method_name)
-          else # TODO support proxying calls to handle_observation_request for listeners just like WidgetProxy
+          elsif block && can_handle_observation_request?(method_name)
+            handle_observation_request(method_name, &block)
+          else
             super
           end
         end
         
-        def respond_to?(method_name, *args, &block)
-          options = args.last if args.last.is_a?(Hash)
-          super_invocation = options && options[:super]
-          if !super_invocation && has_attribute?(method_name)
-            true
-          else
-            super
-          end
+        def deregister_drag_listeners
+          @on_drag_detected&.deregister
+          @on_drag_detected = nil
+          @drawable_on_mouse_move&.deregister
+          @drawable_on_mouse_move = nil
+          @drawable_on_mouse_up&.deregister
+          @drawable_on_mouse_up = nil
         end
-          
+        
+        # Enables dragging for drag and move within parent widget
+        # drag_and_move and drag_source are mutually exclusive
+        # if shape had drag_source true, it is disabled by deregistering its listeners
         def drag_and_move=(drag_and_move_value)
+          deregister_drag_listeners if @drag_source
           drag_and_move_old_value = @drag_and_move
           @drag_and_move = drag_and_move_value
           if @drag_and_move && !drag_and_move_old_value
-            @on_drag_detected = handle_observation_request('on_drag_detected') do |event|
+            @on_drag_detected ||= handle_observation_request('on_drag_detected') do |event|
               Shape.dragging = true
               Shape.dragging_x = event.x
               Shape.dragging_y = event.y
+              Shape.drop_shape_handling_count = 0
               Shape.dragged_shape = self
               Shape.dragged_shape_original_x = x
               Shape.dragged_shape_original_y = y
             end
-            @drawable_on_mouse_move = drawable.handle_observation_request('on_mouse_move') do |event|
-              if Shape.dragging && Shape.dragged_shape == self
+            @drawable_on_mouse_move ||= drawable.handle_observation_request('on_mouse_move') do |event|
+              if Shape.dragging && Shape.dragged_shape.equal?(self)
                 Shape.dragged_shape.move_by((event.x - Shape.dragging_x), (event.y - Shape.dragging_y))
                 Shape.dragging_x = event.x
                 Shape.dragging_y = event.y
               end
             end
-            @drawable_on_mouse_up = drawable.handle_observation_request('on_mouse_up') do |event|
-              if Shape.dragging && Shape.dragged_shape == self
+            @drawable_on_mouse_up ||= drawable.handle_observation_request('on_mouse_up') do |event|
+              if Shape.dragging && Shape.dragged_shape.equal?(self)
                 Shape.dragging = false
               end
             end
           elsif !@drag_and_move && drag_and_move_old_value
-            @on_drag_detected.deregister
-            @drawable_on_mouse_move.deregister
-            @drawable_on_mouse_up.deregister
+            deregister_drag_listeners
           end
         end
             
@@ -712,44 +796,55 @@ module Glimmer
           @drag_and_move
         end
         
+        # Makes shape a drag source (enables dragging for drag and drop)
+        # drag_source and drag_and_move are mutually exclusive
+        # if shape had drag_and_move true, it is disabled by deregistering its listeners
         def drag_source=(drag_source_value)
+          deregister_drag_listeners if @drag_and_move
           drag_source_old_value = @drag_source
           @drag_source = drag_source_value
           if @drag_source && !drag_source_old_value
-            @on_drag_detected = handle_observation_request('on_drag_detected') do |event|
+            @on_drag_detected ||= handle_observation_request('on_drag_detected') do |event|
               Shape.dragging = true
               Shape.dragging_x = event.x
               Shape.dragging_y = event.y
+              Shape.drop_shape_handling_count = 0
               Shape.dragged_shape = self
               Shape.dragged_shape_original_x = x
               Shape.dragged_shape_original_y = y
             end
-            @drawable_on_mouse_move = drawable.handle_observation_request('on_mouse_move') do |event|
-              if Shape.dragging && Shape.dragged_shape == self
+            @drawable_on_mouse_move ||= drawable.handle_observation_request('on_mouse_move') do |event|
+              if Shape.dragging && Shape.dragged_shape.equal?(self)
                 Shape.dragged_shape.move_by((event.x - Shape.dragging_x), (event.y - Shape.dragging_y))
                 Shape.dragging_x = event.x
                 Shape.dragging_y = event.y
               end
             end
-            @drawable_on_mouse_up = drawable.handle_observation_request('on_mouse_up') do |event|
-              if Shape.dragging && Shape.dragged_shape == self && !Shape.drop_shapes.detect {|shape| shape.include_with_children?(event.x, event.y, except_child: Shape.dragged_shape)}
-                Shape.dragging = false
-                Shape.dragged_shape.x = Shape.dragged_shape_original_x
-                Shape.dragged_shape.y = Shape.dragged_shape_original_y
-                Shape.dragged_shape = nil
-              end
+            @drawable_on_mouse_up ||= drawable.handle_observation_request('on_mouse_up') do |event|
+              cancel_dragging! if Shape.dragging && Shape.dragged_shape.equal?(self) && !any_potential_drop_targets?(event.x, event.y)
             end
           elsif !@drag_source && drag_source_old_value
-            @on_drag_detected.deregister
-            @drawable_on_mouse_move.deregister
-            @drawable_on_mouse_up.deregister
+            deregister_drag_listeners
           end
         end
-            
+        
         def drag_source
           @drag_source
         end
         
+        def any_potential_drop_targets?(x, y)
+          drawable.drop_shapes.any? { |shape| shape.include_with_children?(x, y, except_shape: Shape.dragged_shape) }
+        end
+        
+        def cancel_dragging!
+          Shape.dragging = false
+          if Shape.dragged_shape
+            Shape.dragged_shape.x = Shape.dragged_shape_original_x
+            Shape.dragged_shape.y = Shape.dragged_shape_original_y
+            Shape.dragged_shape = nil
+          end
+        end
+        
         def pattern(*args, type: nil)
           instance_variable_name = "@#{type}_pattern"
           the_pattern = instance_variable_get(instance_variable_name)
@@ -772,7 +867,11 @@ module Glimmer
         end
         
         def dispose(dispose_images: true, dispose_patterns: true, redraw: true)
-          shapes.each { |shape| shape.is_a?(Shape::Path) && shape.dispose } # TODO look into why I'm only disposing paths
+          return if drawable.respond_to?(:shell_proxy) && drawable&.shell_proxy&.last_shell_closing?
+          return if @disposed
+          @disposed = true
+          deregister_drag_listeners
+          @widget_listener_proxies&.each(&:deregister)
           if dispose_patterns
             @background_pattern&.dispose
             @background_pattern = nil
@@ -783,7 +882,10 @@ module Glimmer
             @image&.dispose
             @image = nil
           end
+          shapes.dup.each { |shape| shape.dispose(dispose_images: dispose_images, dispose_patterns: dispose_patterns, redraw: false) }
           @parent.shapes.delete(self)
+          drawable.drop_shapes.delete(self)
+          @on_shape_disposed_handlers&.each {|handler| handler.call(self)} # TODO pass a custom event argument to handler
           drawable.redraw if redraw && !drawable.is_a?(ImageProxy)
         end
         
@@ -901,7 +1003,9 @@ module Glimmer
           @calculated_args ||= calculate_args!
           unless container?
             # paint unless parent's calculated args are not calculated yet, meaning it is about to get painted and trigger a paint on this child anyways
-            paint_event.gc.send(@method_name, *@calculated_args) unless (parent.is_a?(Shape) && !parent.calculated_args?)
+            passed_args = @calculated_args.dup
+            passed_args[0] = passed_args[0].to_java(:int) if @method_name == 'drawPolyline' # a weird fix needed for Linux JRuby 9.3.1.0 only (seems to lack a feature from Mac JRuby that automatically converts to appropriate java array type)
+            paint_event.gc.send(@method_name, *passed_args) unless (parent.is_a?(Shape) && !parent.calculated_args?)
             @original_gc_properties.each do |method_name, value|
               paint_event.gc.send(method_name, value)
             end
@@ -924,7 +1028,7 @@ module Glimmer
           old_extent = @extent
           if ['text', 'string'].include?(@name)
             extent_args = [string]
-            extent_flags = SWTProxy[:draw_transparent] if current_parameter_name?(:is_transparent) && is_transparent
+            extent_flags = SWTProxy[:draw_transparent, :draw_delimiter] if current_parameter_name?(:is_transparent) && is_transparent
             extent_flags = flags if current_parameter_name?(:flags)
             extent_args << extent_flags unless extent_flags.nil?
             self.extent = paint_event.gc.send("#{@name}Extent", *extent_args)
@@ -935,10 +1039,10 @@ module Glimmer
           end
         end
         
-        def expanded_shapes
+        def expanded_shapes(except_shape: nil)
           if shapes.to_a.any?
             shapes.map do |shape|
-              [shape] + shape.expanded_shapes
+              shape.equal?(except_shape) ? [] : ([shape] + shape.expanded_shapes(except_shape: except_shape))
             end.flatten
           else
             []
@@ -946,7 +1050,6 @@ module Glimmer
         end
         
         def calculated_args_changed!(children: true)
-          # TODO add a children: true option to enable setting to false to avoid recalculating children args
           @calculated_args = nil
           shapes.each(&:calculated_args_changed!) if children
         end
@@ -980,7 +1083,6 @@ module Glimmer
                 
         # args translated to absolute coordinates
         def calculate_args!
-        # TODO add conditions for parent having default width/height too
           return @args if parent.is_a?(Drawable) && !default_x? && !default_y? && !default_width? && !default_height? && !max_width? && !max_height?
           calculated_args_dependencies = [
             x,

data/lib/glimmer/swt/display_proxy.rb

@@ -68,6 +68,11 @@ module Glimmer
           instance # ensure instance
           @thread
         end
+        
+        # Current custom widgets, shells, and shapes being rendered. Useful to yoke all observers evaluated during rendering of their custom widgets/shells/shapes for automatical disposal on_widget_disposed/on_shape_disposed
+        def current_custom_widgets_and_shapes
+          @current_custom_widgets_and_shapes ||= []
+        end
       end
 
       # SWT Display object wrapped
@@ -160,21 +165,21 @@ module Glimmer
         @swt_display.isDisposed
       end
 
-      def method_missing(method, *args, &block)
-        if can_handle_observation_request?(method)
-          handle_observation_request(method, &block)
+      def method_missing(method_name, *args, &block)
+        if block && can_handle_observation_request?(method_name)
+          handle_observation_request(method_name, &block)
         else
-          swt_display.send(method, *args, &block)
+          swt_display.send(method_name, *args, &block)
         end
       rescue => e
-        Glimmer::Config.logger.debug {"Neither DisplayProxy nor #{swt_display.class.name} can handle the method ##{method}"}
+        Glimmer::Config.logger.debug {"Neither DisplayProxy nor #{swt_display.class.name} can handle the method ##{method_name}"}
         super
       end
       
-      def respond_to?(method, *args, &block)
+      def respond_to?(method_name, *args, &block)
         super ||
-          can_handle_observation_request?(method) ||
-          swt_display.respond_to?(method, *args, &block)
+          can_handle_observation_request?(method_name) ||
+          swt_display.respond_to?(method_name, *args, &block)
       end
 
       def can_handle_observation_request?(observation_request)
@@ -195,7 +200,7 @@ module Glimmer
         if observation_request.start_with?('on_swt_')
           constant_name = observation_request.sub(/^on_swt_/, '')
           swt_event_reg = add_swt_event_filter(constant_name, &block)
-          Glimmer::UI::CustomWidget.current_custom_widgets.last&.observer_registrations&.push(swt_event_reg)
+          DisplayProxy.current_custom_widgets_and_shapes.last&.observer_registrations&.push(swt_event_reg)
           swt_event_reg
         elsif observation_request.start_with?('on_')
           event_name = observation_request.sub(/^on_/, '')
@@ -205,7 +210,7 @@ module Glimmer
               menu_item = system_menu.getItems.find {|menu_item| menu_item.getID == SWTProxy["ID_#{event_name.upcase}"]}
               listener = ConcreteListener.new(&block)
               display_mac_event_registration = menu_item.addListener(SWTProxy[:Selection], listener)
-              Glimmer::UI::CustomWidget.current_custom_widgets.last&.observer_registrations&.push(display_mac_event_registration)
+              DisplayProxy.current_custom_widgets_and_shapes.last&.observer_registrations&.push(display_mac_event_registration)
               display_mac_event_registration
             end
           end

data/lib/glimmer/swt/image_proxy.rb

@@ -197,15 +197,15 @@ module Glimmer
         end
       end
       
-      def method_missing(method, *args, &block)
-        swt_image.send(method, *args, &block)
+      def method_missing(method_name, *args, &block)
+        swt_image.send(method_name, *args, &block)
       rescue => e
-        Glimmer::Config.logger.debug {"Neither ImageProxy nor #{swt_image.class.name} can handle the method ##{method}"}
+        Glimmer::Config.logger.debug {"Neither ImageProxy nor #{swt_image.class.name} can handle the method ##{method_name}"}
         super
       end
       
-      def respond_to?(method, *args, &block)
-        super || swt_image.respond_to?(method, *args, &block)
+      def respond_to?(method_name, *args, &block)
+        super || swt_image.respond_to?(method_name, *args, &block)
       end
     end
   end

data/lib/glimmer/swt/message_box_proxy.rb

@@ -80,23 +80,23 @@ module Glimmer
         end
       end
       
-      def method_missing(method, *args, &block)
+      def method_missing(method_name, *args, &block)
         DisplayProxy.instance.auto_exec do
-          swt_widget.send(method, *args, &block)
+          swt_widget.send(method_name, *args, &block)
         end
       rescue => e
         begin
           super
         rescue Exception => inner_error
-          Glimmer::Config.logger.error {"Neither MessageBoxProxy nor #{swt_widget.class.name} can handle the method ##{method}"}
+          Glimmer::Config.logger.error {"Neither MessageBoxProxy nor #{swt_widget.class.name} can handle the method ##{method_name}"}
           Glimmer::Config.logger.error {e.full_message}
           raise inner_error
         end
       end
       
-      def respond_to?(method, *args, &block)
+      def respond_to?(method_name, *args, &block)
         super ||
-          swt_widget.respond_to?(method, *args, &block)
+          swt_widget.respond_to?(method_name, *args, &block)
       end
     end
   end

data/lib/glimmer/swt/shape_listener_proxy.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2007-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.
+
+module Glimmer
+  module SWT
+    # Proxy for widget listeners
+    #
+    # Follows the Proxy Design Pattern
+    class ShapeListenerProxy
+
+      attr_reader :shape, :observation_request, :widget_listener_proxy
+
+      def initialize(shape: nil, drawable: nil, shape_listener_block: nil, observation_request: nil, widget_listener_proxy: nil)
+        @shape = shape
+        @drawable = drawable
+        @shape_listener_block = shape_listener_block
+        @observation_request = observation_request
+        @widget_listener_proxy = widget_listener_proxy
+      end
+      
+      # Deregisters shape listener
+      def deregister
+        if @observation_request == 'on_drop'
+          @widget_listener_proxy.deregister
+          @shape.widget_listener_proxies.delete(@widget_listener_proxy)
+          @drawable.drop_shapes.delete(shape)
+        elsif @observation_request == 'on_shape_disposed'
+          @shape.remove_shape_disposed_listener(@shape_listener_block)
+        else
+          @widget_listener_proxy.deregister
+          @shape.widget_listener_proxies.delete(@widget_listener_proxy)
+        end
+      end
+      alias unregister deregister # TODO consider dropping unregister (and in Observer too)
+    end
+  end
+end

data/lib/glimmer/swt/shell_proxy.rb

@@ -105,6 +105,7 @@ module Glimmer
           @swt_widget.setLocation(location_x, location_y)
         end
       end
+      alias center_in_display center_within_display
 
       # Opens shell and starts SWT's UI thread event loop
       def open

data/lib/glimmer/swt/transform_proxy.rb

@@ -111,14 +111,14 @@ module Glimmer
         begin
           super
         rescue Exception => inner_e
-          Glimmer::Config.logger.error {"Neither TransformProxy nor #{@swt_transform.class.name} can handle the method ##{method}"}
+          Glimmer::Config.logger.error {"Neither TransformProxy nor #{@swt_transform.class.name} can handle the method ##{method_name}"}
           Glimmer::Config.logger.error {e.full_message}
         end
       end
       
-      def respond_to?(method, *args, &block)
+      def respond_to?(method_name, *args, &block)
         super ||
-          @swt_transform.respond_to?(method, *args, &block)
+          @swt_transform.respond_to?(method_name, *args, &block)
       end
     end
   end

data/lib/glimmer/swt/tray_proxy.rb

@@ -41,12 +41,12 @@ module Glimmer
         @swt_widget = display_proxy.getSystemTray
       end
       
-      def method_missing(method, *args, &block)
-        @swt_widget.send(method, *args, &block)
+      def method_missing(method_name, *args, &block)
+        @swt_widget.send(method_name, *args, &block)
       end
       
-      def respond_to?(method, *args, &block)
-        super || @swt_widget.respond_to?(method, *args, &block)
+      def respond_to?(method_name, *args, &block)
+        super || @swt_widget.respond_to?(method_name, *args, &block)
       end
       
       def post_initialize_child(child)