glimmer-dsl-swt 4.18.4.8 → 4.18.5.1

data/lib/glimmer/swt/color_proxy.rb

@@ -33,7 +33,7 @@ module Glimmer
       include_package 'org.eclipse.swt.graphics'
       
       class << self
-        def flyweight(*args)
+        def create(*args)
           flyweight_color_proxies[args] ||= new(*args)
         end
         

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

@@ -64,6 +64,18 @@ module Glimmer
           respond_to?(method_name)
         end
         
+        def can_handle_observation_request?(observation_request)
+          @styled_text_proxy.can_handle_observation_request?(observation_request)
+        rescue
+          super
+        end
+        
+        def handle_observation_request(observation_request, &block)
+          @styled_text_proxy.handle_observation_request(observation_request, &block)
+        rescue
+          super
+        end
+        
         def root_block=(block)
           body_root.content(&block)
         end
@@ -124,13 +136,13 @@ module Glimmer
                 editable false
                 caret nil
                 on_focus_gained {
-                  @styled_text_proxy&.swt_widget.setFocus
+                  @styled_text_proxy&.setFocus
                 }
                 on_key_pressed {
-                  @styled_text_proxy&.swt_widget.setFocus
+                  @styled_text_proxy&.setFocus
                 }
                 on_mouse_up {
-                  @styled_text_proxy&.swt_widget.setFocus
+                  @styled_text_proxy&.setFocus
                 }
               }
 
@@ -153,19 +165,29 @@ module Glimmer
             top_margin 5
             right_margin 5
             bottom_margin 5
+            tabs 2
             
             if default_behavior
               on_key_pressed { |event|
                 character = event.keyCode.chr rescue nil
                 case [event.stateMask, character]
                 when [(OS.mac? ? swt(:command) : swt(:ctrl)), 'a']
-                  @styled_text_proxy.swt_widget.selectAll
+                  @styled_text_proxy.selectAll
                 when [(swt(:ctrl) if OS.mac?), 'a']
                   jump_to_beginning_of_line
                 when [(swt(:ctrl) if OS.mac?), 'e']
                   jump_to_end_of_line
                 end
               }
+              on_verify_text { |verify_event|
+                if verify_event.text == "\n"
+                  line_index = verify_event.widget.get_line_at_offset(verify_event.widget.get_caret_offset)
+                  line = verify_event.widget.get_line(line_index)
+                  line_indent = line.match(/^([ ]*)/)[1].to_s.size
+                  verify_event.text += ' '*line_indent
+                  verify_event.text += ' '*2 if line.strip.end_with?('{') || line.strip.match(/do([ ]*[|][^|]*[|])?$/) || line.start_with?('class') || line.start_with?('module') || line.strip.start_with?('def')
+                end
+              }
             end
             
             on_modify_text { |event|
@@ -241,17 +263,17 @@ module Glimmer
         end
         
         def jump_to_beginning_of_line
-          current_line_index = @styled_text_proxy.swt_widget.getLineAtOffset(@styled_text_proxy.swt_widget.getCaretOffset)
-          beginning_of_current_line_offset = @styled_text_proxy.swt_widget.getOffsetAtLine(current_line_index)
-          @styled_text_proxy.swt_widget.setSelection(beginning_of_current_line_offset, beginning_of_current_line_offset)
+          current_line_index = @styled_text_proxy.getLineAtOffset(@styled_text_proxy.getCaretOffset)
+          beginning_of_current_line_offset = @styled_text_proxy.getOffsetAtLine(current_line_index)
+          @styled_text_proxy.setSelection(beginning_of_current_line_offset, beginning_of_current_line_offset)
         end
         
         def jump_to_end_of_line
-          current_line_index = @styled_text_proxy.swt_widget.getLineAtOffset(@styled_text_proxy.swt_widget.getCaretOffset)
-          current_line = @styled_text_proxy.swt_widget.getLine(current_line_index)
-          beginning_of_current_line_offset = @styled_text_proxy.swt_widget.getOffsetAtLine(current_line_index)
+          current_line_index = @styled_text_proxy.getLineAtOffset(@styled_text_proxy.getCaretOffset)
+          current_line = @styled_text_proxy.getLine(current_line_index)
+          beginning_of_current_line_offset = @styled_text_proxy.getOffsetAtLine(current_line_index)
           new_offset = beginning_of_current_line_offset + current_line.size
-          @styled_text_proxy.swt_widget.setSelection(new_offset, new_offset)
+          @styled_text_proxy.setSelection(new_offset, new_offset)
         end
       end
     end

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

@@ -38,6 +38,10 @@ module Glimmer
           @image_buffered_shapes ||= []
         end
         
+        def shape_at_location(x, y)
+          shapes.reverse.detect {|shape| shape.include?(x, y)}
+        end
+        
         def add_shape(shape)
           if !@image_double_buffered || shape.args.first == @image_proxy_buffer
             shapes << shape
@@ -46,9 +50,53 @@ module Glimmer
           end
         end
         
-        def clear_shapes
+        def clear_shapes(dispose_images: true, dispose_patterns: true)
           # 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?
+          shapes.dup.each {|s| s.dispose(dispose_images: dispose_images, dispose_patterns: dispose_patterns) } if requires_shape_disposal?
+        end
+        
+        def paint_pixel_by_pixel(width = nil, height = nil, &each_pixel_color)
+          if @image_double_buffered
+            work = lambda do |paint_event|
+              width ||= swt_drawable.bounds.width
+              height ||= swt_drawable.bounds.height
+              @image_proxy_buffer ||= ImageProxy.create_pixel_by_pixel(width, height, &each_pixel_color)
+              @image_proxy_buffer.shape(self).paint(paint_event)
+            end
+          else
+            work = lambda do |paint_event_or_image|
+              the_gc = paint_event_or_image.gc
+              current_foreground = nil
+              width ||= swt_drawable.bounds.width
+              height ||= swt_drawable.bounds.height
+              height.times do |y|
+                width.times do |x|
+                  new_foreground = each_pixel_color.call(x, y)
+                  new_foreground = Glimmer::SWT::ColorProxy.create(new_foreground, ensure_bounds: false) unless new_foreground.is_a?(ColorProxy) || new_foreground.is_a?(Color)
+                  new_foreground = new_foreground.swt_color if new_foreground.is_a?(Glimmer::SWT::ColorProxy)
+                  the_gc.foreground = current_foreground = new_foreground unless new_foreground == current_foreground
+                  the_gc.draw_point x, y
+                end
+              end
+            end
+          end
+          if respond_to?(:gc)
+            work.call(self)
+          else
+            on_swt_paint(&work)
+          end
+        end
+        
+        def swt_drawable
+          swt_drawable = nil
+          if respond_to?(:swt_image)
+            swt_drawable = swt_image
+          elsif respond_to?(:swt_display)
+            swt_drawable = swt_display
+          elsif respond_to?(:swt_widget)
+            swt_drawable = swt_widget
+          end
+          swt_drawable
         end
         
         def deregister_shape_painting

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

@@ -73,7 +73,8 @@ module Glimmer
         end
         
         def can_handle_observation_request?(observation_request)
-          radios.first&.can_handle_observation_request?(observation_request) || super(observation_request)
+          radios.first&.can_handle_observation_request?(observation_request) or
+            super(observation_request)
         end
         
         def handle_observation_request(observation_request, &block)

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

@@ -38,6 +38,15 @@ module Glimmer
         # TODO support a Pattern DSL for methods that take Pattern arguments
         
         class << self
+          def create(parent, keyword, *args, &property_block)
+            potential_shape_class_name = keyword.to_s.camelcase(:upper).to_sym
+            if constants.include?(potential_shape_class_name)
+              const_get(potential_shape_class_name).new(parent, keyword, *args, &property_block)
+            else
+              new(parent, keyword, *args, &property_block)
+            end
+          end
+        
           def valid?(parent, keyword, *args, &block)
             gc_instance_methods.include?(method_name(keyword, arg_options(args)))
           end
@@ -79,15 +88,15 @@ module Glimmer
           end
           
           def pattern(*args)
-            found_pattern = flyweigh_patterns[args]
+            found_pattern = flyweight_patterns[args]
             if found_pattern.nil? || found_pattern.is_disposed
-              found_pattern = flyweigh_patterns[args] = org.eclipse.swt.graphics.Pattern.new(*args)
+              found_pattern = flyweight_patterns[args] = org.eclipse.swt.graphics.Pattern.new(*args)
             end
             found_pattern
           end
           
-          def flyweigh_patterns
-            @flyweigh_patterns ||= {}
+          def flyweight_patterns
+            @flyweight_patterns ||= {}
           end
         end
         
@@ -123,6 +132,29 @@ module Glimmer
           @options[:round]
         end
         
+        # subclasses (like polygon) may override to indicate if a point x,y coordinates fall inside the shape
+        # has a default implementation for rectangle and oval
+        def include?(x, y)
+          case @name
+          when 'rectangle', 'oval', 'arc'
+            self_x = self.x
+            self_y = self.y
+            width = self.width
+            height = self.height
+            x.between?(self_x, self_x + width) && y.between?(self_y, self_y + height)
+          else
+            false
+          end
+        end
+        
+        def move_by(x_delta, y_delta)
+          case @name
+          when 'rectangle', 'oval', 'arc'
+            self.x += x_delta
+            self.y += y_delta
+          end
+        end
+        
         def has_some_background?
           @properties.keys.map(&:to_s).include?('background') || @properties.keys.map(&:to_s).include?('background_pattern')
         end
@@ -142,6 +174,9 @@ module Glimmer
         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 the_java_method.parameter_types.first == Color.java_class && args.first.is_a?(RGB)
+            args[0] = [args[0].red, args[0].green, args[0].blue]
+          end
           if ['setBackground', 'setForeground'].include?(method_name.to_s) && args.first.is_a?(Array)
             args[0] = ColorProxy.new(args[0])
           end
@@ -156,7 +191,7 @@ module Glimmer
           if args.first.is_a?(ColorProxy)
             args[0] = args[0].swt_color
           end
-          if args.first.is_a?(Hash) && the_java_method.parameter_types.first == Font.java_class
+          if (args.first.is_a?(Hash) || args.first.is_a?(FontData)) && the_java_method.parameter_types.first == Font.java_class
             args[0] = FontProxy.new(args[0])
           end
           if args.first.is_a?(FontProxy)
@@ -167,15 +202,22 @@ module Glimmer
           end
           if ['setBackgroundPattern', 'setForegroundPattern'].include?(method_name.to_s)
             @parent.requires_shape_disposal = true
+            args = args.first if args.first.is_a?(Array)
             args.each_with_index do |arg, i|
-              if arg.is_a?(Symbol) || arg.is_a?(String)
-                args[i] = ColorProxy.new(arg).swt_color
-              elsif arg.is_a?(ColorProxy)
-                args[i] = arg.swt_color
-              end
+              arg = ColorProxy.new(arg.red, arg.green, arg.blue) if arg.is_a?(RGB)
+              arg = ColorProxy.new(arg) if arg.is_a?(Symbol) || arg.is_a?(String)
+              arg = arg.swt_color if arg.is_a?(ColorProxy)
+              args[i] = arg
             end
-            new_args = [DisplayProxy.instance.swt_display] + args
-            args[0] = pattern(*new_args, type: method_name.to_s.match(/set(.+)Pattern/)[1])
+            @pattern_args ||= {}
+            pattern_type = method_name.to_s.match(/set(.+)Pattern/)[1]
+            if args.first.is_a?(Pattern)
+              new_args = @pattern_args[pattern_type]
+            else
+              new_args = args.first.is_a?(Display) ? args : ([DisplayProxy.instance.swt_display] + args)
+              @pattern_args[pattern_type] = new_args.dup
+            end
+            args[0] = pattern(*new_args, type: pattern_type)
             args[1..-1] = []
           end
           args
@@ -186,6 +228,28 @@ module Glimmer
             @args[0] = @args.dup
             @args[1..-1] = []
           end
+          if @name == 'image'
+            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
+            if @args.first.nil?
+              @image = nil
+            end
+          end
+          if @name == 'text'
+            if @args[3].is_a?(Symbol) || @args[3].is_a?(String)
+              @args[3] = [@args[3]]
+            end
+            if @args[3].is_a?(Array)
+              if @args[3].size == 1 && @args[3].first.is_a?(Array)
+                @args[3] = @args[3].first
+              end
+              @args[3] = SWTProxy[*@args[3]]
+            end
+          end
         end
         
         def apply_shape_arg_defaults!
@@ -202,12 +266,6 @@ module Glimmer
               @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
                 
@@ -217,14 +275,14 @@ module Glimmer
           the_java_method_arg_count = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.select do |m|
             m.name == @method_name.camelcase(:lower)
           end.map(&:parameter_types).map(&:size).max
-          if @args.size > the_java_method_arg_count
+          if the_java_method_arg_count && @args.to_a.size > the_java_method_arg_count
             @args[the_java_method_arg_count..-1] = []
           end
         end
         
         def amend_method_name_options_based_on_properties!
           return if @name == 'point'
-          if has_some_background? && !has_some_foreground?
+          if @name != 'text' && has_some_background? && !has_some_foreground?
             @options[:fill] = true
           elsif !has_some_background? && has_some_foreground?
             @options[:fill] = false
@@ -237,13 +295,39 @@ module Glimmer
           end
           @method_name = self.class.method_name(@name, @options)
         end
-                
+        
+        # parameter names for arguments to pass to SWT GC.xyz method for rendering shape (e.g. draw_image(image, x, y) yields :image, :x, :y parameter names)
+        def parameter_names
+          []
+        end
+        
+        def possible_parameter_names
+          parameter_names
+        end
+        
+        def parameter_name?(attribute_name)
+          possible_parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
+        end
+        
+        def parameter_index(attribute_name)
+          parameter_names.map(&:to_s).index(attribute_name.to_s)
+        end
+        
+        def set_parameter_attribute(attribute_name, *args)
+          @args[parameter_index(ruby_attribute_getter(attribute_name))] = args.size == 1 ? args.first : args
+        end
+        
         def has_attribute?(attribute_name, *args)
-          self.class.gc_instance_methods.include?(attribute_setter(attribute_name))
+          self.class.gc_instance_methods.include?(attribute_setter(attribute_name)) or
+            parameter_name?(attribute_name)
         end
   
         def set_attribute(attribute_name, *args)
-          @properties[attribute_name] = args
+          if parameter_name?(attribute_name)
+            set_parameter_attribute(attribute_name, *args)
+          else
+            @properties[ruby_attribute_getter(attribute_name)] = args
+          end
           if @content_added && !@parent.is_disposed
             @calculated_paint_args = false
             @parent.redraw
@@ -251,28 +335,66 @@ module Glimmer
         end
         
         def get_attribute(attribute_name)
-          @properties.symbolize_keys[attribute_name.to_s.to_sym]
+          if parameter_name?(attribute_name)
+            @args[parameter_index(attribute_name)]
+          else
+            @properties.symbolize_keys[attribute_name.to_s.to_sym]
+          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
+            super
+          end
+        end
+        
+        def respond_to?(method_name, *args, &block)
+          if has_attribute?(method_name)
+            true
+          else
+            super
+          end
         end
         
         def pattern(*args, type: nil)
           instance_variable_name = "@#{type}_pattern"
           the_pattern = instance_variable_get(instance_variable_name)
-          if the_pattern.nil?
+          if the_pattern.nil? || the_pattern.is_disposed
             the_pattern = self.class.pattern(*args)
           end
           the_pattern
         end
         
-        def dispose
-          @background_pattern&.dispose
-          @background_pattern = nil
-          @foreground_pattern&.dispose
-          @foreground_pattern = nil
-          @image&.dispose
-          @image = nil
-          @parent.shapes.delete(self)
+        def pattern_args(type: nil)
+          @pattern_args && @pattern_args[type.to_s.capitalize]
+        end
+        
+        def background_pattern_args
+          pattern_args(type: 'background')
         end
         
+        def foreground_pattern_args
+          pattern_args(type: 'foreground')
+        end
+        
+        def dispose(dispose_images: true, dispose_patterns: true)
+          if dispose_patterns
+            @background_pattern&.dispose
+            @background_pattern = nil
+            @foreground_pattern&.dispose
+            @foreground_pattern = nil
+          end
+          if dispose_images
+            @image&.dispose
+            @image = nil
+          end
+          @parent.shapes.delete(self)
+        end
+                
         def paint(paint_event)
           calculate_paint_args!
           @properties.each do |property, args|
@@ -284,11 +406,15 @@ module Glimmer
             end
           end
           paint_event.gc.send(@method_name, *@args)
+        rescue => e
+          Glimmer::Config.logger.error {"Error encountered in painting shape: #{self.inspect}"}
+          Glimmer::Config.logger.error {e.full_message}
         end
         
         def calculate_paint_args!
           unless @calculated_paint_args
-            if @name == 'point'
+            if @name == 'pixel'
+              @name = 'point'
               # optimized performance calculation for pixel points
               if !@properties[:foreground].is_a?(Color)
                 if @properties[:foreground].is_a?(Array)
@@ -304,7 +430,11 @@ module Glimmer
             else
               @properties['background'] = [@parent.background] if fill? && !has_some_background?
               @properties['foreground'] = [@parent.foreground] if @parent.respond_to?(:foreground) && draw? && !has_some_foreground?
+              # TODO regarding alpha, make sure to reset it to parent stored alpha once we allow setting shape properties on parents directly without shapes
+              @properties['alpha'] ||= [255]
               @properties['font'] = [@parent.font] if @parent.respond_to?(:font) && draw? && !@properties.keys.map(&:to_s).include?('font')
+              # TODO regarding transform, make sure to reset it to parent stored alpha once we allow setting shape properties on parents directly without shapes
+              # Also do that with all future-added properties
               @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)
@@ -326,3 +456,5 @@ module Glimmer
   end
   
 end
+
+Dir[File.expand_path(File.join(__dir__, 'shape', '**', '*.rb'))].each {|shape_file| require(shape_file)}