rfil 0.2

data/examples/afminfo

@@ -0,0 +1,305 @@
+#!/usr/bin/env ruby
+#--
+# Last Change: Mon May 22 12:38:42 2006
+#++
+=begin rdoc
+
+== afminfo - print out information about an afm or truetype font file
+
+  Usage: afminfo [options] afm-file[.afm]
+      -m, --metrics                    show global metrics information
+      -v, --verbose                    verbose output
+          --[no-]info                  list general information (default)
+      -l, --list-glyphs                list all available glyphs
+      -g, --glyphinfo g                information about a specific glyph
+      -h, --help                       Show this help
+          --version                    Show version information
+  
+---
+Author:: Patrick Gundlach <patrick@gundla.ch>
+License::  Copyright (c) 2006 Patrick Gundlach.
+           Released under the terms of the GNU General Public License
+=end
+
+# :enddoc:
+
+AFMINFO_VERSION="0.1"
+
+require 'optparse'
+require 'ostruct'
+require 'rfil/font/afm'
+require 'rfil/version'
+
+################################################## texttable.rb follows
+
+# Render a list of data column-wise or row-wise. TextTable is used to
+# print a table to the console, without a GUI.
+#
+# Example:
+#  data=%w(one two three four five six seven eight nine ten)
+#  puts TextTable.do_columns(data)
+#
+# This will print out this table:
+#  one   five  eight
+#  two   six   nine 
+#  three seven ten  
+#  four
+# see that the order is column one first, then second column ...
+#
+# Another posibility would be:
+#  puts TextTable.do_rows(data)
+# which outputs
+#  one   two   three
+#  four  five  six  
+#  seven eight nine 
+#  ten   
+
+
+class TextTable
+  class << self
+    #     def columns(data,maxchars=80)
+    #       m,c=count_columns=calculate_maxwidth_columns(data,maxchars)
+    #       return c
+    #     end
+
+    # def maxwidth(data,maxchars=80)
+    #       m,c=count_columns=calculate_maxwidth_columns(data,maxchars)
+    #       return m
+    #     end
+
+    # Arrange the data in columns. The total width is <= maxchars.
+    def do_columns(data,maxchars=80)
+      maxwidth,count_columns=calculate_maxwidth_columns(data,maxchars)
+      
+      tmp=""
+      # amount of data(rows) in each column. The first
+      # count_full_columns columns might have more rows then the last
+      # columns.
+      rowsmin = (data.size * 1.0 / count_columns).floor
+      rowsmax = (data.size * 1.0 / count_columns).ceil
+      count_full_columns = data.size % count_columns
+      
+      distribution=Array.new()
+      distribution[0]=0
+      count = 0
+      (0...count_columns).each { |col|
+        if col < count_full_columns
+          count += rowsmax
+        else 
+          count += rowsmin
+        end
+        distribution[col]= count
+      }
+      
+      distribution.unshift 0
+      (0...rowsmax).each { |row|
+        tmp <<((0...count_columns).collect { |column| 
+                 w = data[distribution[column] + row]
+                 if (column >= count_full_columns) and (row >= rowsmin)
+                   w = ""
+                 end
+                 sprintf("%-#{maxwidth}s",w)
+               }.join(' '))
+        tmp << "\n"
+      }
+      tmp 
+    end
+
+    # Arrange the data in rows.
+    def do_rows(data,maxchars=80)
+      maxwidth,count_columns=calculate_maxwidth_columns(data,maxchars)
+      tmp=""
+      (0...data.size).each { |x|
+        tmp << sprintf("%-#{maxwidth}s",data[x]) +
+        if (x+1) % count_columns == 0
+          "\n"
+        else
+          " "
+        end
+      }
+      tmp << "\n"
+      tmp 
+    end
+
+    private
+
+    def calculate_maxwidth_columns(data,maxchars)
+      maxwidth = 0
+      data.each { |elt|
+        maxwidth = maxwidth > elt.length ? maxwidth : elt.length
+      }
+      columns = (maxchars/(maxwidth + 1)).floor
+      raise ArgumentError,"calculated columns == 0, need wider table" if columns==0
+      return maxwidth,columns
+    end
+  end
+end
+
+################################################## texttable.rb ends here
+
+class AFMinfo # :nodoc:
+  def initialize (afm)
+    @afm = afm
+    @uppercase_letters = ('A'..'Z').collect { |l|  l }
+    @lowercase_letters = ('a'..'z').collect { |l|  l }
+    @digits = %w(one two three four five six seven eight nine zero)
+  end
+  def stdformat
+    "%-18s "
+  end
+  def printout (str,value)
+    puts sprintf(stdformat + "%s", str + ":" ,value.to_s)
+  end
+
+  def num_to_string (num,reservespace=true)
+    formatstring = "%" 
+    formatstring << " " if reservespace
+    formatstring << (num.to_i == num ? "d" : "f")
+    # output "integer" if value after decimal point is 0
+    sprintf(formatstring,num)
+  end
+  
+  def dump_maininfo
+    puts "General font information:"
+    puts "========================="
+    printout("Filename",@afm.filename)
+    [ 
+      ["Fontname",:fontname],
+      ["FullName",:fullname],
+      ["Family name",:familyname],
+      ["Weight",:weight],
+      ["EncodingScheme",:encodingscheme],
+#      ["�","�"],
+    ].each { |s,m|
+      printout(s,@afm.send(m))
+    }
+    puts sprintf(stdformat,'Number of gylphs:') +  @afm.count_charmetrics.to_s + 
+      " (encoded: " + @afm.count_charmetrics_encoded.to_s +  ", unencoded: " + @afm.count_charmetrics_unencoded.to_s + ")"
+
+  end
+  def dump_metrics
+    puts "\n\nGlobal metrics information:"
+    puts "=========================="
+    puts sprintf(stdformat,"FontBBox:") + @afm.fontbbox.collect { |f|
+      num_to_string(f)
+    }.join(' ') + ' (llx,lly,urx,ury)'
+    printout('IsFixedPitch',@afm.isfixedpitch)
+
+    [ 
+      ["ItalicAngle", :italicangle],
+      ["UnderlinePosition", :underlineposition],
+      ["UnderlineThickness", :underlinethickness],
+      ["CapHeight", :capheight],
+      ["XHeight", :xheight],
+      ["Ascender", :ascender],
+      ["Descender", :descender]
+    ].each { |s,m|
+      puts sprintf(stdformat,s) +  num_to_string(@afm.send(m))
+    }
+  end
+  def dump_glyphinfo (glyph)
+    chars=@afm.chars[glyph]
+    puts "\n\nGlyph information (" + glyph + ")"
+    puts "===================="
+    puts sprintf(stdformat,"Encoding pos:") +
+      if chars.c == -1 
+        "--" 
+      else 
+        sprintf("%d (dec), %x (hex), %o (oct)",chars.c,chars.c,chars.c)
+      end
+    puts sprintf(stdformat,"Width x (wx)")  + chars.wx.to_s
+    puts sprintf(stdformat,"Bounding box")  + chars.b.collect { |f|
+      num_to_string(f,false)
+    }.join(' ') + ' (llx,lly,urx,ury)'
+    puts "Kerning pairs: (x,y)"
+    puts "--------------------"
+    chars.kern_data.each { |k,v|
+      puts sprintf(stdformat,"  " + k) + num_to_string(v[0]) + "," +   
+        num_to_string(v[1]) 
+    }
+  end
+  def dump_glyphs
+    chars=@afm.chars
+    puts "\n\nList of glyphs"
+    puts "================"
+    removefromlist=[]
+    if @uppercase_letters.all? { |glyph|
+        chars[glyph]
+      }
+      puts sprintf(stdformat,"A-Z") + "available"
+      removefromlist += @uppercase_letters
+    else
+      puts sprintf(stdformat,"A-Z") + "some missing"
+    end
+    if @lowercase_letters.all? { |glyph|
+        chars[glyph]
+      }
+      puts sprintf(stdformat,"a-z") + "available"
+      removefromlist += @lowercase_letters
+    else
+      puts sprintf(stdformat,"a-z") + "some missing"
+    end
+    if @digits.all? { |glyph|
+        chars[glyph]
+      }
+      puts sprintf(stdformat,"one, two, .., zero") + "available"
+      removefromlist += @digits
+    else
+      puts sprintf(stdformat,"one, two, .., zero") + "some missing"
+    end
+    puts
+    glyphlist=[]
+    chars.each { |glyph,h|
+      glyphlist.push(glyph + (h.c == -1 ? "*" : ""))
+    } 
+    glyphlist = glyphlist - removefromlist
+    glyphlist.sort! { |a,b|
+      a.casecmp b
+    }
+    puts TextTable.do_columns(glyphlist)
+    puts "\n* = unencoded - only glyphs not mentioned above listed"
+  end
+
+end
+
+options=OpenStruct.new
+options.verbose = false
+options.metrics = false
+options.glyph = nil
+options.listglyphs = false
+options.generalinfo = true
+
+ARGV.options { |opt|
+  opt.banner = "Usage: #{File.basename($0)} [options] afm-file[.afm]"
+  opt.on("--metrics", "-m", "show global metrics information") { options.metrics=true}
+  opt.on("--verbose", "-v", "verbose output") { options.verbose=true }
+  opt.on("--[no-]info", "list general information (default)") { |x|
+    options.generalinfo=x }
+  opt.on("--list-glyphs", "-l", "list all available glyphs") { options.listglyphs=true }
+  opt.on("--glyphinfo g" , "-g", 
+         "information about a specific glyph") { |arg| 
+    options.glyph = arg
+  }
+    
+  opt.on("--help", "-h", "Show this help") { puts opt; exit 0 }
+  opt.on("--version", "Show version information") {
+    puts %Q{This is afminfo version #{AFMINFO_VERSION}, based on rfil version #{RFIL_VERSION}\n#{COPYRIGHT}\nMore information: #{HOMEPAGE}}; exit 0 }
+  opt.separator  ""
+  opt.separator COPYRIGHT
+  opt.parse!
+}
+
+unless ARGV.size==1
+  puts "Please specify one afm-file to read"  if ARGV
+  exit 1
+end
+
+
+# afm=Font::AFM.new(:verbose => options.verbose)
+afm=RFIL::Font::Metric.read(ARGV[0],:verbose => options.verbose)
+
+ai = AFMinfo.new(afm)
+ai.dump_maininfo if options.generalinfo
+ai.dump_metrics if options.metrics
+options.glyph && ai.dump_glyphinfo(options.glyph)
+ai.dump_glyphs if options.listglyphs

data/examples/encodingtable

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby -w
+#--
+# Last Change: Tue May 16 18:11:49 2006
+#++
+=begin rdoc
+= encodingtable -- print out a table with different encodings in colums
+
+This is mainly an example how to use the ENC and Kpathsea class. 
+
+== Usage
+ encodingtable encoding[.enc] [encoding[.enc] ...]
+
+
+== Example
+ 
+ $ ./encodingtable ec texnansi 8r 8a
+
+ dec | oct |hex | ECEncoding       | TeXnANSIEncoding | TeXBase1Encoding | StandardEncoding |
+ --------------------------------------------------------------------------------------------
+   0 |   0 |  0 | grave            | ---              | ---              | ---              |
+   1 |   1 |  1 | acute            | Euro             | dotaccent        | ---              |
+   2 |   2 |  2 | circumflex       | ---              | fi               | ---              |
+   3 |   3 |  3 | tilde            | ---              | fl               | ---              |
+   4 |   4 |  4 | dieresis         | fraction         | fraction         | ---              |
+   5 |   5 |  5 | hungarumlaut     | dotaccent        | hungarumlaut     | ---              |
+  ...
+---
+Author:: Patrick Gundlach <patrick@gundla.ch>
+=end
+
+# :enddoc:
+
+require 'tex/enc'
+require 'tex/kpathsea'
+
+
+unless ARGV.size > 0
+  puts "Usage: #{File.basename($0)} encoding[.enc] ..."
+  exit
+end
+
+fmt=" %-16.16s |"
+
+encodings=[]
+kpse=Kpathsea.new
+ARGV.each { |e|
+  kpse.open_file(e.chomp('.enc')+'.enc','enc') { |f|
+    encodings.push(ENC.new(f))
+  }
+}
+
+
+print "dec | oct |hex |"
+encodings.each { |e| print sprintf(fmt,e.encname) }
+
+
+0.upto(255) { |slot|
+  print "\n"+"-"*(16 + encodings.size * 19 ) if slot % 32 == 0
+
+  print sprintf("\n%3d | %3o | %2x |", slot,slot,slot)
+  encodings.each { |e|
+    print sprintf(fmt, e[slot]==".notdef" ? "---" :  e[slot])
+  }
+}
+puts

data/examples/pldiff

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+#--
+# Last Change: Tue May 16 18:13:36 2006
+#++
+=begin rdoc
+
+== pldiff -- show the differences between two (v)pl files.
+  
+  Usage: pldiff [options] file file
+  file can be tfm, pl, vpl or vf files.
+      -d, --delta DELTA                Don't report differences whithin +/- DELTA percent
+      -c, --ignore-comments            ignore comments
+      -k, --ignore-kern                ignore difference in kerning information
+      -m, --mapenc ENC                 assume encoding ENC for destination encoding
+      -t, --texenc ENC                 assume encoding ENC for source encoding (TeX side)
+      -e, --encoding ENC               assume encoding ENC for both in and out
+      -s, --skip-characters            only look at fontdimen and main data
+  
+      -h, --help                       Show this help
+    
+
+---
+Author:: Patrick Gundlach <patrick@gundla.ch>
+License::  Copyright (c) 2005 Patrick Gundlach.
+           Released under the terms of the GNU General Public License
+
+=end
+
+# :enddoc:
+
+require 'optparse'
+require 'ostruct'
+
+require 'tex/kpathsea'
+require 'tex/enc'
+require 'tex/tfm'
+require 'tex/vf'
+
+
+def showmap(mapary)
+  str = ""
+  if mapary
+    mapary.each { |entry|
+      str << "  |  " << entry.join(" ") << "\n"
+    }
+  end
+  str
+end
+
+def plopen(filename)
+  case filename
+  when /\.tfm$/
+    return TFM.new.read_tfm(filename)
+  when /\.vf$/
+    # change to that dir first
+    currentdir=Dir.getwd
+    dirname=File.dirname(filename)
+    Dir.chdir(dirname)
+    fn=File.basename(filename)
+    vf=VF.new.read_vf(filename)
+    Dir.chdir(currentdir)
+    return vf
+  when /\.pl$/
+    return TFM.new.read_pl(filename)
+  when /\.vpl$/
+    return TFM.new.read_pl(filename)
+  else
+    puts "Unknown format: #{filename}"
+    exit 1
+  end
+end
+
+include TeX
+options=OpenStruct.new
+kpse=Kpathsea.new
+
+ARGV.options { |opts|
+  opts.banner = "Usage: #{File.basename($0)} [options] file file"
+  opts.separator "file can be tfm, pl, vpl or vf files."
+  
+  opts.on("--delta","-d DELTA", Float,
+         "Don't report differences whithin +/- DELTA percent") { |d|
+    options.delta=d
+  }
+  opts.on("--ignore-comments", "-c", "ignore comments") { |i|
+    options.ignore_comments=true
+  }
+  opts.on("--ignore-kern", "-k", "ignore difference in kerning information") { |k|
+    options.ignore_kern=true
+  }
+
+  opts.on("--mapenc", "-m ENC",
+          "assume encoding ENC for destination encoding") {|e|
+    options.mapencoding=e
+  }
+
+  opts.on("--texenc", "-t ENC",
+          "assume encoding ENC for source encoding (TeX side)") {|e|
+    options.texencoding=e
+  }
+    
+  opts.on("--encoding", "-e ENC",
+          "assume encoding ENC for both in and out") {|e|
+    options.encoding=e
+  }
+  opts.on("--skip-characters", "-s", "only look at fontdimen and main data") {|s|
+    options.skip=true
+  }
+  opts.on_tail("--help", "-h", "Show this help") { puts opts; exit 0 }
+  opts.separator  ""
+  opts.parse!
+}
+
+# untested:
+if options.encoding
+  kpse.open_file(options.encoding,"enc") { |f|
+    options.encoding = ENC.new(f)
+  }
+  options.mapencoding=options.encoding
+  options.texencoding=options.encoding
+end
+
+if options.mapencoding.instance_of?(String)
+  kpse.open_file(options.mapencoding,"enc") { |f|
+    options.mapencoding = ENC.new(f)
+  }
+end
+
+if options.texencoding.instance_of?(String)
+  kpse.open_file(options.texencoding,"enc") { |f|
+    options.texencoding = ENC.new(f)
+  }
+end
+
+if ARGV.size != 2
+  puts "#{File.basename($0)}: Need exactly two file arguments."
+  puts "Try `#{File.basename($0)} --help' for more information."
+  exit 0
+end
+
+
+p1 = plopen(ARGV[0])
+p2 = plopen(ARGV[1])
+
+percent = options.delta ? options.delta/50.0 : 0
+
+[:fontfamily,:codingscheme,:designsize].each { |sym|
+  if p1.send(sym) != p2.send(sym)
+    puts "#{sym} differ: #{p1.send(sym)} vs #{p2.send(sym)}"
+  end
+}
+
+
+fd1 = p1.params
+fd2 = p2.params
+str = ""
+if fd1.size != fd2.size
+  str << "Difference in number of parameters (fontdimen)"
+end
+
+paramname=%w( X SLANT SPACE STRETCH SHRINK XHEIGHT QUAD EXTRASPACE )
+if p1.codingscheme=="TeX math symbols"
+  paramname += %w(NUM1 NUM2 NUM3 DENOM1 DENOM2 SUP1 SUP2 SUP3
+                      SUB1 SUB2 SUPDROP)
+elsif p1.codingscheme=="TeX math extension"
+  paramname += %w(DEFAULT_RULE_THICKNESS BIG_OP_SPACING1
+      BIG_OP_SPACING2 BIG_OP_SPACING3 BIG_OP_SPACING4 BIG_OP_SPACING5) 
+end
+
+for i in 1..fd1.size
+  next if fd1[i] == fd2[i]
+  if fd1[i]==nil
+    str << "Difference in #{paramname[i]}: nil vs. #{fd2[i]}" << "\n"
+  elsif
+    fd2[i]==nil
+    str << "Difference in #{paramname[i]}: #{fd1[i]} vs. nil"  << "\n"
+  elsif (fd1[i] - fd2[i] ).abs > fd1[i] * percent
+    str << "Difference in #{paramname[i]}: #{fd1[i]} vs. #{fd2[i]}" << "\n" 
+  end
+end
+
+if str.size > 0
+  puts "--------------------"
+  puts "fondimen difference:"
+  puts str
+  puts "--------------------"
+end
+
+exit if options.skip==true
+str= ""
+0.upto(255) do |i|
+  a=p1.chars[i]
+  b=p2.chars[i]
+  next unless a and b
+  l1=a[:lig_kern] ? p1.lig_kern[a[:lig_kern]] : nil
+  l2=b[:lig_kern] ? p2.lig_kern[b[:lig_kern]] : nil
+
+  next if a==b and l1==l2
+
+  if a==nil
+    str << "#{i}: no character at this slot in font 1" << "\n"
+  elsif b==nil
+    str << "#{i}: no character at this slot in font 2" << "\n"
+  else
+    chr=""
+    [:charwd, :charht, :chardp, :charic].each { |dim|
+      next if a[dim].to_f==b[dim].to_f
+      if a[dim]==nil 
+        chr << "  Difference in #{dim}: nil vs. #{b[dim]}" << "\n"
+      elsif b[dim]==nil
+        chr << "  Difference in #{dim}: #{b[dim]} vs. nil" << "\n"
+      elsif (a[dim]  - b[dim]).abs > a[dim] * percent
+        chr << "  Difference in #{dim}: #{a[dim]} vs. #{b[dim]}" << "\n"
+      end
+    }
+    if  l1 != l2  and options.ignore_kern != true
+      chr << "  Difference in kern information" << "\n"
+      if l1==nil
+        str << "  no lig/kern information for first font \n"
+      elsif l2==nil
+        str << "  no lig/kern information for second font \n"
+      else
+        chr << "  in font1 but not in font 2:" << (l1 - l2).join(" ").to_s << "\n"
+        chr << "  in font2 but not in font 1:" << (l2 - l1).join(" ").to_s << "\n"
+      end
+    end
+      
+#     if a[:ligkern] and b[:ligkern]
+#       if a[:ligkern][:lig] != b[:ligkern][:lig]
+#         chr << "  Difference in lig information"  << "\n"
+#         if a[:ligkern][:lig]  
+#           a[:ligkern][:lig].each { |lig|
+#             chr << "  | " << lig.inspect << "\n"
+#           }
+#         else
+#           chr << "nil"
+#         end
+#         chr << "  vs.\n"
+#         if b[:ligkern][:lig]
+#           b[:ligkern][:lig].each { |lig|
+#             chr << "  | " << lig.inspect << "\n"
+#           }
+#         else
+#           chr << "nil"
+#         end
+#       end
+#         if a[:ligkern][:krn]
+#           (a[:ligkern][:krn] - b[:ligkern][:krn]).each { |lig|
+#             if options.mapencoding
+#               chr <<  "  | [#{options.mapencoding[lig[0]]} #{lig[1]}]\n"
+#             else
+#               chr << "  | " << lig.inspect << "\n"
+#             end
+#           }
+#         else
+#           chr << "nil"
+#         end
+#         chr << "  vs.\n"
+#         if b[:ligkern][:krn]
+#           (b[:ligkern][:krn] - a[:ligkern][:krn]).each { |lig|
+#             if options.mapencoding
+#               chr <<  "  | [#{options.mapencoding[lig[0]]} #{lig[1]}]\n"
+#             else
+#               chr << "  | " << lig.inspect << "\n"
+#             end
+#           }
+#         else
+#           chr << "nil"
+#         end
+    #end
+#    end
+    if  a[:dvi] != b[:dvi] 
+      chr << "  Difference in map\n"
+      chr << showmap(a[:map])
+      chr << "  vs.\n"
+      chr << showmap(b[:map])
+    end
+
+    if chr.length > 0
+      str << "#{i}: "
+      if options.texencoding
+        str << options.texencoding[i]
+      end
+      str << "\n"
+      str << chr
+    end
+  end
+end
+if str.length > 0
+  puts "Character entries:"
+  puts "------------------"
+  puts str
+end
+
+