glimmer-dsl-swt 4.18.1.0 → 4.18.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 174d5b75d96fe6595809e3f212aa30b4fd17caec61fe98018ce8fcf72880c036
-  data.tar.gz: 42f16bb6b36d68dea3ed1886d1993f65b539cc47e22799a4c7bd02fad2208389
+  metadata.gz: 813f7cef0d25c94aa62c0cd57d3445a3eb13acb229bdd59264f7d4a0268f1ed3
+  data.tar.gz: dccf84bac2d2ca037df0b4157335fd7451fc2701d90a79df18abc61971725df6
 SHA512:
-  metadata.gz: 220d7fbbba99b5b9f65c334cd0aec9a3ddb4120227d3ea2876e7ab9327027d70e651b849a4891dd58e5e61f85dce01382919a212c2c39d9d79af83106596bfa3
-  data.tar.gz: ca8a7864a504618abd517aaf97832a185b84e86b7fb21ef4a27ffd70edc068822d1d5aae0ebdd192c9cd5ab106411fd78512354f676e49e1ac2b0dd8a1072154
+  metadata.gz: 9702ce2c81c56ddf6c56e590c7f30509149d75fbd6ee8e01da4bb5e0405381fae39da688ec30ab0686ff987cdc4eee06992d7c4b365a32f8bc2d773ea23e3b05
+  data.tar.gz: 4d1a2dfa58fffa6dd037ef07463056ccc70d09261bb0720f238332c07284347993c94e96ef5d18bb9a7f1f75d71b72ed2fdfe72202320f8de489624ac9084edc

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Change Log
 
+### 4.18.2.3
+
+- Added Tetris Elaborate Sample
+- Added support for CustomShell `::launch` and `::shutdown` class methods to treat a top-level custom shell as a self contained launchable app (saving you from writing boilerplate code for launching Glimmer applications)
+
+### 4.18.2.2
+
+- Fixed issue with processing shape color due to missing Color class package name
+
+### 4.18.2.1
+
+- Ensure drawing image works in Shape DSL
+- Support passing image as simply an image path or image proxy to Shape DSL image method
+
+### 4.18.2.0
+
+- Canvas animation start method (useful if animation had a frame count limit or cycle count limit and needed to be started again after it stopped)
+- Canvas animation stop method
+- Canvas animation restart method (restarts from frame 1)
+- Canvas animation started? # meaning it is animating
+- Canvas animation stopped? # meaning it has stopped animating
+- Canvas animation duration_limit option
+- Make gradient/round rectangles in Shape DSL receive an option of `gradient: true` and `round: true` instead of prefix
+- Canvas Shape DSL support for Background/Foreground Pattern (NOTE: not extensively tested yet)
+- Canvas Shape DSL smart defaults for background/foreground depending on shape being drawn
+- Canvas Shape DSL smart defaults for fill option depending on shape being drawn
+- Added fallback font "Courier" for `code_text` widget when "Consolas" is not available.
+
+### 4.18.1.1
+
+- Add smart defaults for round rectangle angles (defaults to 60 degrees angles)
+- Add smart default for gradient rectangle vertical option
+- Small update to Hello, Canvas! Sample
+- Convert SWT style symbol to SWT style integer if method takes integer but receives a symbol (or string)
+- Make polygon not require [] for its array args
+- Allow cycle to receive splatted array as varargs
+- Change references to `Display.setAppName` and `Display.setAppVersion` to `Display.app_name =` and `Display.app_version =`
+- Default Glimmer app name to "Glimmer" (instead of previous "SWT") unless `Display.app_name = "Somename"` is set by consumer before instantiating first display
+- Set default background to system widget background default for fill shapes
+- Set default foreground to black for draw shapes
+- Fix issue with shapes always requiring a block (even an empty one) to render
+- Fix issue with animation requiring changes to canvas directly in addition to shapes
+- Fix issue with `glimmer list:gems:dsl` command
+- Fix issue with scaffolding still depending on git-glimmer despite being merged back to git gem
+
 ### 4.18.1.0
 
 - Canvas Shape DSL

data/README.md

@@ -1,6 +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.1.0
-
-
+# [<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.2.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)
@@ -10,9 +8,7 @@
 
 **[Contributors Wanted! (Submit a Glimmer App Sample to Get Started)](#contributing)**
 
-(The Original Glimmer Library Since 2007. Beware of Imitators!)
-
-[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 version of [Ruby](https://www.ruby-lang.org/en/). [Glimmer](https://github.com/AndyObtiva/glimmer)'s main innovation is a declarative [Ruby DSL](#glimmer-dsl-syntax) that enables productive and efficient authoring of desktop application user-interfaces while 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](#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. To get started quickly, [Glimmer](https://rubygems.org/gems/glimmer) offers [scaffolding](#scaffolding) options for [Apps](#in-production), [Gems](#custom-shell-gem), and [Custom Widgets](#custom-widgets). [Glimmer](https://rubygems.org/gems/glimmer) also includes native-executable [packaging](#packaging--distribution) 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](#custom-shell-gem) on [Linux](https://www.linux.org/).
+[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](#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](#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](#widgets), but it also supports drawing Canvas Graphics like [Shapes](#canvas-shape-dsl) and [Animations](#canvas-animation-dsl). To get started quickly, [Glimmer](https://rubygems.org/gems/glimmer) offers [scaffolding](#scaffolding) options for [Apps](#in-production), [Gems](#custom-shell-gem), and [Custom Widgets](#custom-widgets). [Glimmer](https://rubygems.org/gems/glimmer) also includes native-executable [packaging](#packaging--distribution) 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](#custom-shell-gem) 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.
 
@@ -368,6 +364,7 @@ Glimmer App:
       - [Login](#login)
       - [Tic Tac Toe Sample](#tic-tac-toe-sample)
       - [Contact Manager Sample](#contact-manager-sample)
+      - [Tetris](#tetris)
     - [External Samples](#external-samples)
       - [Glimmer Calculator](#glimmer-calculator)
       - [Gladiator](#gladiator)
@@ -456,7 +453,7 @@ jgem install glimmer-dsl-swt
 
 Or this command if you want a specific version:
 ```
-jgem install glimmer-dsl-swt -v 4.18.1.0
+jgem install glimmer-dsl-swt -v 4.18.2.3
 
 
 ```
@@ -476,7 +473,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.1.0
+gem 'glimmer-dsl-swt', '~> 4.18.2.3
 '
 ```
 
@@ -535,7 +532,7 @@ bin/glimmer samples
 Below are the full usage instructions that come up when running `glimmer` without args.
 
 ```
-Glimmer (JRuby Desktop Development GUI Framework) - JRuby Gem: glimmer-dsl-swt v4.18.1.0
+Glimmer (JRuby Desktop Development GUI Framework) - JRuby Gem: glimmer-dsl-swt v4.18.2.3
 
 
       
@@ -593,6 +590,8 @@ glimmer samples/hello/hello_world.rb samples/hello/hello_tab.rb
 
 Launches samples/hello/hello_world.rb and samples/hello_tab.rb at the same time, each in a separate JRuby thread.
 
+Note: under Zsh (Z Shell), glimmer can only be used in its advanced TUI mode (e.g. `glimmer` and then selecting a task) not the primitive rake task mode (e.g. `glimmer scaffold[app]`)
+
 ### Glimmer Samples
 
 You can list available Glimmer samples by running:
@@ -1013,8 +1012,8 @@ Output:
   Name         Gem          Version    Author          Description
                                                                          
   Css    glimmer-dsl-css    1.1.0     AndyMaleh    Glimmer DSL for CSS
-  Opal   glimmer-dsl-opal   0.8.0     AndyMaleh    Glimmer DSL for Opal
-  Swt    glimmer-dsl-swt    4.18.1.0
+  Opal   glimmer-dsl-opal   0.10.2     AndyMaleh    Glimmer DSL for Opal
+  Swt    glimmer-dsl-swt    4.18.2.3
 
   AndyMaleh    Glimmer DSL for SWT
   Tk     glimmer-dsl-tk     0.0.6     AndyMaleh    Glimmer DSL for Tk
@@ -1082,6 +1081,8 @@ With `glimmer-dsl-swt` installed, you may want to run `girb` instead of standard
 girb
 ```
 
+![GIRB](images/glimmer-girb.png)
+
 If you cloned [glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt) project locally, you may run `bin/girb` instead.
 
 ```
@@ -1347,7 +1348,8 @@ This is not an exaustive list, but should give you a good start in learning Glim
 **Event loop:**
 - `display`: featured in [Tic Tac Toe](#tic-tac-toe)
 - `async_exec`: featured in [Hello, Custom Widget!](#hello-custom-widget) / [Hello, Custom Shell!](#hello-custom-shell)
-
+- `sync_exec`: executes a block on the event loop synchronously (usually from another thread)
+- `timer_exec`: executes a block after a delay of time has passed
 
 #### SWT Proxies
 
@@ -2292,37 +2294,54 @@ https://help.eclipse.org/2019-12/nftopic/org.eclipse.platform.doc.isv/reference/
 
 ### Canvas Shape DSL
 
-(note: this is a very new feature of Glimmer. It may change a bit while getting battle tested. As always, you could default to basic SWT usage if needed.)
-
 Glimmer supports drawing graphics directly on a `canvas` widget via SWT (or any widget for that matter though `canvas` is recommended for drawing).
 
 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 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​(int x, int y, int width, int height, int startAngle, int arcAngle)`
-- `focus​(int x, int y, int width, int height)`
-- `image(Image image, int x, int y)`
-- `line(int x1, int y1, int x2, int y2)`
-- `oval(int x, int y, int width, int height)`
-- `point​(int x, int y)`
-- `polygon(int[] pointArray)`
-- `polyline(int[] pointArray)`
-- `rectangle(int x, int y, int width, int height)`
-- `round_rectangle(int x, int y, int width, int height, int arcWidth, int arcHeight)`
-- `gradiant_rectangle​(int x, int y, int width, int height, boolean vertical)`
-- `text(String string, int x, int y)`
-
-Shape keywords that can be filled with color can take an additional keyword argument `fill: true`
+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)
+- `image(image, x, y)` [image](#image)
+- `line(x1, y1, x2, y2)` line
+- `oval(x, y, width, height, fill: false)` oval if width does not match heigh and circle if width matches height. Can be optionally filled.
+- `point​(x, y)` point
+- `polygon(pointArray, fill: false)` polygon consisting of points, which close automatically to form a shape that can be optionally filled (when points only form a line, it does not show up as filled)
+- `polyline(pointArray)` polyline is just like a polygon, but it does not close up to form a shape, remaining open (unless the points close themselves by having the last point or an intermediate point match the first)
+- `rectangle(x, y, width, height, fill: false)` standard rectangle, which can be optionally filled
+- `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, flags = nil)` 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 an keyword argument `fill: true` (defaults to false when not specified)
 
 Optionally, a shape keyword takes a block that can set any attributes from [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) (methods starting with `set`), which enable setting the `background` for filling and `foreground` for drawing.
 
+Here is a list of supported attributes nestable within a block under shapes:
+- `advanced` enables advanced graphics subsystem (boolean value). Typically gets enabled automatically when setting alpha, antialias, patterns, interpolation, clipping. Rendering sometimes differs between advanced and non-advanced mode for basic graphics too, so you could enable manually if you prefer its look even for basic graphics.
+- `alpha` sets transparency (integer between `0` and `255`)
+- `antialias` enables antialiasing (SWT style value of `:default`, `:off`, `:on` whereby `:default` applies OS default, which varies per OS)
+- `background` sets fill color for fillable shapes (standard color symbol (e.g. `:red`), `rgb(red_integer, green_integer, blue_integer)` color, or Color/ColorProxy object directly)
+- `background_pattern` sets fill gradient/image pattern for fillable shape background (takes the same arguments as the SWT [Pattern](https://help.eclipse.org/2020-12/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/Pattern.html) class [e.g. `background_pattern 2.3, 4.2, 5.4, 7.2, :red, :blue`] / note: this feature isn't extensively tested yet)
+- `clipping` clips area of painting (​numeric values for `(x, y, width, height)`)
+- `fill_rule` sets filling rule (SWT style value of `:fill_even_odd` or `:fill_winding`)
+- `font` sets font (Hash of `:name`, `:height`, and `:style` just like standard widget font property, or Font/FontProxy object directly)
+- `foreground` sets draw color for drawable shapes (standard color symbol (e.g. `:red`), `rgb(red_integer, green_integer, blue_integer)` color, or Color/ColorProxy object directly)
+- `foreground_pattern` sets foreground gradient/image pattern for drawable shape lines (takes the same arguments as the SWT [Pattern](https://help.eclipse.org/2020-12/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/Pattern.html) class [e.g. `foreground_pattern 2.3, 4.2, 5.4, 7.2, :red, :blue`] / note: this feature isn't extensively tested yet)
+- `interpolation` sets the interpolation value (SWT style value of `:default`, `:none`, `:low`, `:high`)
+- `line_cap` sets line cap (SWT style value of `:cap_flat`, `:cap_round`, or `:cap_square`)
+- `line_dash` line dash float values (automatically sets `line_style` to SWT style value of `:line_custom`)
+- `line_join` line join style (SWT style value of `:join_miter`, `:join_round`, or `:join_bevel`)
+- `line_style` line join style (SWT style value of `:line_solid`, `:line_dash`, `:line_dot`, `:line_dashdot`, or `:line_dashdotdot`)
+- `line_width` line width in integer (used in draw operations)
+- `text_anti_alias` enables text antialiasing (SWT style value of `:default`, `:off`, `:on` whereby `:default` applies OS default, which varies per OS)
+
 Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
 
 ```ruby
 include Glimmer
 
 shell {
-  text 'Canvas Example!'
+  text 'Canvas Example'
   minimum_size 320, 400
 
   canvas {
@@ -2330,10 +2349,10 @@ shell {
     rectangle(0, 0, 220, 400, fill: true) {
       background :red
     }
-    round_rectangle(50, 20, 300, 150, 30, 50, fill: true) {
+    rectangle(50, 20, 300, 150, 30, 50, round: true, fill: true) {
       background :magenta
     }
-    gradient_rectangle(150, 200, 100, 70, true, fill: true) {
+    rectangle(150, 200, 100, 70, true, gradient: true) {
       background :dark_magenta
       foreground :yellow
     }
@@ -2344,8 +2363,45 @@ shell {
 }.open
 ```
 
+Screenshot:
+
+![Canvas Animation Example](images/glimmer-example-canvas.png)
+
 Learn more at the [Hello, Canvas! Sample](#hello-canvas).
 
+If you get extremely stuck, remember that you could always default to direct [SWT GC usage]([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) and learn more at the [SWT Graphics Guide](https://www.eclipse.org/articles/Article-SWT-graphics/SWT_graphics.html) and [SWT Image Guide](https://www.eclipse.org/articles/Article-SWT-images/graphics-resources.html#Saving%20Images).
+
+Example of manually doing the same things as in the above example without relying on the declarative Glimmer Shape DSL:
+
+```ruby
+include Glimmer
+
+shell {
+  text 'Canvas Manual Example'
+  minimum_size 320, 400
+
+  canvas {
+    background :yellow
+    
+    on_paint_control { |event|
+      event.gc.setBackground(color(:red).swt_color)
+      event.gc.fillRectangle(0, 0, 220, 400)
+      
+      event.gc.setBackground(color(:magenta).swt_color)
+      event.gc.fillRoundRectangle(50, 20, 300, 150, 30, 50)
+      
+      event.gc.setBackground(color(:dark_magenta).swt_color)
+      event.gc.fillGradientRectangle(150, 200, 100, 70, true)
+      
+      event.gc.setForeground(color(:dark_blue).swt_color)
+      event.gc.drawRectangle(200, 80, 108, 36)
+    }
+  }
+}.open
+```
+
+In any case, if there is anything missing you would like added to the Glimmer Shape DSL that you saw available in the SWT APIs, you may [report an issue](https://github.com/AndyObtiva/glimmer-dsl-swt/issues) or implement yourself and [contribute](#contributing) via a Pull Request.
+
 ### Canvas Animation DSL
 
 (note: this is a very new feature of Glimmer. It may change a bit while getting battle tested. As always, you could default to basic SWT usage if needed.)
@@ -2354,13 +2410,13 @@ Glimmer additionally provides built-in support for animations via a declarative
 
 Animations take advantage of multi-threading, each animation runs in its own independent thread of execution while updating the GUI asynchronously.
 
-This example says it all (it moves a tiny red square across a blue background):
+This example says it all (it moves a tiny red square across a blue background) (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
 
 ```ruby
 include Glimmer
 
 shell {
-  text 'Canvas Animation Example!'
+  text 'Canvas Animation Example'
   minimum_size 400, 400
 
   canvas {
@@ -2378,8 +2434,12 @@ shell {
 }.open
 ```
 
-Keywords involved:
-- `animation` declares an animation under a canvas, which renders frames indefinitely or finitely depending on properties
+Screenshot:
+
+![Canvas Animation Example](images/glimmer-example-canvas-animation.png)
+
+Keywords:
+- `animation` declares an animation under a canvas, which renders frames using a frame block indefinitely or finitely depending on (cycle_count/frame_count) properties
 - `every` specifies delay in seconds between every two frame renders
 - `frame` a block that can contain Shape DSL syntax that is rendered dynamically with variables calculated on the fly
 - `cycle` a property that takes an array to cycle into a second variable for the `frame` block
@@ -2387,15 +2447,23 @@ Keywords involved:
 - `frame_count` an optional frame count limit after which the animation stops
 - `started` a boolean indicating if the animation is started right away or stopped waiting for manual startup via `#start` method
 
-API:
-- `#start` starts animation as a method on the animation object (returned from `animation` keyword)
-- `#stop` stops animation gracefully as a method on the animation object (returned from `animation` keyword)
-
-Caveat:
-In order for animation to occur, the frame block must include changes that happen directly on the canvas (like setting initial background updating every frame) not just changes to shapes. This should be fixed in the future.
+API of Animation Object (returned from `animation` keyword):
+- `#start` starts an animation that is indefinite or has never been started before (i.e. having `started: false` option). Otherwise, resumes a stopped animation that has not been completed.
+- `#stop` stops animation. Maintains progress when `frame_count`, `cycle_count`, or `duration_limit` are set and haven't finished. That way, if `#start` is called, animation resumes from where it stopped exactly to completion.
+- `#restart` restarts animation, restarting progress of `frame_count`, `cycle_count`, and `duration_limit` if set.
+- `#started?` returns whether animation started
+- `#stopped?` returns whether animation stopped
+- `#indefinite?` (alias `infinite?`) returns true if animation does not have `frame_count`, `cycle_count`, or `duration_limit`
+- `#finite?` returns true if animation has `frame_count`, `cycle_count` (with `cycle`), or `duration_limit`
+- `#frame_count_limited?` returns true if `frame_count` is specified
+- `#cycle_enabled?` returns true if `cycle` is specified
+- `#cycle_limited?` returns true if `cycle_count` is specified
+- `#duration_limited?` returns true if `duration_limit` is specified
 
 Learn more at the [Hello, Canvas Animation! Sample](#hello-canvas-animation).
 
+If there is anything missing you would like added to the Glimmer Animation DSL that you saw available in the SWT APIs, you may [report an issue](https://github.com/AndyObtiva/glimmer-dsl-swt/issues) or implement yourself and [contribute](#contributing) via a Pull Request.
+
 ### Data-Binding
 
 Data-binding is done with `bind` command following widget property to bind and taking model and bindable attribute as arguments.
@@ -3579,12 +3647,12 @@ Example.new
 
 Application name (shows up on the Mac in top menu bar) and version may be specified upon [packaging](#packaging--distribution) by specifying "-Bmac.CFBundleName" and "-Bmac.CFBundleVersion" options.
 
-Still, if you would like proper application name to show up on the Mac top menu bar during development, you may do so by invoking the SWT Display.setAppName method before any Display object has been instantiated (i.e. before any Glimmer widget like shell has been declared).
+Still, if you would like proper application name to show up on the Mac top menu bar during development, you may do so by invoking the SWT `Display.app_name=` method before any Display object has been instantiated (i.e. before any Glimmer widget like shell has been declared).
 
 Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
 
 ```ruby
-Display.setAppName('Glimmer Demo')
+Display.app_name = 'Glimmer Demo'
 
 shell(:no_resize) {
   text "Glimmer"
@@ -3594,7 +3662,7 @@ shell(:no_resize) {
 }.open
 ```
 
-Also, you may invoke `Display.setAppVersion('1.0.0')` if needed for OS app version identification reasons during development, replacing `'1.0.0'` with your application version.
+Also, you may invoke `Display.app_version = '1.0.0'` if needed for OS app version identification reasons during development, replacing `'1.0.0'` with your application version.
 
 #### Checkbox Group Widget
 
@@ -4566,6 +4634,16 @@ Contact Manager - Edit Done
 
 ![Contact Manager](images/glimmer-contact-manager-edit-done.png)
 
+#### Tetris
+
+This sample demonstrates how to build an interactive animated game with MVC architecture, custom-shell/custom-widgets, multi-threading, asynchronous programming, data-binding, canvas shape graphic decorations, and keyboard events.
+
+Code:
+
+[samples/elaborate/tic_tac_toe.rb](samples/elaborate/tetris.rb)
+
+![Tetris](images/glimmer-tetris.png)
+
 ### External Samples
 
 #### Glimmer Calculator
@@ -4593,7 +4671,7 @@ Gladiator is a good demonstration of:
 
 #### Timer
 
-[<img alt="Glimmer Timer Icon" src="https://raw.githubusercontent.com/AndyObtiva/glimmer-cs-timer/master/images/glimmer-timer-logo.png" height=40 /> Timer](https://github.com/AndyObtiva/glimmer-cs-timer) is a sample app demonstrating data-binding, multi-threading, and Java (Sound) library integration in a desktop application.
+[<img alt="Glimmer Timer Icon" src="https://raw.githubusercontent.com/AndyObtiva/glimmer-cs-timer/master/images/glimmer-timer-logo.png" height=40 /> Timer](https://github.com/AndyObtiva/glimmer-cs-timer) is a sample app demonstrating data-binding, multi-threading, and JSound (Java Sound) library integration in a desktop application.
 
 [<img src="https://raw.githubusercontent.com/AndyObtiva/glimmer-cs-timer/master/glimmer-timer-screenshot.png" />](https://github.com/AndyObtiva/glimmer-cs-timer)
 
@@ -4686,6 +4764,8 @@ require_relative '../app/my_application.rb'
 
 ### javapackager Extra Arguments
 
+(note: currently `Glimmer::RakeTask::Package.javapackager_extra_args` is only honored when packaging from bash, not zsh)
+
 In order to explicitly configure javapackager, Mac package attributes, or sign your Mac app to distribute on the App Store, you can follow more advanced instructions for `javapackager` here:
 - https://docs.oracle.com/javase/9/tools/javapackager.htm#JSWOR719
 - https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javapackager.html
@@ -4794,6 +4874,16 @@ By the way, keep in mind that during normal operation, it does also indicate a f
 Exec failed with code 2 command [[/usr/bin/SetFile, -c, icnC, /var/folders/4_/g1sw__tx6mjdgyh3mky7vydc0000gp/T/fxbundler4076750801763032201/images/MathBowling/.VolumeIcon.icns] in unspecified directory
 ```
 
+3. Zsh (Z Shell)
+
+Currently, `Glimmer::RakeTask::Package.javapackager_extra_args` is only honored when packaging from bash, not zsh.
+
+You can get around that in zsh by running glimmer package commands with `bash -c` prefix:
+
+```
+bash -c 'glimmer package'
+```
+
 ## App Updates
 
 Glimmer already supports automatic (and manual) app updates via the Mac App Store for Mac apps. Simply run the `glimmer package` command with the Mac App Store keys configured as per [Mac Application Distribution](mac-application-distribution) instructions and you get automatic (and manual) app update support courtesy of the Mac App Store.

data/VERSION

@@ -1 +1 @@
-4.18.1.0
+4.18.2.3

data/glimmer-dsl-swt.gemspec

@@ -2,17 +2,17 @@
 # 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.1.0 ruby lib
+# stub: glimmer-dsl-swt 4.18.2.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "glimmer-dsl-swt".freeze
-  s.version = "4.18.1.0"
+  s.version = "4.18.2.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-01-19"
-  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 version of Ruby. Glimmer's main innovation is a declarative Ruby DSL that enables productive and efficient authoring of desktop application user-interfaces while 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. 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.date = "2021-01-23"
+  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]
   s.extra_rdoc_files = [
@@ -132,6 +132,12 @@ Gem::Specification.new do |s|
     "samples/elaborate/contact_manager/contact_repository.rb",
     "samples/elaborate/login.rb",
     "samples/elaborate/meta_sample.rb",
+    "samples/elaborate/tetris.rb",
+    "samples/elaborate/tetris/model/block.rb",
+    "samples/elaborate/tetris/model/game.rb",
+    "samples/elaborate/tetris/model/tetromino.rb",
+    "samples/elaborate/tetris/view/block.rb",
+    "samples/elaborate/tetris/view/playfield.rb",
     "samples/elaborate/tic_tac_toe.rb",
     "samples/elaborate/tic_tac_toe/board.rb",
     "samples/elaborate/tic_tac_toe/cell.rb",