glimmer-dsl-swt 4.18.1.1 → 4.18.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aa85c5f6d4f5a71bbc9538f291fff86199d26219c7b919068b5be7f99fc4bfd
-  data.tar.gz: 4db3a940c06f112c309e822ce73b0a1e98317f87ae808c183f261d49d357c490
+  metadata.gz: beefdf4e3985d47de8a553ea073466812c89a738a1efa691bac62a9d375bb5b9
+  data.tar.gz: ed6373191af3b73886ae171313d0fbcd279205c883f887e2c940cbc0318275a3
 SHA512:
-  metadata.gz: 96d95b883f011fc5d706382c4a8f1eea500ccd9ad15bf1fb3c82e9c7509348d0dcd16ef4c99ef963eb3bb4760e63aca217d0f4ab43d404ea6c8fa636bdfc8adc
-  data.tar.gz: a5182246e7825790b8c63ed8b7506d0e35e93af1f5a2e60c8ad6e015cee6fb092357ef2ca842d6f4bcf432b9cc5676b8167ec2bb42ef6dde47d007e50e1c2ba0
+  metadata.gz: 52eaa3d36b54333a9c457233a00de3975c3e932f99ef7b9b484fdff20c6f96ea2b7465a63f6e2cc46b91b86a3631edef913643b2303103fc2901920402459bea
+  data.tar.gz: 84273ec05bc34a8a233d403edba5ad372a631560252cfec36d3d5bd200410a1a0f9184e07ebb77d0241ae3ea723d6c7575f7441575a61115f53d9c302fb54fb5

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+### 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)

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.1.1
+# [<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.0
 
 
 ## JRuby Desktop Development GUI Framework
@@ -12,7 +12,7 @@
 
 (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. Not only does Glimmer provide a large set of GUI [widgets](#widgets), but 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 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 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.
 
@@ -456,7 +456,7 @@ jgem install glimmer-dsl-swt
 
 Or this command if you want a specific version:
 ```
-jgem install glimmer-dsl-swt -v 4.18.1.1
+jgem install glimmer-dsl-swt -v 4.18.2.0
 
 
 ```
@@ -476,7 +476,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.1
+gem 'glimmer-dsl-swt', '~> 4.18.2.0
 '
 ```
 
@@ -535,7 +535,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.1
+Glimmer (JRuby Desktop Development GUI Framework) - JRuby Gem: glimmer-dsl-swt v4.18.2.0
 
 
       
@@ -1016,7 +1016,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.1.1
+  Swt    glimmer-dsl-swt    4.18.2.0
 
   AndyMaleh    Glimmer DSL for SWT
   Tk     glimmer-dsl-tk     0.0.6     AndyMaleh    Glimmer DSL for Tk
@@ -2294,43 +2294,46 @@ 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 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)`
-- `focus​(x, y, width, height)`
-- `image(image, x, y)`
-- `line(x1, y1, x2, y2)`
-- `oval(x, y, width, height, fill: false)`
-- `point​(x, y)`
-- `polygon(pointArray, fill: false)`
-- `polyline(pointArray)`
-- `rectangle(x, y, width, height, fill: false)`
-- `round_rectangle(x, y, width, height, arcWidth = 60, arcHeight = 60, fill: false)`
-- `gradient_rectangle​(x, y, width, height, vertical = true, fill: false)`
-- `text(String string, x, y)`
+- `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:
-- `alpha` sets transparency (integer between 0 and 255)
-- `antialias` enables antialiasing (SWT style value of :default, :off, :on whereby :default applies OS default)
-- `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)
-- `clipping​(x, y, width, height)` clips area of painting
-- `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)
-- `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)
+- `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)
+- `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)):
 
@@ -2346,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
     }
@@ -2366,6 +2369,39 @@ Screenshot:
 
 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 you would like added to the Glimmer Shape DSL that you saw available in the SWT APIs, you may [report and 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.)
@@ -2374,7 +2410,7 @@ 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
@@ -2411,12 +2447,23 @@ Keywords:
 - `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)
+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 you would like added to the Glimmer Animation DSL that you saw available in the SWT APIs, you may [report and 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.

data/VERSION

@@ -1 +1 @@
-4.18.1.1
+4.18.2.0

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.1 ruby lib
+# stub: glimmer-dsl-swt 4.18.2.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "glimmer-dsl-swt".freeze
-  s.version = "4.18.1.1"
+  s.version = "4.18.2.0"
 
   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-20"
-  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.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 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 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 = [

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

@@ -28,42 +28,126 @@ module Glimmer
       class Animation
         include Properties # TODO rename to Properties
         
+        class << self
+          def schedule_frame_animation(animation, &frame_animation_block)
+            frame_animation_queue(animation).prepend(frame_animation_block)
+            swt_display.async_exec do
+              frame_animation_queue(next_animation)&.pop&.call
+            end
+          end
+          
+          def next_animation
+            animation = nil
+            while frame_animation_queues.values.reduce(:+)&.any? && (animation.nil? || frame_animation_queue(animation).last.nil?)
+              animation = frame_animation_queues.keys[next_animation_index]
+              frame_animation_queues.delete(animation) if frame_animation_queues.values.reduce(:+)&.any? && !animation.nil? && frame_animation_queue(animation).empty?
+            end
+            animation
+          end
+          
+          def next_animation_index
+            next_schedule_index % frame_animation_queues.keys.size
+          end
+          
+          def next_schedule_index
+            unless defined? @@next_schedule_index
+              @@next_schedule_index = 0
+            else
+              @@next_schedule_index += 1
+            end
+          end
+          
+          def frame_animation_queues
+            unless defined? @@frame_animation_queues
+              @@frame_animation_queues = {}
+            end
+            @@frame_animation_queues
+          end
+          
+          def frame_animation_queue(animation)
+            frame_animation_queues[animation] ||= []
+          end
+          
+          def swt_display
+            unless defined? @@swt_display
+              @@swt_display = DisplayProxy.instance.swt_display
+            end
+            @@swt_display
+          end
+        end
+        
         attr_reader :parent, :options, :frame_index, :cycle
         alias current_frame_index frame_index
-        attr_accessor :frame_block, :every, :cycle_count, :frame_count, :started
+        attr_accessor :frame_block, :every, :cycle_count, :frame_count, :started, :duration_limit
+        alias started? started
         # TODO consider supporting an async: false option
         
         def initialize(parent)
           @parent = parent
           @started = true
           @frame_index = 0
+          @cycle_count_index = 0
+          @start_number = 0 # denotes the number of starts (increments on every start)
+          self.class.swt_display # ensures initializing variable to set from GUI thread
         end
         
         def post_add_content
           @parent.on_widget_disposed { stop }
-          start if @started
+          start if started?
         end
         
+        # 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.
         def start
-          swt_display = DisplayProxy.instance.swt_display
+          return if @start_number > 0 && started?
+          @start_number += 1
+          @started = true
+          @start_time = Time.now
+          @original_start_time = @start_time if @duration.nil?
+          # TODO track when finished in a variable for finite animations (whether by frame count, cycle count, or duration limit)
           Thread.new do
+            start_number = @start_number
             if cycle_count.is_a?(Integer) && cycle.is_a?(Array)
               (cycle_count * cycle.length).times do
-                break unless draw_frame(swt_display)
+                break unless draw_frame(start_number)
               end
             else
               loop do
                 # this code has to be duplicated to break from a loop (break keyword only works when literally in a loop block)
-                break unless draw_frame(swt_display)
+                break unless draw_frame(start_number)
               end
             end
-            @started = false
           end
         end
         
         def stop
+          return if stopped?
           @started = false
+          @duration = (Time.now - @start_time) + @duration.to_f if duration_limited? && !@start_time.nil?
+        end
+        
+        # Restarts an animation (whether indefinite or not and whether stopped or not)
+        def restart
+          @original_start_time = @start_time = nil
+          @duration = nil
+          @frame_index = 0
+          @cycle_count_index = 0
+          stop
+          start
+        end
+        
+        def stopped?
+          !started?
+        end
+        
+        def finite?
+          frame_count_limited? || cycle_limited? || duration_limited?
+        end
+        
+        def infinite?
+          !finite?
         end
+        alias indefinite? infinite?
         
         def has_attribute?(attribute_name, *args)
           respond_to?(ruby_attribute_setter(attribute_name)) && respond_to?(ruby_attribute_getter(attribute_name))
@@ -89,21 +173,60 @@ module Glimmer
           end
         end
         
+        def cycle_enabled?
+          @cycle.is_a?(Array)
+        end
+        
+        def cycle_limited?
+          cycle_enabled? && @cycle_count.is_a?(Integer)
+        end
+        
+        def duration_limited?
+          @duration_limit.is_a?(Integer)
+        end
+        
+        def frame_count_limited?
+          @frame_count.is_a?(Integer)
+        end
+        
+        def surpassed_duration_limit?
+          duration_limited? && ((Time.now - @start_time) > (@duration_limit - @duration.to_f))
+        end
+        
+        def within_duration_limit?
+          !surpassed_duration_limit?
+        end
+        
         private
         
         # Returns true on success of painting a frame and false otherwise
-        def draw_frame(swt_display)
-          return false if !@started || (@frame_count.is_a?(Integer) && @frame_index == @frame_count)
+        def draw_frame(start_number)
+          return false if stopped? ||
+                          start_number != @start_number ||
+                          (frame_count_limited? && @frame_index == @frame_count) ||
+                          (cycle_limited? && @cycle_count_index == @cycle_count) ||
+                          surpassed_duration_limit?
           block_args = [@frame_index]
-          block_args << @cycle[@frame_index % @cycle.length] if @cycle.is_a?(Array)
-          swt_display.async_exec do
-            @parent.clear_shapes
-            @parent.content {
-              frame_block.call(*block_args)
-            }
-            @parent.redraw
+          block_args << @cycle[@frame_index % @cycle.length] if cycle_enabled?
+          current_frame_index = @frame_index
+          current_cycle_count_index = @cycle_count_index
+          self.class.schedule_frame_animation(self) do
+            if started? && start_number == @start_number && within_duration_limit?
+              @parent.clear_shapes
+              @parent.content {
+                frame_block.call(*block_args)
+              }
+              @parent.redraw
+            else
+              if stopped? && @frame_index > current_frame_index
+                @started = false
+                @frame_index = current_frame_index
+                @cycle_count_index = current_cycle_count_index
+              end
+            end
           end
           @frame_index += 1
+          @cycle_count_index += 1 if cycle_limited? && (@frame_index % @cycle&.length&.to_i) == 0
           sleep(every) if every.is_a?(Numeric)
           true
         rescue => e

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

@@ -61,11 +61,12 @@ module Glimmer
         
         before_body {
           @swt_style = swt_style == 0 ? [:border, :multi, :v_scroll, :h_scroll] : swt_style
+          @font_name = display.get_font_list(nil, true).map(&:name).include?('Consolas') ? 'Consolas' : 'Courier'
         }
         
         body {
           styled_text(swt_style) {
-            font name: 'Consolas', height: 15
+            font name: @font_name, height: 15
             foreground rgb(75, 75, 75)
             left_margin 5
             top_margin 5

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

@@ -20,6 +20,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'glimmer/swt/properties'
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/swt/color_proxy'
+require 'glimmer/swt/font_proxy'
 
 module Glimmer
   module SWT
@@ -29,7 +33,7 @@ module Glimmer
       # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
       class Shape
         include Properties
-        # TODO support textExtent as an option
+        # TODO support textExtent sized shapes nested within text/string
         # TODO support a Pattern DSL for methods that take Pattern arguments
         
         class << self
@@ -48,8 +52,11 @@ module Glimmer
           end
           
           def method_name(keyword, args)
-            gc_instance_method_name_prefix = arg_options(args)[:fill] ? 'fill_' : 'draw_'
-            "#{gc_instance_method_name_prefix}#{keyword}"
+            keyword = keyword.to_s
+            gradient = 'gradient_' if arg_options(args)[:gradient]
+            round = 'round_' if arg_options(args)[:round]
+            gc_instance_method_name_prefix = !['polyline', 'point', 'image', 'focus'].include?(keyword) && (arg_options(args)[:fill] || arg_options(args)[:gradient]) ? 'fill_' : 'draw_'
+            "#{gc_instance_method_name_prefix}#{gradient}#{round}#{keyword}"
           end
         end
         
@@ -67,18 +74,26 @@ module Glimmer
           post_add_content if property_block.nil?
         end
         
+        def draw?
+          !fill?
+        end
+        
         def fill?
-          !draw?
+          @options[:fill]
         end
         
-        def draw?
-          !@options[:fill]
+        def gradient?
+          @options[:gradient]
+        end
+        
+        def round?
+          @options[:round]
         end
         
         def post_add_content
           event_handler = lambda do |event|
-            @properties['background'] = [DisplayProxy.instance.get_system_color(SWTProxy(:color_widget_background))] if fill? && !@properties.keys.map(&:to_s).include?('background')
-            @properties['foreground'] = [ColorProxy.new(0, 0, 0)] if draw? && !@properties.keys.map(&:to_s).include?('foreground')
+            @properties['background'] = [@parent.background] if fill? && !@properties.keys.map(&:to_s).include?('background')
+            @properties['foreground'] = [@parent.foreground] if draw? && !@properties.keys.map(&:to_s).include?('foreground')
             @properties.each do |property, args|
               method_name = attribute_setter(property)
               apply_property_arg_conversions(method_name, args)
@@ -86,6 +101,7 @@ module Glimmer
             end
             apply_shape_arg_conversions(@method_name, @args)
             apply_shape_arg_defaults(@method_name, @args)
+            tolerate_shape_extra_args(@method_name, @args)
             event.gc.send(@method_name, *@args)
           end
           if parent.respond_to?(:swt_display)
@@ -102,7 +118,7 @@ module Glimmer
               args[0] = ColorProxy.new(args[0])
             end
             if the_java_method.parameter_types.first == Java::int.java_class
-              args[0] = SWTProxy[args[0]]
+              args[0] = SWTProxy.constant(args[0])
             end
           end
           if args.first.is_a?(ColorProxy)
@@ -114,6 +130,18 @@ module Glimmer
           if args.first.is_a?(FontProxy)
             args[0] = args[0].swt_font
           end
+          if ['setBackgroundPattern', 'setForegroundPattern'].include?(method_name.to_s)
+            args.each_with_index do |arg, i|
+              if arg.is_a?(Symbol) || arg.is_a?(String)
+                args[i] = ColorProxy.new(arg).swt_color
+              elsif arg.is_a?(ColorProxy)
+                args[i] = arg.swt_color
+              end
+            end
+            new_args = [DisplayProxy.instance.swt_display] + args
+            args[0] = org.eclipse.swt.graphics.Pattern.new(*new_args)
+            args[1..-1] = []
+          end
         end
         
         def apply_shape_arg_conversions(method_name, args)
@@ -126,18 +154,29 @@ module Glimmer
         def apply_shape_arg_defaults(method_name, args)
           if method_name.include?('round_rectangle') && args.size.between?(4, 5)
             (6 - args.size).times {args << 60}
-          elsif method_name.include?('gradient_rectangle') && args.size == 4
+          elsif method_name.include?('rectangle') && gradient? && args.size == 4
+            args << true
+          elsif (method_name.include?('text') || method_name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && args.size == 3
             args << true
           end
         end
                 
+        # Tolerates shape extra args added by user by mistake
+        # (e.g. happens when switching from round rectangle to a standard one without removing all extra args)
+        def tolerate_shape_extra_args(method_name, args)
+          the_java_method_arg_count = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.select do |m|
+            m.name == method_name.camelcase(:lower)
+          end.map(&:parameter_types).map(&:size).max
+          if args.size > the_java_method_arg_count
+            args[the_java_method_arg_count..-1] = []
+          end
+        end
+                
         def has_attribute?(attribute_name, *args)
-          # TODO test that attribute getter responds too
           self.class.gc_instance_methods.include?(attribute_setter(attribute_name))
         end
   
         def set_attribute(attribute_name, *args)
-          # TODO special treatment for color symbols
           @properties[attribute_name] = args
         end
   

data/samples/hello/hello_canvas.rb

@@ -1,27 +1,48 @@
+# Copyright (c) 2007-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 include Glimmer
 
 shell {
   text 'Hello, Canvas!'
   minimum_size 320, 400
 
-  canvas { |prox|
+  canvas {
     background :yellow
     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
     }
-    gradient_rectangle(50, 200, 30, 70, false, fill: true) {
+    rectangle(50, 200, 30, 70, false, gradient: true) {
       background :magenta
       foreground :dark_blue
     }
     rectangle(205, 50, 88, 96) {
-      foreground color(:yellow)
+      foreground :yellow
     }
     text('Picasso', 60, 80) {
       background :yellow
@@ -34,10 +55,9 @@ shell {
     arc(210, 210, 100, 100, 30, -77, fill: true) {
       background :red
     }
-    polygon(250, 210, 260, 170, 270, 210, 290, 230, 250, 210, fill: true) {
+    polygon(250, 210, 260, 170, 270, 210, 290, 230, fill: true) {
       background :dark_yellow
-      foreground :yellow
     }
-    polygon(250, 110, 260, 70, 270, 110, 290, 130, 250, 110)
+    polyline(250, 110, 260, 70, 270, 110, 290, 130, 250, 110)
   }
 }.open

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glimmer-dsl-swt
 version: !ruby/object:Gem::Version
-  version: 4.18.1.1
+  version: 4.18.2.0
 platform: ruby
 authors:
 - AndyMaleh
@@ -331,17 +331,19 @@ dependencies:
 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.
+  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 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.
 email: andy.am@gmail.com
 executables:
 - glimmer