glimmer-dsl-swt 4.18.6.2 → 4.18.7.3

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

@@ -34,13 +34,9 @@ module Glimmer
       class Shape
         class Image < Shape
           def parameter_names
-            if @args.to_a.size > 3
-              image_part_parameter_names
-            else
-              image_whole_parameter_names
-            end
+            @parameter_names || image_whole_parameter_names
           end
-          
+        
           def possible_parameter_names
             (image_part_parameter_names + image_whole_parameter_names).uniq
           end
@@ -53,13 +49,15 @@ module Glimmer
             [:image, :x, :y]
           end
           
-          def parameter_index(attribute_name)
+          def set_parameter_attribute(attribute_name, *args)
+            return super if @parameter_names.to_a.map(&:to_s).include?(attribute_name.to_s)
             ####TODO refactor and improve this method through meta-programming (and share across other shapes)
             if image_part_parameter_names.map(&:to_s).include?(attribute_name.to_s)
-              image_part_parameter_names.map(&:to_s).index(attribute_name.to_s)
+              @parameter_names = image_part_parameter_names
             elsif image_whole_parameter_names.map(&:to_s).include?(attribute_name.to_s)
-              image_whole_parameter_names.map(&:to_s).index(attribute_name.to_s)
+              @parameter_names = image_whole_parameter_names
             end
+            super
           end
           
           def x

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

@@ -52,8 +52,10 @@ module Glimmer
           
           def add_shape(shape)
             if shape.is_a?(PathSegment)
-              @path_segments << shape
-              @uncalculated_path_segments << shape
+              Glimmer::SWT::DisplayProxy.instance.auto_exec do
+                @path_segments << shape
+                @uncalculated_path_segments << shape
+              end
             else
               super
             end
@@ -80,45 +82,52 @@ module Glimmer
           end
           
           def post_dispose_content(path_segment)
-            @path_segments.delete(path_segment)
-            @uncalculated_path_segments = @path_segments.dup
-            @swt_path&.dispose
-            @swt_path = nil
-            @args = []
-            calculated_args_changed!(children: false)
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              @path_segments.delete(path_segment)
+              @uncalculated_path_segments = @path_segments.dup
+              @swt_path&.dispose
+              @swt_path = nil
+              @args = []
+              calculated_args_changed!(children: false)
+            end
           end
           
           def clear
-            @path_segments.each { |path_segments| path_segments.class == Path && path_segments.dispose }
-            @path_segments.clear
-            @uncalculated_path_segments = @path_segments.dup
-            @swt_path&.dispose
-            @swt_path = nil
-            @args = []
-            calculated_args_changed!(children: false)
-          end
-          
-          def dispose
-            clear if self.class == Path
-            super if parent.is_a?(Drawable)
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              @path_segments.each { |path_segments| path_segments.class == Path && path_segments.dispose }
+              @path_segments.clear
+              @uncalculated_path_segments = @path_segments.dup
+              @swt_path&.dispose
+              @swt_path = nil
+              @args = []
+              calculated_args_changed!(children: false)
+              drawable.redraw unless drawable.is_a?(ImageProxy)
+            end
           end
           
-          def calculated_args_changed!(children: true)
-            super
+          def dispose(redraw: true)
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              clear if self.class == Path
+              super(redraw: redraw) if (parent.is_a?(Shape) && (!parent.is_a?(PathSegment) || !parent.part_of_path?)) || parent.is_a?(Drawable)
+            end
           end
           
-          def calculated_args
+          def calculate_args!
             new_swt_path = @swt_path.nil? || !@calculated_paint_args || !@calculated_path_args
             if new_swt_path
-              @swt_path&.dispose
-              @swt_path = org.eclipse.swt.graphics.Path.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
-              @uncalculated_path_segments = @path_segments.dup
+              Glimmer::SWT::DisplayProxy.instance.auto_exec do
+                @swt_path&.dispose
+                @swt_path = org.eclipse.swt.graphics.Path.new(Glimmer::SWT::DisplayProxy.instance.swt_display)
+                @uncalculated_path_segments = @path_segments.dup
+              end
             end
             # TODO recreate @swt_path only if one of the children get disposed (must notify parent on dispose)
             @args = [@swt_path]
-            @uncalculated_path_segments.each do |path_segment|
-              path_segment.add_to_swt_path(@swt_path)
-              @uncalculated_path_segments.delete(path_segment)
+            @uncalculated_path_segments.dup.each do |path_segment|
+              Glimmer::SWT::DisplayProxy.instance.auto_exec do
+                path_segment.add_to_swt_path(@swt_path)
+                @uncalculated_path_segments.delete(path_segment)
+              end
             end
             @calculated_path_args = true
             if new_swt_path

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

@@ -24,8 +24,6 @@ require 'glimmer/swt/custom/shape'
 module Glimmer
   module SWT
     module Custom
-      # Represents a path to be drawn on a control/widget/canvas/display
-      # That is because Shape is drawn on a parent as graphics and doesn't have an SWT widget for itself
       class Shape
         # Represents path segments like point, line, quad, and cubic curves
         # Shapes could mix in
@@ -77,10 +75,17 @@ module Glimmer
             true
           end
           
-          def dispose
-            parent.post_dispose_content(self) if parent.is_a?(Path)
-            super if !part_of_path?
-            drawable.redraw unless drawable.is_a?(ImageProxy)
+          def dispose(redraw: true)
+            Glimmer::SWT::DisplayProxy.instance.auto_exec do
+              # including classes could override to dispose of resources first
+              # afterwards, parent removes from its path segments with post_dispose_content
+              parent.post_dispose_content(self) if parent.is_a?(Path)
+              if part_of_path?
+                drawable.redraw if redraw && !drawable.is_a?(ImageProxy)
+              else
+                super(redraw: redraw)
+              end
+            end
           end
           
           def first_path_segment?
@@ -92,22 +97,19 @@ module Glimmer
           end
           
           def add_to_swt_path(swt_path)
-            if @swt_path != swt_path
-              @swt_path = swt_path
-              the_path_segment_args = path_segment_args.dup
-              if !is_a?(Point) && self.class != Path
-                if !previous_point_connected?
-                  if the_path_segment_args.count == default_path_segment_arg_count
-                    point = the_path_segment_args.shift, the_path_segment_args.shift
-                    @swt_path.moveTo(*point)
-                  elsif first_path_segment?
-                    point = the_path_segment_args[0..1]
-                    @swt_path.moveTo(*point)
-                  end
+            the_path_segment_args = path_segment_args.dup
+            if !is_a?(Point) && self.class != Path
+              if !previous_point_connected?
+                if the_path_segment_args.count == default_path_segment_arg_count
+                  point = the_path_segment_args.shift, the_path_segment_args.shift
+                  swt_path.moveTo(*point)
+                elsif first_path_segment?
+                  point = the_path_segment_args[0..1]
+                  swt_path.moveTo(*point)
                 end
               end
-              @swt_path.send(path_segment_method_name, *the_path_segment_args)
             end
+            swt_path.send(path_segment_method_name, *the_path_segment_args)
           end
           
           def add_to_geometry(geometry)

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

@@ -119,16 +119,28 @@ module Glimmer
           
           # Logical x coordinate relative to parent
           def x
-            x_value = bounds.x
-            x_value -= parent.absolute_x if parent.is_a?(Shape)
-            x_value
+            x_dependencies = [bounds.x, parent.is_a?(Shape) && parent.absolute_x]
+            if x_dependencies != @x_dependencies
+              # avoid recalculating values
+              bounds_x, parent_absolute_x = @x_dependencies = x_dependencies
+              x_value = bounds_x
+              x_value -= parent_absolute_x if parent.is_a?(Shape)
+              @x = x_value
+            end
+            @x
           end
           
           # Logical y coordinate relative to parent
           def y
-            y_value = bounds.y
-            y_value -= parent.absolute_y if parent.is_a?(Shape)
-            y_value
+            y_dependencies = [bounds.y, parent.is_a?(Shape) && parent.absolute_y]
+            if y_dependencies != @y_dependencies
+              # avoid recalculating values
+              bounds_y, parent_absolute_y = @y_dependencies = y_dependencies
+              y_value = bounds_y
+              y_value -= parent_absolute_y if parent.is_a?(Shape)
+              @y = y_value
+            end
+            @y
           end
           
           def width
@@ -144,8 +156,12 @@ module Glimmer
           end
 
           def include?(x, y)
-            comparison_lines = absolute_point_xy_array.zip(absolute_point_xy_array.rotate(1))
-            comparison_lines.any? {|line| Line.include?(line.first.first, line.first.last, line.last.first, line.last.last, x, y)}
+            if filled?
+              contain?(x, y)
+            else
+              comparison_lines = absolute_point_xy_array.zip(absolute_point_xy_array.rotate(1))
+              comparison_lines.any? {|line| Line.include?(line.first.first, line.first.last, line.last.first, line.last.last, x, y)}
+            end
           end
                     
           def move_by(x_delta, y_delta)

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

@@ -42,19 +42,23 @@ module Glimmer
           end
           
           def point_count
+            point_array = args.size > 1 ? args : self.point_array
             point_array.count / 2
           end
           
           def [](index)
+            point_array = args.size > 1 ? args : self.point_array
             index = 0 if index == point_count
             org.eclipse.swt.graphics.Point.new(point_array[index * 2], point_array[index * 2 + 1])
           end
           
           def x_array
+            point_array = args.size > 1 ? args : self.point_array
             point_array.each_with_index.select {|pair| pair.last.even?}.map(&:first)
           end
           
           def y_array
+            point_array = args.size > 1 ? args : self.point_array
             point_array.each_with_index.select {|pair| pair.last.odd?}.map(&:first)
           end
           
@@ -63,6 +67,7 @@ module Glimmer
           end
           
           def absolute_point_array
+            point_array = args.size > 1 ? args : self.point_array
             if parent.is_a?(Shape)
               point_array.each_with_index.map do |coordinate, i|
                 if i.even?

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

@@ -23,7 +23,6 @@ require 'glimmer/swt/custom/shape'
 require 'glimmer/swt/swt_proxy'
 require 'glimmer/swt/display_proxy'
 require 'glimmer/swt/color_proxy'
-require 'glimmer/swt/font_proxy'
 require 'glimmer/swt/transform_proxy'
 
 module Glimmer
@@ -34,16 +33,7 @@ module Glimmer
       class Shape
         class Rectangle < Shape
           def parameter_names
-            # TODO consider optimizing just like text where it is set upon updating attribute and here you just return a variable
-            if @args.to_a.size >= 6
-              rectangle_round_parameter_names
-            elsif @args.to_a.size == 5
-              rectangle_gradient_parameter_names
-            elsif @args.to_a.size == 1
-              rectangle_rectangle_parameter_names
-            else
-              rectangle_parameter_names
-            end
+            @parameter_names || rectangle_parameter_names
           end
           
           def possible_parameter_names
@@ -68,17 +58,18 @@ module Glimmer
             [:rectangle]
           end
           
-          def parameter_index(attribute_name)
-            ####TODO refactor and improve this method through meta-programming (and share across other shapes)
-            if rectangle_round_parameter_names.map(&:to_s).include?(attribute_name.to_s)
-              rectangle_round_parameter_names.map(&:to_s).index(attribute_name.to_s)
+          def set_parameter_attribute(attribute_name, *args)
+            return super if @parameter_names.to_a.map(&:to_s).include?(attribute_name.to_s)
+            if rectangle_parameter_names.map(&:to_s).include?(attribute_name.to_s)
+              @parameter_names = rectangle_parameter_names
+            elsif rectangle_round_parameter_names.map(&:to_s).include?(attribute_name.to_s)
+              @parameter_names = rectangle_round_parameter_names
             elsif rectangle_gradient_parameter_names.map(&:to_s).include?(attribute_name.to_s)
-              rectangle_gradient_parameter_names.map(&:to_s).index(attribute_name.to_s)
-            elsif rectangle_parameter_names.map(&:to_s).include?(attribute_name.to_s)
-              rectangle_parameter_names.map(&:to_s).index(attribute_name.to_s)
+              @parameter_names = rectangle_gradient_parameter_names
             elsif rectangle_rectangle_parameter_names.map(&:to_s).include?(attribute_name.to_s)
-              rectangle_rectangle_parameter_names.map(&:to_s).index(attribute_name.to_s)
+              @parameter_names = rectangle_rectangle_parameter_names
             end
+            super
           end
           
           def point_xy_array

data/lib/glimmer/swt/display_proxy.rb

@@ -84,7 +84,7 @@ module Glimmer
       end
       
       def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::DisplayExpression.new, &block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::DisplayExpression.new, 'display', &block)
       end
       
       # asynchronously executes the block (required from threads other than first GUI thread)

data/lib/glimmer/swt/message_box_proxy.rb

@@ -51,7 +51,7 @@ module Glimmer
       end
       
       def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::MessageBoxExpression.new, &block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::MessageBoxExpression.new, 'message_box', &block)
       end
       
       # TODO refactor the following methods to put in a JavaBean mixin or somethin (perhaps contribute to OSS project too)

data/lib/glimmer/swt/shell_proxy.rb

@@ -186,7 +186,7 @@ module Glimmer
       end
 
       def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShellExpression.new, &block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShellExpression.new, 'shell', &block)
       end
 
       # (happens as part of `#open`)

data/lib/glimmer/swt/tab_folder_proxy.rb

@@ -0,0 +1,52 @@
+# 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.
+
+require 'glimmer/swt/widget_proxy'
+
+module Glimmer
+  module SWT
+    # Proxy for org.eclipse.swt.widgets.TabProxy
+    #
+    # Follows the Proxy Design Pattern
+    class TabFolderProxy < WidgetProxy
+      def initialize(underscored_widget_name, parent, args, swt_widget: nil)
+        @initialize_tabs_on_select = args.delete(:initialize_tabs_on_select)
+        super
+      end
+      
+      def post_add_content
+        shown = false
+        unless @initialize_tabs_on_select
+          @show_listener = parent_proxy.on_swt_show do
+            unless shown
+              shown = true
+              self.items.to_a.each do |item|
+                self.selection = item
+              end
+              self.selection = self.items.first unless self.items.first.nil?
+              @show_listener.deregister
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/swt/transform_proxy.rb

@@ -73,7 +73,7 @@ module Glimmer
       end
       
       def content(&block)
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::TransformExpression.new, &block)
+        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::TransformExpression.new, 'transform', &block)
       end
       
       def proxy_source_object

data/lib/glimmer/swt/widget_proxy.rb

@@ -712,7 +712,7 @@ module Glimmer
 
       def content(&block)
         auto_exec do
-          Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::WidgetExpression.new, &block)
+          Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::WidgetExpression.new, @keyword, &block)
         end
       end
 

data/lib/glimmer/ui/custom_shape.rb

@@ -0,0 +1,281 @@
+# 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.
+
+require 'glimmer'
+require 'glimmer/ui'
+require 'glimmer/error'
+require 'glimmer/swt/swt_proxy'
+require 'glimmer/swt/display_proxy'
+require 'glimmer/util/proc_tracker'
+require 'glimmer/data_binding/observer'
+require 'glimmer/data_binding/observable_model'
+
+module Glimmer
+  module UI
+    module CustomShape
+      include SuperModule
+      include DataBinding::ObservableModel
+
+      super_module_included do |klass|
+        klass.include(Glimmer)
+        Glimmer::UI::CustomShape.add_custom_shape_namespaces_for(klass)
+      end
+
+      class << self
+        def for(underscored_custom_shape_name)
+          unless flyweight_custom_shape_classes.keys.include?(underscored_custom_shape_name)
+            begin
+              extracted_namespaces = underscored_custom_shape_name.
+                to_s.
+                split(/__/).map do |namespace|
+                  namespace.camelcase(:upper)
+                end
+              custom_shape_namespaces.each do |base|
+                extracted_namespaces.reduce(base) do |result, namespace|
+                  if !result.constants.include?(namespace)
+                    namespace = result.constants.detect {|c| c.to_s.upcase == namespace.to_s.upcase } || namespace
+                  end
+                  begin
+                    flyweight_custom_shape_classes[underscored_custom_shape_name] = constant = result.const_get(namespace)
+                    return constant if constant.ancestors.include?(Glimmer::UI::CustomShape)
+                    flyweight_custom_shape_classes[underscored_custom_shape_name] = constant
+                  rescue => e
+                    # Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+                    flyweight_custom_shape_classes[underscored_custom_shape_name] = result
+                  end
+                end
+              end
+              raise "#{underscored_custom_shape_name} has no custom shape class!"
+            rescue => e
+              Glimmer::Config.logger.debug {e.message}
+              Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+              flyweight_custom_shape_classes[underscored_custom_shape_name] = nil
+            end
+          end
+          flyweight_custom_shape_classes[underscored_custom_shape_name]
+        end
+        
+        # Flyweight Design Pattern memoization cache. Can be cleared if memory is needed.
+        def flyweight_custom_shape_classes
+          @flyweight_custom_shape_classes ||= {}
+        end
+        
+        # Returns keyword to use for this custom shape
+        def keyword
+          self.name.underscore.gsub('::', '__')
+        end
+        
+        # Returns shortcut keyword to use for this custom shape (keyword minus namespace)
+        def shortcut_keyword
+          self.name.underscore.gsub('::', '__').split('__').last
+        end
+        
+        def add_custom_shape_namespaces_for(klass)
+          Glimmer::UI::CustomShape.namespaces_for_class(klass).drop(1).each do |namespace|
+            Glimmer::UI::CustomShape.custom_shape_namespaces << namespace
+          end
+        end
+
+        def namespaces_for_class(m)
+          return [m] if m.name.nil?
+          namespace_constants = m.name.split(/::/).map(&:to_sym)
+          namespace_constants.reduce([Object]) do |output, namespace_constant|
+            output += [output.last.const_get(namespace_constant)]
+          end[1..-1].uniq.reverse
+        end
+
+        def custom_shape_namespaces
+          @custom_shape_namespaces ||= reset_custom_shape_namespaces
+        end
+
+        def reset_custom_shape_namespaces
+          @custom_shape_namespaces = Set[Object, Glimmer::UI]
+        end
+
+        # Allows defining convenience option accessors for an array of option names
+        # Example: `options :color1, :color2` defines `#color1` and `#color2`
+        # where they return the instance values `options[:color1]` and `options[:color2]`
+        # respectively.
+        # Can be called multiple times to set more options additively.
+        # When passed no arguments, it returns list of all option names captured so far
+        def options(*new_options)
+          new_options = new_options.compact.map(&:to_s).map(&:to_sym)
+          if new_options.empty?
+            @options ||= {} # maps options to defaults
+          else
+            new_options = new_options.reduce({}) {|new_options_hash, new_option| new_options_hash.merge(new_option => nil)}
+            @options = options.merge(new_options)
+            def_option_attr_accessors(new_options)
+          end
+        end
+
+        def option(new_option, default: nil)
+          new_option = new_option.to_s.to_sym
+          new_options = {new_option => default}
+          @options = options.merge(new_options)
+          def_option_attr_accessors(new_options)
+        end
+
+        def def_option_attr_accessors(new_options)
+          new_options.each do |option, default|
+            class_eval <<-end_eval, __FILE__, __LINE__
+              def #{option}
+                options[:#{option}]
+              end
+              def #{option}=(option_value)
+                self.options[:#{option}] = option_value
+              end
+            end_eval
+          end
+        end
+
+        def before_body(&block)
+          @before_body_block = block
+        end
+
+        def body(&block)
+          @body_block = block
+        end
+
+        def after_body(&block)
+          @after_body_block = block
+        end
+
+        # Current custom shapes being rendered. Useful to yoke all observers evaluated during rendering of their custom shapes for automatical disposal on_shape_disposed
+        def current_custom_shapes
+          @current_custom_shapes ||= []
+        end
+      end
+
+      attr_reader :body_root, :args, :parent, :parent_proxy, :options
+
+      def initialize(parent, *args, options, &content)
+        Glimmer::UI::CustomShape.current_custom_shapes << self
+        @parent_proxy = @parent = parent
+        @parent_proxy = @parent&.get_data('proxy') if @parent.respond_to?(:get_data) && @parent.get_data('proxy')
+        @args = args
+        options ||= {}
+        @options = self.class.options.merge(options)
+        @content = Util::ProcTracker.new(content) if content
+        execute_hook('before_body')
+        body_block = self.class.instance_variable_get("@body_block")
+        raise Glimmer::Error, 'Invalid custom shape for having no body! Please define body block!' if body_block.nil?
+        @body_root = instance_exec(&body_block)
+        raise Glimmer::Error, 'Invalid custom shape for having an empty body! Please fill body block!' if @body_root.nil?
+        auto_exec do
+          @body_root.set_data('custom_shape', self)
+        end
+        execute_hook('after_body')
+      end
+      
+      # Subclasses may override to perform post initialization work on an added child
+      def post_initialize_child(child)
+        # No Op by default
+      end
+
+      def observer_registrations
+        @observer_registrations ||= []
+      end
+
+      def has_attribute?(attribute_name, *args)
+        has_instance_method?(attribute_setter(attribute_name)) ||
+          @body_root.has_attribute?(attribute_name, *args)
+      end
+
+      def set_attribute(attribute_name, *args)
+        if has_instance_method?(attribute_setter(attribute_name))
+          send(attribute_setter(attribute_name), *args)
+        else
+          @body_root.set_attribute(attribute_name, *args)
+        end
+      end
+
+      # This method ensures it has an instance method not coming from Glimmer DSL
+      def has_instance_method?(method_name)
+        respond_to?(method_name) and
+          !body_root&.respond_to?(method_name) and
+          (method(method_name) rescue nil) and
+          !method(method_name)&.source_location&.first&.include?('glimmer/dsl/engine.rb') and
+          !method(method_name)&.source_location&.first&.include?('glimmer/swt/custom/shape.rb')
+      end
+
+      def get_attribute(attribute_name)
+        if has_instance_method?(attribute_name)
+          send(attribute_name)
+        else
+          @body_root.get_attribute(attribute_name)
+        end
+      end
+
+      def attribute_setter(attribute_name)
+        "#{attribute_name}="
+      end
+      
+      # TODO see if it is worth it to eliminate duplication of async_exec/sync_exec
+      # delegation to DisplayProxy, via a module
+
+      def async_exec(&block)
+        SWT::DisplayProxy.instance.async_exec(&block)
+      end
+
+      def sync_exec(&block)
+        SWT::DisplayProxy.instance.sync_exec(&block)
+      end
+
+      def timer_exec(delay_in_millis, &block)
+        SWT::DisplayProxy.instance.timer_exec(delay_in_millis, &block)
+      end
+
+      # Returns content block if used as an attribute reader (no args)
+      # Otherwise, if a block is passed, it adds it as content to this custom shape
+      def content(&block)
+        if block_given?
+          body_root.content(&block)
+        else
+          @content
+        end
+      end
+      
+      def method_missing(method, *args, &block)
+        # TODO Consider supporting a glimmer error silencing option for methods defined here
+        # but fail the glimmer DSL for the right reason to avoid seeing noise in the log output
+        body_root.send(method, *args, &block)
+      end
+
+      alias local_respond_to? respond_to?
+      def respond_to?(method, *args, &block)
+        super or
+          body_root.respond_to?(method, *args, &block)
+      end
+      
+      private
+
+      def execute_hook(hook_name)
+        hook_block = self.class.instance_variable_get("@#{hook_name}_block")
+        return if hook_block.nil?
+        temp_method_name = "#{hook_name}_block_#{hook_block.hash.abs}_#{(Time.now.to_f * 1_000_000).to_i}"
+        singleton_class.define_method(temp_method_name, &hook_block)
+        send(temp_method_name)
+        singleton_class.send(:remove_method, temp_method_name)
+      end
+    end
+  end
+end