glimmer-dsl-swt 4.18.5.2 → 4.18.6.1

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

@@ -0,0 +1,111 @@
+# 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'
+
+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
+        # Represents path segments like point, line, quad, and cubic curves
+        # Shapes could mix in
+        module PathSegment
+          # Subclasses must override and implement to indicate method name to invoke on SWT Path object to add segment
+          def path_segment_method_name
+            nil
+          end
+          # Subclasses must override and implement to indicate args to pass when invoking SWT Path object method
+          def path_segment_args
+            []
+          end
+          # Subclasses must override to indicate expected complete count of args when previous point is NOT connected (e.g. 4 for line, 6 for quad, 8 for cubic)
+          def default_path_segment_arg_count
+          end
+          # Subclasses must override to indicate expected count of args when previous point IS connected (e.g. 2 for line, 4 for quad, 6 for cubic)
+          def default_connected_path_segment_arg_count
+          end
+          # Subclasses may override to provide name of method to invoke for geometry object obtained from the Java AWT library java.awt.geom.Path2D.Double (e.g. curveTo vs cubicTo)
+          def path_segment_geometry_method_name
+            path_segment_method_name
+          end
+          # Subclasses must override and implement to indicate args to pass when invoking SWT Path object method
+          def path_segment_geometry_args
+            path_segment_args
+          end
+          # Subclasses must override to indicate otherwise
+          def previous_point_connected?
+            true
+          end
+          
+          def dispose
+            parent.post_dispose_content(self) if parent.is_a?(Path)
+          end
+          
+          def first_path_segment?
+            parent.path_segments.first == self
+          end
+          
+          def previous_path_segment
+            parent.path_segments[parent.path_segments.index(self) - 1] || self
+          end
+          
+          def add_to_swt_path(swt_path)
+            if @swt_path != swt_path
+              @swt_path = swt_path
+              the_path_segment_args = path_segment_args.dup
+              if !is_a?(Point) && self.class != Path
+                if !previous_point_connected?
+                  if the_path_segment_args.count == default_path_segment_arg_count
+                    point = the_path_segment_args.shift, the_path_segment_args.shift
+                    @swt_path.moveTo(*point)
+                  elsif first_path_segment?
+                    point = the_path_segment_args[0..1]
+                    @swt_path.moveTo(*point)
+                  end
+                end
+              end
+              @swt_path.send(path_segment_method_name, *the_path_segment_args)
+            end
+          end
+          
+          def add_to_geometry(geometry)
+            the_path_segment_geometry_args = path_segment_geometry_args.dup
+            if !is_a?(Point) && self.class != Path
+              if !previous_point_connected?
+                if the_path_segment_geometry_args.count == default_path_segment_arg_count
+                  point = the_path_segment_geometry_args.shift, the_path_segment_geometry_args.shift
+                  @swt_path.moveTo(*point)
+                elsif first_path_segment?
+                  point = the_path_segment_geometry_args[0..1]
+                  @swt_path.moveTo(*point)
+                end
+              end
+            end
+            geometry.send(path_segment_geometry_method_name, *the_path_segment_geometry_args)
+          end
+                  
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/swt/custom/shape/point.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,20 +34,55 @@ 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 Point < Shape
+          include PathSegment
+          
           def parameter_names
             [:x, :y]
           end
           
+          def width
+            1
+          end
+          
+          def height
+            1
+          end
+          
           def include?(x, y)
             # give it some fuzz (helps makes mouse clicking easier)
-            x.to_i.between?(self.x.to_i - 2, self.x.to_i + 2) && y.to_i.between?(self.y.to_i - 2, self.y.to_i + 2)
+            x.to_i.between?(self.absolute_x.to_i - 2, self.absolute_x.to_i + 2) && y.to_i.between?(self.absolute_y.to_i - 2, self.absolute_y.to_i + 2)
           end
           alias contain? include?
           
-          def move_by(x_delta, y_delta)
-            self.x += x_delta
-            self.y += y_delta
+          def path_segment_method_name
+            'addRectangle'
+          end
+                    
+          def path_segment_args
+            @args + [1, 1]
+          end
+          
+          def path_segment_geometry_method_name
+            'moveTo'
           end
+                    
+          def path_segment_geometry_args
+            @args
+          end
+          
+          def previous_point_connected?
+            false
+          end
+          
+          def eql?(other)
+            x == (other && other.respond_to?(:x) && other.x) && y == (other && other.respond_to?(:y) && other.y)
+          end
+          alias == eql?
+          
+          def hash
+            [x, y].hash
+          end
+          
         end
       end
     end

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

@@ -37,6 +37,10 @@ module Glimmer
             [:point_array]
           end
           
+          def location_parameter_names
+            parameter_names
+          end
+          
           def point_count
             point_array.count / 2
           end
@@ -58,14 +62,100 @@ module Glimmer
             x_array.zip(y_array)
           end
           
-          def include?(x, y)
-            shape_geometry = java.awt.Polygon.new(x_array.to_java(:int), y_array.to_java(:int), point_count)
-            shape_geometry.contains(x, y)
+          def absolute_point_array
+            if parent.is_a?(Shape)
+              point_array.each_with_index.map do |coordinate, i|
+                if i.even?
+                  parent.absolute_x + coordinate
+                else
+                  parent.absolute_y + coordinate
+                end
+              end
+            else
+              point_array
+            end
+          end
+          
+          def absolute_x_array
+            absolute_point_array.each_with_index.select {|pair| pair.last.even?}.map(&:first)
+          end
+          
+          def absolute_y_array
+            absolute_point_array.each_with_index.select {|pair| pair.last.odd?}.map(&:first)
+          end
+          
+          def absolute_point_xy_array
+            absolute_x_array.zip(absolute_y_array)
+          end
+          
+          def bounds
+            the_point_array = point_array
+            if the_point_array != @bounds_point_array
+              @bounds_point_array = point_array
+              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
+            the_point_array = point_array
+            if the_point_array != @size_point_array
+              @size_point_array = point_array
+              shape_bounds = geometry.getBounds2D
+              @size = org.eclipse.swt.graphics.Point.new(shape_bounds.width, shape_bounds.height)
+            end
+            @size
+          end
+          
+          def geometry
+            the_point_array = point_array
+            if the_point_array != @geometry_point_array
+              @geometry_point_array = point_array
+              @geometry = java.awt.Polygon.new(absolute_x_array.to_java(:int), absolute_y_array.to_java(:int), point_count)
+            end
+            @geometry
           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 contain?(x, y)
+            geometry.contains(x, y)
+          end
+
+          def include?(x, y)
+            comparison_lines = absolute_point_xy_array.zip(absolute_point_xy_array.rotate(1))
+            comparison_lines.any? {|line| Line.include?(line.first.first, line.first.last, line.last.first, line.last.last, x, y)}
+          end
+                    
           def move_by(x_delta, y_delta)
             self.point_array = point_array.each_with_index.map {|coordinate, i| i.even? ? coordinate + x_delta : coordinate + y_delta}
           end
+          
+          def irregular?
+            true
+          end
+          
         end
       end
     end

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

@@ -37,10 +37,19 @@ module Glimmer
             [:point_array]
           end
           
+          def location_parameter_names
+            parameter_names
+          end
+          
           def point_count
             point_array.count / 2
           end
           
+          def [](index)
+            index = 0 if index == point_count
+            org.eclipse.swt.graphics.Point.new(point_array[index * 2], point_array[index * 2 + 1])
+          end
+          
           def x_array
             point_array.each_with_index.select {|pair| pair.last.even?}.map(&:first)
           end
@@ -53,20 +62,83 @@ module Glimmer
             x_array.zip(y_array)
           end
           
-          def [](index)
-            index = 0 if index == point_count
-            org.eclipse.swt.graphics.Point.new(point_array[index * 2], point_array[index * 2 + 1])
+          def absolute_point_array
+            if parent.is_a?(Shape)
+              point_array.each_with_index.map do |coordinate, i|
+                if i.even?
+                  parent.absolute_x + coordinate
+                else
+                  parent.absolute_y + coordinate
+                end
+              end
+            else
+              point_array
+            end
+          end
+          
+          def absolute_x_array
+            absolute_point_array.each_with_index.select {|pair| pair.last.even?}.map(&:first)
+          end
+          
+          def absolute_y_array
+            absolute_point_array.each_with_index.select {|pair| pair.last.odd?}.map(&:first)
+          end
+          
+          def absolute_point_xy_array
+            absolute_x_array.zip(absolute_y_array)
+          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.Polygon.new(absolute_x_array.to_java(:int), absolute_y_array.to_java(:int), point_count)
+          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
+            bounds.width
+          end
+          
+          def height
+            bounds.height
           end
           
           def include?(x, y)
-            comparison_lines = point_xy_array.zip(point_xy_array.rotate(1))
+            comparison_lines = absolute_point_xy_array.zip(absolute_point_xy_array.rotate(1))
             comparison_lines.pop # ignore last pair since you don't want to compare last point with first point
             comparison_lines.any? {|line| Line.include?(line.first.first, line.first.last, line.last.first, line.last.last, x, y)}
           end
+          alias contain? include?
           
           def move_by(x_delta, y_delta)
             self.point_array = point_array.each_with_index.map {|coordinate, i| i.even? ? coordinate + x_delta : coordinate + y_delta}
           end
+          
+          def irregular?
+            true
+          end
+          
         end
       end
     end

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

@@ -0,0 +1,113 @@
+# 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 Quad < Path
+          def parameter_names
+            [:point_array]
+          end
+          
+          def geometry
+            the_point_array = point_array
+            if the_point_array != @geometry_point_array
+              @geometry_point_array = the_point_array
+              @geometry = Java::JavaAwtGeom::Path2D::Double.new
+              add_to_geometry(@geometry)
+            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.quadTo(*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
+            'quadTo'
+          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 default_path_segment_arg_count
+            6
+          end
+          
+          def default_connected_path_segment_arg_count
+            4
+          end
+          
+          def previous_point_connected?
+            @args.compact.count == 4 && !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