glimmer-dsl-swt 4.18.5.0 → 4.18.5.5

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/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

@@ -33,17 +33,96 @@ 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
+          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
+            bounds.width
+          end
+          
+          def height
+            bounds.height
+          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
+            else
+              x2
+            end
+          end
+          
+          def absolute_y2
+            if parent.is_a?(Shape)
+              parent.absolute_y + y1
+            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 +130,11 @@ module Glimmer
             self.x2 += x_delta
             self.y2 += y_delta
           end
+          
+          def irregular?
+            true
+          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/point.rb

@@ -37,14 +37,19 @@ module Glimmer
             [:x, :y]
           end
           
-          def include?(x, y)
-            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)
+          def width
+            1
+          end
+          
+          def height
+            1
           end
           
-          def move_by(x_delta, y_delta)
-            self.x += x_delta
-            self.y += y_delta
+          def include?(x, y)
+            # give it some fuzz (helps makes mouse clicking easier)
+            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?
         end
       end
     end

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

@@ -37,35 +37,125 @@ module Glimmer
             [:point_array]
           end
           
-          def size
-            point_array.size / 2
+          def location_parameter_names
+            parameter_names
+          end
+          
+          def point_count
+            point_array.count / 2
           end
           
           def [](index)
-            index = 0 if index == size
+            index = 0 if index == point_count
             org.eclipse.swt.graphics.Point.new(point_array[index * 2], point_array[index * 2 + 1])
           end
           
-          def include?(x, y)
-            c = false
-            i = -1
-            j = self.size
-            while (i += 1) < (self.size + 1)
-              if ((self[i].y <= y && y < self[j].y) ||
-                 (self[j].y <= y && y < self[i].y))
-                if (x < (self[j].x - self[i].x) * (y - self[i].y) /
-                              (self[j].y - self[i].y) + self[i].x)
-                  c = !c
+          def x_array
+            point_array.each_with_index.select {|pair| pair.last.even?}.map(&:first)
+          end
+          
+          def y_array
+            point_array.each_with_index.select {|pair| pair.last.odd?}.map(&:first)
+          end
+          
+          def point_xy_array
+            x_array.zip(y_array)
+          end
+          
+          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
-                j = i
               end
+            else
+              point_array
             end
-            c
           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
+            bounds.width
+          end
+          
+          def height
+            bounds.height
+          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,35 +37,108 @@ module Glimmer
             [:point_array]
           end
           
-          def size
-            point_array.size / 2
+          def location_parameter_names
+            parameter_names
+          end
+          
+          def point_count
+            point_array.count / 2
           end
           
           def [](index)
-            index = 0 if index == size
+            index = 0 if index == point_count
             org.eclipse.swt.graphics.Point.new(point_array[index * 2], point_array[index * 2 + 1])
           end
           
-          def include?(x, y)
-            c = false
-            i = -1
-            j = self.size
-            while (i += 1) < (self.size + 1)
-              if ((self[i].y <= y && y < self[j].y) ||
-                 (self[j].y <= y && y < self[i].y))
-                if (x < (self[j].x - self[i].x) * (y - self[i].y) /
-                              (self[j].y - self[i].y) + self[i].x)
-                  c = !c
+          def x_array
+            point_array.each_with_index.select {|pair| pair.last.even?}.map(&:first)
+          end
+          
+          def y_array
+            point_array.each_with_index.select {|pair| pair.last.odd?}.map(&:first)
+          end
+          
+          def point_xy_array
+            x_array.zip(y_array)
+          end
+          
+          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
-                j = i
               end
+            else
+              point_array
             end
-            c
           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 = 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