glimmer-dsl-swt 4.18.4.10 → 4.18.5.3

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

@@ -32,12 +32,12 @@ module Glimmer
         include ParentExpression
         
         def can_interpret?(parent, keyword, *args, &block)
-          parent.is_a?(Glimmer::SWT::Custom::Drawable) and
+          (parent.is_a?(Glimmer::SWT::Custom::Drawable) or parent.is_a?(Glimmer::SWT::Custom::Shape)) and
             Glimmer::SWT::Custom::Shape.valid?(parent, keyword, *args, &block)
         end
         
         def interpret(parent, keyword, *args, &block)
-          Glimmer::SWT::Custom::Shape.new(parent, keyword, *args, &block)
+          Glimmer::SWT::Custom::Shape.create(parent, keyword, *args, &block)
         end
         
         def add_content(parent, &block)

data/lib/glimmer/dsl/swt/shell_expression.rb

@@ -38,7 +38,7 @@ module Glimmer
   
         def interpret(parent, keyword, *args, &block)
           args = [parent] + args unless parent.nil?
-          Glimmer::SWT::ShellProxy.send(:new, *args)
+          Glimmer::SWT::ShellProxy.new(*args)
         end
       end
       class WindowExpression < ShellExpression

data/lib/glimmer/dsl/swt/widget_expression.rb

@@ -33,17 +33,21 @@ module Glimmer
         EXCLUDED_KEYWORDS = %w[shell display tab_item] + Glimmer::SWT::Custom::Shape.keywords - ['text']
 
         def can_interpret?(parent, keyword, *args, &block)
-          result = !EXCLUDED_KEYWORDS.include?(keyword) &&
-            parent.respond_to?(:swt_widget) && #TODO change to composite?(parent)
+          !EXCLUDED_KEYWORDS.include?(keyword) and
+            parent.respond_to?(:swt_widget) and
+            !parent.is_a?(Glimmer::SWT::Custom::Shape) and
+            !((keyword.to_s == 'text') and (args.first.is_a?(String) or parent.swt_widget.class == org.eclipse.swt.widgets.Canvas)) and
             Glimmer::SWT::WidgetProxy.widget_exists?(keyword)
-          (keyword.to_s == 'text' && args.first.is_a?(String)) ? false : result
         end
 
         def interpret(parent, keyword, *args, &block)
-          Glimmer::SWT::WidgetProxy.create(keyword, parent, args)
+          Glimmer::SWT::WidgetProxy.create(keyword, parent, args).tap do |new_widget_proxy|
+            new_widget_proxy.paint_pixel_by_pixel(&block) if block&.parameters&.count == 2
+          end
         end
 
         def add_content(parent, &block)
+          return if block&.parameters&.count == 2
           super
           parent.post_add_content
           parent.finish_add_content!

data/lib/glimmer/launcher.rb

@@ -27,9 +27,12 @@ require 'fileutils'
 require 'os'
 
 module Glimmer
+  # Launcher of glimmer applications and main entry point for the `glimmer` command.
   class Launcher
     OPERATING_SYSTEMS_SUPPORTED = ["mac", "windows", "linux"]
     
+    # TODO convert to a bash script to achieve faster startup time
+    
     TEXT_USAGE = <<~MULTI_LINE_STRING
       Glimmer (JRuby Desktop Development GUI Framework) - JRuby Gem: glimmer-dsl-swt v#{File.read(File.expand_path('../../../VERSION', __FILE__))}
       Usage: glimmer [--bundler] [--pd] [--quiet] [--debug] [--log-level=VALUE] [[ENV_VAR=VALUE]...] [[-jruby-option]...] (application.rb or task[task_args]) [[application2.rb]...]

data/lib/glimmer/rake_task/scaffold.rb

@@ -94,6 +94,9 @@ module Glimmer
           # Mac
           .DS_Store
           
+          # Warbler
+          Jars.lock
+          
           # Gladiator (Glimmer Editor)
           .gladiator
           

data/lib/glimmer/swt/color_proxy.rb

@@ -33,7 +33,7 @@ module Glimmer
       include_package 'org.eclipse.swt.graphics'
       
       class << self
-        def flyweight(*args)
+        def create(*args)
           flyweight_color_proxies[args] ||= new(*args)
         end
         

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

@@ -64,6 +64,18 @@ module Glimmer
           respond_to?(method_name)
         end
         
+        def can_handle_observation_request?(observation_request)
+          @styled_text_proxy.can_handle_observation_request?(observation_request)
+        rescue
+          super
+        end
+        
+        def handle_observation_request(observation_request, &block)
+          @styled_text_proxy.handle_observation_request(observation_request, &block)
+        rescue
+          super
+        end
+        
         def root_block=(block)
           body_root.content(&block)
         end
@@ -124,13 +136,13 @@ module Glimmer
                 editable false
                 caret nil
                 on_focus_gained {
-                  @styled_text_proxy&.swt_widget.setFocus
+                  @styled_text_proxy&.setFocus
                 }
                 on_key_pressed {
-                  @styled_text_proxy&.swt_widget.setFocus
+                  @styled_text_proxy&.setFocus
                 }
                 on_mouse_up {
-                  @styled_text_proxy&.swt_widget.setFocus
+                  @styled_text_proxy&.setFocus
                 }
               }
 
@@ -153,19 +165,29 @@ module Glimmer
             top_margin 5
             right_margin 5
             bottom_margin 5
+            tabs 2
             
             if default_behavior
               on_key_pressed { |event|
                 character = event.keyCode.chr rescue nil
                 case [event.stateMask, character]
                 when [(OS.mac? ? swt(:command) : swt(:ctrl)), 'a']
-                  @styled_text_proxy.swt_widget.selectAll
+                  @styled_text_proxy.selectAll
                 when [(swt(:ctrl) if OS.mac?), 'a']
                   jump_to_beginning_of_line
                 when [(swt(:ctrl) if OS.mac?), 'e']
                   jump_to_end_of_line
                 end
               }
+              on_verify_text { |verify_event|
+                if verify_event.text == "\n"
+                  line_index = verify_event.widget.get_line_at_offset(verify_event.widget.get_caret_offset)
+                  line = verify_event.widget.get_line(line_index)
+                  line_indent = line.match(/^([ ]*)/)[1].to_s.size
+                  verify_event.text += ' '*line_indent
+                  verify_event.text += ' '*2 if line.strip.end_with?('{') || line.strip.match(/do([ ]*[|][^|]*[|])?$/) || line.start_with?('class') || line.start_with?('module') || line.strip.start_with?('def')
+                end
+              }
             end
             
             on_modify_text { |event|
@@ -241,17 +263,17 @@ module Glimmer
         end
         
         def jump_to_beginning_of_line
-          current_line_index = @styled_text_proxy.swt_widget.getLineAtOffset(@styled_text_proxy.swt_widget.getCaretOffset)
-          beginning_of_current_line_offset = @styled_text_proxy.swt_widget.getOffsetAtLine(current_line_index)
-          @styled_text_proxy.swt_widget.setSelection(beginning_of_current_line_offset, beginning_of_current_line_offset)
+          current_line_index = @styled_text_proxy.getLineAtOffset(@styled_text_proxy.getCaretOffset)
+          beginning_of_current_line_offset = @styled_text_proxy.getOffsetAtLine(current_line_index)
+          @styled_text_proxy.setSelection(beginning_of_current_line_offset, beginning_of_current_line_offset)
         end
         
         def jump_to_end_of_line
-          current_line_index = @styled_text_proxy.swt_widget.getLineAtOffset(@styled_text_proxy.swt_widget.getCaretOffset)
-          current_line = @styled_text_proxy.swt_widget.getLine(current_line_index)
-          beginning_of_current_line_offset = @styled_text_proxy.swt_widget.getOffsetAtLine(current_line_index)
+          current_line_index = @styled_text_proxy.getLineAtOffset(@styled_text_proxy.getCaretOffset)
+          current_line = @styled_text_proxy.getLine(current_line_index)
+          beginning_of_current_line_offset = @styled_text_proxy.getOffsetAtLine(current_line_index)
           new_offset = beginning_of_current_line_offset + current_line.size
-          @styled_text_proxy.swt_widget.setSelection(new_offset, new_offset)
+          @styled_text_proxy.setSelection(new_offset, new_offset)
         end
       end
     end

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

@@ -34,10 +34,22 @@ module Glimmer
           @shapes ||= []
         end
         
+        def expanded_shapes
+          @shapes.map do |shape|
+            [shape] + shape.expanded_shapes
+          end.flatten
+        end
+        
         def image_buffered_shapes
           @image_buffered_shapes ||= []
         end
         
+        # TODO add a method like shapes that specifies drawable_properties to be able to adjust properties like transform in between shapes
+          
+        def shape_at_location(x, y)
+          expanded_shapes.reverse.detect {|shape| shape.include?(x, y)}
+        end
+        
         def add_shape(shape)
           if !@image_double_buffered || shape.args.first == @image_proxy_buffer
             shapes << shape
@@ -51,6 +63,50 @@ module Glimmer
           shapes.dup.each {|s| s.dispose(dispose_images: dispose_images, dispose_patterns: dispose_patterns) } if requires_shape_disposal?
         end
         
+        def paint_pixel_by_pixel(width = nil, height = nil, &each_pixel_color)
+          if @image_double_buffered
+            work = lambda do |paint_event|
+              width ||= swt_drawable.bounds.width
+              height ||= swt_drawable.bounds.height
+              @image_proxy_buffer ||= ImageProxy.create_pixel_by_pixel(width, height, &each_pixel_color)
+              @image_proxy_buffer.shape(self).paint(paint_event)
+            end
+          else
+            work = lambda do |paint_event_or_image|
+              the_gc = paint_event_or_image.gc
+              current_foreground = nil
+              width ||= swt_drawable.bounds.width
+              height ||= swt_drawable.bounds.height
+              height.times do |y|
+                width.times do |x|
+                  new_foreground = each_pixel_color.call(x, y)
+                  new_foreground = Glimmer::SWT::ColorProxy.create(new_foreground, ensure_bounds: false) unless new_foreground.is_a?(ColorProxy) || new_foreground.is_a?(Color)
+                  new_foreground = new_foreground.swt_color if new_foreground.is_a?(Glimmer::SWT::ColorProxy)
+                  the_gc.foreground = current_foreground = new_foreground unless new_foreground == current_foreground
+                  the_gc.draw_point x, y
+                end
+              end
+            end
+          end
+          if respond_to?(:gc)
+            work.call(self)
+          else
+            on_swt_paint(&work)
+          end
+        end
+        
+        def swt_drawable
+          swt_drawable = nil
+          if respond_to?(:swt_image)
+            swt_drawable = swt_image
+          elsif respond_to?(:swt_display)
+            swt_drawable = swt_display
+          elsif respond_to?(:swt_widget)
+            swt_drawable = swt_widget
+          end
+          swt_drawable
+        end
+        
         def deregister_shape_painting
           @paint_listener_proxy&.deregister
         end
@@ -84,7 +140,7 @@ module Glimmer
               @paint_listener_proxy = on_swt_paint(&shape_painter)
             end
           else
-            redraw if @finished_add_content && !is_disposed
+            redraw if respond_to?(:redraw) && @finished_add_content && !is_disposed
           end
         end
         alias resetup_shape_painting setup_shape_painting

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

@@ -34,10 +34,17 @@ module Glimmer
       class Shape
         include Packages
         include Properties
-        # TODO support textExtent sized shapes nested within text/string
-        # TODO support a Pattern DSL for methods that take Pattern arguments
         
         class << self
+          def create(parent, keyword, *args, &property_block)
+            potential_shape_class_name = keyword.to_s.camelcase(:upper).to_sym
+            if constants.include?(potential_shape_class_name)
+              const_get(potential_shape_class_name).new(parent, keyword, *args, &property_block)
+            else
+              new(parent, keyword, *args, &property_block)
+            end
+          end
+        
           def valid?(parent, keyword, *args, &block)
             gc_instance_methods.include?(method_name(keyword, arg_options(args)))
           end
@@ -79,27 +86,32 @@ module Glimmer
           end
           
           def pattern(*args)
-            found_pattern = flyweigh_patterns[args]
+            found_pattern = flyweight_patterns[args]
             if found_pattern.nil? || found_pattern.is_disposed
-              found_pattern = flyweigh_patterns[args] = org.eclipse.swt.graphics.Pattern.new(*args)
+              found_pattern = flyweight_patterns[args] = org.eclipse.swt.graphics.Pattern.new(*args)
             end
             found_pattern
           end
           
-          def flyweigh_patterns
-            @flyweigh_patterns ||= {}
+          def flyweight_patterns
+            @flyweight_patterns ||= {}
           end
         end
         
-        attr_reader :parent, :name, :args, :options
+        attr_reader :drawable, :parent, :name, :args, :options, :shapes
+        attr_accessor :x_delta, :y_delta
         
         def initialize(parent, keyword, *args, &property_block)
           @parent = parent
+          @drawable = @parent.is_a?(Drawable) ? @parent : @parent.drawable
           @name = keyword
           @options = self.class.arg_options(args, extract: true)
           @method_name = self.class.method_name(keyword, @options)
           @args = args
           @properties = {}
+          @shapes = [] # nested shapes
+          @x_delta = 0
+          @y_delta = 0
           @options.reject {|key, value| %w[fill gradient round].include?(key.to_s)}.each do |property, property_args|
             @properties[property] = property_args
           end
@@ -107,13 +119,19 @@ module Glimmer
           post_add_content if property_block.nil?
         end
         
+        def add_shape(shape)
+          @shapes << shape
+        end
+        
         def draw?
           !fill?
         end
+        alias drawn? draw?
         
         def fill?
           @options[:fill]
         end
+        alias filled? fill?
         
         def gradient?
           @options[:gradient]
@@ -123,6 +141,45 @@ module Glimmer
           @options[:round]
         end
         
+        # subclasses (like polygon) may override to indicate if a point x,y coordinates falls inside the shape
+        # some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly
+        def contain?(x, y)
+          # assume a rectangular filled shape by default (works for several shapes like image, text, and focus)
+          if respond_to?(:x) && respond_to?(:y) && respond_to?(:width) && respond_to?(:height) && self.x && self.y && width && height
+            x.between?(self.absolute_x, self.absolute_x + width) && y.between?(self.absolute_y, self.absolute_y + height)
+          else
+            false # subclasses must provide implementation
+          end
+        end
+        
+        # subclasses (like polygon) may override to indicate if a point x,y coordinates falls on the edge of a drawn shape or inside a filled shape
+        # some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly
+        def include?(x, y)
+          # assume a rectangular shape by default
+          if respond_to?(:x) && respond_to?(:y) && respond_to?(:width) && respond_to?(:height)
+            contain?(x, y)
+          else
+            false # subclasses must provide implementation
+          end
+        end
+        
+        # moves by x delta and y delta. Subclasses must implement
+        # provdies a default implementation that assumes moving x and y is sufficient by default (not for polygons though, which must override)
+        def move_by(x_delta, y_delta)
+          if respond_to?(:x) && respond_to?(:y) && respond_to?(:x=) && respond_to?(:y=)
+            if default_x?
+              self.x_delta += x_delta
+            else
+              self.x += x_delta
+            end
+            if default_y?
+              self.y_delta += y_delta
+            else
+              self.y += y_delta
+            end
+          end
+        end
+        
         def has_some_background?
           @properties.keys.map(&:to_s).include?('background') || @properties.keys.map(&:to_s).include?('background_pattern')
         end
@@ -134,7 +191,7 @@ module Glimmer
         def post_add_content
           unless @content_added
             amend_method_name_options_based_on_properties!
-            @parent.setup_shape_painting unless @parent.is_a?(ImageProxy)
+            @drawable.setup_shape_painting unless @drawable.is_a?(ImageProxy)
             @content_added = true
           end
         end
@@ -142,10 +199,13 @@ module Glimmer
         def apply_property_arg_conversions(method_name, property, args)
           args = args.dup
           the_java_method = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.detect {|m| m.name == method_name}
+          if the_java_method.parameter_types.first == Color.java_class && args.first.is_a?(RGB)
+            args[0] = [args[0].red, args[0].green, args[0].blue]
+          end
           if ['setBackground', 'setForeground'].include?(method_name.to_s) && args.first.is_a?(Array)
             args[0] = ColorProxy.new(args[0])
           end
-          if args.first.is_a?(Symbol) || args.first.is_a?(String)
+          if args.first.is_a?(Symbol) || args.first.is_a?(::String)
             if the_java_method.parameter_types.first == Color.java_class
               args[0] = ColorProxy.new(args[0])
             end
@@ -156,7 +216,7 @@ module Glimmer
           if args.first.is_a?(ColorProxy)
             args[0] = args[0].swt_color
           end
-          if args.first.is_a?(Hash) && the_java_method.parameter_types.first == Font.java_class
+          if (args.first.is_a?(Hash) || args.first.is_a?(FontData)) && the_java_method.parameter_types.first == Font.java_class
             args[0] = FontProxy.new(args[0])
           end
           if args.first.is_a?(FontProxy)
@@ -166,16 +226,23 @@ module Glimmer
             args[0] = args[0].swt_transform
           end
           if ['setBackgroundPattern', 'setForegroundPattern'].include?(method_name.to_s)
-            @parent.requires_shape_disposal = true
+            @drawable.requires_shape_disposal = true
+            args = args.first if args.first.is_a?(Array)
             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
+              arg = ColorProxy.new(arg.red, arg.green, arg.blue) if arg.is_a?(RGB)
+              arg = ColorProxy.new(arg) if arg.is_a?(Symbol) || arg.is_a?(::String)
+              arg = arg.swt_color if arg.is_a?(ColorProxy)
+              args[i] = arg
+            end
+            @pattern_args ||= {}
+            pattern_type = method_name.to_s.match(/set(.+)Pattern/)[1]
+            if args.first.is_a?(Pattern)
+              new_args = @pattern_args[pattern_type]
+            else
+              new_args = args.first.is_a?(Display) ? args : ([DisplayProxy.instance.swt_display] + args)
+              @pattern_args[pattern_type] = new_args.dup
             end
-            new_args = [DisplayProxy.instance.swt_display] + args
-            args[0] = pattern(*new_args, type: method_name.to_s.match(/set(.+)Pattern/)[1])
+            args[0] = pattern(*new_args, type: pattern_type)
             args[1..-1] = []
           end
           args
@@ -186,29 +253,45 @@ module Glimmer
             @args[0] = @args.dup
             @args[1..-1] = []
           end
+          if @name == 'image'
+            if @args.first.is_a?(::String)
+              @args[0] = ImageProxy.new(@args[0])
+            end
+            if @args.first.is_a?(ImageProxy)
+              @image = @args[0] = @args[0].swt_image
+            end
+            if @args.first.nil?
+              @image = nil
+            end
+          end
+          if @name == 'text'
+            if @args[3].is_a?(Symbol) || @args[3].is_a?(::String)
+              @args[3] = [@args[3]]
+            end
+            if @args[3].is_a?(Array)
+              if @args[3].size == 1 && @args[3].first.is_a?(Array)
+                @args[3] = @args[3].first
+              end
+              @args[3] = SWTProxy[*@args[3]]
+            end
+          end
         end
         
         def apply_shape_arg_defaults!
           if @name.include?('rectangle') && round? && @args.size.between?(4, 5)
             (6 - @args.size).times {@args << 60}
           elsif @name.include?('rectangle') && gradient? && @args.size == 4
-            @args << true
-          elsif (@name.include?('text') || @name.include?('String')) && !@properties.keys.map(&:to_s).include?('background') && @args.size == 3
-            @args << true
+            @args << true # vertical is true by default
+          elsif (@name.include?('text') || @name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && @args.size == 3
+            @args << true # is_transparent is true by default
           end
           if @name.include?('image')
-            @parent.requires_shape_disposal = true
-            if @args.size == 1
-              @args[1] = 0
-              @args[2] = 0
-            end
-            if @args.first.is_a?(String)
-              @args[0] = ImageProxy.new(@args[0])
-            end
-            if @args.first.is_a?(ImageProxy)
-              @image = @args[0] = @args[0].swt_image
-            end
+            @drawable.requires_shape_disposal = true
           end
+          self.x = :default if current_parameter_name?(:x) && x.nil?
+          self.y = :default if current_parameter_name?(:y) && y.nil?
+          self.dest_x = :default if current_parameter_name?(:dest_x) && dest_x.nil?
+          self.dest_y = :default if current_parameter_name?(:dest_y) && dest_y.nil?
         end
                 
         # Tolerates shape extra args added by user by mistake
@@ -217,14 +300,14 @@ module Glimmer
           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
+          if the_java_method_arg_count && @args.to_a.size > the_java_method_arg_count
             @args[the_java_method_arg_count..-1] = []
           end
         end
         
         def amend_method_name_options_based_on_properties!
           return if @name == 'point'
-          if has_some_background? && !has_some_foreground?
+          if @name != 'text' && @name != 'string' && has_some_background? && !has_some_foreground?
             @options[:fill] = true
           elsif !has_some_background? && has_some_foreground?
             @options[:fill] = false
@@ -237,32 +320,118 @@ module Glimmer
           end
           @method_name = self.class.method_name(@name, @options)
         end
-                
+        
+        # parameter names for arguments to pass to SWT GC.xyz method for rendering shape (e.g. draw_image(image, x, y) yields :image, :x, :y parameter names)
+        def parameter_names
+          []
+        end
+        
+        # subclasses may override to specify location parameter names if different from x and y (e.g. all polygon points are location parameters)
+        # used in calculating movement changes
+        def location_parameter_names
+          [:x, :y]
+        end
+        
+        def possible_parameter_names
+          parameter_names
+        end
+        
+        def parameter_name?(attribute_name)
+          possible_parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
+        end
+        
+        def current_parameter_name?(attribute_name)
+          parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
+        end
+        
+        def parameter_index(attribute_name)
+          parameter_names.map(&:to_s).index(attribute_name.to_s)
+        end
+        
+        def set_parameter_attribute(attribute_name, *args)
+          @args[parameter_index(ruby_attribute_getter(attribute_name))] = args.size == 1 ? args.first : args
+        end
+        
         def has_attribute?(attribute_name, *args)
-          self.class.gc_instance_methods.include?(attribute_setter(attribute_name))
+          self.class.gc_instance_methods.include?(attribute_setter(attribute_name)) or
+            parameter_name?(attribute_name) or
+            (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
         end
   
         def set_attribute(attribute_name, *args)
-          @properties[attribute_name] = args
-          if @content_added && !@parent.is_disposed
+          options = args.last if args.last.is_a?(Hash)
+          perform_redraw = @perform_redraw
+          perform_redraw = options[:redraw] if perform_redraw.nil? && !options.nil?
+          perform_redraw = true if perform_redraw.nil?
+          if parameter_name?(attribute_name)
+            set_parameter_attribute(attribute_name, *args)
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
+            self.send(ruby_attribute_setter(attribute_name), *args)
+          else
+            @properties[ruby_attribute_getter(attribute_name)] = args
+          end
+          if @content_added && perform_redraw && !drawable.is_disposed
             @calculated_paint_args = false
-            @parent.redraw
+            attribute_name = ruby_attribute_getter(attribute_name)
+            @calculated_absolute_args = false if (location_parameter_names.map(&:to_s) + ['x_delta', 'y_delta']).include?(attribute_name)
+
+            # TODO consider redrawing an image proxy's gc in the future
+            drawable.redraw unless drawable.is_a?(ImageProxy)
           end
         end
         
         def get_attribute(attribute_name)
-          @properties.symbolize_keys[attribute_name.to_s.to_sym]
+          if parameter_name?(attribute_name)
+            arg_index = parameter_index(attribute_name)
+            @args[arg_index] if arg_index
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
+            self.send(attribute_name)
+          else
+            @properties.symbolize_keys[attribute_name.to_s.to_sym]
+          end
+        end
+        
+        def method_missing(method_name, *args, &block)
+          if method_name.to_s.end_with?('=')
+            set_attribute(method_name, *args)
+          elsif has_attribute?(method_name)
+            get_attribute(method_name)
+          else
+            super
+          end
+        end
+        
+        def respond_to?(method_name, *args, &block)
+          options = args.last if args.last.is_a?(Hash)
+          super_invocation = options && options[:super]
+          if !super_invocation && has_attribute?(method_name)
+            true
+          else
+            super
+          end
         end
         
         def pattern(*args, type: nil)
           instance_variable_name = "@#{type}_pattern"
           the_pattern = instance_variable_get(instance_variable_name)
-          if the_pattern.nil?
+          if the_pattern.nil? || the_pattern.is_disposed
             the_pattern = self.class.pattern(*args)
           end
           the_pattern
         end
         
+        def pattern_args(type: nil)
+          @pattern_args && @pattern_args[type.to_s.capitalize]
+        end
+        
+        def background_pattern_args
+          pattern_args(type: 'background')
+        end
+        
+        def foreground_pattern_args
+          pattern_args(type: 'foreground')
+        end
+        
         def dispose(dispose_images: true, dispose_patterns: true)
           if dispose_patterns
             @background_pattern&.dispose
@@ -287,18 +456,127 @@ module Glimmer
               args.first.swt_transform.dispose
             end
           end
-          paint_event.gc.send(@method_name, *@args)
+          self.extent = paint_event.gc.send("#{@name}Extent", *(([string, flags] if respond_to?(:flags)).compact)) if ['text', 'string'].include?(@name)
+          if !@calculated_absolute_args || parent_shape_absolute_location_changed?
+            @absolute_args = absolute_args
+            @calculated_absolute_args = true
+          end
+          paint_event.gc.send(@method_name, *@absolute_args)
+          paint_children(paint_event)
+        rescue => e
+          Glimmer::Config.logger.error {"Error encountered in painting shape: #{self.inspect}"}
+          Glimmer::Config.logger.error {e.full_message}
+        end
+        
+        def paint_children(paint_event)
+          shapes.to_a.each do |shape|
+            shape.paint(paint_event)
+          end
+        end
+        
+        def expanded_shapes
+          if shapes.to_a.any?
+            shapes.map do |shape|
+              [shape] + shape.expanded_shapes
+            end.flatten
+          else
+            []
+          end
+        end
+        
+        def parent_shape_absolute_location_changed?
+          (parent.is_a?(Shape) && (parent.absolute_x != @parent_absolute_x || parent.absolute_y != @parent_absolute_y))
+        end
+                
+        # args translated to absolute coordinates
+        def absolute_args
+          return @args if !default_x? && !default_y? && @x_delta == 0 && @y_delta == 0 && parent.is_a?(Drawable)
+          @perform_redraw = false
+          original_x = nil
+          original_y = nil
+          if default_x?
+            original_x = x
+            self.x = default_x
+          end
+          if default_y?
+            original_y = y
+            self.y = default_y
+          end
+          move_by(@x_delta, @y_delta)
+          if parent.is_a?(Shape)
+            @parent_absolute_x = parent.absolute_x
+            @parent_absolute_y = parent.absolute_y
+            move_by(parent.absolute_x, parent.absolute_y)
+            calculated_absolute_args = @args.clone
+            move_by(-1*parent.absolute_x, -1*parent.absolute_y)
+          else
+            calculated_absolute_args = @args.clone
+          end
+          move_by(-1*@x_delta, -1*@y_delta)
+          if original_x
+            self.x = original_x
+          end
+          if original_y
+            self.y = original_y
+          end
+          @perform_redraw = true
+          calculated_absolute_args
+        end
+        
+        def default_x?
+          current_parameter_name?('x') && (x.nil? || x.to_s == 'default')
+        end
+        
+        def default_y?
+          current_parameter_name?('y') && (y.nil? || y.to_s == 'default')
+        end
+        
+        def default_x
+          if respond_to?(:width) && width && parent.respond_to?(:width) && parent.width
+            (parent.width - width) / 2
+          else
+            0
+          end
+        end
+        
+        def default_y
+          if respond_to?(:height) && height && parent.respond_to?(:height) && parent.height
+            (parent.height - height) / 2
+          else
+            0
+          end
+        end
+        
+        def absolute_x
+          x = default_x? ? default_x : self.x
+          x += @x_delta
+          if parent.is_a?(Shape)
+            parent.absolute_x + x
+          else
+            x
+          end
+        end
+        
+        def absolute_y
+          y = default_y? ? default_y : self.y
+          y += @y_delta
+          if parent.is_a?(Shape)
+            parent.absolute_y + y
+          else
+            y
+          end
         end
         
         def calculate_paint_args!
           unless @calculated_paint_args
-            if @name == 'point'
+            if @name == 'pixel'
+              @name = 'point'
               # optimized performance calculation for pixel points
               if !@properties[:foreground].is_a?(Color)
                 if @properties[:foreground].is_a?(Array)
                   @properties[:foreground] = ColorProxy.new(@properties[:foreground], ensure_bounds: false)
                 end
-                if @properties[:foreground].is_a?(Symbol) || @properties[:foreground].is_a?(String)
+                if @properties[:foreground].is_a?(Symbol) || @properties[:foreground].is_a?(::String)
                  @properties[:foreground] = ColorProxy.new(@properties[:foreground], ensure_bounds: false)
                 end
                 if @properties[:foreground].is_a?(ColorProxy)
@@ -306,10 +584,14 @@ module Glimmer
                 end
               end
             else
-              @properties['background'] = [@parent.background] if fill? && !has_some_background?
-              @properties['foreground'] = [@parent.foreground] if @parent.respond_to?(:foreground) && draw? && !has_some_foreground?
-              @properties['font'] = [@parent.font] if @parent.respond_to?(:font) && draw? && !@properties.keys.map(&:to_s).include?('font')
-              @properties['transform'] = [nil] if @parent.respond_to?(:transform) && !@properties.keys.map(&:to_s).include?('transform')
+              @properties['background'] = [@drawable.background] if fill? && !has_some_background?
+              @properties['foreground'] = [@drawable.foreground] if @drawable.respond_to?(:foreground) && draw? && !has_some_foreground?
+              # TODO regarding alpha, make sure to reset it to parent stored alpha once we allow setting shape properties on parents directly without shapes
+              @properties['alpha'] ||= [255]
+              @properties['font'] = [@drawable.font] if @drawable.respond_to?(:font) && draw? && !@properties.keys.map(&:to_s).include?('font')
+              # TODO regarding transform, make sure to reset it to parent stored alpha once we allow setting shape properties on parents directly without shapes
+              # Also do that with all future-added properties
+              @properties['transform'] = [nil] if @drawable.respond_to?(:transform) && !@properties.keys.map(&:to_s).include?('transform')
               @properties.each do |property, args|
                 method_name = attribute_setter(property)
                 converted_args = apply_property_arg_conversions(method_name, property, args)
@@ -330,3 +612,5 @@ module Glimmer
   end
   
 end
+
+Dir[File.expand_path(File.join(__dir__, 'shape', '**', '*.rb'))].each {|shape_file| require(shape_file)}