htmlgrid 1.1.1 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c5d30addff4506799b90228f01a9c910f6231967
-  data.tar.gz: d96e8a7d27da7aab4acaf1458a334bbf89c76af2
+SHA256:
+  metadata.gz: 499db7822b7a9628ffc8a755339c9498e727b60711b38c3433bf62340919dbcc
+  data.tar.gz: a742bdfd63e8a2bfe70d52b0912b68b3372194f182edaa9030f4db3b05034c48
 SHA512:
-  metadata.gz: 7be2249769ff2f267ff89af97188e897c89e87d79403e71cb24658f315cf09d25211f756db822aec048da2ecf6fdc166c74a82b1c734b570b0cae68bec642754
-  data.tar.gz: b6995921b53ae767df96a8fabdd97e3d7de0396e1a5a3626e88e7ed7d5259c9c84cd97de5e1f54ec26c00b3e7898499fa17f242cf31fb60fef9d9f7e98f86a8a
+  metadata.gz: d95e0f3b698b69bf8e3aaa9a8f84b2d79e28428e28b357512bfb74860b1dba3134b458fc9c7fbd62843ae570f228f3f8408bf0a033bd3b0e56c3de07284f5e08
+  data.tar.gz: 759170973e867985a62c8a1155d11dbcead9cafcade750f8d9089e1843544b8a6f04018741ec4dd9a1c8b1aff0f787700dcb194e4004303c7a60bb87d68a34e0

data/Manifest.txt

@@ -2,11 +2,10 @@
 .travis.yml
 COPYING
 Gemfile
-Gemfile.lock
 History.txt
 LICENCE.txt
 Manifest.txt
-README.textile
+README.md
 Rakefile
 ext/htmlgrid/MANIFEST
 ext/htmlgrid/extconf.rb
@@ -65,7 +64,6 @@ lib/htmlgrid/ulcomposite.rb
 lib/htmlgrid/ullist.rb
 lib/htmlgrid/urllink.rb
 lib/htmlgrid/value.rb
-test/rebuild.rb
 test/stub/cgi.rb
 test/test_component.rb
 test/test_composite.rb
@@ -79,5 +77,6 @@ test/test_list.rb
 test/test_select.rb
 test/test_template.rb
 test/test_text.rb
+test/test_helper.rb
 usage-en.txt
 widget/Tooltip.js

data/lib/htmlgrid/component.rb

@@ -22,8 +22,8 @@
 #	ywesee - intellectual capital connected, Winterthurerstrasse 52, CH-8006 Zuerich, Switzerland
 #	htmlgrid@ywesee.com, www.ywesee.com/htmlgrid
 #
-# HtmlGrid::Component -- htmlgrid -- 23.12.2012 -- mhatakeyama@ywesee.com 
-# HtmlGrid::Component -- htmlgrid -- 23.10.2002 -- hwyss@ywesee.com 
+# HtmlGrid::Component -- htmlgrid -- 23.12.2012 -- mhatakeyama@ywesee.com
+# HtmlGrid::Component -- htmlgrid -- 23.10.2002 -- hwyss@ywesee.com
 #++
 
 module HtmlGrid
@@ -72,7 +72,7 @@ module HtmlGrid
 			83	=>	"Sigma",    		115	=>	"sigma",
 			84	=>	"Tau",      		116	=>	"tau",
 			85	=>	"Upsilon",  		117	=>	"upsilon",
-			86	=>	"sigmaf",   		
+			86	=>	"sigmaf",
 			87	=>	"Omega",    		119	=>	"omega",
 			88	=>	"Xi",       		120	=>	"xi",
 			89	=>	"Psi",      		121	=>	"psi",
@@ -163,7 +163,7 @@ module HtmlGrid
 		end
 		# escape '&', '<' and '>' characters in txt
 		def escape(txt)
-			@@html_entities.inject(txt.to_s.dup) { |str, map| 
+			@@html_entities.inject(txt.to_s.dup) { |str, map|
 				char, entity = map
 				str.gsub!(char, '&' << entity << ';')
 				str
@@ -213,8 +213,8 @@ module HtmlGrid
 		def tabindex=(tab)
 			@attributes.store('tabIndex', tab.to_s)
 		end
-		def to_html(context)
-      _to_html(context, @value).to_s.force_encoding('utf-8')
+    def to_html(context)
+      _to_html(context, @value).to_s.encode('utf-8')
     end
     @@nl2br_ptrn = /(\r\n)|(\n)|(\r)/
 		def _to_html(context, value=@value)
@@ -223,7 +223,7 @@ module HtmlGrid
 			elsif(value.respond_to?(:to_html))
 				value.to_html(context).to_s.force_encoding('utf-8')
 			else
-				value.to_s.gsub(@@nl2br_ptrn, '<br>')
+        value =CGI.unescape(value) if value && value.is_a?(String)
 			end
 		end
 		private

data/lib/htmlgrid/composite.rb

@@ -51,6 +51,21 @@ module HtmlGrid
 		CSS_ID = nil
 		DEFAULT_CLASS = Value
 		LOOKANDFEEL_MAP = {}
+
+    def self.component(klass, key, name=nil)
+      methname = klass.to_s.downcase.gsub('::', '_') << '_' << key.to_s
+      define_method(methname) { |*args|
+        model, session = args
+        args = [model.send(key), session || @session, self]
+        if(name)
+          args.unshift(name)
+          lookandfeel_map.store(methname.to_sym, name.to_sym)
+        end
+        klass.new(*args)
+      }
+      methname.to_sym
+    end
+
 		def init
 			super
 			setup_grid()
@@ -102,19 +117,6 @@ module HtmlGrid
 		def symbol_map
 			@symbol_map ||= self::class::SYMBOL_MAP.dup
 		end
-		def AbstractComposite.component(klass, key, name=nil)
-			methname = klass.to_s.downcase.gsub('::', '_') << '_' << key.to_s
-			define_method(methname) { |*args|
-				model, session = args
-				args = [model.send(key), @session, self]
-				if(name)
-					args.unshift(name)
-					lookandfeel_map.store(methname.to_sym, name.to_sym)
-				end
-				klass.new(*args)
-			}
-			methname.to_sym
-		end
 	end
 	class TagComposite < AbstractComposite
 		def compose(model=@model)

data/lib/htmlgrid/dojotoolkit.rb

@@ -5,12 +5,12 @@
 
 require 'htmlgrid/component'
 require 'htmlgrid/div'
+require 'htmlgrid/template'
 
 module HtmlGrid
   class Component
     @@msie_ptrn = /MSIE\s*(\d)/
     attr_accessor :dojo_tooltip
-    # DOJO_VERSION >= 1.7.0 only (removed old version support)
     def dojo_tag(widget, args={}, inner_html='')
       div = HtmlGrid::Div.new(@model, @session, self)
       div.set_attribute('data-dojo-type', widget)
@@ -38,24 +38,22 @@ module HtmlGrid
       def dynamic_html(context)
         html = ''
         attrs = {
-          # NOTE:
-          #   DOJO >= 1.8 has support for type name separated by '/'
-          #   but, <= 1.7 must be separated with '.'
-          'data-dojo-type'  => 'dijit.Tooltip',
-          'data-dojo-props' => "connectId:'#{css_id}'",
+          'data-dojo-type'  => 'dijit/TooltipDialog',
+          'data-dojo-props' => "connectId:#{css_id}",
           'id'              => "#{css_id}_widget",
           'style'           => 'display: none',
         }
-        unless match = @@msie_ptrn.match(@session.user_agent) \
+        unless (match = @@msie_ptrn.match(@session.user_agent)) \
                && match[1].to_i < 7
           attrs.update({
             'toggle'         => 'fade',
             'toggleDuration' => '500',
           })
         end
+        @dojo_tooltip ||= nil
         if @dojo_tooltip.is_a?(String)
           if @dojo_tooltip !~ /^http/ # e.g. javascript
-            attrs.store('href', "'#@dojo_tooltip'")
+            attrs.store('href', "#@dojo_tooltip")
           else
             attrs.store('href', @dojo_tooltip)
           end
@@ -65,9 +63,7 @@ module HtmlGrid
           html << @dojo_tooltip.to_html(context).force_encoding('utf-8')
         end
         unless html.empty? || dojo_parse_on_load
-          html << context.script('type' => 'text/javascript') {
-            "dojoConfig.searchIds.push('#{css_id}')"
-          }
+          html << context.script('type' => 'text/javascript') { "dojoConfig.searchIds.push('#{css_id}')" }
         end
         # call original dynamic_html
         dojo_dynamic_html(context) << html
@@ -76,7 +72,7 @@ module HtmlGrid
   end
 	module DojoToolkit
 		module DojoTemplate
-			DOJO_DEBUG = false
+			DOJO_DEBUG = true
 			DOJO_BACK_BUTTON = false
       DOJO_ENCODING = nil
       DOJO_PARSE_ON_LOAD = true
@@ -95,53 +91,30 @@ module HtmlGrid
             "{ name: '#{prefix}', location: '#{path}' }"
           }.join(",")
         end
-        config = [
-          "parseOnLoad:          #{self.class::DOJO_PARSE_ON_LOAD}",
-          "isDebug:              #{self.class::DOJO_DEBUG}",
-          "preventBackButtonFix: #{!self.class::DOJO_BACK_BUTTON}",
-          "bindEncoding:         '#{encoding}'",
-          "searchIds:            []",
-          "async:                true",
-          "urchin:               ''",
+        puts "dynamic_html_headers with pkgs: #{packages}"
+        config =config = [
           "has: {
-             'dojo-firebug':        #{self.class::DOJO_DEBUG},
-             'dojo-debug-messages': #{self.class::DOJO_DEBUG}
+             'dojo-debug-messages': true
           }",
-          "packages: [ #{packages} ]"
         ].join(',')
-        args.store('data-dojo-config', config)
-        args.store('src', dojo_path)
+        headers << %(<script>
+       var dojoConfig = {
+            parseOnLoad: true,
+            isDebug: true,
+            async: true,
+            urchin: '',
+        };
+</script>)
         headers << context.script(args)
-        args = { 'type' => 'text/javascript' }
-        headers << context.script(args) {
-          package_paths = self.class::DOJO_REQUIRE.map { |req|
-            "'#{req}'"
-          }.join(',')
-          package_names = self.class::DOJO_REQUIRE.map { |req|
-            req.split('/').last
-          }.join(',')
-          if @dojo_onloads
-            onloads = ''
-            @dojo_onloads.each { |onload|
-              onloads << "#{onload}\n"
-            }
-            script =
-            "require([#{package_paths}], function(#{package_names}) {" \
-              "ready(function() {" \
-                "#{onloads}" \
-              "});" \
-            "});"
+        {  'text/css'         => File.join(File.dirname(dojo_path), "/resources/dojo.css"),
+           'text/javascript'  => dojo_path,
+        }.each do |type, path|
+          if (content = get_inline(path))
+            headers << context.style(:type =>type) { content }
           else
-            script = "require([#{package_paths}]);"
+            headers << context.style(:type =>type, :src => path) { "@import \"#{path}\";" }
           end
-          script
-        }
-        dojo_dir = File.dirname(dojo_path)
-        headers << context.style(:type => "text/css") { <<-EOS
-          @import "#{File.join(dojo_dir, "/resources/dojo.css")}";
-          @import "#{File.join(dojo_dir, "../dijit/themes/tundra/tundra.css")}";
-        EOS
-        }
+        end
         headers
       end
       def dojo_parse_on_load

data/lib/htmlgrid/errormessage.rb

@@ -61,7 +61,7 @@ module HtmlGrid
 		end
 		def __messages(ary, css_class, ypos=0)
 			ary.sort_by { |item|
-				(components.index(item.key) || [-1,-1]).reverse
+				(components.key(item.key) || [-1,-1]).reverse
 			}.reverse.each { |item|
 				__message(item, css_class, ypos)
 			}

data/lib/htmlgrid/grid.rb

@@ -24,285 +24,268 @@
 #
 # HtmlGrid::Grid -- htmlgrid -- 23.02.2012 -- mhatakeyama@ywesee.com
 # HtmlGrid::Grid -- htmlgrid -- 12.01.2010 -- hwyss@ywesee.com
-require 'htmlgrid/version'
-begin
-  VERSION = '1.0.8'
-  begin
-    # for gem install
-    ext_dir = File.expand_path('../../ext/htmlgrid', File.dirname(__FILE__))
-    ext_lib = File.join(ext_dir, 'htmlgrid.so')
-    require ext_lib
-  rescue LoadError
-    # for setup.rb install
-    require 'htmlgrid.so'
-  end
-rescue LoadError
-	puts "could not find htmlgrid.so, falling back to pure-ruby class"
-	module HtmlGrid
-		class Grid 
-			attr_accessor :width, :height
-			private
-			class Row
-				class Field
-					attr_reader :components
-					attr_accessor :tag
-					ALLOWED_ATTRIBUTES = [
-						'align',
-						'class',
-						'colspan',
-						'style',
-						'tag',
-						'title',
-					]
-					def initialize
-						@components = []
-						@attributes = {}
-					end
-					def add(item)
-						if(item.is_a? Array)
-							@components += item
-						else
-							@components.push item
-						end
-					end
-					def add_background
-						compose
-						@components.each { |component| 
-							component.add_background
-						}
-						if(@attributes["class"])
-							@attributes["class"] += "-bg" unless @attributes["class"] =~ /-bg/
-						else
-							@attributes["class"] = "bg"
-						end
-					end
-					def add_attribute(key, value)
-						@attributes.store(key.to_s, value.to_s)
-					end
-					def add_component_style(style)
-						@components.each { |cmp| 
-							cmp.set_attribute("class", style) if cmp.respond_to?(:set_attribute)
-						}
-					end
-					def add_style(style)
-						@attributes["class"] = style
-					end
-					def attribute(key)
-						@attributes[key]
-					end
-					def colspan
-						@attributes.fetch("colspan", 1).to_i
-					end
-					def colspan=(span)
-						@attributes["colspan"] = span.to_s if span.to_i > 1
-					end
-					def component_html(cgi)
-						html = ''
-						@components.each { |component|
-							if component.respond_to? :to_html
-								html << component.to_html(cgi).to_s.force_encoding('utf-8')
-							else
-								html << component.to_s
-							end
-						}
-						html = "&nbsp;" if html.empty?
-						html
-					end
-					def tag=(tag)
-						@tag = tag.to_s.downcase
-					end
-					def to_html(context)
-						if(@tag && context.respond_to?(@tag))
-							context.send(@tag, @attributes) { 
-								component_html(context) }
-						else
-							context.td(@attributes) {
-								component_html(context) }
-						end
-					end
-				end
-				def initialize # Row
-					@width = 1
-					@fields = [Field.new]
-					@attributes = {}
-				end
-				def initialize_row w
-					if(w > @width)
-						@width.upto(w-1) { |ii| @fields[ii] ||= Field.new }
-						@width = w
-					end
-				end
-				def add(item, x)
-					(@fields[x] ||= Field.new).add item
-				end
-				def each_field(x, w=1)
-					x.upto([x+w, @width].min - 1) { |xx|
-						yield(@fields[xx])
-					}
-				end
-				def to_html cgi
-					cgi.tr(@attributes) {
-						field_html(cgi)
-					}
-				end
-				def field_attribute(key, x=0)
-					@fields[x].attribute(key)
-				end
-				def field_html(cgi)
-					html = ""
-					span = 1
-					@fields.each { |field|
-						if(span < 2)
-							html << field.to_html(cgi)
-							span = field.colspan
-						else
-              span -= 1
-						end
-					}
-					html
-				end
-				def set_attributes(attr)
-					@attributes = attr
-				end
-				def [](x)
-					begin
-						@fields[x]
-					rescue StandardError
-						nil
-					end
-				end
-			end
-			public
-			def initialize(attributes={}) # Grid
-				@height = 1
-				@width = 1
-				@rows = [Row.new]
-				@attributes = {
-					"cellspacing" =>  "0",
-				}.update(attributes)
-			end
-			def initialize_grid(w, h)
-				if(w > @width || h > @height)
-					floor = (w > @width) ? 0 : @height
-					@width = [w, @width].max
-					@height = [h, @height].max
-					floor.upto(@height - 1) { |ii|
-						(@rows[ii] ||= Row.new).initialize_row(@width)
-					}
-				end
-			end
-			def add(arg, x, y, col=false)
-				if arg.kind_of? Enumerable
-          if arg.kind_of? String
-            add_field(arg, x, y)
-          elsif arg.kind_of? Array
-            arg.each do |item|
-              add_field(item, x ? x : '', y)
-            end
+module HtmlGrid
+  class Grid
+    attr_accessor :width, :height
+    private
+    class Row
+      class Field
+        attr_reader :components, :tag
+        ALLOWED_ATTRIBUTES = [
+          'align',
+          'class',
+          'colspan',
+          'style',
+          'tag',
+          'title',
+        ]
+        def initialize
+          @components = []
+          @attributes = {}
+          @tag = nil
+        end
+        def add(item)
+          if(item.is_a? Array)
+            @components += item
           else
-            if(col)
-              add_column(arg, x, y)
+            @components.push item
+          end
+        end
+        def add_background
+          compose
+          @components.each { |component| 
+            component.add_background
+          }
+          if(@attributes["class"])
+            @attributes["class"] += "-bg" unless @attributes["class"] =~ /-bg/
+          else
+            @attributes["class"] = "bg"
+          end
+        end
+        def add_attribute(key, value)
+          @attributes.store(key.to_s, value.to_s)
+        end
+        def add_component_style(style)
+          @components.each { |cmp| 
+            cmp.set_attribute("class", style) if cmp.respond_to?(:set_attribute)
+          }
+        end
+        def add_style(style)
+          @attributes["class"] = style
+        end
+        def attribute(key)
+          @attributes[key]
+        end
+        def colspan
+          @attributes.fetch("colspan", 1).to_i
+        end
+        def colspan=(span)
+          @attributes["colspan"] = span.to_s if span.to_i > 1
+        end
+        def component_html(cgi)
+          html = ''
+          @components.each { |component|
+            if component.respond_to? :to_html
+              html << component.to_html(cgi).to_s.dup.force_encoding('utf-8')
             else
-              add_row(arg, x, y)
+              html << component.to_s
             end
+          }
+          html = "&nbsp;" if html.empty?
+          html
+        end
+        def tag=(tag)
+          @tag = tag.to_s.downcase
+        end
+        def to_html(context)
+          if(@tag && context.respond_to?(@tag))
+            context.send(@tag, @attributes) { 
+              component_html(context) }
+          else
+            context.td(@attributes) {
+              component_html(context) }
           end
-        else
+        end
+      end
+      def initialize # Row
+        @width = 1
+        @fields = [Field.new]
+        @attributes = {}
+      end
+      def initialize_row w
+        if(w > @width)
+          @width.upto(w-1) { |ii| @fields[ii] ||= Field.new }
+          @width = w
+        end
+      end
+      def add(item, x)
+        (@fields[x] ||= Field.new).add item
+      end
+      def each_field(x, w=1)
+        x.upto([x+w, @width].min - 1) { |xx|
+          yield(@fields[xx])
+        }
+      end
+      def to_html cgi
+        cgi.tr(@attributes) {
+          field_html(cgi)
+        }
+      end
+      def field_attribute(key, x=0)
+        @fields[x].attribute(key)
+      end
+      def field_html(cgi)
+        html = ""
+        span = 1
+        @fields.each { |field|
+          if(span < 2)
+            html << field.to_html(cgi)
+            span = field.colspan
+          else
+            span -= 1
+          end
+        }
+        html
+      end
+      def set_attributes(attr)
+        @attributes = attr
+      end
+      def [](x)
+        begin
+          @fields[x]
+        rescue StandardError
+          nil
+        end
+      end
+    end
+    public
+    def initialize(attributes={}) # Grid
+      @height = 1
+      @width = 1
+      @rows = [Row.new]
+      @attributes = {
+        "cellspacing" =>  "0",
+      }.update(attributes)
+    end
+    def initialize_grid(w, h)
+      if(w > @width || h > @height)
+        floor = (w > @width) ? 0 : @height
+        @width = [w, @width].max
+        @height = [h, @height].max
+        floor.upto(@height - 1) { |ii|
+          (@rows[ii] ||= Row.new).initialize_row(@width)
+        }
+      end
+    end
+    def add(arg, x, y, col=false)
+      if arg.kind_of?(Enumerable)
+        if arg.kind_of?(String)
           add_field(arg, x, y)
+        elsif arg.kind_of?(Array)
+          arg.each do |item|
+            add_field(item, x ? x : '', y)
+          end
+        elsif col
+          add_column(arg, x, y)
+        else
+          add_row(arg, x, y)
         end
-			end
-			def add_attribute(key, value, x, y, w=1, h=1)
-				each_field(x, y, w, h) { |field|
-					field.add_attribute(key, value)
-				}
-			end
-			def add_background(x, y, w=1, h=1)
-				each_field(x, y, w, h) { |field|
-					field.add_background(x, w)
-				}
-			end
-			def add_column(arg, x, y)
-				offset = 0
-				arg.each do |item|
-					add_field(item, x, y + offset)
-					offset = offset.next
-				end
-			end
-			def add_component_style(style, x, y, w=1, h=1)
-				each_field(x, y, w, h) { |field|
-					field.add_component_style(style)
-				}
-			end
-			def add_field(arg, x, y)
-				initialize_grid(x+1, y+1)
-				(@rows[y] ||= Row.new).add(arg, x)
-			end
-			def add_row(arg, x, y)
-				offset = 0
-				arg.each do |item|
-					add_field(item, x + offset, y)
-					offset = offset.next
-				end
-			end
-			def add_style(style, x, y, w=1, h=1)
-				each_field(x, y, w, h) { |field|
-					field.add_style(style)
-				}
-			end
-			def add_tag(tag, x, y, w=1, h=1)
-				initialize_grid(x+w, y+h)
-				each_field(x, y, w, h) { |field| 
-					field.tag = tag
-				}
-			end
-			def each_field(x, y, w=1, h=1)
-				y.upto([y+h, @height].min - 1) { |yy|
-					@rows[yy].each_field(x,w) { |field|
-						yield(field)
-					}
-				}
-			end
-			def field_attribute(key, x=0, y=0)
-				@rows[y].field_attribute(key, x)
-			end
-			def insert_row(y=0, arg=nil)
-				@rows[y, 0] = Row.new	
-				@height += 1
-				add(arg, 0, y)
-			end
-			def push(arg, x=0, y=height)
-				add(arg, x, y)
-				set_colspan(x,y)
-			end
-			def set_attribute(key, value)
-				@attributes[key] = value
-			end
-			def set_attributes(hash)
-				@attributes.update(hash)
-			end
-			def set_colspan(x=0, y=0, span=(@width - x))
-				span = span.to_i
-				initialize_grid(x+span, y+1)
-				self[x,y].colspan = span
-			end
-			def set_row_attributes(attr={}, y=0, offset=0)
-        # TODO
-        # At the moment, offset value is not used
-        # But probably offset value is used in grid.c
-        initialize_grid(offset, y + 1)
-				@rows[y].set_attributes(attr)
-			end
-			def to_html(cgi)
-				cgi.table(@attributes) {
-					@rows.collect { |row| row.to_html(cgi).force_encoding('utf-8') }.join
-				}
-			end
-			def [](x, y)
-				begin
-					@rows[y][x]
-				rescue StandardError
-					nil
-				end
-			end
-		end
-	end
+      else
+        add_field(arg, x, y)
+      end
+    end
+    def add_attribute(key, value, x, y, w=1, h=1)
+      each_field(x, y, w, h) { |field|
+        field.add_attribute(key, value)
+      }
+    end
+    def add_background(x, y, w=1, h=1)
+      each_field(x, y, w, h) { |field|
+        field.add_background(x, w)
+      }
+    end
+    def add_column(arg, x, y)
+      offset = 0
+      arg.each do |item|
+        add_field(item, x, y + offset)
+        offset = offset.next
+      end
+    end
+    def add_component_style(style, x, y, w=1, h=1)
+      each_field(x, y, w, h) { |field|
+        field.add_component_style(style)
+      }
+    end
+    def add_field(arg, x, y)
+      initialize_grid(x+1, y+1)
+      (@rows[y] ||= Row.new).add(arg, x)
+    end
+    def add_row(arg, x, y)
+      offset = 0
+      arg.each do |item|
+        add_field(item, x + offset, y)
+        offset = offset.next
+      end
+    end
+    def add_style(style, x, y, w=1, h=1)
+      each_field(x, y, w, h) { |field|
+        field.add_style(style)
+      }
+    end
+    def add_tag(tag, x, y, w=1, h=1)
+      initialize_grid(x+w, y+h)
+      each_field(x, y, w, h) { |field| 
+        field.tag = tag
+      }
+    end
+    def each_field(x, y, w=1, h=1)
+      y.upto([y+h, @height].min - 1) { |yy|
+        @rows[yy].each_field(x,w) { |field|
+          yield(field)
+        }
+      }
+    end
+    def field_attribute(key, x=0, y=0)
+      @rows[y].field_attribute(key, x)
+    end
+    def insert_row(y=0, arg=nil)
+      @rows[y, 0] = Row.new	
+      @height += 1
+      add(arg, 0, y)
+    end
+    def push(arg, x=0, y=height)
+      add(arg, x, y)
+      set_colspan(x,y)
+    end
+    def set_attribute(key, value)
+      @attributes[key] = value
+    end
+    def set_attributes(hash)
+      @attributes.update(hash)
+    end
+    def set_colspan(x=0, y=0, span=(@width - x))
+      span = span.to_i
+      initialize_grid(x+span, y+1)
+      self[x,y].colspan = span
+    end
+    def set_row_attributes(attr={}, y=0, offset=0)
+      # TODO
+      # At the moment, offset value is not used
+      # But probably offset value is used in grid.c
+      initialize_grid(offset, y + 1)
+      @rows[y].set_attributes(attr)
+    end
+    def to_html(cgi)
+      cgi.table(@attributes) {
+        @rows.collect { |row| row.to_html(cgi).force_encoding('utf-8') }.join
+      }
+    end
+    def [](x, y)
+      begin
+        @rows[y][x]
+      rescue StandardError
+        nil
+      end
+    end
+  end
 end