glimmer-dsl-libui 0.7.7 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc2c8178ea922168b2df15740230c175155c96313d847dd117137ba18eba0991
-  data.tar.gz: 49cbaff89df8bb0d1099b6adf9f0dcdaefe05010c4ee7b295160b0f7fbe8bd66
+  metadata.gz: c03b331e5839b335cf2945538ed66eb6faf988f6ec6230f41abbb3f4fb918159
+  data.tar.gz: 7e2a9da5462232b63f28602811b81b15d28e20a10f322058513142e0a103ceb0
 SHA512:
-  metadata.gz: 30c0cbe41224d6c18e32c204a9f8fab80330ce27d8174f3293399ea9aeb73474f2083145d361d708f062d7035762a4417a135be886dacc09785034ed2b8f0887
-  data.tar.gz: 3f5adf2374b390a21f4e6e7c28003c0446d5fd2a1c810beaebedb820530f56f7415c4a44f91887056be8e7745bc6cc6cd9728c9833cbd7688886f1b3a293d355
+  metadata.gz: 8153d251be4588058275826d42a1eace167148a25a9b54b3906948438888532276773143b4f26b21ae7fab4cc071bca33f36da8db6627cef5c38bb6ce273e6e4
+  data.tar.gz: '0921ce14a33189f3145a72536c2feed44626a4ace129ea2978581d17514bcf048c1b70b58eb6a8fd7207b58b1bfd1d5cbb5c4bc6bc9ece7e3acc223d6e95d8d8'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change Log
 
+## 0.8.0
+
+- Support `composite_shape` keyword (alias: `shape`) as aggregate (composite) shape that can have arbitrary shapes, text, transforms underneath, which inherit its `fill`/`stroke` colors and `transform`
+- New `examples/basic_composite_shape.rb` with use of `shape` + drag and drop support for moving shapes and click support for changing shape colors
+- Invert `Glimmer::LibUI::ControlProxy::KEYWORD_ALIASES` to enable adding multiple aliases per keyword
+- Support `Glimmer::LibUI::Shape::KEYWORD_ALIASES` to enable adding multiple aliases per keyword
+- Small update for `examples/button_counter.rb`
+
+## 0.7.8
+
+- Upgrade to `perfect-shape` gem version 1.0.8 to fix a crashing issue in `examples/shape_coloring.rb`
+
 ## 0.7.7
 
 - Support ability for `area` `on_key_event`/`on_key_down`/`on_key_up` listeners to return a boolean value indicating whether they handled a key event or not in case some key events need to be left to other operating system key handlers like COMMAND+Q for the Mac quit menu item

data/README.md

@@ -1,9 +1,11 @@
-# [<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 LibUI 0.7.7
+# [<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 LibUI 0.8.0
 ## Prerequisite-Free Ruby Desktop Development GUI Library
 ### The Quickest Way From Zero To GUI
 [![Gem Version](https://badge.fury.io/rb/glimmer-dsl-libui.svg)](http://badge.fury.io/rb/glimmer-dsl-libui)
 [![Join the chat at https://gitter.im/AndyObtiva/glimmer](https://badges.gitter.im/AndyObtiva/glimmer.svg)](https://gitter.im/AndyObtiva/glimmer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
+**[If You Liked Shoes, You'll Love Glimmer!](https://github.com/AndyObtiva/glimmer#faq)**
+
 (**[Fukuoka Ruby Award Competition 2022 Special Award Winner](https://andymaleh.blogspot.com/2022/02/glimmer-dsl-for-libui-wins-fukuoka-ruby.html)** [[Award Announcement]](http://www.digitalfukuoka.jp/topics/187?locale=ja))
 
 (**[***RubyConf 2022 Talk - Building Native GUI Apps in Ruby***](https://andymaleh.blogspot.com/2023/02/rubyconf-2022-talk-video-for-building.html)**)
@@ -335,19 +337,7 @@ Mac | Windows | Linux
 
 NOTE: [Glimmer DSL for LibUI](https://rubygems.org/gems/glimmer-dsl-libui) is regularly catching up with changes in the C [libui-ng](https://github.com/libui-ng/libui-ng) library API and in beta mode. The C [libui-ng](https://github.com/libui-ng/libui-ng) is still mid-alpha, which is why [Glimmer DSL for LibUI](https://rubygems.org/gems/glimmer-dsl-libui) cannot be declared v1.0.0 yet. Please help make better by contributing, adopting for small or low risk projects, and providing feedback. The more feedback and issues you report the better.
 
-**[Glimmer](https://rubygems.org/gems/glimmer) DSL Comparison Table:**
-DSL | Platforms | Native? | Vector Graphics? | Pros | Cons | Prereqs
-----|-----------|---------|------------------|------|------|--------
-[Glimmer DSL for SWT (JRuby Desktop Development GUI Framework)](https://github.com/AndyObtiva/glimmer-dsl-swt) | Mac / Windows / Linux | Yes | Yes (Canvas Shape DSL) | Very Mature / Scaffolding / Native Executable Packaging / Custom Widgets | Slow JRuby Startup Time / Heavy Memory Footprint | Java / JRuby
-[Glimmer DSL for Opal (Pure Ruby Web GUI and Auto-Webifier of Desktop Apps)](https://github.com/AndyObtiva/glimmer-dsl-opal) | All Web Browsers | No | Yes (Canvas Shape DSL) | Simpler than All JavaScript Technologies / Auto-Webify Desktop Apps | Setup Process / Only Rails 5 Support for Now | Rails
-[Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI Library)](https://github.com/AndyObtiva/glimmer-dsl-libui) | Mac / Windows / Linux | Yes | Yes (Area API) | Fast Startup Time / Light Memory Footprint | LibUI is an Incomplete Mid-Alpha Only | None Other Than MRI Ruby
-[Glimmer DSL for Tk (Ruby Tk Desktop Development GUI Library)](https://github.com/AndyObtiva/glimmer-dsl-tk) | Mac / Windows / Linux | Some Native-Themed Widgets (Not Truly Native) | Yes (Canvas) | Fast Startup Time / Light Memory Footprint | Complicated Setup / Widgets Do Not Look Truly Native, Espcially on Linux | ActiveTcl / MRI Ruby
-[Glimmer DSL for GTK (Ruby-GNOME Desktop Development GUI Library)](https://github.com/AndyObtiva/glimmer-dsl-gtk) | Mac / Windows / Linux | Only on Linux | Yes (Cairo) | Complete Access to GNOME Features on Linux (Forte) | Not Native on Mac and Windows | None Other Than MRI Ruby on Linux / Brew Packages on Mac / MSYS & MING Toolchains on Windows / MRI Ruby
-[Glimmer DSL for FX (FOX Toolkit Ruby Desktop Development GUI Library)](https://github.com/AndyObtiva/glimmer-dsl-fx) | Mac (requires XQuartz) / Windows / Linux | No | Yes (Canvas) | No Prerequisites on Windows (Forte Since Binaries Are Included Out of The Box) | Widgets Do Not Look Native / Mac Usage Obtrusively Starts XQuartz | None Other Than MRI Ruby on Windows / XQuarts on Mac / MRI Ruby
-[Glimmer DSL for JFX (JRuby JavaFX Desktop Development GUI Library)](https://github.com/AndyObtiva/glimmer-dsl-jfx) | Mac / Windows / Linux | No | Yes (javafx.scene.shape and javafx.scene.canvas) | Rich in Custom Widgets | Slow JRuby Startup Time / Heavy Memory Footprint / Widgets Do Not Look Native | Java / JRuby / JavaFX SDK
-[Glimmer DSL for Swing (JRuby Swing Desktop Development GUI Library)](https://github.com/AndyObtiva/glimmer-dsl-swing) | Mac / Windows / Linux | No | Yes (Java2D) | Very Mature | Slow JRuby Startup Time / Heavy Memory Footprint / Widgets Do Not Look Native | Java / JRuby
-[Glimmer DSL for XML (& HTML)](https://github.com/AndyObtiva/glimmer-dsl-xml) | All Web Browsers | No | Yes (SVG) | Programmable / Lighter-weight Than Actual XML | XML Elements Are Sometimes Not Well-Named (Many Types of Input) | None
-[Glimmer DSL for CSS](https://github.com/AndyObtiva/glimmer-dsl-css) | All Web Browsers | No | Yes | Programmable | CSS Is Over-Engineered / Too Many Features To Learn | None
+Learn more about the differences between various [Glimmer](https://github.com/AndyObtiva/glimmer) DSLs by looking at the **[Glimmer DSL Comparison Table](https://github.com/AndyObtiva/glimmer#glimmer-dsl-comparison-table)**.
 
 ## Table of Contents
 
@@ -373,6 +363,7 @@ DSL | Platforms | Native? | Vector Graphics? | Pros | Cons | Prereqs
       - [Area Listeners](#area-listeners)
       - [Area Methods/Attributes](#area-methods-attributes)
       - [Area Transform Matrix](#area-transform-matrix)
+      - [Area Composite Shape](#area-composite-shape)
       - [Area Animation](#area-animation)
     - [Smart Defaults and Conventions](#smart-defaults-and-conventions)
     - [Custom Keywords](#custom-keywords)
@@ -544,7 +535,7 @@ gem install glimmer-dsl-libui
 Or install via Bundler `Gemfile`:
 
 ```ruby
-gem 'glimmer-dsl-libui', '~> 0.7.7'
+gem 'glimmer-dsl-libui', '~> 0.8.0'
 ```
 
 Test that installation worked by running the [Meta-Example](#examples):
@@ -773,7 +764,7 @@ Keyword(Args) | Properties | Listeners
 
 All operations that could normally be called on `LibUI` can also be called on `Glimmer::LibUI`, but some have enhancements as detailed below.
 
-- `Glimmer::LibUI::queue_main(&block)`: queues an operation to be run on the main event loop at the earliest opportunity possible
+- `Glimmer::LibUI::queue_main(&block)`: queues an operation to be run on the main event loop at the earliest opportunity possible. When writing multi-threaded code, it is required to wrap all code interacting with GUI objects (like `window` or `button`) from another `Thread` with `Glimmer::LibUI::queue_main { ... }`. See [Glimmer Meta-Example](https://github.com/AndyObtiva/glimmer-dsl-libui/blob/master/examples/meta_example.rb) for an example of using `Glimmer::LibUI::queue_main { ... }` inside another `Thread`.
 - `Glimmer::LibUI::timer(time_in_seconds=0.1, repeat: true, &block)`: calls block after time_in_seconds has elapsed, repeating indefinitely unless repeat is `false` or an `Integer` for finite number of repeats. Block can return `false` or `true` to override next repetition.
 
 There are additional useful `Glimmer::LibUI` operations that are not found in `LibUI`, which mostly help if you would like to do advanced lower level [LibUI](https://github.com/kojix2/LibUI) programming:
@@ -1563,6 +1554,170 @@ You can set a `matrix`/`transform` on `area` directly to conveniently apply to a
 
 Note that `area`, `path`, and nested shapes are all truly declarative, meaning they do not care about the ordering of calls to `fill`, `stroke`, and `transform`. Furthermore, any transform that is applied is reversed at the end of the block, so you never have to worry about the ordering of `transform` calls among different paths. You simply set a transform on the `path`s that need it and it is guaranteed to be called before all its content is drawn, and then undone afterwards to avoid affecting later paths. Matrix `transform` can be set on an entire `area` too, applying to all nested `path`s.
 
+#### Area Composite Shape
+
+If you would like to build a composite shape that contains smaller sub-shapes, which would all get treated as a single unit,
+you can use the `shape` (or `composite_shape`) keyword, and wrap all the sub-shapes within the composite `shape`.
+
+If you specify the `fill`, `stroke`, and `transform` at the `shape` level, they will get inherited by all sub-shapes that do not
+specify values for `fill`, `stroke`, or `transform` (though if they do, they override their parent's value).
+
+When you use the `include?(x, y)` or `contain?(x, y)` method on a composite `shape`, it automatically includes all its aggregated shapes
+in the inclusion or containment check using the corresponding [PerfectShape](https://github.com/AndyObtiva/perfect-shape) object.
+
+Example of a `cube` method-based custom keyword built using the composite `shape` keyword:
+
+![glimmer-dsl-libui-mac-basic-composite-shape.gif](/images/glimmer-dsl-libui-mac-basic-composite-shape.gif)
+
+```ruby
+require 'glimmer-dsl-libui'
+
+class BasicCompositeShape
+  include Glimmer::LibUI::Application
+  
+  body {
+    window {
+      title 'Basic Composite Shape'
+      content_size 200, 225
+    
+      @area = area {
+        rectangle(0, 0, 200, 225) {
+          fill :white
+        }
+        
+        7.times do |n|
+          x_location = (rand*125).to_i%200 + (rand*15).to_i
+          y_location = (rand*125).to_i%200 + (rand*15).to_i
+          shape_color = [rand*125 + 130, rand*125 + 130, rand*125 + 130]
+          shape_size = 20+n
+
+          cube(
+            location_x: x_location,
+            location_y: y_location,
+            rectangle_width: shape_size*2,
+            rectangle_height: shape_size,
+            cube_height: shape_size*2,
+            background_color: shape_color,
+            line_thickness: 2
+          ) { |the_shape|
+            on_mouse_up do |area_mouse_event|
+              # Change color on mouse up without dragging
+              if @drag_shape.nil?
+                background_color = [rand(255), rand(255), rand(255)]
+                the_shape.fill = background_color
+              end
+            end
+            
+            on_mouse_drag_start do |area_mouse_event|
+              @drag_shape = the_shape
+              @drag_x = area_mouse_event[:x]
+              @drag_y = area_mouse_event[:y]
+            end
+                        
+            on_mouse_drag do |area_mouse_event|
+              if @drag_shape && @drag_x && @drag_y
+                drag_distance_width = area_mouse_event[:x]  - @drag_x
+                drag_distance_height = area_mouse_event[:y] - @drag_y
+                @drag_shape.x += drag_distance_width
+                @drag_shape.y += drag_distance_height
+                @drag_x = area_mouse_event[:x]
+                @drag_y = area_mouse_event[:y]
+              end
+            end
+            
+            on_mouse_drop do |area_mouse_event|
+              @drag_shape = nil
+              @drag_x = nil
+              @drag_y = nil
+            end
+          }
+        end
+        
+        # this general area on_mouse_drag listener is needed to ensure that dragging a shape
+        # outside of its boundaries would still move the dragged shape
+        on_mouse_drag do |area_mouse_event|
+          if @drag_shape && @drag_x && @drag_y
+            drag_distance_width = area_mouse_event[:x]  - @drag_x
+            drag_distance_height = area_mouse_event[:y] - @drag_y
+            @drag_shape.x += drag_distance_width
+            @drag_shape.y += drag_distance_height
+            @drag_x = area_mouse_event[:x]
+            @drag_y = area_mouse_event[:y]
+          end
+        end
+        
+        on_mouse_drop do |area_mouse_event|
+          @drag_shape = nil
+          @drag_x = nil
+          @drag_y = nil
+        end
+      }
+    }
+  }
+  
+  # method-based custom shape using `shape` keyword as a composite shape containing nested shapes
+  # that are declared with relative positioning
+  def cube(location_x: 0,
+           location_y: 0,
+           rectangle_width: nil,
+           rectangle_height: nil,
+           cube_height: nil,
+           background_color: :brown,
+           line_thickness: 1,
+           &content_block)
+    default_size = 28
+    rectangle_width ||= rectangle_height || cube_height || default_size
+    rectangle_height ||= rectangle_width || cube_height || default_size
+    cube_height ||= rectangle_width || rectangle_height || default_size
+    foreground_color = [0, 0, 0, thickness: line_thickness]
+    
+    # the shape keyword (alias for composite_shape) enables building a composite shape that is treated as one shape
+    # like a cube containing polygons, a polyline, a rectangle, and a line
+    # with the fill and stroke colors getting inherited by all children that do not specify them
+    shape(location_x, location_y) { |the_shape|
+      fill background_color
+      stroke foreground_color
+    
+      bottom = polygon(0, cube_height + rectangle_height / 2.0,
+              rectangle_width / 2.0, cube_height,
+              rectangle_width, cube_height + rectangle_height / 2.0,
+              rectangle_width / 2.0, cube_height + rectangle_height) {
+        # inherits fill property from parent shape if not set
+        # inherits stroke property from parent shape if not set
+      }
+      body = rectangle(0, rectangle_height / 2.0, rectangle_width, cube_height) {
+        # inherits fill property from parent shape if not set
+        # stroke is overridden to ensure a different value from parent
+        stroke thickness: 0
+      }
+      polyline(0, rectangle_height / 2.0 + cube_height,
+               0, rectangle_height / 2.0,
+               rectangle_width, rectangle_height / 2.0,
+               rectangle_width, rectangle_height / 2.0 + cube_height) {
+        # inherits stroke property from parent shape if not set
+      }
+      top = polygon(0, rectangle_height / 2.0,
+              rectangle_width / 2.0, 0,
+              rectangle_width, rectangle_height / 2.0,
+              rectangle_width / 2.0, rectangle_height) {
+        # inherits fill property from parent shape if not set
+        # inherits stroke property from parent shape if not set
+      }
+      line(rectangle_width / 2.0, cube_height + rectangle_height,
+           rectangle_width / 2.0, rectangle_height) {
+        # inherits stroke property from parent shape if not set
+      }
+      
+      content_block&.call(the_shape)
+    }
+  end
+end
+
+BasicCompositeShape.launch
+        
+
+```
+
 #### Area Animation
 
 If you need to animate `area` vector graphics, you just have to use the [`Glimmer::LibUI::timer`](#libui-operations) method along with making changes to shape attributes.

data/VERSION

@@ -1 +1 @@
-0.7.7
+0.8.0

data/docs/examples/GLIMMER-DSL-LIBUI-BASIC-EXAMPLES.md

@@ -25,6 +25,7 @@
   - [Basic Transform](#basic-transform)
   - [Basic Draw Text](#basic-draw-text)
   - [Basic Code Area](#basic-code-area)
+  - [Basic Composite Shape](#basic-composite-shape)
 
 ## Basic Window
 
@@ -2344,36 +2345,20 @@ Mac | Windows | Linux
 
 New [Glimmer DSL for LibUI](https://rubygems.org/gems/glimmer-dsl-libui) Version:
 
-```ruby
-require 'glimmer-dsl-libui'
+## Basic Composite Shape
 
-class BasicCodeArea
-  include Glimmer::LibUI::Application
-  
-  before_body do
-    @code = <<~CODE
-      # Greets target with greeting
-      def greet(greeting: 'Hello', target: 'World')
-        
-        puts "\#{greeting}, \#{target}!"
-      end
-      
-      greet
-      greet(target: 'Robert')
-      greet(greeting: 'Aloha')
-      greet(greeting: 'Aloha', target: 'Nancy')
-      greet(greeting: 'Howdy', target: 'Doodle')
-    CODE
-  end
-  
-  body {
-    window('Basic Code Area', 400, 300) {
-      margined true
-      
-      code_area(language: 'ruby', code: @code)
-    }
-  }
-end
+[examples/basic_composite_shape.rb](/examples/basic_composite_shape.rb)
+
+Run with this command from the root of the project if you cloned the project:
 
-BasicCodeArea.launch
 ```
+ruby -r './lib/glimmer-dsl-libui' examples/basic_composite_shape.rb
+```
+
+Run with this command if you installed the [Ruby gem](https://rubygems.org/gems/glimmer-dsl-libui):
+
+```
+ruby -r glimmer-dsl-libui -e "require 'examples/basic_composite_shape.rb'"
+```
+
+![glimmer-dsl-libui-mac-basic-composite-shape.gif](/images/glimmer-dsl-libui-mac-basic-composite-shape.gif)

data/examples/basic_composite_shape.rb

@@ -0,0 +1,145 @@
+require 'glimmer-dsl-libui'
+
+class BasicCompositeShape
+  include Glimmer::LibUI::Application
+  
+  body {
+    window {
+      title 'Basic Composite Shape'
+      content_size 200, 225
+    
+      @area = area {
+        rectangle(0, 0, 200, 225) {
+          fill :white
+        }
+        
+        7.times do |n|
+          x_location = (rand*125).to_i%200 + (rand*15).to_i
+          y_location = (rand*125).to_i%200 + (rand*15).to_i
+          shape_color = [rand*125 + 130, rand*125 + 130, rand*125 + 130]
+          shape_size = 20+n
+
+          cube(
+            location_x: x_location,
+            location_y: y_location,
+            rectangle_width: shape_size*2,
+            rectangle_height: shape_size,
+            cube_height: shape_size*2,
+            background_color: shape_color,
+            line_thickness: 2
+          ) { |the_shape|
+            on_mouse_up do |area_mouse_event|
+              # Change color on mouse up without dragging
+              if @drag_shape.nil?
+                background_color = [rand(255), rand(255), rand(255)]
+                the_shape.fill = background_color
+              end
+            end
+            
+            on_mouse_drag_start do |area_mouse_event|
+              @drag_shape = the_shape
+              @drag_x = area_mouse_event[:x]
+              @drag_y = area_mouse_event[:y]
+            end
+                        
+            on_mouse_drag do |area_mouse_event|
+              if @drag_shape && @drag_x && @drag_y
+                drag_distance_width = area_mouse_event[:x]  - @drag_x
+                drag_distance_height = area_mouse_event[:y] - @drag_y
+                @drag_shape.x += drag_distance_width
+                @drag_shape.y += drag_distance_height
+                @drag_x = area_mouse_event[:x]
+                @drag_y = area_mouse_event[:y]
+              end
+            end
+            
+            on_mouse_drop do |area_mouse_event|
+              @drag_shape = nil
+              @drag_x = nil
+              @drag_y = nil
+            end
+          }
+        end
+        
+        # this general area on_mouse_drag listener is needed to ensure that dragging a shape
+        # outside of its boundaries would still move the dragged shape
+        on_mouse_drag do |area_mouse_event|
+          if @drag_shape && @drag_x && @drag_y
+            drag_distance_width = area_mouse_event[:x]  - @drag_x
+            drag_distance_height = area_mouse_event[:y] - @drag_y
+            @drag_shape.x += drag_distance_width
+            @drag_shape.y += drag_distance_height
+            @drag_x = area_mouse_event[:x]
+            @drag_y = area_mouse_event[:y]
+          end
+        end
+        
+        on_mouse_drop do |area_mouse_event|
+          @drag_shape = nil
+          @drag_x = nil
+          @drag_y = nil
+        end
+      }
+    }
+  }
+  
+  # method-based custom shape using `shape` keyword as a composite shape containing nested shapes
+  # that are declared with relative positioning
+  def cube(location_x: 0,
+           location_y: 0,
+           rectangle_width: nil,
+           rectangle_height: nil,
+           cube_height: nil,
+           background_color: :brown,
+           line_thickness: 1,
+           &content_block)
+    default_size = 28
+    rectangle_width ||= rectangle_height || cube_height || default_size
+    rectangle_height ||= rectangle_width || cube_height || default_size
+    cube_height ||= rectangle_width || rectangle_height || default_size
+    foreground_color = [0, 0, 0, thickness: line_thickness]
+    
+    # the shape keyword (alias for composite_shape) enables building a composite shape that is treated as one shape
+    # like a cube containing polygons, a polyline, a rectangle, and a line
+    # with the fill and stroke colors getting inherited by all children that do not specify them
+    shape(location_x, location_y) { |the_shape|
+      fill background_color
+      stroke foreground_color
+    
+      bottom = polygon(0, cube_height + rectangle_height / 2.0,
+              rectangle_width / 2.0, cube_height,
+              rectangle_width, cube_height + rectangle_height / 2.0,
+              rectangle_width / 2.0, cube_height + rectangle_height) {
+        # inherits fill property from parent shape if not set
+        # inherits stroke property from parent shape if not set
+      }
+      body = rectangle(0, rectangle_height / 2.0, rectangle_width, cube_height) {
+        # inherits fill property from parent shape if not set
+        # stroke is overridden to ensure a different value from parent
+        stroke thickness: 0
+      }
+      polyline(0, rectangle_height / 2.0 + cube_height,
+               0, rectangle_height / 2.0,
+               rectangle_width, rectangle_height / 2.0,
+               rectangle_width, rectangle_height / 2.0 + cube_height) {
+        # inherits stroke property from parent shape if not set
+      }
+      top = polygon(0, rectangle_height / 2.0,
+              rectangle_width / 2.0, 0,
+              rectangle_width, rectangle_height / 2.0,
+              rectangle_width / 2.0, rectangle_height) {
+        # inherits fill property from parent shape if not set
+        # inherits stroke property from parent shape if not set
+      }
+      line(rectangle_width / 2.0, cube_height + rectangle_height,
+           rectangle_width / 2.0, rectangle_height) {
+        # inherits stroke property from parent shape if not set
+      }
+      
+      content_block&.call(the_shape)
+    }
+  end
+end
+
+BasicCompositeShape.launch
+        

data/examples/button_counter.rb

@@ -6,7 +6,7 @@ class ButtonCounter
   attr_accessor :count
 
   def initialize
-    @count = 0
+    self.count = 0
   end
 
   def launch

data/lib/glimmer/dsl/libui/control_expression.rb

@@ -33,8 +33,7 @@ module Glimmer
         end
   
         def interpret(parent, keyword, *args, &block)
-          @@inverted_keyword_aliases = Glimmer::LibUI::ControlProxy::KEYWORD_ALIASES.invert unless defined?(@@inverted_keyword_aliases)
-          keyword = @@inverted_keyword_aliases[keyword] || keyword
+          keyword = Glimmer::LibUI::ControlProxy::KEYWORD_ALIASES[keyword] || keyword
           Glimmer::LibUI::ControlProxy.create(keyword, parent, args, &block)
         end
         

data/lib/glimmer/dsl/libui/shape_expression.rb

@@ -42,6 +42,7 @@ module Glimmer
         end
   
         def interpret(parent, keyword, *args, &block)
+          keyword = Glimmer::LibUI::Shape::KEYWORD_ALIASES[keyword] || keyword
           args = [args] if args.size > 1 && Glimmer::LibUI::Shape.shape_class(keyword).parameters.size == 1
           Glimmer::LibUI::Shape.create(keyword, parent, args, &block)
         end

data/lib/glimmer/libui/control_proxy/matrix_proxy.rb

@@ -129,6 +129,7 @@ module Glimmer
         
         def build_control
           @libui = ::LibUI::FFI::DrawMatrix.malloc
+          # TODO is there a way to free the memory allocated for this? Or does it get garbage collected automatically?
           if @args.empty?
             set_identity
           else

data/lib/glimmer/libui/control_proxy/path_proxy.rb

@@ -167,9 +167,9 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [draw_fill_mode, children]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            draw_fill_mode, children = @perfect_shape_dependencies = perfect_shape_dependencies
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            draw_fill_mode, _ = @perfect_shape_dependencies = the_perfect_shape_dependencies
             shapes = children.map(&:perfect_shape)
             new_shapes = []
             shapes.each do |shape|
@@ -190,6 +190,10 @@ module Glimmer
           @perfect_shape
         end
         
+        def perfect_shape_dependencies
+          [draw_fill_mode, children.map(&:perfect_shape_dependencies)]
+        end
+        
         private
         
         def build_control

data/lib/glimmer/libui/control_proxy.rb

@@ -35,10 +35,10 @@ module Glimmer
         end
         
         def create(keyword, parent, args, &block)
-          widget_proxy_class(keyword).new(keyword, parent, args, &block).tap {|c| control_proxies << c}
+          control_proxy_class(keyword).new(keyword, parent, args, &block).tap {|c| control_proxies << c}
         end
         
-        def widget_proxy_class(keyword)
+        def control_proxy_class(keyword)
           descendant_keyword_constant_map[keyword] || ControlProxy
         end
         
@@ -96,7 +96,7 @@ module Glimmer
         private
         
         def add_aliases_to_keyword_constant_map(keyword_constant_map)
-          KEYWORD_ALIASES.each do |keyword, alias_keyword|
+          KEYWORD_ALIASES.each do |alias_keyword, keyword|
             keyword_constant_map[alias_keyword] = keyword_constant_map[keyword]
           end
           keyword_constant_map
@@ -106,8 +106,8 @@ module Glimmer
       include DataBindable
       
       KEYWORD_ALIASES = {
-        'msg_box'       => 'message_box',
-        'msg_box_error' => 'message_box_error',
+        'message_box'       => 'msg_box',
+        'message_box_error' => 'msg_box_error',
       }
       
       BOOLEAN_PROPERTIES = %w[

data/lib/glimmer/libui/perfect_shaped.rb

@@ -8,7 +8,7 @@ module Glimmer
       
       def_delegators :perfect_shape,
                      :min_x, :min_y, :max_x, :max_y, :center_point, :center_x, :center_y
-      
+                     
       # Returns if shape contains point on the inside when outline is false (default)
       # or if point is on the outline when outline is true
       # distance_tolerance is used when outline is true to enable a fuzz factor in
@@ -22,6 +22,7 @@ module Glimmer
       # or if shape includes point on the outline when stroked
       def include?(*point)
         if fill.empty?
+          # TODO check if distance_tolerance should be half the thickness in case it is checked against both sides of out and in
           contain?(*point, outline: true, distance_tolerance: ((stroke[:thickness] || 1) - 1))
         else
           contain?(*point)
@@ -60,6 +61,13 @@ module Glimmer
       def perfect_shape
         # No Op
       end
+      
+      # Returns PerfectShape object dependencies to determine if the PerfectShape
+      # object changed or not for caching purposes.
+      # Every shape/path implements this uniquely for its own PerfectShape attribute dependencies
+      def perfect_shape_dependencies
+        # No Op
+      end
     end
   end
 end

data/lib/glimmer/libui/shape/arc.rb

@@ -51,21 +51,25 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [x_center, y_center, radius, start_angle, sweep, is_negative]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            x_center, y_center, radius, start_angle, sweep, is_negative = @perfect_shape_dependencies = perfect_shape_dependencies
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_x_center, absolute_y_center, radius, start_angle, sweep, is_negative = @perfect_shape_dependencies = the_perfect_shape_dependencies
             sign = is_negative ? 1 : -1
             start = is_negative ? (360 - start_angle) : -1*start_angle
             extent = is_negative ? (360 - sweep) : -1*sweep
             @perfect_shape = PerfectShape::Arc.new(
               type: :open,
-              center_x: x_center, center_y: y_center,
+              center_x: absolute_x_center, center_y: absolute_y_center,
               radius_x: radius, radius_y: radius,
               start: start, extent: extent
             )
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x_center, absolute_y_center, radius, start_angle, sweep, is_negative]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/bezier.rb

@@ -62,13 +62,17 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [x, y, c1_x, c1_y, c2_x, c2_y, end_x, end_y]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            x, y, c1_x, c1_y, c2_x, c2_y, end_x, end_y = @perfect_shape_dependencies = perfect_shape_dependencies
-            @perfect_shape = PerfectShape::CubicBezierCurve.new(points: [x, y, c1_x, c1_y, c2_x, c2_y, end_x, end_y].compact)
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_x, absolute_y, absolute_c1_x, absolute_c1_y, absolute_c2_x, absolute_c2_y, absolute_end_x, absolute_end_y = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            @perfect_shape = PerfectShape::CubicBezierCurve.new(points: [absolute_x, absolute_y, absolute_c1_x, absolute_c1_y, absolute_c2_x, absolute_c2_y, absolute_end_x, absolute_end_y].compact)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x, absolute_y, absolute_c1_x, absolute_c1_y, absolute_c2_x, absolute_c2_y, absolute_end_x, absolute_end_y]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/circle.rb

@@ -51,13 +51,17 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [x_center, y_center, radius]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            x_center, y_center, radius = @perfect_shape_dependencies = perfect_shape_dependencies
-            @perfect_shape = PerfectShape::Circle.new(center_x: x_center, center_y: y_center, radius: radius)
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_x_center, absolute_y_center, radius = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            @perfect_shape = PerfectShape::Circle.new(center_x: absolute_x_center, center_y: absolute_y_center, radius: radius)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x_center, absolute_y_center, radius]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/composite_shape.rb

@@ -0,0 +1,101 @@
+# Copyright (c) 2021-2022 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.
+
+require 'glimmer/libui/shape'
+
+module Glimmer
+  module LibUI
+    class Shape
+      class CompositeShape < Glimmer::LibUI::Shape
+        # TODO support nested shape properties that apply to all children
+        parameters :x, :y
+        parameter_defaults 0, 0
+      
+        def draw(area_draw_params)
+          children.each do |child|
+            child_fill = child.fill
+            child_stroke = child.stroke
+            child_transform = child.transform
+            child.fill = fill if Glimmer::LibUI.blank_color?(child.fill)
+            child.stroke = stroke if Glimmer::LibUI.blank_color?(child.stroke)
+            child.transform = transform if child.transform.nil?
+            child.move_by(x, y)
+            begin
+              child.draw(area_draw_params)
+            rescue Exception => e
+              raise e
+            ensure
+              # restore original child attributes
+              child.move_by(-x, -y)
+              child.transform = child_transform
+              child.stroke = Glimmer::LibUI.blank_color?(child_stroke) ? Glimmer::LibUI.blank_color : child_stroke
+              child.fill = Glimmer::LibUI.blank_color?(child_fill) ? Glimmer::LibUI.blank_color : child_fill
+            end
+          end
+          super
+        end
+        
+        def transform(matrix = nil)
+          if matrix.nil?
+            @matrix
+          else
+            @matrix = matrix
+          end
+        end
+        
+        def move_by(x_delta, y_delta)
+          self.x += x_delta
+          self.y += y_delta
+        end
+        
+        def contain?(*point, outline: false, distance_tolerance: 0)
+          children.any? { |child| child.contain?(*point, outline: outline, distance_tolerance: distance_tolerance) }
+        end
+        
+        def include?(*point)
+          children.any? { |child| child.include?(*point) }
+        end
+        
+        def relative_x(x)
+          self.x + x
+        end
+        
+        def relative_y(y)
+          self.y + y
+        end
+        
+        def relative_point(*point)
+          [relative_x(point.first), relative_y(point.last)]
+        end
+        
+        def perfect_shape
+          perfect_shape_dependencies = [x, y, children.map(&:perfect_shape_dependencies)]
+          if perfect_shape_dependencies != @perfect_shape_dependencies
+            x, y, _ = @perfect_shape_dependencies = perfect_shape_dependencies
+            shapes = children.map(&:perfect_shape)
+            @perfect_shape = PerfectShape::CompositeShape.new(shapes: shapes)
+          end
+          @perfect_shape
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/libui/shape/figure.rb

@@ -58,10 +58,10 @@ module Glimmer
         end
                 
         def perfect_shape
-          perfect_shape_dependencies = [x, y, closed, parent.draw_fill_mode, children]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            x, y, closed, draw_fill_mode, children = @perfect_shape_dependencies = perfect_shape_dependencies
-            path_shapes = [[x, y]]
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_x, absolute_y, closed, draw_fill_mode, children = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            path_shapes = [[absolute_x, absolute_y]]
             path_shapes += children.map(&:perfect_shape)
             winding_rule = draw_fill_mode == :winding ? :wind_non_zero : :wind_even_odd
             @perfect_shape = PerfectShape::Path.new(
@@ -73,6 +73,10 @@ module Glimmer
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x, absolute_y, closed, parent.draw_fill_mode, children]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/line.rb

@@ -61,13 +61,17 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [x, y, end_x, end_y]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            x, y, end_x, end_y = @perfect_shape_dependencies = perfect_shape_dependencies
-            @perfect_shape = PerfectShape::Line.new(points: [x, y, end_x, end_y].compact)
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_x, absolute_y, absolute_end_x, absolute_end_y = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            @perfect_shape = PerfectShape::Line.new(points: [absolute_x, absolute_y, absolute_end_x, absolute_end_y].compact)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x, absolute_y, absolute_end_x, absolute_end_y]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/polybezier.rb

@@ -45,16 +45,20 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = PerfectShape::MultiPoint.normalize_point_array(point_array)
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            point_array = @perfect_shape_dependencies = perfect_shape_dependencies
-            path_shapes = [point_array.first]
-            bezier_shape_points = point_array.drop(1).each.with_index.to_a.group_by {|pair| pair.last/3}.values.map {|arr| arr.map(&:first)}
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_point_array = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            path_shapes = [absolute_point_array.first]
+            bezier_shape_points = absolute_point_array.drop(1).each.with_index.to_a.group_by {|pair| pair.last/3}.values.map {|arr| arr.map(&:first)}
             path_shapes += bezier_shape_points.map { |points| PerfectShape::CubicBezierCurve.new(points: points) }
             @perfect_shape = PerfectShape::Path.new(closed: false, shapes: path_shapes)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          absolute_point_array
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/polygon.rb

@@ -46,15 +46,19 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = PerfectShape::MultiPoint.normalize_point_array(point_array)
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            point_array = @perfect_shape_dependencies = perfect_shape_dependencies
-            path_shapes = [point_array.first]
-            path_shapes += point_array.drop(1).map { |point| PerfectShape::Line.new(points: [point]) }
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_point_array = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            path_shapes = [absolute_point_array.first]
+            path_shapes += absolute_point_array.drop(1).map { |point| PerfectShape::Line.new(points: [point]) }
             @perfect_shape = PerfectShape::Path.new(closed: true, shapes: path_shapes)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          absolute_point_array
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/polyline.rb

@@ -45,15 +45,19 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = PerfectShape::MultiPoint.normalize_point_array(point_array)
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            point_array = @perfect_shape_dependencies = perfect_shape_dependencies
-            path_shapes = [point_array.first]
-            path_shapes += point_array.drop(1).map { |point| PerfectShape::Line.new(points: [point]) }
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_point_array = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            path_shapes = [absolute_point_array.first]
+            path_shapes += absolute_point_array.drop(1).map { |point| PerfectShape::Line.new(points: [point]) }
             @perfect_shape = PerfectShape::Path.new(closed: false, shapes: path_shapes)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          absolute_point_array
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/rectangle.rb

@@ -39,13 +39,17 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [x, y, width, height]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            x, y, width, height = @perfect_shape_dependencies = perfect_shape_dependencies
-            @perfect_shape = PerfectShape::Rectangle.new(x: x, y: y, width: width, height: height)
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            absolute_x, absolute_y, width, height = @perfect_shape_dependencies = the_perfect_shape_dependencies
+            @perfect_shape = PerfectShape::Rectangle.new(x: absolute_x, y: absolute_y, width: width, height: height)
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x, absolute_y, width, height]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape/square.rb

@@ -41,13 +41,17 @@ module Glimmer
         end
         
         def perfect_shape
-          perfect_shape_dependencies = [x, y, length]
-          if perfect_shape_dependencies != @perfect_shape_dependencies
-            @perfect_shape_dependencies = perfect_shape_dependencies
+          the_perfect_shape_dependencies = perfect_shape_dependencies
+          if the_perfect_shape_dependencies != @perfect_shape_dependencies
+            @perfect_shape_dependencies = the_perfect_shape_dependencies
             @perfect_shape = PerfectShape::Square.new(x: @perfect_shape_dependencies[0], y: @perfect_shape_dependencies[1], length: @perfect_shape_dependencies[2])
           end
           @perfect_shape
         end
+        
+        def perfect_shape_dependencies
+          [absolute_x, absolute_y, length]
+        end
       end
     end
   end

data/lib/glimmer/libui/shape.rb

@@ -31,16 +31,19 @@ module Glimmer
     class Shape
       class << self
         def exists?(keyword)
+          keyword = KEYWORD_ALIASES[keyword] || keyword
           Shape.constants.include?(constant_symbol(keyword)) and
             shape_class(keyword).respond_to?(:ancestors) and
             shape_class(keyword).ancestors.include?(Shape)
         end
         
         def create(keyword, parent, args, &block)
+          keyword = KEYWORD_ALIASES[keyword] || keyword
           shape_class(keyword).new(keyword, parent, args, &block)
         end
         
         def shape_class(keyword)
+          keyword = KEYWORD_ALIASES[keyword] || keyword
           Shape.const_get(constant_symbol(keyword))
         end
         
@@ -61,6 +64,7 @@ module Glimmer
         end
         
         def constant_symbol(keyword)
+          keyword = KEYWORD_ALIASES[keyword] || keyword
           "#{keyword.camelcase(:upper)}".to_sym
         end
       end
@@ -69,10 +73,15 @@ module Glimmer
       include PerfectShaped
       include DataBindable
       
+      KEYWORD_ALIASES = {
+        'shape' => 'composite_shape',
+      }
+      
       attr_reader :parent, :args, :keyword, :block, :content_added
       alias content_added? content_added
       
       def initialize(keyword, parent, args, &block)
+        keyword = KEYWORD_ALIASES[keyword] || keyword
         @keyword = keyword
         @parent = parent
         @args = args
@@ -129,6 +138,10 @@ module Glimmer
       def path_proxy
         find_parent_in_ancestors { |parent| parent.nil? || parent.is_a?(ControlProxy::PathProxy) }
       end
+      
+      def composite_shape
+        find_parent_in_ancestors { |parent| parent.nil? || parent.is_a?(CompositeShape) }
+      end
     
       def fill(*args)
         path_proxy.fill(*args)
@@ -148,6 +161,125 @@ module Glimmer
       alias transform= transform
       alias set_transform transform
       
+      def absolute_x
+        if composite_shape
+          composite_shape.relative_x(x)
+        else
+          x
+        end
+      end
+      
+      def absolute_y
+        if composite_shape
+          composite_shape.relative_y(y)
+        else
+          y
+        end
+      end
+      
+      def absolute_point_array
+        # TODO Consider moving this method into a module mixed into all shapes having point_array
+        return unless respond_to?(:point_array)
+        
+        point_array = self.point_array || []
+        point_array = PerfectShape::MultiPoint.normalize_point_array(point_array)
+        point_array.map do |point|
+          if composite_shape
+            composite_shape.relative_point(*point)
+          else
+            point
+          end
+        end
+      end
+      
+      def absolute_x_center
+        # TODO Consider moving this method into a module mixed into all shapes having x_center
+        return unless respond_to?(:x_center)
+        
+        if composite_shape
+          composite_shape.relative_x(x_center)
+        else
+          x_center
+        end
+      end
+      
+      def absolute_y_center
+        # TODO Consider moving this method into a module mixed into all shapes having y_center
+        return unless respond_to?(:y_center)
+        
+        if composite_shape
+          composite_shape.relative_y(y_center)
+        else
+          y_center
+        end
+      end
+      
+      def absolute_c1_x
+        # TODO Consider moving this method into a module mixed into all shapes having c1_x
+        return unless respond_to?(:c1_x)
+        
+        if composite_shape
+          composite_shape.relative_x(c1_x)
+        else
+          c1_x
+        end
+      end
+      
+      def absolute_c1_y
+        # TODO Consider moving this method into a module mixed into all shapes having c1_y
+        return unless respond_to?(:c1_y)
+        
+        if composite_shape
+          composite_shape.relative_x(c1_y)
+        else
+          c1_y
+        end
+      end
+      
+      def absolute_c2_x
+        # TODO Consider moving this method into a module mixed into all shapes having c2_x
+        return unless respond_to?(:c2_x)
+        
+        if composite_shape
+          composite_shape.relative_x(c2_x)
+        else
+          c2_x
+        end
+      end
+      
+      def absolute_c2_y
+        # TODO Consider moving this method into a module mixed into all shapes having c2_y
+        return unless respond_to?(:c2_y)
+        
+        if composite_shape
+          composite_shape.relative_x(c2_y)
+        else
+          c2_y
+        end
+      end
+      
+      def absolute_end_x
+        # TODO Consider moving this method into a module mixed into all shapes having end_x
+        return unless respond_to?(:end_x)
+        
+        if composite_shape
+          composite_shape.relative_x(end_x)
+        else
+          end_x
+        end
+      end
+      
+      def absolute_end_y
+        # TODO Consider moving this method into a module mixed into all shapes having end_y
+        return unless respond_to?(:end_y)
+        
+        if composite_shape
+          composite_shape.relative_x(end_y)
+        else
+          end_y
+        end
+      end
+      
       def can_handle_listener?(listener_name)
         area_proxy.can_handle_listener?(listener_name)
       end
@@ -181,7 +313,16 @@ module Glimmer
           super
         end
       end
-    
+      
+      # indicates if nested directly under area or on_draw event (having an implicit path not an explicit path parent)
+      def implicit_path?
+        @implicit_path ||= !!(
+          @parent.is_a?(Glimmer::LibUI::ControlProxy::AreaProxy) ||
+          @parent.is_a?(Glimmer::LibUI::Shape::CompositeShape) ||
+          (@parent.nil? && Glimmer::LibUI::ControlProxy::AreaProxy.current_area_draw_params)
+        )
+      end
+      
       private
       
       def build_control
@@ -189,11 +330,6 @@ module Glimmer
         @parent = Glimmer::LibUI::ControlProxy::PathProxy.new('path', @parent, [], &block)
       end
       
-      # indicates if nested directly under area or on_draw event (having an implicit path not an explicit path parent)
-      def implicit_path?
-        @implicit_path ||= !!(@parent.is_a?(Glimmer::LibUI::ControlProxy::AreaProxy) || (@parent.nil? && Glimmer::LibUI::ControlProxy::AreaProxy.current_area_draw_params))
-      end
-      
       def dynamic?
         ((@parent.nil? || (@parent.is_a?(ControlProxy::PathProxy) && @parent.parent_proxy.nil?)) && Glimmer::LibUI::ControlProxy::AreaProxy.current_area_draw_params)
       end

data/lib/glimmer/libui.rb

@@ -104,6 +104,21 @@ module Glimmer
         result.merge!(options) if options
         result
       end
+      
+      # returns whether the value represents no color (blank) or a present color
+      # when a path is first built, it has a blank color
+      def blank_color?(value)
+        value.nil? ||
+          (value.respond_to?(:empty?) && value.empty?) ||
+          (value.is_a?(Array) && value.compact.empty?) ||
+          (value.is_a?(Hash) && value.values.compact.empty?)
+      end
+      
+      # returns a representation of a blank color
+      # when a path is first built, it has a blank color
+      def blank_color
+        [{}]
+      end
     
       def hex_to_rgb(value)
         if value.is_a?(String)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer-dsl-libui
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.8.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-15 00:00:00.000000000 Z
+date: 2023-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glimmer
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: 1.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: 1.0.8
 - !ruby/object:Gem::Dependency
   name: super_module
   requirement: !ruby/object:Gem::Requirement
@@ -301,7 +301,7 @@ description: Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development G
   syntax that visually maps to GUI control hierarchy, convention over configuration
   via smart defaults, automation of low-level details, requiring the least amount
   of syntax possible to build GUI, bidirectional data-binding, and custom keyword
-  support.
+  support. If you liked Shoes, You'll love Glimmer!
 email: andy.am@gmail.com
 executables:
 - girb
@@ -331,6 +331,7 @@ files:
 - examples/basic_button.rb
 - examples/basic_child_window.rb
 - examples/basic_code_area.rb
+- examples/basic_composite_shape.rb
 - examples/basic_draw_text.rb
 - examples/basic_draw_text2.rb
 - examples/basic_entry.rb
@@ -533,6 +534,7 @@ files:
 - lib/glimmer/libui/shape/arc.rb
 - lib/glimmer/libui/shape/bezier.rb
 - lib/glimmer/libui/shape/circle.rb
+- lib/glimmer/libui/shape/composite_shape.rb
 - lib/glimmer/libui/shape/figure.rb
 - lib/glimmer/libui/shape/line.rb
 - lib/glimmer/libui/shape/polybezier.rb
@@ -567,7 +569,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.1
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Glimmer DSL for LibUI