glimmer-dsl-swt 4.18.5.3 → 4.18.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acf07c3a7c6f534f4082330369a0bacac2593675506da814ec68e70446ec02b9
-  data.tar.gz: ff2983c28283b30b4f7f9e6bdf9cc0bad3768331014ef281ff5397726851b39d
+  metadata.gz: 495c8eacce66f3b425a8f1603eea5051f5b776f0cb8e8550419382079c58e85e
+  data.tar.gz: 7e922de5ff80a2e85facee8a36444fe70bd6a9e25a65416aeebec4bfabd10749
 SHA512:
-  metadata.gz: d89da48eb352e555e861032de5b5fee9c1e1ad3e7796c920e354b61b5fb1e2522fa1eafd89e363259ee9c3961ab4207a51ea483ef670e072c869fb1671fecccb
-  data.tar.gz: d267615568ac7e20ef8b5778df77cfe36f3de061ab9dd5c4e227b2ef08d5323a27bc6742f07728a84b0760a11f64bdad822c4468f1cf24049ac536919816548e
+  metadata.gz: 5ace8433246247b3210cced98a70bb45cfdc978808b632ad322b5c995a7b0e868fc7df9c6ed23293fd5845e50257696617ad9a85ad9e7a0f0b697aea55901cfc
+  data.tar.gz: 58c632f794d07225737d101b68300db72c41b90778320765971e29539242d48260512db44c77ed99fb1aa9307056d24364a5bb57e400b3a0aab49c41ac8babb4

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+### 4.18.5.4
+
+- Support passing width, height as :default (or nil or not passed in if they are the last args) in all shapes that include other shapes to indicate they are calculated automatically from nested shapes, text/string extent, or otherwise defaulting to 0, 0
+- Support [:default, width_delta], [:default, height_delta] attributes for width and height, which add/subtract from defaults used for shape
+- Switch from use of `:default` with x_delta/y_delta to passing `[:default, x_delta]` or `[:default, y_delta]` (e.g. `image(file, [:default, -30], :default)` for x = default - 30 and y = default + 0)
+- Support a bounding box for all shapes, implementing `#bounds` (x, y, width, and height) and `#size` (width, height) for the ones that don't receive as parameters (like polygon)
+
 ### 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)

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.3
+# [<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.4
 ## 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)
@@ -8,7 +8,7 @@
 
 **[Contributors Wanted! (Submit a Glimmer App Sample to Get Started)](#contributing)**
 
-[Glimmer DSL for SWT](https://github.com/AndyObtiva/glimmer) is a native-GUI cross-platform desktop development library written in [JRuby](https://www.jruby.org/), an OS-threaded faster JVM version of [Ruby](https://www.ruby-lang.org/en/). [Glimmer](https://github.com/AndyObtiva/glimmer)'s main innovation is a declarative [Ruby DSL](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#glimmer-dsl-syntax) that enables productive and efficient authoring of desktop application user-interfaces by relying on the robust [Eclipse SWT library](https://www.eclipse.org/swt/). [Glimmer](https://rubygems.org/gems/glimmer) additionally innovates by having built-in [data-binding](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#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](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#widgets), but it also supports drawing Canvas Graphics like [Shapes](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#canvas-shape-dsl) and [Animations](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#canvas-animation-dsl). To get started quickly, [Glimmer](https://rubygems.org/gems/glimmer) offers [scaffolding](docs/reference/GLIMMER_COMMAND.md#scaffolding) options for [Apps](#in-production), [Gems](docs/reference/GLIMMER_COMMAND.md#custom-shell-gem), and [Custom Widgets](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#custom-widgets). [Glimmer](https://rubygems.org/gems/glimmer) also includes native-executable [packaging](docs/reference/GLIMMER_PACKAGING_AND_DISTRIBUTION.md) support, sorely lacking in other libraries, thus enabling the delivery of desktop apps written in [Ruby](https://www.ruby-lang.org/en/) as truly native DMG/PKG/APP files on the [Mac](https://www.apple.com/ca/macos) + [App Store](https://developer.apple.com/macos/distribution/), MSI/EXE files on [Windows](https://www.microsoft.com/en-ca/windows), and [Gem Packaged Shell Scripts](docs/reference/GLIMMER_COMMAND.md#packaging) on [Linux](https://www.linux.org/).
+[Glimmer](https://github.com/AndyObtiva/glimmer) DSL for SWT is a native-GUI cross-platform desktop development library written in [JRuby](https://www.jruby.org/), an OS-threaded faster JVM version of [Ruby](https://www.ruby-lang.org/en/). [Glimmer](https://github.com/AndyObtiva/glimmer)'s main innovation is a declarative [Ruby DSL](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#glimmer-dsl-syntax) that enables productive and efficient authoring of desktop application user-interfaces by relying on the robust [Eclipse SWT library](https://www.eclipse.org/swt/). [Glimmer](https://rubygems.org/gems/glimmer) additionally innovates by having built-in [data-binding](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#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](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#widgets), but it also supports drawing Canvas Graphics like [Shapes](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#canvas-shape-dsl) and [Animations](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#canvas-animation-dsl). To get started quickly, [Glimmer](https://rubygems.org/gems/glimmer) offers [scaffolding](docs/reference/GLIMMER_COMMAND.md#scaffolding) options for [Apps](#in-production), [Gems](docs/reference/GLIMMER_COMMAND.md#custom-shell-gem), and [Custom Widgets](docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#custom-widgets). [Glimmer](https://rubygems.org/gems/glimmer) also includes native-executable [packaging](docs/reference/GLIMMER_PACKAGING_AND_DISTRIBUTION.md) support, sorely lacking in other libraries, thus enabling the delivery of desktop apps written in [Ruby](https://www.ruby-lang.org/en/) as truly native DMG/PKG/APP files on the [Mac](https://www.apple.com/ca/macos) + [App Store](https://developer.apple.com/macos/distribution/), MSI/EXE files on [Windows](https://www.microsoft.com/en-ca/windows), and [Gem Packaged Shell Scripts](docs/reference/GLIMMER_COMMAND.md#packaging) on [Linux](https://www.linux.org/).
 
 [Glimmer receives two updates per month](https://rubygems.org/gems/glimmer-dsl-swt/versions). You can trust [Glimmer](https://rubygems.org/gems/glimmer) with your Ruby desktop GUI development needs. Please make [Glimmer](https://rubygems.org/gems/glimmer) even better by providing feedback and [contributing](#contributing) when possible.
 
@@ -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.3
+jgem install glimmer-dsl-swt -v 4.18.5.4
 ```
 
 `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.3'
+gem 'glimmer-dsl-swt', '~> 4.18.5.4'
 ```
 
 And, then run:

data/VERSION

@@ -1 +1 @@
-4.18.5.3
+4.18.5.4

data/docs/reference/GLIMMER_GUI_DSL_SYNTAX.md

@@ -36,6 +36,7 @@ This guide should help you get started with Glimmer DSL for SWT. For more advanc
   - [Layouts](#layouts)
   - [Layout Data](#layout-data)
   - [Canvas Shape DSL](#canvas-shape-dsl)
+    - [Shapes inside a Shape](#shapes-inside-a-shape)
     - [Shapes inside a Widget](#shapes-inside-a-widget)
     - [Shapes inside an Image](#shapes-inside-an-image)
     - [Canvas Shape API](#canvas-shape-api)
@@ -1403,7 +1404,7 @@ Shape keywords and their args (including defaults) are listed below (they basica
 - `rectangle(x, y, width, height, arcWidth = 60, arcHeight = 60, fill: false, round: true)` round rectangle, which can be optionally filled, and takes optional extra round angle arguments
 - `rectangle(x, y, width, height, vertical = true, fill: true, gradient: true)` gradient rectangle, which is always filled, and takes an optional extra argument to specify true for vertical gradient (default) and false for horizontal gradient
 - `text(string, x, y, is_transparent = true)` text with optional is_transparent to indicate if background is transparent (default is true)
-- `text(string, x, y, flags)` text with optional flags (flag format is `swt(comma_separated_flags)` where flags can be :draw_delimiter (i.e. new lines), :draw_tab, :draw_mnemonic, and :draw_transparent as explained in [GC API](https://help.eclipse.org/2020-12/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/GC.html))
+- `text(string, x, y, flags)` text with optional flags (flag format is `swt(comma_separated_flags)` where flags can be `:draw_delimiter` (i.e. new lines), `:draw_tab`, `:draw_mnemonic`, and `:draw_transparent` as explained in [GC API](https://help.eclipse.org/2020-12/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/GC.html))
 
 Shape keywords that can be filled with color can take a keyword argument `fill: true`. Defaults to false when not specified unless background is set with no foreground (or foreground is set with no background), in which case a smart default is applied.
 Smart defaults can be applied to automatically infer `gradient: true` (rectangle with both foreground and background) and `round: true` (rectangle with more than 4 args, the extra args are numeric) as well.
@@ -1460,7 +1461,7 @@ shell {
       font height: 25, style: :bold
     }
     rectangle(200, 80, 108, 36) {
-      foreground :black
+      foreground rgb(0, 0, 0)
       line_width 3
     }
     image(image_object, 70, 50)
@@ -1506,7 +1507,7 @@ shell {
       font height: 25, style: :bold
     }
     rectangle(200, 80, 108, 36) {
-      foreground :black
+      foreground rgb(0, 0, 0)
       line_width 3
     }
     image(image_object, 70, 50)
@@ -1541,7 +1542,7 @@ shell {
     }
     rectangle {
       x 50
-      x 20
+      y 20
       width 300
       height 150
       arc_width 30
@@ -1596,23 +1597,26 @@ shell {
   minimum_size 320, 400
 
   canvas {
-    background :yellow
+    background :dark_yellow
     
     on_paint_control { |paint_event|
       gc = paint_event.gc
-      gc.background = color(:red).swt_color
-      gc.fill_rectangle(0, 0, 220, 400)
       
-      gc.background = color(:magenta).swt_color
-      gc.fill_roundRectangle(50, 20, 300, 150, 30, 50)
+      gc.background = color(:dark_red).swt_color
+      gc.fill_rectangle(0, 0, 220, 400)
       
-      gc.background = color(:dark_magenta).swt_color
-      gc.fill_gradientRectangle(150, 200, 100, 70, true)
+      gc.background = color(:yellow).swt_color
+      gc.fill_round_rectangle(50, 20, 300, 150, 30, 50)
       
-      gc.foreground = color(:dark_blue).swt_color
-      gc.draw_rectangle(200, 80, 108, 36)
+      gc.background = color(:dark_red).swt_color
+      gc.foreground = color(:yellow).swt_color
+      gc.fill_gradient_rectangle(150, 200, 100, 70, true)
       
+      gc.font = font(height: 25, style: :bold).swt_font
       gc.foreground = color(:black).swt_color
+      gc.draw_text('Glimmer', 208, 83, true)
+      
+      gc.foreground = rgb(0, 0, 0).swt_color
       gc.line_width = 3
       gc.draw_rectangle(200, 80, 108, 36)
       
@@ -1762,6 +1766,8 @@ They are implemented with the help of the highly robust Java built-in shape geom
 - `Shape#contain?(x, y)` : indicates if shape contains x, y point
 - `Shape#include?(x, y)` : indicates if shape includes x, y point on the edge if drawn or inside if filled (include uses contain for filled shapes)
 - `Shape#move_by(x_delta, y_delta)` : moves shape object at x, y location
+- `Shape#size` : calculated size for shape bounding box (e.g. a polygon with an irregular shape will have its bounding box width and height calculated)
+- `Shape#bounds` : calculated bounds (x, y, width, height) for shape bounding box (e.g. a polygon with an irregular shape will have its bounding box top-left x, y, width and height calculated)
 
 Check [Hello, Canvas!](GLIMMER_SAMPLES.md#hello-canvas) for an example.
 

data/docs/reference/GLIMMER_SAMPLES.md

@@ -580,6 +580,10 @@ Hello, Canvas! Colors Changed
 
 ![Hello Canvas Colors Changed](/images/glimmer-hello-canvas-colors-changed.png)
 
+Hello, Canvas! Data-Binding (changing a `text` shape `string` via data-binding changes from another thread)
+
+![Hello Canvas Data Binding](/images/glimmer-hello-canvas-data-binding.gif)
+
 #### Hello, Canvas Animation!
 
 This sample demonstrates the use of the `canvas` widget and [Animation DSL](#canvas-animation-dsl) in Glimmer.

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.3 ruby lib
+# stub: glimmer-dsl-swt 4.18.5.4 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "glimmer-dsl-swt".freeze
-  s.version = "4.18.5.3"
+  s.version = "4.18.5.4"
 
   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-25"
+  s.date = "2021-02-26"
   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/shape.rb

@@ -99,7 +99,7 @@ module Glimmer
         end
         
         attr_reader :drawable, :parent, :name, :args, :options, :shapes
-        attr_accessor :x_delta, :y_delta
+        attr_accessor :extent
         
         def initialize(parent, keyword, *args, &property_block)
           @parent = parent
@@ -110,8 +110,6 @@ 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
@@ -121,6 +119,7 @@ module Glimmer
         
         def add_shape(shape)
           @shapes << shape
+          calculated_args_changed_for_default_size!
         end
         
         def draw?
@@ -141,26 +140,34 @@ module Glimmer
           @options[:round]
         end
         
-        # subclasses (like polygon) may override to indicate if a point x,y coordinates falls inside the shape
+        # The bounding box top-left x, y, width, height in absolute positioning
+        def bounds
+          org.eclipse.swt.graphics.Rectangle.new(absolute_x, absolute_y, calculated_width, calculated_height)
+        end
+        
+        # The bounding box width and height (as a Point object with x being width and y being height)
+        def size
+          org.eclipse.swt.graphics.Point.new(calculated_width, calculated_height)
+        end
+        
+        def extent
+          @extent || size
+        end
+        
+        # Returns if shape contains a point
+        # Subclasses (like polygon) may override to indicate if a point x,y coordinates falls inside the shape
         # some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly
         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.absolute_x, self.absolute_x + width) && y.between?(self.absolute_y, self.absolute_y + height)
-          else
-            false # subclasses must provide implementation
-          end
+          x.between?(self.absolute_x, self.absolute_x + calculated_width) && y.between?(self.absolute_y, self.absolute_y + calculated_height)
         end
         
-        # subclasses (like polygon) may override to indicate if a point x,y coordinates falls on the edge of a drawn shape or inside a filled shape
+        # Returns if shape includes a point. When the shape is filled, this is the same as contain. When the shape is drawn, it only returns true if the point lies on the edge (boundary/border)
+        # Subclasses (like polygon) may override to indicate if a point x,y coordinates falls on the edge of a drawn shape or inside a filled shape
         # some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly
         def include?(x, y)
           # assume a rectangular shape by default
-          if respond_to?(:x) && respond_to?(:y) && respond_to?(:width) && respond_to?(:height)
-            contain?(x, y)
-          else
-            false # subclasses must provide implementation
-          end
+          contain?(x, y)
         end
         
         # moves by x delta and y delta. Subclasses must implement
@@ -168,12 +175,12 @@ module Glimmer
         def move_by(x_delta, y_delta)
           if respond_to?(:x) && respond_to?(:y) && respond_to?(:x=) && respond_to?(:y=)
             if default_x?
-              self.x_delta += x_delta
+              self.default_x_delta += x_delta
             else
               self.x += x_delta
             end
             if default_y?
-              self.y_delta += y_delta
+              self.default_y_delta += y_delta
             else
               self.y += y_delta
             end
@@ -278,20 +285,22 @@ module Glimmer
         end
         
         def apply_shape_arg_defaults!
+          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?
+          self.width = :default if current_parameter_name?(:width) && width.nil?
+          self.height = :default if current_parameter_name?(:height) && height.nil?
           if @name.include?('rectangle') && round? && @args.size.between?(4, 5)
             (6 - @args.size).times {@args << 60}
           elsif @name.include?('rectangle') && gradient? && @args.size == 4
-            @args << true # vertical is true by default
-          elsif (@name.include?('text') || @name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && @args.size == 3
-            @args << true # is_transparent is true by default
+            set_attribute('vertical', true, redraw: false)
+          elsif (@name.include?('text') || @name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && @args.size < 4
+            set_attribute('is_transparent', true, redraw: false)
           end
           if @name.include?('image')
             @drawable.requires_shape_disposal = true
           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
@@ -341,11 +350,11 @@ module Glimmer
         end
         
         def current_parameter_name?(attribute_name)
-          parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
+          parameter_names.include?(attribute_name.to_s.to_sym)
         end
         
         def parameter_index(attribute_name)
-          parameter_names.map(&:to_s).index(attribute_name.to_s)
+          parameter_names.index(attribute_name.to_s.to_sym)
         end
         
         def set_parameter_attribute(attribute_name, *args)
@@ -357,9 +366,10 @@ module Glimmer
             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)
+          args.pop if !options.nil? && !options[:redraw].nil?
           perform_redraw = @perform_redraw
           perform_redraw = options[:redraw] if perform_redraw.nil? && !options.nil?
           perform_redraw = true if perform_redraw.nil?
@@ -373,8 +383,10 @@ module Glimmer
           if @content_added && perform_redraw && !drawable.is_disposed
             @calculated_paint_args = false
             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)
-
+            @calculated_args = nil if location_parameter_names.map(&:to_s).include?(attribute_name)
+            if ['width', 'height'].include?(attribute_name)
+              calculated_args_changed_for_default_size!
+            end
             # TODO consider redrawing an image proxy's gc in the future
             drawable.redraw unless drawable.is_a?(ImageProxy)
           end
@@ -447,6 +459,17 @@ module Glimmer
         end
                 
         def paint(paint_event)
+          paint_children(paint_event) if default_width? || default_height?
+          paint_self(paint_event)
+          shapes.each(&:calculated_args_changed!) if default_width? || default_height?
+          paint_children(paint_event)
+        rescue => e
+          Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with calculated args (#{@calculated_args}) and args (#{@args})"}
+          Glimmer::Config.logger.error {e.full_message}
+        end
+        
+        def paint_self(paint_event)
+          @painting = true
           calculate_paint_args!
           @properties.each do |property, args|
             method_name = attribute_setter(property)
@@ -456,16 +479,18 @@ module Glimmer
               args.first.swt_transform.dispose
             end
           end
-          self.extent = paint_event.gc.send("#{@name}Extent", *(([string, flags] if respond_to?(:flags)).compact)) if ['text', 'string'].include?(@name)
-          if !@calculated_absolute_args || parent_shape_absolute_location_changed?
-            @absolute_args = absolute_args
-            @calculated_absolute_args = true
+          ensure_extent(paint_event)
+          if !@calculated_args || parent_shape_absolute_location_changed?
+            @calculated_args = calculated_args
           end
-          paint_event.gc.send(@method_name, *@absolute_args)
-          paint_children(paint_event)
+          # paint unless parent's calculated args are not calculated yet, meaning it is about to get painted and trigger a paint on this child anyways
+          paint_event.gc.send(@method_name, *@calculated_args) unless parent.is_a?(Shape) && !parent.calculated_args?
+          @painting = false
         rescue => e
-          Glimmer::Config.logger.error {"Error encountered in painting shape: #{self.inspect}"}
+          Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with calculated args (#{@calculated_args}) and args (#{@args})"}
           Glimmer::Config.logger.error {e.full_message}
+        ensure
+          @painting = false
         end
         
         def paint_children(paint_event)
@@ -474,6 +499,20 @@ module Glimmer
           end
         end
         
+        def ensure_extent(paint_event)
+          old_extent = @extent
+          if ['text', 'string'].include?(@name)
+            extent_args = [string]
+            extent_flags = SWTProxy[:draw_transparent] if current_parameter_name?(:is_transparent) && is_transparent
+            extent_flags = flags if current_parameter_name?(:flags)
+            extent_args << extent_flags unless extent_flags.nil?
+            self.extent = paint_event.gc.send("#{@name}Extent", *extent_args)
+          end
+          if !@extent.nil? && (old_extent&.x != @extent&.x || old_extent&.y != @extent&.y)
+            parent.calculated_args_changed_for_default_size! if parent.is_a?(Shape)
+          end
+        end
+        
         def expanded_shapes
           if shapes.to_a.any?
             shapes.map do |shape|
@@ -487,69 +526,198 @@ module Glimmer
         def parent_shape_absolute_location_changed?
           (parent.is_a?(Shape) && (parent.absolute_x != @parent_absolute_x || parent.absolute_y != @parent_absolute_y))
         end
+        
+        def calculated_args_changed!
+          # TODO add a children: true option to enable setting to false to avoid recalculating children args
+          @calculated_args = nil
+          shapes.each(&:calculated_args_changed!)
+        end
+        
+        def calculated_args_changed_for_default_size!
+          @calculated_args = nil if default_width? || default_height?
+          if parent.is_a?(Shape)
+            parent.calculated_args_changed_for_default_size!
+          elsif @content_added && !drawable.is_disposed
+            # TODO consider optimizing in the future if needed by ensuring one redraw for all parents in the hierarchy at the end instead of doing one per parent that needs it
+            drawable.redraw if !@painting && !drawable.is_a?(ImageProxy)
+          end
+        end
+        
+        def calculated_args?
+          !!@calculated_args
+        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)
+        def calculated_args
+          return @args if !default_x? && !default_y? && !default_width? && !default_height? && parent.is_a?(Drawable)
+          # Note: Must set x and move_by because not all shapes have a real x and some must translate all their points with move_by
+          # TODO change that by setting a bounding box for all shapes with a calculated top-left x, y and
+          # a setter that does the moving inside them instead so that I could rely on absolute_x and absolute_y
+          # here to get the job done of calculating absolute args
           @perform_redraw = false
           original_x = nil
           original_y = nil
+          original_width = nil
+          original_height = nil
+          if default_width?
+            original_width = width
+            self.width = default_width + default_width_delta
+          end
+          if default_height?
+            original_height = height
+            self.height = default_height + default_height_delta
+          end
           if default_x?
             original_x = x
-            self.x = default_x
+            self.x = default_x + default_x_delta
           end
           if default_y?
             original_y = y
-            self.y = default_y
+            self.y = default_y + default_y_delta
           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
+            result_args = @args.clone
             move_by(-1*parent.absolute_x, -1*parent.absolute_y)
           else
-            calculated_absolute_args = @args.clone
+            result_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
+          if original_width
+            self.width = original_width
+          end
+          if original_height
+            self.height = original_height
+          end
           @perform_redraw = true
-          calculated_absolute_args
+          result_args
         end
         
         def default_x?
-          current_parameter_name?('x') && (x.nil? || x.to_s == 'default')
+          current_parameter_name?(:x) and
+            (x.nil? || x.to_s == 'default' || (x.is_a?(Array) && x.first.to_s == 'default'))
         end
         
         def default_y?
-          current_parameter_name?('y') && (y.nil? || y.to_s == 'default')
+          current_parameter_name?(:y) and
+            (y.nil? || y.to_s == 'default' || (y.is_a?(Array) && y.first.to_s == 'default'))
+        end
+        
+        def default_width?
+          return false unless current_parameter_name?(:width)
+          width = self.width
+          (width.nil? || width == :default || width == 'default' || (width.is_a?(Array) && (width.first.to_s == :default || width.first.to_s == 'default')))
+        end
+        
+        def default_height?
+          return false unless current_parameter_name?(:height)
+          height = self.height
+          (height.nil? || height == :default || height == 'default' || (height.is_a?(Array) && (height.first.to_s == :default || height.first.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
+          result = ((parent.size.x - size.x) / 2)
+          result += parent.bounds.x - parent.absolute_x if parent.is_a?(Shape)
+          result
         end
         
         def default_y
-          if respond_to?(:height) && height && parent.respond_to?(:height) && parent.height
-            (parent.height - height) / 2
-          else
-            0
+          result = ((parent.size.y - size.y) / 2)
+          result += parent.bounds.y - parent.absolute_y if parent.is_a?(Shape)
+          result
+        end
+        
+        def default_width
+          x_start_end_pairs = shapes.map do |shape|
+            shape_x = shape.default_x? ? 0 : shape.x.to_f
+            shape_width = shape.calculated_width.to_f
+            [shape_x, shape_x + shape_width]
           end
+          min_x = x_start_end_pairs.map(&:first).min.to_f
+          max_x = x_start_end_pairs.map(&:last).max.to_f
+          max_x - min_x
+        end
+        
+        def default_height
+          y_start_end_pairs = shapes.map do |shape|
+            shape_y = shape.default_y? ? 0 : shape.y.to_f
+            shape_height = shape.calculated_height.to_f
+            [shape_y, shape_y + shape_height]
+          end
+          min_y = y_start_end_pairs.map(&:first).min.to_f
+          max_y = y_start_end_pairs.map(&:last).max.to_f
+          max_y - min_y
+        end
+        
+        def calculated_width
+          default_width? ? default_width : width
+        end
+        
+        def calculated_height
+          default_height? ? default_height : height
+        end
+        
+        def default_x_delta
+          return 0 unless default_x? && x.is_a?(Array)
+          x[1].to_f
+        end
+        
+        def default_y_delta
+          return 0 unless default_y? && y.is_a?(Array)
+          y[1].to_f
+        end
+        
+        def default_width_delta
+          return 0 unless default_width? && width.is_a?(Array)
+          width[1].to_f
+        end
+        
+        def default_height_delta
+          return 0 unless default_height? && height.is_a?(Array)
+          height[1].to_f
+        end
+        
+        def default_x_delta=(delta)
+          return unless default_x?
+          self.x = [:default, delta]
+        end
+        
+        def default_y_delta=(delta)
+          return unless default_y?
+          self.y = [:default, delta]
+        end
+        
+        def default_width_delta=(delta)
+          return unless default_width?
+          self.width = [:default, delta]
+        end
+        
+        def default_height_delta=(delta)
+          return unless default_height?
+          self.height = [:default, delta]
+        end
+        
+        def calculated_x
+          result = default_x? ? default_x : self.x
+          result += default_x_delta
+          result
+        end
+        
+        def calculated_y
+          result = default_y? ? default_y : self.y
+          result += default_y_delta
+          result
         end
         
         def absolute_x
-          x = default_x? ? default_x : self.x
-          x += @x_delta
+          x = calculated_x
           if parent.is_a?(Shape)
             parent.absolute_x + x
           else
@@ -558,8 +726,7 @@ module Glimmer
         end
         
         def absolute_y
-          y = default_y? ? default_y : self.y
-          y += @y_delta
+          y = calculated_y
           if parent.is_a?(Shape)
             parent.absolute_y + y
           else
@@ -567,6 +734,13 @@ module Glimmer
           end
         end
         
+        # Overriding inspect to avoid printing very long shape hierarchies
+        def inspect
+          "#<#{self.class.name}:0x#{self.hash.to_s(16)} args=#{@args.inspect}, properties=#{@properties.inspect}}>"
+        rescue => e
+          "#<#{self.class.name}:0x#{self.hash.to_s(16)}"
+        end
+        
         def calculate_paint_args!
           unless @calculated_paint_args
             if @name == 'pixel'

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

@@ -37,10 +37,23 @@ module Glimmer
             [: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)
-            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)
+            geometry.contains(x, y)
           end
           
           def include?(x, y)
@@ -48,8 +61,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.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 = 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

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

@@ -80,17 +80,17 @@ module Glimmer
           
           def default_x?
             super ||
-              current_parameter_name?('dest_x') && (dest_x.nil? || dest_x.to_s == 'default')
+              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')
+              current_parameter_name?(:dest_y) && (dest_y.nil? || dest_y.to_s == 'default')
           end
           
           def move_by(x_delta, y_delta)
             if default_x?
-              self.x_delta += x_delta
+              self.default_x_delta += x_delta
             elsif dest_x
               self.dest_x += x_delta
             else
@@ -98,7 +98,7 @@ module Glimmer
             end
             
             if default_y?
-              self.y_delta += y_delta
+              self.default_y_delta += y_delta
             elsif dest_y
               self.dest_y += y_delta
             else

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

@@ -50,14 +50,40 @@ module Glimmer
             parameter_names
           end
           
-          # Logical x coordinate. Always assumes the first point in the line to be the x coordinate.
+          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
-            x1
+            x_value = bounds.x
+            x_value -= parent.absolute_x if parent.is_a?(Shape)
+            x_value
           end
           
-          # Logical y coordinate. Always assumes the first point in the line to be the y coordinate.
+          # Logical y coordinate relative to parent
           def y
-            y1
+            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

data/lib/glimmer/swt/custom/shape/oval.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.Ellipse2D::Double.new(self.absolute_x, self.absolute_y, width, height)
+            shape_geometry = java.awt.geom.Ellipse2D::Double.new(self.absolute_x, self.absolute_y, calculated_width, calculated_height)
             shape_geometry.contains(x, y)
           end
           
@@ -49,8 +49,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.Ellipse2D::Double.new(self.absolute_x - 3, self.absolute_y - 3, width + 6, height + 6)
-              inner_shape_geometry = java.awt.geom.Ellipse2D::Double.new(self.absolute_x + 3, self.absolute_y + 3, width - 6, height - 6)
+              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

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

@@ -37,6 +37,14 @@ module Glimmer
             [: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.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)

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

@@ -62,16 +62,6 @@ module Glimmer
             x_array.zip(y_array)
           end
           
-          # Logical x coordinate. Always assumes the first point in the polygon to be the x coordinate.
-          def x
-            x_array.first
-          end
-           
-          # Logical y coordinate. Always assumes the first point in the polygon to be the y coordinate.
-          def y
-            y_array.first
-          end
-          
           def absolute_point_array
             if parent.is_a?(Shape)
               point_array.each_with_index.map do |coordinate, i|
@@ -98,9 +88,59 @@ module Glimmer
             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 include?(x, y)
-            shape_geometry = java.awt.Polygon.new(absolute_x_array.to_java(:int), absolute_y_array.to_java(:int), point_count)
-            shape_geometry.contains(x, y)
+            geometry.contains(x, y)
           end
           alias contain? include? # TODO make include do an outer/inner check of edge detection only
           

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

@@ -62,16 +62,6 @@ module Glimmer
             x_array.zip(y_array)
           end
           
-          # Logical x coordinate. Always assumes the first point in the polyline to be the x coordinate.
-          def x
-            x_array.first
-          end
-           
-          # Logical y coordinate. Always assumes the first point in the polyline to be the y coordinate.
-          def y
-            y_array.first
-          end
-          
           def absolute_point_array
             if parent.is_a?(Shape)
               point_array.each_with_index.map do |coordinate, i|
@@ -98,6 +88,42 @@ module Glimmer
             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

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

@@ -34,6 +34,7 @@ module Glimmer
       class Shape
         class Rectangle < Shape
           def parameter_names
+            # TODO consider optimizing just like text where it is set upon updating attribute and here you just return a variable
             if @args.to_a.size >= 6
               rectangle_round_parameter_names
             elsif @args.to_a.size == 5
@@ -81,11 +82,11 @@ module Glimmer
           end
           
           def point_xy_array
-            [[x, y], [x + width, y], [x + width, y + height], [x, y + height]]
+            [[x, y], [x + calculated_width, y], [x + calculated_width, y + calculated_height], [x, y + calculated_height]]
           end
           
           def absolute_point_xy_array
-            [[absolute_x, absolute_y], [absolute_x + width, absolute_y], [absolute_x + width, absolute_y + height], [absolute_x, absolute_y + height]]
+            [[absolute_x, absolute_y], [absolute_x + calculated_width, absolute_y], [absolute_x + calculated_width, absolute_y + calculated_height], [absolute_x, absolute_y + calculated_height]]
           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)

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

@@ -33,8 +33,6 @@ 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 Text < Shape
-          attr_accessor :extent
-        
           def parameter_names
             @parameter_names || text_parameter_names
           end
@@ -69,11 +67,11 @@ module Glimmer
           end
           
           def width
-            extent&.x
+            @extent&.x
           end
           
           def height
-            extent&.y
+            @extent&.y
           end
           
         end

data/samples/hello/hello_canvas.rb

@@ -25,9 +25,20 @@ class HelloCanvas
   include Glimmer::UI::CustomShell
   
   attr_accessor :selected_shape
+  attr_accessor :artist
   
   before_body {
     @image_object = image(File.expand_path('../../icons/scaffold_app.png', __dir__), width: 50)
+    @artist = ''
+  }
+  
+  after_body {
+    Thread.new {
+      'Picasso'.chars.each do |character|
+        sleep(1)
+        self.artist += character
+      end
+    }
   }
   
   body {
@@ -38,10 +49,36 @@ class HelloCanvas
       @canvas = canvas {
         background :yellow
         rectangle(0, 0, 220, 400) {
-          background :red
+          background rgb(255, 0, 0)
         }
         rectangle(50, 20, 300, 150, 30, 50) {
           background :magenta
+          rectangle([:default, -70], :default, :default, [:default, 1]) {
+            foreground :cyan
+            text {
+              x :default, 1
+              # y is assumed to be the default (centered within parent)
+              string bind(self, :artist)
+              background :yellow
+              foreground :dark_magenta
+              font name: 'Courier', height: 30
+            }
+          }
+          rectangle(155, 30) { # width and height are assumed to be the default (calculated from children)
+            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)
+          }
         }
         rectangle(150, 200, 100, 70, true) {
           background :dark_magenta
@@ -51,26 +88,6 @@ class HelloCanvas
           background :magenta
           foreground :dark_blue
         }
-        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)
-        }
-        text('Picasso', 60, 80) {
-          background :yellow
-          foreground :dark_magenta
-          font name: 'Courier', height: 30
-        }
         oval(110, 310, 100, 100) {
           # patterns provide a differnet way to make gradients
           background_pattern 0, 0, 105, 0, :yellow, rgb(128, 138, 248)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer-dsl-swt
 version: !ruby/object:Gem::Version
-  version: 4.18.5.3
+  version: 4.18.5.4
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-25 00:00:00.000000000 Z
+date: 2021-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement