eideticrml 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e7a24549e78789d378487d0b3b2d7c8ae015167
+  data.tar.gz: de5a5090642ccb6928f0b31f301e8583e7c895df
+SHA512:
+  metadata.gz: 56da9c4a8f20131617bba41606eb6f4ae8293ea5ee6c7375b5c7266ee766ba6ab71c26050f5e871af2d517e88890de165ec8ab58cae82f3bbbab3b13469ee174
+  data.tar.gz: ba2c27d259d1ba7eb4275eeb59878f5b887c7c696fd5249459a142fc3dfb3692c346761d29bd0142577dfd0b4efaa738ce9b0ab44e8bfd29b3a826385a795430

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = "eideticrml"
+  s.version = "0.3.0"
+  s.date = "2017-09-11"
+  s.summary = "Report Markup Language"
+  s.requirements = "Ruby 2.x, eideticpdf"
+  s.add_runtime_dependency "eideticpdf", [">= 1.0.2"]
+  s.require_path = 'lib'
+  s.autorequire = 'erml'
+  s.email = "brent.rowland@eideticsoftware.com"
+  s.homepage = "http://www.eideticsoftware.com"
+  s.author = "Brent Rowland, Eidetic Software, LLC"
+  # s.rubyforge_project = "eideticrml"
+  # s.test_file = "test/pdf_tests.rb"
+  s.has_rdoc = false
+  # s.extra_rdoc_files = ['README']
+  # s.rdoc_options << '--title' << 'Eidetic RML' << '--main' << 'README' << '-x' << 'test'
+  s.files = FileList["lib/*.rb"] + ['Rakefile'] + FileList["test/test*.rb"] + FileList["samples/test*.erml*"] + ['samples/testimg.jpg']
+  s.platform = Gem::Platform::RUBY
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+desc "Clean up files generated by tests."
+task :clean do
+  rm Dir["*.pdf"]
+  rm Dir["samples/*.pdf"]
+  rm Dir["test/*.pdf"]
+end
+
+desc "Render test erml files to pdf."
+task :ermls do
+  start = Time.now
+  pdfs = []
+  require_relative 'lib/erml'
+  Dir["samples/*.erml","samples/*.haml","samples/*.erb"].each do |erml|
+    puts erml
+    pdfs << render_erml(erml)
+  end
+  elapsed = Time.now - start
+  puts "Elapsed: #{(elapsed * 1000).round} ms"
+  `open -a Preview #{pdfs * ' '}` if (RUBY_PLATFORM =~ /darwin/) and ($0 !~ /rake_test_loader/)
+end

data/lib/erml.rb

@@ -0,0 +1,345 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brent Rowland on 2008-01-06.
+#  Copyright (c) 2008 Eidetic Software. All rights reserved.
+
+$:.unshift File.expand_path(File.dirname(__FILE__))
+require 'erml_support'
+require 'erml_widgets'
+
+module EideticRML
+  STANDARD_ALIASES = [
+    { 'id' => 'h', 'tag' => 'p', 'font.weight' => 'Bold', 'text_align' => 'center', 'width' => '100%' }.freeze,
+    { 'id' => 'b', 'tag' => 'span', 'font.weight' => 'Bold' }.freeze,
+    { 'id' => 'i', 'tag' => 'span', 'font.style' => 'Italic' }.freeze,
+    { 'id' => 'u', 'tag' => 'span', 'underline' => 'true' }.freeze,
+    { 'id' => 'hbox', 'tag' => 'div', 'layout' => 'hbox' }.freeze,
+    { 'id' => 'vbox', 'tag' => 'div', 'layout' => 'vbox' }.freeze,
+    { 'id' => 'table', 'tag' => 'div', 'layout' => 'table' }.freeze,
+    { 'id' => 'layer', 'tag' => 'div', 'position' => 'relative', 'width' => '100%', 'height' => '100%' }.freeze,
+    { 'id' => 'br', 'tag' => 'label' }.freeze
+  ]
+
+  class StyleBuilder
+    def initialize(styles)
+      @styles = styles
+    end
+
+    def method_missing(id, *args)
+      @styles.add(id, *args)
+    end
+  end
+
+  class RuleBuilder
+    def initialize(rules)
+      @rules = rules
+    end
+
+    def rule(selector, attrs={})
+      @rules.add(selector, attrs)
+    end
+  end
+
+  class PageBuilder
+    undef_method :p
+
+    def initialize(doc)
+      @stack = [doc]
+      @tag_aliases = {}
+      EideticRML::STANDARD_ALIASES.each do |a|
+        a = a.dup
+        define(a.delete('id'), a['tag'], a)
+      end
+    end
+
+    def initialize_copy(other)
+      @stack = @stack.clone
+    end
+
+    def method_missing(id, *args, &block)
+      if current.respond_to?(id)
+        current.send(id, *args)
+        return current
+      else
+        tag, attrs = @tag_aliases[id.to_s] || [id.to_s, {}]
+        attrs = attrs.merge(fix_attrs(args.first))
+        attrs['tag'] = id unless tag == id
+        factory = Widgets::StdWidgetFactory.instance # TODO: select factory by namespace
+        raise ArgumentError, "Unknown tag: #{tag}." unless factory.has_widget?(tag)
+        widget = factory.make_widget(tag, current, attrs)
+        @stack.push(widget)
+        result = if block_given?
+          yield
+          current
+        else
+          self.clone
+        end
+        @stack.pop
+        return result
+      end
+    end
+
+    def define(new_tag, old_tag, attrs)
+      @tag_aliases[new_tag.to_s] = [old_tag.to_s, attrs.clone.freeze]
+    end
+
+  private
+    def current
+      @stack.last
+    end
+
+    def fix_attrs(attrs)
+      if attrs.nil?
+        {}
+      elsif attrs.respond_to?(:to_str)
+        { :text => attrs }
+      else
+        attrs
+      end
+    end
+  end
+
+  class Builder
+    attr_reader :doc
+
+    def initialize(&block)
+      @doc = Widgets::Document.new
+      self.instance_eval(&block) if block_given?
+    end
+
+    def styles(&block)
+      @styles ||= StyleBuilder.new(@doc.styles)
+      @styles.instance_eval(&block) if block_given?
+      @styles
+    end
+
+    def rules(&block)
+      @rules ||= RuleBuilder.new(@doc.rules)
+      @rules.instance_eval(&block)
+    end
+
+    def pages(attrs={}, &block)
+      @doc.attributes(attrs)
+      @pages ||= PageBuilder.new(@doc)
+      @pages.instance_eval(&block) if block_given?
+      @pages
+    end
+
+    def print(options={})
+      file = options[:file] || "#{File.basename($0, '.rb')}.pdf"
+      File.open(file,'w') { |f| f.write(@doc) }
+    end
+  end
+
+  class XmlStyleParser
+    undef_method :p
+
+    def initialize(stack, styles)
+      @stack, @styles = stack, styles
+      @stack.push styles
+    end
+
+    def method_missing(id, *args)
+      attrs = args.first.inject({}) { |attrs, kv| attrs[kv[0].to_sym] = kv[1]; attrs }
+      @styles.add(id, attrs)
+      @stack.push @styles
+    end
+
+    def text(text)
+      # no meaningful text in styles section
+    end
+  end
+
+  class XmlRuleParser
+    undef_method :p
+    undef_method :rule if self.private_methods.include?('rule')
+
+    def initialize(stack, rules)
+      @stack, @rules = stack, rules
+      @stack.push rules
+    end
+
+    def comment(text)
+      # puts "rule comment: #{text}"
+      Rules::Rule.parse(text).each { |rule| @rules.add(rule[0], rule[1]) }
+    end
+
+    def method_missing(id, *args)
+      @stack.push @rules.add(id, *args)
+    end
+
+    def text(text)
+      # no meaningful text in rules section
+    end
+  end
+
+  class XmlPageParser
+    COLLISIONS = [:p, :method]
+    COLLISIONS.each { |symbol| undef_method(symbol) }
+
+    def initialize(stack, doc)
+      @stack = stack
+      @stack.push doc
+      @tag_aliases = {}
+      STANDARD_ALIASES.each { |definition| define(definition) }
+    end
+
+    def method_missing(id, *args)
+      # puts "page method_missing: #{id}, #{args.inspect}"
+      if current.respond_to?(id) and !COLLISIONS.include?(id)
+        current.send(id, *args)
+        @stack.push(current)
+      else
+        tag, attrs = @tag_aliases[id.to_s] || [id.to_s, {}]
+        attrs = attrs.merge(args.first)
+        attrs['tag'] = id unless tag == id
+        factory = Widgets::StdWidgetFactory.instance # TODO: select factory by namespace
+        raise ArgumentError, "Unknown tag: #{tag}." unless factory.has_widget?(tag)
+        # puts "Making #{tag} with parent #{current.class}."
+        widget = factory.make_widget(tag, current, attrs)
+        @stack.push(widget)
+      end
+    end
+
+    def define(attrs)
+      attrs = attrs.dup
+      id, tag = attrs.delete('id').to_s, attrs['tag'].to_s
+      raise ArgumentError, "Invalid id for define: #{id}." unless id =~ /^(\w+)$/
+      raise ArgumentError, "Invalid tag for define: #{tag}." unless tag =~ /^(\w+)$/
+      @tag_aliases[id] = [tag, attrs.freeze]
+      @stack.push(current)
+    end
+
+    def text(text)
+      if current.respond_to?(:text)
+        current.text(text)
+      end
+    end
+
+  private
+    def current
+      @stack.last
+    end
+  end
+
+  class XmlParser
+    attr_reader :doc
+
+    def initialize
+      @doc = Widgets::Document.new
+    end
+
+    def self.parse(data)
+      require 'rexml/document'
+      parser = self.new
+      REXML::Document.parse_stream(data, parser)
+      parser.doc
+    end
+
+    def comment(text)
+      # puts "base comment: #{text}"
+      @parser.comment(text) if @parser.respond_to?(:comment)
+    end
+
+    def tag_start(name, attrs)
+      # puts "tag_start: #{name}"
+      if @parser.nil?
+        self.send(name, attrs)
+      else
+        @parser.send(name, attrs)
+      end
+    rescue Exception => e
+      raise ArgumentError,
+        "Error processing <%s>\n%s" % [attrs.inject(name) { |tag, (k, v)| tag << " #{k}=\"#{v}\"" }, e.message], e.backtrace
+    end
+
+    def tag_end(name)
+      # puts "tag_end: #{name}"
+      @stack.pop
+      @parser = nil if @stack.empty?
+    end
+
+    def text(text)
+      # puts "text: #{text.strip}"
+      @parser.text(text) unless @parser.nil?
+    end
+
+    def method_missing(id, *args)
+      # puts "missing: #{id}, #{args.inspect}"
+    end
+
+  private
+    def current
+      @stack.last
+    end
+
+    def erml(attrs)
+      @stack = []
+    end
+
+    def styles(attrs)
+      # puts "styles"
+      @parser = XmlStyleParser.new(@stack, @doc.styles)
+    end
+
+    def rules(attrs)
+      # puts "rules"
+      @parser = XmlRuleParser.new(@stack, @doc.rules)
+      if url = attrs['url']
+        text = open(url) { |f| f.read }
+        @parser.comment(text)
+      end
+    end
+
+    def pages(attrs)
+      # puts "pages"
+      @doc.attributes(attrs)
+      @parser = XmlPageParser.new(@stack, @doc)
+    end
+  end
+end
+
+def open_erml(erml, &block)
+  if erml =~ /\.erb$/
+    require 'erb'
+    require 'stringio'
+    source = open(erml) { |f| f.read }
+    result = ERB.new(source).result
+    sio = StringIO.new(result)
+    yield(sio)
+  elsif erml =~ /\.haml$/
+    require 'haml'
+    require 'stringio'
+    source = open(erml) { |f| f.read }
+    result = Haml::Engine.new(source).render
+    sio = StringIO.new(result)
+    yield(sio)
+  else
+    File.open(erml, &block)
+  end
+end
+
+def render_erml(erml)
+  doc = open_erml(erml) do |f|
+    begin
+      EideticRML::XmlParser.parse(f)
+    rescue Exception => e
+      $stderr.puts "Error in %s: %s\n%s" % [erml, e.message, e.backtrace.join("\n")]
+    end
+  end
+  unless doc.nil?
+    pdf = erml.sub(/\.erml(\.erb|\.haml)?$/, '') << '.pdf'
+    File.open(pdf, 'w') { |f| f.write(doc) }
+    return pdf
+  end
+end
+
+# ARGV.unshift "samples/test24.erml.erb" unless ARGV.size.nonzero?
+if $0 == __FILE__ and erml = ARGV.shift and File.exist?(erml)
+  begin
+    pdf = render_erml(erml)
+    `open -a Preview #{pdf}` if pdf and (RUBY_PLATFORM =~ /darwin/) and ($0 !~ /rake_test_loader/ and $0 !~ /rcov/)
+  rescue Exception => e
+    $stderr.puts e.message, e.backtrace.join("\n")
+  end
+end

data/lib/erml_layout_managers.rb

@@ -0,0 +1,667 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brent Rowland on 2008-01-06.
+#  Copyright (c) 2008 Eidetic Software. All rights reserved.
+
+require 'erml_support'
+
+module EideticRML
+  module LayoutManagers
+    class LayoutManager
+      def initialize(style)
+        @style = style
+      end
+
+      def row_grid(container)
+        grid = Support::Grid.new(container.children.size, 1)
+        container.children.each_with_index do |widget, index|
+          grid[index, 0] = widget
+        end
+        grid
+      end
+
+      def col_grid(container)
+        grid = Support::Grid.new(1, container.children.size)
+        container.children.each_with_index do |widget, index|
+          grid[0, index] = widget
+        end
+        grid
+      end
+
+      def layout(container, writer)
+        absolute_widgets = container.children.select { |widget| widget.position == :absolute }
+        layout_absolute(container, writer, absolute_widgets)
+        relative_widgets = container.children.select { |widget| widget.position == :relative }
+        layout_relative(container, writer, relative_widgets)
+        container.children.each { |widget| container.root_page.positioned_widgets[widget.position] += 1 if widget.visible and widget.leaf? }
+        # $stderr.puts "+++base+++ #{container.root_page.positioned_widgets[:static]}"
+      end
+
+      def layout_absolute(container, writer, widgets)
+        widgets.each do |widget|
+          widget.before_layout
+          widget.position(:absolute)
+          widget.left(0, :pt) if widget.left.nil? and widget.right.nil?
+          widget.top(0, :pt) if widget.top.nil? and widget.bottom.nil?
+          widget.width(widget.preferred_width(writer), :pt) if widget.width.nil?
+          widget.height(widget.preferred_height(writer), :pt) if widget.height.nil? # swapped
+          widget.layout_widget(writer)                                              # swapped
+        end
+      end
+
+      def layout_relative(container, writer, widgets)
+        widgets.each do |widget|
+          widget.before_layout
+          widget.position(:relative) if widget.position == :static
+          widget.left(0, :pt) if widget.left.nil? and widget.right.nil?
+          widget.top(0, :pt) if widget.top.nil? and widget.bottom.nil?
+          widget.width(widget.preferred_width(writer), :pt) if widget.width.nil?
+          widget.layout_widget(writer)
+          widget.height(widget.preferred_height(writer), :pt) if widget.height.nil?
+        end
+      end
+
+      def after_layout(container)
+      end
+
+      def self.register(name, klass)
+        (@@klasses ||= {})[name] = klass
+      end
+
+      def self.for_name(name)
+        @@klasses[name] unless @@klasses.nil?
+      end
+
+    protected
+      def printable_widgets(container, position)
+        dpgno, spgno = container.root.document_page_no, container.root.section_page_no
+        widgets, remaining = container.children.partition do |child|
+          (child.position == :static) and (!child.printed or child.display_for_page(dpgno, spgno))
+        end
+      end
+    end
+
+    class AbsoluteLayout < LayoutManager
+      register('absolute', self)
+
+      alias :grid :row_grid
+
+      def layout(container, writer)
+        layout_absolute(container, writer, container.children)
+      end
+
+      def preferred_height(grid, writer)
+        return grid.row(0).empty? ? 0 : nil
+      end
+
+      def preferred_width(grid, writer)
+        return grid.row(0).empty? ? 0 : nil
+      end
+    end
+
+    class FlowLayout < LayoutManager
+      register('flow', self)
+
+      alias :grid :row_grid
+
+      def layout(container, writer)
+        cx = cy = max_y = 0
+        container_full = false
+        bottom = container.content_top + container.max_content_height
+        widgets, remaining = printable_widgets(container, :static)
+        remaining.each { |widget| widget.visible = false if widget.printed }
+        widgets.each do |widget|
+          widget.visible = !container_full
+          next if container_full
+          widget.before_layout
+          widget.width([widget.preferred_width(writer) || container.content_width, container.content_width].min, :pt) if widget.width.nil?
+          # puts "flow widget width: #{widget.width} #{widget.path}"
+          if cx != 0 and cx + widget.width > container.content_width
+            cy += max_y + @style.vpadding
+            cx = max_y = 0
+          end
+          widget.left(container.content_left + cx, :pt)
+          widget.top(container.content_top + cy, :pt)
+          widget.height(widget.preferred_height(writer) || 0, :pt) if widget.height.nil? # swapped
+          widget.layout_widget(writer)                                                   # swapped
+          # if container.bottom and widget.bottom > container.bottom
+          if widget.bottom > bottom
+            container_full = true
+            # widget.visible = (cy == 0)
+            widget.visible = container.root_page.positioned_widgets[:static] == 0
+            # $stderr.puts "+++flow+++ #{container.root_page.positioned_widgets[:static]}, visible: #{widget.visible}"
+            next
+          end
+          container.root_page.positioned_widgets[widget.position] += 1
+          cx += widget.width + @style.hpadding
+          max_y = [max_y, widget.height].max
+        end
+        container.more(true) if container_full and container.overflow
+        container.height(cy + max_y + container.non_content_height, :pt) if container.height.nil? and max_y > 0
+        super(container, writer)
+      end
+
+      def preferred_height(grid, writer)
+        cells = grid.row(0)
+        return 0 if cells.empty?
+        cell_heights = cells.map { |w| w.preferred_height(writer) }
+        return nil unless cell_heights.all?
+        cell_heights.max
+      end
+
+      def preferred_width(grid, writer)
+        cells = grid.row(0)
+        return 0 if cells.empty?
+        cell_widths = cells.map { |w| w.preferred_width(writer) }
+        return nil unless cell_widths.all?
+        cell_widths.inject((cells.size - 1) * @style.hpadding) { |sum, width| sum + width }
+      end
+    end
+
+    class HBoxLayout < LayoutManager
+      register('hbox', self)
+
+      alias :grid :row_grid
+
+      def layout(container, writer)
+        container_full = false
+        widgets, remaining = printable_widgets(container, :static)
+        remaining.each { |widget| widget.visible = false if widget.printed }
+        static, relative = widgets.partition { |widget| widget.position == :static }
+        lpanels, unaligned = static.partition { |widget| widget.align == :left }
+        rpanels, unaligned = unaligned.partition { |widget| widget.align == :right }
+        percents, others = static.partition { |widget| widget.width_pct }
+        specified, others = others.partition { |widget| widget.width }
+
+        width_avail = container.content_width
+
+        # allocate specified widths first
+        specified.each do |widget|
+          width_avail -= widget.width
+          container_full = width_avail < 0
+          widget.disabled = container_full
+          width_avail -= @style.hpadding
+        end
+
+        # allocate percent widths next, with a minimum width of 1 point
+        if width_avail - (percents.size - 1) * @style.hpadding >= percents.size
+          width_avail -= (percents.size - 1) * @style.hpadding
+          total_percents = percents.inject(0) { |total, widget| total + widget.width }
+          ratio = width_avail.quo(total_percents)
+          percents.each do |widget|
+            widget.width(widget.width * ratio, :pt) if ratio < 1.0
+            width_avail -= widget.width
+          end
+        else
+          container_full = true
+          percents.each { |widget| widget.disabled = true }
+        end
+        width_avail -= @style.hpadding
+
+        # divide remaining width equally among widgets with unspecified widths
+        if width_avail - (others.size - 1) * @style.hpadding >= others.size
+          width_avail -= (others.size - 1) * @style.hpadding
+          others_width = width_avail.quo(others.size)
+          others.each { |widget| widget.width(others_width, :pt) }
+        else
+          container_full = true
+          others.each { |widget| widget.disabled = true }
+        end
+
+        static.each do |widget|
+          if container.align == :bottom
+            widget.bottom(container.content_bottom, :pt)
+          else
+            container_full = true
+            widget.top(container.content_top, :pt)
+          end
+          widget.height(widget.preferred_height(writer), :pt) if widget.height.nil?
+        end
+        left = container.content_left
+        right = container.content_right
+        lpanels.each do |widget|
+          next if widget.disabled
+          widget.left(left, :pt)
+          left += (widget.width + @style.hpadding)
+        end
+        rpanels.reverse.each do |widget|
+          next if widget.disabled
+          widget.right(right, :pt)
+          right -= (widget.width + @style.hpadding)
+        end
+        unaligned.each do |widget|
+          next if widget.disabled
+          widget.left(left, :pt)
+          left += (widget.width + @style.hpadding)
+        end
+        if container.height.nil?
+          content_height = static.map { |widget| widget.height }.max || 0
+          container.height(content_height + container.non_content_height, :pt)
+        end
+        static.each { |widget| widget.layout_widget(writer) if widget.visible and !widget.disabled }
+        super(container, writer)
+      end
+
+      def preferred_height(grid, writer)
+        cells = grid.row(0)
+        return 0 if cells.empty?
+        cell_heights = cells.map { |w| w.preferred_height(writer) }
+        return nil unless cell_heights.all?
+        cell_heights.max
+      end
+
+      def preferred_width(grid, writer)
+        cells = grid.row(0)
+        return 0 if cells.empty?
+        cell_widths = cells.map { |w| w.preferred_width(writer) }
+        return nil unless cell_widths.all?
+        cell_widths.inject((cells.size - 1) * @style.hpadding) { |sum, width| sum + width }
+      end
+    end
+
+    class VBoxLayout < LayoutManager
+      register('vbox', self)
+
+      alias :grid :col_grid
+
+      def layout(container, writer)
+        # $stderr.puts "layout container: #{container.tag}"
+        container_full = false
+        widgets, remaining = printable_widgets(container, :static)
+        remaining.each { |widget| widget.visible = false if widget.printed }
+        static, relative = widgets.partition { |widget| widget.position == :static }
+        headers, unaligned = static.partition { |widget| widget.align == :top }
+        footers, unaligned = unaligned.partition { |widget| widget.align == :bottom }
+        static.each do |widget|
+          widget.before_layout
+          # puts "<1> vbox widget width: #{widget.width} #{widget.path}"
+          widget.width([widget.preferred_width(writer) || container.content_width, container.content_width].min, :pt) if widget.width.nil?
+          # puts "<2> vbox widget width: #{widget.width} #{widget.path}"
+          widget.left(container.content_left, :pt)
+        end
+        top, dy = container.content_top, 0
+        bottom = container.content_top + container.max_content_height
+
+        headers.each_with_index do |widget, index|
+          widget.top(top, :pt)
+          widget.layout_widget(writer)                                              # swapped
+          widget.height(widget.preferred_height(writer), :pt) if widget.height.nil? # swapped
+          top += (widget.height + @style.vpadding)
+          dy += widget.height + ((index > 0) ? @style.vpadding : 0)
+        end
+        headers.each { |widget| widget.visible = (widget.bottom <= bottom) } # or first static widget?
+
+        unless footers.empty?
+          container.height('100%') if container.height.nil?
+          footers.reverse.each do |widget|
+            widget.bottom(bottom, :pt)
+            widget.layout_widget(writer)                                              # swapped
+            widget.height(widget.preferred_height(writer), :pt) if widget.height.nil? # swapped
+            bottom -= (widget.height + @style.vpadding)
+          end
+        end
+        footers.each { |widget| widget.visible = (widget.top >= top) } # or first static widget?
+
+        widgets_visible = 0
+        unaligned.each_with_index do |widget, index|
+          widget.visible = !container_full
+          next if container_full
+          widget.top(top, :pt)
+          # puts "<1> vbox widget height: #{widget.height} #{widget.path}"
+          widget.layout_widget(writer)                                              # swapped
+          # puts "<2> vbox widget height: #{widget.height} #{widget.path}"
+          widget.height(widget.preferred_height(writer), :pt) if widget.height.nil? # swapped
+          # puts "<3> vbox widget height: #{widget.height} #{widget.path}"
+          top += widget.height
+          dy += widget.height + (index > 0 ? @style.vpadding : 0) #if widget.visible
+          if top > bottom
+            container_full = true
+            widget.visible = (widgets_visible == 0)
+            # widget.visible = widget.leaves > 0 and container.root_page.positioned_widgets[:static] == 0
+            # $stderr.puts "+++vbox+++ #{container.root_page.positioned_widgets[:static]}, tag: #{widget.tag}, visible: #{widget.visible}"
+          end
+          widgets_visible += 1 if widget.visible
+          top += @style.vpadding
+        end
+        # set_height = container.height.nil?
+        # container.height(container.max_height_avail, :pt) if set_height
+        # unaligned.each_with_index do |widget, index|
+        #   # widget.visible = (widget.bottom <= bottom) || (index == 0) #|| (container.overflow && widget.top < bottom)
+        #   widget.visible = (widget.bottom <= bottom) || (container.root_page.positioned_widgets[:static] == 0) #|| (container.overflow && widget.top < bottom)
+        #   # if widget.visible and widget.bottom > bottom and container.overflow
+        #   #   widget.layout_widget(writer)
+        #   # end
+        # end
+
+        container_full = unaligned.last && !unaligned.last.visible
+        container.more(true) if container_full and container.overflow
+        # container.height(top - container.content_top + @style.vpadding, :pt) if container.height.nil?
+        # container.height(dy + container.non_content_height, :pt) if container.height.nil?
+        super(container, writer)
+      end
+
+      def preferred_height(grid, writer)
+        cells = grid.col(0)
+        return 0 if cells.empty?
+        cell_heights = cells.map { |w| w.preferred_height(writer) }
+        return nil unless cell_heights.all?
+        cell_heights.inject((cells.size - 1) * @style.vpadding) { |sum, height| sum + height }
+      end
+
+      def preferred_width(grid, writer)
+        cells = grid.col(0)
+        return 0 if cells.empty?
+        cell_widths = cells.map { |w| w.preferred_width(writer) }
+        return nil unless cell_widths.all?
+        cell_widths.max
+      end
+
+      # def after_layout(container)
+      #   container.children.each do |widget|
+      #     if widget.visible and widget.position == :static
+      #       if widget.bottom > container.content_bottom
+      #         widget.disabled = !container.overflow
+      #       end
+      #       # widget.after_layout if widget.visible
+      #     end
+      #   end
+      # end
+    end
+
+    class TableLayout < LayoutManager
+      register('table', self)
+
+    private
+      ROW_SPAN   = 0
+      COL_SPAN   = 0
+      ROW_HEIGHT = 1
+      COL_WIDTH  = 1
+      def mark_grid(grid, a, b, c, d, value)
+        c.times do |aa|
+          d.times do |bb|
+            grid[a + aa, b + bb] = value if aa > 0 or bb > 0
+          end
+        end
+      end
+
+      def row_grid(container)
+        raise ArgumentError, "cols must be specified." if container.cols.nil?
+        static = printable_widgets(container, :static).first
+        grid = Support::Grid.new(container.cols, 0)
+        row = col = 0
+        static.each do |widget|
+          while grid[col, row] == false
+            col += 1
+            if col >= container.cols then row += 1; col = 0 end
+          end
+          grid[col, row] = widget
+          mark_grid(grid, col, row, widget.colspan, widget.rowspan, false)
+          col += widget.colspan
+          raise ArgumentError, "colspan causes number of columns to exceed table size." if col > container.cols
+          if col == container.cols then row += 1; col = 0 end
+        end
+        grid
+      end
+
+      def col_grid(container)
+        raise ArgumentError, "rows must be specified." if container.rows.nil?
+        static = printable_widgets(container, :static).first
+        grid = Support::Grid.new(0, container.rows)
+        row = col = 0
+        static.each do |widget|
+          while grid[col, row] == false
+            row += 1
+            if row >= container.rows then col += 1; row = 0 end
+          end
+          if row >= container.rows then col += 1; row = 0 end
+          grid[col, row] = widget
+          mark_grid(grid, col, row, widget.colspan, widget.rowspan, false)
+          row += widget.rowspan
+          raise ArgumentError, "rowspan causes number of rows to exceed table size." if row > container.rows
+        end
+        grid
+      end
+
+      def detect_widths(grid, writer)
+        widths = []
+        grid.cols.times do |c|
+          col = grid.col(c)
+          widget = col.detect { |w| w and (w.colspan == 1) }
+          if widget.nil?
+            widths << [:unspecified, 0]
+          elsif widget.width_pct
+            widths << [:percent, widget.width]
+          elsif widget.width
+            widths << [:specified, widget.width]
+          else
+            widths << [:unspecified, col.map { |w| w ? w.preferred_width(writer) : 0 }.max]
+          end
+        end
+        widths
+      end
+
+      def allocate_specified_widths(width_avail, specified)
+        specified.each do |w|
+          if width_avail < w[COL_WIDTH]
+            # w[COL_WIDTH] = 0
+          else
+            width_avail -= (w[COL_WIDTH] + @style.hpadding)
+          end
+        end
+        width_avail
+      end
+
+      def allocate_percent_widths(width_avail, percents)
+        # allocate percent widths with a minimum width of 1 point
+        if width_avail - (percents.size - 1) * @style.hpadding >= percents.size
+          width_avail -= (percents.size - 1) * @style.hpadding
+          total_percents = percents.inject(0) { |total, w| total + w[COL_WIDTH] }
+          ratio = width_avail.quo(total_percents)
+          percents.each do |w|
+            w[COL_WIDTH] = w[COL_WIDTH] * ratio if ratio < 1.0
+            width_avail -= w[COL_WIDTH]
+          end
+        else
+          percents.each { |w| w[COL_WIDTH] = 0 }
+        end
+        width_avail -= @style.hpadding
+        width_avail
+      end
+
+      def allocate_other_widths(width_avail, others)
+        # divide remaining width equally among widgets with unspecified widths
+        if width_avail - (others.size - 1) * @style.hpadding >= others.size
+          width_avail -= (others.size - 1) * @style.hpadding
+          others_width = width_avail.quo(others.size)
+          others.each { |w| w[COL_WIDTH] = others_width }
+        else
+          others.each { |w| w[COL_WIDTH] = 0 }
+        end
+        width_avail
+      end
+
+      def layout_grid(grid, container, writer)
+        container_full = false
+        widths = detect_widths(grid, writer)
+        if container.width.nil?
+          puts "Noooooooo!!!!"
+        end
+        percents, others = widths.partition { |w| w[0] == :percent }
+        specified, others = others.partition { |w| w[0] == :specified }
+
+        width_avail = container.content_width
+        width_avail = allocate_specified_widths(width_avail, specified)
+        width_avail = allocate_percent_widths(width_avail, percents)
+        width_avail = allocate_other_widths(width_avail, others)
+
+        heights = Support::Grid.new(grid.cols, grid.rows)
+        grid.cols.times do |c|
+          grid.col(c).each_with_index do |widget, r|
+            next unless widget
+            if widths[c][COL_WIDTH] > 0
+              width = (0...widget.colspan).inject(0) { |width, i| width + widths[c + i][COL_WIDTH] }
+              widget.width(width + (widget.colspan - 1) * @style.hpadding, :pt)
+            else
+              # widget.visible = false
+              widget.disabled = true
+              next
+            end
+            heights[c, r] = [widget.rowspan, widget.height || widget.preferred_height(writer)]
+          end
+        end
+
+        heights.rows.times do |r|
+          row_heights = (0...heights.cols).map { |c| heights[c,r] }.compact
+          min_rowspan = row_heights.map { |rowspan, height| rowspan }.min
+          min_rowspan_heights = row_heights.select { |rowspan, height| rowspan == min_rowspan }
+          max_height = min_rowspan_heights.map { |rowspan, height| height }.max
+          heights.cols.times do |c|
+            rh = heights[c,r]
+            next if rh.nil?
+            if rh[ROW_SPAN] > min_rowspan
+              heights[c,r+1] = [rh[ROW_SPAN] - 1, [rh[ROW_HEIGHT] - max_height, 0].max]
+            end
+            rh[ROW_HEIGHT] = max_height
+          end
+        end
+
+        top = container.content_top
+        bottom = container.content_top + container.max_content_height
+        grid.rows.times do |r|
+          max_height = 0
+          left = container.content_left
+          grid.cols.times do |c|
+            if widget = grid[c, r]
+              widget.visible = !container_full
+              next if container_full
+              rh = heights[c,r]
+              next if rh.nil?
+              widget.top(top, :pt)
+              widget.left(left, :pt)
+              height = (0...rh[ROW_SPAN]).inject((rh[ROW_SPAN] - 1) * @style.vpadding) { |height, row_offset| height + heights[c,r+row_offset][ROW_HEIGHT] }
+              widget.height(height, :pt)
+              max_height = [max_height, rh[ROW_HEIGHT]].max if rh[ROW_SPAN] == 1
+            end
+            left += widths[c][1] + @style.hpadding
+          end
+          next if container_full
+          if top + max_height > bottom
+            container_full = true
+            grid.cols.times { |c| grid[c, r].visible = (r == 0) if grid[c, r] }
+            container.more(true) if container.overflow and (r > 0)
+          end
+          top += max_height + @style.vpadding unless container_full
+        end
+        if container.height.nil?
+          container.height(top - container.content_top + container.non_content_height - @style.vpadding, :pt)
+        end
+        static, remaining = printable_widgets(container, :static)
+        remaining.each { |widget| widget.visible = false if widget.printed }
+        static.each { |widget| widget.layout_widget(writer) }
+      end
+
+    public
+      def grid(container)
+        if container.order == :rows
+          row_grid(container)
+        else # container.order == :cols
+          col_grid(container)
+        end
+      end
+
+      def layout(container, writer)
+        layout_grid(grid(container), container, writer)
+        super(container, writer)
+      end
+
+      def preferred_height(grid, writer)
+        # calculate preferred heights, where available
+        heights = Support::Grid.new(grid.cols, grid.rows)
+        return 0 if heights.cols == 0 or heights.rows == 0
+        grid.cols.times do |c|
+          grid.col(c).each_with_index do |widget, r|
+            next unless widget
+            # heights[c, r] = [widget.rowspan, widget.has_height? ? widget.preferred_height(writer) : nil]
+            heights[c, r] = [widget.rowspan, widget.preferred_height(writer)]
+          end
+        end
+
+        heights.rows.times do |r|
+          row_heights = (0...heights.cols).map { |c| heights[c,r] }.compact
+          min_rowspan = row_heights.map { |rowspan, height| rowspan }.min
+          min_rowspan_heights = row_heights.select { |rowspan, height| rowspan == min_rowspan }
+          max_height = min_rowspan_heights.map { |rowspan, height| height }.compact.max
+          # at least one cell must specify a height
+          return nil if max_height.nil?
+          heights.cols.times do |c|
+            rh = heights[c,r]
+            next if rh.nil?
+            # carry height in excess of max height of cells with min_rowspan to cell in next row, subtracting vpadding
+            if rh[ROW_SPAN] > min_rowspan
+              heights[c,r+1] = [rh[ROW_SPAN] - 1, [rh[ROW_HEIGHT] - max_height - @style.vpadding, 0].max]
+            end
+            rh[ROW_HEIGHT] = max_height
+          end
+        end
+
+        result = 0
+        grid.rows.times do |r|
+          max_height = 0
+          grid.cols.times do |c|
+            if (widget = grid[c, r]) and (rh = heights[c,r])
+              height = (0...rh[ROW_SPAN]).inject((rh[ROW_SPAN] - 1) * @style.vpadding) { |height, row_offset| height + heights[c,r+row_offset][ROW_HEIGHT] }
+              max_height = [max_height, rh[ROW_HEIGHT]].max if rh[ROW_SPAN] == 1
+            end
+          end
+          result += max_height + @style.vpadding
+        end
+        result -= @style.vpadding if result > 0
+      end
+
+      def preferred_width(grid, writer)
+        # calculate preferred widths, where available
+        widths = Support::Grid.new(grid.cols, grid.rows)
+        return 0 if widths.cols == 0 or widths.rows == 0
+        grid.rows.times do |r|
+          grid.row(r).each_with_index do |widget, c|
+            next unless widget
+            # widths[c, r] = [widget.colspan, widget.has_width? ? widget.preferred_width(writer) : nil]
+            widths[c, r] = [widget.colspan, widget.preferred_width(writer)]
+          end
+        end
+
+        widths.cols.times do |c|
+          col_widths = (0...widths.rows).map { |r| widths[c,r] }.compact
+          min_colspan = col_widths.map { |colspan, width| colspan }.min
+          min_colspan_widths = col_widths.select { |colspan, width| colspan == min_colspan }
+          max_width = min_colspan_widths.map { |colspan, width| width }.compact.max
+          # at least one cell must specify a width
+          return nil if max_width.nil?
+          widths.rows.times do |r|
+            cw = widths[c,r]
+            next if cw.nil?
+            # carry width in excess of max width of cells with min_colspan to cell in next col, subtracting hpadding
+            if cw[COL_SPAN] > min_colspan
+              widths[c+1,r] = [cw[COL_SPAN] - 1, [cw[COL_WIDTH] - max_width - @style.hpadding, 0].max]
+            end
+            cw[COL_WIDTH] = max_width
+          end
+        end
+
+        result = 0
+        grid.cols.times do |c|
+          max_width = 0
+          grid.rows.times do |r|
+            if (widget = grid[c, r]) and (cw = widths[c, r])
+              width = (0...cw[COL_SPAN]).inject((cw[COL_SPAN] - 1) * @style.hpadding) { |width, col_offset| width + widths[c+col_offset,r][COL_WIDTH] }
+              max_width = [max_width, cw[COL_WIDTH]].max if cw[COL_SPAN] == 1
+            end
+          end
+          result += max_width + @style.hpadding
+        end
+        result -= @style.hpadding if result > 0
+        result
+      end
+    end
+  end
+end