diff options
Diffstat (limited to 'support/rfil/lib/rfil/font/glyph.rb')
-rw-r--r-- | support/rfil/lib/rfil/font/glyph.rb | 198 |
1 files changed, 198 insertions, 0 deletions
diff --git a/support/rfil/lib/rfil/font/glyph.rb b/support/rfil/lib/rfil/font/glyph.rb new file mode 100644 index 0000000000..91b1d69422 --- /dev/null +++ b/support/rfil/lib/rfil/font/glyph.rb @@ -0,0 +1,198 @@ + +module RFIL + module Font + class Glyph + + # to make Rdoc and Ruby happy: [ruby-talk:147778] + def self.documented_as_accessor(*args) #:nodoc: + end + + # Glyphname + attr_accessor :name + + # Advance with + attr_accessor :wx + + # Standard code slot (0-255 or -1 for unencoded) + attr_accessor :c + + # bounding box (llx, lly, urx, ury). Array of size 4. + # You should use the methods llx, lly, urx, ury to access the + # bounding box. + attr_accessor :b + + # Kern_data (Hash). The key is the glyph name, the entries are + # _[x,y]_ arrays. For ltr and rtl typesetting only the x entry + # should be interesting. This is raw information from the font + # metric file. Does not change when efactor et al. are set in any + # way. + attr_accessor :kern_data + + # Information about ligatures - unknown datatype yet + attr_accessor :lig_data + + # Composite characters. Array [['glyph1',xshift,yshift],...] + attr_accessor :pcc_data + + # Upper right x value of glyph. + documented_as_accessor :urx + + # Upper right y value of glyph. + documented_as_accessor :ury + + # Lower left x value of glyph. + documented_as_accessor :llx + + # Lower left y value of glyph. + documented_as_accessor :lly + + # the name of the uppercase glyph (nil if there is no uppercase glyph) + attr_accessor :uc + + # the name of the lowercase glyph (nil if there is no lowercase glyph) + attr_accessor :lc + + # Optional argument sets the name of the glyph. + def initialize (glyphname=nil) + @name=glyphname + @lig_data={} + @kern_data={} + @wx=0 + @b=[0,0,0,0] + @efactor=1.0 + @slant=0.0 + end + + # Lower left x position of glyph. + def llx # :nodoc: + @b[0] + end + def llx=(value) # :nodoc: + @b[0]=value + end + + # Lower left y position of glyph. + def lly # :nodoc: + @b[1] + end + def lly=(value) # :nodoc: + @b[1]=value + end + # Upper right x position of glyph. + def urx # :nodoc: + @b[2] + end + def urx=(value) # :nodoc: + @b[2]=value + end + + # Upper right y position of glyph. + def ury # :nodoc: + @b[3] + end + def ury=(value) # :nodoc: + @b[3]=value + end + + # Return height of the char used for tfm file. + def charht + ury + end + + # Return width of the char used for tfm file. + def charwd + wx + end + + # Return depth of the char. + def chardp + lly >= 0 ? 0 : -lly + end + + # Return italic correction of the char. + def charic + (urx - wx) > 0 ? (urx - wx) : 0 + end + # Return an array with all kerning information (x-direction only) + # of this glyph. Kerning information is an Array where first + # element is the destchar, the second element is the kerning amount. + def kerns_x + ret=[] + @kern_data.each { |destchar,kern| + ret.push([destchar,kern[0]]) + } + ret + end + + # Return an array with all ligature information (LIG objects) of + # this glyph. + def ligs + ret=[] + @lig_data.each { |destchar,lig| + ret.push(lig) + } + ret + end + + # Return true if this char has ligature or kerning information. If + # glyphindex is supplied, only return true if relevant. This means + # that the second parameter of a kerning information or the second + # parameter and the result of a ligature information must be in + # the glyphindex. glyphindex must respond to <em>include?</em>. + def has_ligkern?(glyphindex=nil) + if glyphindex and not glyphindex.respond_to? :include? + raise ArgumentError, "glyphindex does not respod to include?" + end + return false if (lig_data == {} and kern_data=={}) + # this one is easy, just look at lig_data and kern_data + # more complicated, we have to take glyphindex into account + if glyphindex + return false unless glyphindex.include? self.name + # right kerningpair not in glyphindex? -> false + # right lig not in glyphindex? -> false + # result lig not in glyphindex? -> false + if lig_data + lig_data.each { |otherchar,lig| + if (glyphindex.include?(lig.right) and glyphindex.include?(lig.result)) + return true + end + } + end + if kern_data + kern_data.each { |otherchar,krn| + return true if glyphindex.include?(otherchar) + } + end + return false + else + # no glyphindex + return true + end + raise "never reached" + end # has_ligkern? + + # Return true if glyph is an uppercase char, such as AE. + def is_uppercase? + return @lc != nil + end + + # Return true if glyph is a lowercase char, such as germandbls, + # but not hyphen. + def is_lowercase? + return @uc != nil + end + + # Return the uppercase variant of the glyph. Undefined behaviour if + # glyph cannot be uppercased. + def capitalize + @uc + end + + # Return the lowercase variant of the glyph. Undefined behaviour if + # glyph cannot be lowercased. + def downcase + @lc + end + end + end +end |