glimmer-dsl-swt 4.18.5.4 → 4.18.6.3

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

@@ -66,6 +66,11 @@ module Glimmer
               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,118 @@
+# 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'
+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
+            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.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 default_path_segment_arg_count
+            8
+          end
+          
+          def default_connected_path_segment_arg_count
+            6
+          end
+          
+          def path_segment_geometry_method_name
+            'curveTo'
+          end
+          
+          def previous_point_connected?
+            @args.compact.count == 6 && !first_path_segment?
+          end
+          
+          def eql?(other)
+            other.is_a?(Cubic) && 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/line.rb

@@ -1,4 +1,5 @@
 # Copyright (c) 2007-2021 Andy Maleh
+# 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
@@ -20,6 +21,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,6 +35,8 @@ 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)
@@ -79,11 +83,11 @@ module Glimmer
           end
           
           def width
-            bounds.width
+            size.x
           end
           
           def height
-            bounds.height
+            size.y
           end
           
           def absolute_x1
@@ -104,7 +108,7 @@ module Glimmer
           
           def absolute_x2
             if parent.is_a?(Shape)
-              parent.absolute_x + x2
+              parent.absolute_x + x2.to_f
             else
               x2
             end
@@ -112,7 +116,7 @@ module Glimmer
           
           def absolute_y2
             if parent.is_a?(Shape)
-              parent.absolute_y + y1
+              parent.absolute_y + y2.to_f
             else
               y2
             end
@@ -130,6 +134,50 @@ 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 default_path_segment_arg_count
+            4
+          end
+          
+          def default_connected_path_segment_arg_count
+            2
+          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
+          end
+          
+          def previous_point_connected?
+            @args.compact.count == 2 && !first_path_segment?
+          end
+          
+          def eql?(other)
+            other.is_a?(Line) &&
+              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/path.rb

@@ -0,0 +1,240 @@
+# 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
+      class Shape
+        # 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
+        # swt_path is not guaranteed to have any object in it till after rendering
+        class Path < Shape
+          include PathSegment # a path may behave as a path segment in another path
+          
+          attr_reader :swt_path, :path_segments
+          attr_accessor :calculated_path_args
+        
+          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)
+              Glimmer::SWT::DisplayProxy.instance.auto_exec do
+                @path_segments << shape
+                @uncalculated_path_segments << shape
+              end
+            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)
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              @path_segments.delete(path_segment)
+              @uncalculated_path_segments = @path_segments.dup
+              @swt_path&.dispose
+              @swt_path = nil
+              @args = []
+              calculated_args_changed!(children: false)
+            end
+          end
+          
+          def clear
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              @path_segments.each { |path_segments| path_segments.class == Path && path_segments.dispose }
+              @path_segments.clear
+              @uncalculated_path_segments = @path_segments.dup
+              @swt_path&.dispose
+              @swt_path = nil
+              @args = []
+              calculated_args_changed!(children: false)
+              drawable.redraw unless drawable.is_a?(ImageProxy)
+            end
+          end
+          
+          def dispose(redraw: true)
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              clear if self.class == Path
+              super(redraw: redraw) if (parent.is_a?(Shape) && (!parent.is_a?(PathSegment) || !parent.part_of_path?)) || parent.is_a?(Drawable)
+            end
+          end
+          
+          def calculated_args_changed!(children: true)
+            super
+          end
+          
+          def calculated_args
+            new_swt_path = @swt_path.nil? || !@calculated_paint_args || !@calculated_path_args
+            if new_swt_path
+              Glimmer::SWT::DisplayProxy.instance.auto_exec do
+                @swt_path&.dispose
+                @swt_path = org.eclipse.swt.graphics.Path.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+                @uncalculated_path_segments = @path_segments.dup
+              end
+            end
+            # 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|
+              Glimmer::SWT::DisplayProxy.instance.auto_exec do
+                path_segment.add_to_swt_path(@swt_path)
+                @uncalculated_path_segments.delete(path_segment)
+              end
+            end
+            @calculated_path_args = true
+            if new_swt_path
+              @path_calculated_args = super
+            else
+              @path_calculated_args
+            end
+          rescue => e
+            Glimmer::Config.logger.error {e.full_message}
+            @args
+          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|
+                path_segment.add_to_geometry(@geometry)
+              end
+            end
+            @geometry
+          end
+                            
+          def path_segment_method_name
+            'addPath'
+          end
+                    
+          def path_segment_args
+            @args
+          end
+                            
+          def path_segment_geometry_method_name
+            if self.class == Path
+              'append'
+            else
+              super
+            end
+          end
+                    
+          def path_segment_geometry_args
+            if self.class == Path
+              # TODO consider supporting connected true instead of false (2nd arg)
+              [geometry, false]
+            else
+              super
+            end
+          end
+          
+          def eql?(other)
+            (other.class == Path) && geometry.equals(other && other.respond_to?(:geometry) && other.geometry)
+          end
+          alias == eql?
+          
+          def hash
+            geometry.hashCode
+          end
+          
+        end
+      end
+    end
+  end
+end