glimmer-dsl-swt 4.18.6.2 → 4.18.7.3

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

@@ -33,7 +33,7 @@ module Glimmer
           Glimmer::SWT::Custom::Animation.new(parent)
         end
         
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           super
           parent.post_add_content
         end

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

@@ -0,0 +1,61 @@
+# 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/dsl/expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/ui/custom_shape'
+require 'glimmer/swt/custom/code_text'
+require 'glimmer/swt/custom/checkbox_group'
+
+module Glimmer
+  module DSL
+    module SWT
+      class CustomShapeExpression < Expression
+        # TODO Make custom shapes automatically generate static expressions
+        include ParentExpression
+        include TopLevelExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          !!UI::CustomShape.for(keyword)
+        end
+  
+        def interpret(parent, keyword, *args, &block)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+            UI::CustomShape.for(keyword).new(parent, *args, options, &block).tap do |new_custom_shape|
+            new_custom_shape.body_root.paint_pixel_by_pixel(&block) if block&.parameters&.count == 2
+          end
+        end
+  
+        def add_content(parent, keyword, *args, &block)
+          # TODO consider avoiding source_location
+          return if block&.parameters&.count == 2
+          if block.source_location == parent.content&.__getobj__.source_location
+            parent.content.call(parent) unless parent.content.called?
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,7 +51,7 @@ module Glimmer
           end
         end
   
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           # TODO consider avoiding source_location
           return if block&.parameters&.count == 2
           if block.source_location == parent.content&.__getobj__.source_location

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

@@ -57,6 +57,7 @@ module Glimmer
           widget
           custom_widget
           shape
+          custom_shape
         ]
       )
     end

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

@@ -1,5 +1,5 @@
 # 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
@@ -7,10 +7,10 @@
 # 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
@@ -49,7 +49,7 @@ module Glimmer
           Glimmer::SWT::ExpandItemProxy.new(parent, args)
         end
         
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           super
           parent.post_add_content
         end

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

@@ -57,7 +57,7 @@ module Glimmer
           end
         end
 
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           return if @create_pixel_by_pixel || block&.parameters&.count == 2
           super
           parent.post_add_content

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

@@ -39,7 +39,7 @@ module Glimmer
           Glimmer::SWT::TransformProxy.new(parent, *args, multiply: true)
         end
         
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           super
           parent.post_add_content
         end

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

@@ -40,7 +40,7 @@ module Glimmer
           Glimmer::SWT::Custom::Shape.create(parent, keyword, *args, &block)
         end
         
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           super
           parent.post_add_content
         end

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

@@ -41,7 +41,7 @@ module Glimmer
           Glimmer::SWT::TransformProxy.new(parent, *args)
         end
         
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           super
           parent.post_add_content
         end

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

@@ -46,7 +46,7 @@ module Glimmer
           end
         end
 
-        def add_content(parent, &block)
+        def add_content(parent, keyword, *args, &block)
           return if block&.parameters&.count == 2
           super
           parent.post_add_content
@@ -69,3 +69,4 @@ require 'glimmer/swt/table_column_proxy'
 require 'glimmer/swt/sash_form_proxy'
 require 'glimmer/swt/styled_text_proxy'
 require 'glimmer/swt/date_time_proxy'
+require 'glimmer/swt/tab_folder_proxy'

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

@@ -73,6 +73,7 @@ module Glimmer
           end
         
           def valid?(parent, keyword, *args, &block)
+            return true if keyword.to_s == 'shape'
             gc_instance_methods.include?(method_name(keyword, arg_options(args))) ||
               constants.include?(keyword.to_s.camelcase(:upper).to_sym)
           end
@@ -126,7 +127,7 @@ module Glimmer
           end
         end
         
-        attr_reader :drawable, :parent, :name, :args, :options, :shapes
+        attr_reader :drawable, :parent, :name, :args, :options, :shapes, :properties
         attr_accessor :extent
         
         def initialize(parent, keyword, *args, &property_block)
@@ -134,7 +135,7 @@ module Glimmer
           @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)
+          @method_name = self.class.method_name(keyword, @options) unless keyword.to_s == 'shape'
           @args = args
           @properties = {}
           @shapes = [] # nested shapes
@@ -170,7 +171,13 @@ module Glimmer
         
         # The bounding box top-left x, y, width, height in absolute positioning
         def bounds
-          org.eclipse.swt.graphics.Rectangle.new(absolute_x, absolute_y, calculated_width, calculated_height)
+          bounds_dependencies = [absolute_x, absolute_y, calculated_width, calculated_height]
+          if bounds_dependencies != @bounds_dependencies
+            # avoid repeating calculations
+            absolute_x, absolute_y, calculated_width, calculated_height = @bounds_dependencies = bounds_dependencies
+            @bounds = org.eclipse.swt.graphics.Rectangle.new(absolute_x, absolute_y, calculated_width, calculated_height)
+          end
+          @bounds
         end
         
         # The bounding box top-left x and y
@@ -180,7 +187,13 @@ module Glimmer
         
         # The bounding box width and height (as a Point object with x being width and y being height)
         def size
-          org.eclipse.swt.graphics.Point.new(calculated_width, calculated_height)
+          size_dependencies = [calculated_width, calculated_height]
+          if size_dependencies != @size_dependencies
+            # avoid repeating calculations
+            calculated_width, calculated_height = @size_dependencies = size_dependencies
+            @size = org.eclipse.swt.graphics.Point.new(calculated_width, calculated_height)
+          end
+          @size
         end
         
         def extent
@@ -213,12 +226,12 @@ module Glimmer
         def move_by(x_delta, y_delta)
           if respond_to?(:x) && respond_to?(:y) && respond_to?(:x=) && respond_to?(:y=)
             if default_x?
-              self.default_x_delta += x_delta
+              self.x_delta += x_delta
             else
               self.x += x_delta
             end
             if default_y?
-              self.default_y_delta += y_delta
+              self.y_delta += y_delta
             else
               self.y += y_delta
             end
@@ -227,7 +240,7 @@ module Glimmer
         
         def content(&block)
           Glimmer::SWT::DisplayProxy.instance.auto_exec do
-            Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShapeExpression.new, &block)
+            Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShapeExpression.new, @name, &block)
             calculated_args_changed!(children: false)
           end
         end
@@ -248,7 +261,8 @@ module Glimmer
           end
         end
         
-        def apply_property_arg_conversions(method_name, property, args)
+        def apply_property_arg_conversions(property, args)
+          method_name = attribute_setter(property)
           args = args.dup
           the_java_method = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.detect {|m| m.name == method_name}
           return args if the_java_method.nil?
@@ -262,10 +276,23 @@ module Glimmer
             args[0] = args.dup
             args[1..-1] = []
           end
+          if method_name.to_s == 'setAntialias' && [nil, true, false].include?(args.first)
+            args[0] = case args.first
+            when true
+              args[0] = :on
+            when false
+              args[0] = :off
+            when nil
+              args[0] = :default
+            end
+          end
           if args.first.is_a?(Symbol) || args.first.is_a?(::String)
             if the_java_method.parameter_types.first == org.eclipse.swt.graphics.Color.java_class
               args[0] = ColorProxy.new(args[0])
             end
+            if method_name.to_s == 'setLineStyle'
+              args[0] = "line_#{args[0]}" if !args[0].to_s.downcase.start_with?('line_')
+            end
             if the_java_method.parameter_types.first == Java::int.java_class
               args[0] = SWTProxy.constant(args[0])
             end
@@ -293,10 +320,10 @@ module Glimmer
             end
             @pattern_args ||= {}
             pattern_type = method_name.to_s.match(/set(.+)Pattern/)[1]
-            if args.first.is_a?(Pattern)
+            if args.first.is_a?(org.eclipse.swt.graphics.Pattern)
               new_args = @pattern_args[pattern_type]
             else
-              new_args = args.first.is_a?(Display) ? args : ([DisplayProxy.instance.swt_display] + args)
+              new_args = args.first.is_a?(org.eclipse.swt.widgets.Display) ? args : ([DisplayProxy.instance.swt_display] + args)
               @pattern_args[pattern_type] = new_args.dup
             end
             args[0] = pattern(*new_args, type: pattern_type)
@@ -335,10 +362,16 @@ module Glimmer
         end
         
         def apply_shape_arg_defaults!
-          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?
+          if current_parameter_name?(:dest_x) && dest_x.nil?
+            self.dest_x = :default
+          elsif parameter_name?(:x) && x.nil?
+            self.x = :default
+          end
+          if current_parameter_name?(:dest_y) && dest_y.nil?
+            self.dest_y = :default
+          elsif parameter_name?(:y) && y.nil?
+            self.y = :default
+          end
           self.width = :default if current_parameter_name?(:width) && width.nil?
           self.height = :default if current_parameter_name?(:height) && height.nil?
           if @name.include?('rectangle') && round? && @args.size.between?(4, 5)
@@ -383,7 +416,7 @@ module Glimmer
         
         # 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
-          []
+          [:x, :y, :width, :height]
         end
         
         # subclasses may override to specify location parameter names if different from x and y (e.g. all polygon points are location parameters)
@@ -408,6 +441,10 @@ module Glimmer
           parameter_names.index(attribute_name.to_s.to_sym)
         end
         
+        def get_parameter_attribute(attribute_name)
+          @args[parameter_index(ruby_attribute_getter(attribute_name))]
+        end
+        
         def set_parameter_attribute(attribute_name, *args)
           @args[parameter_index(ruby_attribute_getter(attribute_name))] = args.size == 1 ? args.first : args
         end
@@ -423,31 +460,43 @@ module Glimmer
           args.pop if !options.nil? && !options[:redraw].nil?
           perform_redraw = @perform_redraw
           perform_redraw = options[:redraw] if perform_redraw.nil? && !options.nil?
-          perform_redraw = true if perform_redraw.nil?
+          perform_redraw ||= true
+          property_change = nil
+          ruby_attribute_getter_name = ruby_attribute_getter(attribute_name)
+          ruby_attribute_setter_name = ruby_attribute_setter(attribute_name)
           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)
+            return if ruby_attribute_getter_name == (args.size == 1 ? args.first : args)
+            set_parameter_attribute(ruby_attribute_getter_name, *args)
+          elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter_name, super: true))
+            return if self.send(ruby_attribute_getter_name) == (args.size == 1 ? args.first : args)
+            self.send(ruby_attribute_setter_name, *args)
           else
-            @properties[ruby_attribute_getter(attribute_name)] = args
+            # TODO consider this optimization of preconverting args (removing conversion from other methods) to reject equal args
+            args = apply_property_arg_conversions(ruby_attribute_getter_name, args)
+            return if @properties[ruby_attribute_getter_name] == args
+            @properties[ruby_attribute_getter_name] = args
+            property_change = true
           end
           if @content_added && perform_redraw && !drawable.is_disposed
-            @calculated_paint_args = false
-            if is_a?(PathSegment)
-              root_path&.calculated_path_args = @calculated_path_args = false
-              calculated_args_changed!
-              root_path&.calculated_args_changed!
-            end
-            attribute_name = ruby_attribute_getter(attribute_name)
-            if location_parameter_names.map(&:to_s).include?(attribute_name)
-              @calculated_args = nil
-              parent.calculated_args_changed_for_defaults! if parent.is_a?(Shape)
-            end
-            if ['width', 'height'].include?(attribute_name)
-              calculated_args_changed_for_defaults!
+            redrawn = false
+            unless property_change
+              @calculated_paint_args = false
+              if is_a?(PathSegment)
+                root_path&.calculated_path_args = @calculated_path_args = false
+                calculated_args_changed!
+                root_path&.calculated_args_changed!
+              end
+              if location_parameter_names.map(&:to_s).include?(ruby_attribute_getter_name)
+                calculated_args_changed!(children: true)
+                redrawn = parent.calculated_args_changed_for_defaults! if parent.is_a?(Shape)
+              end
+              if ['width', 'height'].include?(ruby_attribute_getter_name)
+                redrawn = calculated_args_changed_for_defaults!
+              end
             end
             # TODO consider redrawing an image proxy's gc in the future
-            drawable.redraw unless drawable.is_a?(ImageProxy)
+            # TODO consider ensuring only a single redraw happens for a hierarchy of nested shapes
+            drawable.redraw unless redrawn || drawable.is_a?(ImageProxy)
           end
         end
         
@@ -458,10 +507,25 @@ module Glimmer
           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]
+            @properties[attribute_name.to_s]
           end
         end
         
+        # Sets data just like SWT widgets
+        def set_data(key=nil, value)
+          @data ||= {}
+          @data[key] = value
+        end
+        alias setData set_data # for compatibility with SWT APIs
+  
+        # Gets data just like SWT widgets
+        def get_data(key=nil)
+          @data ||= {}
+          @data[key]
+        end
+        alias getData get_data # for compatibility with SWT APIs
+        alias data get_data # for compatibility with SWT APIs
+  
         def method_missing(method_name, *args, &block)
           if method_name.to_s.end_with?('=')
             set_attribute(method_name, *args)
@@ -503,7 +567,7 @@ module Glimmer
           pattern_args(type: 'foreground')
         end
         
-        def dispose(dispose_images: true, dispose_patterns: true)
+        def dispose(dispose_images: true, dispose_patterns: true, redraw: true)
           shapes.each { |shape| shape.is_a?(Shape::Path) && shape.dispose }
           if dispose_patterns
             @background_pattern&.dispose
@@ -516,10 +580,80 @@ module Glimmer
             @image = nil
           end
           @parent.shapes.delete(self)
+          drawable.redraw if redraw && !drawable.is_a?(ImageProxy)
+        end
+        
+        # Indicate if this is a container shape (meaning a shape bag that is just there to contain nested shapes, but doesn't render anything of its own)
+        def container?
+          @name == 'shape'
+        end
+        
+        # Indicate if this is a composite shape (meaning a shape that contains nested shapes like a rectangle with ovals inside it)
+        def composite?
+          !shapes.empty?
+        end
+        
+        # ordered from closest to farthest parent
+        def parent_shapes
+          if @parent_shapes.nil?
+            if parent.is_a?(Drawable)
+              @parent_shapes = []
+            else
+              @parent_shapes = parent.parent_shapes + [parent]
+            end
+          end
+          @parent_shapes
+        end
+        
+        # ordered from closest to farthest parent
+        def parent_shape_containers
+          if @parent_shape_containers.nil?
+            if parent.is_a?(Drawable)
+              @parent_shape_containers = []
+            elsif !parent.container?
+              @parent_shape_containers = parent.parent_shape_containers
+            else
+              @parent_shape_containers = parent.parent_shape_containers + [parent]
+            end
+          end
+          @parent_shape_containers
+        end
+        
+        # ordered from closest to farthest parent
+        def parent_shape_composites
+          if @parent_shape_composites.nil?
+            if parent.is_a?(Drawable)
+              @parent_shape_composites = []
+            elsif !parent.container?
+              @parent_shape_composites = parent.parent_shape_composites
+            else
+              @parent_shape_composites = parent.parent_shape_composites + [parent]
+            end
+          end
+          @parent_shape_composites
+        end
+        
+        def convert_properties!
+          if @properties != @converted_properties
+            @properties.each do |property, args|
+              @properties[property] = apply_property_arg_conversions(property, args)
+            end
+            @converted_properties = @properties.dup
+          end
+        end
+        
+        def converted_properties
+          convert_properties!
+          @properties
+        end
+        
+        def all_parent_properties
+          @all_parent_properties ||= parent_shape_containers.reverse.reduce({}) do |all_properties, parent_shape|
+            all_properties.merge(parent_shape.converted_properties)
+          end
         end
         
         def paint(paint_event)
-          # pre-paint children an extra-time first when default width/height need to be calculated for defaults
           paint_children(paint_event) if default_width? || default_height?
           paint_self(paint_event)
           # re-paint children from scratch in the special case of pre-calculating parent width/height to re-center within new parent dimensions
@@ -532,28 +666,30 @@ module Glimmer
         
         def paint_self(paint_event)
           @painting = true
-          calculate_paint_args!
-          @original_properties_backup = {}
-          @properties.each do |property, args|
-            method_name = attribute_setter(property)
-            @original_properties_backup[method_name] = paint_event.gc.send(method_name.sub('set', 'get')) rescue nil
-            paint_event.gc.send(method_name, *args)
-            if property == 'transform' && args.first.is_a?(TransformProxy)
-              args.first.swt_transform.dispose
+          unless container?
+            calculate_paint_args!
+            @original_gc_properties = {} # this stores GC properties before making calls to updates TODO avoid using in pixel graphics
+            @properties.each do |property, args|
+              method_name = attribute_setter(property)
+              @original_gc_properties[method_name] = paint_event.gc.send(method_name.sub('set', 'get')) rescue nil
+              paint_event.gc.send(method_name, *args)
+              if property == 'transform' && args.first.is_a?(TransformProxy)
+                args.first.swt_transform.dispose
+              end
             end
+            ensure_extent(paint_event)
           end
-          ensure_extent(paint_event)
-          if !@calculated_args || parent_shape_absolute_location_changed?
-            @calculated_args = calculated_args
-          end
-          # paint unless parent's calculated args are not calculated yet, meaning it is about to get painted and trigger a paint on this child anyways
-          paint_event.gc.send(@method_name, *@calculated_args) unless parent.is_a?(Shape) && !parent.calculated_args?
-          @original_properties_backup.each do |method_name, value|
-            paint_event.gc.send(method_name, value)
+          @calculated_args ||= calculate_args!
+          unless container?
+            # paint unless parent's calculated args are not calculated yet, meaning it is about to get painted and trigger a paint on this child anyways
+            paint_event.gc.send(@method_name, *@calculated_args) unless (parent.is_a?(Shape) && !parent.calculated_args?)
+            @original_gc_properties.each do |method_name, value|
+              paint_event.gc.send(method_name, value)
+            end
           end
           @painting = false
         rescue => e
-          Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with calculated args (#{@calculated_args}) and args (#{@args})"}
+          Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with method (#{@method_name}) calculated args (#{@calculated_args}) and args (#{@args})"}
           Glimmer::Config.logger.error {e.full_message}
         ensure
           @painting = false
@@ -590,26 +726,27 @@ module Glimmer
           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
-        
         def calculated_args_changed!(children: true)
           # TODO add a children: true option to enable setting to false to avoid recalculating children args
           @calculated_args = nil
           shapes.each(&:calculated_args_changed!) if children
         end
         
+        # Notifies object that calculated args changed for defaults. Returns true if redrawing and false otherwise.
         def calculated_args_changed_for_defaults!
           has_default_dimensions = default_width? || default_height?
           parent_calculated_args_changed_for_defaults = has_default_dimensions
-          @calculated_args = nil if default_x? || default_y? || has_default_dimensions
+          calculated_args_changed!(children: false) if default_x? || default_y? || has_default_dimensions
           if has_default_dimensions && parent.is_a?(Shape)
             parent.calculated_args_changed_for_defaults!
           elsif @content_added && !drawable.is_disposed
             # TODO consider optimizing in the future if needed by ensuring one redraw for all parents in the hierarchy at the end instead of doing one per parent that needs it
-            drawable.redraw if !@painting && !drawable.is_a?(ImageProxy)
+            if !@painting && !drawable.is_a?(ImageProxy)
+              drawable.redraw
+              return true
+            end
           end
+          false
         end
         
         def calculated_args?
@@ -617,68 +754,101 @@ module Glimmer
         end
                 
         # args translated to absolute coordinates
-        def calculated_args
-          return @args if !default_x? && !default_y? && !default_width? && !default_height? && parent.is_a?(Drawable)
-          # Note: Must set x and move_by because not all shapes have a real x and some must translate all their points with move_by
-          # TODO change that by setting a bounding box for all shapes with a calculated top-left x, y and
-          # a setter that does the moving inside them instead so that I could rely on absolute_x and absolute_y
-          # here to get the job done of calculating absolute args
-          @perform_redraw = false
-          original_x = nil
-          original_y = nil
-          original_width = nil
-          original_height = nil
-          if parent.is_a?(Shape)
-            @parent_absolute_x = parent.absolute_x
-            @parent_absolute_y = parent.absolute_y
-          end
-          if default_width?
-            original_width = width
-            self.width = default_width + default_width_delta
-          end
-          if default_height?
-            original_height = height
-            self.height = default_height + default_height_delta
-          end
-          if default_x?
-            original_x = x
-            self.x = default_x + default_x_delta
-          end
-          if default_y?
-            original_y = y
-            self.y = default_y + default_y_delta
-          end
-          if parent.is_a?(Shape)
-            move_by(@parent_absolute_x, @parent_absolute_y)
-            result_args = @args.clone
-            move_by(-1*@parent_absolute_x, -1*@parent_absolute_y)
-          else
-            result_args = @args.clone
-          end
-          if original_x
-            self.x = original_x
-          end
-          if original_y
-            self.y = original_y
-          end
-          if original_width
-            self.width = original_width
-          end
-          if original_height
-            self.height = original_height
+        def calculate_args!
+        # TODO add conditions for parent having default width/height too
+          return @args if parent.is_a?(Drawable) && !default_x? && !default_y? && !default_width? && !default_height? && !max_width? && !max_height?
+          calculated_args_dependencies = [
+            x,
+            y,
+            parent.is_a?(Shape) && parent.absolute_x,
+            parent.is_a?(Shape) && parent.absolute_y,
+            default_width? && default_width,
+            default_width? && width_delta,
+            default_height? && default_height,
+            default_height? && height_delta,
+            max_width? && max_width,
+            max_width? && width_delta,
+            max_height? && max_height,
+            max_height? && height_delta,
+            default_x? && default_x,
+            default_x? && x_delta,
+            default_y? && default_y,
+            default_y? && y_delta,
+          ]
+          if calculated_args_dependencies != @calculated_args_dependencies
+            # avoid recalculating values again
+            x, y, parent_absolute_x, parent_absolute_y, default_width, default_width_delta, default_height, default_height_delta, max_width, max_width_delta, max_height, max_height_delta, default_x, default_x_delta, default_y, default_y_delta = @calculated_args_dependencies = calculated_args_dependencies
+            # Note: Must set x and move_by because not all shapes have a real x and some must translate all their points with move_by
+            # TODO change that by setting a bounding box for all shapes with a calculated top-left x, y and
+            # a setter that does the moving inside them instead so that I could rely on absolute_x and absolute_y
+            # here to get the job done of calculating absolute args
+            @perform_redraw = false
+            original_x = nil
+            original_y = nil
+            original_width = nil
+            original_height = nil
+            if parent.is_a?(Shape)
+              @parent_absolute_x = parent_absolute_x
+              @parent_absolute_y = parent_absolute_y
+            end
+            if default_width?
+              original_width = width
+              self.width = default_width + default_width_delta
+            end
+            if default_height?
+              original_height = height
+              self.height = default_height + default_height_delta
+            end
+            if max_width?
+              original_width = width
+              self.width = max_width + max_width_delta
+            end
+            if max_height?
+              original_height = height
+              self.height = max_height + max_height_delta
+            end
+            if default_x?
+              original_x = x
+              self.x = default_x + default_x_delta
+            end
+            if default_y?
+              original_y = y
+              self.y = default_y + default_y_delta
+            end
+            if parent.is_a?(Shape)
+              move_by(@parent_absolute_x, @parent_absolute_y)
+              @result_calculated_args = @args.clone
+              move_by(-1*@parent_absolute_x, -1*@parent_absolute_y)
+            else
+              @result_calculated_args = @args.clone
+            end
+            if original_x
+              self.x = original_x
+            end
+            if original_y
+              self.y = original_y
+            end
+            if original_width
+              self.width = original_width
+            end
+            if original_height
+              self.height = original_height
+            end
+            @perform_redraw = true
           end
-          @perform_redraw = true
-          result_args
+          @result_calculated_args
         end
         
         def default_x?
-          current_parameter_name?(:x) and
-            (x.nil? || x.to_s == 'default' || (x.is_a?(Array) && x.first.to_s == 'default'))
+          return false unless current_parameter_name?(:x)
+          x = self.x
+          x.nil? || x.to_s == 'default' || (x.is_a?(Array) && x.first.to_s == 'default')
         end
         
         def default_y?
-          current_parameter_name?(:y) and
-            (y.nil? || y.to_s == 'default' || (y.is_a?(Array) && y.first.to_s == 'default'))
+          return false unless current_parameter_name?(:y)
+          y = self.y
+          y.nil? || y.to_s == 'default' || (y.is_a?(Array) && y.first.to_s == 'default')
         end
         
         def default_width?
@@ -693,120 +863,248 @@ module Glimmer
           (height.nil? || height == :default || height == 'default' || (height.is_a?(Array) && (height.first.to_s == :default || height.first.to_s == 'default')))
         end
         
+        def max_width?
+          return false unless current_parameter_name?(:width)
+          width = self.width
+          (width.nil? || width.to_s == 'max' || (width.is_a?(Array) && width.first.to_s == 'max'))
+        end
+        
+        def max_height?
+          return false unless current_parameter_name?(:height)
+          height = self.height
+          (height.nil? || height.to_s == 'max' || (height.is_a?(Array) && height.first.to_s == 'max'))
+        end
+        
         def default_x
-          result = ((parent.size.x - size.x) / 2)
-          result += parent.bounds.x - parent.absolute_x if parent.is_a?(Shape) && parent.irregular?
-          result
+          default_x_dependencies = [parent.size.x, size.x, parent.is_a?(Shape) && parent.irregular? && parent.bounds.x, parent.is_a?(Shape) && parent.irregular? && parent.absolute_x]
+          if default_x_dependencies != @default_x_dependencies
+            @default_x_dependencies = default_x_dependencies
+            result = ((parent.size.x - size.x) / 2)
+            result += parent.bounds.x - parent.absolute_x if parent.is_a?(Shape) && parent.irregular?
+            @default_x = result
+          end
+          @default_x
         end
         
         def default_y
-          result = ((parent.size.y - size.y) / 2)
-          result += parent.bounds.y - parent.absolute_y if parent.is_a?(Shape) && parent.irregular?
-          result
+          default_y_dependencies = [parent.size.y, size.y, parent.is_a?(Shape) && parent.irregular? && parent.bounds.y, parent.is_a?(Shape) && parent.irregular? && parent.absolute_y]
+          if default_y_dependencies != @default_y_dependencies
+            result = ((parent.size.y - size.y) / 2)
+            result += parent.bounds.y - parent.absolute_y if parent.is_a?(Shape) && parent.irregular?
+            @default_y = result
+          end
+          @default_y
+        end
+        
+        # right-most x coordinate in this shape (adding up its width and location)
+        def x_end
+          x_end_dependencies = [calculated_width, default_x?, !default_x? && x]
+          if x_end_dependencies != @x_end_dependencies
+            # avoid recalculation of dependencies
+            calculated_width, is_default_x, x = @x_end_dependencies = x_end_dependencies
+            shape_width = calculated_width.to_f
+            shape_x = is_default_x ? 0 : x.to_f
+            @x_end = shape_x + shape_width
+          end
+          @x_end
+        end
+        
+        # right-most y coordinate in this shape (adding up its height and location)
+        def y_end
+          y_end_dependencies = [calculated_height, default_y?, !default_y? && y]
+          if y_end_dependencies != @y_end_dependencies
+            # avoid recalculation of dependencies
+            calculated_height, is_default_y, y = @y_end_dependencies = y_end_dependencies
+            shape_height = calculated_height.to_f
+            shape_y = is_default_y ? 0 : y.to_f
+            @y_end = shape_y + shape_height
+          end
+          @y_end
         end
         
         def default_width
-          # TODO consider caching
-          x_ends = shapes.map do |shape|
-            shape_width = shape.calculated_width.to_f
-            shape_x = shape.default_x? ? 0 : shape.x.to_f
-            shape_x + shape_width
+          default_width_dependencies = [shapes.empty? && max_width, shapes.size == 1 && shapes.first.max_width? && parent.size.x, shapes.size >= 1 && !shapes.first.max_width? && shapes.map {|s| s.max_width? ? 0 : s.x_end}]
+          if default_width_dependencies != @default_width_dependencies
+            # Do not repeat calculations
+            max_width, parent_size_x, x_ends = @default_width_dependencies = default_width_dependencies
+            @default_width = if shapes.empty?
+              max_width
+            elsif shapes.size == 1 && shapes.first.max_width?
+              parent_size_x
+            else
+              x_ends.max.to_f
+            end
           end
-          x_ends.max.to_f
+          @default_width
         end
         
         def default_height
-          # TODO consider caching
-          y_ends = shapes.map do |shape|
-            shape_height = shape.calculated_height.to_f
-            shape_y = shape.default_y? ? 0 : shape.y.to_f
-            shape_y + shape_height
+          default_height_dependencies = [shapes.empty? && max_height, shapes.size == 1 && shapes.first.max_height? && parent.size.y, shapes.size >= 1 && !shapes.first.max_height? && shapes.map {|s| s.max_height? ? 0 : s.y_end}]
+          if default_height_dependencies != @default_height_dependencies
+            # Do not repeat calculations
+            max_height, parent_size_y, y_ends = @default_height_dependencies = default_height_dependencies
+            @default_height = if shapes.empty?
+              max_height
+            elsif shapes.size == 1 && shapes.first.max_height?
+              parent_size_y
+            else
+              y_ends.max.to_f
+            end
+          end
+          @default_height
+        end
+        
+        def max_width
+          max_width_dependencies = [parent.is_a?(Drawable) && parent.size.x, !parent.is_a?(Drawable) && parent.calculated_width]
+          if max_width_dependencies != @max_width_dependencies
+            # do not repeat calculations
+            parent_size_x, parent_calculated_width = @max_width_dependencies = max_width_dependencies
+            @max_width = parent.is_a?(Drawable) ? parent_size_x : parent_calculated_width
+          end
+          @max_width
+        end
+        
+        def max_height
+          max_height_dependencies = [parent.is_a?(Drawable) && parent.size.y, !parent.is_a?(Drawable) && parent.calculated_height]
+          if max_height_dependencies != @max_height_dependencies
+            # do not repeat calculations
+            parent_size_y, parent_calculated_height = @max_height_dependencies = max_height_dependencies
+            @max_height = parent.is_a?(Drawable) ? parent_size_y : parent_calculated_height
           end
-          y_ends.max.to_f
+          @max_height
         end
         
         def calculated_width
-          default_width? ? (default_width + default_width_delta) : width
+          calculated_width_dependencies = [width, default_width? && (default_width + width_delta), max_width? && (max_width + width_delta)]
+          if calculated_width_dependencies != @calculated_width_dependencies
+            @calculated_width_dependencies = calculated_width_dependencies
+            result_width = width
+            result_width = (default_width + width_delta) if default_width?
+            result_width = (max_width + width_delta) if max_width?
+            @calculated_width = result_width
+          end
+          @calculated_width
         end
         
         def calculated_height
-          default_height? ? (default_height + default_height_delta) : height
+          calculated_height_dependencies = [height, default_height? && (default_height + height_delta), max_height? && (max_height + height_delta)]
+          if calculated_height_dependencies != @calculated_height_dependencies
+            @calculated_height_dependencies = calculated_height_dependencies
+            result_height = height
+            result_height = (default_height + height_delta) if default_height?
+            result_height = (max_height + height_delta) if max_height?
+            @calculated_height = result_height
+          end
+          @calculated_height
         end
         
-        def default_x_delta
-          return 0 unless default_x? && x.is_a?(Array)
+        def x_delta
+          return 0 unless x.is_a?(Array) && default_x?
           x[1].to_f
         end
         
-        def default_y_delta
-          return 0 unless default_y? && y.is_a?(Array)
+        def y_delta
+          return 0 unless y.is_a?(Array) && default_y?
           y[1].to_f
         end
         
-        def default_width_delta
-          return 0 unless default_width? && width.is_a?(Array)
+        def width_delta
+          return 0 unless width.is_a?(Array) && (default_width? || max_width?)
           width[1].to_f
         end
         
-        def default_height_delta
-          return 0 unless default_height? && height.is_a?(Array)
+        def height_delta
+          return 0 unless height.is_a?(Array) && (default_height? || max_height?)
           height[1].to_f
         end
         
-        def default_x_delta=(delta)
+        def x_delta=(delta)
           return unless default_x?
-          self.x = [:default, delta]
+          symbol = x.is_a?(Array) ? x.first : x
+          self.x = [symbol, delta]
         end
         
-        def default_y_delta=(delta)
+        def y_delta=(delta)
           return unless default_y?
-          self.y = [:default, delta]
+          symbol = y.is_a?(Array) ? y.first : y
+          self.y = [symbol, delta]
         end
         
-        def default_width_delta=(delta)
+        def width_delta=(delta)
           return unless default_width?
-          self.width = [:default, delta]
+          symbol = width.is_a?(Array) ? width.first : width
+          self.width = [symbol, delta]
         end
         
-        def default_height_delta=(delta)
+        def height_delta=(delta)
           return unless default_height?
-          self.height = [:default, delta]
+          symbol = height.is_a?(Array) ? height.first : height
+          self.height = [symbol, delta]
         end
         
         def calculated_x
-          result = default_x? ? default_x : self.x
-          result += default_x_delta
-          result
+          calculated_x_dependencies = [default_x? && default_x, !default_x? && self.x, self.x_delta]
+          if calculated_x_dependencies != @calculated_x_dependencies
+            default_x, x, x_delta = @calculated_x_dependencies = calculated_x_dependencies
+            result = default_x? ? default_x : x
+            result += x_delta
+            @calculated_x = result
+          end
+          @calculated_x
         end
         
         def calculated_y
-          result = default_y? ? default_y : self.y
-          result += default_y_delta
-          result
+          calculated_y_dependencies = [default_y? && default_y, !default_y? && self.y, self.y_delta]
+          if calculated_y_dependencies != @calculated_y_dependencies
+            default_y, y, y_delta = @calculated_y_dependencies = calculated_y_dependencies
+            result = default_y? ? default_y : y
+            result += y_delta
+            @calculated_y = result
+          end
+          @calculated_y
         end
         
         def absolute_x
-          x = calculated_x
-          if parent.is_a?(Shape)
-            parent.absolute_x + x
-          else
-            x
+          absolute_x_dependencies = [calculated_x, parent.is_a?(Shape) && parent.absolute_x]
+          if absolute_x_dependencies != @absolute_x_dependencies
+            # do not repeat calculations
+            calculated_x, parent_absolute_x = @absolute_x_dependencies = absolute_x_dependencies
+            x = calculated_x
+            @absolute_x = if parent.is_a?(Shape)
+              parent_absolute_x + x
+            else
+              x
+            end
           end
+          @absolute_x
         end
         
         def absolute_y
-          y = calculated_y
-          if parent.is_a?(Shape)
-            parent.absolute_y + y
-          else
-            y
+          absolute_y_dependencies = [calculated_y, parent.is_a?(Shape) && parent.absolute_y]
+          if absolute_y_dependencies != @absolute_y_dependencies
+            calculated_y, parent_absolute_y = @absolute_y_dependencies = absolute_y_dependencies
+            y = calculated_y
+            @absolute_y = if parent.is_a?(Shape)
+              parent_absolute_y + y
+            else
+              y
+            end
           end
-        end
-        
-        # Overriding inspect to avoid printing very long shape hierarchies
-        def inspect
-          "#<#{self.class.name}:0x#{self.hash.to_s(16)} args=#{@args.inspect}, properties=#{@properties.inspect}}>"
+          @absolute_y
+        end
+        
+        # Overriding inspect to avoid printing very long nested shape hierarchies (recurses onces only)
+        def inspect(recursive: 1, calculated: false, args: true, properties: true, calculated_args: false)
+          recurse = recursive == true || recursive.is_a?(Integer) && recursive.to_i > 0
+          recursive = [recursive -= 1, 0].max if recursive.is_a?(Integer)
+          args_string = " args=#{@args.inspect}" if args
+          properties_string = " properties=#{@properties.inspect}}" if properties
+          calculated_args_string = " calculated_args=#{@calculated_args.inspect}" if calculated_args
+          calculated_string = " absolute_x=#{absolute_x} absolute_y=#{absolute_y} calculated_width=#{calculated_width} calculated_height=#{calculated_height}" if calculated
+          recursive_string = " shapes=#{@shapes.map {|s| s.inspect(recursive: recursive, calculated: calculated, args: args, properties: properties)}}" if recurse
+          "#<#{self.class.name}:0x#{self.hash.to_s(16)}#{args_string}#{properties_string}#{calculated_args_string}#{calculated_string}#{recursive_string}>"
         rescue => e
+          Glimmer::Config.logger.error { e.full_message }
           "#<#{self.class.name}:0x#{self.hash.to_s(16)}"
         end
         
@@ -827,19 +1125,14 @@ module Glimmer
                 end
               end
             else
+              @properties = all_parent_properties.merge(@properties)
               @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')
+              @properties['font'] = [@drawable.font] if @drawable.respond_to?(:font) && @name == 'text' && draw? && !@properties.keys.map(&:to_s).include?('font')
               # TODO regarding transform, make sure to reset it to parent stored transform 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)
-                @properties[property] = converted_args
-              end
+              convert_properties!
               apply_shape_arg_conversions!
               apply_shape_arg_defaults!
               tolerate_shape_extra_args!