htmlgrid 1.1.0 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5ff89d7ef9b327cfe5f71794afc0e08acabe92ae
-  data.tar.gz: 6669995c93c30107c4b20b207950fa3f7229ec0d
+SHA256:
+  metadata.gz: eda73d2e1ec602956e9dac7af185179cc676906adf4a34fd1a683685c391ed49
+  data.tar.gz: c7668593f88170c009de8cc42839d69ec24834aec487baed336152eab1f979a4
 SHA512:
-  metadata.gz: 3a659474980dc94623435c3ede8307cf0249888ccb644187de53a29333936823780a4c3ae8a44a425d9bc15dc8b47865ca633a47ec1d31628ec7e7bffb44f6de
-  data.tar.gz: fd7d0cd908342a8fc1c48ee087f985dad3bd33ef5ca86cbcc43bde20b6213baff3290cdbdf2db86fe872a32c00f832bb0ee31540474863fc6d031640f47342b2
+  metadata.gz: c85d82f860af997c13a4c6f3298a5ac1dfc1cfff668d28842b21f0e8723c4cc35cadb19fa4990070ba6fd3d735235d2ec0d1b54585e46a91ef229e3683af5ebf
+  data.tar.gz: 5701ee21b4d273fcef7e6caab0af4401f8d67019aff1214327d092567fa73798690aebec32163aa890cd79eb6f4984c6e90a676eb2ffaee38fbfe7dc0137f80d

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

@@ -213,7 +213,7 @@ module HtmlGrid
 		def tabindex=(tab)
 			@attributes.store('tabIndex', tab.to_s)
 		end
-		def to_html(context)
+    def to_html(context)
       _to_html(context, @value).to_s.force_encoding('utf-8')
     end
     @@nl2br_ptrn = /(\r\n)|(\n)|(\r)/

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,13 +5,12 @@
 
 require 'htmlgrid/component'
 require 'htmlgrid/div'
+require 'htmlgrid/template'
 
 module HtmlGrid
-	class Component
+  class Component
     @@msie_ptrn = /MSIE\s*(\d)/
-		attr_accessor :dojo_tooltip
-    # FIXME
-    # DOJO_VERSION >= 1.7.0 only (removed old version support)
+    attr_accessor :dojo_tooltip
     def dojo_tag(widget, args={}, inner_html='')
       div = HtmlGrid::Div.new(@model, @session, self)
       div.set_attribute('data-dojo-type', widget)
@@ -29,50 +28,54 @@ module HtmlGrid
       tooltip.value = value
       self.dojo_tooltip = tooltip
     end
-		def dojo_parse_widgets
-			if(@container.respond_to?(:dojo_parse_widgets))
-				@container.dojo_parse_widgets
-			end
-		end
-    unless(method_defined?(:dojo_dynamic_html))
+    def dojo_parse_on_load
+      if @container.respond_to?(:dojo_parse_on_load)
+        @container.dojo_parse_on_load
+      end
+    end
+    unless method_defined?(:dojo_dynamic_html)
       alias :dojo_dynamic_html :dynamic_html
       def dynamic_html(context)
         html = ''
         attrs = {
-        'data-dojo-type' => 'dijit/Tooltip',
-        'data-dojo-props' => "connectId:'#{css_id}'",
-          'id'             =>  "#{css_id}_widget",
-          'style'          =>  'display: none',
+          '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)) \
-               && match[1].to_i < 7)
+        unless (match = @@msie_ptrn.match(@session.user_agent)) \
+               && match[1].to_i < 7
           attrs.update({
             'toggle'         => 'fade',
             'toggleDuration' => '500',
           })
         end
-        if(@dojo_tooltip.is_a?(String))
-          attrs.store('href', "'#@dojo_tooltip'")
+        @dojo_tooltip ||= nil
+        if @dojo_tooltip.is_a?(String)
+          if @dojo_tooltip !~ /^http/ # e.g. javascript
+            attrs.store('href', "#@dojo_tooltip")
+          else
+            attrs.store('href', @dojo_tooltip)
+          end
           html << context.div(attrs)
-        elsif(@dojo_tooltip.respond_to?(:to_html))
+        elsif @dojo_tooltip.respond_to?(:to_html)
           @dojo_tooltip.attributes.update(attrs)
           html << @dojo_tooltip.to_html(context).force_encoding('utf-8')
         end
-        unless(html.empty? || dojo_parse_widgets)
-          html << context.script('type' => 'text/javascript') {
-            "dojoConfig.searchIds.push('#{css_id}')"
-          }
+        unless html.empty? || dojo_parse_on_load
+          html << context.script('type' => 'text/javascript') { "dojoConfig.searchIds.push('#{css_id}')" }
         end
+        # call original dynamic_html
         dojo_dynamic_html(context) << html
       end
     end
-	end
+  end
 	module DojoToolkit
 		module DojoTemplate
-			DOJO_DEBUG = false
+			DOJO_DEBUG = true
 			DOJO_BACK_BUTTON = false
       DOJO_ENCODING = nil
-			DOJO_PARSE_WIDGETS = true
+      DOJO_PARSE_ON_LOAD = true
 			DOJO_PREFIX = []
 			DOJO_REQUIRE = []
       def dynamic_html_headers(context)
@@ -88,58 +91,35 @@ module HtmlGrid
             "{ name: '#{prefix}', location: '#{path}' }"
           }.join(",")
         end
-        config = [
-          "parseOnLoad:          true",
-          "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_widgets
-				self.class::DOJO_PARSE_WIDGETS
-			end
+      def dojo_parse_on_load
+        self.class::DOJO_PARSE_ON_LOAD
+      end
 			def onload=(script)
 				(@dojo_onloads ||= []).push(script)
 			end

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