glimmer-dsl-swt 4.18.5.1 → 4.18.6.0

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

@@ -36,6 +36,41 @@ module Glimmer
           def parameter_names
             [:x, :y, :width, :height, :start_angle, :arc_angle]
           end
+          
+          def bounds
+            shape_bounds = geometry.getBounds2D
+            org.eclipse.swt.graphics.Rectangle.new(shape_bounds.x, shape_bounds.y, shape_bounds.width, shape_bounds.height)
+          end
+          
+          def size
+            shape_bounds = geometry.getBounds2D
+            org.eclipse.swt.graphics.Point.new(shape_bounds.width, shape_bounds.height)
+          end
+          
+          def geometry
+            java.awt.geom.Arc2D::Double.new(self.absolute_x, self.absolute_y, calculated_width, calculated_height, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
+          end
+            
+          # checks if shape contains the point denoted by x and y
+          def contain?(x, y)
+            geometry.contains(x, y)
+          end
+          
+          def include?(x, y)
+            if filled?
+              contain?(x, y)
+            else
+              # give it some fuzz to allow a larger region around the drawn oval to accept including a point (helps with mouse clickability on a shape)
+              outer_shape_geometry = java.awt.geom.Arc2D::Double.new(self.absolute_x, self.absolute_y, calculated_width + 3, calculated_height + 3, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
+              inner_shape_geometry = java.awt.geom.Arc2D::Double.new(self.absolute_x, self.absolute_y, calculated_width - 3, calculated_height - 3, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
+              outer_shape_geometry.contains(x, y) && !inner_shape_geometry.contains(x, y)
+            end
+          end
+          
+          def irregular?
+            true
+          end
+          
         end
       end
     end

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

@@ -0,0 +1,108 @@
+# 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.
+
+require 'glimmer/swt/custom/shape'
+require 'glimmer/swt/custom/shape/path_segment'
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/color_proxy'
+require 'glimmer/swt/font_proxy'
+require 'glimmer/swt/transform_proxy'
+
+module Glimmer
+  module SWT
+    module Custom
+      # Represents a shape (graphics) to be drawn on a control/widget/canvas/display
+      # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
+      class Shape
+        class Cubic < Path
+          def parameter_names
+            [:point_array]
+          end
+          
+          def geometry
+            if @point_array != @geometry_point_array
+              @geometry_point_array = @point_array
+              @geometry = Java::JavaAwtGeom::Path2D::Double.new
+              @geometry.send(path_segment_geometry_method_name, *path_segment_geometry_args)
+            end
+            @geometry
+          end
+        
+          def contain?(x, y)
+            include?(x, y, filled: true)
+          end
+        
+          # checks if drawn or filled rectangle includes the point denoted by x and y (if drawn, it only returns true if point lies on the edge)
+          def include?(x, y, filled: nil)
+            filled = filled? if filled.nil?
+            makeshift_gc = org.eclipse.swt.graphics.GC.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+            swt_path = org.eclipse.swt.graphics.Path.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+            the_path_segment_args = path_segment_args.dup
+            if previous_point_connected?
+              the_previous_path_segment = previous_path_segment
+              swt_path.moveTo(the_previous_path_segment.x, the_previous_path_segment.y)
+            else
+              swt_path.moveTo(the_path_segment_args.shift, the_path_segment_args.shift)
+            end
+            swt_path.curveTo(*the_path_segment_args)
+            swt_path.contains(x.to_f, y.to_f, makeshift_gc, !filled)
+          ensure
+            swt_path.dispose
+          end
+            
+          def move_by(x_delta, y_delta)
+            the_point_array = @args.compact
+            the_point_array = the_point_array.first if the_point_array.first.is_a?(Array)
+            self.point_array = the_point_array.each_with_index.map {|coordinate, i| i.even? ? coordinate + x_delta : coordinate + y_delta}
+          end
+                              
+          def path_segment_method_name
+            'cubicTo'
+          end
+          
+          def path_segment_args
+            # TODO make args auto-infer control points if previous_point_connected is true or if there is only a point_array with 1 point
+            @args.to_a
+          end
+          
+          def path_segment_geometry_method_name
+            'curveTo'
+          end
+          
+          def previous_point_connected?
+            @args.compact.count <= 6 && !first_path_segment?
+          end
+          
+          def eql?(other)
+            point_array == (other && other.respond_to?(:point_array) && other.point_array)
+          end
+          alias == eql?
+          
+          def hash
+            point_array.hash
+          end
+                    
+        end
+      end
+    end
+  end
+end

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

@@ -29,9 +29,9 @@ require 'glimmer/swt/transform_proxy'
 module Glimmer
   module SWT
     module Custom
-      # Represents a shape (graphics) to be drawn on a control/widget/canvas/display
-      # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
       class Shape
+        # Represents a focus shape to be drawn on a control/widget/canvas/display
+        # Helps highlight focus on another selected shape
         class Focus < Shape
           def parameter_names
             [:x, :y, :width, :height]

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

@@ -62,20 +62,46 @@ module Glimmer
             end
           end
           
-          def include?(x, y)
-            self_x = dest_x || self.x
-            self_y = dest_y || self.y
-            width = dest_width || image.bounds.width
-            height = dest_height || image.bounds.height
-            x.between?(self_x, self_x + width) && y.between?(self_y, self_y + height)
+          def x
+            dest_x || get_attribute('x')
           end
-            
+          
+          def y
+            dest_y || get_attribute('y')
+          end
+          
+          def width
+            dest_width || image.bounds.width
+          end
+          
+          def height
+            dest_height || image.bounds.height
+          end
+          
+          def default_x?
+            super ||
+              current_parameter_name?(:dest_x) && (dest_x.nil? || dest_x.to_s == 'default')
+          end
+          
+          def default_y?
+            super ||
+              current_parameter_name?(:dest_y) && (dest_y.nil? || dest_y.to_s == 'default')
+          end
+          
           def move_by(x_delta, y_delta)
-            if dest_x
+            if default_x?
+              self.default_x_delta += x_delta
+            elsif dest_x
               self.dest_x += x_delta
-              self.dest_y += y_delta
             else
               self.x += x_delta
+            end
+            
+            if default_y?
+              self.default_y_delta += y_delta
+            elsif dest_y
+              self.dest_y += y_delta
+            else
               self.y += y_delta
             end
           end

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

@@ -20,6 +20,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'glimmer/swt/custom/shape'
+require 'glimmer/swt/custom/shape/path_segment'
 require 'glimmer/swt/swt_proxy'
 require 'glimmer/swt/display_proxy'
 require 'glimmer/swt/color_proxy'
@@ -33,17 +34,98 @@ module Glimmer
       # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
       class Shape
         class Line < Shape
+          include PathSegment
+          
+          class << self
+            def include?(x1, y1, x2, y2, x, y)
+              distance1 = Math.sqrt((x - x1)**2 + (y - y1)**2)
+              distance2 = Math.sqrt((x2 - x)**2 + (y2 - y)**2)
+              distance = Math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+              (distance1 + distance2).to_i == distance.to_i
+            end
+          end
+        
           def parameter_names
             [:x1, :y1, :x2, :y2]
           end
           
+          def location_parameter_names
+            parameter_names
+          end
+          
+          def bounds
+            shape_bounds = geometry.getBounds2D
+            org.eclipse.swt.graphics.Rectangle.new(shape_bounds.x, shape_bounds.y, shape_bounds.width, shape_bounds.height)
+          end
+          
+          def size
+            shape_bounds = geometry.getBounds2D
+            org.eclipse.swt.graphics.Point.new(shape_bounds.width, shape_bounds.height)
+          end
+          
+          def geometry
+            java.awt.geom.Line2D::Double.new(absolute_x1, absolute_y1, absolute_x2, absolute_y2)
+          end
+          
+          # Logical x coordinate relative to parent
+          def x
+            x_value = bounds.x
+            x_value -= parent.absolute_x if parent.is_a?(Shape)
+            x_value
+          end
+          
+          # Logical y coordinate relative to parent
+          def y
+            y_value = bounds.y
+            y_value -= parent.absolute_y if parent.is_a?(Shape)
+            y_value
+          end
+          
+          def width
+            size.x
+          end
+          
+          def height
+            size.y
+          end
+          
+          def absolute_x1
+            if parent.is_a?(Shape)
+              parent.absolute_x + x1
+            else
+              x1
+            end
+          end
+          
+          def absolute_y1
+            if parent.is_a?(Shape)
+              parent.absolute_y + y1
+            else
+              y1
+            end
+          end
+          
+          def absolute_x2
+            if parent.is_a?(Shape)
+              parent.absolute_x + x2.to_f
+            else
+              x2
+            end
+          end
+          
+          def absolute_y2
+            if parent.is_a?(Shape)
+              parent.absolute_y + y2.to_f
+            else
+              y2
+            end
+          end
+          
           def include?(x, y)
             # TODO must account for line width
-            distance1 = Math.sqrt((x - x1)**2 + (y - y1)**2)
-            distance2 = Math.sqrt((x2 - x)**2 + (y2 - y)**2)
-            distance = Math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
-            (distance1 + distance2).to_i == distance.to_i
+            Line.include?(absolute_x1, absolute_y1, absolute_x2, absolute_y2, x, y)
           end
+          alias contain? include?
             
           def move_by(x_delta, y_delta)
             self.x1 += x_delta
@@ -51,6 +133,41 @@ module Glimmer
             self.x2 += x_delta
             self.y2 += y_delta
           end
+          
+          def irregular?
+            true
+          end
+                    
+          def path_segment_method_name
+            'lineTo'
+          end
+          
+          def path_segment_args
+            # TODO make args auto-infer first point if previous_point_connected is true or if there is only x1,y1 or x2,y2 (but not both), or if there is an x, y, or if there is a point_array with 1 point
+            @args
+          end
+          
+          def path_segment_geometry_args
+            # TODO make args auto-infer first point if previous_point_connected is true or if there is only x1,y1 or x2,y2 (but not both), or if there is an x, y, or if there is a point_array with 1 point
+            @args[0..1]
+          end
+          
+          def previous_point_connected?
+            @args.compact.count == 2 && !first_path_segment?
+          end
+          
+          def eql?(other)
+            x1 == (other && other.respond_to?(:x1) && other.x1) &&
+              y1 == (other && other.respond_to?(:y1) && other.y1) &&
+              x2 == (other && other.respond_to?(:x2) && other.x2) &&
+              y2 == (other && other.respond_to?(:y2) && other.y2)
+          end
+          alias == eql?
+          
+          def hash
+            [x1, y1, x2, y2].hash
+          end
+                    
         end
       end
     end

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

@@ -36,6 +36,24 @@ module Glimmer
           def parameter_names
             [:x, :y, :width, :height]
           end
+          
+          # checks if shape contains the point denoted by x and y
+          def contain?(x, y)
+            shape_geometry = java.awt.geom.Ellipse2D::Double.new(self.absolute_x, self.absolute_y, calculated_width, calculated_height)
+            shape_geometry.contains(x, y)
+          end
+          
+          # checks if drawn or filled oval includes the point denoted by x and y (if drawn, it only returns true if point lies on the edge)
+          def include?(x, y)
+            if filled?
+              contain?(x, y)
+            else
+              # give it some fuzz to allow a larger region around the drawn oval to accept including a point (helps with mouse clickability on a shape)
+              outer_shape_geometry = java.awt.geom.Ellipse2D::Double.new(self.absolute_x - 3, self.absolute_y - 3, calculated_width + 6, calculated_height + 6)
+              inner_shape_geometry = java.awt.geom.Ellipse2D::Double.new(self.absolute_x + 3, self.absolute_y + 3, calculated_width - 6, calculated_height - 6)
+              outer_shape_geometry.contains(x, y) && !inner_shape_geometry.contains(x, y)
+            end
+          end
         end
       end
     end

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

@@ -0,0 +1,197 @@
+# 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.
+
+require 'glimmer/swt/custom/shape'
+require 'glimmer/swt/custom/shape/path_segment'
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/color_proxy'
+require 'glimmer/swt/font_proxy'
+require 'glimmer/swt/display_proxy'
+
+module Glimmer
+  module SWT
+    module Custom
+      # Represents a path to be drawn on a control/widget/canvas/display
+      # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
+      class Shape
+        class Path < Shape
+          include PathSegment # a path may behave as a path segment in another path
+          
+          attr_accessor :flatness, :closed
+          attr_reader :swt_path, :path_segments
+        
+          def initialize(parent, keyword, *args, &property_block)
+            super
+            @path_segments = []
+            @uncalculated_path_segments = []
+          end
+          
+          def parameter_names
+            [:swt_path]
+          end
+          
+          def add_shape(shape)
+            if shape.is_a?(PathSegment)
+              @path_segments << shape
+              @uncalculated_path_segments << shape
+            else
+              super
+            end
+          end
+          
+          def contain?(x, y)
+            makeshift_gc = org.eclipse.swt.graphics.GC.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+            @swt_path.contains(x.to_f, y.to_f, makeshift_gc, false)
+          end
+          
+          def contain?(x, y)
+            include?(x, y, filled: true)
+          end
+        
+          # checks if drawn or filled rectangle includes the point denoted by x and y (if drawn, it only returns true if point lies on the edge)
+          def include?(x, y, filled: nil)
+            filled = filled? if filled.nil?
+            makeshift_gc = org.eclipse.swt.graphics.GC.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+            @swt_path.contains(x.to_f, y.to_f, makeshift_gc, !filled)
+          end
+          
+          def irregular?
+            true
+          end
+          
+          def post_dispose_content(path_segment)
+            @path_segments.delete(path_segment)
+            @uncalculated_path_segments = @path_segments.dup
+            dispose
+          end
+          
+          def dispose
+            @swt_path&.dispose
+            @swt_path = nil
+            @args = []
+            calculated_args_changed!(children: false)
+            super
+          end
+          
+          def calculated_args_changed!(children: true)
+            super
+          end
+          
+          def calculated_args
+            @swt_path ||= org.eclipse.swt.graphics.Path.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+            # TODO recreate @swt_path only if one of the children get disposed (must notify parent on dispose)
+            @args = [@swt_path]
+            @uncalculated_path_segments.dup.each do |path_segment|
+              path_segment.add_to_swt_path(@swt_path)
+              @uncalculated_path_segments.delete(path_segment)
+            end
+            super
+          rescue => e
+            Glimmer::Config.logger.error {e.full_message}
+          end
+          
+          def move_by(x_delta, y_delta)
+            @path_segments.each {|path_segment| path_segment.move_by(x_delta, y_delta)}
+          end
+          
+          def bounds
+            if @path_segments != @bounds_path_segments
+              @bounds_path_segments = @path_segments
+              shape_bounds = geometry.getBounds2D
+              @bounds = org.eclipse.swt.graphics.Rectangle.new(shape_bounds.x, shape_bounds.y, shape_bounds.width, shape_bounds.height)
+            end
+            @bounds
+          end
+          
+          def size
+            if @path_segments != @size_path_segments
+              @size_path_segments = @path_segments
+              shape_bounds = geometry.getBounds2D
+              @size = org.eclipse.swt.graphics.Point.new(shape_bounds.width, shape_bounds.height)
+            end
+            @size
+          end
+          
+          # Logical x coordinate relative to parent
+          def x
+            x_value = bounds.x
+            x_value -= parent.absolute_x if parent.is_a?(Shape)
+            x_value
+          end
+          
+          # Logical y coordinate relative to parent
+          def y
+            y_value = bounds.y
+            y_value -= parent.absolute_y if parent.is_a?(Shape)
+            y_value
+          end
+          
+          def width
+            size.x
+          end
+          
+          def height
+            size.y
+          end
+          
+          def geometry
+            if @path_segments != @geometry_path_segments
+              @geometry_path_segments = @path_segments
+              @geometry = Java::JavaAwtGeom::Path2D::Double.new
+              @path_segments.each do |path_segment|
+                @geometry.send(path_segment.path_segment_geometry_method_name, *path_segment.path_segment_geometry_args)
+              end
+            end
+            @geometry
+          end
+                            
+          def path_segment_method_name
+            'addPath'
+          end
+                    
+          def path_segment_args
+            @args
+          end
+                            
+          def path_segment_geometry_method_name
+            'append'
+          end
+                    
+          def path_segment_geometry_args
+            # TODO consider supporting connected true instead of false (2nd arg)
+            [geometry, false]
+          end
+          
+          def eql?(other)
+            geometry.equals(other && other.respond_to?(:geometry) && other.geometry)
+          end
+          alias == eql?
+          
+          def hash
+            geometry.hashCode
+          end
+          
+        end
+      end
+    end
+  end
+end