glimmer-dsl-swt 4.18.5.2 → 4.18.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03f0ab47e7617c3d595a737c755ddc05e877074fb9139cacca042c6c31f7999e
-  data.tar.gz: f80117653d4ce70cfde372cbe660ab4d0a7ae181a24df76c79226fcb43c68549
+  metadata.gz: acf07c3a7c6f534f4082330369a0bacac2593675506da814ec68e70446ec02b9
+  data.tar.gz: ff2983c28283b30b4f7f9e6bdf9cc0bad3768331014ef281ff5397726851b39d
 SHA512:
-  metadata.gz: a543129ea30b6a18306341b9fad1f62a36f919d83cedc27ea5b6e62c18e13827b28e05cbb01c81e0d8639d5412aeb6ba2e81de60e4c7f0ba5052b474eb07b7f3
-  data.tar.gz: 8d757538764f6018a381bcc68583b2d2660d23c9a2f8f1b15c90ad904b84316b1a4e61197f1f618a2bb42ad5d2114cc087e9aaebe1538514a24b330bdf8ce44f
+  metadata.gz: d89da48eb352e555e861032de5b5fee9c1e1ad3e7796c920e354b61b5fb1e2522fa1eafd89e363259ee9c3961ab4207a51ea483ef670e072c869fb1671fecccb
+  data.tar.gz: d267615568ac7e20ef8b5778df77cfe36f3de061ab9dd5c4e227b2ef08d5323a27bc6742f07728a84b0760a11f64bdad822c4468f1cf24049ac536919816548e

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+### 4.18.5.3
+
+- Support nesting shapes within shapes, with relative positioning (meaning x, y coordinates are assumed relative to parent's x, y in nested shapes)
+- Support passing x, y coordinates as :default (or nil or not passed in if they are the last args) in all shapes, meaning they are centered within parent taking their width and height into account
+- Support default_x_delta, y_delta attributes, which add/subtract from defaults used for shape
+
 ### 4.18.5.2
 
 - Support checking if an `arc` shape accurately includes a point x,y coordinates within pie region only

data/README.md

@@ -1,4 +1,4 @@
-# [<img src="https://raw.githubusercontent.com/AndyObtiva/glimmer/master/images/glimmer-logo-hi-res.png" height=85 />](https://github.com/AndyObtiva/glimmer) Glimmer DSL for SWT 4.18.5.2
+# [<img src="https://raw.githubusercontent.com/AndyObtiva/glimmer/master/images/glimmer-logo-hi-res.png" height=85 />](https://github.com/AndyObtiva/glimmer) Glimmer DSL for SWT 4.18.5.3
 ## JRuby Desktop Development GUI Framework
 [![Gem Version](https://badge.fury.io/rb/glimmer-dsl-swt.svg)](http://badge.fury.io/rb/glimmer-dsl-swt)
 [![Travis CI](https://travis-ci.com/AndyObtiva/glimmer-dsl-swt.svg?branch=master)](https://travis-ci.com/github/AndyObtiva/glimmer-dsl-swt)
@@ -342,7 +342,7 @@ jgem install glimmer-dsl-swt
 
 Or this command if you want a specific version:
 ```
-jgem install glimmer-dsl-swt -v 4.18.5.2
+jgem install glimmer-dsl-swt -v 4.18.5.3
 ```
 
 `jgem` is JRuby's version of `gem` command.
@@ -360,7 +360,7 @@ Note: if you're using activerecord or activesupport, keep in mind that Glimmer u
 
 Add the following to `Gemfile`:
 ```
-gem 'glimmer-dsl-swt', '~> 4.18.5.2'
+gem 'glimmer-dsl-swt', '~> 4.18.5.3'
 ```
 
 And, then run:

data/VERSION

@@ -1 +1 @@
-4.18.5.2
+4.18.5.3

data/docs/reference/GLIMMER_GUI_DSL_SYNTAX.md

@@ -1385,12 +1385,10 @@ https://help.eclipse.org/2019-12/nftopic/org.eclipse.platform.doc.isv/reference/
 
 **(ALPHA FEATURE)**
 
-Glimmer supports drawing graphics directly on a `canvas` widget via SWT (or any widget for that matter though `canvas` is recommended for drawing).
+While other GUI toolkits only offer a way to draw graphics imperatively (e.g. fill_rectangle, draw_point, etc...), Glimmer DSL for SWT breaks away from the mold by enabling software engineers to draw graphics declaratively. Simply declare all the shapes you want to see with their attributes, like background/foreground colors, and Glimmer DSL for SWT takes care of the rest, painting graphics on a blank `canvas` widget or amending/decorating an existing widget. This is accomplished through the Canvas Shape DSL, a sub-DSL of the Glimmer GUI DSL, which makes it possible to draw graphics declaratively with very understandable and maintainable syntax. Still, for the rare cases where imperative logic is needed, Glimmer DSL for SWT supports imperative painting of graphics through direct usage of SWT.
 
 `canvas` has the `:double_buffered` SWT style by default on platforms that need it (Windows & Linux) to ensure flicker-free rendering. If you need to disable it for whatever reason, just pass the `:none` SWT style instead (e.g. `canvas(:none)`)
 
-This is accomplished via the Shape DSL a sub-DSL of the Glimmer GUI DSL, which makes it possible to draw graphics declaratively with very understandable and maintainable syntax.
-
 Shape keywords and their args (including defaults) are listed below (they basically match method names and arguments on [org.eclipse.swt.graphics.GC](https://help.eclipse.org/2020-12/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/GC.html) minus the `draw` or `fill` prefix in downcase):
 - `arc(x, y, width, height, startAngle, arcAngle, fill: false)` arc is part of a circle within an oval area, denoted by start angle (degrees) and end angle (degrees)
 - `focus(x, y, width, height)` this is just like rectangle but its foreground color is always that of the OS widget focus color (useful when capturing user interaction via a shape)
@@ -1474,6 +1472,10 @@ Screenshot:
 
 ![Canvas Animation Example](/images/glimmer-example-canvas.png)
 
+If you specify the x and y coordinates as `:default`, `nil`, or leave them out, they get calculated automatically by centering the shape within its parent `canvas`.
+
+Note that you could shift a shape off its centered position within its parent `canvas` by using `x_delta` and `y_delta` instead of `x` and `y`
+
 The round and gradient options could be dropped since Glimmer DSL for SWT supports auto-inference of them based on shape parameters.
 
 Example (you may copy/paste in [`girb`](GLIMMER_GIRB.md)):
@@ -1620,6 +1622,36 @@ shell {
 }.open
 ```
 
+#### Shapes inside a Shape
+
+Shapes can be nested within each other. If you nest a shape within another, its coordinates are assumed to be relative to its parent.
+
+As such, if you move the parent, it moves all its children with it.
+
+If you specify the x and y coordinates as `:default`, `nil`, or leave them out, they get calculated automatically by centering the shape within its parent shape relatively.
+
+Note that you could shift a shape off its centered position within its parent shape by using `x_delta` and `y_delta` instead of `x` and `y`
+
+Check [Hello, Canvas!](GLIMMER_SAMPLES.md#hello-canvas) for an example that nests lines, points, a polyline, and an image within a drawn rectangle parent:
+
+```ruby
+        rectangle(205, 50, 88, 96) {
+          foreground :yellow
+          3.times { |n|
+            line(45, 70 + n*10, 65 + n*10, 30 + n*10) {
+              foreground :yellow
+            }
+          }
+          10.times {|n|
+            point(15 + n*5, 50 + n*5) {
+              foreground :yellow
+            }
+          }
+          polyline(45, 60, 55, 20, 65, 60, 85, 80, 45, 60)
+          image(@image_object, 0, 5)
+        }
+```
+
 #### Shapes inside a Widget
 
 Keep in mind that the Shape DSL can be used inside any widget, not just `canvas`. Unlike shapes on a `canvas`, which are standalone graphics, when included in a widget, which already has its own look and feel, shapes are used as a decorative add-on that complements its look by getting painted on top of it. For example, shapes were used to decorate `composite` blocks in the [Tetris](GLIMMER_SAMPLES.md#tetris) sample to have a more bevel look. In summary, Shapes can be used in a hybrid approach (shapes inside a widget), not just standalone in a `canvas`.

data/glimmer-dsl-swt.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: glimmer-dsl-swt 4.18.5.2 ruby lib
+# stub: glimmer-dsl-swt 4.18.5.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "glimmer-dsl-swt".freeze
-  s.version = "4.18.5.2"
+  s.version = "4.18.5.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["AndyMaleh".freeze]
-  s.date = "2021-02-24"
+  s.date = "2021-02-25"
   s.description = "Glimmer DSL for SWT (JRuby Desktop Development GUI Framework) is a native-GUI cross-platform desktop development library written in JRuby, an OS-threaded faster JVM version of Ruby. Glimmer's main innovation is a declarative Ruby DSL that enables productive and efficient authoring of desktop application user-interfaces by relying on the robust Eclipse SWT library. Glimmer additionally innovates by having built-in data-binding support, which greatly facilitates synchronizing the GUI with domain models, thus achieving true decoupling of object oriented components and enabling developers to solve business problems (test-first) without worrying about GUI concerns, or alternatively drive development GUI-first, and then write clean business models (test-first) afterwards. Not only does Glimmer provide a large set of GUI widgets, but it also supports drawing Canvas Graphics like Shapes and Animations. To get started quickly, Glimmer offers scaffolding options for Apps, Gems, and Custom Widgets. Glimmer also includes native-executable packaging support, sorely lacking in other libraries, thus enabling the delivery of desktop apps written in Ruby as truly native DMG/PKG/APP files on the Mac + App Store, MSI/EXE files on Windows, and Gem Packaged Shell Scripts on Linux.".freeze
   s.email = "andy.am@gmail.com".freeze
   s.executables = ["glimmer".freeze, "girb".freeze]

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

@@ -34,19 +34,20 @@ module Glimmer
           @shapes ||= []
         end
         
-        def image_buffered_shapes
-          @image_buffered_shapes ||= []
+        def expanded_shapes
+          @shapes.map do |shape|
+            [shape] + shape.expanded_shapes
+          end.flatten
         end
         
-        # Returns shapes expanded with regards to nested shapes
-        def expand_shapes(shapes)
-          # TODO
+        def image_buffered_shapes
+          @image_buffered_shapes ||= []
         end
         
         # TODO add a method like shapes that specifies drawable_properties to be able to adjust properties like transform in between shapes
           
         def shape_at_location(x, y)
-          shapes.reverse.detect {|shape| shape.include?(x, y)}
+          expanded_shapes.reverse.detect {|shape| shape.include?(x, y)}
         end
         
         def add_shape(shape)
@@ -139,7 +140,7 @@ module Glimmer
               @paint_listener_proxy = on_swt_paint(&shape_painter)
             end
           else
-            redraw if @finished_add_content && !is_disposed
+            redraw if respond_to?(:redraw) && @finished_add_content && !is_disposed
           end
         end
         alias resetup_shape_painting setup_shape_painting

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

@@ -99,6 +99,7 @@ module Glimmer
         end
         
         attr_reader :drawable, :parent, :name, :args, :options, :shapes
+        attr_accessor :x_delta, :y_delta
         
         def initialize(parent, keyword, *args, &property_block)
           @parent = parent
@@ -109,6 +110,8 @@ module Glimmer
           @args = args
           @properties = {}
           @shapes = [] # nested shapes
+          @x_delta = 0
+          @y_delta = 0
           @options.reject {|key, value| %w[fill gradient round].include?(key.to_s)}.each do |property, property_args|
             @properties[property] = property_args
           end
@@ -143,7 +146,7 @@ module Glimmer
         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)
+            x.between?(self.absolute_x, self.absolute_x + width) && y.between?(self.absolute_y, self.absolute_y + height)
           else
             false # subclasses must provide implementation
           end
@@ -163,9 +166,17 @@ module Glimmer
         # 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.x_delta += x_delta
+            else
+              self.x += x_delta
+            end
+            if default_y?
+              self.y_delta += y_delta
+            else
+              self.y += y_delta
+            end
           end
         end
         
@@ -276,11 +287,11 @@ module Glimmer
           end
           if @name.include?('image')
             @drawable.requires_shape_disposal = true
-            if @args.size == 1
-              @args[1] = 0
-              @args[2] = 0
-            end
           end
+          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?
         end
                 
         # Tolerates shape extra args added by user by mistake
@@ -315,6 +326,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,6 +340,10 @@ module Glimmer
           possible_parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
         end
         
+        def current_parameter_name?(attribute_name)
+          parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
+        end
+        
         def parameter_index(attribute_name)
           parameter_names.map(&:to_s).index(attribute_name.to_s)
         end
@@ -333,18 +354,29 @@ 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)
+          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)
+            @calculated_absolute_args = false if (location_parameter_names.map(&:to_s) + ['x_delta', 'y_delta']).include?(attribute_name)
+
+            # TODO consider redrawing an image proxy's gc in the future
+            drawable.redraw unless drawable.is_a?(ImageProxy)
           end
         end
         
@@ -352,6 +384,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 +402,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
@@ -421,12 +457,116 @@ module Glimmer
             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)
+          if !@calculated_absolute_args || parent_shape_absolute_location_changed?
+            @absolute_args = absolute_args
+            @calculated_absolute_args = true
+          end
+          paint_event.gc.send(@method_name, *@absolute_args)
+          paint_children(paint_event)
         rescue => e
           Glimmer::Config.logger.error {"Error encountered in painting shape: #{self.inspect}"}
           Glimmer::Config.logger.error {e.full_message}
         end
         
+        def paint_children(paint_event)
+          shapes.to_a.each do |shape|
+            shape.paint(paint_event)
+          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
+                
+        # args translated to absolute coordinates
+        def absolute_args
+          return @args if !default_x? && !default_y? && @x_delta == 0 && @y_delta == 0 && parent.is_a?(Drawable)
+          @perform_redraw = false
+          original_x = nil
+          original_y = nil
+          if default_x?
+            original_x = x
+            self.x = default_x
+          end
+          if default_y?
+            original_y = y
+            self.y = default_y
+          end
+          move_by(@x_delta, @y_delta)
+          if parent.is_a?(Shape)
+            @parent_absolute_x = parent.absolute_x
+            @parent_absolute_y = parent.absolute_y
+            move_by(parent.absolute_x, parent.absolute_y)
+            calculated_absolute_args = @args.clone
+            move_by(-1*parent.absolute_x, -1*parent.absolute_y)
+          else
+            calculated_absolute_args = @args.clone
+          end
+          move_by(-1*@x_delta, -1*@y_delta)
+          if original_x
+            self.x = original_x
+          end
+          if original_y
+            self.y = original_y
+          end
+          @perform_redraw = true
+          calculated_absolute_args
+        end
+        
+        def default_x?
+          current_parameter_name?('x') && (x.nil? || x.to_s == 'default')
+        end
+        
+        def default_y?
+          current_parameter_name?('y') && (y.nil? || y.to_s == 'default')
+        end
+        
+        def default_x
+          if respond_to?(:width) && width && parent.respond_to?(:width) && parent.width
+            (parent.width - width) / 2
+          else
+            0
+          end
+        end
+        
+        def default_y
+          if respond_to?(:height) && height && parent.respond_to?(:height) && parent.height
+            (parent.height - height) / 2
+          else
+            0
+          end
+        end
+        
+        def absolute_x
+          x = default_x? ? default_x : self.x
+          x += @x_delta
+          if parent.is_a?(Shape)
+            parent.absolute_x + x
+          else
+            x
+          end
+        end
+        
+        def absolute_y
+          y = default_y? ? default_y : self.y
+          y += @y_delta
+          if parent.is_a?(Shape)
+            parent.absolute_y + y
+          else
+            y
+          end
+        end
+        
         def calculate_paint_args!
           unless @calculated_paint_args
             if @name == 'pixel'

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

@@ -39,7 +39,7 @@ module Glimmer
           
           # checks if shape contains the point denoted by x and y
           def contain?(x, y)
-            shape_geometry = java.awt.geom.Arc2D::Double.new(self.x, self.y, width, height, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
+            shape_geometry = java.awt.geom.Arc2D::Double.new(self.absolute_x, self.absolute_y, width, height, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
             shape_geometry.contains(x, y)
           end
           
@@ -48,8 +48,8 @@ module Glimmer
               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.x, self.y, width + 3, height + 3, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
-              inner_shape_geometry = java.awt.geom.Arc2D::Double.new(self.x, self.y, width - 3, height - 3, start_angle, arc_angle, java.awt.geom.Arc2D::PIE)
+              outer_shape_geometry = java.awt.geom.Arc2D::Double.new(self.absolute_x, self.absolute_y, width + 3, 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, width - 3, 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

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

@@ -78,17 +78,30 @@ module Glimmer
             dest_height || image.bounds.height
           end
           
-          def include?(x, y)
-            x.between?(self.x, self.x + width) && y.between?(self.y, self.y + height)
+          def default_x?
+            super ||
+              current_parameter_name?('dest_x') && (dest_x.nil? || dest_x.to_s == 'default')
           end
-          alias contain? include?
-            
+          
+          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.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.y_delta += y_delta
+            elsif dest_y
+              self.dest_y += y_delta
+            else
               self.y += y_delta
             end
           end