glimmer-dsl-swt 4.18.2.4 → 4.18.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e12bb24a84b93822013eef2122021cd5e6a8f90f9e450ac83f7bd5b5f0b7b55
-  data.tar.gz: dfdba626253a34506b99971821378e8579eac7f21a955ddbd7bc0543f770ad51
+  metadata.gz: 59c5aae689604e6024a5bffb1053cd50cc05c1598dca6fc3a01510f17371deab
+  data.tar.gz: 5fc97483b96bf334b1e25b30b8455ad41af3e6f56ae6f5310ac31504ce87c41d
 SHA512:
-  metadata.gz: d489317bc86659858e1215aca4f35441aa123f59affb4f35fe9fce1ec04f220f3856f5d203d686a1091a7a1652b746a9453ce598eb684910b1ded8717fc1552b
-  data.tar.gz: 10c31c53aab7d5a8905c6448f66dcacb01c98b952c9934ae1e5236437e583d37aa607161f38946754938c9fc655c876064cc268a93d73d8746667d69d69f684b
+  metadata.gz: fdf5681c5632aa64d15c9e2037757d4e7599fbcaeacc14acc1af1dd1669c205ca7a8730551277ae0a3cff5bb435a802dcbdb824e7dbc749f75471ba15079e999
+  data.tar.gz: 5f96f41c1bdd491da20ae87ad1b2a5f072eeaca78c6e8f15a1a942390c2cc23b07259465452b242e0d61111a6881954458b5fe5214d77bfd4f45dd365ae0eb14

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Change Log
 
+### 4.18.3.3
+
+- Support Table data binding read_only_sort: true option to allow visual sorting without affecting model data
+- Tetris Add lines and level to High Score Dialog
+- Tetris Immediate Drop on Arrow Up
+- Tetris Pause on showing High Score Dialog
+- Tetris Make High Scores -> Show a check menu item
+- Tetris Disable pause button upon showing High Score Dialog
+- Fix Quit Tetris CMD+Q shortcut by adding on_quit event to display
+- Tetris Fix escape button upon entering high score name
+- If WidgetBinding encounters a disposed widget, it deregisters all observables that it is observing
+
+### 4.18.3.2
+
+- Tetris High Scores
+- Tetris Modify High Score Player Name
+- Tetris Show High Scores (Menu Item + Accelerator)
+- Tetris add a menu item with beep enablement option
+- Tetris Clear High Scores
+- Tetris Add left and right alt (option) buttons as alternative to shift for rotation. Use left ctrl as rotate left. Use a, s, d as left, down, right.
+- Fix issues relating to setting parenthood with custom widgets before building their body (instead of after)
+- Fix issues relating to not respecting arity of passed in table editing callbacks: before_write, after_write, and after_cancel
+
+### 4.18.3.1
+
+- Provide an auto_sync_exec all data-binding config option to automatically sync_exec GUI calls from other threads instead of requiring users to use sync_exec on model attribute-change logic. Default value to false.
+- Have CustomShell::launch method take options to pass to custom shell keyword invocation
+- Update Glimmer Meta-Sample to load entire gem into user directory (since some new samples rely on images)
+- Update Glimmer Meta-Sample to display errors in a `dialog` instead of a `message_box` to allow scrolling
+- Removed newly added CustomShell::shutdown as unnecessary (could just do CustomShell::launchd_custom_shell.close)
+- Supporting deregistering Display listeners just like standard listeners via deregister
+- Enhance performance of excluded keyword check
+- Remove CustomWidget support for multiple before_body/after_body blocks instead of one each since it is not needed.
+- Add new :fill_screen style for `shell` to start app filling the screen size (not full screen mode though)
+- Tetris Menu Bar with Game Menu -> Start, Pause, Restart, and Exit
+- Tetris refactor mutation methods to end with bangs
+- Tetris Stop game if user does not play again in the end (instead of closing it)
+- End Tetris Thread loop gracefully if game over is encountered
+- Tetris use more observers instead of callbacks to Game
+- Turn Tetris::Model::Game class from a singleton class to a standard class supporting instances
+- Fix issue of `tetris` keyword not found when run from meta-sample app
+
+### 4.18.3.0
+
+- Canvas Transform DSL (DSL declared Transform objects are auto-disposed after getting used by their parent shape)
+- Canvas support a top-level Transform DSL fluent interface for methods that use Transform arguments manually (e.g. tr1 = transform.rotate(90).translate(0, -100))
+- Hello, Canvas Transformation!
+
+### 4.18.2.5
+
+- ColorProxy args now are automatically fit into 0..255 bounds upon use of the `color`/`rgb`/`rgba` keywords
+- Canvas Shape DSL (Property) Data-Binding support (No Argument Data-Binding support yet)
+- Add a more bevel 3D look to Tetris blocks
+- Use flyweight pattern with colors
+- Use flyweight pattern with widget classes
+- Use flyweight pattern with custom widget classes
+- Optimized performance of Canvas Shape DSL
+- Optimized performance of Tetris game
+- Fixed issue with top-level sync_exec/async_exec use randomly bombing
+
 ### 4.18.2.4
 
 - Tetris scoring

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.2.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.3.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)
@@ -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](#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 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) s [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.
 
@@ -24,7 +24,7 @@ Glimmer DSL gems:
 - [glimmer-dsl-opal](https://github.com/AndyObtiva/glimmer-dsl-opal): Glimmer DSL for Opal (Pure Ruby Web GUI and Auto-Webifier of Desktop Apps)
 - [glimmer-dsl-xml](https://github.com/AndyObtiva/glimmer-dsl-xml): Glimmer DSL for XML (& HTML)
 - [glimmer-dsl-css](https://github.com/AndyObtiva/glimmer-dsl-css): Glimmer DSL for CSS
-- [glimmer-dsl-tk](https://github.com/AndyObtiva/glimmer-dsl-tk): Glimmer DSL for Tk (Ruby Desktop Development GUI Library)
+- [glimmer-dsl-tk](https://github.com/AndyObtiva/glimmer-dsl-tk): Glimmer DSL for Tk (MRI Ruby Desktop Development GUI Library)
 
 ## Examples
 
@@ -226,7 +226,7 @@ Glimmer App:
 
 [![Math Bowling App Screenshot](https://raw.githubusercontent.com/AndyObtiva/MathBowling/master/Math-Bowling-Screenshot.png)](https://github.com/AndyObtiva/MathBowling)
 
-**Note:** I offer Glimmer as an open-source project that represents my interests in Ruby Programming, Desktop GUI application development with SWT, Object Oriented Design, Design Patterns, and Software Architecture.
+**Note:** I offer Glimmer DSL for SWT as a free and open-source [Ruby Gem](https://rubygems.org/gems/glimmer-dsl-swt) that represents my interests in Ruby Programming, Desktop GUI application development with SWT, Object Oriented Design, Design Patterns, and Software Architecture.
 Additionally, I am sharing my professional experience and expertise in Eclipse SWT given that I am an [EclipseCon](http://andymaleh.blogspot.com/2007/03/eclipsecon-2007-day-3.html)/[EclipseWorld](http://andymaleh.blogspot.com/2008/11/eclipseworld-2008-highlights.html) presenter and have built professional applications in SWT/JFace/RCP for Obtiva and the Pampered Chef in the past. This is also done in the hopes that it would indirectly bring me work in a field I am extremely passionate about.
 That said, please keep in mind that I myself am learning topics in Software Engineering too everyday, including newer editions of SWT and JRuby, which seem to pop up every quarter.
 If you see anything that needs to be improved, please do not hesitate to contact me on [Gitter](https://gitter.im/AndyObtiva/glimmer) or submit [Issues](https://github.com/AndyObtiva/glimmer-dsl-swt/issues)/[Pull-Requests](https://github.com/AndyObtiva/glimmer-dsl-swt/pulls).
@@ -241,6 +241,7 @@ If you see anything that needs to be improved, please do not hesitate to contact
     - [Desktop Apps Built with Glimmer DSL for SWT](#desktop-apps-built-with-glimmer-dsl-for-swt)
   - [Table of contents](#table-of-contents)
   - [Background](#background)
+  - [Software Architecture](#software-architecture)
   - [Platform Support](#platform-support)
   - [Pre-requisites](#pre-requisites)
   - [Setup](#setup)
@@ -288,6 +289,7 @@ If you see anything that needs to be improved, please do not hesitate to contact
     - [Layouts](#layouts)
     - [Layout Data](#layout-data)
     - [Canvas Shape DSL](#canvas-shape-dsl)
+    - [Canvas Transform DSL](#canvas-transform-dsl)
     - [Canvas Animation DSL](#canvas-animation-dsl)
     - [Data-Binding](#data-binding)
       - [General Examples](#general-examples)
@@ -364,6 +366,7 @@ If you see anything that needs to be improved, please do not hesitate to contact
       - [Hello, Dialog!](#hello-dialog)
       - [Hello, Canvas!](#hello-canvas)
       - [Hello, Canvas Animation!](#hello-canvas-animation)
+      - [Hello, Canvas Transform!](#hello-canvas-transform)
     - [Elaborate Samples](#elaborate-samples)
       - [User Profile](#user-profile)
       - [Login](#login)
@@ -403,7 +406,39 @@ If you see anything that needs to be improved, please do not hesitate to contact
   
 ## Background
 
-Ruby is a dynamically-typed object-oriented language, which provides great productivity gains due to its powerful expressive syntax and dynamic nature. While it is proven by the Ruby on Rails framework for web development, it currently lacks a robust platform-independent framework for building desktop applications. Given that Java libraries can now be utilized in Ruby code through JRuby, Eclipse technologies, such as SWT, JFace, and RCP can help fill the gap of desktop application development with Ruby.
+[Ruby](https://www.ruby-lang.org) is a dynamically-typed object-oriented language, which provides great productivity gains due to its powerful expressive syntax and dynamic nature. While it is proven by the [Ruby](https://www.ruby-lang.org) on Rails framework for web development, it currently lacks a robust platform-independent framework for building desktop applications. Given that Java libraries can now be utilized in Ruby code through JRuby, Eclipse technologies, such as [SWT](https://www.eclipse.org/swt/), JFace, and RCP can help fill the gap of desktop application development with Ruby.
+
+## Software Architecture
+
+There are several requirements for building enterprise-level/consumer-level desktop GUI applications:
+- Cross-Platform Support (Mac, Windows, Linux) without compilation/recompilation
+- OS Native Look & Feel
+- High Performance
+- Productivity
+- Maintainability
+- Extensibility
+- Native Executable Packaging
+- Multi-Threading / Parallel Programming
+- Arbitrary Graphics Painting
+- Audio Support
+
+Glimmer provides cross-platform support that does not require Ruby compilation (like Tk does), thanks to JRuby, a JVM (Java Virtual Machine) faster OS-threaded version of Ruby.
+
+Glimmer leverages SWT (Standard Widget Toolkit), which provides cross-platform widgets that automatically use the native GUI libraries under each operating system, such as Win32 on Windows, Cocoa on Mac, and GTK on Linux.
+
+Furthermore, what is special about SWT regarding "High Performance" is that it does all the GUI painting natively outside of Java, thus producing GUI that runs at maximum performance even in Ruby. As such, you do not need to worry about Ruby dynamic typing getting in the way of GUI performance. It has ZERO effect on it and since SWT supports making asynchronous calls for GUI rendering, you could avoid blocking the GUI completely with any computations happening in Ruby no matter how complex, thus never affecting the responsiveness of GUI of applications while taking full advantage of the productivity benefits of Ruby dynamic typing.
+
+Glimmer takes this further by providing a very programmer friendly DSL (Domain Specific Language) that visually maps lightweight Ruby syntax to the containment hierarchy of GUI widgets (meaning Ruby blocks nested within each other map to GUI widgets nested within each other). This provides maximum productivity and maintainability.
+
+Extensibility has never been simpler in desktop GUI application development than with Glimmer, which provides the ability to support any new custom keywords through custom widgets and custom shells (windows). Basically, you map a keyword by declaring a view class matching its name by convention with a GUI body that simply consists of reusable Glimmer GUI syntax. They can be passive views or smart views with additional logic. This provides the ultimate realization of Object Oriented Programming and micro-level MVC pattern.
+
+Thanks to Java and JRuby, Glimmer apps can be packaged as cross-platform JAR files (with JRuby Warbler) and native executables (with Java Packager) as Mac APP/DMG/PACKAGE or Windows EXE/MSI.
+
+The Java Virtual Machine already supports OS-native threads, so Glimmer apps can have multiple things running in parallel with no problem.
+
+SWT supports Canvas graphics drawing, and Glimmer takes that further by provding a Canvas Shape/Transform/Animation DSL, making it very simple to decorate any existing widgets or add new widgets with a completely custom look and feel if needed for branding or entertainment (gaming) purposes.
+
+Audio is supported via the Java Sound library in a cross-platform approach and video is supported via a Glimmer custom widget, so any Glimmer app can be enhanced with audio and video where needed.
 
 ## Platform Support
 
@@ -458,7 +493,7 @@ jgem install glimmer-dsl-swt
 
 Or this command if you want a specific version:
 ```
-jgem install glimmer-dsl-swt -v 4.18.2.4
+jgem install glimmer-dsl-swt -v 4.18.3.3
 
 
 ```
@@ -478,7 +513,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.2.4
+gem 'glimmer-dsl-swt', '~> 4.18.3.3
 '
 ```
 
@@ -537,7 +572,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.2.4
+Glimmer (JRuby Desktop Development GUI Framework) - JRuby Gem: glimmer-dsl-swt v4.18.3.3
 
 
       
@@ -813,7 +848,7 @@ glimmer run
 
 #### Custom Shell
 
-To scaffold a Glimmer custom shell (full window view) for an existing Glimmer app, run the following command:
+To scaffold a Glimmer [custom shell](#custom-shells) (full window view) for an existing Glimmer app, run the following command:
 
 ```
 glimmer scaffold:customshell[name]
@@ -827,7 +862,7 @@ glimmer scaffold:cs[name]
 
 #### Custom Widget
 
-To scaffold a Glimmer custom widget (part of a view) for an existing Glimmer app, run the following command:
+To scaffold a Glimmer [custom widget](#custom-widgets) (part of a view) for an existing Glimmer app, run the following command:
 
 ```
 glimmer scaffold:customwidget[name]
@@ -841,7 +876,7 @@ glimmer scaffold:cw[name]
 
 #### Custom Shell Gem
 
-Custom shell gems are self-contained Glimmer apps as well as reusable custom shells.
+Custom shell gems are self-contained Glimmer apps as well as reusable [custom shells](#custom-shells).
 They have everything scaffolded Glimmer apps come with in addition to gem content like a [Juwelier](https://rubygems.org/gems/juwelier) Rakefile that can build gemspec and release gems.
 Unlike scaffolded Glimmer apps, custom shell gem content lives under the `lib` directory (not `app`).
 They can be packaged as both a native executable (e.g. Mac DMG/PKG/APP) and a Ruby gem.
@@ -876,7 +911,7 @@ Examples:
 
 #### Custom Widget Gem
 
-To scaffold a Glimmer custom widget gem (part of a view distributed as a Ruby gem), run the following command:
+To scaffold a Glimmer [custom widget](#custom-widgets) gem (part of a view distributed as a Ruby gem), run the following command:
 
 ```
 glimmer scaffold:gem:customwidget[name,namespace]
@@ -902,7 +937,7 @@ Examples:
 
 ### Gem Listing
 
-The `glimmer` command comes with tasks for listing Glimmer related gems to make it easy to find Glimmer Custom Shells, Custom Widgets, and DSLs published by others in the Glimmer community on [rubygems.org](http://www.rubygems.org).
+The `glimmer` command comes with tasks for listing Glimmer related gems to make it easy to find Glimmer [Custom Shells](#custom-shells), [Custom Widgets](#custom-widgets), and DSLs published by others in the Glimmer community on [rubygems.org](http://www.rubygems.org).
 
 #### Listing Custom Shell Gems
 
@@ -1018,7 +1053,7 @@ Output:
                                                                          
   Css    glimmer-dsl-css    1.1.0     AndyMaleh    Glimmer DSL for CSS
   Opal   glimmer-dsl-opal   0.10.2     AndyMaleh    Glimmer DSL for Opal
-  Swt    glimmer-dsl-swt    4.18.2.4
+  Swt    glimmer-dsl-swt    4.18.3.3
 
   AndyMaleh    Glimmer DSL for SWT
   Tk     glimmer-dsl-tk     0.0.6     AndyMaleh    Glimmer DSL for Tk
@@ -1096,7 +1131,12 @@ bin/girb
 
 Watch out for hands-on examples in this README indicated by "you may copy/paste in [`girb`](#girb-glimmer-irb-command)"
 
-Keep in mind that all samples live under [https://github.com/AndyObtiva/glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt)
+Keep in mind that all samples live under [https://github.com/AndyObtiva/glimmer-dsl-swt/samples](https://github.com/AndyObtiva/glimmer-dsl-swt/samples)
+
+If you need a more GUI interactive option to experiement with Glimmer GUI DSL Syntax, you may try:
+- [Glimmer Meta-Sample (The Sample of Samples)](#samples): allows launching Glimmer samples and viewing/editing code to learn/experiment too.
+- ["Ugliest Editor Ever"](https://github.com/AndyObtiva/glimmer-cs-gladiator)
+- Just build your own GUI editor using the [Glimmer DSL for SWT Ruby Gem](https://rubygems.org/gems/glimmer-dsl-swt).
 
 ## Glimmer GUI DSL Syntax
 
@@ -1507,7 +1547,7 @@ Although SWT Display is not technically a widget, it has similar APIs and DSL su
 
 #### Multi-Threading
 
-[JRuby](https://www.jruby.org/) supports [truly parallel multi-threading](https://github.com/jruby/jruby/wiki/Concurrency-in-jruby) since it relies on the JVM (Java Virtual Machine). As such, it enables development of highly-interactive desktop applications that can do background work while the user is interacting with the GUI.
+[JRuby](https://www.jruby.org/) supports [truly parallel multi-threading](https://github.com/jruby/jruby/wiki/Concurrency-in-jruby) since it relies on the JVM (Java Virtual Machine). As such, it enables development of highly-interactive desktop applications that can do background work while the user is interacting with the GUI. However, any code that interacts with the GUI from a thread other than the main (first) GUI thread must do so only through sync_exec (if it is standard synchronous code) or async_exec.
 
 ##### async_exec
 
@@ -1938,7 +1978,7 @@ style = swt(:shell_trim, :max!) # creates a shell trim style without the maximiz
 
 SWT Shell widget by default is resizable. To make it non-resizable, one must pass a complicated style bit concoction like `swt(:shell_trim, :resize!, :max!)`.
 
-Glimmer makes this easier by alternatively offering a `:no_resize` extra SWT style, added for convenience.
+Glimmer makes this easier by alternatively ing a `:no_resize` extra SWT style, added for convenience.
 This makes declaring a non-resizable window as easy as:
 
 ```ruby
@@ -2339,6 +2379,7 @@ Here is a list of supported attributes nestable within a block under shapes:
 - `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)
+- `transform` sets transform object using [Canvas Transform DSL](#canvas-transform-dsl) syntax
 
 Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
 
@@ -2387,6 +2428,8 @@ If you get extremely stuck, remember that you could always default to direct [SW
 Example of manually doing the same things as in the above example without relying on the declarative Glimmer Shape DSL:
 
 ```ruby
+image_object = image(File.expand_path('./icons/scaffold_app.png'), width: 100)
+
 include Glimmer
 
 shell {
@@ -2397,17 +2440,23 @@ shell {
     background :yellow
     
     on_paint_control { |event|
-      event.gc.setBackground(color(:red).swt_color)
-      event.gc.fillRectangle(0, 0, 220, 400)
+      event.gc.set_background(color(:red).swt_color)
+      event.gc.fill_rectangle(0, 0, 220, 400)
+      
+      event.gc.set_background(color(:magenta).swt_color)
+      event.gc.fill_roundRectangle(50, 20, 300, 150, 30, 50)
       
-      event.gc.setBackground(color(:magenta).swt_color)
-      event.gc.fillRoundRectangle(50, 20, 300, 150, 30, 50)
+      event.gc.set_background(color(:dark_magenta).swt_color)
+      event.gc.fill_gradientRectangle(150, 200, 100, 70, true)
       
-      event.gc.setBackground(color(:dark_magenta).swt_color)
-      event.gc.fillGradientRectangle(150, 200, 100, 70, true)
+      event.gc.set_foreground(color(:dark_blue).swt_color)
+      event.gc.draw_rectangle(200, 80, 108, 36)
       
-      event.gc.setForeground(color(:dark_blue).swt_color)
-      event.gc.drawRectangle(200, 80, 108, 36)
+      event.gc.set_foreground(color(:black).swt_color)
+      event.gc.set_lineWidth(3)
+      event.gc.draw_rectangle(200, 80, 108, 36)
+      
+      event.gc.draw_image(image_object.swt_image, 70, 50)
     }
   }
 }.open
@@ -2419,6 +2468,88 @@ In any case, if there is anything missing you would like added to the Glimmer Sh
 
 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](#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`.
 
+### Canvas Transform DSL
+
+The transform DSL builds [org.eclipse.swt.graphics.Transform](https://help.eclipse.org/2020-12/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/Transform.html) objects with a nice declarative syntax.
+
+`transform` keyword builds a `Transform` object. It optionally takes the transformation matrix elements: (m11, m12, m21, m22, dx, dy)
+
+The first 2 values represent the 1st row, the second 2 values represent the 2nd row, and the last 2 values represent translation on the x and y axes
+
+Additionally, Transform operation keywords may be nested within the `transform` keyword to set its properties:
+- `identity` resets transform to identity (no transformation)
+- `invert` inverts a transform
+- `multiply(&block)` multiplies by another transform (takes a block representing properties of another transform, no need for using the word transform again)
+- `rotate(angle)` rotates by angle degrees
+- `scale(x, y)` scales a shape (stretch)
+- `shear(x, y)` shear effect
+- `translate(x, y)` translate x and y coordinates (move)
+- `elements(m11, m12, m21, m22, dx, dy)` resets all values of the transform matrix (first 2 values represent the 1st row, second 2 values represent the 2nd row, the last 2 values represent translation on x and y axes)
+ 
+Also, setting `transform` to `nil` after a previous `transform` has been set is like calling `identity`. It resets the transform.
+ 
+Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+include Glimmer
+
+shell {
+  text 'Canvas Transform Example'
+  minimum_size 330, 352
+  
+  canvas { |canvas_proxy|
+    background :white
+
+    text('glimmer', 0, 0) {
+      foreground :red
+      transform {
+        translate 220, 100
+        scale 2.5, 2.5
+        rotate 90
+      }
+    }
+    text('glimmer', 0, 0) {
+      foreground :dark_green
+      transform {
+        translate 0, 0
+        shear 2, 3
+        scale 2, 2
+      }
+    }
+    text('glimmer', 0, 0) {
+      foreground :blue
+      transform {
+        translate 0, 220
+        scale 3, 3
+      }
+    }
+  }
+}.open
+```
+
+![Canvas Transform Example](images/glimmer-example-canvas-transform.png)
+
+#### Top-Level Transform Fluent Interface
+
+When using a transform at the top-level (outside of shell), you get a fluent interface to faciliate manual constructioni and use.
+
+Example:
+
+```ruby
+include Glimmer # make sure it is included in your class/module before using the fluent interface
+
+transform(1, 1, 4, 2, 2, 4).
+  multiply(1, 2, 3, 4,3,4).
+  scale(1, 2, 3, 4, 5, 6).
+  rotate(45).
+  scale(2, 4).
+  invert.
+  shear(2, 4).
+  translate(3, 7)
+```
+
+Learn more at the [Hello, Canvas Transform! Sample](#hello-canvas-transform).
+
 ### 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.)
@@ -2843,7 +2974,7 @@ Glimmer automatic table sorting supports `String`, `Integer`, and `Float` column
 
 In cases where data is nil, depending on the data-type, it is automatically converted to `Float` with `to_f`, `Integer` with `to_i`, or `String` with `to_s`.
 
-Should you have a special data type that could not be compared automatically, Glimmer offers the following 3 alternatives for custom sorting:
+Should you have a special data type that could not be compared automatically, Glimmer s the following 3 alternatives for custom sorting:
 - `sort_property`: this may be set to an alternative property to the one data-bound to the table column. For example, a table column called 'adult', which returns `true` or `false` may be sorted with `sort_property :dob` instead. This also support multi-property (aka multi-column) sorting (e.g. `sort_property :dob, :name`).
 - `sort_by(&block)`: this works just like Ruby `Enumerable` `sort_by`. The block receives the table column data as argument.
 - `sort(&comparator)`: this works just like Ruby `Enumerable` `sort`. The comparator block receives two objects from the table column data.
@@ -2894,6 +3025,7 @@ Here is an explanation of the example above:
 - Task Start Date table column has a custom sort comparator block
 - Additional (secondary) sort properties are applied when sorting by Task, Project, or Duration in the order specified
 
+`bind(model, :property, read_only_sort: true)` could be used with items to make sorting not propagate sorting changes to model.
 
 #### Tree
 
@@ -2938,7 +3070,7 @@ a text widget to the user to change the selected or passed tree item text into s
 
 `date_time` represents the SWT DateTime widget.
 
-Glimmer offers the following alias keywords for it for convenience:
+Glimmer s the following alias keywords for it for convenience:
 - `date`: `date_time(:date)`
 - `date_drop_down`: `date_time(:date, :drop_down)`
 - `time`: `date_time(:time)`
@@ -3143,7 +3275,7 @@ Approach #1 is a casual Ruby-based approach. Approach #2 is the official Glimmer
 
 A developer might start with approach #1 to eliminate duplication in a view and later upgrade it to approach #2 when needing to export a custom widget to make it available in many views.
 
-Class-based Custom Widgets offer a number of benefits over method-based custom widgets, such as built-in support for passing SWT style, nested block of extra widgets and properties, and `before_body`/`after_body` hooks.
+Class-based Custom Widgets  a number of benefits over method-based custom widgets, such as built-in support for passing SWT style, nested block of extra widgets and properties, and `before_body`/`after_body` hooks.
 
 #### Simple Example
 
@@ -3401,11 +3533,13 @@ shell { |app_shell|
 }.open
 ```
 
+If you use a Custom Shell as the top-level app shell, you may invoke the class method `::launch` instead to avoid building an app class yourself or including Glimmer into the top-level namespace (e.g. `Tetris.launch` instead of `include Glimmer; tetris.open`)
+
 You may check out [Hello, Custom Shell!](#hello-custom-shell) for another example.
 
 ### Drag and Drop
 
-Glimmer offers Drag and Drop support, thanks to [SWT](https://www.eclipse.org/swt/) and Glimmer's lightweight [DSL syntax](#glimmer-dsl-syntax).
+Glimmer s Drag and Drop support, thanks to [SWT](https://www.eclipse.org/swt/) and Glimmer's lightweight [DSL syntax](#glimmer-dsl-syntax).
 
 You may learn more about SWT Drag and Drop support over here: [https://www.eclipse.org/articles/Article-SWT-DND/DND-in-SWT.html](https://www.eclipse.org/articles/Article-SWT-DND/DND-in-SWT.html)
 
@@ -3681,6 +3815,41 @@ shell(:no_resize) {
 
 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.
 
+#### Performance Profiling
+
+JRuby comes with built-in support for performance profiling via the `--profile` option (with some code shown below), which can be accepted by the `glimmer` command too:
+
+`glimmer --profile path_to_glimmer_app.rb`
+
+Additionally, add this code to monitor Glimmer app performance around its launch method:
+
+```ruby
+require 'jruby/profiler'
+profile_data = JRuby::Profiler.profile do
+  SomeGlimmerApp.launch
+end
+
+profile_printer = JRuby::Profiler::HtmlProfilePrinter.new(profile_data)
+ps = java.io.PrintStream.new(STDOUT.to_outputstream)
+```
+
+When monitoring app startup time performance, make sure to add a hook to the top-level `shell` `on_swt_show` event that exits the app as soon as the shell shows up to end performance profiling and get the results.
+
+Example:
+
+```ruby
+shell {
+  # some code
+  on_swt_show {
+    exit(0)
+  }
+}
+```
+
+You may run `glimmer` with the `--profile.graph` instead for a more detailed output.
+
+Learn more at the [JRuby Performance Profile WIKI page](https://github.com/jruby/jruby/wiki/Profiling-JRuby).
+
 #### Checkbox Group Widget
 
 `checkbox_group` (or alias `check_group`) is a Glimmer built-in custom widget that displays a list of `checkbox` buttons (`button(:check)`) based on its `items` property.
@@ -4017,8 +4186,18 @@ end
 
 ### log_excluded_keywords
 
+(default = false)
+
 This just tells Glimmer whether to log excluded keywords or not (at the debug level). It is off by default.
 
+### auto_sync_exec
+
+(default = false)
+
+This automatically uses sync_exec on GUI calls from threads other than the main GUI thread instead of requiring users to manually use sync_exec. Default value to false.
+
+Keep in mind the caveat that it would force redraws on every minor changein the models instead of applying large scope changes all together, thus causing too much drawing/stutter in the GUI. As such, this is a good fit for simpler GUIs, not ones used with highly sophisticated 2D graphics. It may be mitigated in the future by introducing the idea of large-scale observation events that wrap around smaller events. Until then, keep the caveat in mind or just use sync_exec manually as usually done with Java SWT apps.
+
 ## Glimmer Style Guide
 
 - Widgets are declared with underscored lowercase versions of their SWT names minus the SWT package name.
@@ -4094,6 +4273,12 @@ This brings up the [Glimmer Meta-Sample (The Sample of Samples)](samples/elabora
 
 You may edit the code of any sample before launching it by clicking on the "Launch" button. This helps you learn by experimenting with Glimmer GUI DSL syntax. To go back to original code, simply hit the "Reset" button.
 
+Note that if you fail to run any sample through the Glimmer Meta-Sample for whatever reason, you could always run directly by cloning the project, running `bundle`, and then this command (drop the "bin" if you install the glimmer-dsl-swt gem instead):
+
+```ruby
+bin/glimmer samples/hello/hello_canvas_transform.rb
+```
+
 ### Hello Samples
 
 For hello-type simple samples, check the following.
@@ -4581,6 +4766,19 @@ Hello, Canvas Animation Another Frame!
 
 ![Hello Canvas Animation Frame 2](images/glimmer-hello-canvas-animation-frame2.png)
 
+#### Hello, Canvas Transform!
+
+This sample demonstrates the use of the `transform` keyword as part of the [Transform DSL](#canvas-transform-dsl) within the [Shape DSL](#canvas-shape-dsl).
+
+Code:
+
+[samples/hello/hello_canvas_transform.rb](samples/hello/hello_canvas_transform.rb)
+
+Hello, Canvas Transform!
+
+![Hello Canvas Transform](images/glimmer-hello-canvas-transform.png)
+
+
 ### Elaborate Samples
 
 For more elaborate samples, check the following:
@@ -4663,6 +4861,18 @@ Code:
 
 ![Tetris Game Over](images/glimmer-tetris-game-over.png)
 
+![Tetris Game Over](images/glimmer-tetris-game-over-sorted-by-score.png)
+
+![Tetris High Scores](images/glimmer-tetris-high-score-dialog.png)
+
+![Tetris Game Menu](images/glimmer-tetris-game-menu.png)
+
+![Tetris View Menu](images/glimmer-tetris-view-menu.png)
+
+![Tetris Options Menu](images/glimmer-tetris-options-menu.png)
+
+![Tetris Help Menu](images/glimmer-tetris-help-menu.png)
+
 ### External Samples
 
 #### Glimmer Calculator
@@ -4824,7 +5034,7 @@ Pass `-v` to javapackager in `Glimmer::RakeTask::Package.javapackager_extra_args
 
 ### Windows Application Packaging
 
-Windows offers two options for setup packaging:
+Windows s two options for setup packaging:
 - `msi` (recommended): simpler packaging option. Requires [WiX Toolset](https://wixtoolset.org/) and [.NET Framework](https://dotnet.microsoft.com/download/dotnet-framework). Simply run `glimmer package[msi]` (or `glimmer package:native[msi]` if it's not your first time) and it will give you more details on the pre-requisites you need to install (e.g. [WiX Toolset](https://wixtoolset.org/) and [.NET Framework 3.5 SP1](https://dotnet.microsoft.com/download/dotnet-framework/net35-sp1)).
 - `exe`: more advanced packaging option. Requires [Inno Setup](https://jrsoftware.org/isinfo.php). Simply run `glimmer package[exe]` (or `glimmer package:native[exe]` if it's not your first time) and it will tell you what you need to install.