green_shoes 0.227.0 → 0.233.0

data/README.md

@@ -68,6 +68,7 @@ Except:
 - hh/static/(all).png (c) 2008 why the lucky stiff
 - lib/ext/hpricot/(all) (c) 2008 why the lucky stiff
 - lib/ext/projector/(all).rb (c) 2010 MIZUTANI Tociyuki
+- lib/ext/highlighter/(all) (c) 2008 why the lucky stiff and 2011 Steve Klabnik
 - samples/akatsukiface.png (c) 2010 MIZUTANI Tociyuki
 - samples/class-book.yaml (c) 2008 why the lucky stiff
 - samples/splash-hand.png (c) 2008 why the lucky stiff

data/VERSION

@@ -1 +1 @@
-0.227.0
+0.233.0

data/lib/ext/highlighter.rb

@@ -0,0 +1,2 @@
+module ::HH end
+require_relative 'highlighter/markup'

data/lib/ext/highlighter/common.rb

@@ -0,0 +1,197 @@
+require 'strscan'
+
+module HH::Syntax
+
+  # A single token extracted by a tokenizer. It is simply the lexeme
+  # itself, decorated with a 'group' attribute to identify the type of the
+  # lexeme.
+  class Token < String
+
+    # the type of the lexeme that was extracted.
+    attr_reader :group
+
+    # the instruction associated with this token (:none, :region_open, or
+    # :region_close)
+    attr_reader :instruction
+
+    # Create a new Token representing the given text, and belonging to the
+    # given group.
+    def initialize( text, group, instruction = :none )
+      super text
+      @group = group
+      @instruction = instruction
+    end
+
+  end
+
+  # The base class of all tokenizers. It sets up the scanner and manages the
+  # looping until all tokens have been extracted. It also provides convenience
+  # methods to make sure adjacent tokens of identical groups are returned as
+  # a single token.
+  class Tokenizer
+
+    # The current group being processed by the tokenizer
+    attr_reader :group
+
+    # The current chunk of text being accumulated
+    attr_reader :chunk
+
+    # Start tokenizing. This sets up the state in preparation for tokenization,
+    # such as creating a new scanner for the text and saving the callback block.
+    # The block will be invoked for each token extracted.
+    def start( text, &block )
+      @chunk = ""
+      @group = :normal
+      @callback = block
+      @text = StringScanner.new( text )
+      setup
+    end
+
+    # Subclasses may override this method to provide implementation-specific
+    # setup logic.
+    def setup
+    end
+
+    # Finish tokenizing. This flushes the buffer, yielding any remaining text
+    # to the client.
+    def finish
+      start_group nil
+      teardown
+    end
+
+    # Subclasses may override this method to provide implementation-specific
+    # teardown logic.
+    def teardown
+    end
+
+    # Subclasses must implement this method, which is called for each iteration
+    # of the tokenization process. This method may extract multiple tokens.
+    def step
+      raise NotImplementedError, "subclasses must implement #step"
+    end
+
+    # Begins tokenizing the given text, calling #step until the text has been
+    # exhausted.
+    def tokenize( text, &block )
+      start text, &block
+      step until @text.eos?
+      finish
+    end
+
+    # Specify a set of tokenizer-specific options. Each tokenizer may (or may
+    # not) publish any options, but if a tokenizer does those options may be
+    # used to specify optional behavior.
+    def set( opts={} )
+      ( @options ||= Hash.new ).update opts
+    end
+
+    # Get the value of the specified option.
+    def option(opt)
+      @options ? @options[opt] : nil
+    end
+
+  private
+
+    EOL = /(?=\r\n?|\n|$)/
+
+    # A convenience for delegating method calls to the scanner.
+    def self.delegate( sym )
+      define_method( sym ) { |*a| @text.__send__( sym, *a ) }
+    end
+
+    delegate :bol?
+    delegate :eos?
+    delegate :scan
+    delegate :scan_until
+    delegate :check
+    delegate :check_until
+    delegate :getch
+    delegate :matched
+    delegate :pre_match
+    delegate :peek
+    delegate :pos
+
+    # Access the n-th subgroup from the most recent match.
+    def subgroup(n)
+      @text[n]
+    end
+
+    # Append the given data to the currently active chunk.
+    def append( data )
+      @chunk << data
+    end
+
+    # Request that a new group be started. If the current group is the same
+    # as the group being requested, a new group will not be created. If a new
+    # group is created and the current chunk is not empty, the chunk's
+    # contents will be yielded to the client as a token, and then cleared.
+    #
+    # After the new group is started, if +data+ is non-nil it will be appended
+    # to the chunk.
+    def start_group( gr, data=nil )
+      flush_chunk if gr != @group
+      @group = gr
+      @chunk << data if data
+    end
+
+    def start_region( gr, data=nil )
+      flush_chunk
+      @group = gr
+      @callback.call( Token.new( data||"", @group, :region_open ) )
+    end
+
+    def end_region( gr, data=nil )
+      flush_chunk
+      @group = gr
+      @callback.call( Token.new( data||"", @group, :region_close ) )
+    end
+
+    def flush_chunk
+      @callback.call( Token.new( @chunk, @group ) ) unless @chunk.empty?
+      @chunk = ""
+    end
+
+    def subtokenize( syntax, text )
+      tokenizer = Syntax.load( syntax )
+      tokenizer.set @options if @options
+      flush_chunk
+      tokenizer.tokenize( text, &@callback )
+    end
+  end
+
+
+  # A default tokenizer for handling syntaxes that are not explicitly handled
+  # elsewhere. It simply yields the given text as a single token.
+  class Default
+
+    # Yield the given text as a single token.
+    def tokenize( text )
+      yield Token.new( text, :normal )
+    end
+
+  end
+
+  # A hash for registering syntax implementations.
+  SYNTAX = Hash.new( Default )
+
+  # Load the implementation of the requested syntax. If the syntax cannot be
+  # found, or if it cannot be loaded for whatever reason, the Default syntax
+  # handler will be returned.
+  def load( syntax )
+    begin
+      require_relative "lang/#{syntax}"
+    rescue LoadError
+    end
+    SYNTAX[ syntax ].new
+  end
+  module_function :load
+
+  # Return an array of the names of supported syntaxes.
+  def all
+    lang_dir = File.join(File.dirname(__FILE__), "syntax", "lang")
+    Dir["#{lang_dir}/*.rb"].map { |path| File.basename(path, ".rb") }
+  end
+  module_function :all
+
+
+end

data/lib/ext/highlighter/lang/ruby.rb

@@ -0,0 +1,316 @@
+
+module HH::Syntax
+
+  # A tokenizer for the Ruby language. It recognizes all common syntax
+  # (and some less common syntax) but because it is not a true lexer, it
+  # will make mistakes on some ambiguous cases.
+  class Ruby < Tokenizer
+
+    # The list of all identifiers recognized as keywords.
+    KEYWORDS =
+      %w{if then elsif else end begin do rescue ensure while for
+         class module def yield raise until unless and or not when
+         case super undef break next redo retry in return alias
+         defined?}
+
+    # Perform ruby-specific setup
+    def setup
+      @selector = false
+      @allow_operator = false
+      @heredocs = []
+    end
+
+    # Step through a single iteration of the tokenization process.
+    def step
+      case
+        when bol? && check( /=begin/ )
+          start_group( :comment, scan_until( /^=end#{EOL}/ ) )
+        when bol? && check( /__END__#{EOL}/ )
+          start_group( :comment, scan_until( /\Z/ ) )
+      else
+        case
+          when check( /def\s+/ )
+            start_group :keyword, scan( /def\s+/ )
+            start_group :method,  scan_until( /(?=[;(\s]|#{EOL})/ )
+          when check( /class\s+/ )
+            start_group :keyword, scan( /class\s+/ )
+            start_group :class,  scan_until( /(?=[;\s<]|#{EOL})/ )
+          when check( /module\s+/ )
+            start_group :keyword, scan( /module\s+/ )
+            start_group :module,  scan_until( /(?=[;\s]|#{EOL})/ )
+          when check( /::/ )
+            start_group :punct, scan(/::/)
+          when check( /:"/ )
+            start_group :symbol, scan(/:/)
+            scan_delimited_region :symbol, :symbol, "", true
+            @allow_operator = true
+          when check( /:'/ )
+            start_group :symbol, scan(/:/)
+            scan_delimited_region :symbol, :symbol, "", false
+            @allow_operator = true
+          when scan( /:[_a-zA-Z@$][$@\w]*[=!?]?/ )
+            start_group :symbol, matched
+            @allow_operator = true
+          when scan( /\?(\\[^\n\r]|[^\\\n\r\s])/ )
+            start_group :char, matched
+            @allow_operator = true
+          when check( /(__FILE__|__LINE__|true|false|nil|self)[?!]?/ )
+            if @selector || matched[-1] == ?? || matched[-1] == ?!
+              start_group :ident,
+                scan(/(__FILE__|__LINE__|true|false|nil|self)[?!]?/)
+            else
+              start_group :constant,
+                scan(/(__FILE__|__LINE__|true|false|nil|self)/)
+            end
+            @selector = false
+            @allow_operator = true
+          when scan(/0([bB][01]+|[oO][0-7]+|[dD][0-9]+|[xX][0-9a-fA-F]+)/)
+            start_group :number, matched
+            @allow_operator = true
+          else
+            case peek(2)
+              when "%r"
+                scan_delimited_region :punct, :regex, scan( /../ ), true
+                @allow_operator = true
+              when "%w", "%q"
+                scan_delimited_region :punct, :string, scan( /../ ), false
+                @allow_operator = true
+              when "%s"
+                scan_delimited_region :punct, :symbol, scan( /../ ), false
+                @allow_operator = true
+              when "%W", "%Q", "%x"
+                scan_delimited_region :punct, :string, scan( /../ ), true
+                @allow_operator = true
+              when /%[^\sa-zA-Z0-9]/
+                scan_delimited_region :punct, :string, scan( /./ ), true
+                @allow_operator = true
+              when "<<"
+                saw_word = ( chunk[-1,1] =~ /[\w!?]/ )
+                start_group :punct, scan( /<</ )
+                if saw_word
+                  @allow_operator = false
+                  return
+                end
+
+                float_right = scan( /-/ )
+                append "-" if float_right
+                if ( type = scan( /['"]/ ) )
+                  append type
+                  delim = scan_until( /(?=#{type})/ )
+                  if delim.nil?
+                    append scan_until( /\Z/ )
+                    return
+                  end
+                else
+                  delim = scan( /\w+/ ) or return
+                end
+                start_group :constant, delim
+                start_group :punct, scan( /#{type}/ ) if type
+                @heredocs << [ float_right, type, delim ]
+                @allow_operator = true
+              else
+                case peek(1)
+                  when /[\n\r]/
+                    unless @heredocs.empty?
+                      scan_heredoc(*@heredocs.shift)
+                    else
+                      start_group :normal, scan( /\s+/ )
+                    end
+                    @allow_operator = false
+                  when /\s/
+                    start_group :normal, scan( /\s+/ )
+                  when "#"
+                    start_group :comment, scan( /#[^\n\r]*/ )
+                  when /[A-Z]/
+                    start_group @selector ? :ident : :constant, scan( /\w+/ )
+                    @allow_operator = true
+                  when /[a-z_]/
+                    word = scan( /\w+[?!]?/ )
+                    if !@selector && KEYWORDS.include?( word )
+                      start_group :keyword, word
+                      @allow_operator = false
+                    elsif
+                      start_group :ident, word
+                      @allow_operator = true
+                    end
+                    @selector = false
+                  when /\d/
+                    start_group :number,
+                      scan( /[\d_]+(\.[\d_]+)?([eE][\d_]+)?/ )
+                    @allow_operator = true
+                  when '"'
+                    scan_delimited_region :punct, :string, "", true
+                    @allow_operator = true
+                  when '/'
+                    if @allow_operator
+                      start_group :punct, scan(%r{/})
+                      @allow_operator = false
+                    else
+                      scan_delimited_region :punct, :regex, "", true
+                      @allow_operator = true
+                    end
+                  when "'"
+                    scan_delimited_region :punct, :string, "", false
+                    @allow_operator = true
+                  when "."
+                    dots = scan( /\.{1,3}/ )
+                    start_group :punct, dots
+                    @selector = ( dots.length == 1 )
+                  when /[@]/
+                    start_group :attribute, scan( /@{1,2}\w*/ )
+                    @allow_operator = true
+                  when /[$]/
+                    start_group :global, scan(/\$/)
+                    start_group :global, scan( /\w+|./ ) if check(/./)
+                    @allow_operator = true
+                  when /[-!?*\/+=<>(\[\{}:;,&|%]/
+                    start_group :punct, scan(/./)
+                    @allow_operator = false
+                  when /[)\]]/
+                    start_group :punct, scan(/./)
+                    @allow_operator = true
+                  else
+                    # all else just falls through this, to prevent
+                    # infinite loops...
+                    append getch
+                end
+            end
+        end
+      end
+    end
+
+    private
+
+      # Scan a delimited region of text. This handles the simple cases (strings
+      # delimited with quotes) as well as the more complex cases of %-strings
+      # and here-documents.
+      #
+      # * +delim_group+ is the group to use to classify the delimiters of the
+      #   region
+      # * +inner_group+ is the group to use to classify the contents of the
+      #   region
+      # * +starter+ is the text to use as the starting delimiter
+      # * +exprs+ is a boolean flag indicating whether the region is an
+      #   interpolated string or not
+      # * +delim+ is the text to use as the delimiter of the region. If +nil+,
+      #   the next character will be treated as the delimiter.
+      # * +heredoc+ is either +false+, meaning the region is not a heredoc, or
+      #   <tt>:flush</tt> (meaning the delimiter must be flushed left), or
+      #   <tt>:float</tt> (meaning the delimiter doens't have to be flush left).
+      def scan_delimited_region( delim_group, inner_group, starter, exprs,
+        delim=nil, heredoc=false )
+      # begin
+        if !delim
+          start_group delim_group, starter
+          delim = scan( /./ )
+          append delim
+
+          delim = case delim
+            when '{' then '}'
+            when '(' then ')'
+            when '[' then ']'
+            when '<' then '>'
+            else delim
+          end
+        end
+
+        start_region inner_group
+
+        items = "\\\\|"
+        if heredoc
+          items << "(^"
+          items << '\s*' if heredoc == :float
+          items << "#{Regexp.escape(delim)}\s*?)#{EOL}"
+        else
+          items << "#{Regexp.escape(delim)}"
+        end
+        items << "|#(\\$|@@?|\\{)" if exprs
+        items = Regexp.new( items )
+
+        loop do
+          p = pos
+          match = scan_until( items )
+          if match.nil?
+            start_group inner_group, scan_until( /\Z/ )
+            break
+          else
+            text = pre_match[p..-1]
+            start_group inner_group, text if text.length > 0
+            case matched.strip
+              when "\\"
+                unless exprs
+                  case peek(1)
+                    when "'"
+                      scan(/./)
+                      start_group :escape, "\\'"
+                    when "\\"
+                      scan(/./)
+                      start_group :escape, "\\\\"
+                    else
+                      start_group inner_group, "\\"
+                  end
+                else
+                  start_group :escape, "\\"
+                  c = getch
+                  append c
+                  case c
+                    when 'x'
+                      append scan( /[a-fA-F0-9]{1,2}/ )
+                    when /[0-7]/
+                      append scan( /[0-7]{0,2}/ )
+                  end
+                end
+              when delim
+                end_region inner_group
+                start_group delim_group, matched
+                break
+              when /^#/
+                do_highlight = (option(:expressions) == :highlight)
+                start_region :expr if do_highlight
+                start_group :expr, matched
+                case matched[1]
+                  when ?{
+                    depth = 1
+                    content = ""
+                    while depth > 0
+                      p = pos
+                      c = scan_until( /[\{}]/ )
+                      if c.nil?
+                        content << scan_until( /\Z/ )
+                        break
+                      else
+                        depth += ( matched == "{" ? 1 : -1 )
+                        content << pre_match[p..-1]
+                        content << matched if depth > 0
+                      end
+                    end
+                    if do_highlight
+                      subtokenize "ruby", content
+                      start_group :expr, "}"
+                    else
+                      append content + "}"
+                    end
+                  when ?$, ?@
+                    append scan( /\w+/ )
+                end
+                end_region :expr if do_highlight
+              else raise "unexpected match on #{matched}"
+            end
+          end
+        end
+      end
+
+      # Scan a heredoc beginning at the current position.
+      #
+      # * +float+ indicates whether the delimiter may be floated to the right
+      # * +type+ is +nil+, a single quote, or a double quote
+      # * +delim+ is the delimiter to look for
+      def scan_heredoc(float, type, delim)
+        scan_delimited_region( :constant, :string, "", type != "'",
+          delim, float ? :float : :flush )
+      end
+  end
+
+  SYNTAX["ruby"] = Ruby
+
+end

data/lib/ext/highlighter/markup.rb

@@ -0,0 +1,222 @@
+# syntax highlighting
+
+require_relative 'common'
+
+module HH::Markup
+
+  TOKENIZER = HH::Syntax.load "ruby"
+  COLORS = {
+    :comment => {:stroke => "#887"},
+    :keyword => {:stroke => "#111"},
+    :method => {:stroke => "#C09", :weight => "bold"},
+    # :class => {:stroke => "#0c4", :weight => "bold"},
+    # :module => {:stroke => "#050"},
+    # :punct => {:stroke => "#668", :weight => "bold"},
+    :symbol => {:stroke => "#C30"},
+    :string => {:stroke => "#C90"},
+    :number => {:stroke => "#396" },
+    :regex => {:stroke => "#000", :fill => "#FFC" },
+    # :char => {:stroke => "#f07"},
+    :attribute => {:stroke => "#369" },
+    # :global => {:stroke => "#7FB" },
+    :expr => {:stroke => "#722" },
+    # :escape => {:stroke => "#277" }
+    :ident => {:stroke => "#994c99"},
+    :constant => {:stroke => "#630", :weight => "bold"},
+    :class => {:stroke => "#630", :weight => "bold"},
+    :matching => {:stroke => "#ff0", :weight => "bold"},
+  }
+
+  
+  def highlight str, pos=nil, colors=COLORS
+    tokens = []
+    TOKENIZER.tokenize(str) do |t|
+      if t.group == :punct
+        # split punctuation into single characters tokens
+        # TODO: to it in the parser
+        tokens += t.split('').map{|s| HH::Syntax::Token.new(s, :punct)}
+      else
+        # add token as is
+        tokens << t
+      end
+    end
+
+    res = []
+    tokens.each do |token|
+      res <<
+        if colors[token.group]
+          #span(token, colors[token.group])
+          tmp = fg(token, tr_color(colors[token.group][:stroke]))
+          colors[token.group][:fill] ? bg(tmp, tr_color(colors[token.group][:fill])) : tmp
+        elsif colors[:any]
+          #span(token, colors[:any])
+          tmp = fg(token, tr_color(colors[:any][:stroke]))
+          colors[:any][:fill] ? bg(tmp, tr_color(colors[:any][:fill])) : tmp
+        else
+          token
+        end
+    end
+
+    if pos.nil? or pos < 0
+      return res.join
+    end
+
+    token_index, matching_index = matching_token(tokens, pos)
+
+    if token_index
+      #res[token_index] = span(tokens[token_index], colors[:matching])
+      tmp = fg(tokens[token_index], tr_color(colors[:matching][:stroke]))
+      res[token_index] = colors[:matching][:fill] ? bg(tmp, tr_color(colors[:matching][:fill])) : tmp
+      if matching_index
+        #res[matching_index] = span(tokens[matching_index], colors[:matching])
+        tmp = fg(tokens[matching_index], tr_color(colors[:matching][:stroke]))
+        res[matching_index] = colors[:matching][:fill] ? bg(tmp, tr_color(colors[:matching][:fill])) : tmp
+      end
+    end
+
+    res.join
+  end
+
+private
+  def matching_token(tokens, pos)
+    curr_pos = 0
+    token_index = nil
+    tokens.each_with_index do |t, i|
+      curr_pos += t.size
+      if token_index.nil? and curr_pos >= pos
+        token_index = i
+        break
+      end
+    end
+    if token_index.nil? then return nil end
+
+    match = matching_token_at_index(tokens, token_index);
+    if match.nil? and curr_pos == pos and token_index < tokens.size-1
+      # try the token before the cursor, instead of the one after
+      token_index += 1
+      match = matching_token_at_index(tokens, token_index)
+    end
+
+    if match
+      [token_index, match]
+    else
+      nil
+    end
+  end
+
+
+  def matching_token_at_index(tokens, index)
+    starts, ends, direction = matching_tokens(tokens, index)
+    if starts.nil?
+      return nil
+    end
+
+    stack_level = 1
+    index += direction
+    while index >= 0 and index < tokens.size
+      # TODO separate space in the tokenizer
+      t = tokens[index].gsub(/\s/, '')
+      if ends.include?(t) and not as_modifier?(tokens, index)
+        stack_level -= 1
+        return index if stack_level == 0
+      elsif starts.include?(t) and not as_modifier?(tokens, index)
+        stack_level += 1
+      end
+      index += direction
+    end
+    # no matching token found
+    return nil
+  end
+
+  # returns an array of tokens matching and the direction
+  def matching_tokens(tokens, index)
+    # TODO separate space in the tokenizer
+    token = tokens[index].gsub(/\s/, '')
+    starts = [token]
+    if OPEN_BRACKETS[token]
+      direction = 1
+      ends = [OPEN_BRACKETS[token]]
+    elsif CLOSE_BRACKETS[token]
+      direction = -1
+      ends = [CLOSE_BRACKETS[token]]
+    elsif OPEN_BLOCK.include?(token)
+      if as_modifier?(tokens, index)
+        return nil
+      end
+      direction = 1
+      ends = ['end']
+      starts = OPEN_BLOCK
+    elsif token == 'end'
+      direction = -1
+      ends = OPEN_BLOCK
+    else
+      return nil
+    end
+
+    [starts, ends, direction]
+  end
+
+  def as_modifier?(tokens, index)
+
+    if not MODIFIERS.include? tokens[index].gsub(/\s/, '')
+      return false
+    end
+    
+    index -= 1
+    # find last index before the token that is no space
+    index -= 1 while index >= 0 and tokens[index] =~ /\A[ \t]*\z/
+
+    if index < 0
+      # first character of the string
+      false
+    elsif tokens[index] =~ /\n[ \t]*\Z/
+      # first token of the line
+      false
+    elsif tokens[index].group == :punct
+      # preceded by a punctuation token on the same line
+      i = tokens[index].rindex(/\S/)
+      punc = tokens[index][i, 1]
+      # true if the preceeding statement was terminating
+      not NON_TERMINATING.include?(punc)
+    else
+      # preceded by a non punctuation token on the same line
+      true
+    end
+  end
+
+
+  OPEN_BRACKETS = {
+    '{' => '}',
+    '(' => ')',
+    '[' => ']',
+  }
+
+  #close_bracket = {}
+  #OPEN_BRACKETS.each{|open, close| opens_bracket[close] = open}
+  #CLOSE_BRACKETS = opens_bracket
+  # the following is more readable :)
+  CLOSE_BRACKETS = {
+    '}' => '{',
+    ')' => '(',
+    ']' => '[',
+  }
+
+  BRACKETS = CLOSE_BRACKETS.keys + OPEN_BRACKETS.keys
+
+  OPEN_BLOCK = [
+    'def',
+    'class',
+    'module',
+    'do',
+    'if',
+    'unless',
+    'while',
+    'until',
+    'begin',
+    'for'
+  ]
+
+  MODIFIERS = %w[if unless while until]
+
+  NON_TERMINATING = %w{+ - * / , . = ~ < > ( [}
+end

data/lib/green_shoes.rb

@@ -48,3 +48,4 @@ autoload :ChipMunk, File.join(Shoes::DIR, 'ext/chipmunk')
 autoload :Bloops, File.join(Shoes::DIR, 'ext/bloops')
 autoload :Projector, File.join(Shoes::DIR, 'ext/projector')
 autoload :Hpricot, File.join(Shoes::DIR, 'ext/hpricot')
+autoload :HH, File.join(Shoes::DIR, 'ext/highlighter')

data/lib/shoes/basic.rb

@@ -92,6 +92,8 @@ class Shoes
       end
     end
 
+    alias :clear_all :clear
+
     def positioning x, y, max
       if parent.is_a?(Flow) and x + @width <= parent.left + parent.width
         move3 x + parent.margin_left, max.top + parent.margin_top

data/lib/shoes/help.rb

@@ -3,6 +3,7 @@ class Manual < Shoes
   url '/manual/(\d+)', :index
 
   include Hpricot
+  include HH::Markup
 
   def index pnum = 0
     font LANG == 'ja' ? 'MS UI Gothic' : 'Arial'
@@ -84,7 +85,11 @@ class Manual < Shoes
           flow do
             background rgb(190, 190, 190), curve: 5
             inscription link(fg('Run this', green)){eval mk_executable(_code), TOPLEVEL_BINDING}, margin_left: 480
-            para fg(code('  ' + _code), maroon), NL, margin_left: -10
+            if _code.include? 'te-su-to'
+              para fg(code('  ' + _code), maroon), NL, margin_left: -10
+            else
+              para code(highlight('  ' + _code, nil)), NL, margin_left: -10
+	    end
           end
           para
         end
@@ -329,7 +334,7 @@ class Manual < Shoes
 
   def mk_sidebar_list num
     toc = []
-    [0..3, 4..9, 10..16, 17..32, 33..35].each do |r|
+    [0..3, 4..9, 10..16, 17..32, 33..36].each do |r|
       toc.push TOC_LIST[r.first][0]
       toc.push(TOC_LIST[r.first+1..r.last].to_a.map &:first) if r.include?(num)
     end

data/lib/shoes/helper_methods.rb

@@ -194,7 +194,7 @@ class Shoes
     mask_control app
     repaint_all_by_order app
     repaint_textcursors app
-    app.canvas.set_size 0, scrollable_height unless app.prjct
+    app.canvas.set_size 0, scrollable_height unless(app.prjct or app.trvw)
     true
   end
 
@@ -284,6 +284,7 @@ class Shoes
   def self.mouse_on? e
     if e.is_a? Slot
       mouse_x, mouse_y = e.app.win.pointer
+      mouse_y += e.app.scroll_top
       (e.left..e.left+e.width).include?(mouse_x) and (e.top..e.top+e.height).include?(mouse_y)
     else
       mouse_x, mouse_y = e.real.pointer

data/lib/shoes/main.rb

@@ -12,7 +12,8 @@ class Shoes
     args[:left] ||= 0
     args[:top] ||= 0
     projector = args[:prjct] = args[:projector]
-    args.delete :projector
+    treeview = args[:trvw] = args[:treeview]
+    [:projector, :treeview].each{|x| args.delete x}
 
     app = App.new args
     @apps.push app
@@ -62,7 +63,11 @@ class Shoes
       mouse_leave_control app
     end
 
-    app.canvas = projector ? Gtk::DrawingArea.new : Gtk::Layout.new
+    app.canvas = if treeview
+      Gtk::TreeView.new
+    else
+      projector ? Gtk::DrawingArea.new : Gtk::Layout.new
+    end
     swin = Gtk::ScrolledWindow.new
     swin.set_policy Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC 
     swin.vadjustment.step_increment = 10  

data/lib/shoes/ruby.rb

@@ -143,6 +143,10 @@ class Array
   def clear
     self.each &:clear
   end
+
+  def clear_all
+    self.each &:clear_all
+  end
 end
 
 class NilClass

data/lib/shoes/slot.rb

@@ -74,9 +74,8 @@ class Shoes
 
     def fix_size; end
     
-    def clear &blk
-      @app.delete_mouse_events self
-      @contents.each &:clear
+    def clear all = false, &blk
+      all ? @contents.each(&:clear_all) : @contents.each(&:clear)
       @contents.each{|e| @app.mlcs.delete e; @app.mhcs.delete e}
       @contents = []
       if blk
@@ -91,6 +90,11 @@ class Shoes
       end
     end
 
+    def clear_all &blk
+      @app.delete_mouse_events self
+      clear true, &blk
+    end
+
     def append &blk
       prepend contents.length, &blk
     end

data/samples/sample52.rb

@@ -0,0 +1,32 @@
+require '../lib/green_shoes'
+
+Shoes.app do
+ extend HH::Markup
+ colors = {
+    :comment => {:stroke => "#bba"},
+    :keyword => {:stroke => "#FCF91F"},
+    :method => {:stroke => "#C09"},
+    :symbol => {:stroke => "#9DF3C6"},
+    :string => {:stroke => "#C9F5A5"},
+    :number => {:stroke => "#C9F5A5"},
+    :regex => {:stroke => "#000", :fill => "#FFC" },
+    :attribute => {:stroke => "#C9F5A5"},
+    :expr => {:stroke => "#f33" },
+    :ident => {:stroke => "#6e7"},
+    :any => {:stroke => "#FFF"},
+    :constant => {:stroke => "#55f"},
+    :class => {:stroke => "#55f"},
+    :matching => {:stroke => "#f00"},
+  }
+  code = IO.read(ask_open_file)
+  button 'change color' do
+    @slot.clear do
+      background gray 0.1
+      para highlight code, nil, colors
+    end
+  end
+  @slot = stack do
+    background gainsboro
+    para highlight code, nil
+  end
+end

data/samples/sample53.rb

@@ -0,0 +1,10 @@
+require '../lib/green_shoes'
+
+Shoes.app do
+  button 'Open TreeView Window' do
+    Shoes.app width: 275, height: 300, treeview: true do
+      $app = app
+      load './treeview.rb'
+    end
+  end
+end

data/samples/treeview.rb

@@ -0,0 +1,60 @@
+# The following code was quoted from http://ruby-gnome2.sourceforge.jp/hiki.cgi?tut-gtk2-treev-trees
+# and edited a little bit for Green Shoes
+
+def setup_tree_view(treeview)
+  renderer = Gtk::CellRendererText.new
+  column = Gtk::TreeViewColumn.new("Buy", renderer, "text" => $buy_index)
+  treeview.append_column(column)
+  renderer = Gtk::CellRendererText.new
+  column = Gtk::TreeViewColumn.new("Count", renderer, "text" => $qty_index)
+  treeview.append_column(column) 
+  renderer = Gtk::CellRendererText.new
+  column = Gtk::TreeViewColumn.new("Product", renderer, "text" => $prod_index)
+  treeview.append_column(column)
+end
+
+class GroceryItem
+  attr_accessor :product_type, :buy, :quantity, :product
+  def initialize(t,b,q,p)
+    @product_type, @buy, @quantity, @product = t, b, q, p
+  end
+end
+$buy_index = 0; $qty_index = 1; $prod_index = 2
+$p_category = 0; $p_child = 1
+
+list = Array.new
+list[0] = GroceryItem.new($p_category, true,  0, "Cleaning Supplies")
+list[1] = GroceryItem.new($p_child,    true,  1, "Paper Towels")
+list[2] = GroceryItem.new($p_child,    true,  3, "Toilet Paper")
+list[3] = GroceryItem.new($p_category, true,  0, "Food")
+list[4] = GroceryItem.new($p_child,    true,  2, "Bread")
+list[5] = GroceryItem.new($p_child,    false, 1, "Butter")
+list[6] = GroceryItem.new($p_child,    true,  1, "Milk")
+list[7] = GroceryItem.new($p_child,    false, 3, "Chips")
+list[8] = GroceryItem.new($p_child,    true,  4, "Soda")
+
+setup_tree_view($app.canvas)
+
+store = Gtk::TreeStore.new(TrueClass, Integer, String)
+parent = child = nil
+
+list.each_with_index do |e, i|
+  if (e.product_type == $p_category)
+    j = i + 1
+    while j < list.size && list[j].product_type != $p_category
+      list[i].quantity += list[j].quantity if list[j].buy
+      j += 1
+    end
+    parent = store.append(nil)
+    parent[$buy_index]  = list[i].buy
+    parent[$qty_index]  = list[i].quantity
+    parent[$prod_index] = list[i].product
+  else
+    child = store.append(parent)
+    child[$buy_index]  = list[i].buy
+    child[$qty_index]  = list[i].quantity
+    child[$prod_index] = list[i].product
+  end
+end
+
+$app.canvas.model = store

data/static/manual-en.txt

@@ -3877,3 +3877,34 @@ Hope this helps:
  * You can join [[http://librelist.com/browser/shoes/ Shoes ML]] and feel free ask your questions. 
  * [[https://github.com/ashbb/green_shoes/ Current Source Code]] is on GitHub.
  * Green Shoes Gem is on [[http://rubygems.org/gems/green_shoes RubyGems.org]].
+
+== vs.RedShoes ==
+
+Green Shoes is following Red Shoes, but not fully compatible.
+
+==== TextBlock ====
+
+The following two snippets are same in Red Shoes.
+
+{{{
+ Shoes.app do
+   para 'hello ' * 20
+ end
+}}}
+
+{{{
+ Shoes.app do
+   20.times{para 'hello '}
+ end
+}}}
+
+But in Green Shoes, need to add `:width` size explicitly.
+
+{{{
+ Shoes.app do
+   20.times{para 'hello ', width: 40}
+ end
+}}}
+
+If you don't specify the `:width` size, Green Shoes makes a TextBlock object with 
+the `parent.width`.

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 227
+  - 233
   - 0
-  version: 0.227.0
+  version: 0.233.0
 platform: ruby
 authors: 
 - ashbb
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-06 00:00:00 +09:00
+date: 2011-06-14 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,10 @@ files:
 - lib/ext/bloops/songs/simpsons_theme_song_by_why.rb
 - lib/ext/chipmunk.rb
 - lib/ext/chipmunk/chipmunk.so
+- lib/ext/highlighter.rb
+- lib/ext/highlighter/common.rb
+- lib/ext/highlighter/lang/ruby.rb
+- lib/ext/highlighter/markup.rb
 - lib/ext/hpricot.rb
 - lib/ext/hpricot/blankslate.rb
 - lib/ext/hpricot/builder.rb
@@ -196,6 +200,8 @@ files:
 - samples/sample5.rb
 - samples/sample50.rb
 - samples/sample51.rb
+- samples/sample52.rb
+- samples/sample53.rb
 - samples/sample6.rb
 - samples/sample7.rb
 - samples/sample8.rb
@@ -203,6 +209,7 @@ files:
 - samples/sample99.rb
 - samples/shell.png
 - samples/splash-hand.png
+- samples/treeview.rb
 - snapshots/helloworld.png
 - snapshots/mini-hh.png
 - snapshots/sample1.png
@@ -255,6 +262,8 @@ files:
 - snapshots/sample5.png
 - snapshots/sample50.png
 - snapshots/sample51.png
+- snapshots/sample52.png
+- snapshots/sample53.png
 - snapshots/sample6.png
 - snapshots/sample7.png
 - snapshots/sample8.png