glimmer-dsl-swt 4.18.4.3 → 4.18.4.8

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

@@ -24,22 +24,70 @@ module Glimmer
     module Custom
       # Represents SWT drawable controls (widgets like canvas) and display
       module Drawable
+        attr_accessor :requires_shape_disposal, :image_double_buffered
+        alias requires_shape_disposal? requires_shape_disposal
+        alias image_double_buffered? image_double_buffered
+        
+        include_package 'org.eclipse.swt.graphics'
+      
         def shapes
           @shapes ||= []
         end
         
+        def image_buffered_shapes
+          @image_buffered_shapes ||= []
+        end
+        
+        def add_shape(shape)
+          if !@image_double_buffered || shape.args.first == @image_proxy_buffer
+            shapes << shape
+          else
+            image_buffered_shapes << shape
+          end
+        end
+        
         def clear_shapes
-          shapes.dup.each(&:dispose)
+          # Optimize further by having a collection of disposable_shapes independent of shapes, which is much smaller and only has shapes that require disposal (shapes with patterns or image)
+          shapes.dup.each(&:dispose) if requires_shape_disposal?
+        end
+        
+        def deregister_shape_painting
+          @paint_listener_proxy&.deregister
         end
         
-        def resetup_shape_painting
+        def setup_shape_painting
           # TODO consider performance optimization relating to order of shape rendering (affecting only further shapes not previous ones)
-          reset_gc if respond_to?(:reset_gc)
-          shapes.each do |shape|
-            shape.paint_listener_proxy&.unregister
-            shape.setup_painting
+          if @paint_listener_proxy.nil?
+            shape_painter = lambda do |paint_event|
+              shape_painting_work = lambda do |paint_event|
+                paintable_shapes = @image_double_buffered ? image_buffered_shapes : shapes
+                paintable_shapes.each do |shape|
+                  shape.paint(paint_event)
+                end
+              end
+              if @image_double_buffered
+                if @image_proxy_buffer.nil?
+                  swt_image = Image.new(DisplayProxy.instance.swt_display, bounds.width, bounds.height)
+                  @image_proxy_buffer = ImageProxy.new(swt_image: swt_image)
+                  shape_painting_work.call(@image_proxy_buffer)
+                end
+                @image_proxy_buffer.shape(self).paint(paint_event)
+              else
+                shape_painting_work.call(paint_event)
+              end
+            end
+            
+            # TODO consider making this logic polymorphic (image vs other)
+            if respond_to?(:swt_image)
+              shape_painter.call(self) # treat self as paint event since image has its own gc and doesn't do repaints (it's a one time deal for now though could be adjusted in the future.)
+            else
+              @paint_listener_proxy = on_swt_paint(&shape_painter)
+            end
+          else
+            redraw if @finished_add_content && !is_disposed
           end
         end
+        alias resetup_shape_painting setup_shape_painting
       end
       
     end

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

@@ -39,7 +39,7 @@ module Glimmer
         
         class << self
           def valid?(parent, keyword, *args, &block)
-            gc_instance_methods.include?(method_name(keyword, args))
+            gc_instance_methods.include?(method_name(keyword, arg_options(args)))
           end
           
           def gc_instance_methods
@@ -62,14 +62,14 @@ module Glimmer
             options.nil? ? {} : options.symbolize_keys
           end
           
-          def method_name(keyword, args)
-            method_arg_options = arg_options(args)
+          def method_name(keyword, method_arg_options)
+            keyword = keyword.to_s
+            method_arg_options = method_arg_options.select {|key, value| %w[fill gradient round].include?(key.to_s)}
             unless flyweight_method_names.keys.include?([keyword, method_arg_options])
-              keyword = keyword.to_s
-              gradient = 'gradient_' if method_arg_options[:gradient]
-              round = 'round_' if method_arg_options[:round]
-              gc_instance_method_name_prefix = !['polyline', 'point', 'image', 'focus'].include?(keyword) && (method_arg_options[:fill] || method_arg_options[:gradient]) ? 'fill_' : 'draw_'
-              flyweight_method_names[[keyword, method_arg_options]] = "#{gc_instance_method_name_prefix}#{gradient}#{round}#{keyword}"
+              gradient = 'Gradient' if method_arg_options[:gradient]
+              round = 'Round' if method_arg_options[:round]
+              gc_instance_method_name_prefix = !['polyline', 'point', 'image', 'focus'].include?(keyword) && (method_arg_options[:fill] || method_arg_options[:gradient]) ? 'fill' : 'draw'
+              flyweight_method_names[[keyword, method_arg_options]] = "#{gc_instance_method_name_prefix}#{gradient}#{round}#{keyword.capitalize}"
             end
             flyweight_method_names[[keyword, method_arg_options]]
           end
@@ -91,16 +91,19 @@ module Glimmer
           end
         end
         
-        attr_reader :parent, :name, :args, :options, :paint_listener_proxy
+        attr_reader :parent, :name, :args, :options
         
         def initialize(parent, keyword, *args, &property_block)
           @parent = parent
           @name = keyword
-          @method_name = self.class.method_name(keyword, args)
           @options = self.class.arg_options(args, extract: true)
+          @method_name = self.class.method_name(keyword, @options)
           @args = args
           @properties = {}
-          @parent.shapes << self
+          @options.reject {|key, value| %w[fill gradient round].include?(key.to_s)}.each do |property, property_args|
+            @properties[property] = property_args
+          end
+          @parent.add_shape(self)
           post_add_content if property_block.nil?
         end
         
@@ -129,15 +132,20 @@ module Glimmer
         end
         
         def post_add_content
-          amend_method_name_options_based_on_properties
-          setup_painting
-          @content_added = true
+          unless @content_added
+            amend_method_name_options_based_on_properties!
+            @parent.setup_shape_painting unless @parent.is_a?(ImageProxy)
+            @content_added = true
+          end
         end
         
         def apply_property_arg_conversions(method_name, property, args)
           args = args.dup
           the_java_method = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.detect {|m| m.name == method_name}
-          if (args.first.is_a?(Symbol) || args.first.is_a?(String))
+          if ['setBackground', 'setForeground'].include?(method_name.to_s) && args.first.is_a?(Array)
+            args[0] = ColorProxy.new(args[0])
+          end
+          if args.first.is_a?(Symbol) || args.first.is_a?(String)
             if the_java_method.parameter_types.first == Color.java_class
               args[0] = ColorProxy.new(args[0])
             end
@@ -158,6 +166,7 @@ module Glimmer
             args[0] = args[0].swt_transform
           end
           if ['setBackgroundPattern', 'setForegroundPattern'].include?(method_name.to_s)
+            @parent.requires_shape_disposal = true
             args.each_with_index do |arg, i|
               if arg.is_a?(Symbol) || arg.is_a?(String)
                 args[i] = ColorProxy.new(arg).swt_color
@@ -172,41 +181,49 @@ module Glimmer
           args
         end
         
-        def apply_shape_arg_conversions(method_name, args)
-          if args.size > 1 && (method_name.include?('polygon') || method_name.include?('polyline'))
-            args[0] = args.dup
-            args[1..-1] = []
+        def apply_shape_arg_conversions!
+          if @args.size > 1 && (['polygon', 'polyline'].include?(@name))
+            @args[0] = @args.dup
+            @args[1..-1] = []
           end
         end
         
-        def apply_shape_arg_defaults(method_name, args)
-          if method_name.include?('round_rectangle') && args.size.between?(4, 5)
-            (6 - args.size).times {args << 60}
-          elsif method_name.include?('rectangle') && gradient? && args.size == 4
-            args << true
-          elsif (method_name.include?('text') || method_name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && args.size == 3
-            args << true
-          end
-          if method_name.include?('image') && args.first.is_a?(String)
-            args[0] = ImageProxy.new(args[0])
+        def apply_shape_arg_defaults!
+          if @name.include?('rectangle') && round? && @args.size.between?(4, 5)
+            (6 - @args.size).times {@args << 60}
+          elsif @name.include?('rectangle') && gradient? && @args.size == 4
+            @args << true
+          elsif (@name.include?('text') || @name.include?('String')) && !@properties.keys.map(&:to_s).include?('background') && @args.size == 3
+            @args << true
           end
-          if method_name.include?('image') && args.first.is_a?(ImageProxy)
-            @image = args[0] = args[0].swt_image
+          if @name.include?('image')
+            @parent.requires_shape_disposal = true
+            if @args.size == 1
+              @args[1] = 0
+              @args[2] = 0
+            end
+            if @args.first.is_a?(String)
+              @args[0] = ImageProxy.new(@args[0])
+            end
+            if @args.first.is_a?(ImageProxy)
+              @image = @args[0] = @args[0].swt_image
+            end
           end
         end
                 
         # Tolerates shape extra args added by user by mistake
         # (e.g. happens when switching from round rectangle to a standard one without removing all extra args)
-        def tolerate_shape_extra_args(method_name, args)
+        def tolerate_shape_extra_args!
           the_java_method_arg_count = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.select do |m|
-            m.name == method_name.camelcase(:lower)
+            m.name == @method_name.camelcase(:lower)
           end.map(&:parameter_types).map(&:size).max
-          if args.size > the_java_method_arg_count
-            args[the_java_method_arg_count..-1] = []
+          if @args.size > the_java_method_arg_count
+            @args[the_java_method_arg_count..-1] = []
           end
         end
         
-        def amend_method_name_options_based_on_properties
+        def amend_method_name_options_based_on_properties!
+          return if @name == 'point'
           if has_some_background? && !has_some_foreground?
             @options[:fill] = true
           elsif !has_some_background? && has_some_foreground?
@@ -218,7 +235,7 @@ module Glimmer
           if @name == 'rectangle' && @args.size > 4 && @args.last.is_a?(Numeric)
             @options[:round] = true
           end
-          @method_name = self.class.method_name(@name, @args + [@options])
+          @method_name = self.class.method_name(@name, @options)
         end
                 
         def has_attribute?(attribute_name, *args)
@@ -228,7 +245,7 @@ module Glimmer
         def set_attribute(attribute_name, *args)
           @properties[attribute_name] = args
           if @content_added && !@parent.is_disposed
-            @parent.resetup_shape_painting
+            @calculated_paint_args = false
             @parent.redraw
           end
         end
@@ -247,7 +264,6 @@ module Glimmer
         end
         
         def dispose
-          paint_listener_proxy&.unregister
           @background_pattern&.dispose
           @background_pattern = nil
           @foreground_pattern&.dispose
@@ -257,36 +273,51 @@ module Glimmer
           @parent.shapes.delete(self)
         end
         
-        def setup_painting
-          # TODO consider moving this method to parent (making the logic polymorphic)
-          return if @parent.is_disposed
-          if parent.respond_to?(:swt_display)
-            @paint_listener_proxy = @parent.on_swt_paint(&method(:paint))
-          elsif parent.respond_to?(:swt_image)
-            paint(parent) # treat parent as paint event since you don't do repaints with images, it's a one time deal.
-          elsif parent.respond_to?(:swt_widget)
-            @paint_listener_proxy = @parent.on_paint_control(&method(:paint))
-          end
-        end
-        
         def paint(paint_event)
-          @properties['background'] = [@parent.background] if fill? && !has_some_background?
-          @properties['foreground'] = [@parent.foreground] if @parent.respond_to?(:foreground) && draw? && !has_some_foreground?
-          @properties['font'] = [@parent.font] if @parent.respond_to?(:font) && draw? && !@properties.keys.map(&:to_s).include?('font')
-          @properties['transform'] = [nil] if @parent.respond_to?(:transform) && !@properties.keys.map(&:to_s).include?('transform')
+          calculate_paint_args!
           @properties.each do |property, args|
             method_name = attribute_setter(property)
-            converted_args = apply_property_arg_conversions(method_name, property, args)
-            paint_event.gc.send(method_name, *converted_args)
+            # TODO consider optimization of not setting a background/foreground/font if it didn't change from last shape
+            paint_event.gc.send(method_name, *args)
             if property == 'transform' && args.first.is_a?(TransformProxy)
               args.first.swt_transform.dispose
             end
           end
-          apply_shape_arg_conversions(@method_name, @args)
-          apply_shape_arg_defaults(@method_name, @args)
-          tolerate_shape_extra_args(@method_name, @args)
           paint_event.gc.send(@method_name, *@args)
         end
+        
+        def calculate_paint_args!
+          unless @calculated_paint_args
+            if @name == 'point'
+              # optimized performance calculation for pixel points
+              if !@properties[:foreground].is_a?(Color)
+                if @properties[:foreground].is_a?(Array)
+                  @properties[:foreground] = ColorProxy.new(@properties[:foreground], ensure_bounds: false)
+                end
+                if @properties[:foreground].is_a?(Symbol) || @properties[:foreground].is_a?(String)
+                 @properties[:foreground] = ColorProxy.new(@properties[:foreground], ensure_bounds: false)
+                end
+                if @properties[:foreground].is_a?(ColorProxy)
+                  @properties[:foreground] = @properties[:foreground].swt_color
+                end
+              end
+            else
+              @properties['background'] = [@parent.background] if fill? && !has_some_background?
+              @properties['foreground'] = [@parent.foreground] if @parent.respond_to?(:foreground) && draw? && !has_some_foreground?
+              @properties['font'] = [@parent.font] if @parent.respond_to?(:font) && draw? && !@properties.keys.map(&:to_s).include?('font')
+              @properties['transform'] = [nil] if @parent.respond_to?(:transform) && !@properties.keys.map(&:to_s).include?('transform')
+              @properties.each do |property, args|
+                method_name = attribute_setter(property)
+                converted_args = apply_property_arg_conversions(method_name, property, args)
+                @properties[property] = converted_args
+              end
+              apply_shape_arg_conversions!
+              apply_shape_arg_defaults!
+              tolerate_shape_extra_args!
+              @calculated_paint_args = true
+            end
+          end
+        end
     
       end
       

data/lib/glimmer/swt/display_proxy.rb

@@ -81,15 +81,15 @@ module Glimmer
       end
       
       def async_exec(&block)
-        @swt_display.async_exec(&block)
+        @swt_display.asyncExec(&block)
       end
 
       def sync_exec(&block)
-        @swt_display.sync_exec(&block)
+        @swt_display.syncExec(&block)
       end
 
-      def timer_exec(&block)
-        @swt_display.timer_exec(&block)
+      def timer_exec(delay_in_millis, &block)
+        @swt_display.timerExec(delay_in_millis, &block)
       end
       
       def on_widget_disposed(&block)
@@ -137,12 +137,13 @@ module Glimmer
           add_swt_event_filter(constant_name, &block)
         elsif observation_request.start_with?('on_')
           event_name = observation_request.sub(/^on_/, '')
-          if OBSERVED_MENU_ITEMS.include?(event_name)
-            if OS.mac?
-              system_menu = swt_display.getSystemMenu
-              menu_item = system_menu.getItems.find {|menu_item| menu_item.getID == SWTProxy["ID_#{event_name.upcase}"]}
-              menu_item.addListener(SWTProxy[:Selection], &block)
-            end
+          if OBSERVED_MENU_ITEMS.include?(event_name) && OS.mac?
+            system_menu = swt_display.getSystemMenu
+            menu_item = system_menu.getItems.find {|menu_item| menu_item.getID == SWTProxy["ID_#{event_name.upcase}"]}
+            display_mac_event_registration = menu_item.addListener(SWTProxy[:Selection], &block)
+            # TODO enable this code and test on the Mac to ensure automatic cleanup of mac event registrations in custom widgets
+#             Glimmer::UI::CustomWidget.current_custom_widgets.last&.observer_registrations&.push(display_mac_event_registration)
+            display_mac_event_registration
           end
         end
       end

data/lib/glimmer/swt/image_proxy.rb

@@ -32,7 +32,7 @@ module Glimmer
     class ImageProxy
       include Custom::Drawable
       include Properties
-      
+            
       class << self
         def create(*args)
           if args.size == 1 && args.first.is_a?(ImageProxy)
@@ -53,6 +53,7 @@ module Glimmer
       # Takes the same args as the SWT Image class
       # Alternatively, takes a file path string or a uri:classloader file path string (generated by JRuby when invoking `File.expand_path` inside a JAR file)
       # and returns an image object.
+      # Last but not least, it could serve as a parent for nesting shapes underneath to build an image with the Canvas Shape DSL
       def initialize(*args, &content)
         @args = args
         @parent_proxy = nil
@@ -62,7 +63,7 @@ module Glimmer
         end
         options = @args.last.is_a?(Hash) ? @args.delete_at(-1) : {}
         options[:swt_image] = @args.first if @args.size == 1 && @args.first.is_a?(Image)
-        @file_path = @args.first if @args.size == 1 && @args.first.is_a?(String)
+        @file_path = @args.first if @args.first.is_a?(String)
         @args = @args.first if @args.size == 1 && @args.first.is_a?(Array)
         if options&.keys&.include?(:swt_image)
           @swt_image = options[:swt_image]
@@ -78,23 +79,33 @@ module Glimmer
           height = (@image_data.height.to_f / @image_data.width.to_f)*width.to_f if !width.nil? && height.nil?
           width = (@image_data.width.to_f / @image_data.height.to_f)*height.to_f if !height.nil? && width.nil?
           scale_to(width, height) unless width.nil? || height.nil?
-        else
+        elsif !@args.first.is_a?(ImageProxy) && !@args.first.is_a?(Image)
           @args.prepend(DisplayProxy.instance.swt_display) unless @args.first.is_a?(Display)
           @swt_image = Image.new(*@args)
           @original_image_data = @image_data = @swt_image.image_data
         end
-        @swt_image.singleton_class.alias_method(:dispose_without_glimmer, :dispose)
         proxy = self
         # TODO consider adding a get_data/set_data method to conform with other SWT widgets
         @swt_image.singleton_class.define_method(:dispose) do
           proxy.clear_shapes
-          dispose_without_glimmer
+          super
         end
         post_add_content if content.nil?
       end
       
       def post_add_content
-        @parent&.image = swt_image
+        if shapes.any?
+          setup_shape_painting
+        end
+        if @parent.respond_to?('image=')
+          @parent&.image = swt_image
+        end
+      end
+      
+      def shape(parent_proxy = nil, args = nil)
+        parent_proxy ||= @parent_proxy
+        args ||= [self] # TODO consider passing args if available
+        @shape ||= Glimmer::SWT::Custom::Shape.new(parent_proxy, 'image', *args)
       end
       
       def input_stream

data/lib/glimmer/swt/properties.rb

@@ -22,28 +22,53 @@
 module Glimmer
   module SWT
     module Properties
+      class << self
+        def ruby_attribute_setter(attribute_name)
+          @ruby_attribute_setters ||= {}
+          @ruby_attribute_setters[attribute_name] ||= "#{normalized_attribute(attribute_name)}="
+        end
+  
+        def attribute_setter(attribute_name)
+          @attribute_setters ||= {}
+          @attribute_setters[attribute_name] ||= "set#{normalized_attribute(attribute_name).camelcase(:upper)}"
+        end
+  
+        def attribute_getter(attribute_name)
+          @attribute_getters ||= {}
+          @attribute_getters[attribute_name] ||= "get#{normalized_attribute(attribute_name).camelcase(:upper)}"
+        end
+        
+        def normalized_attribute(attribute_name)
+          @normalized_attributes ||= {}
+          if @normalized_attributes[attribute_name].nil?
+            attribute_name = attribute_name.to_s if attribute_name.is_a?(Symbol)
+            attribute_name = attribute_name.underscore unless attribute_name.downcase?
+            attribute_name = attribute_name.sub(/^get_/, '') if attribute_name.start_with?('get_')
+            attribute_name = attribute_name.sub(/^set_/, '') if attribute_name.start_with?('set_')
+            attribute_name = attribute_name.sub(/=$/, '') if attribute_name.end_with?('=')
+            @normalized_attributes[attribute_name] = attribute_name
+          end
+          @normalized_attributes[attribute_name]
+        end
+        alias ruby_attribute_getter normalized_attribute
+      end
+      
       def ruby_attribute_setter(attribute_name)
-        "#{normalized_attribute(attribute_name)}="
+        Glimmer::SWT::Properties.ruby_attribute_setter(attribute_name)
       end
 
       def attribute_setter(attribute_name)
-        "set#{normalized_attribute(attribute_name).camelcase(:upper)}"
+        Glimmer::SWT::Properties.attribute_setter(attribute_name)
       end
 
       def attribute_getter(attribute_name)
-        "get#{normalized_attribute(attribute_name).camelcase(:upper)}"
+        Glimmer::SWT::Properties.attribute_getter(attribute_name)
       end
       
       def normalized_attribute(attribute_name)
-        attribute_name = attribute_name.to_s if attribute_name.is_a?(Symbol)
-        attribute_name = attribute_name.underscore unless attribute_name.downcase?
-        attribute_name = attribute_name.sub(/^get_/, '') if attribute_name.start_with?('get_')
-        attribute_name = attribute_name.sub(/^set_/, '') if attribute_name.start_with?('set_')
-        attribute_name = attribute_name.sub(/=$/, '') if attribute_name.end_with?('=')
-        attribute_name
+        Glimmer::SWT::Properties.normalized_attribute(attribute_name)
       end
       alias ruby_attribute_getter normalized_attribute
-      
     end
   end
 end