glimmer-dsl-swt 4.18.5.2 → 4.18.6.1

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

@@ -26,6 +26,34 @@ require 'glimmer/swt/color_proxy'
 require 'glimmer/swt/font_proxy'
 require 'glimmer/swt/transform_proxy'
 
+class Java::OrgEclipseSwtGraphics::GC
+  def setLineDashOffset(value)
+    lineMiterLimit = getLineAttributes&.miterLimit || 999_999
+    setLineAttributes(Java::OrgEclipseSwtGraphics::LineAttributes.new(getLineWidth, getLineCap, getLineJoin, getLineStyle, getLineDash.map(&:to_f).to_java(:float), value, lineMiterLimit))
+  end
+  alias set_line_dash_offset setLineDashOffset
+  alias line_dash_offset= setLineDashOffset
+  
+  def getLineDashOffset
+    getLineAttributes&.dashOffset
+  end
+  alias get_line_dash_offset getLineDashOffset
+  alias line_dash_offset getLineDashOffset
+  
+  def setLineMiterLimit(value)
+    lineDashOffset = getLineAttributes&.dashOffset || 0
+    setLineAttributes(Java::OrgEclipseSwtGraphics::LineAttributes.new(getLineWidth, getLineCap, getLineJoin, getLineStyle, getLineDash.map(&:to_f).to_java(:float), lineDashOffset, value))
+  end
+  alias set_line_miter_limit setLineMiterLimit
+  alias line_miter_limit= setLineMiterLimit
+  
+  def getLineMiterLimit
+    getLineAttributes&.miterLimit
+  end
+  alias get_line_miter_limit getLineMiterLimit
+  alias line_miter_limit getLineMiterLimit
+end
+
 module Glimmer
   module SWT
     module Custom
@@ -46,7 +74,8 @@ module Glimmer
           end
         
           def valid?(parent, keyword, *args, &block)
-            gc_instance_methods.include?(method_name(keyword, arg_options(args)))
+            gc_instance_methods.include?(method_name(keyword, arg_options(args))) ||
+              constants.include?(keyword.to_s.camelcase(:upper).to_sym)
           end
           
           def gc_instance_methods
@@ -99,6 +128,7 @@ module Glimmer
         end
         
         attr_reader :drawable, :parent, :name, :args, :options, :shapes
+        attr_accessor :extent
         
         def initialize(parent, keyword, *args, &property_block)
           @parent = parent
@@ -118,6 +148,7 @@ module Glimmer
         
         def add_shape(shape)
           @shapes << shape
+          calculated_args_changed_for_defaults!
         end
         
         def draw?
@@ -138,34 +169,67 @@ module Glimmer
           @options[:round]
         end
         
-        # subclasses (like polygon) may override to indicate if a point x,y coordinates falls inside the shape
+        # The bounding box top-left x, y, width, height in absolute positioning
+        def bounds
+          org.eclipse.swt.graphics.Rectangle.new(absolute_x, absolute_y, calculated_width, calculated_height)
+        end
+        
+        # The bounding box top-left x and y
+        def location
+          org.eclipse.swt.graphics.Point.new(bounds.x, bounds.y)
+        end
+        
+        # The bounding box width and height (as a Point object with x being width and y being height)
+        def size
+          org.eclipse.swt.graphics.Point.new(calculated_width, calculated_height)
+        end
+        
+        def extent
+          @extent || size
+        end
+        
+        # Returns if shape contains a point
+        # Subclasses (like polygon) may override to indicate if a point x,y coordinates falls inside the shape
         # some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly
         def contain?(x, y)
           # assume a rectangular filled shape by default (works for several shapes like image, text, and focus)
-          if respond_to?(:x) && respond_to?(:y) && respond_to?(:width) && respond_to?(:height) && self.x && self.y && width && height
-            x.between?(self.x, self.x + width) && y.between?(self.y, self.y + height)
-          else
-            false # subclasses must provide implementation
-          end
+          x.between?(self.absolute_x, self.absolute_x + calculated_width) && y.between?(self.absolute_y, self.absolute_y + calculated_height)
         end
         
-        # subclasses (like polygon) may override to indicate if a point x,y coordinates falls on the edge of a drawn shape or inside a filled shape
+        # Returns if shape includes a point. When the shape is filled, this is the same as contain. When the shape is drawn, it only returns true if the point lies on the edge (boundary/border)
+        # Subclasses (like polygon) may override to indicate if a point x,y coordinates falls on the edge of a drawn shape or inside a filled shape
         # some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly
         def include?(x, y)
           # assume a rectangular shape by default
-          if respond_to?(:x) && respond_to?(:y) && respond_to?(:width) && respond_to?(:height)
-            contain?(x, y)
-          else
-            false # subclasses must provide implementation
-          end
+          contain?(x, y)
+        end
+
+        # Indicates if a shape's x, y, width, height differ from its bounds calculation (e.g. arc / polygon)
+        def irregular?
+          false
         end
         
         # moves by x delta and y delta. Subclasses must implement
         # provdies a default implementation that assumes moving x and y is sufficient by default (not for polygons though, which must override)
         def move_by(x_delta, y_delta)
-          if respond_to?(:x) && respond_to?(:y) && x && y
-            self.x += x_delta
-            self.y += y_delta
+          if respond_to?(:x) && respond_to?(:y) && respond_to?(:x=) && respond_to?(:y=)
+            if default_x?
+              self.default_x_delta += x_delta
+            else
+              self.x += x_delta
+            end
+            if default_y?
+              self.default_y_delta += y_delta
+            else
+              self.y += y_delta
+            end
+          end
+        end
+        
+        def content(&block)
+          Glimmer::SWT::DisplayProxy.instance.auto_exec do
+            Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShapeExpression.new, &block)
+            calculated_args_changed!(children: false)
           end
         end
         
@@ -178,8 +242,8 @@ module Glimmer
         end
         
         def post_add_content
-          unless @content_added
-            amend_method_name_options_based_on_properties!
+          amend_method_name_options_based_on_properties!
+          if !@content_added || @method_name != @original_method_name
             @drawable.setup_shape_painting unless @drawable.is_a?(ImageProxy)
             @content_added = true
           end
@@ -188,12 +252,17 @@ 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}
+          return args if the_java_method.nil?
           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
+          if method_name.to_s == 'setLineDash' && args.size > 1
+            args[0] = args.dup
+            args[1..-1] = []
+          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])
@@ -267,19 +336,21 @@ module Glimmer
         end
         
         def apply_shape_arg_defaults!
+          self.x = :default if current_parameter_name?(:x) && x.nil?
+          self.y = :default if current_parameter_name?(:y) && y.nil?
+          self.dest_x = :default if current_parameter_name?(:dest_x) && dest_x.nil?
+          self.dest_y = :default if current_parameter_name?(:dest_y) && dest_y.nil?
+          self.width = :default if current_parameter_name?(:width) && width.nil?
+          self.height = :default if current_parameter_name?(:height) && height.nil?
           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 # vertical is true by default
-          elsif (@name.include?('text') || @name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && @args.size == 3
-            @args << true # is_transparent is true by default
+            set_attribute('vertical', true, redraw: false)
+          elsif (@name.include?('text') || @name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && @args.size < 4
+            set_attribute('is_transparent', true, redraw: false)
           end
           if @name.include?('image')
             @drawable.requires_shape_disposal = true
-            if @args.size == 1
-              @args[1] = 0
-              @args[2] = 0
-            end
           end
         end
                 
@@ -295,6 +366,7 @@ module Glimmer
         end
         
         def amend_method_name_options_based_on_properties!
+          @original_method_name = @method_name
           return if @name == 'point'
           if @name != 'text' && @name != 'string' && has_some_background? && !has_some_foreground?
             @options[:fill] = true
@@ -315,6 +387,12 @@ module Glimmer
           []
         end
         
+        # subclasses may override to specify location parameter names if different from x and y (e.g. all polygon points are location parameters)
+        # used in calculating movement changes
+        def location_parameter_names
+          [:x, :y]
+        end
+        
         def possible_parameter_names
           parameter_names
         end
@@ -323,8 +401,12 @@ module Glimmer
           possible_parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
         end
         
+        def current_parameter_name?(attribute_name)
+          parameter_names.include?(attribute_name.to_s.to_sym)
+        end
+        
         def parameter_index(attribute_name)
-          parameter_names.map(&:to_s).index(attribute_name.to_s)
+          parameter_names.index(attribute_name.to_s.to_sym)
         end
         
         def set_parameter_attribute(attribute_name, *args)
@@ -333,18 +415,35 @@ module Glimmer
         
         def has_attribute?(attribute_name, *args)
           self.class.gc_instance_methods.include?(attribute_setter(attribute_name)) or
-            parameter_name?(attribute_name)
+            parameter_name?(attribute_name) or
+            (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
         end
-  
+        
         def set_attribute(attribute_name, *args)
+          options = args.last if args.last.is_a?(Hash)
+          args.pop if !options.nil? && !options[:redraw].nil?
+          perform_redraw = @perform_redraw
+          perform_redraw = options[:redraw] if perform_redraw.nil? && !options.nil?
+          perform_redraw = true if perform_redraw.nil?
           if parameter_name?(attribute_name)
             set_parameter_attribute(attribute_name, *args)
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
+            self.send(ruby_attribute_setter(attribute_name), *args)
           else
             @properties[ruby_attribute_getter(attribute_name)] = args
           end
-          if @content_added && !@drawable.is_disposed
+          if @content_added && perform_redraw && !drawable.is_disposed
             @calculated_paint_args = false
-            @drawable.redraw
+            attribute_name = ruby_attribute_getter(attribute_name)
+            if location_parameter_names.map(&:to_s).include?(attribute_name)
+              @calculated_args = nil
+              parent.calculated_args_changed_for_defaults! if parent.is_a?(Shape)
+            end
+            if ['width', 'height'].include?(attribute_name)
+              calculated_args_changed_for_defaults!
+            end
+            # TODO consider redrawing an image proxy's gc in the future
+            drawable.redraw unless drawable.is_a?(ImageProxy)
           end
         end
         
@@ -352,6 +451,8 @@ module Glimmer
           if parameter_name?(attribute_name)
             arg_index = parameter_index(attribute_name)
             @args[arg_index] if arg_index
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
+            self.send(attribute_name)
           else
             @properties.symbolize_keys[attribute_name.to_s.to_sym]
           end
@@ -368,7 +469,9 @@ module Glimmer
         end
         
         def respond_to?(method_name, *args, &block)
-          if has_attribute?(method_name)
+          options = args.last if args.last.is_a?(Hash)
+          super_invocation = options && options[:super]
+          if !super_invocation && has_attribute?(method_name)
             true
           else
             super
@@ -397,6 +500,7 @@ module Glimmer
         end
         
         def dispose(dispose_images: true, dispose_patterns: true)
+          shapes.each { |shape| shape.is_a?(Shape::Path) && shape.dispose }
           if dispose_patterns
             @background_pattern&.dispose
             @background_pattern = nil
@@ -409,22 +513,297 @@ module Glimmer
           end
           @parent.shapes.delete(self)
         end
-                
+        
         def paint(paint_event)
+          # pre-paint children an extra-time first when default width/height need to be calculated for defaults
+          paint_children(paint_event) if default_width? || default_height?
+          paint_self(paint_event)
+          # re-paint children from scratch in the special case of pre-calculating parent width/height to re-center within new parent dimensions
+          shapes.each(&:calculated_args_changed!) if default_width? || default_height?
+          paint_children(paint_event)
+        rescue => e
+          Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with calculated args (#{@calculated_args}) and args (#{@args})"}
+          Glimmer::Config.logger.error {e.full_message}
+        end
+        
+        def paint_self(paint_event)
+          @painting = true
           calculate_paint_args!
+          @original_properties_backup = {}
           @properties.each do |property, args|
             method_name = attribute_setter(property)
-            # TODO consider optimization of not setting a background/foreground/font if it didn't change from last shape
+            @original_properties_backup[method_name] = paint_event.gc.send(method_name.sub('set', 'get')) rescue nil
             paint_event.gc.send(method_name, *args)
             if property == 'transform' && args.first.is_a?(TransformProxy)
               args.first.swt_transform.dispose
             end
           end
-          self.extent = paint_event.gc.send("#{@name}Extent", *(([string, flags] if respond_to?(:flags)).compact)) if ['text', 'string'].include?(@name)
-          paint_event.gc.send(@method_name, *@args)
+          ensure_extent(paint_event)
+          if !@calculated_args || parent_shape_absolute_location_changed?
+            @calculated_args = calculated_args
+          end
+          # 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?
+          @original_properties_backup.each do |method_name, value|
+            paint_event.gc.send(method_name, value)
+          end
+          @painting = false
         rescue => e
-          Glimmer::Config.logger.error {"Error encountered in painting shape: #{self.inspect}"}
+          Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with calculated args (#{@calculated_args}) and args (#{@args})"}
           Glimmer::Config.logger.error {e.full_message}
+        ensure
+          @painting = false
+        end
+        
+        def paint_children(paint_event)
+          shapes.to_a.each do |shape|
+            shape.paint(paint_event)
+          end
+        end
+        
+        def ensure_extent(paint_event)
+          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 = flags if current_parameter_name?(:flags)
+            extent_args << extent_flags unless extent_flags.nil?
+            self.extent = paint_event.gc.send("#{@name}Extent", *extent_args)
+          end
+          if !@extent.nil? && (old_extent&.x != @extent&.x || old_extent&.y != @extent&.y)
+            calculated_args_changed!
+            parent.calculated_args_changed_for_defaults! if parent.is_a?(Shape)
+          end
+        end
+        
+        def expanded_shapes
+          if shapes.to_a.any?
+            shapes.map do |shape|
+              [shape] + shape.expanded_shapes
+            end.flatten
+          else
+            []
+          end
+        end
+        
+        def parent_shape_absolute_location_changed?
+          (parent.is_a?(Shape) && (parent.absolute_x != @parent_absolute_x || parent.absolute_y != @parent_absolute_y))
+        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
+        
+        def calculated_args_changed_for_defaults!
+          has_default_dimensions = default_width? || default_height?
+          parent_calculated_args_changed_for_defaults = has_default_dimensions
+          @calculated_args = nil if default_x? || default_y? || has_default_dimensions
+          if has_default_dimensions && parent.is_a?(Shape)
+            parent.calculated_args_changed_for_defaults!
+          elsif @content_added && !drawable.is_disposed
+            # TODO consider optimizing in the future if needed by ensuring one redraw for all parents in the hierarchy at the end instead of doing one per parent that needs it
+            drawable.redraw if !@painting && !drawable.is_a?(ImageProxy)
+          end
+        end
+        
+        def calculated_args?
+          !!@calculated_args
+        end
+                
+        # args translated to absolute coordinates
+        def calculated_args
+          return @args if !default_x? && !default_y? && !default_width? && !default_height? && parent.is_a?(Drawable)
+          # Note: Must set x and move_by because not all shapes have a real x and some must translate all their points with move_by
+          # TODO change that by setting a bounding box for all shapes with a calculated top-left x, y and
+          # a setter that does the moving inside them instead so that I could rely on absolute_x and absolute_y
+          # here to get the job done of calculating absolute args
+          @perform_redraw = false
+          original_x = nil
+          original_y = nil
+          original_width = nil
+          original_height = nil
+          if parent.is_a?(Shape)
+            @parent_absolute_x = parent.absolute_x
+            @parent_absolute_y = parent.absolute_y
+          end
+          if default_width?
+            original_width = width
+            self.width = default_width + default_width_delta
+          end
+          if default_height?
+            original_height = height
+            self.height = default_height + default_height_delta
+          end
+          if default_x?
+            original_x = x
+            self.x = default_x + default_x_delta
+          end
+          if default_y?
+            original_y = y
+            self.y = default_y + default_y_delta
+          end
+          if parent.is_a?(Shape)
+            move_by(@parent_absolute_x, @parent_absolute_y)
+            result_args = @args.clone
+            move_by(-1*@parent_absolute_x, -1*@parent_absolute_y)
+          else
+            result_args = @args.clone
+          end
+          if original_x
+            self.x = original_x
+          end
+          if original_y
+            self.y = original_y
+          end
+          if original_width
+            self.width = original_width
+          end
+          if original_height
+            self.height = original_height
+          end
+          @perform_redraw = true
+          result_args
+        end
+        
+        def default_x?
+          current_parameter_name?(:x) and
+            (x.nil? || x.to_s == 'default' || (x.is_a?(Array) && x.first.to_s == 'default'))
+        end
+        
+        def default_y?
+          current_parameter_name?(:y) and
+            (y.nil? || y.to_s == 'default' || (y.is_a?(Array) && y.first.to_s == 'default'))
+        end
+        
+        def default_width?
+          return false unless current_parameter_name?(:width)
+          width = self.width
+          (width.nil? || width == :default || width == 'default' || (width.is_a?(Array) && (width.first.to_s == :default || width.first.to_s == 'default')))
+        end
+        
+        def default_height?
+          return false unless current_parameter_name?(:height)
+          height = self.height
+          (height.nil? || height == :default || height == 'default' || (height.is_a?(Array) && (height.first.to_s == :default || height.first.to_s == 'default')))
+        end
+        
+        def default_x
+          result = ((parent.size.x - size.x) / 2)
+          result += parent.bounds.x - parent.absolute_x if parent.is_a?(Shape) && parent.irregular?
+          result
+        end
+        
+        def default_y
+          result = ((parent.size.y - size.y) / 2)
+          result += parent.bounds.y - parent.absolute_y if parent.is_a?(Shape) && parent.irregular?
+          result
+        end
+        
+        def default_width
+          # TODO consider caching
+          x_ends = shapes.map do |shape|
+            shape_width = shape.calculated_width.to_f
+            shape_x = shape.default_x? ? 0 : shape.x.to_f
+            shape_x + shape_width
+          end
+          x_ends.max.to_f
+        end
+        
+        def default_height
+          # TODO consider caching
+          y_ends = shapes.map do |shape|
+            shape_height = shape.calculated_height.to_f
+            shape_y = shape.default_y? ? 0 : shape.y.to_f
+            shape_y + shape_height
+          end
+          y_ends.max.to_f
+        end
+        
+        def calculated_width
+          default_width? ? (default_width + default_width_delta) : width
+        end
+        
+        def calculated_height
+          default_height? ? (default_height + default_height_delta) : height
+        end
+        
+        def default_x_delta
+          return 0 unless default_x? && x.is_a?(Array)
+          x[1].to_f
+        end
+        
+        def default_y_delta
+          return 0 unless default_y? && y.is_a?(Array)
+          y[1].to_f
+        end
+        
+        def default_width_delta
+          return 0 unless default_width? && width.is_a?(Array)
+          width[1].to_f
+        end
+        
+        def default_height_delta
+          return 0 unless default_height? && height.is_a?(Array)
+          height[1].to_f
+        end
+        
+        def default_x_delta=(delta)
+          return unless default_x?
+          self.x = [:default, delta]
+        end
+        
+        def default_y_delta=(delta)
+          return unless default_y?
+          self.y = [:default, delta]
+        end
+        
+        def default_width_delta=(delta)
+          return unless default_width?
+          self.width = [:default, delta]
+        end
+        
+        def default_height_delta=(delta)
+          return unless default_height?
+          self.height = [:default, delta]
+        end
+        
+        def calculated_x
+          result = default_x? ? default_x : self.x
+          result += default_x_delta
+          result
+        end
+        
+        def calculated_y
+          result = default_y? ? default_y : self.y
+          result += default_y_delta
+          result
+        end
+        
+        def absolute_x
+          x = calculated_x
+          if parent.is_a?(Shape)
+            parent.absolute_x + x
+          else
+            x
+          end
+        end
+        
+        def absolute_y
+          y = calculated_y
+          if parent.is_a?(Shape)
+            parent.absolute_y + y
+          else
+            y
+          end
+        end
+        
+        # Overriding inspect to avoid printing very long shape hierarchies
+        def inspect
+          "#<#{self.class.name}:0x#{self.hash.to_s(16)} args=#{@args.inspect}, properties=#{@properties.inspect}}>"
+        rescue => e
+          "#<#{self.class.name}:0x#{self.hash.to_s(16)}"
         end
         
         def calculate_paint_args!
@@ -449,7 +828,7 @@ module Glimmer
               # 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'] = [@drawable.font] if @drawable.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
+              # TODO regarding transform, make sure to reset it to parent stored transform once we allow setting shape properties on parents directly without shapes
               # Also do that with all future-added properties
               @properties['transform'] = [nil] if @drawable.respond_to?(:transform) && !@properties.keys.map(&:to_s).include?('transform')
               @properties.each do |property, args|